Simplification in resolving classes

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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 11328 matching lines @@
                 type_parameter.token_pos(),
                 "type parameter '%s' cannot be parameterized",
                 String::Handle(Z, type_parameter.name()).ToCString());
             return;
           }
           *type = type_parameter.raw();
           return;
         }
       }
       // The referenced class may not have been parsed yet. It would be wrong
-      // to resolve it too early to an imported class of the same name.
+      // to resolve it too early to an imported class of the same name. Only
+      // resolve the class when a finalized type is requested.
       if (finalization > ClassFinalizer::kResolveTypeParameters) {
-        // Resolve classname in the scope of the current library.
-        resolved_type_class = ResolveClassInCurrentLibraryScope(
-            unresolved_class_name);
+        resolved_type_class = library_.LookupClass(unresolved_class_name);
       }
     } else {
-      LibraryPrefix& lib_prefix =
+      // Resolve class name in the scope of the library prefix.
+      const LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(Z, unresolved_class.library_prefix());
-      // Resolve class name in the scope of the library prefix.
-      resolved_type_class =
-          ResolveClassInPrefixScope(lib_prefix, unresolved_class_name);
+      resolved_type_class = lib_prefix.LookupClass(unresolved_class_name);
     }
     // At this point, we can only have a parameterized_type.
     const Type& parameterized_type = Type::Cast(*type);
     if (!resolved_type_class.IsNull()) {
       // Replace unresolved class with resolved type class.
       parameterized_type.set_type_class(resolved_type_class);
     } else if (finalization >= ClassFinalizer::kCanonicalize) {
       ClassFinalizer::FinalizeMalformedType(
           Error::Handle(Z),  // No previous error.
           script_,
@@ skipping 335 matching lines @@
   }
 
   // Nothing found in scope of current class.
   if (node != NULL) {
     *node = NULL;
   }
   return false;
 }
 
 
-RawClass* Parser::ResolveClassInCurrentLibraryScope(const String& name) {
-  HANDLESCOPE(I);
-  const Object& obj = Object::Handle(Z, library_.ResolveName(name));
-  if (obj.IsClass()) {
-    return Class::Cast(obj).raw();
-  }
-  return Class::null();
-}
-
-
 // Resolve an identifier by checking the global scope of the current
 // library. If not found in the current library, then look in the scopes
 // of all libraries that are imported without a library prefix.
 AstNode* Parser::ResolveIdentInCurrentLibraryScope(intptr_t ident_pos,
                                                    const String& ident) {
   TRACE_PARSER("ResolveIdentInCurrentLibraryScope");
   HANDLESCOPE(I);
   const Object& obj = Object::Handle(Z, library_.ResolveName(ident));
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
@@ skipping 21 matching lines @@
       return new(Z) PrimaryNode(ident_pos, Function::ZoneHandle(Z, func.raw()));
     }
   } else {
     ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new(Z) PrimaryNode(ident_pos, ident);
 }
 
 
-RawClass* Parser::ResolveClassInPrefixScope(const LibraryPrefix& prefix,
-                                            const String& name) {
-  HANDLESCOPE(I);
-  const Object& obj = Object::Handle(Z, prefix.LookupObject(name));
-  if (obj.IsClass()) {
-    return Class::Cast(obj).raw();
-  }
-  return Class::null();
-}
-
-
 // Do a lookup for the identifier in the scope of the specified
 // library prefix. This means trying to resolve it locally in all of the
 // libraries present in the library prefix.
 AstNode* Parser::ResolveIdentInPrefixScope(intptr_t ident_pos,
                                            const LibraryPrefix& prefix,
                                            const String& ident) {
   TRACE_PARSER("ResolveIdentInPrefixScope");
   HANDLESCOPE(I);
   if (ident.CharAt(0) == Library::kPrivateIdentifierStart) {
     // Private names are not exported by libraries. The name mangling
@@ skipping 1717 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart