Support for show/hide combinators

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 4069 matching lines @@
       CallLibraryTagHandler(kImportTag, import_pos, canon_url);
       // If the library tag handler succeded without registering the
       // library we create an empty library to import.
       library = Library::LookupLibrary(canon_url);
       if (library.IsNull()) {
         library = Library::New(canon_url);
         library.Register();
       }
     }
     // Add the import to the library.
+    const Namespace& import = Namespace::Handle(
+        Namespace::New(library, Array::Handle(), Array::Handle()));
     if (prefix.IsNull() || (prefix.Length() == 0)) {
-      library_.AddImport(library);
+      library_.AddImport(import);
     } else {
       LibraryPrefix& library_prefix = LibraryPrefix::Handle();
       library_prefix = library_.LookupLocalLibraryPrefix(prefix);
       if (!library_prefix.IsNull()) {
-        library_prefix.AddLibrary(library);
+        library_prefix.AddImport(import);
       } else {
-        library_prefix = LibraryPrefix::New(prefix, library);
+        library_prefix = LibraryPrefix::New(prefix, import);
         library_.AddObject(library_prefix, prefix);
       }
     }
   }
 }
 
 
 // TODO(hausner): Remove support for old library definition syntax.
 void Parser::ParseLibraryIncludeObsoleteSyntax() {
   while (CurrentToken() == Token::kSOURCE) {
@@ skipping 21 matching lines @@
   ConsumeToken();
   // TODO(hausner): Exact syntax of library name still unclear: identifier,
   // qualified identifier or even multiple dots allowed? For now we just
   // accept simple identifiers.
   const String& lib_name = *ExpectIdentifier("library name expected");
   library_.SetName(lib_name);
   ExpectSemicolon();
 }
 
 
+void Parser::ParseIdentList(GrowableObjectArray* names) {
+  while (IsIdentifier()) {
+    names->Add(*CurrentLiteral());
+    ConsumeToken();  // Identifier.
+    if (CurrentToken() != Token::kCOMMA) {
+      return;
+    }
+    ConsumeToken();  // Comma.
+  }
+}
+
+
 void Parser::ParseLibraryImportExport() {
   if (IsLiteral("import")) {
     const intptr_t import_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library url expected");
     }
     const String& url = *CurrentLiteral();
     if (url.Length() == 0) {
       ErrorMsg("library url expected");
     }
     ConsumeToken();
     String& prefix = String::Handle();
     if (IsLiteral("as")) {
       ConsumeToken();
       prefix = ExpectIdentifier("prefix expected")->raw();
     }
-    if (IsLiteral("show")) {
-      ErrorMsg("show combinator not yet supported");
-    } else if (IsLiteral("hide")) {
-      ErrorMsg("hide combinator not yet supported");
+
+    Array& show_names = Array::Handle();
+    Array& hide_names = Array::Handle();
+    if (IsLiteral("show") || IsLiteral("hide")) {
+      GrowableObjectArray& show_list =
+          GrowableObjectArray::Handle(GrowableObjectArray::New());
+      GrowableObjectArray& hide_list =
+          GrowableObjectArray::Handle(GrowableObjectArray::New());
+      for (;;) {
+        if (IsLiteral("show")) {
+          ConsumeToken();
+          ParseIdentList(&show_list);
+        } else if (IsLiteral("hide")) {
+          ConsumeToken();
+          ParseIdentList(&hide_list);
+        } else {
+          break;
+        }
+      }
+      if (show_list.Length() > 0) {
+        show_names = Array::MakeArray(show_list);
+      }
+      if (hide_list.Length() > 0) {
+        hide_names = Array::MakeArray(hide_list);
+      }
     }
     ExpectSemicolon();
 
     // Canonicalize library URL.
     Dart_Handle handle =
         CallLibraryTagHandler(kCanonicalizeUrl, import_pos, url);
     const String& canon_url = String::CheckedHandle(Api::UnwrapHandle(handle));
     // Lookup the library URL.
     Library& library = Library::Handle(Library::LookupLibrary(canon_url));
     if (library.IsNull()) {
       // Call the library tag handler to load the library.
       CallLibraryTagHandler(kImportTag, import_pos, canon_url);
       // If the library tag handler succeded without registering the
       // library we create an empty library to import.
       library = Library::LookupLibrary(canon_url);
       if (library.IsNull()) {
         library = Library::New(canon_url);
         library.Register();
       }
     }
     // Add the import to the library.
+    const Namespace& import =
+        Namespace::Handle(Namespace::New(library, show_names, hide_names));
     if (prefix.IsNull() || (prefix.Length() == 0)) {
-      library_.AddImport(library);
+      library_.AddImport(import);
     } else {
       LibraryPrefix& library_prefix = LibraryPrefix::Handle();
       library_prefix = library_.LookupLocalLibraryPrefix(prefix);
       if (!library_prefix.IsNull()) {
-        library_prefix.AddLibrary(library);
+        library_prefix.AddImport(import);
       } else {
-        library_prefix = LibraryPrefix::New(prefix, library);
+        library_prefix = LibraryPrefix::New(prefix, import);
         library_.AddObject(library_prefix, prefix);
       }
     }
   } else if (IsLiteral("export")) {
     ErrorMsg("export clause not yet supported");
   } else {
     ErrorMsg("unreachable");
     UNREACHABLE();
   }
 }
@@ skipping 18 matching lines @@
       (CurrentToken() == Token::kIMPORT) ||
       (CurrentToken() == Token::kSOURCE)) {
     ParseLibraryNameObsoleteSyntax();
     ParseLibraryImportObsoleteSyntax();
     ParseLibraryIncludeObsoleteSyntax();
     // Core lib has not been explicitly imported, so we implicitly
     // import it here.
     if (!library_.ImportsCorelib()) {
       Library& core_lib = Library::Handle(Library::CoreLibrary());
       ASSERT(!core_lib.IsNull());
-      library_.AddImport(core_lib);
+      const Namespace& core_ns = Namespace::Handle(
+          Namespace::New(core_lib, Array::Handle(), Array::Handle()));
+      library_.AddImport(core_ns);
     }
     return;
   }
 
   // We may read metadata tokens that are part of the toplevel
   // declaration that follows the library definitions. Therefore, we
   // need to remember the position of the last token that was
   // successfully consumed.
   intptr_t metadata_pos = TokenPos();
   SkipMetadata();
   if (IsLiteral("library")) {
     ParseLibraryName();
     metadata_pos = TokenPos();
     SkipMetadata();
   } else if (script_.kind() == RawScript::kLibraryTag) {
     ErrorMsg("library name definition expected");
   }
   while (IsLiteral("import") || IsLiteral("export")) {
     ParseLibraryImportExport();
     metadata_pos = TokenPos();
     SkipMetadata();
   }
   // Core lib has not been explicitly imported, so we implicitly
   // import it here.
   if (!library_.ImportsCorelib()) {
     Library& core_lib = Library::Handle(Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
-    library_.AddImport(core_lib);
+    const Namespace& core_ns = Namespace::Handle(
+        Namespace::New(core_lib, Array::Handle(), Array::Handle()));
+    library_.AddImport(core_ns);
   }
   while (IsLiteral("part")) {
     ParseLibraryPart();
     metadata_pos = TokenPos();
     SkipMetadata();
   }
   if (IsLiteral("library") || IsLiteral("import") || IsLiteral("export")) {
     ErrorMsg("unexpected token '%s'", CurrentLiteral()->ToCString());
   }
   SetPosition(metadata_pos);
@@ skipping 3709 matching lines @@
   obj = lib.LookupLocalObject(accessor_name);
   if (!obj.IsNull()) {
     return obj.raw();
   }
   accessor_name = Field::SetterName(name);
   obj = lib.LookupLocalObject(accessor_name);
   return obj.raw();
 }
 
 
+static RawObject* LookupNameInImport(const Namespace& ns, const String& name) {
+  Object& obj = Object::Handle();
+  obj = ns.Lookup(name);
+  if (!obj.IsNull()) {
+    return obj.raw();
+  }
+  // If the given name is filtered out by the import, don't look up the
+  // getter and setter names.
+  if (ns.HidesName(name)) {
+    return Object::null();
+  }
+  String& accessor_name = String::Handle(Field::GetterName(name));
+  obj = ns.Lookup(accessor_name);
+  if (!obj.IsNull()) {
+    return obj.raw();
+  }
+  accessor_name = Field::SetterName(name);
+  obj = ns.Lookup(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.
 // Issue an error if the name is not found in the global scope
 // of the current library, but is defined in more than one imported
 // library, i.e. if the name cannot be resolved unambiguously.
 RawObject* Parser::ResolveNameInCurrentLibraryScope(intptr_t ident_pos,
                                                     const String& name) {
   TRACE_PARSER("ResolveNameInCurrentLibraryScope");
   Object& obj = Object::Handle(LookupNameInLibrary(library_, name));
   if (obj.IsNull()) {
     // Name is not found in current library. Check scope of all
     // imported libraries.
     String& first_lib_url = String::Handle();
-    Library& lib = Library::Handle();
+    Namespace& import = Namespace::Handle();
     intptr_t num_imports = library_.num_imports();
-    Object& resolved_obj = Object::Handle();
+    Object& imported_obj = Object::Handle();
     for (int i = 0; i < num_imports; i++) {
-      lib ^= library_.ImportAt(i);
-      resolved_obj = LookupNameInLibrary(lib, name);
-      if (!resolved_obj.IsNull()) {
+      import ^= library_.ImportAt(i);
+      imported_obj = LookupNameInImport(import, name);
+      if (!imported_obj.IsNull()) {
+        const Library& lib = Library::Handle(import.library());
         if (!first_lib_url.IsNull()) {
           // Found duplicate definition.
           if (first_lib_url.raw() == lib.url()) {
             ErrorMsg(ident_pos,
                      "ambiguous reference: "
                      "'%s' as library '%s' is imported multiple times",
                      name.ToCString(),
                      first_lib_url.ToCString());
           } else {
             ErrorMsg(ident_pos,
                      "ambiguous reference: "
                      "'%s' is defined in library '%s' and also in '%s'",
                      name.ToCString(),
                      first_lib_url.ToCString(),
                      String::Handle(lib.url()).ToCString());
           }
         } else {
           first_lib_url = lib.url();
-          obj = resolved_obj.raw();
+          obj = imported_obj.raw();
         }
       }
     }
   }
   return obj.raw();
 }
 
 
 RawClass* Parser::ResolveClassInCurrentLibraryScope(intptr_t ident_pos,
                                                     const String& name) {
@@ skipping 42 matching lines @@
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new PrimaryNode(ident_pos, ident);
 }
 
 
 RawObject* Parser::ResolveNameInPrefixScope(intptr_t ident_pos,
                                             const LibraryPrefix& prefix,
                                             const String& name) {
   TRACE_PARSER("ResolveNameInPrefixScope");
-  Library& lib = Library::Handle();
+  Namespace& import = Namespace::Handle();
   String& first_lib_url = String::Handle();
   Object& obj = Object::Handle();
   Object& resolved_obj = Object::Handle();
-  for (intptr_t i = 0; i < prefix.num_libs(); i++) {
-    lib = prefix.GetLibrary(i);
-    ASSERT(!lib.IsNull());
-    resolved_obj = LookupNameInLibrary(lib, name);
+  const Array& imports = Array::Handle(prefix.imports());
+  for (intptr_t i = 0; i < prefix.num_imports(); i++) {
+    import ^= imports.At(i);
+    resolved_obj = LookupNameInImport(import, name);
     if (!resolved_obj.IsNull()) {
       obj = resolved_obj.raw();
+      const Library& lib = Library::Handle(import.library());
       if (first_lib_url.IsNull()) {
         first_lib_url = lib.url();
       } else {
         ErrorMsg(ident_pos,
                  "ambiguous reference: '%s.%s' is defined in '%s' and '%s'",
                  String::Handle(prefix.name()).ToCString(),
                  name.ToCString(),
                  first_lib_url.ToCString(),
                  String::Handle(lib.url()).ToCString());

[siva, 2012/09/24 21:12:37]

We need a "if (first_lib_url.raw() == lib.url())" check
here to avoid weird error messages.

[hausner, 2012/09/24 21:41:06]

Done.

       }
     }
   }
   return obj.raw();
 }
 
 
 RawClass* Parser::ResolveClassInPrefixScope(intptr_t ident_pos,
                                             const LibraryPrefix& prefix,
                                             const String& name) {
@@ skipping 1421 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart