Handle implicitly hidden exports.

sdk/lib/_internal/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.
 
 library dart2js.library_loader;
 
 import 'dart:async';
 import 'dart2jslib.dart'
     show Compiler,
          CompilerTask,
          MessageKind,
          Script,
          invariant;
 import 'elements/elements.dart'
     show CompilationUnitElement,
          Element,
          LibraryElement,
          PrefixElement;
 import 'elements/modelx.dart'
     show CompilationUnitElementX,
          DeferredLoaderGetterElementX,
          ErroneousElementX,
          LibraryElementX,
-         PrefixElementX;
+         PrefixElementX,
+         WarnOnUseElementX,
+         WrappedMessage;
 import 'helpers/helpers.dart';  // Included for debug helpers.
 import 'native_handler.dart' as native;
 import 'tree/tree.dart';
 import 'util/util.dart' show Link, LinkBuilder;
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  *
  * The library loader uses four different kinds of URIs in different parts of
  * the loading process.
@@ skipping 726 matching lines @@
    * Copies and clears pending export set for this node.
    */
   Map<Element, Link<Export>> pullPendingExports() {
     Map<Element, Link<Export>> pendingExports =
         new Map<Element, Link<Export>>.from(pendingExportMap);
     pendingExportMap.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 export scope.
+   * Adds [newElement] to the export scope for this node. If the [newElement]
+   * name is a duplicate, an error element is inserted into the export scope.
    */
-  Element addElementToExportScope(Compiler compiler, Element element,
+  Element addElementToExportScope(Compiler compiler, Element newElement,
                                   Link<Export> exports) {
-    String name = element.name;
+    return compiler.withCurrentElement(library, () {
+      String name = newElement.name;
+      exporters[newElement] = exports;
 
-    void reportDuplicateExport(Element duplicate,
-                               Link<Export> duplicateExports,
-                               {bool reportError: true}) {
-      assert(invariant(library, !duplicateExports.isEmpty,
-          message: "No export for $duplicate from ${duplicate.library} "
-                   "in $library."));
-      compiler.withCurrentElement(library, () {
-        for (Export export in duplicateExports) {
-          if (reportError) {
-            compiler.reportError(export,
-                MessageKind.DUPLICATE_EXPORT, {'name': name});
-            reportError = false;
+      void reportDuplicateExport(Element duplicate,
+                                 Link<Export> duplicateExports,
+                                 {bool reportError: true}) {
+        assert(invariant(library, !duplicateExports.isEmpty,
+            message: "No export for $duplicate from ${duplicate.library} "
+                     "in $library."));
+        compiler.withCurrentElement(library, () {
+          for (Export export in duplicateExports) {
+            if (reportError) {
+              compiler.reportError(export,
+                  MessageKind.DUPLICATE_EXPORT, {'name': name});
+              reportError = false;
+            } else {
+              compiler.reportInfo(export,
+                  MessageKind.DUPLICATE_EXPORT_CONT, {'name': name});
+            }
+          }
+        });
+      }
+
+      void reportDuplicateExportDecl(Element duplicate,
+                                     Link<Export> duplicateExports) {
+        assert(invariant(library, !duplicateExports.isEmpty,
+            message: "No export for $duplicate from ${duplicate.library} "
+                     "in $library."));
+        compiler.reportInfo(duplicate, MessageKind.DUPLICATE_EXPORT_DECL,
+            {'name': name, 'uriString': duplicateExports.head.uri});
+      }
+
+
+      Element createWarnOnUseElement(MessageKind messageKind,
+                                     Element hidingElement,
+                                     Element hiddenElement) {
+        Uri hiddenUri = hiddenElement.library.canonicalUri;
+        Uri hidingUri = hidingElement.library.canonicalUri;
+        Element exportedElement = new WarnOnUseElementX(
+            new WrappedMessage(
+                null, // Report on reference to [hidingElement].
+                messageKind,
+                {'name': name, 'hiddenUri': hiddenUri, 'hidingUri': hidingUri}),
+            new WrappedMessage(
+                compiler.spanFromSpannable(exporters[hiddenElement].head),
+                MessageKind.EXPORTED_HERE,
+                {'name': name,
+                 'uri': hiddenUri}),
+            hidingElement.enclosingElement, hidingElement);
+        exporters[exportedElement] = exports;
+        return exportedElement;
+      }
+
+      bool fromPlatform(Element e) => e.library.isPlatformLibrary;
+
+      Element computeExportedElement(Element existingElement) {
+        if (existingElement != null && existingElement != newElement) {
+          if (existingElement.isErroneous) {
+            if (!fromPlatform(newElement)) {
+              reportDuplicateExport(newElement, exports);
+              reportDuplicateExportDecl(newElement, exports);
+            }
+            return existingElement;
+          } else if (existingElement.library == library) {
+            // Do nothing. [existingElement] hides [newElement].
+            return existingElement;
+          } else if (newElement.library == library) {
+            // [newElement] hides [existingElement].
+            return newElement;
           } else {
-            compiler.reportInfo(export,
-                MessageKind.DUPLICATE_EXPORT_CONT, {'name': name});
+            if (fromPlatform(existingElement) &&
+                !fromPlatform(newElement)) {
+              // [existingElement] is implicitly hidden.
+              return createWarnOnUseElement(
+                  MessageKind.HIDDEN_IMPLICIT_EXPORT,
+                  newElement,
+                  existingElement);
+            } else if (!fromPlatform(existingElement) &&
+                       fromPlatform(newElement)) {
+              // [element] is implicitly hidden.
+              return createWarnOnUseElement(
+                  MessageKind.HIDDEN_IMPLICIT_EXPORT,
+                  existingElement,
+                  newElement);
+            } else {
+              // Declared elements hide exported elements.
+              Link<Export> existingExports = exporters[existingElement];
+              reportDuplicateExport(existingElement, existingExports);
+              reportDuplicateExport(newElement, exports, reportError: false);
+              reportDuplicateExportDecl(existingElement, existingExports);
+              reportDuplicateExportDecl(newElement, exports);
+              Element exportedElement = new ErroneousElementX(
+                  MessageKind.DUPLICATE_EXPORT, {'name': name}, name, library);
+              exporters[exportedElement] = existingExports;
+              return exportedElement;
+            }
           }
+        } else {
+          return newElement;
         }
-      });
-    }
+      }
 
-    void reportDuplicateExportDecl(Element duplicate,
-                                   Link<Export> duplicateExports) {
-      assert(invariant(library, !duplicateExports.isEmpty,
-          message: "No export for $duplicate from ${duplicate.library} "
-                   "in $library."));
-      compiler.reportInfo(duplicate, MessageKind.DUPLICATE_EXPORT_DECL,
-          {'name': name, 'uriString': duplicateExports.head.uri});
-    }
-
-    Element existingElement = exportScope[name];
-    if (existingElement != null && existingElement != element) {
-      if (existingElement.isErroneous) {
-        reportDuplicateExport(element, exports);
-        reportDuplicateExportDecl(element, exports);
-        element = existingElement;
-      } else if (existingElement.library == library) {
-        // Do nothing. [existingElement] hides [element].
-      } else if (element.library == library) {
-        // [element] hides [existingElement].
-        exportScope[name] = element;
-        exporters[element] = exports;
-      } else {
-        // Declared elements hide exported elements.
-        Link<Export> existingExports = exporters[existingElement];
-        reportDuplicateExport(existingElement, existingExports);
-        reportDuplicateExport(element, exports, reportError: false);
-        reportDuplicateExportDecl(existingElement, existingExports);
-        reportDuplicateExportDecl(element, exports);
-        element = exportScope[name] = new ErroneousElementX(
-            MessageKind.DUPLICATE_EXPORT, {'name': name}, name, library);
-      }
-    } else {
-      exportScope[name] = element;
-      exporters[element] = exports;
-    }
-    return element;
+      Element existingElement = exportScope[name];
+      Element exportedElement = computeExportedElement(existingElement);
+      exportScope[name] = exportedElement;
+      return exportedElement;
+    });
   }
 
   /**
    * 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;
     for (ExportLink link in dependencies) {
@@ skipping 141 matching lines @@
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 
   Future processLibraryTags(LibraryElement library) {
     return task.processLibraryTags(this, library);
   }
 }