Simplify type resolution in parser.

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 1941 matching lines @@
              "static method '%s' cannot be abstract",
              method->name->ToCString());
   }
   if (method->has_const && !(method->IsConstructor() || method->IsFactory())) {
     ErrorMsg(method->name_pos, "'const' not allowed for methods");
   }
   if (method->IsConstructor() && method->has_static) {
     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()) {
     ErrorMsg(method->name_pos,
              "'abstract' method only allowed in class definition");
   }
 
   if (members->FunctionNameExists(*method->name, method->kind)) {
     ErrorMsg(method->name_pos,
              "field or method '%s' already defined", method->name->ToCString());
@@ skipping 348 matching lines @@
   // Optionally parse a (possibly named) constructor name or factory.
   if (IsIdentifier() &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     if (member.has_factory) {
       // 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.
+      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(),
                                                 factory_name.ident_pos));
     } else {
       member.name_pos = token_index_;
       member.name = CurrentLiteral();
       ConsumeToken();
     }
     // We must be dealing with a constructor or named constructor.
@@ skipping 340 matching lines @@
                                                signature_function,
                                                script_);
     // Record the function signature class in the current library.
     library_.AddClass(signature_class);
   } else {
     // Forget the just created signature function and use the existing one.
     signature_function = signature_class.signature_function();
   }
   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.
     function_type_alias = Class::NewSignatureClass(*alias_name,
                                                    signature_function,
                                                    script_);
     library_.AddClass(function_type_alias);
   } else {
     const char* format = function_type_alias.is_interface() ?
         "'%s' is already defined" : "'%s' is already defined as class";
@@ skipping 1822 matching lines @@
   String& name = String::Handle(class_name.raw());
   if (class_name.CharAt(0) == Scanner::kPrivateIdentifierStart) {
     // Private identifiers are mangled on a per script basis.
     name = String::Concat(name, String::Handle(core_lib.private_key()));
     name = String::NewSymbol(name);
   }
   return core_lib.LookupClass(name);
 }
 
 
-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,
                                 ArgumentListNode* arguments) {
   const String& cls_name =
       String::Handle(String::NewSymbol(class_name));
   const Class& cls = Class::Handle(LookupImplClass(cls_name));
   ASSERT(!cls.IsNull());
   const String& func_name =
       String::ZoneHandle(String::NewSymbol(function_name));
@@ skipping 1595 matching lines @@
 // 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(const Class& scope_class,
                                   TypeResolution type_resolution,
                                   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,
                                             type->token_index()));
         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_parameter.token_index(),
                      "type parameter '%s' cannot be parameterized",
                      String::Handle(type_parameter.Name()).ToCString());
           }
           *type = type_parameter.raw();
           return;
         }
       }
     } else {
       LibraryPrefix& lib_prefix =
           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 =
       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(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.
-  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;
   }
   // A found name is treated as accessed and possibly marked as captured.
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(ident, kTestOnly);
 }
 
 
@@ skipping 390 matching lines @@
   String& map_name = String::Handle(library_.LookupImportMap(ident));
   if (!map_name.IsNull()) {
     return map_name.raw();
   }
   ErrorMsg(ident_pos, "import variable '%s' has not been defined",
            ident.ToCString());
   return String::null();
 }
 
 
-// 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");
   }
   QualIdent type_name;
   if (type_resolution == kIgnore) {
     SkipQualIdent();
   } else {
     ParseQualIdent(&type_name);
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (!is_top_level_ &&
         (type_name.lib_prefix == NULL) &&
         ResolveIdentInLocalScope(type_name.ident_pos, *type_name.ident, NULL)) {
       ErrorMsg(type_name.ident_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) {
+  // 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();
     }
     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();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor,
     const AbstractTypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
     const Class& constructor_class = Class::Handle(constructor.owner());
@@ skipping 1083 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart