dartfmt pkg/compiler

pkg/compiler/lib/src/compiler.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.compiler_base;
 
-import 'dart:async' show
-    EventSink,
-    Future;
+import 'dart:async' show EventSink, Future;
 
 import '../compiler_new.dart' as api;
-import 'cache_strategy.dart' show
-    CacheStrategy;
-import 'closure.dart' as closureMapping show
-    ClosureTask;
+import 'cache_strategy.dart' show CacheStrategy;
+import 'closure.dart' as closureMapping show ClosureTask;
 import 'common.dart';
-import 'common/backend_api.dart' show
-    Backend;
-import 'common/codegen.dart' show
-    CodegenImpact,
-    CodegenWorkItem;
-import 'common/names.dart' show
-    Identifiers,
-    Uris;
-import 'common/registry.dart' show
-    EagerRegistry,
-    Registry;
-import 'common/resolution.dart' show
-    Parsing,
-    Resolution,
-    ResolutionWorkItem,
-    ResolutionImpact;
-import 'common/tasks.dart' show
-    CompilerTask,
-    GenericTask;
-import 'common/work.dart' show
-    ItemCompilationContext,
-    WorkItem;
+import 'common/backend_api.dart' show Backend;
+import 'common/codegen.dart' show CodegenImpact, CodegenWorkItem;
+import 'common/names.dart' show Identifiers, Uris;
+import 'common/registry.dart' show EagerRegistry, Registry;
+import 'common/resolution.dart'
+    show Parsing, Resolution, ResolutionWorkItem, ResolutionImpact;
+import 'common/tasks.dart' show CompilerTask, GenericTask;
+import 'common/work.dart' show ItemCompilationContext, WorkItem;
 import 'compile_time_constants.dart';
 import 'constants/values.dart';
-import 'core_types.dart' show
-    CoreClasses,
-    CoreTypes;
+import 'core_types.dart' show CoreClasses, CoreTypes;
 import 'dart_backend/dart_backend.dart' as dart_backend;
-import 'dart_types.dart' show
-    DartType,
-    DynamicType,
-    InterfaceType,
-    Types;
+import 'dart_types.dart' show DartType, DynamicType, InterfaceType, Types;
 import 'deferred_load.dart' show DeferredLoadTask, OutputUnit;
 import 'diagnostics/code_location.dart';
-import 'diagnostics/diagnostic_listener.dart' show
-    DiagnosticReporter;
-import 'diagnostics/invariant.dart' show
-    REPORT_EXCESS_RESOLUTION;
-import 'diagnostics/messages.dart' show
-    Message,
-    MessageTemplate;
-import 'dump_info.dart' show
-    DumpInfoTask;
+import 'diagnostics/diagnostic_listener.dart' show DiagnosticReporter;
+import 'diagnostics/invariant.dart' show REPORT_EXCESS_RESOLUTION;
+import 'diagnostics/messages.dart' show Message, MessageTemplate;
+import 'dump_info.dart' show DumpInfoTask;
 import 'elements/elements.dart';
-import 'elements/modelx.dart' show
-    ErroneousElementX,
-    ClassElementX,
-    CompilationUnitElementX,
-    DeferredLoaderGetterElementX,
-    MethodElementX,
-    LibraryElementX,
-    PrefixElementX;
-import 'enqueue.dart' show
-    CodegenEnqueuer,
-    Enqueuer,
-    EnqueueTask,
-    ResolutionEnqueuer,
-    QueueFilter;
+import 'elements/modelx.dart'
+    show
+        ErroneousElementX,
+        ClassElementX,
+        CompilationUnitElementX,
+        DeferredLoaderGetterElementX,
+        MethodElementX,
+        LibraryElementX,
+        PrefixElementX;
+import 'enqueue.dart'
+    show
+        CodegenEnqueuer,
+        Enqueuer,
+        EnqueueTask,
+        ResolutionEnqueuer,
+        QueueFilter;
 import 'environment.dart';
-import 'io/source_information.dart' show
-    SourceInformation;
-import 'js_backend/backend_helpers.dart' as js_backend show
-    BackendHelpers;
-import 'js_backend/js_backend.dart' as js_backend show
-    JavaScriptBackend;
-import 'library_loader.dart' show
-    ElementScanner,
-    LibraryLoader,
-    LibraryLoaderTask,
-    LoadedLibraries,
-    LibraryLoaderListener,
-    ResolvedUriTranslator,
-    ScriptLoader;
-import 'mirrors_used.dart' show
-    MirrorUsageAnalyzerTask;
-import 'common/names.dart' show
-    Selectors;
-import 'null_compiler_output.dart' show
-    NullCompilerOutput,
-    NullSink;
-import 'options.dart' show
-    CompilerOptions,
-    DiagnosticOptions,
-    ParserOptions;
-import 'parser/diet_parser_task.dart' show
-    DietParserTask;
-import 'parser/element_listener.dart' show
-    ScannerOptions;
-import 'parser/parser_task.dart' show
-    ParserTask;
-import 'patch_parser.dart' show
-    PatchParserTask;
-import 'resolution/registry.dart' show
-    ResolutionRegistry;
-import 'resolution/resolution.dart' show
-    ResolverTask;
-import 'resolution/tree_elements.dart' show
-    TreeElementMapping;
-import 'scanner/scanner_task.dart' show
-    ScannerTask;
-import 'serialization/task.dart' show
-    SerializationTask;
-import 'script.dart' show
-    Script;
-import 'ssa/nodes.dart' show
-    HInstruction;
-import 'tracer.dart' show
-    Tracer;
-import 'tokens/token.dart' show
-    StringToken,
-    Token,
-    TokenPair;
-import 'tokens/token_constants.dart' as Tokens show
-    COMMENT_TOKEN,
-    EOF_TOKEN;
-import 'tokens/token_map.dart' show
-    TokenMap;
-import 'tree/tree.dart' show
-    Node,
-    TypeAnnotation;
-import 'typechecker.dart' show
-    TypeCheckerTask;
+import 'io/source_information.dart' show SourceInformation;
+import 'js_backend/backend_helpers.dart' as js_backend show BackendHelpers;
+import 'js_backend/js_backend.dart' as js_backend show JavaScriptBackend;
+import 'library_loader.dart'
+    show
+        ElementScanner,
+        LibraryLoader,
+        LibraryLoaderTask,
+        LoadedLibraries,
+        LibraryLoaderListener,
+        ResolvedUriTranslator,
+        ScriptLoader;
+import 'mirrors_used.dart' show MirrorUsageAnalyzerTask;
+import 'common/names.dart' show Selectors;
+import 'null_compiler_output.dart' show NullCompilerOutput, NullSink;
+import 'options.dart' show CompilerOptions, DiagnosticOptions, ParserOptions;
+import 'parser/diet_parser_task.dart' show DietParserTask;
+import 'parser/element_listener.dart' show ScannerOptions;
+import 'parser/parser_task.dart' show ParserTask;
+import 'patch_parser.dart' show PatchParserTask;
+import 'resolution/registry.dart' show ResolutionRegistry;
+import 'resolution/resolution.dart' show ResolverTask;
+import 'resolution/tree_elements.dart' show TreeElementMapping;
+import 'scanner/scanner_task.dart' show ScannerTask;
+import 'serialization/task.dart' show SerializationTask;
+import 'script.dart' show Script;
+import 'ssa/nodes.dart' show HInstruction;
+import 'tracer.dart' show Tracer;
+import 'tokens/token.dart' show StringToken, Token, TokenPair;
+import 'tokens/token_constants.dart' as Tokens show COMMENT_TOKEN, EOF_TOKEN;
+import 'tokens/token_map.dart' show TokenMap;
+import 'tree/tree.dart' show Node, TypeAnnotation;
+import 'typechecker.dart' show TypeCheckerTask;
 import 'types/types.dart' as ti;
-import 'universe/call_structure.dart' show
-    CallStructure;
-import 'universe/selector.dart' show
-    Selector;
-import 'universe/universe.dart' show
-    Universe;
-import 'universe/use.dart' show
-    StaticUse;
-import 'universe/world_impact.dart' show
-    ImpactStrategy,
-    WorldImpact;
-import 'util/util.dart' show
-    Link,
-    Setlet;
-import 'world.dart' show
-    World;
+import 'universe/call_structure.dart' show CallStructure;
+import 'universe/selector.dart' show Selector;
+import 'universe/universe.dart' show Universe;
+import 'universe/use.dart' show StaticUse;
+import 'universe/world_impact.dart' show ImpactStrategy, WorldImpact;
+import 'util/util.dart' show Link, Setlet;
+import 'world.dart' show World;
 
 abstract class Compiler implements LibraryLoaderListener {
-
   final Stopwatch totalCompileTime = new Stopwatch();
   int nextFreeClassId = 0;
   World world;
   Types types;
   _CompilerCoreTypes _coreTypes;
   _CompilerDiagnosticReporter _reporter;
   _CompilerResolution _resolution;
   _CompilerParsing _parsing;
 
   final CacheStrategy cacheStrategy;
@@ skipping 147 matching lines @@
   ConstantEnvironment constants;
 
   EnqueueTask enqueuer;
   DeferredLoadTask deferredLoadTask;
   MirrorUsageAnalyzerTask mirrorUsageAnalyzerTask;
   DumpInfoTask dumpInfoTask;
 
   /// A customizable filter that is applied to enqueued work items.
   QueueFilter enqueuerFilter = new QueueFilter();
 
-  final Selector symbolValidatedConstructorSelector = new Selector.call(
-      const PublicName('validated'), CallStructure.ONE_ARG);
+  final Selector symbolValidatedConstructorSelector =
+      new Selector.call(const PublicName('validated'), CallStructure.ONE_ARG);
 
-  static const String CREATE_INVOCATION_MIRROR =
-      'createInvocationMirror';
+  static const String CREATE_INVOCATION_MIRROR = 'createInvocationMirror';
 
   bool enabledRuntimeType = false;
   bool enabledFunctionApply = false;
   bool enabledInvokeOn = false;
   bool hasIsolateSupport = false;
 
   bool get hasCrashed => _reporter.hasCrashed;
 
   Stopwatch progress;
 
@@ skipping 11 matching lines @@
 
   bool get compilationFailed => compilationFailedInternal;
 
   void set compilationFailed(bool value) {
     if (value) {
       elementsWithCompileTimeErrors.add(currentElement);
     }
     compilationFailedInternal = value;
   }
 
-  Compiler({CompilerOptions options,
-            api.CompilerOutput outputProvider,
-            this.environment: const _EmptyEnvironment()})
+  Compiler(
+      {CompilerOptions options,
+      api.CompilerOutput outputProvider,
+      this.environment: const _EmptyEnvironment()})
       : this.options = options,
         this.cacheStrategy = new CacheStrategy(options.hasIncrementalSupport),
         this.userOutputProvider = outputProvider == null
-            ? const NullCompilerOutput() : outputProvider {
+            ? const NullCompilerOutput()
+            : outputProvider {
     world = new World(this);
     // TODO(johnniwinther): Initialize core types in [initializeCoreClasses] and
     // make its field final.
     _reporter = new _CompilerDiagnosticReporter(this, options);
     _parsing = new _CompilerParsing(this);
     _resolution = new _CompilerResolution(this);
     _coreTypes = new _CompilerCoreTypes(_resolution);
     types = new Types(_resolution);
     tracer = new Tracer(this, this.outputProvider);
 
     if (options.verbose) {
       progress = new Stopwatch()..start();
     }
 
     // TODO(johnniwinther): Separate the dependency tracking from the enqueuing
     // for global dependencies.
     globalDependencies = new GlobalDependencyRegistry(this);
 
     if (options.emitJavaScript) {
-      js_backend.JavaScriptBackend jsBackend =
-          new js_backend.JavaScriptBackend(
-              this, generateSourceMap: options.generateSourceMap,
-              useStartupEmitter: options.useStartupEmitter,
-              useNewSourceInfo: options.useNewSourceInfo);
+      js_backend.JavaScriptBackend jsBackend = new js_backend.JavaScriptBackend(
+          this,
+          generateSourceMap: options.generateSourceMap,
+          useStartupEmitter: options.useStartupEmitter,
+          useNewSourceInfo: options.useNewSourceInfo);
       backend = jsBackend;
     } else {
       backend = new dart_backend.DartBackend(this, options.strips,
           multiFile: options.dart2dartMultiFile);
       if (options.dumpInfo) {
         throw new ArgumentError('--dump-info is not supported for dart2dart.');
       }
     }
 
     tasks = [
       dietParser = new DietParserTask(this, parsing.parserOptions),
       scanner = createScannerTask(),
       serialization = new SerializationTask(this),
-      libraryLoader = new LibraryLoaderTask(this,
+      libraryLoader = new LibraryLoaderTask(
+          this,
           new _ResolvedUriTranslator(this),
           new _ScriptLoader(this),
           new _ElementScanner(scanner),
           this.serialization,
           this,
           environment),
       parser = new ParserTask(this, parsing.parserOptions),
       patchParser = new PatchParserTask(this, parsing.parserOptions),
       resolver = createResolverTask(),
       closureToClassMapper = new closureMapping.ClosureTask(this),
@@ skipping 123 matching lines @@
     // The maximum number of imports chains to show.
     final int compactChainLimit = options.verbose ? 20 : 10;
     int chainCount = 0;
     loadedLibraries.forEachImportChain(uri,
         callback: (Link<Uri> importChainReversed) {
       Link<CodeLocation> compactImportChain = const Link<CodeLocation>();
       CodeLocation currentCodeLocation =
           new UriLocation(importChainReversed.head);
       compactImportChain = compactImportChain.prepend(currentCodeLocation);
       for (Link<Uri> link = importChainReversed.tail;
-           !link.isEmpty;
-           link = link.tail) {
+          !link.isEmpty;
+          link = link.tail) {
         Uri uri = link.head;
         if (!currentCodeLocation.inSameLocation(uri)) {
           currentCodeLocation =
               options.verbose ? new UriLocation(uri) : new CodeLocation(uri);
-          compactImportChain =
-              compactImportChain.prepend(currentCodeLocation);
+          compactImportChain = compactImportChain.prepend(currentCodeLocation);
         }
       }
-      String importChain =
-          compactImportChain.map((CodeLocation codeLocation) {
-            return codeLocation.relativize(rootUri);
-          }).join(' => ');
+      String importChain = compactImportChain.map((CodeLocation codeLocation) {
+        return codeLocation.relativize(rootUri);
+      }).join(' => ');
 
       if (!importChains.contains(importChain)) {
         if (importChains.length > compactChainLimit) {
           importChains.add('...');
           return false;
         } else {
           importChains.add(importChain);
         }
       }
 
@@ skipping 22 matching lines @@
   /// [loadedLibraries] contains the newly loaded libraries.
   ///
   /// The method returns a [Future] allowing for the loading of additional
   /// libraries.
   Future onLibrariesLoaded(LoadedLibraries loadedLibraries) {
     return new Future.sync(() {
       for (Uri uri in disallowedLibraryUris) {
         if (loadedLibraries.containsLibrary(uri)) {
           Set<String> importChains =
               computeImportChainsFor(loadedLibraries, uri);
-          reporter.reportInfo(NO_LOCATION_SPANNABLE,
-             MessageKind.DISALLOWED_LIBRARY_IMPORT,
-              {'uri': uri,
-               'importChain': importChains.join(
-                   MessageTemplate.DISALLOWED_LIBRARY_IMPORT_PADDING)});
+          reporter.reportInfo(
+              NO_LOCATION_SPANNABLE, MessageKind.DISALLOWED_LIBRARY_IMPORT, {
+            'uri': uri,
+            'importChain': importChains
+                .join(MessageTemplate.DISALLOWED_LIBRARY_IMPORT_PADDING)
+          });
         }
       }
 
       if (!loadedLibraries.containsLibrary(Uris.dart_core)) {
         return null;
       }
 
       bool importsMirrorsLibrary =
           loadedLibraries.containsLibrary(Uris.dart_mirrors);
       if (importsMirrorsLibrary && !backend.supportsReflection) {
         Set<String> importChains =
             computeImportChainsFor(loadedLibraries, Uris.dart_mirrors);
-        reporter.reportErrorMessage(
-            NO_LOCATION_SPANNABLE,
-            MessageKind.MIRRORS_LIBRARY_NOT_SUPPORT_BY_BACKEND,
-            {'importChain': importChains.join(
-                MessageTemplate.MIRRORS_NOT_SUPPORTED_BY_BACKEND_PADDING)});
+        reporter.reportErrorMessage(NO_LOCATION_SPANNABLE,
+            MessageKind.MIRRORS_LIBRARY_NOT_SUPPORT_BY_BACKEND, {
+          'importChain': importChains
+              .join(MessageTemplate.MIRRORS_NOT_SUPPORTED_BY_BACKEND_PADDING)
+        });
       } else if (importsMirrorsLibrary && !options.enableExperimentalMirrors) {
         Set<String> importChains =
             computeImportChainsFor(loadedLibraries, Uris.dart_mirrors);
         reporter.reportWarningMessage(
-            NO_LOCATION_SPANNABLE,
-            MessageKind.IMPORT_EXPERIMENTAL_MIRRORS,
-            {'importChain': importChains.join(
-                 MessageTemplate.IMPORT_EXPERIMENTAL_MIRRORS_PADDING)});
+            NO_LOCATION_SPANNABLE, MessageKind.IMPORT_EXPERIMENTAL_MIRRORS, {
+          'importChain': importChains
+              .join(MessageTemplate.IMPORT_EXPERIMENTAL_MIRRORS_PADDING)
+        });
       }
 
       coreClasses.functionClass.ensureResolved(resolution);
       functionApplyMethod =
           coreClasses.functionClass.lookupLocalMember('apply');
 
       if (options.preserveComments) {
-        return libraryLoader.loadLibrary(Uris.dart_mirrors)
+        return libraryLoader
+            .loadLibrary(Uris.dart_mirrors)
             .then((LibraryElement libraryElement) {
           documentClass = libraryElement.find('Comment');
         });
       }
     }).then((_) => backend.onLibrariesLoaded(loadedLibraries));
   }
 
   bool isProxyConstant(ConstantValue value) {
     FieldElement field = coreLibrary.find('proxy');
     if (field == null) return false;
     if (!resolution.hasBeenResolved(field)) return false;
     if (proxyConstant == null) {
-      proxyConstant =
-          constants.getConstantValue(
-              resolver.constantCompiler.compileConstant(field));
+      proxyConstant = constants
+          .getConstantValue(resolver.constantCompiler.compileConstant(field));
     }
     return proxyConstant == value;
   }
 
   Element findRequiredElement(LibraryElement library, String name) {
     var element = library.find(name);
     if (element == null) {
-      reporter.internalError(library,
+      reporter.internalError(
+          library,
           "The library '${library.canonicalUri}' does not contain required "
           "element: '$name'.");
     }
     return element;
   }
 
   // TODO(johnniwinther): Move this to [PatchParser] when it is moved to the
   // [JavaScriptBackend]. Currently needed for testing.
   String get patchVersion => backend.patchVersion;
 
   void onClassResolved(ClassElement cls) {
     if (mirrorSystemClass == cls) {
       mirrorSystemGetNameFunction = cls.lookupLocalMember('getName');
     } else if (coreClasses.symbolClass == cls) {
       symbolConstructor = cls.constructors.head;
     } else if (symbolImplementationClass == cls) {
-      symbolValidatedConstructor = cls.lookupConstructor(
-          symbolValidatedConstructorSelector.name);
+      symbolValidatedConstructor =
+          cls.lookupConstructor(symbolValidatedConstructorSelector.name);
     } else if (mirrorsUsedClass == cls) {
       mirrorsUsedConstructor = cls.constructors.head;
     } else if (coreClasses.intClass == cls) {
       intEnvironment = cls.lookupConstructor(Identifiers.fromEnvironment);
     } else if (coreClasses.stringClass == cls) {
       stringEnvironment = cls.lookupConstructor(Identifiers.fromEnvironment);
     } else if (coreClasses.boolClass == cls) {
       boolEnvironment = cls.lookupConstructor(Identifiers.fromEnvironment);
     }
   }
@@ skipping 54 matching lines @@
     // TODO(ahe): This prevents memory leaks when invoking the compiler
     // multiple times. Implement a better mechanism where we can store
     // such caches in the compiler and get access to them through a
     // suitably maintained static reference to the current compiler.
     StringToken.canonicalizedSubstrings.clear();
     Selector.canonicalizedValues.clear();
 
     // The selector objects held in static fields must remain canonical.
     for (Selector selector in Selectors.ALL) {
       Selector.canonicalizedValues
-        .putIfAbsent(selector.hashCode, () => <Selector>[])
-        .add(selector);
+          .putIfAbsent(selector.hashCode, () => <Selector>[])
+          .add(selector);
     }
 
     assert(uri != null || options.analyzeOnly || options.hasIncrementalSupport);
     return new Future.sync(() {
       if (librariesToAnalyzeWhenRun != null) {
         return Future.forEach(librariesToAnalyzeWhenRun, (libraryUri) {
           reporter.log('Analyzing $libraryUri (${options.buildId})');
           return libraryLoader.loadLibrary(libraryUri);
         });
       }
@@ skipping 14 matching lines @@
   }
 
   void computeMain() {
     if (mainApp == null) return;
 
     Element main = mainApp.findExported(Identifiers.main);
     ErroneousElement errorElement = null;
     if (main == null) {
       if (options.analyzeOnly) {
         if (!analyzeAll) {
-          errorElement = new ErroneousElementX(
-              MessageKind.CONSIDER_ANALYZE_ALL, {'main': Identifiers.main},
-              Identifiers.main, mainApp);
+          errorElement = new ErroneousElementX(MessageKind.CONSIDER_ANALYZE_ALL,
+              {'main': Identifiers.main}, Identifiers.main, mainApp);
         }
       } else {
         // Compilation requires a main method.
-        errorElement = new ErroneousElementX(
-            MessageKind.MISSING_MAIN, {'main': Identifiers.main},
-            Identifiers.main, mainApp);
+        errorElement = new ErroneousElementX(MessageKind.MISSING_MAIN,
+            {'main': Identifiers.main}, Identifiers.main, mainApp);
       }
       mainFunction = backend.helperForMissingMain();
     } else if (main.isError && main.isSynthesized) {
       if (main is ErroneousElement) {
         errorElement = main;
       } else {
         reporter.internalError(main, 'Problem with ${Identifiers.main}.');
       }
       mainFunction = backend.helperForBadMain();
     } else if (!main.isFunction) {
-      errorElement = new ErroneousElementX(
-          MessageKind.MAIN_NOT_A_FUNCTION, {'main': Identifiers.main},
-          Identifiers.main, main);
+      errorElement = new ErroneousElementX(MessageKind.MAIN_NOT_A_FUNCTION,
+          {'main': Identifiers.main}, Identifiers.main, main);
       mainFunction = backend.helperForBadMain();
     } else {
       mainFunction = main;
       mainFunction.computeType(resolution);
       FunctionSignature parameters = mainFunction.functionSignature;
       if (parameters.requiredParameterCount > 2) {
         int index = 0;
         parameters.orderedForEachParameter((Element parameter) {
           if (index++ < 2) return;
           errorElement = new ErroneousElementX(
-              MessageKind.MAIN_WITH_EXTRA_PARAMETER, {'main': Identifiers.main},
+              MessageKind.MAIN_WITH_EXTRA_PARAMETER,
+              {'main': Identifiers.main},
               Identifiers.main,
               parameter);
           mainFunction = backend.helperForMainArity();
           // Don't warn about main not being used:
           enqueuer.resolution.registerStaticUse(new StaticUse.foreignUse(main));
         });
       }
     }
     if (mainFunction == null) {
       if (errorElement == null && !options.analyzeOnly && !analyzeAll) {
         reporter.internalError(mainApp, "Problem with '${Identifiers.main}'.");
       } else {
         mainFunction = errorElement;
       }
     }
     if (errorElement != null &&
         errorElement.isSynthesized &&
         !mainApp.isSynthesized) {
-      reporter.reportWarningMessage(
-          errorElement, errorElement.messageKind,
+      reporter.reportWarningMessage(errorElement, errorElement.messageKind,
           errorElement.messageArguments);
     }
   }
 
   /// Analyze all members of the library in [libraryUri].
   ///
   /// If [skipLibraryWithPartOfTag] is `true`, member analysis is skipped if the
   /// library has a `part of` tag, assuming it is a part and not a library.
   ///
   /// This operation assumes an unclosed resolution queue and is only supported
   /// when the '--analyze-main' option is used.
-  Future<LibraryElement> analyzeUri(
-      Uri libraryUri,
+  Future<LibraryElement> analyzeUri(Uri libraryUri,
       {bool skipLibraryWithPartOfTag: true}) {
     assert(options.analyzeMain);
     reporter.log('Analyzing $libraryUri (${options.buildId})');
-    return libraryLoader.loadLibrary(
-        libraryUri, skipFileWithPartOfTag: true).then(
-            (LibraryElement library) {
+    return libraryLoader
+        .loadLibrary(libraryUri, skipFileWithPartOfTag: true)
+        .then((LibraryElement library) {
       if (library == null) return null;
       fullyEnqueueLibrary(library, enqueuer.resolution);
       emptyQueue(enqueuer.resolution);
       enqueuer.resolution.logSummary(reporter.log);
       return library;
     });
   }
 
   /// Performs the compilation when all libraries have been loaded.
   void compileLoadedLibraries() {
     computeMain();
 
     mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
 
     // In order to see if a library is deferred, we must compute the
     // compile-time constants that are metadata.  This means adding
     // something to the resolution queue.  So we cannot wait with
     // this until after the resolution queue is processed.
     deferredLoadTask.beforeResolution(this);
     impactStrategy = backend.createImpactStrategy(
         supportDeferredLoad: deferredLoadTask.isProgramSplit,
         supportDumpInfo: options.dumpInfo,
         supportSerialization: serialization.supportSerialization);
 
     phase = PHASE_RESOLVING;
     if (analyzeAll) {
       libraryLoader.libraries.forEach((LibraryElement library) {
-      reporter.log('Enqueuing ${library.canonicalUri}');
+        reporter.log('Enqueuing ${library.canonicalUri}');
         fullyEnqueueLibrary(library, enqueuer.resolution);
       });
     } else if (options.analyzeMain) {
       if (mainApp != null) {
         fullyEnqueueLibrary(mainApp, enqueuer.resolution);
       }
       if (librariesToAnalyzeWhenRun != null) {
         for (Uri libraryUri in librariesToAnalyzeWhenRun) {
-          fullyEnqueueLibrary(libraryLoader.lookupLibrary(libraryUri),
-              enqueuer.resolution);
+          fullyEnqueueLibrary(
+              libraryLoader.lookupLibrary(libraryUri), enqueuer.resolution);
         }
       }
     }
     // Elements required by enqueueHelpers are global dependencies
     // that are not pulled in by a particular element.
     backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
     resolveLibraryMetadata();
     reporter.log('Resolving...');
     processQueue(enqueuer.resolution, mainFunction);
     enqueuer.resolution.logSummary(reporter.log);
 
     _reporter.reportSuppressedMessagesSummary();
 
-    if (compilationFailed){
+    if (compilationFailed) {
       if (!options.generateCodeWithCompileTimeErrors) return;
       if (!backend.enableCodegenWithErrorsIfSupported(NO_LOCATION_SPANNABLE)) {
         return;
       }
     }
 
     if (options.analyzeOnly) {
       if (!analyzeAll && !compilationFailed) {
         // No point in reporting unused code when [analyzeAll] is true: all
         // code is artificially used.
@@ skipping 54 matching lines @@
       fullyEnqueueTopLevelElement(element, world);
     }
     library.implementation.forEachLocalMember(enqueueAll);
   }
 
   void fullyEnqueueTopLevelElement(Element element, Enqueuer world) {
     if (element.isClass) {
       ClassElement cls = element;
       cls.ensureResolved(resolution);
       cls.forEachLocalMember(enqueuer.resolution.addToWorkList);
-      backend.registerInstantiatedType(
-          cls.rawType, world, globalDependencies);
+      backend.registerInstantiatedType(cls.rawType, world, globalDependencies);
     } else {
       world.addToWorkList(element);
     }
   }
 
   // Resolves metadata on library elements.  This is necessary in order to
   // resolve metadata classes referenced only from metadata on library tags.
   // TODO(ahe): Figure out how to do this lazily.
   void resolveLibraryMetadata() {
     for (LibraryElement library in libraryLoader.libraries) {
       if (library.metadata != null) {
         for (MetadataAnnotation metadata in library.metadata) {
           metadata.ensureResolved(resolution);
         }
       }
     }
   }
 
   /**
    * Empty the [world] queue.
    */
   void emptyQueue(Enqueuer world) {
     world.forEach((WorkItem work) {
-    reporter.withCurrentElement(work.element, () {
+      reporter.withCurrentElement(work.element, () {
         world.applyImpact(work.element, work.run(this, world));
       });
     });
   }
 
   void processQueue(Enqueuer world, Element main) {
     world.nativeEnqueuer.processNativeClasses(libraryLoader.libraries);
     if (main != null && !main.isMalformed) {
       FunctionElement mainMethod = main;
       mainMethod.computeType(resolution);
@@ skipping 49 matching lines @@
       }
       if (identical(e.kind, ElementKind.GENERATIVE_CONSTRUCTOR)) {
         resolved.remove(e);
       }
       if (backend.isBackendLibrary(e.library)) {
         resolved.remove(e);
       }
     }
     reporter.log('Excess resolution work: ${resolved.length}.');
     for (Element e in resolved) {
-      reporter.reportWarningMessage(e,
-          MessageKind.GENERIC,
+      reporter.reportWarningMessage(e, MessageKind.GENERIC,
           {'text': 'Warning: $e resolved but not compiled.'});
     }
   }
 
   WorldImpact analyzeElement(Element element) {
-    assert(invariant(element,
-           element.impliesType ||
-           element.isField ||
-           element.isFunction ||
-           element.isConstructor ||
-           element.isGetter ||
-           element.isSetter,
-           message: 'Unexpected element kind: ${element.kind}'));
+    assert(invariant(
+        element,
+        element.impliesType ||
+            element.isField ||
+            element.isFunction ||
+            element.isConstructor ||
+            element.isGetter ||
+            element.isSetter,
+        message: 'Unexpected element kind: ${element.kind}'));
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     assert(invariant(element, element.isDeclaration));
     return resolution.computeWorldImpact(element);
   }
 
-  WorldImpact analyze(ResolutionWorkItem work,
-                      ResolutionEnqueuer world) {
+  WorldImpact analyze(ResolutionWorkItem work, ResolutionEnqueuer world) {
     assert(invariant(work.element, identical(world, enqueuer.resolution)));
     assert(invariant(work.element, !work.isAnalyzed,
         message: 'Element ${work.element} has already been analyzed'));
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       if (phase == PHASE_RESOLVING) {
-        reporter.log(
-            'Resolved ${enqueuer.resolution.processedElements.length} '
+        reporter.log('Resolved ${enqueuer.resolution.processedElements.length} '
             'elements.');
         progress.reset();
       }
     }
     AstElement element = work.element;
     if (world.hasBeenProcessed(element)) {
       return const WorldImpact();
     }
     WorldImpact worldImpact = analyzeElement(element);
     backend.onElementResolved(element, element.resolvedAst.elements);
     world.registerProcessedElement(element);
     return worldImpact;
   }
 
   WorldImpact codegen(CodegenWorkItem work, CodegenEnqueuer world) {
     assert(invariant(work.element, identical(world, enqueuer.codegen)));
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
-      reporter.log(
-          'Compiled ${enqueuer.codegen.generatedCode.length} methods.');
+      reporter
+          .log('Compiled ${enqueuer.codegen.generatedCode.length} methods.');
       progress.reset();
     }
     return backend.codegen(work);
   }
 
   void reportDiagnostic(DiagnosticMessage message,
-                        List<DiagnosticMessage> infos,
-                        api.Diagnostic kind);
+      List<DiagnosticMessage> infos, api.Diagnostic kind);
 
   void reportCrashInUserCode(String message, exception, stackTrace) {
     _reporter.onCrashInUserCode(message, exception, stackTrace);
   }
 
   /// Messages for which compile-time errors are reported but compilation
   /// continues regardless.
   static const List<MessageKind> BENIGN_ERRORS = const <MessageKind>[
-      MessageKind.INVALID_METADATA,
-      MessageKind.INVALID_METADATA_GENERIC,
+    MessageKind.INVALID_METADATA,
+    MessageKind.INVALID_METADATA_GENERIC,
   ];
 
   bool markCompilationAsFailed(DiagnosticMessage message, api.Diagnostic kind) {
     if (options.testMode) {
       // When in test mode, i.e. on the build-bot, we always stop compilation.
       return true;
     }
     if (reporter.options.fatalWarnings) {
       return true;
     }
     return !BENIGN_ERRORS.contains(message.message.kind);
   }
 
   void fatalDiagnosticReported(DiagnosticMessage message,
-                               List<DiagnosticMessage> infos,
-                               api.Diagnostic kind) {
+      List<DiagnosticMessage> infos, api.Diagnostic kind) {
     if (markCompilationAsFailed(message, kind)) {
       compilationFailed = true;
     }
   }
 
   // TODO(sigmund): move this dart doc somewhere else too.
   /**
    * Translates the [resolvedUri] into a readable URI.
    *
    * The [importingLibrary] holds the library importing [resolvedUri] or
    * [:null:] if [resolvedUri] is loaded as the main library. The
    * [importingLibrary] is used to grant access to internal libraries from
    * platform libraries and patch libraries.
    *
    * If the [resolvedUri] is not accessible from [importingLibrary], this method
    * is responsible for reporting errors.
    *
    * See [LibraryLoader] for terminology on URIs.
    */
-  Uri translateResolvedUri(LibraryElement importingLibrary,
-                           Uri resolvedUri, Spannable spannable) {
+  Uri translateResolvedUri(
+      LibraryElement importingLibrary, Uri resolvedUri, Spannable spannable) {
     unimplemented(importingLibrary, 'Compiler.translateResolvedUri');
     return null;
   }
 
   /**
    * Reads the script specified by the [readableUri].
    *
    * See [LibraryLoader] for terminology on URIs.
    */
   Future<Script> readScript(Uri readableUri, [Spannable node]) {
@@ skipping 100 matching lines @@
         (CodeLocation codeLocation) => codeLocation.inSameLocation(libraryUri));
   }
 
   Iterable<CodeLocation> computeUserCodeLocations(
       {bool assumeInUserCode: false}) {
     List<CodeLocation> userCodeLocations = <CodeLocation>[];
     if (mainApp != null) {
       userCodeLocations.add(new CodeLocation(mainApp.canonicalUri));
     }
     if (librariesToAnalyzeWhenRun != null) {
-      userCodeLocations.addAll(librariesToAnalyzeWhenRun.map(
-          (Uri uri) => new CodeLocation(uri)));
+      userCodeLocations.addAll(
+          librariesToAnalyzeWhenRun.map((Uri uri) => new CodeLocation(uri)));
     }
     if (userCodeLocations.isEmpty && assumeInUserCode) {
       // Assume in user code since [mainApp] has not been set yet.
       userCodeLocations.add(const AnyLocation());
     }
     return userCodeLocations;
   }
 
   /// Return a canonical URI for the source of [element].
   ///
@@ skipping 110 matching lines @@
   InterfaceType listType([DartType elementType]) {
     listClass.ensureResolved(resolution);
     InterfaceType type = listClass.rawType;
     if (elementType == null) {
       return type;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
-  InterfaceType mapType([DartType keyType,
-                         DartType valueType]) {
+  InterfaceType mapType([DartType keyType, DartType valueType]) {
     mapClass.ensureResolved(resolution);
     InterfaceType type = mapClass.rawType;
     if (keyType == null && valueType == null) {
       return type;
     } else if (keyType == null) {
       keyType = const DynamicType();
     } else if (valueType == null) {
       valueType = const DynamicType();
     }
     return type.createInstantiation([keyType, valueType]);
@@ skipping 78 matching lines @@
   bool lastDiagnosticWasFiltered = false;
 
   /// Map containing information about the warnings and hints that have been
   /// suppressed for each library.
   Map<Uri, SuppressionInfo> suppressedWarnings = <Uri, SuppressionInfo>{};
 
   _CompilerDiagnosticReporter(this.compiler, this.options);
 
   Element get currentElement => _currentElement;
 
-  DiagnosticMessage createMessage(
-      Spannable spannable,
-      MessageKind messageKind,
+  DiagnosticMessage createMessage(Spannable spannable, MessageKind messageKind,
       [Map arguments = const {}]) {
     SourceSpan span = spanFromSpannable(spannable);
     MessageTemplate template = MessageTemplate.TEMPLATES[messageKind];
     Message message = template.message(arguments, options.terseDiagnostics);
     return new DiagnosticMessage(span, spannable, message);
   }
 
-  void reportError(
-      DiagnosticMessage message,
+  void reportError(DiagnosticMessage message,
       [List<DiagnosticMessage> infos = const <DiagnosticMessage>[]]) {
     reportDiagnosticInternal(message, infos, api.Diagnostic.ERROR);
   }
 
-  void reportWarning(
-      DiagnosticMessage message,
+  void reportWarning(DiagnosticMessage message,
       [List<DiagnosticMessage> infos = const <DiagnosticMessage>[]]) {
     reportDiagnosticInternal(message, infos, api.Diagnostic.WARNING);
   }
 
-  void reportHint(
-      DiagnosticMessage message,
+  void reportHint(DiagnosticMessage message,
       [List<DiagnosticMessage> infos = const <DiagnosticMessage>[]]) {
     reportDiagnosticInternal(message, infos, api.Diagnostic.HINT);
   }
 
   @deprecated
   void reportInfo(Spannable node, MessageKind messageKind,
-                  [Map arguments = const {}]) {
-    reportDiagnosticInternal(
-        createMessage(node, messageKind, arguments),
-        const <DiagnosticMessage>[],
-        api.Diagnostic.INFO);
+      [Map arguments = const {}]) {
+    reportDiagnosticInternal(createMessage(node, messageKind, arguments),
+        const <DiagnosticMessage>[], api.Diagnostic.INFO);
   }
 
   void reportDiagnosticInternal(DiagnosticMessage message,
-                                List<DiagnosticMessage> infos,
-                                api.Diagnostic kind) {
+      List<DiagnosticMessage> infos, api.Diagnostic kind) {
     if (!options.showAllPackageWarnings &&
         message.spannable != NO_LOCATION_SPANNABLE) {
       switch (kind) {
-      case api.Diagnostic.WARNING:
-      case api.Diagnostic.HINT:
-        Element element = elementFromSpannable(message.spannable);
-        if (!compiler.inUserCode(element, assumeInUserCode: true)) {
-          Uri uri = compiler.getCanonicalUri(element);
-          if (options.showPackageWarningsFor(uri)) {
-            reportDiagnostic(message, infos, kind);
+        case api.Diagnostic.WARNING:
+        case api.Diagnostic.HINT:
+          Element element = elementFromSpannable(message.spannable);
+          if (!compiler.inUserCode(element, assumeInUserCode: true)) {
+            Uri uri = compiler.getCanonicalUri(element);
+            if (options.showPackageWarningsFor(uri)) {
+              reportDiagnostic(message, infos, kind);
+              return;
+            }
+            SuppressionInfo info = suppressedWarnings.putIfAbsent(
+                uri, () => new SuppressionInfo());
+            if (kind == api.Diagnostic.WARNING) {
+              info.warnings++;
+            } else {
+              info.hints++;
+            }
+            lastDiagnosticWasFiltered = true;
             return;
           }
-          SuppressionInfo info =
-              suppressedWarnings.putIfAbsent(uri, () => new SuppressionInfo());
-          if (kind == api.Diagnostic.WARNING) {
-            info.warnings++;
-          } else {
-            info.hints++;
+          break;
+        case api.Diagnostic.INFO:
+          if (lastDiagnosticWasFiltered) {
+            return;
           }
-          lastDiagnosticWasFiltered = true;
-          return;
-        }
-        break;
-      case api.Diagnostic.INFO:
-        if (lastDiagnosticWasFiltered) {
-          return;
-        }
-        break;
+          break;
       }
     }
     lastDiagnosticWasFiltered = false;
     reportDiagnostic(message, infos, kind);
   }
 
   void reportDiagnostic(DiagnosticMessage message,
-                        List<DiagnosticMessage> infos,
-                        api.Diagnostic kind) {
+      List<DiagnosticMessage> infos, api.Diagnostic kind) {
     compiler.reportDiagnostic(message, infos, kind);
     if (kind == api.Diagnostic.ERROR ||
         kind == api.Diagnostic.CRASH ||
-        (options.fatalWarnings &&
-         kind == api.Diagnostic.WARNING)) {
+        (options.fatalWarnings && kind == api.Diagnostic.WARNING)) {
       compiler.fatalDiagnosticReported(message, infos, kind);
     }
   }
 
   /**
    * Perform an operation, [f], returning the return value from [f].  If an
    * error occurs then report it as having occurred during compilation of
    * [element].  Can be nested.
    */
   withCurrentElement(Element element, f()) {
@@ skipping 19 matching lines @@
       } catch (doubleFault) {
         // Ignoring exceptions in exception handling.
       }
       rethrow;
     } finally {
       _currentElement = old;
     }
   }
 
   void reportAssertionFailure(SpannableAssertionFailure ex) {
-    String message = (ex.message != null) ? tryToString(ex.message)
-                                          : tryToString(ex);
+    String message =
+        (ex.message != null) ? tryToString(ex.message) : tryToString(ex);
     reportDiagnosticInternal(
         createMessage(ex.node, MessageKind.GENERIC, {'text': message}),
         const <DiagnosticMessage>[],
         api.Diagnostic.CRASH);
   }
 
   SourceSpan spanFromTokens(Token begin, Token end, [Uri uri]) {
     if (begin == null || end == null) {
       // TODO(ahe): We can almost always do better. Often it is only
       // end that is null. Otherwise, we probably know the current
       // URI.
       throw 'Cannot find tokens to produce error message.';
     }
     if (uri == null && currentElement != null) {
       uri = currentElement.compilationUnit.script.resourceUri;
       assert(invariant(currentElement, () {
-
         bool sameToken(Token token, Token sought) {
           if (token == sought) return true;
           if (token.stringValue == '>>') {
             // `>>` is converted to `>` in the parser when needed.
             return sought.stringValue == '>' &&
                 token.charOffset <= sought.charOffset &&
                 sought.charOffset < token.charEnd;
           }
           return false;
         }
@@ skipping 136 matching lines @@
     } else if (node is Local) {
       Local local = node;
       return spanFromElement(local.executableContext);
     } else {
       throw 'No error location.';
     }
   }
 
   Element _elementFromHInstruction(HInstruction instruction) {
     return instruction.sourceElement is Element
-        ? instruction.sourceElement : null;
+        ? instruction.sourceElement
+        : null;
   }
 
   internalError(Spannable node, reason) {
     String message = tryToString(reason);
     reportDiagnosticInternal(
         createMessage(node, MessageKind.GENERIC, {'text': message}),
         const <DiagnosticMessage>[],
         api.Diagnostic.CRASH);
     throw 'Internal Error: $message';
   }
 
   void unhandledExceptionOnElement(Element element) {
     if (hasCrashed) return;
     hasCrashed = true;
-    reportDiagnostic(
-        createMessage(element, MessageKind.COMPILER_CRASHED),
-        const <DiagnosticMessage>[],
-        api.Diagnostic.CRASH);
+    reportDiagnostic(createMessage(element, MessageKind.COMPILER_CRASHED),
+        const <DiagnosticMessage>[], api.Diagnostic.CRASH);
     pleaseReportCrash();
   }
 
   void pleaseReportCrash() {
-    print(
-        MessageTemplate.TEMPLATES[MessageKind.PLEASE_REPORT_THE_CRASH]
-            .message({'buildId': compiler.options.buildId}));
+    print(MessageTemplate.TEMPLATES[MessageKind.PLEASE_REPORT_THE_CRASH]
+        .message({'buildId': compiler.options.buildId}));
   }
 
   /// Finds the approximate [Element] for [node]. [currentElement] is used as
   /// the default value.
   Element elementFromSpannable(Spannable node) {
     Element element;
     if (node is Element) {
       element = node;
     } else if (node is HInstruction) {
       element = _elementFromHInstruction(node);
     } else if (node is MetadataAnnotation) {
       element = node.annotatedElement;
     }
     return element != null ? element : currentElement;
   }
 
   void log(message) {
     Message msg = MessageTemplate.TEMPLATES[MessageKind.GENERIC]
         .message({'text': '$message'});
-    reportDiagnostic(
-        new DiagnosticMessage(null, null, msg),
-        const <DiagnosticMessage>[],
-        api.Diagnostic.VERBOSE_INFO);
+    reportDiagnostic(new DiagnosticMessage(null, null, msg),
+        const <DiagnosticMessage>[], api.Diagnostic.VERBOSE_INFO);
   }
 
   String tryToString(object) {
     try {
       return object.toString();
     } catch (_) {
       return '<exception in toString()>';
     }
   }
 
   onError(Uri uri, error) {
     try {
       if (!hasCrashed) {
         hasCrashed = true;
         if (error is SpannableAssertionFailure) {
           reportAssertionFailure(error);
         } else {
           reportDiagnostic(
               createMessage(
-                  new SourceSpan(uri, 0, 0),
-                  MessageKind.COMPILER_CRASHED),
+                  new SourceSpan(uri, 0, 0), MessageKind.COMPILER_CRASHED),
               const <DiagnosticMessage>[],
               api.Diagnostic.CRASH);
         }
         pleaseReportCrash();
       }
     } catch (doubleFault) {
       // Ignoring exceptions in exception handling.
     }
     throw error;
   }
 
   void onCrashInUserCode(String message, exception, stackTrace) {
     hasCrashed = true;
     print('$message: ${tryToString(exception)}');
     print(tryToString(stackTrace));
   }
 
   void reportSuppressedMessagesSummary() {
     if (!options.showAllPackageWarnings && !options.suppressWarnings) {
       suppressedWarnings.forEach((Uri uri, SuppressionInfo info) {
         MessageKind kind = MessageKind.HIDDEN_WARNINGS_HINTS;
         if (info.warnings == 0) {
           kind = MessageKind.HIDDEN_HINTS;
         } else if (info.hints == 0) {
           kind = MessageKind.HIDDEN_WARNINGS;
         }
         MessageTemplate template = MessageTemplate.TEMPLATES[kind];
         Message message = template.message(
-            {'warnings': info.warnings,
-             'hints': info.hints,
-             'uri': uri},
-             options.terseDiagnostics);
-        reportDiagnostic(
-            new DiagnosticMessage(null, null, message),
-            const <DiagnosticMessage>[],
-            api.Diagnostic.HINT);
+            {'warnings': info.warnings, 'hints': info.hints, 'uri': uri},
+            options.terseDiagnostics);
+        reportDiagnostic(new DiagnosticMessage(null, null, message),
+            const <DiagnosticMessage>[], api.Diagnostic.HINT);
       });
     }
   }
 }
 
 // TODO(johnniwinther): Move [ResolverTask] here.
 class _CompilerResolution implements Resolution {
   final Compiler compiler;
   final Map<Element, ResolutionImpact> _resolutionImpactCache =
       <Element, ResolutionImpact>{};
@@ skipping 61 matching lines @@
         message: "WorldImpact not computed for $element."));
     return worldImpact;
   }
 
   @override
   WorldImpact computeWorldImpact(Element element) {
     return _worldImpactCache.putIfAbsent(element, () {
       assert(compiler.parser != null);
       Node tree = compiler.parser.parse(element);
       assert(invariant(element, !element.isSynthesized || tree == null));
-      ResolutionImpact resolutionImpact =
-          compiler.resolver.resolve(element);
-      if (compiler.serialization.supportSerialization || retainCachesForTesting) {
+      ResolutionImpact resolutionImpact = compiler.resolver.resolve(element);
+      if (compiler.serialization.supportSerialization ||
+          retainCachesForTesting) {
         // [ResolutionImpact] is currently only used by serialization. The
         // enqueuer uses the [WorldImpact] which is always cached.
         // TODO(johnniwinther): Align these use cases better; maybe only
         // cache [ResolutionImpact] and let the enqueuer transform it into
         // a [WorldImpact].
         _resolutionImpactCache[element] = resolutionImpact;
       }
       if (tree != null && !compiler.options.analyzeSignaturesOnly) {
         // TODO(het): don't do this if suppressWarnings is on, currently we have
         // to do it because the typechecker also sets types
         // Only analyze nodes with a corresponding [TreeElements].
         compiler.checker.check(element);
       }
-      WorldImpact worldImpact =
-          compiler.backend.impactTransformer.transformResolutionImpact(
-              resolutionImpact);
+      WorldImpact worldImpact = compiler.backend.impactTransformer
+          .transformResolutionImpact(resolutionImpact);
       return worldImpact;
     });
   }
 
   @override
   void uncacheWorldImpact(Element element) {
     if (retainCachesForTesting) return;
     if (compiler.serialization.isDeserialized(element)) return;
     assert(invariant(element, _worldImpactCache[element] != null,
         message: "WorldImpact not computed for $element."));
@@ skipping 12 matching lines @@
 
   @override
   bool hasBeenResolved(Element element) {
     return _worldImpactCache.containsKey(element);
   }
 
   @override
   ResolutionWorkItem createWorkItem(
       Element element, ItemCompilationContext compilationContext) {
     if (compiler.serialization.isDeserialized(element)) {
-      return compiler.serialization.createResolutionWorkItem(
-          element, compilationContext);
+      return compiler.serialization
+          .createResolutionWorkItem(element, compilationContext);
     } else {
       return new ResolutionWorkItem(element, compilationContext);
     }
   }
 }
 
 // TODO(johnniwinther): Move [ParserTask], [PatchParserTask], [DietParserTask]
 // and [ScannerTask] here.
 class _CompilerParsing implements Parsing {
   final Compiler compiler;
@@ skipping 45 matching lines @@
   }
 }
 
 // TODO(sigmund): in the future, each of these classes should be self contained
 // and not use references to `compiler`.
 class _ResolvedUriTranslator implements ResolvedUriTranslator {
   Compiler compiler;
   _ResolvedUriTranslator(this.compiler);
 
   Uri translate(LibraryElement importingLibrary, Uri resolvedUri,
-      [Spannable spannable]) =>
-    compiler.translateResolvedUri(importingLibrary, resolvedUri, spannable);
+          [Spannable spannable]) =>
+      compiler.translateResolvedUri(importingLibrary, resolvedUri, spannable);
 }
 
 class _ScriptLoader implements ScriptLoader {
   Compiler compiler;
   _ScriptLoader(this.compiler);
 
   Future<Script> readScript(Uri uri, [Spannable spannable]) =>
       compiler.readScript(uri, spannable);
 }
 
 class _ElementScanner implements ElementScanner {
   ScannerTask scanner;
   _ElementScanner(this.scanner);
   void scanLibrary(LibraryElement library) => scanner.scanLibrary(library);
   void scanUnit(CompilationUnitElement unit) => scanner.scan(unit);
 }
 
 class _EmptyEnvironment implements Environment {
   const _EmptyEnvironment();
 
   String valueOf(String key) => null;
 }