Implement capability to use the same library prefix for multiple library imports (currently this ...

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 3278 matching lines @@
       library = Library::LookupLibrary(canon_url);
       if (library.IsNull()) {
         library = Library::New(canon_url);
         library.Register();
       }
     }
     // Add the import to the library.
     if (prefix.IsNull() || (prefix.Length() == 0)) {
       library_.AddImport(library);
     } else {
-      if (library_.LookupLocalObject(prefix) != Object::null()) {
-        ErrorMsg(token_index_, "'%s' is already defined", prefix.ToCString());
+      LibraryPrefix& library_prefix = LibraryPrefix::Handle();
+      library_prefix = library_.LookupLocalLibraryPrefix(prefix);
+      if (!library_prefix.IsNull()) {
+        library_prefix.AddLibrary(library);
+      } else {
+        library_prefix = LibraryPrefix::New(prefix, library);
+        library_.AddObject(library_prefix, prefix);
       }
-      const LibraryPrefix& library_prefix =
-          LibraryPrefix::Handle(LibraryPrefix::New(prefix, library));
-      library_.AddObject(library_prefix, prefix);
     }
   }
 }
 
 
 void Parser::ParseLibraryInclude() {
   const Array& import_map = Array::Handle(library_.import_map());
   while (CurrentToken() == Token::kSOURCE) {
     const intptr_t source_pos = token_index_;
     ConsumeToken();
@@ skipping 2842 matching lines @@
   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());
-    Library& lib = Library::Handle();
+    Class& resolved_type_class = Class::Handle();
     if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
       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;
         }
       }
+      // Global lookup in current library.
+      resolved_type_class = library_.LookupClass(unresolved_class_name);
     } else {
       LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(unresolved_class.library_prefix());
-      lib = lib_prefix.library();
-    }
-    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);
+      // Local lookup in library prefix scope.
+      resolved_type_class = lib_prefix.LookupLocalClass(unresolved_class_name);

[regis, 2012/02/15 18:39:48]

Nice cleanup!

[siva, 2012/02/15 20:52:47]

Thanks.

     }
     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",
@@ skipping 304 matching lines @@
     Class& cls = Class::Handle();
     cls ^= obj.raw();
     return new PrimaryNode(qual_ident.ident_pos, Class::ZoneHandle(cls.raw()));
   }
   if (obj.IsField()) {
     Field& field = Field::Handle();
     field ^= obj.raw();
     ASSERT(field.is_static());
     return GenerateStaticFieldLookup(field, qual_ident.ident_pos);
   }
-  Function& func = Function::Handle();
   if (obj.IsFunction()) {
+    Function& func = Function::Handle();

[hausner, 2012/02/15 18:04:27]

Why not allocate a ZoneHandle here instead of allocating a second handle a few
lines below?

[siva, 2012/02/15 20:52:47]

Hoisted the Handle allocation outside the 'if statement' the
way it used to be.

     func ^= obj.raw();
     ASSERT(func.is_static());
     return new PrimaryNode(qual_ident.ident_pos,
                            Function::ZoneHandle(func.raw()));
   } else {
     ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
   }
 
   // Check if there is a global getter or setter for qual_ident.
   // We create a getter node even if a getter doesn't exist since
   // qual_ident could be followed by an assignment which will convert it
   // to a setter node. If there is no assignment we will get an error
   // when we try to invoke the getter.
   String& accessor_name = String::Handle(Field::GetterName(*qual_ident.ident));
   if (resolve_locally) {
     obj = lib.LookupLocalObject(accessor_name);
   } else {
     obj = lib.LookupObject(accessor_name);
   }
   if (obj.IsNull()) {
     accessor_name = Field::SetterName(*qual_ident.ident);
     if (resolve_locally) {
       obj = lib.LookupLocalObject(accessor_name);
     } else {
       obj = lib.LookupObject(accessor_name);
     }
   }
   if (!obj.IsNull()) {
+    Function& func = Function::Handle();
     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.lib_prefix != NULL) {
+    return NULL;
+  }
+  // Lexically unresolved primary identifiers are referenced by their name.
+  return new PrimaryNode(qual_ident.ident_pos, *qual_ident.ident);
+}
+
+
+// Do a lookup for the identifier in the library prefix scope of the specified
+// library prefix. This would mean trying to resolve it locally in any of the
+// libraries present in the library prefix.
+AstNode* Parser::ResolveIdentInLibraryPrefixScope(const LibraryPrefix& prefix,
+                                                  const QualIdent& qual_ident) {
+  TRACE_PARSER("ResolveIdentInLibraryPrefixScope");
+  Library& lib = Library::Handle();
+  AstNode* result = NULL;
+  for (intptr_t i = 0; ((i < prefix.num_libs()) && (result == NULL)); i++) {
+    lib = prefix.GetLibrary(i);
+    ASSERT(!lib.IsNull());
+    result = ResolveIdentInLibraryScope(lib, qual_ident, kResolveLocally);
+  }
+  if (result == NULL) {
     // This is an unresolved prefixed primary identifier, need to report
     // an error.
     ErrorMsg(qual_ident.ident_pos, "identifier '%s.%s' cannot be resolved",
              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);
+  return result;
 }
 
 
 // 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");
@@ skipping 813 matching lines @@
         // 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 {
       // This is a qualified identifier with a library prefix so resolve
       // the identifier locally in that library (we do not include the
       // libraries imported by that library).
-      const Library& lib = Library::Handle(qual_ident.lib_prefix->library());
-      primary = ResolveIdentInLibraryScope(lib,
-                                           qual_ident,
-                                           kResolveLocally);
+      primary = ResolveIdentInLibraryPrefixScope(*(qual_ident.lib_prefix),
+                                                 qual_ident);
     }
     ASSERT(primary != NULL);
   } else if (CurrentToken() == Token::kTHIS) {
     const String& this_name = String::Handle(String::NewSymbol(kThisName));
     LocalVariable* local = LookupLocalScope(this_name);
     if (local == NULL) {
       ErrorMsg("unexpected use of 'this' in primary expression");
     }
     primary = new LoadLocalNode(token_index_, *local);
     ConsumeToken();
@@ skipping 357 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart