Add ImportElement and ExportElement

pkg/compiler/lib/src/deferred_load.dart

 // Copyright (c) 2014, 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 deferred_load;
 
 import 'common/backend_api.dart' show
     Backend;
 import 'common/tasks.dart' show
     CompilerTask;
 import 'compiler.dart' show
     Compiler;
 import 'constants/values.dart' show
     ConstantValue,
     ConstructedConstantValue,
     DeferredConstantValue,
     StringConstantValue;
 import 'dart_types.dart';
 import 'diagnostics/messages.dart' show
     MessageKind;
 import 'diagnostics/spannable.dart' show
     Spannable;
 import 'elements/elements.dart' show
     AccessorElement,
     AstElement,
     ClassElement,
     Element,
     ElementKind,
     Elements,
+    ExportElement,
     FunctionElement,
+    ImportElement,
     LibraryElement,
     MetadataAnnotation,
     PrefixElement,
     ScopeContainerElement,
     TypedefElement,
     VoidElement;
 import 'js_backend/js_backend.dart' show
     JavaScriptBackend;
 import 'resolution/resolution.dart' show
     AnalyzableElementX;
@@ skipping 179 matching lines @@
   void registerConstantDeferredUse(DeferredConstantValue constant,
                                    PrefixElement prefix) {
     OutputUnit outputUnit = new OutputUnit();
     outputUnit.imports.add(new _DeclaredDeferredImport(prefix.deferredImport));
     _constantToOutputUnit[constant] = outputUnit;
   }
 
   /// Answers whether [element] is explicitly deferred when referred to from
   /// [library].
   bool _isExplicitlyDeferred(Element element, LibraryElement library) {
-    Link<Import> imports = _getImports(element, library);
+    Iterable<ImportElement> imports = _getImports(element, library);
     // If the element is not imported explicitly, it is implicitly imported
     // not deferred.
     if (imports.isEmpty) return false;
     // An element could potentially be loaded by several imports. If all of them
     // is explicitly deferred, we say the element is explicitly deferred.
     // TODO(sigurdm): We might want to give a warning if the imports do not
     // agree.
-    return imports.every((Import import) => import.isDeferred);
+    return imports.every((ImportElement import) => import.isDeferred);
   }
 
   /// Returns a [Link] of every [Import] that imports [element] into [library].
-  Link<Import> _getImports(Element element, LibraryElement library) {
+  Iterable<ImportElement> _getImports(Element element, LibraryElement library) {
     if (element.isClassMember) {
       element = element.enclosingClass;
     }
     if (element.isAccessor) {
       element = (element as AccessorElement).abstractField;
     }
     return library.getImportsFor(element);
   }
 
   /// Finds all elements and constants that [element] depends directly on.
@@ skipping 137 matching lines @@
   Set<LibraryElement> _nonDeferredReachableLibraries(LibraryElement root) {
     Set<LibraryElement> result = new Set<LibraryElement>();
 
     void traverseLibrary(LibraryElement library) {
       if (result.contains(library)) return;
       result.add(library);
 
       iterateTags(LibraryElement library) {
         // TODO(sigurdm): Make helper getLibraryDependencyTags when tags is
         // changed to be a List instead of a Link.
-        for (LibraryTag tag in library.tags) {
-          if (tag is! LibraryDependency) continue;
-          LibraryDependency libraryDependency = tag;
-          if (!(libraryDependency is Import && libraryDependency.isDeferred)) {
-            LibraryElement importedLibrary = library.getLibraryFromTag(tag);
+        for (ImportElement import in library.imports) {
+          if (!import.isDeferred) {
+            LibraryElement importedLibrary = import.importedLibrary;
             traverseLibrary(importedLibrary);
           }
         }
+        for (ExportElement export in library.exports) {
+          LibraryElement exportedLibrary = export.exportedLibrary;
+          traverseLibrary(exportedLibrary);
+        }
       }
 
       iterateTags(library);
       if (library.isPatched) {
         iterateTags(library.implementation);
       }
     }
     traverseLibrary(root);
     result.add(compiler.coreLibrary);
     return result;
@@ skipping 43 matching lines @@
 
       // This call can modify [dependentElements] and [dependentConstants].
       _collectAllElementsAndConstantsResolvedFrom(
           element, dependentElements, dependentConstants, isMirrorUsage);
 
       library = element.library;
     }
 
     for (Element dependency in dependentElements) {
       if (_isExplicitlyDeferred(dependency, library)) {
-        for (Import deferredImport in _getImports(dependency, library)) {
-          _mapDependencies(
-              element: dependency,
+        for (ImportElement deferredImport in _getImports(dependency, library)) {
+          _mapDependencies(element: dependency,
               import: new _DeclaredDeferredImport(deferredImport));
         }
       } else {
         _mapDependencies(element: dependency, import: import);
       }
     }
 
     for (ConstantValue dependency in dependentConstants) {
       if (dependency is DeferredConstantValue) {
         _mapConstantDependencies(dependency,
@@ skipping 10 matching lines @@
   void _addMirrorElements() {
     void mapDependenciesIfResolved(Element element,
                                    _DeferredImport deferredImport) {
       // If an element is the target of a MirrorsUsed annotation but never used
       // It will not be resolved, and we should not call isNeededForReflection.
       // TODO(sigurdm): Unresolved elements should just answer false when
       // asked isNeededForReflection. Instead an internal error is triggered.
       // So we have to filter them out here.
       if (element is AnalyzableElementX && !element.hasTreeElements) return;
       if (compiler.backend.isAccessibleByReflection(element)) {
-        _mapDependencies(element: element, import: deferredImport,
-                         isMirrorUsage: true);
+        _mapDependencies(
+            element: element, import: deferredImport, isMirrorUsage: true);
       }
     }
 
     // For each deferred import we analyze all elements reachable from the
     // imported library through non-deferred imports.
-    handleLibrary(LibraryElement library, _DeferredImport deferredImport) {
+    void handleLibrary(LibraryElement library, _DeferredImport deferredImport) {
       library.implementation.forEachLocalMember((Element element) {
         mapDependenciesIfResolved(element, deferredImport);
       });
 
-      for (MetadataAnnotation metadata in library.metadata) {
-        ConstantValue constant =
-            backend.constants.getConstantValueForMetadata(metadata);
-        if (constant != null) {
-          _mapConstantDependencies(constant, deferredImport);
-        }
-      }
-      for (LibraryTag tag in library.tags) {
-        for (MetadataAnnotation metadata in tag.metadata) {
+      void processMetadata(Element element) {
+        for (MetadataAnnotation metadata in element.metadata) {
           ConstantValue constant =
               backend.constants.getConstantValueForMetadata(metadata);
           if (constant != null) {
             _mapConstantDependencies(constant, deferredImport);
           }
         }
       }
+
+      processMetadata(library);
+      library.imports.forEach(processMetadata);
+      library.exports.forEach(processMetadata);
     }
 
     for (_DeferredImport deferredImport in _allDeferredImports.keys) {
       LibraryElement deferredLibrary = _allDeferredImports[deferredImport];
       for (LibraryElement library in
           _nonDeferredReachableLibraries(deferredLibrary)) {
         handleLibrary(library, deferredImport);
       }
     }
   }
@@ skipping 163 matching lines @@
     // import "lib.dart" as a;
     // import "lib2.dart" deferred as a;
     // 4.
     // import "lib.dart" as a;
     // import "lib2.dart" as a;
     // We must be able to signal error for case 1, 2, 3, but accept case 4.
 
     // The prefixes that have been used by any imports in this library.
     Setlet<String> usedPrefixes = new Setlet<String>();
     // The last deferred import we saw with a given prefix (if any).
-    Map<String, Import> prefixDeferredImport = new Map<String, Import>();
+    Map<String, ImportElement> prefixDeferredImport =
+        new Map<String, ImportElement>();
     for (LibraryElement library in compiler.libraryLoader.libraries) {
       compiler.withCurrentElement(library, () {
         prefixDeferredImport.clear();
         usedPrefixes.clear();
         // TODO(sigurdm): Make helper getLibraryImportTags when tags is a List
         // instead of a Link.
-        for (LibraryTag tag in library.tags) {
-          if (tag is! Import) continue;
-          Import import = tag;
-
+        for (ImportElement import in library.imports) {
           /// Give an error if the old annotation-based syntax has been used.
           List<MetadataAnnotation> metadataList = import.metadata;
           if (metadataList != null) {
             for (MetadataAnnotation metadata in metadataList) {
               metadata.ensureResolved(compiler);
               ConstantValue value =
                   compiler.constants.getConstantValue(metadata.constant);
               Element element = value.getType(compiler.coreTypes).element;
               if (element == deferredLibraryClass) {
                  compiler.reportError(
                      import, MessageKind.DEFERRED_OLD_SYNTAX);
               }
             }
           }
 
           String prefix = (import.prefix != null)
-              ? import.prefix.toString()
+              ? import.prefix.name
               : null;
           // The last import we saw with the same prefix.
-          Import previousDeferredImport = prefixDeferredImport[prefix];
+          ImportElement previousDeferredImport = prefixDeferredImport[prefix];
           if (import.isDeferred) {
             _DeferredImport key = new _DeclaredDeferredImport(import);
-            LibraryElement importedLibrary = library.getLibraryFromTag(import);
+            LibraryElement importedLibrary = import.importedLibrary;
             _allDeferredImports[key] = importedLibrary;
 
             if (prefix == null) {
               compiler.reportError(import,
                   MessageKind.DEFERRED_LIBRARY_WITHOUT_PREFIX);
             } else {
               prefixDeferredImport[prefix] = import;
               _deferredImportDescriptions[key] =
                   new ImportDescription(import, library, compiler);
             }
             isProgramSplit = true;
             lastDeferred = import;
           }
           if (prefix != null) {
             if (previousDeferredImport != null ||
                 (import.isDeferred && usedPrefixes.contains(prefix))) {
-              Import failingImport = (previousDeferredImport != null)
+              ImportElement failingImport = (previousDeferredImport != null)
                   ? previousDeferredImport
                   : import;
               compiler.reportError(failingImport.prefix,
                   MessageKind.DEFERRED_LIBRARY_DUPLICATE_PREFIX);
             }
             usedPrefixes.add(prefix);
           }
         }
       });
     }
@@ skipping 93 matching lines @@
   }
 }
 
 class ImportDescription {
   /// Relative uri to the importing library.
   final String importingUri;
   /// The prefix this import is imported as.
   final String prefix;
   final LibraryElement _importingLibrary;
 
-  ImportDescription(Import import,
+  ImportDescription(ImportElement import,
                     LibraryElement importingLibrary,
                     Compiler compiler)
       : importingUri = uri_extras.relativize(
           compiler.mainApp.canonicalUri,
           importingLibrary.canonicalUri, false),
-        prefix = import.prefix.source,
+        prefix = import.prefix.name,
         _importingLibrary = importingLibrary;
 
   String get importingLibraryName {
-    String libraryName = _importingLibrary.getLibraryName();
-    return libraryName == ""
-      ? "<unnamed>"
-      : libraryName;
+    return _importingLibrary.hasLibraryName
+        ? _importingLibrary.libraryName : "<unnamed>";
   }
 }
 
 /// A node in the deferred import graph.
 ///
 /// This class serves as the root node; the 'import' of the main library.
 class _DeferredImport {
   const _DeferredImport();
 
   /// Computes a suggestive name for this import.
   String computeImportDeferName(Compiler compiler) => 'main';
 }
 
 /// A node in the deferred import graph defined by a deferred import directive.
 class _DeclaredDeferredImport implements _DeferredImport {
-  final Import declaration;
+  final ImportElement declaration;
 
   _DeclaredDeferredImport(this.declaration);
 
   @override
   String computeImportDeferName(Compiler compiler) {
     String result;
     if (declaration.isDeferred) {
-      result = declaration.prefix.toString();
+      result = declaration.prefix.name;
     } else {
       // Finds the first argument to the [DeferredLibrary] annotation
       List<MetadataAnnotation> metadatas = declaration.metadata;
       assert(metadatas != null);
       for (MetadataAnnotation metadata in metadatas) {
         metadata.ensureResolved(compiler);
         ConstantValue value =
             compiler.constants.getConstantValue(metadata.constant);
         Element element = value.getType(compiler.coreTypes).element;
         if (element == compiler.deferredLibraryClass) {
           ConstructedConstantValue constant = value;
           StringConstantValue s = constant.fields.values.single;
           result = s.primitiveValue.slowToString();
           break;
         }
       }
     }
     assert(result != null);
     return result;
   }
 
   bool operator ==(other) {
     if (other is! _DeclaredDeferredImport) return false;
     return declaration == other.declaration;
   }
 
   int get hashCode => declaration.hashCode * 17;
 }