Store resolved library prefix in unresolved class object in order not to repeat

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 252 matching lines @@
 }
 
 
 // A QualIdent is an optionally qualified identifier.
 struct QualIdent {
   QualIdent() {
     Clear();
   }
   void Clear() {
     lib_prefix = NULL;
-    qualifier = NULL;
     ident_pos = 0;
     ident = NULL;
   }
   LibraryPrefix* lib_prefix;
-  String* qualifier;
   intptr_t ident_pos;
   String* ident;
 };
 
 
 struct ParamDesc {
   ParamDesc()
       : type(NULL),
         name_pos(0),
         name(NULL),
@@ skipping 1610 matching lines @@
       SetAllowFunctionLiterals(false);
       SkipExpr();
       SetAllowFunctionLiterals(true);
     }
   } while (CurrentToken() == Token::kCOMMA);
 }
 
 
 void Parser::ParseQualIdent(QualIdent* qual_ident) {
   ASSERT(IsIdentifier());
-  if (!is_top_level_) {
-    qual_ident->ident_pos = token_index_;
-    qual_ident->ident = CurrentLiteral();
-    qual_ident->lib_prefix = NULL;
-    qual_ident->qualifier = NULL;
-    ConsumeToken();
-    if (CurrentToken() == Token::kPERIOD) {
-      if (!ResolveIdentInLocalScope(qual_ident->ident_pos,
-                                    *(qual_ident->ident),
-                                    NULL)) {
-        LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
-        lib_prefix = current_class().LookupLibraryPrefix(*(qual_ident->ident));
-        if (!lib_prefix.IsNull()) {
-          // We have a library prefix qualified identifier, unless the prefix is
-          // shadowed by a type parameter in scope.
-          const Class& scope_class = Class::Handle(TypeParametersScopeClass());
-          if (scope_class.IsNull() ||
-              (scope_class.LookupTypeParameter(*(qual_ident->ident)) ==
-               TypeParameter::null())) {
-            ConsumeToken();  // Consume the kPERIOD token.
-            qual_ident->lib_prefix = &lib_prefix;
-            qual_ident->qualifier = qual_ident->ident;
-            qual_ident->ident_pos = token_index_;
-            qual_ident->ident =
-                ExpectIdentifier("identifier expected after '.'");
-          }
+  qual_ident->ident_pos = token_index_;
+  qual_ident->ident = CurrentLiteral();
+  qual_ident->lib_prefix = NULL;
+  ConsumeToken();
+  if (CurrentToken() == Token::kPERIOD) {
+    // An identifier cannot be resolved in a local scope when top level parsing.
+    if (is_top_level_ ||
+        !ResolveIdentInLocalScope(qual_ident->ident_pos,
+                                  *(qual_ident->ident),
+                                  NULL)) {
+      LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
+      lib_prefix = current_class().LookupLibraryPrefix(*(qual_ident->ident));
+      if (!lib_prefix.IsNull()) {
+        // We have a library prefix qualified identifier, unless the prefix is
+        // shadowed by a type parameter in scope.
+        const Class& scope_class = Class::Handle(TypeParametersScopeClass());
+        if (scope_class.IsNull() ||
+            (scope_class.LookupTypeParameter(*(qual_ident->ident)) ==
+             TypeParameter::null())) {
+          ConsumeToken();  // Consume the kPERIOD token.
+          qual_ident->lib_prefix = &lib_prefix;
+          qual_ident->ident_pos = token_index_;
+          qual_ident->ident =
+              ExpectIdentifier("identifier expected after '.'");
         }
       }
     }
-  } else {
-    qual_ident->ident_pos = token_index_;
-    qual_ident->ident = CurrentLiteral();
-    qual_ident->lib_prefix = NULL;
-    qual_ident->qualifier = NULL;
-    ConsumeToken();
-    if (CurrentToken() == Token::kPERIOD) {
-      ConsumeToken();  // Consume the kPERIOD token.
-      qual_ident->qualifier = qual_ident->ident;
-      qual_ident->ident_pos = token_index_;
-      qual_ident->ident = ExpectIdentifier("identifier expected after '.'");
-    }
   }
 }
 
 
 void Parser::ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method) {
   ASSERT(CurrentToken() == Token::kLPAREN);
   intptr_t method_pos = this->token_index_;
   ASSERT(method->type != NULL);
   ASSERT(method->name_pos > 0);
   ASSERT(current_member_ == method);
@@ skipping 371 matching lines @@
         // The declared type of fields is never ignored, even in unchecked mode,
         // because getters and setters could be closurized at some time (not
         // supported yet).
         member.type = &AbstractType::ZoneHandle(ParseType(kCanResolve));
       }
     }
   }
   // Optionally parse a (possibly named) constructor name or factory.
   if (IsIdentifier() &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
-    member.name = CurrentLiteral();
-    member.name_pos = this->token_index_;
-    // TODO(regis): Simplify the following code by calling ParseQualIdent().
-    ConsumeToken();
     if (member.has_factory) {
-      String& qualifier = String::Handle();
-      if (CurrentToken() == Token::kPERIOD) {
-        LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
-        lib_prefix = current_class().LookupLibraryPrefix(*member.name);
-        if (!lib_prefix.IsNull()) {
-          // We have a library prefix qualified identifier.
-          ConsumeToken();  // Consume the kPERIOD token.
-          qualifier ^= member.name->raw();
-          member.name = ExpectIdentifier("identifier expected");
-        }
-      }
-      // TODO(regis): Stop postponing resolution of the factory result type
-      // until class finalization. Use ResolveTypeFromClass instead.
-      // Factory result type is the same as the type name of the factory.
-      const UnresolvedClass& unresolved_factory_class =
-          UnresolvedClass::Handle(UnresolvedClass::New(member.name_pos,
-                                                       qualifier,
-                                                       *member.name));
+      // The factory name may be qualified.
+      QualIdent factory_name;
+      ParseQualIdent(&factory_name);
+      member.name_pos = factory_name.ident_pos;
+      member.name = factory_name.ident;  // Unqualified identifier.
+      // The class of the factory result type is specified by the factory name.
+      const Object& result_type_class = Object::Handle(
+          LookupTypeClass(factory_name, kCanResolve));
       // The type arguments of the result type are set during finalization.
       member.type = &Type::ZoneHandle(
-          Type::NewParameterizedType(unresolved_factory_class,
-                                     TypeArguments::Handle()));
+          Type::New(result_type_class, TypeArguments::Handle()));
+    } else {
+      member.name_pos = token_index_;
+      member.name = CurrentLiteral();
+      ConsumeToken();
     }
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     String& ctor_suffix = String::ZoneHandle(String::NewSymbol("."));
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       const String* name = ExpectIdentifier("identifier expected");
       ctor_suffix = String::Concat(ctor_suffix, *name);
     }
