Add ImportElement and ExportElement

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import '../compiler.dart' show
     Compiler;
 import '../constants/constant_constructors.dart';
 import '../constants/constructors.dart';
@@ skipping 542 matching lines @@
               newElement);
 
   void diagnose(Element context, DiagnosticListener listener) {
     Setlet ambiguousElements = flatten();
     MessageKind code = (ambiguousElements.length == 1)
         ? MessageKind.AMBIGUOUS_REEXPORT : MessageKind.AMBIGUOUS_LOCATION;
     LibraryElementX importer = context.library;
     for (Element element in ambiguousElements) {
       var arguments = {'name': element.name};
       listener.reportInfo(element, code, arguments);
-      Link<Import> importers = importer.importers.getImports(element);
       listener.withCurrentElement(importer, () {
-        for (; !importers.isEmpty; importers = importers.tail) {
+        for (ImportElement import in importer.importers.getImports(element)) {
           listener.reportInfo(
-              importers.head, MessageKind.IMPORTED_HERE, arguments);
+              import, MessageKind.IMPORTED_HERE, arguments);
         }
       });
     }
   }
 }
 
 /// Element synthesized to recover from a duplicated member of an element.
 class DuplicatedElementX extends AmbiguousElementX {
   DuplicatedElementX(
       MessageKind messageKind,
@@ skipping 177 matching lines @@
 
   bool get hasMembers => !localMembers.isEmpty;
 
   Element get analyzableElement => library;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitCompilationUnitElement(this, arg);
   }
 }
 
