Simplify type resolution in parser.

runtime/vm/parser.cc

Index: runtime/vm/parser.cc
===================================================================
--- runtime/vm/parser.cc	(revision 4232)
+++ runtime/vm/parser.cc	(working copy)
@@ -1959,7 +1959,7 @@
     ErrorMsg(method->name_pos, "constructor cannot be 'static'");
   }
   if (method->IsConstructor() && method->has_const) {
-    Class& cls = Class::ZoneHandle(LookupClass(members->class_name()));
+    Class& cls = Class::ZoneHandle(library_.LookupClass(members->class_name()));
     cls.set_is_const();
   }
   if (method->has_abstract && members->is_interface()) {
@@ -2328,8 +2328,14 @@
       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.
+      LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
+      if (factory_name.lib_prefix != NULL) {
+        lib_prefix = factory_name.lib_prefix->raw();
+      }
       const Object& result_type_class = Object::Handle(
-          LookupTypeClass(factory_name, kCanResolve));
+          UnresolvedClass::New(lib_prefix,
+                               *factory_name.ident,
+                               factory_name.ident_pos));
       // The type arguments of the result type are set during finalization.
       member.type = &Type::ZoneHandle(Type::New(result_type_class,
                                                 TypeArguments::Handle(),
@@ -2690,7 +2696,8 @@
   }
   ASSERT(signature_function.signature_class() == signature_class.raw());
   // Lookup the class by its alias name and report an error if it exists.
-  Class& function_type_alias = Class::ZoneHandle(LookupClass(*alias_name));
+  Class& function_type_alias =
+      Class::ZoneHandle(library_.LookupClass(*alias_name));
   if (function_type_alias.IsNull()) {
     // Create the function type alias, but share the signature function of the
     // canonical signature class.
@@ -4533,11 +4540,6 @@
 }
 
 
-RawClass* Parser::LookupClass(const String& class_name) {
-  return library_.LookupClass(class_name);
-}
-
-
 // Calling VM-internal helpers, uses implementation core library.
 AstNode* Parser::MakeStaticCall(const char* class_name,
                                 const char* function_name,
@@ -6153,19 +6155,18 @@
                                   AbstractType* type) {
   ASSERT((type_resolution == kCanResolve) || (type_resolution == kMustResolve));
   ASSERT(type != NULL);
+  if (type->IsResolved()) {
+    return;
+  }
   // 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 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();
+      if (!scope_class.IsNull()) {
         // 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,
@@ -6187,21 +6188,25 @@
           LibraryPrefix::Handle(unresolved_class.library_prefix());
       lib = lib_prefix.library();
     }
-    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->token_index(), "type '%s' is not loaded",
-                 String::Handle(type->Name()).ToCString());
-      }
+    Class& resolved_type_class = Class::Handle();
+    if (lib.IsNull()) {
+      // Global lookup in current library.
+      resolved_type_class = library_.LookupClass(unresolved_class_name);
+    } else {
+      // Local lookup in imported library.
+      resolved_type_class = 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->token_index(), "type '%s' is not loaded",
+               String::Handle(type->Name()).ToCString());
+    }
   }
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
@@ -6219,39 +6224,6 @@
 }
 
 
-// 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.
-  LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
-  if (type_name.lib_prefix != NULL) {
-    lib_prefix = type_name.lib_prefix->raw();
-  }
-  return UnresolvedClass::New(lib_prefix,
-                              *type_name.ident,
-                              type_name.ident_pos);
-}
-
-
 LocalVariable* Parser::LookupLocalScope(const String& ident) {
   if (current_block_ == NULL) {
     return NULL;
@@ -6662,10 +6634,8 @@
 }
 
 
-// Parses type = [ident "."] ident ["<" type { "," type } ">"].
-// Returns the class object if the type can be resolved. Otherwise, either give
-// an error if type resolution was required, or return the unresolved name as a
-// string object.
+// Parses type = [ident "."] ident ["<" type { "," type } ">"] and resolve it
+// according to the given type_resolution.
 RawAbstractType* Parser::ParseType(TypeResolution type_resolution) {
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
@@ -6683,11 +6653,9 @@
                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) {
+  // Leave type_class as null if type_resolution equals kIgnore.
+  if (type_resolution != kIgnore) {
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     if (type_name.lib_prefix != NULL) {
       lib_prefix = type_name.lib_prefix->raw();
@@ -6695,45 +6663,20 @@
     type_class = UnresolvedClass::New(lib_prefix,
                                       *type_name.ident,
                                       type_name.ident_pos);
-  } else {
-    // TODO(regis): Use ResolveTypeFromClass().
-    ASSERT((type_resolution == kCanResolve) ||
-           (type_resolution == kMustResolve));
-    scope_class = TypeParametersScopeClass();
-    if (!scope_class.IsNull()) {
-      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,
-                                            type_name.ident_pos));
-        if (!type_parameter.IsNull()) {
-          if (CurrentToken() == Token::kLT) {
-            // A type parameter cannot be parameterized.
-            ErrorMsg(type_parameter.token_index(),
-                     "type parameter '%s' cannot be parameterized",
-                     String::Handle(type_parameter.Name()).ToCString());
-          }
-          if (type_resolution == kMustResolve) {
-            type_parameter ^=
-                ClassFinalizer::FinalizeType(current_class(), type_parameter);
-          }
-          return type_parameter.raw();
-        }
-      }
-    }
-    // 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(
+  AbstractType& type = AbstractType::Handle(
       Type::New(type_class, type_arguments, type_name.ident_pos));
-  if (type_resolution == kMustResolve) {
-    ASSERT(type_class.IsClass());  // Must be resolved.
-    type ^= ClassFinalizer::FinalizeType(current_class(), type);
+  if ((type_resolution == kCanResolve) || (type_resolution == kMustResolve)) {
+    const Class& scope_class = Class::Handle(TypeParametersScopeClass());
+    ResolveTypeFromClass(scope_class, type_resolution, &type);
+    if (type_resolution == kMustResolve) {
+      type ^= ClassFinalizer::FinalizeType(current_class(), type);
+    }
   }
   return type.raw();
 }