@@ skipping 261 matching lines @@
   }
   SetPosition(saved_pos);
   return is_alias_name;
 }
 
 
 void Parser::ParseFunctionTypeAlias(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
+  // Allocate an interface to hold the type parameters and their 'extends'
+  // constraints. Make it the owner of the function type descriptor.
+  const Class& alias_owner = Class::Handle(
+      Class::New(String::Handle(String::NewSymbol(":alias_owner")),
+                 Script::Handle()));
+  alias_owner.set_is_interface();
+  alias_owner.set_library(library_);
+  set_current_class(alias_owner);
+
+  // Parse the result type of the function type.
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   const intptr_t result_type_pos = token_index_;
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
     // Type annotations in typedef are never ignored, even in unchecked mode.
     // Wait until we have an owner class before resolving the result type.
     result_type = ParseType(kDoNotResolve);
   }
 
   const intptr_t alias_name_pos = token_index_;
   const String* alias_name =
       ExpectTypeIdentifier("function alias name expected");
 
-  // Allocate an interface to hold the type parameters and their 'extends'
-  // constraints. Make it the owner of the function type descriptor.
-  const Class& alias_owner = Class::Handle(
-      Class::New(String::Handle(String::NewSymbol(":alias_owner")),
-                 Script::Handle()));
-  alias_owner.set_is_interface();
-  set_current_class(alias_owner);
+  // Parse the type parameters of the function type.
   ParseTypeParameters(alias_owner);
-  if (CurrentToken() != Token::kLPAREN) {
-    ErrorMsg("formal parameter list expected");
-  }
-
   // At this point, the type parameters have been parsed, so we can resolve the
   // result type.
   if (!result_type.IsNull()) {
     ResolveTypeFromClass(result_type_pos,
                          alias_owner,
                          kCanResolve,
                          &result_type);
   }