+/// Map from [Element] to the [ImportElement]s throught which it was imported.
+///
+/// This is used for error reporting and deferred loading.
 class Importers {
-  Map<Element, Link<Import>> importers = new Map<Element, Link<Import>>();
+  Map<Element, List<ImportElement>> importers =
+      new Map<Element, List<ImportElement>>();
 
-  Link<Import> getImports(Element element) {
-    Link<Import> imports = importers[element];
-    return imports != null ? imports : const Link<Import>();
+  /// Returns the the list of [ImportElement]s through which [element] was
+  /// imported.
+  List<ImportElement> getImports(Element element) {
+    List<ImportElement> imports = importers[element];
+    return imports != null ? imports : const <ImportElement>[];
   }
 
-  Import getImport(Element element) => getImports(element).head;
+  /// Returns the first [ImportElement] through which [element] was imported.
+  ImportElement getImport(Element element) => getImports(element).first;
 
-  void registerImport(Element element, Import import) {
-    if (import == null) return;
-
-    importers[element] =
-        importers.putIfAbsent(element, () => const Link<Import>())
-          .prepend(import);
+  /// Register [element] as imported through [import];
+  void registerImport(Element element, ImportElement import) {
+    importers.putIfAbsent(element, () => <ImportElement>[]).add(import);
   }
 }
 
 class ImportScope {
   /**
    * Map for elements imported through import declarations.
    *
    * Addition to the map is performed by [addImport]. Lookup is done trough
    * [find].
    */
   final Map<String, Element> importScope =
       new Map<String, Element>();
 
   /**
    * Adds [element] to the import scope of this library.
    *
    * If an element by the same name is already in the imported scope, an
    * [ErroneousElement] will be put in the imported scope, allowing for
    * detection of ambiguous uses of imported names.
    */
   void addImport(Element enclosingElement,
                  Element element,
-                 Import import,
+                 ImportElement import,
                  DiagnosticListener listener) {
     LibraryElementX library = enclosingElement.library;
     Importers importers = library.importers;
 
     String name = element.name;
 
     // The loadLibrary function always shadows existing bindings to that name.
     if (element.isDeferredLoaderGetter) {
       importScope.remove(name);
       // TODO(sigurdm): Print a hint.
     }
     Element existing = importScope.putIfAbsent(name, () => element);
     importers.registerImport(element, import);
 
-    void registerWarnOnUseElement(Import import,
+    void registerWarnOnUseElement(ImportElement import,
                                   MessageKind messageKind,
                                   Element hidingElement,
                                   Element hiddenElement) {
       Uri hiddenUri = hiddenElement.library.canonicalUri;
       Uri hidingUri = hidingElement.library.canonicalUri;
       Element element = new WarnOnUseElementX(
           new WrappedMessage(
               null, // Report on reference to [hidingElement].
               messageKind,
               {'name': name, 'hiddenUri': hiddenUri, 'hidingUri': hidingUri}),
           new WrappedMessage(
               listener.spanFromSpannable(import),
               MessageKind.IMPORTED_HERE,
               {'name': name}),
           enclosingElement, hidingElement);
       importScope[name] = element;
       importers.registerImport(element, import);
     }
 
     if (existing != element) {
-      Import existingImport = importers.getImport(existing);
+      ImportElement existingImport = importers.getImport(existing);
       if (existing.library.isPlatformLibrary &&
           !element.library.isPlatformLibrary) {
         // [existing] is implicitly hidden.
         registerWarnOnUseElement(
             import, MessageKind.HIDDEN_IMPORT, element, existing);
       } else if (!existing.library.isPlatformLibrary &&
                  element.library.isPlatformLibrary) {
         // [element] is implicitly hidden.
-        if (import == null) {
+        if (import.isSynthesized) {
           // [element] is imported implicitly (probably through dart:core).
           registerWarnOnUseElement(
               existingImport, MessageKind.HIDDEN_IMPLICIT_IMPORT,
               existing, element);
         } else {
           registerWarnOnUseElement(
               import, MessageKind.HIDDEN_IMPORT, existing, element);
         }
       } else {
         Element ambiguousElement = new AmbiguousImportX(
             MessageKind.DUPLICATE_IMPORT, {'name': name},
             enclosingElement, existing, element);
         importScope[name] = ambiguousElement;
         importers.registerImport(ambiguousElement, import);
         importers.registerImport(ambiguousElement, existingImport);
       }
     }
   }
 
   Element operator [](String name) => importScope[name];
+
+  void forEach(f(Element element)) => importScope.values.forEach(f);
+}
+
+abstract class LibraryDependencyElementX extends ElementX {
+  final LibraryDependency node;
+  final Uri uri;
+  LibraryElement libraryDependency;
+
+  LibraryDependencyElementX(CompilationUnitElement enclosingElement,
+                            ElementKind kind,
+                            this.node,
+                            this.uri)
+      : super('', kind, enclosingElement);
+
+  @override
+  List<MetadataAnnotation> get metadata => node.metadata;
+
+  void set metadata(value) {
+    // The metadata is stored on [libraryDependency].
+    throw new SpannableAssertionFailure(
+        this, 'Cannot set metadata on a import/export.');
+  }
+
+  @override
+  Token get position => node.getBeginToken();
+
+  SourceSpan get sourcePosition {
+    return new SourceSpan.fromNode(compilationUnit.script.resourceUri, node);
+  }
+
+  String toString() => '$kind($uri)';
+}
+
+class ImportElementX extends LibraryDependencyElementX
+    implements ImportElement {
+  PrefixElementX prefix;
+
+  ImportElementX(CompilationUnitElement enclosingElement, Import node, Uri uri)
+      : super(enclosingElement, ElementKind.IMPORT, node, uri);
+
+  @override
+  Import get node => super.node;
+
+  @override
+  LibraryElement get importedLibrary => libraryDependency;
+
+  @override
+  accept(ElementVisitor visitor, arg) => visitor.visitImportElement(this, arg);
+
+  @override
+  bool get isDeferred => node.isDeferred;
+}
+
+class SyntheticImportElement extends ImportElementX {
+  SyntheticImportElement(CompilationUnitElement enclosingElement, Uri uri)
+      : super(enclosingElement, null, uri);
+
+  @override
+  Token get position => library.position;
+
+  @override
+  bool get isSynthesized => true;
+
+  @override
+  bool get isDeferred => false;
+
+  @override
+  List<MetadataAnnotation> get metadata => const <MetadataAnnotation>[];
+
+  @override
+  SourceSpan get sourcePosition => library.sourcePosition;
+}
+
+
+class ExportElementX extends LibraryDependencyElementX
+    implements ExportElement {
+
+  ExportElementX(CompilationUnitElement enclosingElement, Export node, Uri uri)
+      : super(enclosingElement, ElementKind.EXPORT, node, uri);
+
+  Export get node => super.node;
+
+  @override
+  LibraryElement get exportedLibrary => libraryDependency;
+
+  @override
+  accept(ElementVisitor visitor, arg) => visitor.visitExportElement(this, arg);
 }
 
 class LibraryElementX
     extends ElementX
     with LibraryElementCommon,
          AnalyzableElementX,
          PatchMixin<LibraryElementX>
     implements LibraryElement {
   final Uri canonicalUri;
 
@@ skipping 17 matching lines @@
   /**
    * Link for elements exported either through export declarations or through
    * declaration. This field should not be accessed directly but instead through
    * the [exports] getter.
    *
    * [LibraryDependencyHandler] sets this field through [setExports] when the
    * library is loaded.
    */
   Link<Element> slotForExports;
 
+  List<ImportElement> _imports = <ImportElement>[];
+  List<ExportElement> _exports = <ExportElement>[];
+
   final Map<LibraryDependency, LibraryElement> tagMapping =
       new Map<LibraryDependency, LibraryElement>();
 
   LibraryElementX(Script script,
                   [Uri canonicalUri, LibraryElementX origin])
     : this.canonicalUri =
           ((canonicalUri == null) ? script.readableUri : canonicalUri),
       this.isSynthesized = script.isSynthesized,
       super(script.name, ElementKind.LIBRARY, null) {
     entryCompilationUnit = new CompilationUnitElementX(script, this);
@@ skipping 31 matching lines @@
   }
 
   Iterable<LibraryTag> get tags {
     if (tagsCache == null) {
       tagsCache = tagsBuilder.toList();
       tagsBuilder = null;
     }
     return tagsCache;
   }
 
-  /// Record which element an import or export tag resolved to.
-  void recordResolvedTag(LibraryDependency tag, LibraryElement library) {
-    assert(tagMapping[tag] == null);
-    tagMapping[tag] = library;
+  void addImportDeclaration(ImportElement import) {
+    _imports.add(import);
   }
 
-  LibraryElement getLibraryFromTag(LibraryDependency tag) => tagMapping[tag];
+  Iterable<ImportElement> get imports => _imports;
+
+  void addExportDeclaration(ExportElement export) {
+    _exports.add(export);
+  }
+
+  Iterable<ExportElement> get exports => _exports;
 
   /**
    * Adds [element] to the import scope of this library.
    *
    * If an element by the same name is already in the imported scope, an
    * [ErroneousElement] will be put in the imported scope, allowing for
    * detection of ambiguous uses of imported names.
    */
-  void addImport(Element element, Import import, DiagnosticListener listener) {
+  void addImport(Element element,
+                 ImportElement import,
+                 DiagnosticListener listener) {
     importScope.addImport(this, element, import, listener);
   }
 
   void addMember(Element element, DiagnosticListener listener) {
     localMembers = localMembers.prepend(element);
     addToScope(element, listener);
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
     localScope.add(element, listener);
   }
 
   Element localLookup(String elementName) {
     Element result = localScope.lookup(elementName);
     if (result == null && isPatch) {
       result = origin.localLookup(elementName);
     }
     return result;
   }
 
   /**
    * Returns [:true:] if the export scope has already been computed for this
    * library.
    */
   bool get exportsHandled => slotForExports != null;
 
-  Link<Element> get exports {
-    assert(invariant(this, exportsHandled,
-                     message: 'Exports not handled on $this'));
-    return slotForExports;
-  }
-
   /**
    * Sets the export scope of this library. This method can only be called once.
    */
   void setExports(Iterable<Element> exportedElements) {
     assert(invariant(this, !exportsHandled,
         message: 'Exports already set to $slotForExports on $this'));
     assert(invariant(this, exportedElements != null));
     var builder = new LinkBuilder<Element>();
     for (Element export in exportedElements) {
       builder.addLast(export);
@@ skipping 31 matching lines @@
     // TODO((johnniwinther): How to handle injected elements in the patch
     // library?
     Element result = localScope.lookup(elementName);
     if (result == null && isPatch) {
       return origin.findLocal(elementName);
     }
     return result;
   }
 
   Element findExported(String elementName) {
-    for (Link link = exports; !link.isEmpty; link = link.tail) {
+    assert(invariant(this, exportsHandled,
+                     message: 'Exports not handled on $this'));
+    for (Link link = slotForExports; !link.isEmpty; link = link.tail) {
       Element element = link.head;
       if (element.name == elementName) return element;
     }
     return null;
   }
 
   void forEachExport(f(Element element)) {
-    exports.forEach((Element e) => f(e));
+    assert(invariant(this, exportsHandled,
+                     message: 'Exports not handled on $this'));
+    slotForExports.forEach((Element e) => f(e));
   }
 
-  Link<Import> getImportsFor(Element element) => importers.getImports(element);
+  Iterable<ImportElement> getImportsFor(Element element) {
+    return importers.getImports(element);
+  }
 
-  @override
-  void forEachImport(f(Element element)) {
-    importScope.importScope.values.forEach(f);
-  }
+  void forEachImport(f(Element element)) => importScope.forEach(f);
 
   void forEachLocalMember(f(Element element)) {
     if (isPatch) {
       // Patch libraries traverse both origin and injected members.
       origin.localMembers.forEach(f);
 
       void filterPatch(Element element) {
         if (!element.isPatch) {
           // Do not traverse the patch members.
           f(element);
         }
       }
       localMembers.forEach(filterPatch);
     } else {
       localMembers.forEach(f);
     }
   }
 
   Iterable<Element> getNonPrivateElementsInScope() {
     return localScope.values.where((Element element) {
       // At this point [localScope] only contains members so we don't need
       // to check for foreign or prefix elements.
       return !Name.isPrivateName(element.name);
     });
   }
 
-  bool hasLibraryName() => libraryTag != null;
+  bool get hasLibraryName => libraryTag != null;
 
-  /**
-   * Returns the library name, which is either the name given in the library tag
-   * or the empty string if there is no library tag.
-   */
-  String getLibraryName() {
+  String get libraryName {
     if (libraryTag == null) return '';
     return libraryTag.name.toString();
   }
 
+  String get libraryOrScriptName {
+    if (libraryTag != null) {
+      return libraryTag.name.toString();
+    } else {
+      // Use the file name as script name.
+      String path = canonicalUri.path;
+      return path.substring(path.lastIndexOf('/') + 1);
+    }
+  }
+
   Scope buildScope() => new LibraryScope(this);
 
   String toString() {
     if (origin != null) {
       return 'patch library(${canonicalUri})';
     } else if (patch != null) {
       return 'origin library(${canonicalUri})';
     } else {
       return 'library(${canonicalUri})';
     }
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitLibraryElement(this, arg);
   }
 
   // TODO(johnniwinther): Remove these when issue 18630 is fixed.
   LibraryElementX get patch => super.patch;
   LibraryElementX get origin => super.origin;
 }
 
 class PrefixElementX extends ElementX implements PrefixElement {
   Token firstPosition;
 
   final ImportScope importScope = new ImportScope();
 
-  bool get isDeferred => _deferredImport != null;
+  bool get isDeferred => deferredImport != null;
 
   // Only needed for deferred imports.
-  Import _deferredImport;
-  Import get deferredImport => _deferredImport;
+  final ImportElement deferredImport;
 
-  PrefixElementX(String prefix, Element enclosing, this.firstPosition)
+  PrefixElementX(String prefix,
+                 Element enclosing,
+                 this.firstPosition,
+                 this.deferredImport)
       : super(prefix, ElementKind.PREFIX, enclosing);
 
   bool get isTopLevel => false;
 
   Element lookupLocalMember(String memberName) => importScope[memberName];
 
   DartType computeType(Compiler compiler) => const DynamicType();
 
   Token get position => firstPosition;
 
-  void addImport(Element element, Import import, DiagnosticListener listener) {
+  void addImport(Element element,
+                 ImportElement import,
+                 DiagnosticListener listener) {
     importScope.addImport(this, element, import, listener);
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitPrefixElement(this, arg);
   }
 
-  void markAsDeferred(Import deferredImport) {
-    _deferredImport = deferredImport;
-  }
-
   String toString() => '$kind($name)';
 }
 
 class TypedefElementX extends ElementX
     with AstElementMixin,
          AnalyzableElementX,
          TypeDeclarationElementX<TypedefType>
     implements TypedefElement {
   Typedef cachedNode;
 
@@ skipping 1792 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }