dartfmt pkg/compiler

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.dart';
-import 'common/names.dart' show
-    Uris;
-import 'common/tasks.dart' show
-    CompilerTask;
-import 'compiler.dart' show
-    Compiler;
-import 'elements/elements.dart' show
-    CompilationUnitElement,
-    Element,
-    ImportElement,
-    ExportElement,
-    LibraryElement,
-    PrefixElement;
-import 'elements/modelx.dart' show
-    CompilationUnitElementX,
-    DeferredLoaderGetterElementX,
-    ErroneousElementX,
-    ExportElementX,
-    ImportElementX,
-    LibraryElementX,
-    LibraryDependencyElementX,
-    PrefixElementX,
-    SyntheticImportElement;
+import 'common/names.dart' show Uris;
+import 'common/tasks.dart' show CompilerTask;
+import 'compiler.dart' show Compiler;
+import 'elements/elements.dart'
+    show
+        CompilationUnitElement,
+        Element,
+        ImportElement,
+        ExportElement,
+        LibraryElement,
+        PrefixElement;
+import 'elements/modelx.dart'
+    show
+        CompilationUnitElementX,
+        DeferredLoaderGetterElementX,
+        ErroneousElementX,
+        ExportElementX,
+        ImportElementX,
+        LibraryElementX,
+        LibraryDependencyElementX,
+        PrefixElementX,
+        SyntheticImportElement;
 import 'environment.dart';
 import 'script.dart';
 import 'serialization/serialization.dart' show LibraryDeserializer;
 import 'tree/tree.dart';
-import 'util/util.dart' show
-    Link,
-    LinkBuilder;
+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.
  *
  * ## User URI ##
  *
  * A 'user URI' is a URI provided by the user in code and as the main entry URI
@@ skipping 76 matching lines @@
  * that these imports
  *
  *     import 'package:foo.dart' as a;
  *     import 'packages/foo.dart' as b;
  *
  * do _not_ resolve to the same library when the package root URI happens to
  * point to the 'packages' folder.
  *
  */
 abstract class LibraryLoaderTask implements CompilerTask {
-  factory LibraryLoaderTask(Compiler compiler,
+  factory LibraryLoaderTask(
+      Compiler compiler,
       ResolvedUriTranslator uriTranslator,
       ScriptLoader scriptLoader,
       ElementScanner scriptScanner,
       LibraryDeserializer deserializer,
       LibraryLoaderListener listener,
       Environment environment) = _LibraryLoaderTask;
 
   /// Returns all libraries that have been loaded.
   Iterable<LibraryElement> get libraries;
 
   /// Looks up the library with the [canonicalUri].
   LibraryElement lookupLibrary(Uri canonicalUri);
 
   /// Loads the library specified by the [resolvedUri] and returns its
   /// [LibraryElement].
   ///
   /// If the library is not already loaded, the method creates the
   /// [LibraryElement] for the library and computes the import/export scope,
   /// loading and computing the import/export scopes of all required libraries
   /// in the process. The method handles cyclic dependency between libraries.
   ///
   /// If [skipFileWithPartOfTag] is `true`, `null` is returned if the
   /// compilation unit for [resolvedUri] contains a `part of` tag. This is only
   /// used for analysis through [Compiler.analyzeUri].
-  Future<LibraryElement> loadLibrary(
-      Uri resolvedUri,
+  Future<LibraryElement> loadLibrary(Uri resolvedUri,
       {bool skipFileWithPartOfTag: false});
 
   /// Reset the library loader task to prepare for compilation. If provided,
   /// libraries matching [reuseLibrary] are reused.
   ///
   /// This method is used for incremental compilation.
   void reset({bool reuseLibrary(LibraryElement library)});
 
   /// Asynchronous version of [reset].
   Future resetAsync(Future<bool> reuseLibrary(LibraryElement library));
@@ skipping 113 matching lines @@
   final LibraryDeserializer deserializer;
 
   /// Hooks to inform others about progress done by this loader.
   // TODO(sigmund): move away from this.
   final LibraryLoaderListener listener;
 
   /// Definitions provided via the `-D` command line flags. Used to resolve
   /// conditional imports.
   final Environment environment;
 
-  _LibraryLoaderTask(
-      Compiler compiler, this.uriTranslator, this.scriptLoader,
+  _LibraryLoaderTask(Compiler compiler, this.uriTranslator, this.scriptLoader,
       this.scanner, this.deserializer, this.listener, this.environment)
       // TODO(sigmund): make measurements separate from compiler
       : super(compiler);
 
   String get name => 'LibraryLoader';
 
   final Map<Uri, LibraryElement> libraryCanonicalUriMap =
       new Map<Uri, LibraryElement>();
   final Map<Uri, LibraryElement> libraryResourceUriMap =
       new Map<Uri, LibraryElement>();
@@ skipping 40 matching lines @@
   Future resetAsync(Future<bool> reuseLibrary(LibraryElement library)) {
     return measure(() {
       assert(currentHandler == null);
 
       wrapper(lib) => reuseLibrary(lib).then((reuse) => reuse ? lib : null);
       List<Future<LibraryElement>> reusedLibrariesFuture =
           // TODO(sigmund): make measurements separate from compiler
           compiler.reuseLibraryTask.measure(
               () => libraryCanonicalUriMap.values.map(wrapper).toList());
 
-      return Future.wait(reusedLibrariesFuture).then(
-          (List<LibraryElement> reusedLibraries) {
-            resetImplementation(reusedLibraries.where((e) => e != null));
-          });
+      return Future
+          .wait(reusedLibrariesFuture)
+          .then((List<LibraryElement> reusedLibraries) {
+        resetImplementation(reusedLibraries.where((e) => e != null));
+      });
     });
   }
 
   /// Insert [library] in the internal maps. Used for compiler reuse.
   void mapLibrary(LibraryElement library) {
     libraryCanonicalUriMap[library.canonicalUri] = library;
 
     Uri resourceUri = library.entryCompilationUnit.script.resourceUri;
     libraryResourceUriMap[resourceUri] = library;
 
     if (library.hasLibraryName) {
       String name = library.libraryName;
       libraryNames[name] = library;
     }
   }
 
   Future<LibraryElement> loadLibrary(Uri resolvedUri,
       {bool skipFileWithPartOfTag: false}) {
     return measure(() {
       assert(currentHandler == null);
       // TODO(johnniwinther): Ensure that currentHandler correctly encloses the
       // loading of a library cluster.
       currentHandler = new LibraryDependencyHandler(this);
       return createLibrary(currentHandler, null, resolvedUri,
-          skipFileWithPartOfTag: skipFileWithPartOfTag)
+              skipFileWithPartOfTag: skipFileWithPartOfTag)
           .then((LibraryElement library) {
         if (library == null) {
           currentHandler = null;
           return null;
         }
         return reporter.withCurrentElement(library, () {
           return measure(() {
             currentHandler.computeExports();
-            LoadedLibraries loadedLibraries = new _LoadedLibraries(
-                library,
-                currentHandler.newLibraries,
-                currentHandler.nodeMap,
-                this);
+            LoadedLibraries loadedLibraries = new _LoadedLibraries(library,
+                currentHandler.newLibraries, currentHandler.nodeMap, this);
             currentHandler = null;
-            return listener.onLibrariesLoaded(loadedLibraries)
+            return listener
+                .onLibrariesLoaded(loadedLibraries)
                 .then((_) => library);
           });
         });
       });
     });
   }
 
   /**
    * Processes the library tags in [library].
    *
    * The imported/exported libraries are loaded and processed recursively but
    * the import/export scopes are not set up.
    */
-  Future processLibraryTags(LibraryDependencyHandler handler,
-                            LibraryElementX library) {
+  Future processLibraryTags(
+      LibraryDependencyHandler handler, LibraryElementX library) {
     TagState tagState = new TagState();
 
     bool importsDartCore = false;
     LinkBuilder<LibraryDependencyElementX> libraryDependencies =
         new LinkBuilder<LibraryDependencyElementX>();
     Uri base = library.entryCompilationUnit.script.readableUri;
 
     return Future.forEach(library.tags, (LibraryTag tag) {
       return reporter.withCurrentElement(library, () {
-
         Uri computeUri(LibraryDependency node) {
           StringNode uriNode = node.uri;
           if (node.conditionalUris != null) {
             for (ConditionalUri conditionalUri in node.conditionalUris) {
               String key = conditionalUri.key.slowNameString;
               String value = conditionalUri.value == null
                   ? "true"
                   : conditionalUri.value.dartString.slowToString();
               String actual = environment.valueOf(key);
               if (value == actual) {
                 uriNode = conditionalUri.uri;
                 break;
               }
             }
           }
           String tagUriString = uriNode.dartString.slowToString();
           try {
             return Uri.parse(tagUriString);
           } on FormatException {
             reporter.reportErrorMessage(
-                node.uri,
-                MessageKind.INVALID_URI, {'uri': tagUriString});
+                node.uri, MessageKind.INVALID_URI, {'uri': tagUriString});
             return null;
           }
         }
 
         if (tag.isImport) {
           Uri uri = computeUri(tag);
           if (uri == null) {
             // Skip this erroneous import.
             return new Future.value();
           }
@@ skipping 38 matching lines @@
     }).then((_) {
       return listener.onLibraryScanned(library, handler);
     }).then((_) {
       return reporter.withCurrentElement(library, () {
         checkDuplicatedLibraryName(library);
 
         // Import dart:core if not already imported.
         if (!importsDartCore && library.canonicalUri != Uris.dart_core) {
           return createLibrary(handler, null, Uris.dart_core)
               .then((LibraryElement coreLibrary) {
-            handler.registerDependency(library,
+            handler.registerDependency(
+                library,
                 new SyntheticImportElement(
                     library.entryCompilationUnit, Uris.dart_core),
                 coreLibrary);
           });
         }
       });
     }).then((_) {
       return Future.forEach(libraryDependencies.toList(),
           (LibraryDependencyElementX libraryDependency) {
         return reporter.withCurrentElement(library, () {
           return registerLibraryFromImportExport(
               handler, library, libraryDependency);
         });
       });
     });
   }
 
   void checkDuplicatedLibraryName(LibraryElement library) {
     if (library.isInternalLibrary) return;
     Uri resourceUri = library.entryCompilationUnit.script.resourceUri;
     LibraryElement existing =
         libraryResourceUriMap.putIfAbsent(resourceUri, () => library);
     if (!identical(existing, library)) {
       if (library.hasLibraryName) {
         reporter.withCurrentElement(library, () {
           reporter.reportWarningMessage(
-              library,
-              MessageKind.DUPLICATED_LIBRARY_RESOURCE,
-              {'libraryName': library.libraryName,
-               'resourceUri': resourceUri,
-               'canonicalUri1': library.canonicalUri,
-               'canonicalUri2': existing.canonicalUri});
+              library, MessageKind.DUPLICATED_LIBRARY_RESOURCE, {
+            'libraryName': library.libraryName,
+            'resourceUri': resourceUri,
+            'canonicalUri1': library.canonicalUri,
+            'canonicalUri2': existing.canonicalUri
+          });
         });
       } else {
-        reporter.reportHintMessage(
-            library,
-            MessageKind.DUPLICATED_RESOURCE,
-            {'resourceUri': resourceUri,
-             'canonicalUri1': library.canonicalUri,
-             'canonicalUri2': existing.canonicalUri});
+        reporter.reportHintMessage(library, MessageKind.DUPLICATED_RESOURCE, {
+          'resourceUri': resourceUri,
+          'canonicalUri1': library.canonicalUri,
+          'canonicalUri2': existing.canonicalUri
+        });
       }
     } else if (library.hasLibraryName) {
       String name = library.libraryName;
       existing = libraryNames.putIfAbsent(name, () => library);
       if (!identical(existing, library)) {
         reporter.withCurrentElement(library, () {
-          reporter.reportWarningMessage(
-              library,
-              MessageKind.DUPLICATED_LIBRARY_NAME,
-              {'libraryName': name});
+          reporter.reportWarningMessage(library,
+              MessageKind.DUPLICATED_LIBRARY_NAME, {'libraryName': name});
         });
         reporter.withCurrentElement(existing, () {
-          reporter.reportWarningMessage(
-              existing,
-              MessageKind.DUPLICATED_LIBRARY_NAME,
-              {'libraryName': name});
+          reporter.reportWarningMessage(existing,
+              MessageKind.DUPLICATED_LIBRARY_NAME, {'libraryName': name});
         });
       }
     }
   }
 
   /**
    * Handle a part tag in the scope of [library]. The [resolvedUri] given is
    * used as is, any URI resolution should be done beforehand.
    */
   Future scanPart(Part part, Uri resolvedUri, LibraryElement library) {
     if (!resolvedUri.isAbsolute) throw new ArgumentError(resolvedUri);
     Uri readableUri = uriTranslator.translate(library, resolvedUri, part);
     if (readableUri == null) return new Future.value();
     return reporter.withCurrentElement(library, () {
       return scriptLoader.readScript(readableUri, part).then((Script script) {
         if (script == null) return;
         createUnitSync(script, library);
       });
     });
   }
 
   /**
    * Handle an import/export tag by loading the referenced library and
    * registering its dependency in [handler] for the computation of the import/
    * export scope. If the tag does not contain a valid URI, then its dependency
    * is not registered in [handler].
    */
-  Future<Null> registerLibraryFromImportExport(
-      LibraryDependencyHandler handler,
-      LibraryElement library,
-      LibraryDependencyElementX libraryDependency) {
+  Future<Null> registerLibraryFromImportExport(LibraryDependencyHandler handler,
+      LibraryElement library, LibraryDependencyElementX libraryDependency) {
     Uri base = library.canonicalUri;
     Uri resolvedUri = base.resolveUri(libraryDependency.uri);
     return createLibrary(handler, library, resolvedUri, node: libraryDependency)
         .then((LibraryElement loadedLibrary) {
-          if (loadedLibrary == null) return;
-          reporter.withCurrentElement(library, () {
-            libraryDependency.libraryDependency = loadedLibrary;
-            handler.registerDependency(
-                library, libraryDependency, loadedLibrary);
-          });
-        });
+      if (loadedLibrary == null) return;
+      reporter.withCurrentElement(library, () {
+        libraryDependency.libraryDependency = loadedLibrary;
+        handler.registerDependency(library, libraryDependency, loadedLibrary);
+      });
+    });
   }
 
   /// Loads the deserialized [library] with the [handler].
   ///
   /// All libraries imported or exported transitively from [library] will be
   /// loaded as well.
   Future<LibraryElement> loadDeserializedLibrary(
-      LibraryDependencyHandler handler,
-      LibraryElement library) {
+      LibraryDependencyHandler handler, LibraryElement library) {
     libraryCanonicalUriMap[library.canonicalUri] = library;
     handler.registerNewLibrary(library);
     return listener.onLibraryScanned(library, handler).then((_) {
       return Future.forEach(library.imports, (ImportElement import) {
         return createLibrary(handler, library, import.uri);
       }).then((_) {
         return Future.forEach(library.exports, (ExportElement export) {
           return createLibrary(handler, library, export.uri);
         }).then((_) => library);
       });
     });
   }
 
-  Future<Script> _readScript(Spannable spannable,
-      Uri readableUri, Uri resolvedUri) {
+  Future<Script> _readScript(
+      Spannable spannable, Uri readableUri, Uri resolvedUri) {
     if (readableUri == null) {
       return new Future.value(new Script.synthetic(resolvedUri));
     } else {
       return scriptLoader.readScript(readableUri, spannable);
     }
   }
 
   /**
    * Create (or reuse) a library element for the library specified by the
    * [resolvedUri].
    *
    * If a new library is created, the [handler] is notified.
    */
-  Future<LibraryElement> createLibrary(
-      LibraryDependencyHandler handler,
-      LibraryElement importingLibrary,
-      Uri resolvedUri,
-      {Spannable node,
-       bool skipFileWithPartOfTag: false}) {
+  Future<LibraryElement> createLibrary(LibraryDependencyHandler handler,
+      LibraryElement importingLibrary, Uri resolvedUri,
+      {Spannable node, bool skipFileWithPartOfTag: false}) {
     Uri readableUri =
         uriTranslator.translate(importingLibrary, resolvedUri, node);
     LibraryElement library = libraryCanonicalUriMap[resolvedUri];
     if (library != null) {
       return new Future.value(library);
     }
     library = deserializer.readLibrary(resolvedUri);
     if (library != null) {
       return loadDeserializedLibrary(handler, library);
     }
@@ skipping 17 matching lines @@
                     compilationUnit.partTag, MessageKind.MAIN_HAS_PART_OF));
             reporter.reportError(error);
           } else {
             DiagnosticMessage error = reporter.withCurrentElement(
                 compilationUnit,
                 () => reporter.createMessage(
                     compilationUnit.partTag, MessageKind.IMPORT_PART_OF));
             DiagnosticMessage info = reporter.withCurrentElement(
                 importingLibrary,
                 () => reporter.createMessage(
-                    node,
-                    MessageKind.IMPORT_PART_OF_HERE));
+                    node, MessageKind.IMPORT_PART_OF_HERE));
             reporter.reportError(error, [info]);
           }
         }
         return processLibraryTags(handler, element).then((_) {
           reporter.withCurrentElement(element, () {
             handler.registerLibraryExports(element);
           });
           return element;
         });
       });
     });
   }
 
-  LibraryElement createLibrarySync(LibraryDependencyHandler handler,
-      Script script, Uri resolvedUri) {
+  LibraryElement createLibrarySync(
+      LibraryDependencyHandler handler, Script script, Uri resolvedUri) {
     LibraryElement element = new LibraryElementX(script, resolvedUri);
     return reporter.withCurrentElement(element, () {
       if (handler != null) {
         handler.registerNewLibrary(element);
         libraryCanonicalUriMap[resolvedUri] = element;
       }
       scanner.scanLibrary(element);
       return element;
     });
   }
 
   CompilationUnitElement createUnitSync(Script script, LibraryElement library) {
     CompilationUnitElementX unit = new CompilationUnitElementX(script, library);
     reporter.withCurrentElement(unit, () {
       scanner.scanUnit(unit);
       if (unit.partTag == null && !script.isSynthesized) {
         reporter.reportErrorMessage(unit, MessageKind.MISSING_PART_OF_TAG);
       }
     });
     return unit;
   }
 }
 
-
 /// A state machine for checking script tags come in the correct order.
 class TagState {
   /// Initial state.
   static const int NO_TAG_SEEN = 0;
 
   /// Passed to [checkTag] when a library declaration (the syntax "library
   /// name;") has been seen. Not an actual state.
   static const int LIBRARY = 1;
 
   /// The state after the first library declaration.
   static const int AFTER_LIBRARY_DECLARATION = 2;
 
   /// The state after a import or export declaration has been seen, but before
   /// a part tag has been seen.
   static const int IMPORT_OR_EXPORT = 3;
 
   /// The state after a part tag has been seen.
   static const int PART = 4;
 
   /// Encodes transition function for state machine.
   static const List<int> NEXT = const <int>[
-      NO_TAG_SEEN,
-      AFTER_LIBRARY_DECLARATION, // Only one library tag is allowed.
-      IMPORT_OR_EXPORT,
-      IMPORT_OR_EXPORT,
-      PART,
+    NO_TAG_SEEN,
+    AFTER_LIBRARY_DECLARATION, // Only one library tag is allowed.
+    IMPORT_OR_EXPORT,
+    IMPORT_OR_EXPORT,
+    PART,
   ];
 
   int tagState = TagState.NO_TAG_SEEN;
 
   bool hasLibraryDeclaration = false;
 
   /// If [value] is less than [tagState] complain. Regardless, update
   /// [tagState] using transition function for state machine.
   void checkTag(int value, LibraryTag tag, DiagnosticReporter reporter) {
     if (tagState > value) {
@@ skipping 34 matching lines @@
  */
 class ImportLink {
   final ImportElementX import;
   final LibraryElement importedLibrary;
 
   ImportLink(this.import, this.importedLibrary);
 
   /**
    * Imports the library into the [importingLibrary].
    */
-  void importLibrary(DiagnosticReporter reporter,
-                     LibraryElementX importingLibrary) {
-    assert(invariant(importingLibrary,
-                     importedLibrary.exportsHandled,
-                     message: 'Exports not handled on $importedLibrary'));
+  void importLibrary(
+      DiagnosticReporter reporter, LibraryElementX importingLibrary) {
+    assert(invariant(importingLibrary, importedLibrary.exportsHandled,
+        message: 'Exports not handled on $importedLibrary'));
     Import tag = import.node;
-    CombinatorFilter combinatorFilter =
-        new CombinatorFilter.fromTag(tag);
+    CombinatorFilter combinatorFilter = new CombinatorFilter.fromTag(tag);
     if (tag != null && tag.prefix != null) {
       String prefix = tag.prefix.source;
       Element existingElement = importingLibrary.find(prefix);
       PrefixElementX prefixElement;
       if (existingElement == null || !existingElement.isPrefix) {
         prefixElement = new PrefixElementX(
             prefix,
             importingLibrary.entryCompilationUnit,
             tag.getBeginToken(),
             tag.isDeferred ? import : null);
       } else {
         prefixElement = existingElement;
       }
       importingLibrary.addToScope(prefixElement, reporter);
       importedLibrary.forEachExport((Element element) {
         if (combinatorFilter.exclude(element)) return;
         prefixElement.addImport(element, import, reporter);
       });
       import.prefix = prefixElement;
       if (prefixElement.isDeferred) {
         prefixElement.addImport(
-            new DeferredLoaderGetterElementX(prefixElement),
-            import, reporter);
+            new DeferredLoaderGetterElementX(prefixElement), import, reporter);
       }
     } else {
       importedLibrary.forEachExport((Element element) {
         reporter.withCurrentElement(importingLibrary, () {
           if (combinatorFilter.exclude(element)) return;
           importingLibrary.addImport(element, import, reporter);
         });
       });
     }
   }
@@ skipping 32 matching lines @@
  * exports performed in [LibraryDependencyHandler.computeExports].
  */
 class LibraryDependencyNode {
   final LibraryElementX library;
 
   // TODO(ahe): Remove [hashCodeCounter] and [hashCode] when
   // VM implementation of Object.hashCode is not slow.
   final int hashCode = ++hashCodeCounter;
   static int hashCodeCounter = 0;
 
-
   /**
    * 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 Link<ImportLink>();
 
   /// A linked list of all libraries directly exported by [library].
   Link<LibraryElement> exports = const Link<LibraryElement>();
 
@@ skipping 21 matching lines @@
    */
   Map<Element, Link<ExportElement>> pendingExportMap =
       <Element, Link<ExportElement>>{};
 
   LibraryDependencyNode(this.library);
 
   /**
    * Registers that the library of this node imports [importLibrary] through the
    * [import] tag.
    */
-  void registerImportDependency(ImportElementX import,
-                                LibraryElement importedLibrary) {
+  void registerImportDependency(
+      ImportElementX import, 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(ExportElementX export,
-                                LibraryDependencyNode exportingLibraryNode) {
+  void registerExportDependency(
+      ExportElementX export, LibraryDependencyNode exportingLibraryNode) {
     // Register the exported library in the exporting library node.
     exportingLibraryNode.exports =
         exportingLibraryNode.exports.prepend(library);
     // Register the export in the exported library node.
     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() {
     for (Element element in library.getNonPrivateElementsInScope()) {
       pendingExportMap[element] = const Link<ExportElement>();
     }
   }
 
   /// 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(DiagnosticReporter reporter,
-                              LibraryElement exportedLibraryElement,
-                              ExportElementX export,
-                              CombinatorFilter filter) {
+  void registerHandledExports(
+      DiagnosticReporter reporter,
+      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>());
+        Link<ExportElement> exports = pendingExportMap.putIfAbsent(
+            exportedElement, () => const Link<ExportElement>());
         pendingExportMap[exportedElement] = exports.prepend(export);
       }
     });
     if (!reporter.options.suppressHints) {
       reporter.withCurrentElement(library, () {
         checkLibraryDependency(reporter, export.node, exportedLibraryElement);
       });
     }
   }
 
@@ skipping 20 matching lines @@
     Map<Element, Link<ExportElement>> pendingExports =
         new Map<Element, Link<ExportElement>>.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.
    */
-  Element addElementToExportScope(
-      DiagnosticReporter reporter,
-      Element element,
+  Element addElementToExportScope(DiagnosticReporter reporter, Element element,
       Link<ExportElement> exports) {
     String name = element.name;
     DiagnosticMessage error;
     List<DiagnosticMessage> infos = <DiagnosticMessage>[];
 
     void createDuplicateExportMessage(
-        Element duplicate,
-        Link<ExportElement> duplicateExports) {
+        Element duplicate, Link<ExportElement> duplicateExports) {
       assert(invariant(library, !duplicateExports.isEmpty,
           message: "No export for $duplicate from ${duplicate.library} "
-                   "in $library."));
+              "in $library."));
       reporter.withCurrentElement(library, () {
         for (ExportElement export in duplicateExports) {
           if (error == null) {
             error = reporter.createMessage(
-                export,
-                MessageKind.DUPLICATE_EXPORT,
-                {'name': name});
+                export, MessageKind.DUPLICATE_EXPORT, {'name': name});
           } else {
             infos.add(reporter.createMessage(
-                export,
-                MessageKind.DUPLICATE_EXPORT_CONT,
-                {'name': name}));
+                export, MessageKind.DUPLICATE_EXPORT_CONT, {'name': name}));
           }
         }
       });
     }
 
     void createDuplicateExportDeclMessage(
-        Element duplicate,
-        Link<ExportElement> duplicateExports) {
+        Element duplicate, Link<ExportElement> duplicateExports) {
       assert(invariant(library, !duplicateExports.isEmpty,
           message: "No export for $duplicate from ${duplicate.library} "
-                   "in $library."));
+              "in $library."));
       infos.add(reporter.createMessage(
           duplicate,
-              MessageKind.DUPLICATE_EXPORT_DECL,
+          MessageKind.DUPLICATE_EXPORT_DECL,
           {'name': name, 'uriString': duplicateExports.head.uri}));
     }
 
     Element existingElement = exportScope[name];
     if (existingElement != null && existingElement != element) {
       if (existingElement.isMalformed) {
         createDuplicateExportMessage(element, exports);
         createDuplicateExportDeclMessage(element, exports);
         element = existingElement;
       } else if (existingElement.library == library) {
@@ skipping 65 matching lines @@
     });
     for (ExportLink exportLink in dependencies) {
       reporter.withCurrentElement(exportLink.exportNode.library, () {
         checkLibraryDependency(reporter, exportLink.export.node, library);
       });
     }
   }
 
   /// Check that all names in the show/hide combinators of [tag] are in the
   /// export scope of [library].
