Introduce cache of resolved names in library

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/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 9098 matching lines @@
   }
 
   // Nothing found in scope of current class.
   if (node != NULL) {
     *node = NULL;
   }
   return false;  // Not an unqualified identifier.
 }
 
 
-static RawObject* LookupNameInLibrary(Isolate* isolate,
-                                      const Library& lib,
-                                      const String& name) {
-  Object& obj = Object::Handle(isolate);
-  obj = lib.LookupLocalObject(name);
-  if (!obj.IsNull()) {
-    return obj.raw();
-  }
-  String& accessor_name = String::Handle(isolate, Field::GetterName(name));
-  obj = lib.LookupLocalObject(accessor_name);
-  if (!obj.IsNull()) {
-    return obj.raw();
-  }
-  accessor_name = Field::SetterName(name);
-  obj = lib.LookupLocalObject(accessor_name);
-  return obj.raw();
-}
-
-
-// Resolve a name 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.
-RawObject* Parser::ResolveNameInCurrentLibraryScope(const String& name) {
-  TRACE_PARSER("ResolveNameInCurrentLibraryScope");
-  HANDLESCOPE(isolate());
-  Object& obj = Object::Handle(isolate(),
-                               LookupNameInLibrary(isolate(), library_, name));
-  if (!obj.IsNull()) {
-    return obj.raw();
-  }
-  return library_.LookupImportedObject(name);
-}
-
-
 RawClass* Parser::ResolveClassInCurrentLibraryScope(const String& name) {
-  const Object& obj =
-      Object::Handle(ResolveNameInCurrentLibraryScope(name));
+  HANDLESCOPE(isolate());
+  const Object& obj = Object::Handle(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");
-  const Object& obj =
-    Object::Handle(ResolveNameInCurrentLibraryScope(ident));
+  HANDLESCOPE(isolate());
+  const Object& obj = Object::Handle(library_.ResolveName(ident));
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
     return new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
   } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
     return GenerateStaticFieldLookup(field, ident_pos);
   } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
       return new StaticGetterNode(ident_pos,
                                   /* receiver */ NULL,
                                   /* is_super_getter */ false,
                                   Class::ZoneHandle(func.Owner()),
                                   ident);
 
     } else {
       return new PrimaryNode(ident_pos, Function::ZoneHandle(func.raw()));
     }
   } else {
     ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new PrimaryNode(ident_pos, ident);
 }
 
 
-RawObject* Parser::ResolveNameInPrefixScope(const LibraryPrefix& prefix,
-                                            const String& name) {
-  HANDLESCOPE(isolate());
-  return prefix.LookupObject(name);
-}
-
-
 RawClass* Parser::ResolveClassInPrefixScope(const LibraryPrefix& prefix,
                                             const String& name) {
-  const Object& obj =
-      Object::Handle(ResolveNameInPrefixScope(prefix, name));
+  HANDLESCOPE(isolate());
+  const Object& obj = Object::Handle(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");
-  Object& obj = Object::Handle(ResolveNameInPrefixScope(prefix, ident));
+  HANDLESCOPE(isolate());
+  Object& obj = Object::Handle(prefix.LookupObject(ident));
   if (obj.IsNull()) {
     // Unresolved prefixed primary identifier.
     String& qualified_name = String::ZoneHandle(prefix.name());
     qualified_name = String::Concat(qualified_name, Symbols::Dot());
     qualified_name = String::Concat(qualified_name, ident);
     qualified_name = Symbols::New(qualified_name);
     return new PrimaryNode(ident_pos, qualified_name);
   } else if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
     return new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
@@ skipping 1579 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart