Show and hide combinators supported.

lib/compiler/implementation/library_loader.dart

 // 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.
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  */
 abstract class LibraryLoader extends CompilerTask {
   LibraryLoader(Compiler compiler) : super(compiler);
 
@@ skipping 19 matching lines @@
    * scope of [importingLibrary].
    */
   // TODO(johnniwinther): Move handling of 'js_helper' to the library loader
   // to remove this method from the [LibraryLoader] interface.
   abstract void importLibrary(LibraryElement importingLibrary,
                               LibraryElement importedLibrary,
                               Import tag);
 }
 
 /**
+ * [CombinatorFilter] is a succinct representation of a list of combinators from
+ * a library dependency tag.
+ */
+class CombinatorFilter {
+  const CombinatorFilter();
+
+  /**
+   * Returns [:true:] if [element] is excluded by this filter.
+   */
+  bool exclude(Element element) => false;
+
+  /**
+   * Creates a filter based on the combinators of [tag].
+   */
+  factory CombinatorFilter.fromTag(LibraryDependency tag) {
+    if (tag == null || tag.combinators == null) {
+      return const CombinatorFilter();
+    }
+
+    // If the list of combinators contain at least one [:show:] we can create
+    // a positive list of elements to include, otherwise we create a negative
+    // list of elements to exclude.
+    bool show = false;
+    Set<SourceString> nameSet;
+    for (Combinator combinator in tag.combinators) {
+      if (combinator.isShow) {
+        show = true;
+        var set = new Set<SourceString>();
+        for (Identifier identifier in combinator.identifiers) {
+          set.add(identifier.source);
+        }
+        if (nameSet == null) {
+          nameSet = set;
+        } else {
+          nameSet = nameSet.intersection(set);
+        }
+      }
+    }
+    if (nameSet == null) {
+      nameSet = new Set<SourceString>();
+    }
+    for (Combinator combinator in tag.combinators) {
+      if (combinator.isHide) {
+        for (Identifier identifier in combinator.identifiers) {
+          if (show) {
+            // We have a positive list => Remove hidden elements.
+            nameSet.remove(identifier.source);
+          } else {
+            // We have no positive list => Accumulate hidden elements.
+            nameSet.add(identifier.source);
+          }
+        }
+      }
+    }
+    return show ? new ShowFilter(nameSet) : new HideFilter(nameSet);
+  }
+}
+
+/**
+ * A list of combinators represented as a list of element names to include.
+ */
+class ShowFilter extends CombinatorFilter {
+  final Set<SourceString> includedNames;
+
+  ShowFilter(this.includedNames);
+
+  bool exclude(Element element) => !includedNames.contains(element.name);
+}
+
+/**
+ * A list of combinators represented as a list of element names to exclude.
+ */
+class HideFilter extends CombinatorFilter {
+  final Set<SourceString> excludedNames;
+
+  HideFilter(this.excludedNames);
+
+  bool exclude(Element element) => excludedNames.contains(element.name);
+}
+
+/**
  * Implementation class for [LibraryLoader]. The distinction between
  * [LibraryLoader] and [LibraryLoaderTask] is made to hide internal members from
  * the [LibraryLoader] interface.
  */
 class LibraryLoaderTask extends LibraryLoader {
   LibraryLoaderTask(Compiler compiler) : super(compiler);
   String get name => 'LibraryLoader';
 
   final Map<String, LibraryElement> libraryNames =
       new Map<String, LibraryElement>();
@@ skipping 34 matching lines @@
       }
       return TagState.NEXT[value];
     }
 
     bool importsDartCore = false;
     var libraryDependencies = new LinkBuilder<LibraryDependency>();
     Uri base = library.entryCompilationUnit.script.uri;
     for (LibraryTag tag in library.tags.reverse()) {
       if (tag.isImport) {
         tagState = checkTag(TagState.IMPORT_OR_EXPORT, tag);
-        if (tag.combinators != null) {
-          compiler.unimplemented('combinators', node: tag.combinators);
-        }
         if (tag.uri.dartString.slowToString() == 'dart:core') {
           importsDartCore = true;
         }
         libraryDependencies.addLast(tag);
       } else if (tag.isExport) {
         tagState = checkTag(TagState.IMPORT_OR_EXPORT, tag);
         libraryDependencies.addLast(tag);
       } else if (tag.isLibraryName) {
         tagState = checkTag(TagState.LIBRARY, tag);
         if (library.libraryTag !== null) {
@@ skipping 177 matching lines @@
 
   ImportLink(this.import, this.importedLibrary);
 
   /**
    * Imports the library into the [importingLibrary].
    */
   void importLibrary(Compiler compiler, LibraryElement importingLibrary) {
     assert(invariant(importingLibrary,
                      importedLibrary.exportsHandled,
                      message: 'Exports not handled on $importedLibrary'));
+    var combinatorFilter = new CombinatorFilter.fromTag(import);
     if (import !== null && import.prefix !== null) {
       SourceString prefix = import.prefix.source;
       Element e = importingLibrary.find(prefix);
       if (e === null) {
         e = new PrefixElement(prefix, importingLibrary.entryCompilationUnit,
                               import.getBeginToken());
         importingLibrary.addToScope(e, compiler);
       }
       if (e.kind !== ElementKind.PREFIX) {
         compiler.withCurrentElement(e, () {
           compiler.reportWarning(new Identifier(e.position()),
           'duplicated definition');
         });
         compiler.reportError(import.prefix, 'duplicate definition');
       }
       PrefixElement prefixElement = e;
       importedLibrary.forEachExport((Element element) {
-        // TODO(johnniwinther): Handle show and hide combinators.
+        if (combinatorFilter.exclude(element)) return;
         // TODO(johnniwinther): Clean-up like [checkDuplicateLibraryName].
         Element existing =
             prefixElement.imported.putIfAbsent(element.name, () => element);
         if (existing !== element) {
           compiler.withCurrentElement(existing, () {
             compiler.reportWarning(new Identifier(existing.position()),
             'duplicated import');
           });
           compiler.withCurrentElement(element, () {
             compiler.reportError(new Identifier(element.position()),
             'duplicated import');
           });
         }
       });
     } else {
       importedLibrary.forEachExport((Element element) {
         compiler.withCurrentElement(element, () {
-          // TODO(johnniwinther): Handle show and hide combinators.
+          if (combinatorFilter.exclude(element)) return;
           importingLibrary.addImport(element, compiler);
         });
       });
     }
   }
 }
 
 /**
+ * The combinator filter computed from an export tag and the library dependency
+ * node for the library that declared the export tag. This represents an edge in
+ * the library dependency graph.
+ */
+class ExportLink {
+  final CombinatorFilter combinatorFilter;
+  final LibraryDependencyNode exportNode;
+
+  ExportLink(Export export, LibraryDependencyNode this.exportNode)
+      : this.combinatorFilter = new CombinatorFilter.fromTag(export);
+
+  /**
+   * Exports [element] to the dependent library unless [element] is filtered by
+   * the export combinators. Returns [:true:] if the set pending exports of the
+   * dependent library was modified.
+   */
+  bool exportElement(Element element) {
+    if (combinatorFilter.exclude(element)) return false;
+    return exportNode.addElementToPendingExports(element);
+  }
+}
+
+/**
  * A node in the library dependency graph.
  *
  * This class is used to collect the library dependencies expressed through
  * import and export tags, and as the work-list entry in computations of library
  * exports performed in [LibraryDependencyHandler.computeExports].
  */
 class LibraryDependencyNode {
   final LibraryElement library;
 
   /**
    * A linked list of the import tags that import [library] mapped to the
    * corresponding libraries. This is used to propagate exports into imports
    * after the export scopes have been computed.
    */
   Link<ImportLink> imports = const EmptyLink<ImportLink>();
 
   /**
-   * The export tags that export [library] mapped to the nodes for the libraries
-   * that declared each export tag. This is used to propagete exports during the
-   * computation of export scopes.
+   * A linked list of the export tags the dependent upon this node library.
+   * This is used to propagate exports during the computation of export scopes.
    */
-  Map<Export, LibraryDependencyNode> dependencyMap =
-      new Map<Export, LibraryDependencyNode>();
+  Link<ExportLink> dependencies = const EmptyLink<ExportLink>();
 
   /**
    * The export scope for [library] which is gradually computed by the work-list
    * computation in [LibraryDependencyHandler.computeExports].
    */
   Map<SourceString, Element> exportScope = new Map<SourceString, Element>();
 
   /**
    * The set of exported elements that need to be propageted to dependent
    * libraries as part of the work-list computation performed in
@@ skipping 11 matching lines @@
                                 LibraryElement importedLibrary) {
     imports = imports.prepend(new ImportLink(import, importedLibrary));
   }
 
   /**
    * Registers that the library of this node is exported by
    * [exportingLibraryNode] through the [export] tag.
    */
   void registerExportDependency(Export export,
                                 LibraryDependencyNode exportingLibraryNode) {
-    dependencyMap[export] = exportingLibraryNode;
+    dependencies =
+        dependencies.prepend(new ExportLink(export, exportingLibraryNode));
   }
 
   /**
    * Registers all non-private locally declared members of the library of this
    * node to be exported. This forms the basis for the work-list computation of
    * the export scopes performed in [LibraryDependencyHandler.computeExports].
    */
   void registerInitialExports() {
     pendingExportSet.addAll(
         library.localScope.getValues().filter((Element element) {
@@ skipping 23 matching lines @@
    * Copies and clears pending export set for this node.
    */
   List<Element> pullPendingExports() {
     List<Element> pendingExports = new List.from(pendingExportSet);
     pendingExportSet.clear();
     return pendingExports;
   }
 
   /**
    * Adds [element] to the export scope for this node. If the [element] name
-   * is a duplicate, an error element is inserted into the exscope.
+   * is a duplicate, an error element is inserted into the export scope.
    */
   Element addElementToExportScope(Compiler compiler, Element element) {
     SourceString name = element.name;
     Element existingElement = exportScope[name];
     if (existingElement !== null) {
       if (existingElement.getLibrary() != library) {
         // Declared elements hide exported elements.
         element = exportScope[name] = new ErroneousElement(
             MessageKind.DUPLICATE_EXPORT, [name], name, library);
       }
     } else {
       exportScope[name] = element;
     }
     return element;
   }
 
   /**
    * Propagates the exported [element] to all library nodes that depend upon
    * this node. If the propagation updated any pending exports, [:true:] is
    * returned.
    */
   bool propagateElement(Element element) {
     bool change = false;
-    dependencyMap.forEach((Export export, LibraryDependencyNode exportNode) {
-      if (exportNode.addElementToPendingExports(export, element)) {
+    for (ExportLink link in dependencies) {
+      if (link.exportElement(element)) {
         change = true;
       }
-    });
+    }
     return change;
   }
 
   /**
    * Adds [element] to the pending exports of this node and returns [:true:] if
    * the pending export set was modified. The combinators of [export] are used
    * to filter the element.
    */
-  bool addElementToPendingExports(Export export, Element element) {
-    // TODO(johnniwinther): Use [export] to handle show and hide combinators.
+  bool addElementToPendingExports(Element element) {
     if (exportScope[element.name] !== element) {
       if (!pendingExportSet.contains(element)) {
         pendingExportSet.add(element);
         return true;
       }
     }
     return false;
   }
 }
 
@@ skipping 88 matching lines @@
   }
 
   /**
    * Registers all top-level entities of [library] as starting point for the
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 }