-  void checkLibraryDependency(
-      DiagnosticReporter reporter,
-      LibraryDependency tag,
-      LibraryElement library) {
+  void checkLibraryDependency(DiagnosticReporter reporter,
+      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) {
           if (combinator.isHide) {
             if (library.isPackageLibrary &&
                 reporter.options.hidePackageWarnings) {
               // Only report hide hint on packages if we show warnings on these:
               // The hide may be non-empty in some versions of the package, in
               // which case you shouldn't remove the combinator.
               continue;
             }
-            reporter.reportHintMessage(
-                identifier,
-                MessageKind.EMPTY_HIDE,
-                {'uri': library.canonicalUri,
-                 'name': name});
+            reporter.reportHintMessage(identifier, MessageKind.EMPTY_HIDE,
+                {'uri': library.canonicalUri, 'name': name});
           } else {
-            reporter.reportHintMessage(
-                identifier,
-                MessageKind.EMPTY_SHOW,
-                {'uri': library.canonicalUri,
-                 'name': name});
+            reporter.reportHintMessage(identifier, 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 33 matching lines @@
       // elements.  So we must propagate local elements first.  We
       // ensure this by pulling the pending exports before
       // propagating.  This enforces that we handle exports
       // breadth-first, with locally defined elements being level 0.
       nodeMap.forEach((_, LibraryDependencyNode node) {
         Map<Element, Link<ExportElement>> pendingExports =
             node.pullPendingExports();
         tasks[node] = pendingExports;
       });
       tasks.forEach((LibraryDependencyNode node,
-                     Map<Element, Link<ExportElement>> pendingExports) {
+          Map<Element, Link<ExportElement>> pendingExports) {
         pendingExports.forEach((Element element, Link<ExportElement> exports) {
           element = node.addElementToExportScope(reporter, element, exports);
           if (node.propagateElement(element)) {
             changed = true;
           }
         });
       });
     }
 
     // Setup export scopes. These have to be set before computing the import
@@ skipping 10 matching lines @@
 
     if (!reporter.options.suppressHints) {
       nodeMap.forEach((LibraryElement library, LibraryDependencyNode node) {
         node.checkCombinators(reporter);
       });
     }
   }
 
   /// Registers that [library] depends on [loadedLibrary] through
   /// [libraryDependency].
-  void registerDependency(LibraryElementX library,
-                          LibraryDependencyElementX libraryDependency,
-                          LibraryElement loadedLibrary) {
+  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(
             reporter, loadedLibrary, libraryDependency, combinatorFilter);
         return;
@@ skipping 54 matching lines @@
 
   /// Applies all imports chains of [uri] in this bulk to [callback].
   ///
   /// The argument [importChainReversed] to [callback] contains the chain of
   /// imports uris that lead to importing [uri] starting in [uri] and ending in
   /// [rootUri].
   ///
   /// [callback] is called once for each chain of imports leading to [uri] until
   /// [callback] returns `false`.
   void forEachImportChain(Uri uri,
-                          {bool callback(Link<Uri> importChainReversed)});
+      {bool callback(Link<Uri> importChainReversed)});
 }
 
 class _LoadedLibraries implements LoadedLibraries {
   final _LibraryLoaderTask task;
   final LibraryElement rootLibrary;
   final Map<Uri, LibraryElement> loadedLibraries = <Uri, LibraryElement>{};
   final Map<LibraryElement, LibraryDependencyNode> nodeMap;
 
-  _LoadedLibraries(
-      this.rootLibrary,
-      Iterable<LibraryElement> libraries,
-      this.nodeMap,
-      this.task) {
+  _LoadedLibraries(this.rootLibrary, Iterable<LibraryElement> libraries,
+      this.nodeMap, this.task) {
     libraries.forEach((LibraryElement loadedLibrary) {
       loadedLibraries[loadedLibrary.canonicalUri] = loadedLibrary;
     });
   }
 
   Uri get rootUri => rootLibrary.canonicalUri;
 
   bool containsLibrary(Uri uri) => loadedLibraries.containsKey(uri);
 
   LibraryElement getLibrary(Uri uri) => loadedLibraries[uri];
 
   void forEachLibrary(f(LibraryElement library)) => nodeMap.keys.forEach(f);
 
   void forEachImportChain(Uri targetUri,
-                          {bool callback(Link<Uri> importChainReversed)}) {
+      {bool callback(Link<Uri> importChainReversed)}) {
     bool aborted = false;
 
     /// Map from libraries to the set of (unreversed) paths to [uri].
     Map<LibraryElement, Iterable<Link<Uri>>> suffixChainMap =
         <LibraryElement, Iterable<Link<Uri>>>{};
 
     /// Computes the set of (unreversed) paths to [targetUri].
     ///
     /// Finds all paths (suffixes) from the current library to [uri] and stores
     /// it in [suffixChainMap].
     ///
     /// For every found suffix it prepends the given [prefix] and the canonical
     /// uri of [library] and invokes the [callback] with the concatenated chain.
-    void computeSuffixes(LibraryElement library,
-                         Link<Uri> prefix) {
+    void computeSuffixes(LibraryElement library, Link<Uri> prefix) {
       if (aborted) return;
 
       Uri canonicalUri = library.canonicalUri;
       prefix = prefix.prepend(canonicalUri);
       if (suffixChainMap.containsKey(library)) return;
       suffixChainMap[library] = const <Link<Uri>>[];
       List<Link<Uri>> suffixes = [];
       if (targetUri != canonicalUri) {
         LibraryDependencyNode node = nodeMap[library];
 
@@ skipping 28 matching lines @@
         }
 
         for (ImportLink import in node.imports.reverse()) {
           processLibrary(import.importedLibrary);
           if (aborted) return;
         }
         for (LibraryElement exportedLibrary in node.exports.reverse()) {
           processLibrary(exportedLibrary);
           if (aborted) return;
         }
-      } else { // Here `targetUri == canonicalUri`.
+      } else {
+        // Here `targetUri == canonicalUri`.
         if (!callback(prefix)) {
           aborted = true;
           return;
         }
         suffixes.add(const Link<Uri>().prepend(canonicalUri));
       }
       suffixChainMap[library] = suffixes;
       return;
     }
 
     computeSuffixes(rootLibrary, const Link<Uri>());
   }
 
   String toString() => 'root=$rootLibrary,libraries=${loadedLibraries.keys}';
 }
 
 /// API used by the library loader to translate internal SDK URIs into file
 /// system readable URIs.
 abstract class ResolvedUriTranslator {
   // TODO(sigmund): move here the comments from library loader.
   /// Translate the resolved [uri] in the context of [importingLibrary].
   ///
   /// Use [spannable] for error reporting.
-  Uri translate(
-      LibraryElement importingLibrary, Uri uri, [Spannable spannable]);
+  Uri translate(LibraryElement importingLibrary, Uri uri,
+      [Spannable spannable]);
 }
 
-
 // TODO(sigmund): remove ScriptLoader & ElementScanner. Such abstraction seems
 // rather low-level. It might be more practical to split the library-loading
 // task itself.  The task would continue to do the work of recursively loading
 // dependencies, but it can delegate to a set of subloaders how to do the actual
 // loading. We would then have a list of subloaders that use different
 // implementations: in-memory cache, deserialization, scanning from files.
 //
 // For example, the API might look like this:
 //
 // /// APIs to create [LibraryElement] and [CompilationUnitElements] given it's
@@ skipping 32 matching lines @@
   Future<Script> readScript(Uri uri, [Spannable spannable]);
 }
 
 /// API used by the library loader to synchronously scan a library or
 /// compilation unit and ensure that their library tags are computed.
 abstract class ElementScanner {
   void scanLibrary(LibraryElement library);
   void scanUnit(CompilationUnitElement unit);
 }
 
-
 /// TODO(sigmund): remove this abstraction. Ideally the loader can produce the
 /// LoadedLibraries results once, and the compiler and choose what to do with
 /// it instead.
 abstract class LibraryLoaderListener {
   /// Called after a request to load a library. The [results] will include all
   /// transitive libraries loaded as a result of the initial request.
   Future onLibrariesLoaded(LoadedLibraries results);
 
   /// Called whenever a library element is created.
   void onLibraryCreated(LibraryElement library);
 
   /// Called whenever a library is scanned from a script file.
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader);
 }