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);

[siva, 2012/09/24 18:28:51]

From this code it appears that one can add private names
to the show list, not sure what the spec states in terms of
whether that should be flagged as an error or not.

[hausner, 2012/09/24 20:25:43]

Private names are not contained in the export namespace of the exporting
library, so I expect "show _A" to be a no-op, just like "show NonExistingName".

On 2012/09/24 18:28:51, siva wrote:

+        } else if (IsLiteral("hide")) {
+          ConsumeToken();
+          ParseIdentList(&hide_list);
+        } else {
+          break;
+        }
+      }

[siva, 2012/09/24 18:28:51]

Another question there is no check to ensure that the names being listed in the
show/hide list exist in the library.

Can a name appear in both the hide list and show list? if the show list appears
after the hide list and a name appears in both does it mean the show takes
precedence.

I am sure we will have builders complaining that they included a name in the
show list yet get errors (name misspelt in the list).

[hausner, 2012/09/24 20:25:43]

I added a note to the spec asking for clarification about contradicting
combinators. Regarding non-existing names, I interpret the spec as it being a
no-op if you show/hide a non-existing name.

On 2012/09/24 18:28:51, siva wrote:

+      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);
+      library_.AddImportAll(core_lib);
     }
     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);
+    library_.AddImportAll(core_lib);
   }
   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)) {

[siva, 2012/09/24 18:28:51]

The name HidesName is not very readable here as it seems to imply we are looking
in the hides list and not considering the show list.

maybe FiltersName would be better.

[hausner, 2012/09/24 20:25:43]

FiltersName does not say what the filter is doing. A name is hidden if it either
appears in the 'hide' list, or if it is not explicitly listed in the 'show'.

Another options is "IsHidden()" but it seems that we're splitting hairs...

On 2012/09/24 18:28:51, siva wrote:

+    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());
       }
@@ skipping 1430 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart