dartfmt pkg/compiler

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.dart';
-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 '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 'elements/elements.dart' show
-    AccessorElement,
-    AstElement,
-    ClassElement,
-    Element,
-    ElementKind,
-    Elements,
-    ExportElement,
-    FunctionElement,
-    ImportElement,
-    LibraryElement,
-    LocalFunctionElement,
-    MetadataAnnotation,
-    PrefixElement,
-    ScopeContainerElement,
-    TypedefElement;
-import 'js_backend/js_backend.dart' show
-    JavaScriptBackend;
-import 'resolution/resolution.dart' show
-    AnalyzableElementX;
-import 'resolution/tree_elements.dart' show
-    TreeElements;
+import 'elements/elements.dart'
+    show
+        AccessorElement,
+        AstElement,
+        ClassElement,
+        Element,
+        ElementKind,
+        Elements,
+        ExportElement,
+        FunctionElement,
+        ImportElement,
+        LibraryElement,
+        LocalFunctionElement,
+        MetadataAnnotation,
+        PrefixElement,
+        ScopeContainerElement,
+        TypedefElement;
+import 'js_backend/js_backend.dart' show JavaScriptBackend;
+import 'resolution/resolution.dart' show AnalyzableElementX;
+import 'resolution/tree_elements.dart' show TreeElements;
 import 'tree/tree.dart' as ast;
-import 'tree/tree.dart' show
-    Import,
-    LibraryTag,
-    LibraryDependency,
-    LiteralDartString,
-    LiteralString,
-    NewExpression,
-    Node;
-import 'universe/use.dart' show
-    DynamicUse,
-    StaticUse,
-    TypeUse,
-    TypeUseKind;
-import 'universe/world_impact.dart' show
-    ImpactUseCase,
-    WorldImpact,
-    WorldImpactVisitorImpl;
-import 'util/setlet.dart' show
-    Setlet;
+import 'tree/tree.dart'
+    show
+        Import,
+        LibraryTag,
+        LibraryDependency,
+        LiteralDartString,
+        LiteralString,
+        NewExpression,
+        Node;
+import 'universe/use.dart' show DynamicUse, StaticUse, TypeUse, TypeUseKind;
+import 'universe/world_impact.dart'
+    show ImpactUseCase, WorldImpact, WorldImpactVisitorImpl;
+import 'util/setlet.dart' show Setlet;
 import 'util/uri_extras.dart' as uri_extras;
-import 'util/util.dart' show
-    Link, makeUnique;
+import 'util/util.dart' show Link, makeUnique;
 
 /// A "hunk" of the program that will be loaded whenever one of its [imports]
 /// are loaded.
 ///
 /// Elements that are only used in one deferred import, is in an OutputUnit with
 /// the deferred import as single element in the [imports] set.
 ///
 /// Whenever a deferred Element is shared between several deferred imports it is
 /// in an output unit with those imports in the [imports] Set.
 ///
 /// OutputUnits are equal if their [imports] are equal.
 class OutputUnit {
   /// The deferred imports that will load this output unit when one of them is
   /// loaded.
   final Setlet<_DeferredImport> imports = new Setlet<_DeferredImport>();
 
   /// `true` if this output unit is for the main output file.
   final bool isMainOutput;
 
   /// A unique name representing this [OutputUnit].
   String name;
 
   OutputUnit({this.isMainOutput: false});
 
   String toString() => "OutputUnit($name)";
 
-  bool operator==(OutputUnit other) {
+  bool operator ==(OutputUnit other) {
     return imports.length == other.imports.length &&
         imports.containsAll(other.imports);
   }
 
   int get hashCode {
     int sum = 0;
     for (_DeferredImport import in imports) {
-      sum = (sum + import.hashCode) & 0x3FFFFFFF;  // Stay in 30 bit range.
+      sum = (sum + import.hashCode) & 0x3FFFFFFF; // Stay in 30 bit range.
     }
     return sum;
   }
 }
 
 /// For each deferred import, find elements and constants to be loaded when that
 /// import is loaded. Elements that are used by several deferred imports are in
 /// shared OutputUnits.
 class DeferredLoadTask extends CompilerTask {
   /// The name of this task.
@@ skipping 112 matching lines @@
   ///
   /// For example, if we have two deferred libraries `A` and `B` that both
   /// import a library `C`, then even though elements from `A` and `C` end up in
   /// different output units, there is a non-deferred path between `A` and `C`.
   bool hasOnlyNonDeferredImportPaths(Element from, Element to) {
     OutputUnit outputUnitFrom = outputUnitForElement(from);
     OutputUnit outputUnitTo = outputUnitForElement(to);
     return outputUnitTo.imports.containsAll(outputUnitFrom.imports);
   }
 
-  void registerConstantDeferredUse(DeferredConstantValue constant,
-                                   PrefixElement prefix) {
+  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) {
     Iterable<ImportElement> imports = _getImports(element, library);
     // If the element is not imported explicitly, it is implicitly imported
@@ skipping 14 matching lines @@
     if (element.isAccessor) {
       element = (element as AccessorElement).abstractField;
     }
     return library.getImportsFor(element);
   }
 
   /// Finds all elements and constants that [element] depends directly on.
   /// (not the transitive closure.)
   ///
   /// Adds the results to [elements] and [constants].
-  void _collectAllElementsAndConstantsResolvedFrom(
-      Element element,
-      Set<Element> elements,
-      Set<ConstantValue> constants,
-      isMirrorUsage) {
-
+  void _collectAllElementsAndConstantsResolvedFrom(Element element,
+      Set<Element> elements, Set<ConstantValue> constants, isMirrorUsage) {
     if (element.isMalformed) {
       // Malformed elements are ignored.
       return;
     }
 
     /// Recursively collects all the dependencies of [type].
     void collectTypeDependencies(DartType type) {
       // TODO(het): we would like to separate out types that are only needed for
       // rti from types that are needed for their members.
       if (type is GenericType) {
@@ skipping 36 matching lines @@
         AstElement analyzableElement = element.analyzableElement.declaration;
         if (!compiler.enqueuer.resolution.hasBeenProcessed(analyzableElement)) {
           return;
         }
 
         WorldImpact worldImpact =
             compiler.resolution.getWorldImpact(analyzableElement);
         compiler.impactStrategy.visitImpact(
             analyzableElement,
             worldImpact,
-            new WorldImpactVisitorImpl(
-                visitStaticUse: (StaticUse staticUse) {
-                  elements.add(staticUse.element);
-                },
-                visitTypeUse: (TypeUse typeUse) {
-                  DartType type = typeUse.type;
-                  switch (typeUse.kind) {
-                    case TypeUseKind.TYPE_LITERAL:
-                      if (type.isTypedef || type.isInterfaceType) {
-                        elements.add(type.element);
-                      }
-                      break;
-                    case TypeUseKind.INSTANTIATION:
-                    case TypeUseKind.IS_CHECK:
-                    case TypeUseKind.AS_CAST:
-                    case TypeUseKind.CATCH_TYPE:
-                      collectTypeDependencies(type);
-                      break;
-                    case TypeUseKind.CHECKED_MODE_CHECK:
-                      if (compiler.options.enableTypeAssertions) {
-                        collectTypeDependencies(type);
-                      }
-                      break;
+            new WorldImpactVisitorImpl(visitStaticUse: (StaticUse staticUse) {
+              elements.add(staticUse.element);
+            }, visitTypeUse: (TypeUse typeUse) {
+              DartType type = typeUse.type;
+              switch (typeUse.kind) {
+                case TypeUseKind.TYPE_LITERAL:
+                  if (type.isTypedef || type.isInterfaceType) {
+                    elements.add(type.element);
                   }
-                }),
-             IMPACT_USE);
+                  break;
+                case TypeUseKind.INSTANTIATION:
+                case TypeUseKind.IS_CHECK:
+                case TypeUseKind.AS_CAST:
+                case TypeUseKind.CATCH_TYPE:
+                  collectTypeDependencies(type);
+                  break;
+                case TypeUseKind.CHECKED_MODE_CHECK:
+                  if (compiler.options.enableTypeAssertions) {
+                    collectTypeDependencies(type);
+                  }
+                  break;
+              }
+            }),
+            IMPACT_USE);
 
         TreeElements treeElements = analyzableElement.resolvedAst.elements;
         assert(treeElements != null);
 
         treeElements.forEachConstantNode((Node node, _) {
           // Explicitly depend on the backend constants.
           ConstantValue value =
               backend.constants.getConstantValueForNode(node, treeElements);
           if (value != null) {
             // TODO(johnniwinther): Assert that all constants have values when
@@ skipping 30 matching lines @@
       ClassElement cls = element.declaration;
       cls.forEachLocalMember(addLiveInstanceMember);
       if (cls.implementation != cls) {
         // TODO(ahe): Why doesn't ClassElement.forEachLocalMember do this?
         cls.implementation.forEachLocalMember(addLiveInstanceMember);
       }
       for (var type in cls.implementation.allSupertypes) {
         elements.add(type.element.implementation);
       }
       elements.add(cls.implementation);
-    } else if (Elements.isStaticOrTopLevel(element) ||
-               element.isConstructor) {
+    } else if (Elements.isStaticOrTopLevel(element) || element.isConstructor) {
       elements.add(element);
       collectDependencies(element);
     }
     if (element.isGenerativeConstructor) {
       // When instantiating a class, we record a reference to the
       // constructor, not the class itself.  We must add all the
       // instance members of the constructor's class.
-      ClassElement implementation =
-          element.enclosingClass.implementation;
+      ClassElement implementation = element.enclosingClass.implementation;
       _collectAllElementsAndConstantsResolvedFrom(
           implementation, elements, constants, isMirrorUsage);
     }
 
     // Other elements, in particular instance members, are ignored as
     // they are processed as part of the class.
   }
 
   /// Returns the transitive closure of all libraries that are imported
   /// from root without DeferredLibrary annotations.
@@ skipping 23 matching lines @@
       if (library.isPatched) {
         iterateTags(library.implementation);
       }
     }
     traverseLibrary(root);
     result.add(compiler.coreLibrary);
     return result;
   }
 
   /// Add all dependencies of [constant] to the mapping of [import].
-  void _mapConstantDependencies(ConstantValue constant,
-                                _DeferredImport import) {
-    Set<ConstantValue> constants = _constantsDeferredBy.putIfAbsent(import,
-        () => new Set<ConstantValue>());
+  void _mapConstantDependencies(
+      ConstantValue constant, _DeferredImport import) {
+    Set<ConstantValue> constants = _constantsDeferredBy.putIfAbsent(
+        import, () => new Set<ConstantValue>());
     if (constants.contains(constant)) return;
     constants.add(constant);
     if (constant is ConstructedConstantValue) {
       _mapDependencies(element: constant.type.element, import: import);
     }
     constant.getDependencies().forEach((ConstantValue dependency) {
       _mapConstantDependencies(dependency, import);
     });
   }
 
   /// Recursively traverses the graph of dependencies from one of [element]
   /// or [constant], mapping deferred imports to each dependency it needs in the
   /// sets [_importedDeferredBy] and [_constantsDeferredBy].
   /// Only one of [element] and [constant] should be given.
-  void _mapDependencies({Element element,
-                         _DeferredImport import,
-                         isMirrorUsage: false}) {
-
-    Set<Element> elements = _importedDeferredBy.putIfAbsent(import,
-        () => new Set<Element>());
-
+  void _mapDependencies(
+      {Element element, _DeferredImport import, isMirrorUsage: false}) {
+    Set<Element> elements =
+        _importedDeferredBy.putIfAbsent(import, () => new Set<Element>());
 
     Set<Element> dependentElements = new Set<Element>();
     Set<ConstantValue> dependentConstants = new Set<ConstantValue>();
 
     LibraryElement library;
 
     if (element != null) {
       // Only process elements once, unless we are doing dependencies due to
       // mirrors, which are added in additional traversals.
       if (!isMirrorUsage && elements.contains(element)) return;
       // Anything used directly by main will be loaded from the start
       // We do not need to traverse it again.
       if (import != _fakeMainImport && _mainElements.contains(element)) return;
       elements.add(element);
 
-
       // 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 (ImportElement deferredImport in _getImports(dependency, library)) {
-          _mapDependencies(element: dependency,
+          _mapDependencies(
+              element: dependency,
               import: new _DeclaredDeferredImport(deferredImport));
         }
       } else {
         _mapDependencies(element: dependency, import: import);
       }
     }
 
     for (ConstantValue dependency in dependentConstants) {
       if (dependency is DeferredConstantValue) {
         _mapConstantDependencies(dependency,
             new _DeclaredDeferredImport(dependency.prefix.deferredImport));
       } else {
         _mapConstantDependencies(dependency, import);
       }
     }
   }
 
   /// Adds extra dependencies coming from mirror usage.
   ///
   /// The elements are added with [_mapDependencies].
   void _addMirrorElements() {
-    void mapDependenciesIfResolved(Element element,
-                                   _DeferredImport deferredImport) {
+    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);
       }
@@ skipping 16 matching lines @@
         }
       }
 
       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)) {
+      for (LibraryElement library
+          in _nonDeferredReachableLibraries(deferredLibrary)) {
         handleLibrary(library, deferredImport);
       }
     }
   }
 
   /// Computes a unique string for the name field for each outputUnit.
   ///
   /// Also sets up the [hunksToLoad] mapping.
   void _assignNamesToOutputUnits(Set<OutputUnit> allOutputUnits) {
     Set<String> usedImportNames = new Set<String>();
@@ skipping 52 matching lines @@
       allOutputUnits.add(mainOutputUnit);
       return;
     }
     if (main == null) return;
     LibraryElement mainLibrary = main.library;
     _importedDeferredBy = new Map<_DeferredImport, Set<Element>>();
     _constantsDeferredBy = new Map<_DeferredImport, Set<ConstantValue>>();
     _importedDeferredBy[_fakeMainImport] = _mainElements;
 
     measureElement(mainLibrary, () {
-
       // Starting from main, traverse the program and find all dependencies.
       _mapDependencies(element: compiler.mainFunction, import: _fakeMainImport);
 
       // Also add "global" dependencies to the main OutputUnit.  These are
       // things that the backend needs but cannot associate with a particular
       // element, for example, startRootIsolate.  This set also contains
       // elements for which we lack precise information.
       for (Element element in compiler.globalDependencies.otherDependencies) {
         _mapDependencies(element: element, import: _fakeMainImport);
       }
@@ skipping 13 matching lines @@
       // all deferred imports mapped to this element. Same for constants.
       for (_DeferredImport import in _importedDeferredBy.keys) {
         for (Element element in _importedDeferredBy[import]) {
           // Only one file should be loaded when the program starts, so make
           // sure that only one OutputUnit is created for [fakeMainImport].
           if (import == _fakeMainImport) {
             elementToOutputUnitBuilder[element] = mainOutputUnit;
           } else {
             elementToOutputUnitBuilder
                 .putIfAbsent(element, () => new OutputUnit())
-                .imports.add(import);
+                .imports
+                .add(import);
           }
         }
       }
       for (_DeferredImport import in _constantsDeferredBy.keys) {
         for (ConstantValue constant in _constantsDeferredBy[import]) {
           // Only one file should be loaded when the program starts, so make
           // sure that only one OutputUnit is created for [fakeMainImport].
           if (import == _fakeMainImport) {
             constantToOutputUnitBuilder[constant] = mainOutputUnit;
           } else {
             constantToOutputUnitBuilder
                 .putIfAbsent(constant, () => new OutputUnit())
-                .imports.add(import);
+                .imports
+                .add(import);
           }
         }
       }
 
       // Release maps;
       _importedDeferredBy = null;
       _constantsDeferredBy = null;
 
       // Find all the output units elements/constants have been mapped to, and
       // canonicalize them.
-      elementToOutputUnitBuilder.forEach(
-          (Element element, OutputUnit outputUnit) {
+      elementToOutputUnitBuilder
+          .forEach((Element element, OutputUnit outputUnit) {
         OutputUnit representative = allOutputUnits.lookup(outputUnit);
         if (representative == null) {
           representative = outputUnit;
           allOutputUnits.add(representative);
         }
         _elementToOutputUnit[element] = representative;
       });
-      constantToOutputUnitBuilder.forEach(
-          (ConstantValue constant, OutputUnit outputUnit) {
+      constantToOutputUnitBuilder
+          .forEach((ConstantValue constant, OutputUnit outputUnit) {
         OutputUnit representative = allOutputUnits.lookup(outputUnit);
         if (representative == null) {
           representative = outputUnit;
           allOutputUnits.add(representative);
         }
         _constantToOutputUnit[constant] = representative;
       });
 
       // Generate a unique name for each OutputUnit.
       _assignNamesToOutputUnits(allOutputUnits);
@@ skipping 37 matching lines @@
         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.resolution);
               ConstantValue value =
                   compiler.constants.getConstantValue(metadata.constant);
               Element element = value.getType(compiler.coreTypes).element;
               if (element == deferredLibraryClass) {
-                 reporter.reportErrorMessage(
-                     import, MessageKind.DEFERRED_OLD_SYNTAX);
+                reporter.reportErrorMessage(
+                    import, MessageKind.DEFERRED_OLD_SYNTAX);
               }
             }
           }
 
-          String prefix = (import.prefix != null)
-              ? import.prefix.name
-              : null;
+          String prefix = (import.prefix != null) ? import.prefix.name : null;
           // The last import we saw with the same prefix.
           ImportElement previousDeferredImport = prefixDeferredImport[prefix];
           if (import.isDeferred) {
             _DeferredImport key = new _DeclaredDeferredImport(import);
             LibraryElement importedLibrary = import.importedLibrary;
             _allDeferredImports[key] = importedLibrary;
 
             if (prefix == null) {
               reporter.reportErrorMessage(
-                  import,
-                  MessageKind.DEFERRED_LIBRARY_WITHOUT_PREFIX);
+                  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))) {
               ImportElement failingImport = (previousDeferredImport != null)
                   ? previousDeferredImport
                   : import;
-              reporter.reportErrorMessage(
-                  failingImport.prefix,
+              reporter.reportErrorMessage(failingImport.prefix,
                   MessageKind.DEFERRED_LIBRARY_DUPLICATE_PREFIX);
             }
             usedPrefixes.add(prefix);
           }
         }
       });
     }
     if (isProgramSplit) {
       isProgramSplit = compiler.backend.enableDeferredLoadingIfSupported(
-            lastDeferred, compiler.globalDependencies);
+          lastDeferred, compiler.globalDependencies);
     }
   }
 
   /// If [send] is a static send with a deferred element, returns the
   /// [PrefixElement] that the first prefix of the send resolves to.
   /// Otherwise returns null.
   ///
   /// Precondition: send must be static.
   ///
   /// Example:
@@ skipping 59 matching lines @@
   /// - <prefix> is the `as` prefix used for a given deferred import.
   /// - <list of files> is a list of the filenames the must be loaded when that
   ///   import is loaded.
   Map<String, Map<String, dynamic>> computeDeferredMap() {
     JavaScriptBackend backend = compiler.backend;
     Map<String, Map<String, dynamic>> mapping =
         new Map<String, Map<String, dynamic>>();
     _deferredImportDescriptions.keys.forEach((_DeferredImport import) {
       List<OutputUnit> outputUnits = hunksToLoad[importDeferName[import]];
       ImportDescription description = _deferredImportDescriptions[import];
-      Map<String, dynamic> libraryMap =
-          mapping.putIfAbsent(description.importingUri,
-              () => <String, dynamic>{"name": description.importingLibraryName,
-                                      "imports": <String, List<String>>{}});
+      Map<String, dynamic> libraryMap = mapping.putIfAbsent(
+          description.importingUri,
+          () => <String, dynamic>{
+                "name": description.importingLibraryName,
+                "imports": <String, List<String>>{}
+              });
 
-      libraryMap["imports"][importDeferName[import]] = outputUnits.map(
-            (OutputUnit outputUnit) {
-          return backend.deferredPartFileName(outputUnit.name);
-        }).toList();
+      libraryMap["imports"][importDeferName[import]] =
+          outputUnits.map((OutputUnit outputUnit) {
+        return backend.deferredPartFileName(outputUnit.name);
+      }).toList();
     });
     return mapping;
   }
 
   /// Creates a textual representation of the output unit content.
   String dump() {
     Map<OutputUnit, List<String>> elementMap = <OutputUnit, List<String>>{};
-    Map<OutputUnit, List<String>> constantMap =
-        <OutputUnit, List<String>>{};
+    Map<OutputUnit, List<String>> constantMap = <OutputUnit, List<String>>{};
     _elementToOutputUnit.forEach((Element element, OutputUnit output) {
       elementMap.putIfAbsent(output, () => <String>[]).add('$element');
     });
     _constantToOutputUnit.forEach((ConstantValue value, OutputUnit output) {
-      constantMap.putIfAbsent(output, () => <String>[])
+      constantMap
+          .putIfAbsent(output, () => <String>[])
           .add(value.toStructuredString());
     });
 
     StringBuffer sb = new StringBuffer();
     for (OutputUnit outputUnit in allOutputUnits) {
       sb.write(outputUnit.name);
       List<String> elements = elementMap[outputUnit];
       if (elements != null) {
         sb.write('\n elements:');
         for (String element in elements..sort()) {
           sb.write('\n  $element');
         }
       }
       List<String> constants = constantMap[outputUnit];
       if (constants != null) {
         sb.write('\n constants:');
         for (String value in constants..sort()) {
           sb.write('\n  $value');
         }
       }
     }
     return sb.toString();
   }
-
 }
 
 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(ImportElement import,
-                    LibraryElement importingLibrary,
-                    Compiler compiler)
-      : importingUri = uri_extras.relativize(
-          compiler.mainApp.canonicalUri,
-          importingLibrary.canonicalUri, false),
+  ImportDescription(
+      ImportElement import, LibraryElement importingLibrary, Compiler compiler)
+      : importingUri = uri_extras.relativize(compiler.mainApp.canonicalUri,
+            importingLibrary.canonicalUri, false),
         prefix = import.prefix.name,
         _importingLibrary = importingLibrary;
 
   String get importingLibraryName {
     return _importingLibrary.hasLibraryName
-        ? _importingLibrary.libraryName : "<unnamed>";
+        ? _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.
@@ skipping 38 matching lines @@
     return result;
   }
 
   bool operator ==(other) {
     if (other is! _DeclaredDeferredImport) return false;
     return declaration == other.declaration;
   }
 
   int get hashCode => declaration.hashCode * 17;
 }