Report hint on unmatched show and hide combinators.

pkg/compiler/lib/src/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.
 
 library dart2js.library_loader;
 
 import 'dart:async';
 
 import 'common/names.dart' show
     Uris;
@@ skipping 856 matching lines @@
    * 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() {
     for (Element element in library.getNonPrivateElementsInScope()) {
       pendingExportMap[element] = const Link<ExportElement>();
     }
   }
 
-  void registerHandledExports(LibraryElement exportedLibraryElement,
+  /// Register the already computed export scope of [exportedLibraryElement] to
+  /// export from the library of this node through the [export]  declaration
+  /// with the given combination [filter].
+  ///
+  /// Additionally, check that all names in the show/hide combinators are in the
+  /// export scope of [exportedLibraryElement].
+  void registerHandledExports(DiagnosticListener listener,
+                              LibraryElement exportedLibraryElement,
                               ExportElementX export,
                               CombinatorFilter filter) {
     assert(invariant(library, exportedLibraryElement.exportsHandled));
     exportedLibraryElement.forEachExport((Element exportedElement) {
       if (!filter.exclude(exportedElement)) {
         Link<ExportElement> exports =
             pendingExportMap.putIfAbsent(exportedElement,
                                          () => const Link<ExportElement>());
         pendingExportMap[exportedElement] = exports.prepend(export);
       }
     });
+    listener.withCurrentElement(library, () {
+      checkLibraryDependency(listener, export.node, exportedLibraryElement);
+    });
   }
 
   /**
    * Registers the compute export scope with the node library.
    */
   void registerExports() {
     library.setExports(exportScope.values.toList());
   }
 
   /**
@@ skipping 105 matching lines @@
     bool changed = false;
     if (!identical(exportScope[element.name], element)) {
       Link<ExportElement> exports = pendingExportMap.putIfAbsent(element, () {
         changed = true;
         return const Link<ExportElement>();
       });
       pendingExportMap[element] = exports.prepend(export);
     }
     return changed;
   }
+
+  /// Check that all names in the show/hide combinators of imports and exports
+  /// are in the export scope of the imported/exported libraries.
+  void checkCombinators(DiagnosticListener listener) {
+    listener.withCurrentElement(library, () {
+      for (ImportLink importLink in imports) {
+        checkLibraryDependency(
+            listener, importLink.import.node, importLink.importedLibrary);
+      }
+    });
+    for (ExportLink exportLink in dependencies) {
+      listener.withCurrentElement(exportLink.exportNode.library, () {
+        checkLibraryDependency(listener, exportLink.export.node, library);
+      });
+    }
+  }
+
+  /// Check that all names in the show/hide combinators of [tag] are in the
+  /// export scope of [library].
+  void checkLibraryDependency(DiagnosticListener listener,
+                              LibraryDependency tag,
+                              LibraryElement library) {
+    if (tag == null || tag.combinators == null) return;
+    for (Combinator combinator in tag.combinators) {
+      for (Identifier identifier in combinator.identifiers) {
+        String name = identifier.source;
+        Element element = library.findExported(name);
+        if (element == null) {
+          listener.reportHint(
+              identifier,
+              combinator.isHide
+                  ? MessageKind.EMPTY_HIDE : MessageKind.EMPTY_SHOW,
+              {'uri': library.canonicalUri,
+               'name': name});
+        }
+      }
+    }
+  }
+
 }
 
 /**
  * Helper class used for computing the possibly cyclic import/export scopes of
  * a set of libraries.
  *
  * This class is used by [ScannerTask.scanLibrary] to collect all newly loaded
  * libraries and to compute their import/export scopes through a fixed-point
  * algorithm.
  */
@@ skipping 53 matching lines @@
     // scopes to avoid accessing uncomputed export scopes during handling of
     // imports.
     nodeMap.forEach((LibraryElement library, LibraryDependencyNode node) {
       node.registerExports();
     });
 
     // Setup import scopes.
     nodeMap.forEach((LibraryElement library, LibraryDependencyNode node) {
       node.registerImports(compiler);
     });
+
+    nodeMap.forEach((LibraryElement library, LibraryDependencyNode node) {
+      node.checkCombinators(compiler);
+    });
   }
 
   /// Registers that [library] depends on [loadedLibrary] through
   /// [libraryDependency].
   void registerDependency(LibraryElementX library,
                           LibraryDependencyElementX libraryDependency,
                           LibraryElement loadedLibrary) {
     if (libraryDependency.isExport) {
       // [loadedLibrary] is exported by [library].
       LibraryDependencyNode exportingNode = nodeMap[library];
       if (loadedLibrary.exportsHandled) {
         // Export scope already computed on [loadedLibrary].
         CombinatorFilter combinatorFilter =
             new CombinatorFilter.fromTag(libraryDependency.node);
         exportingNode.registerHandledExports(
-            loadedLibrary, libraryDependency, combinatorFilter);
+            compiler, loadedLibrary, libraryDependency, combinatorFilter);
         return;
       }
       LibraryDependencyNode exportedNode = nodeMap[loadedLibrary];
       assert(invariant(loadedLibrary, exportedNode != null,
           message: "$loadedLibrary has not been registered"));
       assert(invariant(library, exportingNode != null,
           message: "$library has not been registered"));
       exportedNode.registerExportDependency(libraryDependency, exportingNode);
     } else if (libraryDependency == null || libraryDependency.isImport) {
       // [loadedLibrary] is imported by [library].
@@ skipping 144 matching lines @@
         }
         suffixes.add(const Link<Uri>().prepend(canonicalUri));
       }
       suffixChainMap[library] = suffixes;
       return;
     }
 
     computeSuffixes(rootLibrary, const Link<Uri>());
   }
 }