+  // Parse the formal parameters of the function type.
+  if (CurrentToken() != Token::kLPAREN) {
+    ErrorMsg("formal parameter list expected");
+  }
   ParamList func_params;
   const bool no_explicit_default_values = false;
   ParseFormalParameterList(no_explicit_default_values, &func_params);
   // The field 'is_static' has no meaning for signature functions.
   Function& signature_function = Function::Handle(
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     alias_name_pos));
@@ skipping 83 matching lines @@
   }
 
   if (CurrentToken() == Token::kDEFAULT) {
     ConsumeToken();
     if (CurrentToken() != Token::kIDENT) {
       ErrorMsg("class name expected");
     }
     const intptr_t factory_pos = token_index_;
     QualIdent factory_name;
     ParseQualIdent(&factory_name);
-    String& qualifier = String::Handle();
-    if (factory_name.qualifier != NULL) {
-      qualifier ^= factory_name.qualifier->raw();
+    LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
+    if (factory_name.lib_prefix != NULL) {
+      lib_prefix = factory_name.lib_prefix->raw();
     }
     const UnresolvedClass& unresolved_factory_class = UnresolvedClass::Handle(
-        UnresolvedClass::New(factory_pos, qualifier, *factory_name.ident));
+        UnresolvedClass::New(factory_pos, lib_prefix, *factory_name.ident));
     const Class& factory_class = Class::Handle(
         Class::New(String::Handle(String::NewSymbol(":factory_signature")),
                    script_));
     factory_class.set_library(library_);
     factory_class.set_is_finalized();
     ParseTypeParameters(factory_class);
     unresolved_factory_class.set_factory_signature_class(factory_class);
     interface.set_factory_class(unresolved_factory_class);
     // If a type parameter list is included in the default factory clause (it
     // can be omitted), verify that it matches the list of type parameters of
@@ skipping 962 matching lines @@
   LocalVariable* function_variable = NULL;
   Type& function_type = Type::ZoneHandle();
   if (variable_name != NULL) {
     // Since the function type depends on the signature of the closure function,
     // it cannot be determined before the formal parameter list of the closure
     // function is parsed. Therefore, we set the function type to a new
     // parameterized type to be patched after the actual type is known.
     // We temporarily use the class of the Function interface.
     const Class& unknown_signature_class = Class::Handle(
         Type::Handle(Type::FunctionInterface()).type_class());
-    function_type = Type::New(unknown_signature_class,
-                              TypeArguments::Handle());
+    function_type = Type::New(unknown_signature_class, TypeArguments::Handle());
     function_type.set_is_finalized();  // No real finalization needed.
 
     // Add the function variable to the scope before parsing the function in
     // order to allow self reference from inside the function.
     function_variable = new LocalVariable(ident_pos,
                                           *variable_name,
                                           function_type);
     function_variable->set_is_final();
     ASSERT(current_block_ != NULL);
     ASSERT(current_block_->scope != NULL);
@@ skipping 2346 matching lines @@
         postfix_expr->MakeIncrOpNode(postfix_expr_pos, incr_op, false);
     if (incr_op_node == NULL) {
       Unimplemented("incr op not implemented");
     }
     postfix_expr = incr_op_node;
   }
   return postfix_expr;
 }
 
 
-// Resolve the given type and its type arguments from the given class according
-// to the given type_resolution.
+// Resolve the given type and its type arguments from the given scope class
+// according to the given type_resolution.
+// If the given scope class is null, use the current library, but do not try to
+// resolve type parameters.
 // Not all involved type classes may get resolved yet, but at least the type
 // parameters of the given class will get resolved, thereby relieving the class
 // finalizer from resolving type parameters out of context.
 void Parser::ResolveTypeFromClass(intptr_t type_pos,
-                                  const Class& cls,
+                                  const Class& scope_class,
                                   TypeResolution type_resolution,
                                   AbstractType* type) {
-  // TODO(regis): Implement kMustResolve functionality and consolidate with
-  // other resolution code. For now, only support kCanResolve functionality.
-  ASSERT(type_resolution == kCanResolve);
+  ASSERT((type_resolution == kCanResolve) || (type_resolution == kMustResolve));
   ASSERT(type != NULL);
   // Resolve class.
   if (!type->HasResolvedTypeClass()) {
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(type->unresolved_class());
     const String& unresolved_class_name =
         String::Handle(unresolved_class.ident());
-    // First check if the type is a type parameter of the given class.
-    const TypeParameter& type_parameter = TypeParameter::Handle(
-        cls.LookupTypeParameter(unresolved_class_name));
-    if (!type_parameter.IsNull()) {
-      // A type parameter cannot be parameterized, so report an error if type
-      // arguments have previously been parsed.
-      if (!AbstractTypeArguments::Handle(type->arguments()).IsNull()) {
-        ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
-                 type_parameter.ToCString());
+    // First resolve library prefix if any.
+    Library& lib = Library::Handle();
+    if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
+      if (scope_class.IsNull()) {
+        lib = library_.raw();
+      } else {
+        lib = scope_class.library();
+        // First check if the type is a type parameter of the given scope class.
+        const TypeParameter& type_parameter = TypeParameter::Handle(
+            scope_class.LookupTypeParameter(unresolved_class_name));
+        if (!type_parameter.IsNull()) {
+          // A type parameter cannot be parameterized, so report an error if
+          // type arguments have previously been parsed.
+          if (!AbstractTypeArguments::Handle(type->arguments()).IsNull()) {
+            ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
+                     String::Handle(type_parameter.Name()).ToCString());
+          }
+          *type = type_parameter.raw();
+          return;
+        }
       }
-      *type = type_parameter.raw();
-      return;
+    } else {
+      LibraryPrefix& lib_prefix =
+          LibraryPrefix::Handle(unresolved_class.library_prefix());
+      lib = lib_prefix.library();
     }
-    const Class& resolved_type_class =
-        Class::Handle(LookupClass(unresolved_class_name));
-    if (!resolved_type_class.IsNull()) {
-      Object& type_class = Object::Handle(resolved_type_class.raw());
-      ASSERT(type->IsType());
-      // Replace unresolved class with resolved type class.
-      Type& parameterized_type = Type::Handle();
-      parameterized_type ^= type->raw();
-      parameterized_type.set_type_class(type_class);
+    if (!lib.IsNull()) {
+      const Class& resolved_type_class = Class::Handle(
+          lib.LookupLocalClass(unresolved_class_name));
+      if (!resolved_type_class.IsNull()) {
+        Object& type_class = Object::Handle(resolved_type_class.raw());
+        ASSERT(type->IsType());
+        // Replace unresolved class with resolved type class.
+        Type& parameterized_type = Type::Handle();
+        parameterized_type ^= type->raw();
+        parameterized_type.set_type_class(type_class);
+      } else if (type_resolution == kMustResolve) {
+        ErrorMsg(type_pos, "type '%s' is not loaded",
+                 String::Handle(type->Name()).ToCString());
+      }
     }
   }
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(type->arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
       AbstractType& type_argument = AbstractType::Handle(arguments.TypeAt(i));
-      ResolveTypeFromClass(type_pos, cls, type_resolution, &type_argument);
+      ResolveTypeFromClass(type_pos,
+                           scope_class,
+                           type_resolution,
+                           &type_argument);
       arguments.SetTypeAt(i, type_argument);
     }
   }
 }
 
 
 // Return class for type name. If the name cannot be resolved (yet), give an
 // error (if type_resolution == kMustResolve) or return the unresolved name.
 RawObject* Parser::LookupTypeClass(const QualIdent& type_name,
                                    TypeResolution type_resolution) {
   ASSERT(type_name.ident != NULL);
   ASSERT((type_resolution == kCanResolve) || (type_resolution == kMustResolve));
   Class& type_class = Class::Handle();
   if (type_name.lib_prefix != NULL) {
     Library& lib = Library::Handle(type_name.lib_prefix->library());
     type_class = lib.LookupLocalClass(*type_name.ident);
   } else {
     type_class = LookupClass(*type_name.ident);
   }
   if (!type_class.IsNull()) {
     return type_class.raw();
   }
   // Type name could not be resolved (yet).
   if (type_resolution == kMustResolve) {
     ErrorMsg(type_name.ident_pos, "type '%s' is not loaded",
              type_name.ident->ToCString());
     return Object::null_class();
   }
-  // We have an unresolved name, create an UnresolvedClass object
-  // for this case.
-  String& qualifier = String::Handle();
-  if (type_name.qualifier != NULL) {
-    qualifier ^= type_name.qualifier->raw();
+  // We have an unresolved name, create an UnresolvedClass object for this case.
+  LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
+  if (type_name.lib_prefix != NULL) {
+    lib_prefix = type_name.lib_prefix->raw();
   }
-  return UnresolvedClass::New(type_name.ident_pos, qualifier, *type_name.ident);
+  return UnresolvedClass::New(type_name.ident_pos,
+                              lib_prefix,
+                              *type_name.ident);
 }
 
 
 LocalVariable* Parser::LookupLocalScope(const String& ident) {
   if (current_block_ == NULL) {
     return NULL;
   }
   // A found name is treated as accessed and possibly marked as captured.
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(ident, kTestOnly);
@@ skipping 299 matching lines @@
   }
   if (!obj.IsNull()) {
     ASSERT(obj.IsFunction());
     func ^= obj.raw();
     ASSERT(func.is_static());
     ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
     return new StaticGetterNode(qual_ident.ident_pos,
                                 Class::ZoneHandle(func.owner()),
                                 *qual_ident.ident);
   }
-  if (qual_ident.qualifier != NULL) {
+  if (qual_ident.lib_prefix != NULL) {
     // This is an unresolved prefixed primary identifier, need to report
     // an error.
     ErrorMsg(qual_ident.ident_pos, "identifier '%s.%s' cannot be resolved",
-             (qual_ident.qualifier)->ToCString(),
-             (qual_ident.ident)->ToCString());
+             String::Handle(qual_ident.lib_prefix->name()).ToCString(),
+             qual_ident.ident->ToCString());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new PrimaryNode(qual_ident.ident_pos, *qual_ident.ident);
 }
 
 
 // Resolve identifier, issue an error message if the name refers to
 // a method or a class/interface.
 // If the name cannot be resolved, turn it into an instance field access
 // if we're compiling an instance method, or issue an error message
 // if we're compiling a static method.
 AstNode* Parser::ResolveVarOrField(intptr_t ident_pos, const String& ident) {
   TRACE_PARSER("ResolveVarOrField");
   // First try to find the variable in the local scope (block scope or
   // class scope).
   AstNode* var_or_field = NULL;
   ResolveIdentInLocalScope(ident_pos, ident, &var_or_field);
   if (var_or_field == NULL) {
     // Not found in the local scope, so try finding the variable in the
     // library scope (current library and all libraries imported by it).
     QualIdent qual_ident;
-    qual_ident.qualifier = NULL;
     qual_ident.lib_prefix = NULL;
     qual_ident.ident_pos = ident_pos;
     qual_ident.ident = &(String::ZoneHandle(ident.raw()));
     var_or_field = ResolveIdentInLibraryScope(library_,
                                               qual_ident,
                                               kResolveIncludingImports);
   }
   if (var_or_field->IsPrimaryNode()) {
     PrimaryNode* primary = var_or_field->AsPrimaryNode();
     if (primary->primary().IsString()) {
@@ skipping 28 matching lines @@
 RawAbstractType* Parser::ParseType(TypeResolution type_resolution) {
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
   const intptr_t type_pos = token_index_;
   if (type_resolution == kIgnore) {
     SkipQualIdent();
   } else {
     ParseQualIdent(&type_name);
-    if (!is_top_level_ && (type_name.qualifier == NULL) &&
+    // An identifier cannot be resolved in a local scope when top level parsing.
+    if (!is_top_level_ &&
+        (type_name.lib_prefix == NULL) &&
         ResolveIdentInLocalScope(type_pos, *type_name.ident, NULL)) {
       ErrorMsg(type_pos, "using '%s' in this context is invalid",
                type_name.ident->ToCString());
     }
   }
   Class& scope_class = Class::Handle();
   Object& type_class = Object::Handle();
   if (type_resolution == kIgnore) {
     // Leave type_class as null.
   } else if (type_resolution == kDoNotResolve) {
-    String& qualifier = String::Handle();
-    if (type_name.qualifier != NULL) {
-      qualifier ^= type_name.qualifier->raw();
+    LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
+    if (type_name.lib_prefix != NULL) {
+      lib_prefix = type_name.lib_prefix->raw();
     }
-    type_class = UnresolvedClass::New(type_pos, qualifier, *type_name.ident);
+    type_class = UnresolvedClass::New(type_pos, lib_prefix, *type_name.ident);
   } else {
+    // TODO(regis): Use ResolveTypeFromClass().
     ASSERT((type_resolution == kCanResolve) ||
            (type_resolution == kMustResolve));
     scope_class = TypeParametersScopeClass();
     if (!scope_class.IsNull()) {
-      if (type_name.qualifier != NULL) {
-        // Check if qualifier is a type parameter in scope, unless it was
-        // already checked by ParseQualIdent when !is_top_level_.
-        if (is_top_level_) {
-          const TypeParameter& type_parameter = TypeParameter::Handle(
-              scope_class.LookupTypeParameter(*type_name.qualifier));
-          if (!type_parameter.IsNull()) {
-            ErrorMsg(type_pos,
-                     "type Parameter '%s' cannot be used as qualifier",
-                     type_name.qualifier->ToCString());
-          }
-        }
-      } else {
+      if (type_name.lib_prefix == NULL) {
         // Check if ident is a type parameter in scope.
         TypeParameter& type_parameter = TypeParameter::Handle(
             scope_class.LookupTypeParameter(*type_name.ident));
         if (!type_parameter.IsNull()) {
           if (CurrentToken() == Token::kLT) {
             // A type parameter cannot be parameterized.
             ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
                      String::Handle(type_parameter.Name()).ToCString());
           }
           if (type_resolution == kMustResolve) {
@@ skipping 11 matching lines @@
       }
     }
     // Try to resolve the type class.
     type_class = LookupTypeClass(type_name, type_resolution);
   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(ParseTypeArguments(type_resolution));
   if (type_resolution == kIgnore) {
     return Type::DynamicType();
   }
-  Type& type = Type::Handle(
-      Type::NewParameterizedType(type_class, type_arguments));
+  Type& type = Type::Handle(Type::New(type_class, type_arguments));
   if (type_resolution == kMustResolve) {
     ASSERT(type_class.IsClass());  // Must be resolved.
     Error& error = Error::Handle();
     type ^= ClassFinalizer::FinalizeAndCanonicalizeType(scope_class,
                                                         type,
                                                         &error);
     if (!error.IsNull()) {
       ErrorMsg(error.ToErrorCString());
     }
   }
@@ skipping 526 matching lines @@
         if (i < num_type_arguments) {
           type_argument = type_arguments.TypeAt(i);
         } else {
           type_argument = Type::DynamicType();
         }
         temp_type_arguments.SetTypeAt(i, type_argument);
       }
     }
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& temp_type = Type::Handle(
-        Type::NewParameterizedType(constructor_class, temp_type_arguments));
+        Type::New(constructor_class, temp_type_arguments));
     Error& error = Error::Handle();
     const Class& scope_class = Class::Handle(TypeParametersScopeClass());
     temp_type ^= ClassFinalizer::FinalizeAndCanonicalizeType(scope_class,
                                                              temp_type,
                                                              &error);
     if (!error.IsNull()) {
       ErrorMsg(error.ToErrorCString());
     }
     // The type argument vector may have been expanded with the type arguments
     // of the super type when finalizing the temporary type.
@@ skipping 96 matching lines @@
   AstNode* primary = NULL;
   if (IsFunctionLiteral()) {
     // The name of a literal function is visible from inside the function, but
     // must not collide with names in the scope declaring the literal.
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
   } else if (IsIdentifier()) {
     QualIdent qual_ident;
     ParseQualIdent(&qual_ident);
-    if (qual_ident.qualifier == NULL) {
+    if (qual_ident.lib_prefix == NULL) {
       if (!ResolveIdentInLocalScope(qual_ident.ident_pos,
                                     *qual_ident.ident,
                                     &primary)) {
         // This is a non-local unqualified identifier so resolve the identifier
         // locally in the main app library and all libraries imported by it.
         primary = ResolveIdentInLibraryScope(library_,
                                              qual_ident,
                                              kResolveIncludingImports);
       }
     } else {
@@ skipping 364 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart