Reformat

pkg/analyzer/lib/src/generated/engine.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import "dart:math" as math;
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/cancelable_future.dart';
 import 'package:analyzer/src/generated/incremental_resolution_validator.dart';
 import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/src/task/task_dart.dart';
 
 import '../../instrumentation/instrumentation.dart';
 import 'ast.dart';
 import 'constant.dart';
 import 'element.dart';
 import 'error.dart';
 import 'error_verifier.dart';
 import 'html.dart' as ht;
-import 'incremental_resolver.dart' show IncrementalResolver,
-    PoorMansIncrementalResolver;
+import 'incremental_resolver.dart'
+    show IncrementalResolver, PoorMansIncrementalResolver;
 import 'incremental_scanner.dart';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'parser.dart' show Parser, IncrementalParser;
 import 'resolver.dart';
 import 'scanner.dart';
 import 'sdk.dart' show DartSdk;
 import 'source.dart';
 import 'utilities_collection.dart';
 import 'utilities_general.dart';
@@ skipping 57 matching lines @@
    *
    * @return information about each of the partitions in this cache
    */
   List<AnalysisContextStatistics_PartitionData> get partitionData {
     int count = _partitions.length;
     List<AnalysisContextStatistics_PartitionData> data =
         new List<AnalysisContextStatistics_PartitionData>(count);
     for (int i = 0; i < count; i++) {
       CachePartition partition = _partitions[i];
       data[i] = new AnalysisContextStatisticsImpl_PartitionDataImpl(
-          partition.astSize,
-          partition.map.length);
+          partition.astSize, partition.map.length);
     }
     return data;
   }
 
   /**
    * Record that the AST associated with the given source was just read from the cache.
    *
    * @param source the source whose AST was accessed
    */
   void accessedAst(Source source) {
@@ skipping 455 matching lines @@
    * Return a future which will be completed with the fully resolved AST for a
    * single compilation unit within the given library, once that AST is up to
    * date.
    *
    * If the resolved AST can't be computed for some reason, the future will be
    * completed with an error.  One possible error is AnalysisNotScheduledError,
    * which means that the resolved AST can't be computed because the given
    * source file is not scheduled to be analyzed within the context of the
    * given library.
    */
-  CancelableFuture<CompilationUnit>
-      computeResolvedCompilationUnitAsync(Source source, Source librarySource);
+  CancelableFuture<CompilationUnit> computeResolvedCompilationUnitAsync(
+      Source source, Source librarySource);
 
   /**
    * Notifies the context that the client is going to stop using this context.
    */
   void dispose();
 
   /**
    * Return `true` if the given source exists.
    *
    * This method should be used rather than the method [Source.exists] because contexts can
    * have local overrides of the content of a source that the source is not aware of and a source
    * with local content is considered to exist even if there is no file on disk.
    *
    * @param source the source whose modification stamp is to be returned
    * @return `true` if the source exists
    */
   bool exists(Source source);
 
   /**
    * Return the element model corresponding to the compilation unit defined by the given source in
    * the library defined by the given source, or `null` if the element model does not
    * currently exist or if the library cannot be analyzed for some reason.
    *
    * @param unitSource the source of the compilation unit
    * @param librarySource the source of the defining compilation unit of the library containing the
    *          compilation unit
    * @return the element model corresponding to the compilation unit defined by the given source
    */
-  CompilationUnitElement getCompilationUnitElement(Source unitSource,
-      Source librarySource);
+  CompilationUnitElement getCompilationUnitElement(
+      Source unitSource, Source librarySource);
 
   /**
    * Get the contents and timestamp of the given source.
    *
    * This method should be used rather than the method [Source.getContents] because contexts
    * can have local overrides of the content of a source that the source is not aware of.
    *
    * @param source the source whose content is to be returned
    * @return the contents and timestamp of the source
    * @throws Exception if the contents of the source could not be accessed
@@ skipping 124 matching lines @@
 
   /**
    * Return a fully resolved AST for a single compilation unit within the given library, or
    * `null` if the resolved AST is not already computed.
    *
    * @param unitSource the source of the compilation unit
    * @param library the library containing the compilation unit
    * @return a fully resolved AST for the compilation unit
    * See [resolveCompilationUnit].
    */
-  CompilationUnit getResolvedCompilationUnit(Source unitSource,
-      LibraryElement library);
+  CompilationUnit getResolvedCompilationUnit(
+      Source unitSource, LibraryElement library);
 
   /**
    * Return a fully resolved AST for a single compilation unit within the given library, or
    * `null` if the resolved AST is not already computed.
    *
    * @param unitSource the source of the compilation unit
    * @param librarySource the source of the defining compilation unit of the library containing the
    *          compilation unit
    * @return a fully resolved AST for the compilation unit
    * See [resolveCompilationUnit].
    */
-  CompilationUnit getResolvedCompilationUnit2(Source unitSource,
-      Source librarySource);
+  CompilationUnit getResolvedCompilationUnit2(
+      Source unitSource, Source librarySource);
 
   /**
    * Return a fully resolved HTML unit, or `null` if the resolved unit is not already
    * computed.
    *
    * @param htmlSource the source of the HTML unit
    * @return a fully resolved HTML unit
    * See [resolveHtmlUnit].
    */
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource);
@@ skipping 73 matching lines @@
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param unitSource the source to be parsed and resolved
    * @param library the library containing the source to be resolved
    * @return the result of resolving the AST structure representing the content of the source in the
    *         context of the given library
    * @throws AnalysisException if the analysis could not be performed
    * See [getResolvedCompilationUnit].
    */
-  CompilationUnit resolveCompilationUnit(Source unitSource,
-      LibraryElement library);
+  CompilationUnit resolveCompilationUnit(
+      Source unitSource, LibraryElement library);
 
   /**
    * Parse and resolve a single source within the given context to produce a fully resolved AST.
    * Return the resolved AST structure, or `null` if the source could not be either parsed or
    * resolved.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param unitSource the source to be parsed and resolved
    * @param librarySource the source of the defining compilation unit of the library containing the
    *          source to be resolved
    * @return the result of resolving the AST structure representing the content of the source in the
    *         context of the given library
    * @throws AnalysisException if the analysis could not be performed
    * See [getResolvedCompilationUnit].
    */
-  CompilationUnit resolveCompilationUnit2(Source unitSource,
-      Source librarySource);
+  CompilationUnit resolveCompilationUnit2(
+      Source unitSource, Source librarySource);
 
   /**
    * Parse and resolve a single source within the given context to produce a fully resolved AST.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param htmlSource the source to be parsed and resolved
    * @return the result of resolving the AST structure representing the content of the source
    * @throws AnalysisException if the analysis could not be performed
    */
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource);
 
   /**
    * Set the contents of the given source to the given contents and mark the source as having
    * changed. The additional offset and length information is used by the context to determine what
    * reanalysis is necessary.
    *
    * @param source the source whose contents are being overridden
    * @param contents the text to replace the range in the current contents
    * @param offset the offset into the current contents
    * @param oldLength the number of characters in the original contents that were replaced
    * @param newLength the number of characters in the replacement text
    */
-  void setChangedContents(Source source, String contents, int offset,
-      int oldLength, int newLength);
+  void setChangedContents(
+      Source source, String contents, int offset, int oldLength, int newLength);
 
   /**
    * Set the contents of the given source to the given contents and mark the source as having
    * changed. This has the effect of overriding the default contents of the source. If the contents
    * are `null` the override is removed so that the default contents will be returned.
    *
    * @param source the source whose contents are being overridden
    * @param contents the new contents of the source
    */
   void setContents(Source source, String contents);
@@ skipping 173 matching lines @@
   ResolverVisitorFactory resolverVisitorFactory;
 
   /** A factory to override how [TypeResolverVisitor] is created. */
   TypeResolverVisitorFactory typeResolverVisitorFactory;
 
   /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
-    _privatePartition = new UniversalCachePartition(
-        this,
+    _privatePartition = new UniversalCachePartition(this,
         AnalysisOptionsImpl.DEFAULT_CACHE_SIZE,
         new AnalysisContextImpl_ContextRetentionPolicy(this));
     _cache = createCacheFromSourceFactory(null);
     _onSourcesChangedController =
         new StreamController<SourcesChangedEvent>.broadcast();
   }
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
   void set analysisOptions(AnalysisOptions options) {
-    bool needsRecompute =
-        this._options.analyzeFunctionBodiesPredicate !=
+    bool needsRecompute = this._options.analyzeFunctionBodiesPredicate !=
             options.analyzeFunctionBodiesPredicate ||
         this._options.generateSdkErrors != options.generateSdkErrors ||
         this._options.dart2jsHint != options.dart2jsHint ||
         (this._options.hint && !options.hint) ||
         this._options.preserveComments != options.preserveComments;
     int cacheSize = options.cacheSize;
     if (this._options.cacheSize != cacheSize) {
       this._options.cacheSize = cacheSize;
       //cache.setMaxCacheSize(cacheSize);
       _privatePartition.maxCacheSize = cacheSize;
       //
       // Cap the size of the priority list to being less than the cache size.
       // Failure to do so can result in an infinite loop in
       // performAnalysisTask() because re-caching one AST structure
       // can cause another priority source's AST structure to be flushed.
       //
       int maxPriorityOrderSize = cacheSize - _PRIORITY_ORDER_SIZE_DELTA;
       if (_priorityOrder.length > maxPriorityOrderSize) {
         List<Source> newPriorityOrder = new List<Source>(maxPriorityOrderSize);
         JavaSystem.arraycopy(
-            _priorityOrder,
-            0,
-            newPriorityOrder,
-            0,
-            maxPriorityOrderSize);
+            _priorityOrder, 0, newPriorityOrder, 0, maxPriorityOrderSize);
         _priorityOrder = newPriorityOrder;
       }
     }
     this._options.analyzeFunctionBodiesPredicate =
         options.analyzeFunctionBodiesPredicate;
     this._options.generateSdkErrors = options.generateSdkErrors;
     this._options.dart2jsHint = options.dart2jsHint;
     this._options.hint = options.hint;
     this._options.incremental = options.incremental;
     this._options.incrementalApi = options.incrementalApi;
@@ skipping 16 matching lines @@
       }
       if (sources.isEmpty) {
         _priorityOrder = Source.EMPTY_ARRAY;
       }
       //
       // Cap the size of the priority list to being less than the cache size.
       // Failure to do so can result in an infinite loop in
       // performAnalysisTask() because re-caching one AST structure
       // can cause another priority source's AST structure to be flushed.
       //
-      int count =
-          math.min(sources.length, _options.cacheSize - _PRIORITY_ORDER_SIZE_DELTA);
+      int count = math.min(
+          sources.length, _options.cacheSize - _PRIORITY_ORDER_SIZE_DELTA);
       _priorityOrder = new List<Source>(count);
       for (int i = 0; i < count; i++) {
         _priorityOrder[i] = sources[i];
       }
     }
   }
 
   @override
   set contentCache(ContentCache value) {
     _contentCache = value;
@@ skipping 72 matching lines @@
     //
     // Look for a source that needs to be analyzed because it has futures
     // pending.
     //
     if (_pendingFutureSources.isNotEmpty) {
       List<Source> sourcesToRemove = <Source>[];
       AnalysisTask task;
       for (Source source in _pendingFutureSources.keys) {
         SourceEntry sourceEntry = _cache.get(source);
         List<PendingFuture> pendingFutures = _pendingFutureSources[source];
-        for (int i = 0; i < pendingFutures.length; ) {
+        for (int i = 0; i < pendingFutures.length;) {
           if (pendingFutures[i].evaluate(sourceEntry)) {
             pendingFutures.removeAt(i);
           } else {
             i++;
           }
         }
         if (pendingFutures.isEmpty) {
           sourcesToRemove.add(source);
           continue;
         }
         AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(
-            source,
-            sourceEntry,
-            true,
-            hintsEnabled,
-            lintsEnabled);
+            source, sourceEntry, true, hintsEnabled, lintsEnabled);
         task = taskData.task;
         if (task != null) {
           break;
         } else if (taskData.isBlocked) {
           hasBlockedTask = true;
         } else {
           // There is no more work to do for this task, so forcibly complete
           // all its pending futures.
           for (PendingFuture pendingFuture in pendingFutures) {
             pendingFuture.forciblyComplete();
           }
           sourcesToRemove.add(source);
         }
       }
       for (Source source in sourcesToRemove) {
         _pendingFutureSources.remove(source);
       }
       if (task != null) {
         return task;
       }
     }
     //
     // Look for a priority source that needs to be analyzed.
     //
     int priorityCount = _priorityOrder.length;
     for (int i = 0; i < priorityCount; i++) {
       Source source = _priorityOrder[i];
       AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(
-          source,
-          _cache.get(source),
-          true,
-          hintsEnabled,
-          lintsEnabled);
+          source, _cache.get(source), true, hintsEnabled, lintsEnabled);
       AnalysisTask task = taskData.task;
       if (task != null) {
         return task;
       } else if (taskData.isBlocked) {
         hasBlockedTask = true;
       }
     }
     if (_neededForResolution != null) {
       List<Source> sourcesToRemove = new List<Source>();
       for (Source source in _neededForResolution) {
@@ skipping 23 matching lines @@
     }
     //
     // Look for a non-priority source that needs to be analyzed.
     //
     List<Source> sourcesToRemove = new List<Source>();
     WorkManager_WorkIterator sources = _workManager.iterator();
     try {
       while (sources.hasNext) {
         Source source = sources.next();
         AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(
-            source,
-            _cache.get(source),
-            false,
-            hintsEnabled,
-            lintsEnabled);
+            source, _cache.get(source), false, hintsEnabled, lintsEnabled);
         AnalysisTask task = taskData.task;
         if (task != null) {
           return task;
         } else if (taskData.isBlocked) {
           hasBlockedTask = true;
         } else {
           sourcesToRemove.add(source);
         }
       }
     } finally {
@@ skipping 70 matching lines @@
    */
   List<Source> get sourcesNeedingProcessing {
     HashSet<Source> sources = new HashSet<Source>();
     bool hintsEnabled = _options.hint;
     bool lintsEnabled = _options.lint;
 
     //
     // Look for priority sources that need to be analyzed.
     //
     for (Source source in _priorityOrder) {
-      _getSourcesNeedingProcessing(
-          source,
-          _cache.get(source),
-          true,
-          hintsEnabled,
-          lintsEnabled,
-          sources);
+      _getSourcesNeedingProcessing(source, _cache.get(source), true,
+          hintsEnabled, lintsEnabled, sources);
     }
     //
     // Look for non-priority sources that need to be analyzed.
     //
     WorkManager_WorkIterator iterator = _workManager.iterator();
     while (iterator.hasNext) {
       Source source = iterator.next();
-      _getSourcesNeedingProcessing(
-          source,
-          _cache.get(source),
-          false,
-          hintsEnabled,
-          lintsEnabled,
-          sources);
+      _getSourcesNeedingProcessing(source,
+          _cache.get(source), false, hintsEnabled, lintsEnabled, sources);
     }
     return new List<Source>.from(sources);
   }
 
   @override
   AnalysisContextStatistics get statistics {
     AnalysisContextStatisticsImpl statistics =
         new AnalysisContextStatisticsImpl();
     visitCacheItems(statistics._internalPutCacheItem);
     statistics.partitionData = _cache.partitionData;
@@ skipping 85 matching lines @@
         // re-analysis.
         continue;
       }
       _sourceChanged(source);
     }
     changeSet.changedContents.forEach((Source key, String value) {
       _contentsChanged(key, value, false);
     });
     changeSet.changedRanges.forEach(
         (Source source, ChangeSet_ContentChange change) {
-      _contentRangeChanged(
-          source,
-          change.contents,
-          change.offset,
-          change.oldLength,
-          change.newLength);
+      _contentRangeChanged(source, change.contents, change.offset,
+          change.oldLength, change.newLength);
     });
     for (Source source in changeSet.deletedSources) {
       _sourceDeleted(source);
     }
     for (Source source in removedSources) {
       _sourceRemoved(source);
     }
     _onSourcesChangedController.add(new SourcesChangedEvent(changeSet));
   }
 
@@ skipping 37 matching lines @@
   List<AnalysisError> computeErrors(Source source) {
     bool enableHints = _options.hint;
     bool enableLints = _options.lint;
 
     SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
       List<AnalysisError> errors = new List<AnalysisError>();
       try {
         DartEntry dartEntry = sourceEntry;
         ListUtilities.addAll(
-            errors,
-            _getDartScanData(source, dartEntry, DartEntry.SCAN_ERRORS));
+            errors, _getDartScanData(source, dartEntry, DartEntry.SCAN_ERRORS));
         dartEntry = _getReadableDartEntry(source);
-        ListUtilities.addAll(
-            errors,
+        ListUtilities.addAll(errors,
             _getDartParseData(source, dartEntry, DartEntry.PARSE_ERRORS));
         dartEntry = _getReadableDartEntry(source);
         if (dartEntry.getValue(DartEntry.SOURCE_KIND) == SourceKind.LIBRARY) {
-          ListUtilities.addAll(
-              errors,
-              _getDartResolutionData(source, source, dartEntry, DartEntry.RESOLUTION_ERRORS));
+          ListUtilities.addAll(errors, _getDartResolutionData(
+              source, source, dartEntry, DartEntry.RESOLUTION_ERRORS));
           dartEntry = _getReadableDartEntry(source);
-          ListUtilities.addAll(
-              errors,
-              _getDartVerificationData(
-                  source,
-                  source,
-                  dartEntry,
-                  DartEntry.VERIFICATION_ERRORS));
+          ListUtilities.addAll(errors, _getDartVerificationData(
+              source, source, dartEntry, DartEntry.VERIFICATION_ERRORS));
           if (enableHints) {
             dartEntry = _getReadableDartEntry(source);
-            ListUtilities.addAll(
-                errors,
+            ListUtilities.addAll(errors,
                 _getDartHintData(source, source, dartEntry, DartEntry.HINTS));
           }
           if (enableLints) {
             dartEntry = _getReadableDartEntry(source);
-            ListUtilities.addAll(
-                errors,
+            ListUtilities.addAll(errors,
                 _getDartLintData(source, source, dartEntry, DartEntry.LINTS));
           }
         } else {
           List<Source> libraries = getLibrariesContaining(source);
           for (Source librarySource in libraries) {
-            ListUtilities.addAll(
-                errors,
-                _getDartResolutionData(
-                    source,
-                    librarySource,
-                    dartEntry,
-                    DartEntry.RESOLUTION_ERRORS));
+            ListUtilities.addAll(errors, _getDartResolutionData(
+                source, librarySource, dartEntry, DartEntry.RESOLUTION_ERRORS));
             dartEntry = _getReadableDartEntry(source);
-            ListUtilities.addAll(
-                errors,
-                _getDartVerificationData(
-                    source,
-                    librarySource,
-                    dartEntry,
-                    DartEntry.VERIFICATION_ERRORS));
+            ListUtilities.addAll(errors, _getDartVerificationData(source,
+                librarySource, dartEntry, DartEntry.VERIFICATION_ERRORS));
             if (enableHints) {
               dartEntry = _getReadableDartEntry(source);
-              ListUtilities.addAll(
-                  errors,
-                  _getDartHintData(source, librarySource, dartEntry, DartEntry.HINTS));
+              ListUtilities.addAll(errors, _getDartHintData(
+                  source, librarySource, dartEntry, DartEntry.HINTS));
             }
             if (enableLints) {
               dartEntry = _getReadableDartEntry(source);
-              ListUtilities.addAll(
-                  errors,
-                  _getDartLintData(source, librarySource, dartEntry, DartEntry.LINTS));
+              ListUtilities.addAll(errors, _getDartLintData(
+                  source, librarySource, dartEntry, DartEntry.LINTS));
             }
           }
         }
       } on ObsoleteSourceAnalysisException catch (exception, stackTrace) {
         AnalysisEngine.instance.logger.logInformation(
             "Could not compute errors",
             new CaughtException(exception, stackTrace));
       }
       if (errors.isEmpty) {
         return AnalysisError.NO_ERRORS;
       }
       return errors;
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       try {
         return _getHtmlResolutionData2(
-            source,
-            htmlEntry,
-            HtmlEntry.RESOLUTION_ERRORS);
+            source, htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
       } on ObsoleteSourceAnalysisException catch (exception, stackTrace) {
         AnalysisEngine.instance.logger.logInformation(
             "Could not compute errors",
             new CaughtException(exception, stackTrace));
       }
     }
     return AnalysisError.NO_ERRORS;
   }
 
   @override
-  List<Source> computeExportedLibraries(Source source) =>
-      _getDartParseData2(source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+  List<Source> computeExportedLibraries(Source source) => _getDartParseData2(
+      source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
 
   @override
   HtmlElement computeHtmlElement(Source source) =>
       _getHtmlResolutionData(source, HtmlEntry.ELEMENT, null);
 
   @override
-  List<Source> computeImportedLibraries(Source source) =>
-      _getDartParseData2(source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+  List<Source> computeImportedLibraries(Source source) => _getDartParseData2(
+      source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
 
   @override
   SourceKind computeKindOf(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     } else if (sourceEntry is DartEntry) {
       try {
         return _getDartParseData(source, sourceEntry, DartEntry.SOURCE_KIND);
       } on AnalysisException catch (exception) {
@@ skipping 35 matching lines @@
     CompilationUnit unit = dartEntry.resolvableCompilationUnit;
     if (unit == null) {
       throw new AnalysisException(
           "Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}",
           new CaughtException(dartEntry.exception, null));
     }
     return unit;
   }
 
   @override
-  CancelableFuture<CompilationUnit>
-      computeResolvedCompilationUnitAsync(Source unitSource, Source librarySource) {
-    return new _AnalysisFutureHelper<CompilationUnit>(
-        this).computeAsync(unitSource, (SourceEntry sourceEntry) {
+  CancelableFuture<CompilationUnit> computeResolvedCompilationUnitAsync(
+      Source unitSource, Source librarySource) {
+    return new _AnalysisFutureHelper<CompilationUnit>(this).computeAsync(
+        unitSource, (SourceEntry sourceEntry) {
       if (sourceEntry is DartEntry) {
         if (sourceEntry.getStateInLibrary(
-            DartEntry.RESOLVED_UNIT,
-            librarySource) ==
+                DartEntry.RESOLVED_UNIT, librarySource) ==
             CacheState.ERROR) {
           throw sourceEntry.exception;
         }
         return sourceEntry.getValueInLibrary(
-            DartEntry.RESOLVED_UNIT,
-            librarySource);
+            DartEntry.RESOLVED_UNIT, librarySource);
       }
       throw new AnalysisNotScheduledError();
     });
   }
 
   /**
    * Create an analysis cache based on the given source factory.
    *
    * @param factory the source factory containing the information needed to create the cache
    * @return the cache that was created
    */
   AnalysisCache createCacheFromSourceFactory(SourceFactory factory) {
     if (factory == null) {
       return new AnalysisCache(<CachePartition>[_privatePartition]);
     }
     DartSdk sdk = factory.dartSdk;
     if (sdk == null) {
       return new AnalysisCache(<CachePartition>[_privatePartition]);
     }
-    return new AnalysisCache(
-        <CachePartition>[
-            AnalysisEngine.instance.partitionManager.forSdk(sdk),
-            _privatePartition]);
+    return new AnalysisCache(<CachePartition>[
+      AnalysisEngine.instance.partitionManager.forSdk(sdk),
+      _privatePartition
+    ]);
   }
 
   @override
   void dispose() {
     _disposed = true;
     for (List<PendingFuture> pendingFutures in _pendingFutureSources.values) {
       for (PendingFuture pendingFuture in pendingFutures) {
         pendingFuture.forciblyComplete();
       }
     }
@@ skipping 17 matching lines @@
         units = null;
         break;
       }
       units.add(unit);
     }
     // Invalidate the flushed RESOLVED_UNIT to force it eventually.
     if (units == null) {
       bool shouldBeScheduled = false;
       for (Source librarySource in containingLibraries) {
         if (dartEntry.getStateInLibrary(
-            DartEntry.RESOLVED_UNIT,
-            librarySource) ==
+                DartEntry.RESOLVED_UNIT, librarySource) ==
             CacheState.FLUSHED) {
           dartEntry.setStateInLibrary(
-              DartEntry.RESOLVED_UNIT,
-              librarySource,
-              CacheState.INVALID);
+              DartEntry.RESOLVED_UNIT, librarySource, CacheState.INVALID);
           shouldBeScheduled = true;
         }
       }
       if (shouldBeScheduled) {
         _workManager.add(unitSource, SourcePriority.UNKNOWN);
       }
       // We cannot provide resolved units right now,
       // but the future analysis will.
       return null;
     }
@@ skipping 26 matching lines @@
           }
         }
       }
     } on _ElementByIdFinderException catch (e) {
       return finder.result;
     }
     return null;
   }
 
   @override
-  CompilationUnitElement getCompilationUnitElement(Source unitSource,
-      Source librarySource) {
+  CompilationUnitElement getCompilationUnitElement(
+      Source unitSource, Source librarySource) {
     LibraryElement libraryElement = getLibraryElement(librarySource);
     if (libraryElement != null) {
       // try defining unit
       CompilationUnitElement definingUnit =
           libraryElement.definingCompilationUnit;
       if (definingUnit.source == unitSource) {
         return definingUnit;
       }
       // try parts
       for (CompilationUnitElement partUnit in libraryElement.parts) {
         if (partUnit.source == unitSource) {
           return partUnit;
         }
       }
     }
     return null;
   }
 
   @override
   TimestampedData<String> getContents(Source source) {
     String contents = _contentCache.getContents(source);
     if (contents != null) {
       return new TimestampedData<String>(
-          _contentCache.getModificationStamp(source),
-          contents);
+          _contentCache.getModificationStamp(source), contents);
     }
     return source.contents;
   }
 
   @override
   InternalAnalysisContext getContextFor(Source source) {
     InternalAnalysisContext context = _cache.getContextFor(source);
     return context == null ? this : context;
   }
 
@@ skipping 24 matching lines @@
     }
     return null;
   }
 
   @override
   AnalysisErrorInfo getErrors(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return new AnalysisErrorInfoImpl(
-          dartEntry.allErrors,
-          dartEntry.getValue(SourceEntry.LINE_INFO));
+          dartEntry.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return new AnalysisErrorInfoImpl(
-          htmlEntry.allErrors,
-          htmlEntry.getValue(SourceEntry.LINE_INFO));
+          htmlEntry.allErrors, htmlEntry.getValue(SourceEntry.LINE_INFO));
     }
     return new AnalysisErrorInfoImpl(AnalysisError.NO_ERRORS, null);
   }
 
   @override
   HtmlElement getHtmlElement(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
     if (sourceEntry is HtmlEntry) {
       return sourceEntry.getValue(HtmlEntry.ELEMENT);
     }
     return null;
   }
 
   @override
   List<Source> getHtmlFilesReferencing(Source source) {
     SourceKind sourceKind = getKindOf(source);
     if (sourceKind == null) {
       return Source.EMPTY_ARRAY;
     }
     List<Source> htmlSources = new List<Source>();
     while (true) {
       if (sourceKind == SourceKind.PART) {
         List<Source> librarySources = getLibrariesContaining(source);
         MapIterator<Source, SourceEntry> partIterator = _cache.iterator();
         while (partIterator.moveNext()) {
           SourceEntry sourceEntry = partIterator.value;
           if (sourceEntry.kind == SourceKind.HTML) {
-            List<Source> referencedLibraries =
-                (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
+            List<Source> referencedLibraries = (sourceEntry as HtmlEntry)
+                .getValue(HtmlEntry.REFERENCED_LIBRARIES);
             if (_containsAny(referencedLibraries, librarySources)) {
               htmlSources.add(partIterator.key);
             }
           }
         }
       } else {
         MapIterator<Source, SourceEntry> iterator = _cache.iterator();
         while (iterator.moveNext()) {
           SourceEntry sourceEntry = iterator.value;
           if (sourceEntry.kind == SourceKind.HTML) {
-            List<Source> referencedLibraries =
-                (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
+            List<Source> referencedLibraries = (sourceEntry as HtmlEntry)
+                .getValue(HtmlEntry.REFERENCED_LIBRARIES);
             if (_contains(referencedLibraries, source)) {
               htmlSources.add(iterator.key);
             }
           }
         }
       }
       break;
     }
     if (htmlSources.isEmpty) {
       return Source.EMPTY_ARRAY;
@@ skipping 93 matching lines @@
     Namespace namespace = null;
     if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
       namespace = dartEntry.getValue(DartEntry.PUBLIC_NAMESPACE);
     }
     if (namespace == null) {
       NamespaceBuilder builder = new NamespaceBuilder();
       namespace = builder.createPublicNamespaceForLibrary(library);
       if (dartEntry == null) {
         AnalysisEngine.instance.logger.logError(
             "Could not compute the public namespace for ${library.source.fullName}",
-            new CaughtException(
-                new AnalysisException("A Dart file became a non-Dart file: ${source.fullName}"),
+            new CaughtException(new AnalysisException(
+                    "A Dart file became a non-Dart file: ${source.fullName}"),
                 null));
         return null;
       }
       if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
         dartEntry.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
       }
     }
     return namespace;
   }
 
   /**
    * Return the cache entry associated with the given source, or `null` if there is no entry
    * associated with the source.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
    */
   SourceEntry getReadableSourceEntryOrNull(Source source) => _cache.get(source);
 
   @override
-  CompilationUnit getResolvedCompilationUnit(Source unitSource,
-      LibraryElement library) {
+  CompilationUnit getResolvedCompilationUnit(
+      Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return getResolvedCompilationUnit2(unitSource, library.source);
   }
 
   @override
-  CompilationUnit getResolvedCompilationUnit2(Source unitSource,
-      Source librarySource) {
+  CompilationUnit getResolvedCompilationUnit2(
+      Source unitSource, Source librarySource) {
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(unitSource);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValueInLibrary(
-          DartEntry.RESOLVED_UNIT,
-          librarySource);
+          DartEntry.RESOLVED_UNIT, librarySource);
     }
     return null;
   }
 
   @override
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
     }
     return null;
   }
 
   @override
-  bool handleContentsChanged(Source source, String originalContents,
-      String newContents, bool notify) {
+  bool handleContentsChanged(
+      Source source, String originalContents, String newContents, bool notify) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       return false;
     }
     bool changed = newContents != originalContents;
     if (newContents != null) {
       if (newContents != originalContents) {
         _incrementalAnalysisCache =
             IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         if (!analysisOptions.incremental ||
@@ skipping 14 matching lines @@
       // We are removing the overlay for the file, check if the file's
       // contents is the same as it was in the overlay.
       try {
         TimestampedData<String> fileContents = getContents(source);
         String fileContentsData = fileContents.data;
         if (fileContentsData == originalContents) {
           sourceEntry.setValue(SourceEntry.CONTENT, fileContentsData);
           sourceEntry.modificationTime = fileContents.modificationTime;
           changed = false;
         }
-      } catch (e) {
-      }
+      } catch (e) {}
       // If not the same content (e.g. the file is being closed without save),
       // then force analysis.
       if (changed) {
         _sourceChanged(source);
       }
     }
     if (notify && changed) {
-      _onSourcesChangedController.add(
-          new SourcesChangedEvent.changedContent(source, newContents));
+      _onSourcesChangedController
+          .add(new SourcesChangedEvent.changedContent(source, newContents));
     }
     return changed;
   }
 
   /**
    * Invalidates hints in the given [librarySource] and included parts.
    */
   void invalidateLibraryHints(Source librarySource) {
     SourceEntry sourceEntry = _cache.get(librarySource);
     if (sourceEntry is! DartEntry) {
       return;
     }
     DartEntry dartEntry = sourceEntry;
     // Prepare sources to invalidate hints in.
     List<Source> sources = <Source>[librarySource];
     sources.addAll(dartEntry.getValue(DartEntry.INCLUDED_PARTS));
     // Invalidate hints.
     for (Source source in sources) {
       DartEntry dartEntry = _cache.get(source);
       if (dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource) ==
           CacheState.VALID) {
         dartEntry.setStateInLibrary(
-            DartEntry.HINTS,
-            librarySource,
-            CacheState.INVALID);
+            DartEntry.HINTS, librarySource, CacheState.INVALID);
       }
     }
   }
 
   @override
   bool isClientLibrary(Source librarySource) {
     SourceEntry sourceEntry = _getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return dartEntry.getValue(DartEntry.IS_CLIENT) &&
@@ skipping 21 matching lines @@
   ht.HtmlUnit parseHtmlUnit(Source source) =>
       _getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
 
   @override
   AnalysisResult performAnalysisTask() {
     if (_TRACE_PERFORM_TASK) {
       print("----------------------------------------");
     }
     return PerformanceStatistics.performAnaysis.makeCurrentWhile(() {
       int getStart = JavaSystem.currentTimeMillis();
-      AnalysisTask task =
-          PerformanceStatistics.nextTask.makeCurrentWhile(() => nextAnalysisTask);
+      AnalysisTask task = PerformanceStatistics.nextTask
+          .makeCurrentWhile(() => nextAnalysisTask);
       int getEnd = JavaSystem.currentTimeMillis();
       if (task == null && _validateCacheConsistency()) {
         task = nextAnalysisTask;
       }
       if (task == null) {
         _validateLastIncrementalResolutionResult();
         if (_performAnalysisTaskStopwatch != null) {
           AnalysisEngine.instance.instrumentationService.logPerformance(
-              AnalysisPerformanceKind.FULL,
-              _performAnalysisTaskStopwatch,
+              AnalysisPerformanceKind.FULL, _performAnalysisTaskStopwatch,
               'context_id=$_id');
           _performAnalysisTaskStopwatch = null;
         }
         return new AnalysisResult(
-            _getChangeNotices(true),
-            getEnd - getStart,
-            null,
-            -1);
+            _getChangeNotices(true), getEnd - getStart, null, -1);
       }
       if (_performAnalysisTaskStopwatch == null) {
         _performAnalysisTaskStopwatch = new Stopwatch()..start();
       }
       String taskDescription = task.toString();
       _notifyAboutToPerformTask(taskDescription);
       if (_TRACE_PERFORM_TASK) {
         print(taskDescription);
       }
       int performStart = JavaSystem.currentTimeMillis();
@@ skipping 20 matching lines @@
         // always resolved, or whether we need to decide whether to invoke the
         // "parsed" or "resolved" method. This might be better done when
         // recording task results in order to reduce the chance of errors.
 //        if (notice.getCompilationUnit() != null) {
 //          notifyResolvedDart(source, notice.getCompilationUnit());
 //        } else if (notice.getHtmlUnit() != null) {
 //          notifyResolvedHtml(source, notice.getHtmlUnit());
 //        }
         _notifyErrors(source, notice.errors, notice.lineInfo);
       }
-      return new AnalysisResult(
-          notices,
-          getEnd - getStart,
-          task.runtimeType.toString(),
-          performEnd - performStart);
+      return new AnalysisResult(notices, getEnd - getStart,
+          task.runtimeType.toString(), performEnd - performStart);
     });
   }
 
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
     elementMap.forEach((Source librarySource, LibraryElement library) {
       //
       // Cache the element in the library's info.
       //
       DartEntry dartEntry = _getReadableDartEntry(librarySource);
       if (dartEntry != null) {
         _recordElementData(dartEntry, library, library.source, htmlSource);
         dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
         dartEntry.setValue(SourceEntry.LINE_INFO, new LineInfo(<int>[0]));
         // DartEntry.ELEMENT - set in recordElementData
         dartEntry.setValue(DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
         dartEntry.setValue(DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
         dartEntry.setValue(DartEntry.INCLUDED_PARTS, Source.EMPTY_ARRAY);
         // DartEntry.IS_CLIENT - set in recordElementData
         // DartEntry.IS_LAUNCHABLE - set in recordElementData
         dartEntry.setValue(DartEntry.PARSE_ERRORS, AnalysisError.NO_ERRORS);
         dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
         dartEntry.setState(DartEntry.PUBLIC_NAMESPACE, CacheState.FLUSHED);
         dartEntry.setValue(DartEntry.SCAN_ERRORS, AnalysisError.NO_ERRORS);
         dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
         dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
+        dartEntry.setValueInLibrary(DartEntry.RESOLUTION_ERRORS,
+            librarySource, AnalysisError.NO_ERRORS);
+        dartEntry.setStateInLibrary(
+            DartEntry.RESOLVED_UNIT, librarySource, CacheState.FLUSHED);
+        dartEntry.setValueInLibrary(DartEntry.VERIFICATION_ERRORS,
+            librarySource, AnalysisError.NO_ERRORS);
         dartEntry.setValueInLibrary(
-            DartEntry.RESOLUTION_ERRORS,
-            librarySource,
-            AnalysisError.NO_ERRORS);
-        dartEntry.setStateInLibrary(
-            DartEntry.RESOLVED_UNIT,
-            librarySource,
-            CacheState.FLUSHED);
+            DartEntry.HINTS, librarySource, AnalysisError.NO_ERRORS);
         dartEntry.setValueInLibrary(
-            DartEntry.VERIFICATION_ERRORS,
-            librarySource,
-            AnalysisError.NO_ERRORS);
-        dartEntry.setValueInLibrary(
-            DartEntry.HINTS,
-            librarySource,
-            AnalysisError.NO_ERRORS);
-        dartEntry.setValueInLibrary(
-            DartEntry.LINTS,
-            librarySource,
-            AnalysisError.NO_ERRORS);
+            DartEntry.LINTS, librarySource, AnalysisError.NO_ERRORS);
       }
     });
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
-  DartEntry
-      recordResolveDartLibraryCycleTaskResults(ResolveDartLibraryCycleTask task) {
+  DartEntry recordResolveDartLibraryCycleTaskResults(
+      ResolveDartLibraryCycleTask task) {
     LibraryResolver2 resolver = task.libraryResolver;
     CaughtException thrownException = task.exception;
     Source unitSource = task.unitSource;
     DartEntry unitEntry = _getReadableDartEntry(unitSource);
     if (resolver != null) {
       //
       // The resolver should only be null if an exception was thrown before (or
       // while) it was being created.
       //
       List<ResolvableLibrary> resolvedLibraries = resolver.resolvedLibraries;
       if (resolvedLibraries == null) {
         //
         // The resolved libraries should only be null if an exception was thrown
         // during resolution.
         //
         if (thrownException == null) {
-          var message =
-              "In recordResolveDartLibraryCycleTaskResults, "
-                  "resolvedLibraries was null and there was no thrown exception";
+          var message = "In recordResolveDartLibraryCycleTaskResults, "
+              "resolvedLibraries was null and there was no thrown exception";
           unitEntry.recordResolutionError(
               new CaughtException(new AnalysisException(message), null));
         } else {
           unitEntry.recordResolutionError(thrownException);
         }
         _cache.remove(unitSource);
         if (thrownException != null) {
           throw new AnalysisException('<rethrow>', thrownException);
         }
         return unitEntry;
       }
       Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
       RecordingErrorListener errorListener = resolver.errorListener;
       for (ResolvableLibrary library in resolvedLibraries) {
         Source librarySource = library.librarySource;
         for (Source source in library.compilationUnitSources) {
           CompilationUnit unit = library.getAST(source);
           List<AnalysisError> errors = errorListener.getErrorsForSource(source);
           LineInfo lineInfo = getLineInfo(source);
           DartEntry dartEntry = _cache.get(source);
           if (thrownException == null) {
             dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
             dartEntry.setValueInLibrary(
-                DartEntry.RESOLVED_UNIT,
-                librarySource,
-                unit);
+                DartEntry.RESOLVED_UNIT, librarySource, unit);
             dartEntry.setValueInLibrary(
-                DartEntry.RESOLUTION_ERRORS,
-                librarySource,
-                errors);
+                DartEntry.RESOLUTION_ERRORS, librarySource, errors);
             if (source == librarySource) {
               _recordElementData(
-                  dartEntry,
-                  library.libraryElement,
-                  librarySource,
-                  htmlSource);
+                  dartEntry, library.libraryElement, librarySource, htmlSource);
             }
             _cache.storedAst(source);
           } else {
             dartEntry.recordResolutionErrorInLibrary(
-                librarySource,
-                thrownException);
+                librarySource, thrownException);
           }
           if (source != librarySource) {
             _workManager.add(source, SourcePriority.PRIORITY_PART);
           }
           ChangeNoticeImpl notice = _getNotice(source);
           notice.resolvedDartUnit = unit;
           notice.setErrors(dartEntry.allErrors, lineInfo);
         }
       }
     }
@@ skipping 17 matching lines @@
       // The resolver should only be null if an exception was thrown before (or
       // while) it was being created.
       //
       Set<Library> resolvedLibraries = resolver.resolvedLibraries;
       if (resolvedLibraries == null) {
         //
         // The resolved libraries should only be null if an exception was thrown
         // during resolution.
         //
         if (thrownException == null) {
-          String message =
-              "In recordResolveDartLibraryTaskResults, "
-                  "resolvedLibraries was null and there was no thrown exception";
+          String message = "In recordResolveDartLibraryTaskResults, "
+              "resolvedLibraries was null and there was no thrown exception";
           unitEntry.recordResolutionError(
               new CaughtException(new AnalysisException(message), null));
         } else {
           unitEntry.recordResolutionError(thrownException);
         }
         _cache.remove(unitSource);
         if (thrownException != null) {
           throw new AnalysisException('<rethrow>', thrownException);
         }
         return unitEntry;
       }
       Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
       RecordingErrorListener errorListener = resolver.errorListener;
       for (Library library in resolvedLibraries) {
         Source librarySource = library.librarySource;
         for (Source source in library.compilationUnitSources) {
           CompilationUnit unit = library.getAST(source);
           List<AnalysisError> errors = errorListener.getErrorsForSource(source);
           LineInfo lineInfo = getLineInfo(source);
           DartEntry dartEntry = _cache.get(source);
           if (thrownException == null) {
             dartEntry.setValue(SourceEntry.LINE_INFO, lineInfo);
             dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
             dartEntry.setValueInLibrary(
-                DartEntry.RESOLVED_UNIT,
-                librarySource,
-                unit);
+                DartEntry.RESOLVED_UNIT, librarySource, unit);
             dartEntry.setValueInLibrary(
-                DartEntry.RESOLUTION_ERRORS,
-                librarySource,
-                errors);
+                DartEntry.RESOLUTION_ERRORS, librarySource, errors);
             if (source == librarySource) {
               _recordElementData(
-                  dartEntry,
-                  library.libraryElement,
-                  librarySource,
-                  htmlSource);
+                  dartEntry, library.libraryElement, librarySource, htmlSource);
             }
             _cache.storedAst(source);
           } else {
             dartEntry.recordResolutionErrorInLibrary(
-                librarySource,
-                thrownException);
+                librarySource, thrownException);
             _cache.remove(source);
           }
           if (source != librarySource) {
             _workManager.add(source, SourcePriority.PRIORITY_PART);
           }
           ChangeNoticeImpl notice = _getNotice(source);
           notice.resolvedDartUnit = unit;
           notice.setErrors(dartEntry.allErrors, lineInfo);
         }
       }
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', thrownException);
     }
     return unitEntry;
   }
 
   @override
   void removeListener(AnalysisListener listener) {
     _listeners.remove(listener);
   }
 
   @override
-  CompilationUnit resolveCompilationUnit(Source unitSource,
-      LibraryElement library) {
+  CompilationUnit resolveCompilationUnit(
+      Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return resolveCompilationUnit2(unitSource, library.source);
   }
 
   @override
-  CompilationUnit resolveCompilationUnit2(Source unitSource,
-      Source librarySource) =>
-      _getDartResolutionData2(
-          unitSource,
-          librarySource,
-          DartEntry.RESOLVED_UNIT,
-          null);
+  CompilationUnit resolveCompilationUnit2(
+      Source unitSource, Source librarySource) => _getDartResolutionData2(
+          unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
 
   @override
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     computeHtmlElement(htmlSource);
     return parseHtmlUnit(htmlSource);
   }
 
   @override
   void setChangedContents(Source source, String contents, int offset,
       int oldLength, int newLength) {
     if (_contentRangeChanged(source, contents, offset, oldLength, newLength)) {
-      _onSourcesChangedController.add(
-          new SourcesChangedEvent.changedRange(
-              source,
-              contents,
-              offset,
-              oldLength,
-              newLength));
+      _onSourcesChangedController.add(new SourcesChangedEvent.changedRange(
+          source, contents, offset, oldLength, newLength));
     }
   }
 
   @override
   void setContents(Source source, String contents) {
     _contentsChanged(source, contents, true);
   }
 
   @override
   void visitCacheItems(void callback(Source source, SourceEntry dartEntry,
@@ skipping 14 matching lines @@
           continue;
         } else if (descriptor == DartEntry.PUBLIC_NAMESPACE) {
           // The public namespace isn't computed by performAnalysisTask()
           // and therefore isn't interesting.
           continue;
         } else if (descriptor == HtmlEntry.HINTS) {
           // We are not currently recording any hints related to HTML.
           continue;
         }
         callback(
-            source,
-            sourceEntry,
-            descriptor,
-            sourceEntry.getState(descriptor));
+            source, sourceEntry, descriptor, sourceEntry.getState(descriptor));
       }
       if (sourceEntry is DartEntry) {
         // get library-specific values
         List<Source> librarySources = getLibrariesContaining(source);
         for (Source librarySource in librarySources) {
           for (DataDescriptor descriptor in sourceEntry.libraryDescriptors) {
             if (descriptor == DartEntry.BUILT_ELEMENT ||
                 descriptor == DartEntry.BUILT_UNIT) {
               // These values are not currently being computed, so their state
               // is not interesting.
               continue;
             } else if (source.isInSystemLibrary &&
                 !_generateSdkErrors &&
                 (descriptor == DartEntry.VERIFICATION_ERRORS ||
                     descriptor == DartEntry.HINTS ||
                     descriptor == DartEntry.LINTS)) {
               continue;
             } else if (!hintsEnabled && descriptor == DartEntry.HINTS) {
               continue;
             } else if (!lintsEnabled && descriptor == DartEntry.LINTS) {
               continue;
             }
-            callback(
-                librarySource,
-                sourceEntry,
-                descriptor,
+            callback(librarySource, sourceEntry, descriptor,
                 sourceEntry.getStateInLibrary(descriptor, librarySource));
           }
         }
       }
     }
   }
 
   /**
    * Visit all entries of the content cache.
    */
@@ skipping 51 matching lines @@
     //
     CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information.
       // Unless the modification date of the source continues to change,
       // this loop will eventually terminate.
       //
       DartEntry libraryEntry = _getReadableDartEntry(librarySource);
       libraryEntry = _cacheDartResolutionData(
-          librarySource,
-          librarySource,
-          libraryEntry,
-          DartEntry.ELEMENT);
+          librarySource, librarySource, libraryEntry, DartEntry.ELEMENT);
       LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
       CompilationUnitElement definingUnit =
           libraryElement.definingCompilationUnit;
       List<CompilationUnitElement> parts = libraryElement.parts;
       List<TimestampedData<CompilationUnit>> units =
           new List<TimestampedData>(parts.length + 1);
       units[0] = _getResolvedUnit(definingUnit, librarySource);
       if (units[0] == null) {
         Source source = definingUnit.source;
         units[0] = new TimestampedData<CompilationUnit>(
             getModificationStamp(source),
             resolveCompilationUnit(source, libraryElement));
       }
       for (int i = 0; i < parts.length; i++) {
         units[i + 1] = _getResolvedUnit(parts[i], librarySource);
         if (units[i + 1] == null) {
           Source source = parts[i].source;
-          units[i +
-              1] = new TimestampedData<CompilationUnit>(
-                  getModificationStamp(source),
-                  resolveCompilationUnit(source, libraryElement));
+          units[i + 1] = new TimestampedData<CompilationUnit>(
+              getModificationStamp(source),
+              resolveCompilationUnit(source, libraryElement));
         }
       }
       dartEntry = new GenerateDartHintsTask(
-          this,
-          units,
-          getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry;
+              this, units, getLibraryElement(librarySource))
+          .perform(_resultRecorder) as DartEntry;
       state = dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState.VALID] or
    * [CacheStateERROR]. This method assumes that the data can be produced by generating lints
    * for the library if the data is not already cached.
@@ skipping 14 matching lines @@
     //
     CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information.
       // Unless the modification date of the source continues to change,
       // this loop will eventually terminate.
       //
       DartEntry libraryEntry = _getReadableDartEntry(librarySource);
       libraryEntry = _cacheDartResolutionData(
-          librarySource,
-          librarySource,
-          libraryEntry,
-          DartEntry.ELEMENT);
+          librarySource, librarySource, libraryEntry, DartEntry.ELEMENT);
       LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
       CompilationUnitElement definingUnit =
           libraryElement.definingCompilationUnit;
       List<CompilationUnitElement> parts = libraryElement.parts;
       List<TimestampedData<CompilationUnit>> units =
           new List<TimestampedData>(parts.length + 1);
       units[0] = _getResolvedUnit(definingUnit, librarySource);
       if (units[0] == null) {
         Source source = definingUnit.source;
         units[0] = new TimestampedData<CompilationUnit>(
             getModificationStamp(source),
             resolveCompilationUnit(source, libraryElement));
       }
       for (int i = 0; i < parts.length; i++) {
         units[i + 1] = _getResolvedUnit(parts[i], librarySource);
         if (units[i + 1] == null) {
           Source source = parts[i].source;
-          units[i +
-              1] = new TimestampedData<CompilationUnit>(
-                  getModificationStamp(source),
-                  resolveCompilationUnit(source, libraryElement));
+          units[i + 1] = new TimestampedData<CompilationUnit>(
+              getModificationStamp(source),
+              resolveCompilationUnit(source, libraryElement));
         }
       }
       //TODO(pquitslund): revisit if we need all units or whether one will do
       dartEntry = new GenerateDartLintsTask(
-          this,
-          units,
-          getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry;
+              this, units, getLibraryElement(librarySource))
+          .perform(_resultRecorder) as DartEntry;
       state = dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file, return a cache entry in which the state of the data represented
    * by the given descriptor is either [CacheState.VALID] or [CacheState.ERROR]. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  DartEntry _cacheDartParseData(Source source, DartEntry dartEntry,
-      DataDescriptor descriptor) {
+  DartEntry _cacheDartParseData(
+      Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       if (dartEntry.hasResolvableCompilationUnit) {
         return dartEntry;
       }
     }
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the
       // source continues to change, this loop will eventually terminate.
       //
       dartEntry = _cacheDartScanData(source, dartEntry, DartEntry.TOKEN_STREAM);
-      dartEntry = new ParseDartTask(
-          this,
-          source,
-          dartEntry.getValue(DartEntry.TOKEN_STREAM),
-          dartEntry.getValue(
-              SourceEntry.LINE_INFO)).perform(_resultRecorder) as DartEntry;
+      dartEntry = new ParseDartTask(this, source,
+              dartEntry.getValue(DartEntry.TOKEN_STREAM),
+              dartEntry.getValue(SourceEntry.LINE_INFO))
+          .perform(_resultRecorder) as DartEntry;
       state = dartEntry.getState(descriptor);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState.VALID] or
    * [CacheState.ERROR]. This method assumes that the data can be produced by resolving the
    * source in the context of the library if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
   DartEntry _cacheDartResolutionData(Source unitSource, Source librarySource,
       DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
     //
-    CacheState state = (identical(descriptor, DartEntry.ELEMENT)) ?
-        dartEntry.getState(descriptor) :
-        dartEntry.getStateInLibrary(descriptor, librarySource);
+    CacheState state = (identical(descriptor, DartEntry.ELEMENT))
+        ? dartEntry.getState(descriptor)
+        : dartEntry.getStateInLibrary(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the
       // source continues to change, this loop will eventually terminate.
       //
       // TODO(brianwilkerson) As an optimization, if we already have the
       // element model for the library we can use ResolveDartUnitTask to produce
       // the resolved AST structure much faster.
-      dartEntry = new ResolveDartLibraryTask(
-          this,
-          unitSource,
-          librarySource).perform(_resultRecorder) as DartEntry;
-      state = (identical(descriptor, DartEntry.ELEMENT)) ?
-          dartEntry.getState(descriptor) :
-          dartEntry.getStateInLibrary(descriptor, librarySource);
+      dartEntry = new ResolveDartLibraryTask(this, unitSource, librarySource)
+          .perform(_resultRecorder) as DartEntry;
+      state = (identical(descriptor, DartEntry.ELEMENT))
+          ? dartEntry.getState(descriptor)
+          : dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file, return a cache entry in which the state of the data represented
    * by the given descriptor is either [CacheState.VALID] or [CacheState.ERROR]. This
    * method assumes that the data can be produced by scanning the source if it is not already
    * cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be scanned
    */
-  DartEntry _cacheDartScanData(Source source, DartEntry dartEntry,
-      DataDescriptor descriptor) {
+  DartEntry _cacheDartScanData(
+      Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the
       // source continues to change, this loop will eventually terminate.
       //
       try {
         if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
-          dartEntry =
-              new GetContentTask(this, source).perform(_resultRecorder) as DartEntry;
+          dartEntry = new GetContentTask(this, source)
+              .perform(_resultRecorder) as DartEntry;
         }
         dartEntry = new ScanDartTask(
-            this,
-            source,
-            dartEntry.getValue(SourceEntry.CONTENT)).perform(_resultRecorder) as DartEntry;
+                this, source, dartEntry.getValue(SourceEntry.CONTENT))
+            .perform(_resultRecorder) as DartEntry;
       } on AnalysisException catch (exception) {
         throw exception;
       } catch (exception, stackTrace) {
         throw new AnalysisException(
-            "Exception",
-            new CaughtException(exception, stackTrace));
+            "Exception", new CaughtException(exception, stackTrace));
       }
       state = dartEntry.getState(descriptor);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState.VALID] or
    * [CacheState.ERROR]. This method assumes that the data can be produced by verifying the
@@ skipping 18 matching lines @@
       //
       // If not, compute the information. Unless the modification date of the
       // source continues to change, this loop will eventually terminate.
       //
       LibraryElement library = computeLibraryElement(librarySource);
       CompilationUnit unit = resolveCompilationUnit(unitSource, library);
       if (unit == null) {
         throw new AnalysisException(
             "Could not resolve compilation unit ${unitSource.fullName} in ${librarySource.fullName}");
       }
-      dartEntry = new GenerateDartErrorsTask(
-          this,
-          unitSource,
-          unit,
-          library).perform(_resultRecorder) as DartEntry;
+      dartEntry = new GenerateDartErrorsTask(this, unitSource, unit, library)
+          .perform(_resultRecorder) as DartEntry;
       state = dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for an HTML file, return a cache entry in which all of the data represented by
    * the state of the given descriptors is either [CacheState.VALID] or
    * [CacheState.ERROR]. This method assumes that the data can be produced by parsing the
    * source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the HTML file
    * @param htmlEntry the cache entry associated with the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  HtmlEntry _cacheHtmlParseData(Source source, HtmlEntry htmlEntry,
-      DataDescriptor descriptor) {
+  HtmlEntry _cacheHtmlParseData(
+      Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
     if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       ht.HtmlUnit unit = htmlEntry.anyParsedUnit;
       if (unit != null) {
         return htmlEntry;
       }
     }
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = htmlEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the
       // source continues to change, this loop will eventually terminate.
       //
       try {
         if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
-          htmlEntry =
-              new GetContentTask(this, source).perform(_resultRecorder) as HtmlEntry;
+          htmlEntry = new GetContentTask(this, source)
+              .perform(_resultRecorder) as HtmlEntry;
         }
         htmlEntry = new ParseHtmlTask(
-            this,
-            source,
-            htmlEntry.getValue(SourceEntry.CONTENT)).perform(_resultRecorder) as HtmlEntry;
+                this, source, htmlEntry.getValue(SourceEntry.CONTENT))
+            .perform(_resultRecorder) as HtmlEntry;
       } on AnalysisException catch (exception) {
         throw exception;
       } catch (exception, stackTrace) {
         throw new AnalysisException(
-            "Exception",
-            new CaughtException(exception, stackTrace));
+            "Exception", new CaughtException(exception, stackTrace));
       }
       state = htmlEntry.getState(descriptor);
     }
     return htmlEntry;
   }
 
   /**
    * Given a source for an HTML file, return a cache entry in which the state of the data
    * represented by the given descriptor is either [CacheState.VALID] or
    * [CacheState.ERROR]. This method assumes that the data can be produced by resolving the
    * source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the HTML file
    * @param dartEntry the cache entry associated with the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  HtmlEntry _cacheHtmlResolutionData(Source source, HtmlEntry htmlEntry,
-      DataDescriptor descriptor) {
+  HtmlEntry _cacheHtmlResolutionData(
+      Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = htmlEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the
       // source continues to change, this loop will eventually terminate.
       //
       htmlEntry = _cacheHtmlParseData(source, htmlEntry, HtmlEntry.PARSED_UNIT);
-      htmlEntry = new ResolveHtmlTask(
-          this,
-          source,
-          htmlEntry.modificationTime,
-          htmlEntry.getValue(
-              HtmlEntry.PARSED_UNIT)).perform(_resultRecorder) as HtmlEntry;
+      htmlEntry = new ResolveHtmlTask(this, source, htmlEntry.modificationTime,
+              htmlEntry.getValue(HtmlEntry.PARSED_UNIT))
+          .perform(_resultRecorder) as HtmlEntry;
       state = htmlEntry.getState(descriptor);
     }
     return htmlEntry;
   }
 
   /**
    * Remove the given [pendingFuture] from [_pendingFutureSources], since the
    * client has indicated its computation is not needed anymore.
    */
   void _cancelFuture(PendingFuture pendingFuture) {
     List<PendingFuture> pendingFutures =
         _pendingFutureSources[pendingFuture.source];
     if (pendingFutures != null) {
       pendingFutures.remove(pendingFuture);
       if (pendingFutures.isEmpty) {
         _pendingFutureSources.remove(pendingFuture.source);
       }
     }
   }
 
   /**
    * Compute the transitive closure of all libraries that depend on the given library by adding such
    * libraries to the given collection.
    *
    * @param library the library on which the other libraries depend
    * @param librariesToInvalidate the libraries that depend on the given library
    */
-  void _computeAllLibrariesDependingOn(Source library,
-      HashSet<Source> librariesToInvalidate) {
+  void _computeAllLibrariesDependingOn(
+      Source library, HashSet<Source> librariesToInvalidate) {
     if (librariesToInvalidate.add(library)) {
       for (Source dependentLibrary in getLibrariesDependingOn(library)) {
         _computeAllLibrariesDependingOn(
-            dependentLibrary,
-            librariesToInvalidate);
+            dependentLibrary, librariesToInvalidate);
       }
     }
   }
 
   /**
    * Compute the priority that should be used when the source associated with the given entry is
    * added to the work manager.
    *
    * @param dartEntry the entry associated with the source
    * @return the priority that was computed
@@ skipping 62 matching lines @@
    * @param newLength the number of characters in the replacement text
    */
   bool _contentRangeChanged(Source source, String contents, int offset,
       int oldLength, int newLength) {
     bool changed = false;
     String originalContents = _contentCache.setContents(source, contents);
     if (contents != null) {
       if (contents != originalContents) {
         if (_options.incremental) {
           _incrementalAnalysisCache = IncrementalAnalysisCache.update(
-              _incrementalAnalysisCache,
-              source,
-              originalContents,
-              contents,
-              offset,
-              oldLength,
-              newLength,
-              _getReadableSourceEntry(source));
+              _incrementalAnalysisCache, source, originalContents, contents,
+              offset, oldLength, newLength, _getReadableSourceEntry(source));
         }
         _sourceChanged(source);
         changed = true;
         SourceEntry sourceEntry = _cache.get(source);
         if (sourceEntry != null) {
           sourceEntry.modificationTime =
               _contentCache.getModificationStamp(source);
           sourceEntry.setValue(SourceEntry.CONTENT, contents);
         }
       }
@@ skipping 42 matching lines @@
    *
    * @param unitSource the source for the compilation unit to be verified
    * @param unitEntry the entry for the compilation unit
    * @param librarySource the source for the library containing the compilation unit
    * @param libraryEntry the entry for the library
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createGenerateDartErrorsTask(Source unitSource,
       DartEntry unitEntry, Source librarySource, DartEntry libraryEntry) {
     if (unitEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) !=
-        CacheState.VALID ||
+            CacheState.VALID ||
         libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) {
       return _createResolveDartLibraryTask(librarySource, libraryEntry);
     }
     CompilationUnit unit =
         unitEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
     if (unit == null) {
-      CaughtException exception = new CaughtException(
-          new AnalysisException(
+      CaughtException exception = new CaughtException(new AnalysisException(
               "Entry has VALID state for RESOLVED_UNIT but null value for ${unitSource.fullName} in ${librarySource.fullName}"),
           null);
       AnalysisEngine.instance.logger.logInformation(
-          exception.toString(),
-          exception);
+          exception.toString(), exception);
       unitEntry.recordResolutionError(exception);
       return new AnalysisContextImpl_TaskData(null, false);
     }
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
     return new AnalysisContextImpl_TaskData(
         new GenerateDartErrorsTask(this, unitSource, unit, libraryElement),
         false);
   }
 
   /**
@@ skipping 25 matching lines @@
     }
     for (int i = 0; i < parts.length; i++) {
       units[i + 1] = _getResolvedUnit(parts[i], librarySource);
       if (units[i + 1] == null) {
         // TODO(brianwilkerson) We should return a ResolveDartUnitTask
         // (unless there are multiple ASTs that need to be resolved).
         return _createResolveDartLibraryTask(librarySource, libraryEntry);
       }
     }
     return new AnalysisContextImpl_TaskData(
-        new GenerateDartHintsTask(this, units, libraryElement),
-        false);
+        new GenerateDartHintsTask(this, units, libraryElement), false);
   }
 
   /**
    * Create a [GenerateDartLintsTask] for the given source, marking the lints as
    * being in-process.
    *
    * @param source the source whose content is to be verified
    * @param dartEntry the entry for the source
    * @param librarySource the source for the library containing the source
    * @param libraryEntry the entry for the library
@@ skipping 19 matching lines @@
     for (int i = 0; i < parts.length; i++) {
       units[i + 1] = _getResolvedUnit(parts[i], librarySource);
       if (units[i + 1] == null) {
         // TODO(brianwilkerson) We should return a ResolveDartUnitTask
         // (unless there are multiple ASTs that need to be resolved).
         return _createResolveDartLibraryTask(librarySource, libraryEntry);
       }
     }
     //TODO(pquitslund): revisit if we need all units or whether one will do
     return new AnalysisContextImpl_TaskData(
-        new GenerateDartLintsTask(this, units, libraryElement),
-        false);
+        new GenerateDartLintsTask(this, units, libraryElement), false);
   }
 
   /**
    * Create a [GetContentTask] for the given source, marking the content as being in-process.
    *
    * @param source the source whose content is to be accessed
    * @param sourceEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createGetContentTask(Source source,
-      SourceEntry sourceEntry) {
+  AnalysisContextImpl_TaskData _createGetContentTask(
+      Source source, SourceEntry sourceEntry) {
     return new AnalysisContextImpl_TaskData(
-        new GetContentTask(this, source),
-        false);
+        new GetContentTask(this, source), false);
   }
 
   /**
    * Create a [ParseDartTask] for the given [source].
    */
-  AnalysisContextImpl_TaskData _createParseDartTask(Source source,
-      DartEntry dartEntry) {
+  AnalysisContextImpl_TaskData _createParseDartTask(
+      Source source, DartEntry dartEntry) {
     if (dartEntry.getState(DartEntry.TOKEN_STREAM) != CacheState.VALID ||
         dartEntry.getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
       return _createScanDartTask(source, dartEntry);
     }
     Token tokenStream = dartEntry.getValue(DartEntry.TOKEN_STREAM);
     dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
-    return new AnalysisContextImpl_TaskData(
-        new ParseDartTask(
-            this,
-            source,
-            tokenStream,
-            dartEntry.getValue(SourceEntry.LINE_INFO)),
-        false);
+    return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source,
+        tokenStream, dartEntry.getValue(SourceEntry.LINE_INFO)), false);
   }
 
   /**
    * Create a [ParseHtmlTask] for the given [source].
    */
-  AnalysisContextImpl_TaskData _createParseHtmlTask(Source source,
-      HtmlEntry htmlEntry) {
+  AnalysisContextImpl_TaskData _createParseHtmlTask(
+      Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, htmlEntry);
     }
     String content = htmlEntry.getValue(SourceEntry.CONTENT);
     htmlEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     return new AnalysisContextImpl_TaskData(
-        new ParseHtmlTask(this, source, content),
-        false);
+        new ParseHtmlTask(this, source, content), false);
   }
 
   /**
    * Create a [ResolveDartLibraryTask] for the given source, marking ? as being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createResolveDartLibraryTask(Source source,
-      DartEntry dartEntry) {
+  AnalysisContextImpl_TaskData _createResolveDartLibraryTask(
+      Source source, DartEntry dartEntry) {
     try {
       AnalysisContextImpl_CycleBuilder builder =
           new AnalysisContextImpl_CycleBuilder(this);
       PerformanceStatistics.cycles.makeCurrentWhile(() {
         builder.computeCycleContaining(source);
       });
       AnalysisContextImpl_TaskData taskData = builder.taskData;
       if (taskData != null) {
         return taskData;
       }
-      return new AnalysisContextImpl_TaskData(
-          new ResolveDartLibraryCycleTask(this, source, source, builder.librariesInCycle),
-          false);
+      return new AnalysisContextImpl_TaskData(new ResolveDartLibraryCycleTask(
+          this, source, source, builder.librariesInCycle), false);
     } on AnalysisException catch (exception, stackTrace) {
-      dartEntry.recordResolutionError(
-          new CaughtException(exception, stackTrace));
+      dartEntry
+          .recordResolutionError(new CaughtException(exception, stackTrace));
       AnalysisEngine.instance.logger.logError(
           "Internal error trying to create a ResolveDartLibraryTask",
           new CaughtException(exception, stackTrace));
     }
     return new AnalysisContextImpl_TaskData(null, false);
   }
 
   /**
    * Create a [ResolveHtmlTask] for the given source, marking the resolved unit as being
    * in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createResolveHtmlTask(Source source,
-      HtmlEntry htmlEntry) {
+  AnalysisContextImpl_TaskData _createResolveHtmlTask(
+      Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.PARSED_UNIT) != CacheState.VALID) {
       return _createParseHtmlTask(source, htmlEntry);
     }
-    return new AnalysisContextImpl_TaskData(
-        new ResolveHtmlTask(
-            this,
-            source,
-            htmlEntry.modificationTime,
-            htmlEntry.getValue(HtmlEntry.PARSED_UNIT)),
-        false);
+    return new AnalysisContextImpl_TaskData(new ResolveHtmlTask(this, source,
+        htmlEntry.modificationTime,
+        htmlEntry.getValue(HtmlEntry.PARSED_UNIT)), false);
   }
 
   /**
    * Create a [ScanDartTask] for the given source, marking the scan errors as being
    * in-process.
    *
    * @param source the source whose content is to be scanned
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createScanDartTask(Source source,
-      DartEntry dartEntry) {
+  AnalysisContextImpl_TaskData _createScanDartTask(
+      Source source, DartEntry dartEntry) {
     if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, dartEntry);
     }
     String content = dartEntry.getValue(SourceEntry.CONTENT);
     dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     return new AnalysisContextImpl_TaskData(
-        new ScanDartTask(this, source, content),
-        false);
+        new ScanDartTask(this, source, content), false);
   }
 
   /**
    * Create a source information object suitable for the given source. Return the source information
    * object that was created, or `null` if the source should not be tracked by this context.
    *
    * @param source the source for which an information object is being created
    * @param explicitlyAdded `true` if the source was explicitly added to the context
    * @return the source information object that was created
    */
@@ skipping 90 matching lines @@
    * source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  Object _getDartParseData(Source source, DartEntry dartEntry,
-      DataDescriptor descriptor) {
+  Object _getDartParseData(
+      Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     dartEntry = _cacheDartParseData(source, dartEntry, descriptor);
     if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       _accessedAst(source);
       return dartEntry.anyParsedCompilationUnit;
     }
     return dartEntry.getValue(descriptor);
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not a Dart file. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  Object _getDartParseData2(Source source, DataDescriptor descriptor,
-      Object defaultValue) {
+  Object _getDartParseData2(
+      Source source, DataDescriptor descriptor, Object defaultValue) {
     DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       return defaultValue;
     }
     try {
       return _getDartParseData(source, dartEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception, stackTrace) {
       AnalysisEngine.instance.logger.logInformation(
           "Could not compute $descriptor",
           new CaughtException(exception, stackTrace));
@@ skipping 11 matching lines @@
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the entry representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
   Object _getDartResolutionData(Source unitSource, Source librarySource,
       DartEntry dartEntry, DataDescriptor descriptor) {
-    dartEntry =
-        _cacheDartResolutionData(unitSource, librarySource, dartEntry, descriptor);
+    dartEntry = _cacheDartResolutionData(
+        unitSource, librarySource, dartEntry, descriptor);
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return dartEntry.getValue(descriptor);
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       _accessedAst(unitSource);
     }
     return dartEntry.getValueInLibrary(descriptor, librarySource);
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return the data represented by
@@ skipping 12 matching lines @@
    *           resolved
    */
   Object _getDartResolutionData2(Source unitSource, Source librarySource,
       DataDescriptor descriptor, Object defaultValue) {
     DartEntry dartEntry = _getReadableDartEntry(unitSource);
     if (dartEntry == null) {
       return defaultValue;
     }
     try {
       return _getDartResolutionData(
-          unitSource,
-          librarySource,
-          dartEntry,
-          descriptor);
+          unitSource, librarySource, dartEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception, stackTrace) {
       AnalysisEngine.instance.logger.logInformation(
           "Could not compute $descriptor",
           new CaughtException(exception, stackTrace));
       return defaultValue;
     }
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by scanning the
    * source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be scanned
    */
-  Object _getDartScanData(Source source, DartEntry dartEntry,
-      DataDescriptor descriptor) {
+  Object _getDartScanData(
+      Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     dartEntry = _cacheDartScanData(source, dartEntry, descriptor);
     return dartEntry.getValue(descriptor);
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not a Dart file. This
    * method assumes that the data can be produced by scanning the source if it is not already
    * cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be scanned
    */
-  Object _getDartScanData2(Source source, DataDescriptor descriptor,
-      Object defaultValue) {
+  Object _getDartScanData2(
+      Source source, DataDescriptor descriptor, Object defaultValue) {
     DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       return defaultValue;
     }
     try {
       return _getDartScanData(source, dartEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception, stackTrace) {
       AnalysisEngine.instance.logger.logInformation(
           "Could not compute $descriptor",
           new CaughtException(exception, stackTrace));
@@ skipping 11 matching lines @@
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the entry representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
   Object _getDartVerificationData(Source unitSource, Source librarySource,
       DartEntry dartEntry, DataDescriptor descriptor) {
-    dartEntry =
-        _cacheDartVerificationData(unitSource, librarySource, dartEntry, descriptor);
+    dartEntry = _cacheDartVerificationData(
+        unitSource, librarySource, dartEntry, descriptor);
     return dartEntry.getValueInLibrary(descriptor, librarySource);
   }
 
   /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not an HTML file. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not an HTML file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  Object _getHtmlParseData(Source source, DataDescriptor descriptor,
-      Object defaultValue) {
+  Object _getHtmlParseData(
+      Source source, DataDescriptor descriptor, Object defaultValue) {
     HtmlEntry htmlEntry = _getReadableHtmlEntry(source);
     if (htmlEntry == null) {
       return defaultValue;
     }
     htmlEntry = _cacheHtmlParseData(source, htmlEntry, descriptor);
     if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       _accessedAst(source);
       return htmlEntry.anyParsedUnit;
     }
     return htmlEntry.getValue(descriptor);
   }
 
   /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not an HTML file. This
    * method assumes that the data can be produced by resolving the source if it is not already
    * cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not an HTML file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  Object _getHtmlResolutionData(Source source, DataDescriptor descriptor,
-      Object defaultValue) {
+  Object _getHtmlResolutionData(
+      Source source, DataDescriptor descriptor, Object defaultValue) {
     HtmlEntry htmlEntry = _getReadableHtmlEntry(source);
     if (htmlEntry == null) {
       return defaultValue;
     }
     try {
       return _getHtmlResolutionData2(source, htmlEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception, stackTrace) {
       AnalysisEngine.instance.logger.logInformation(
           "Could not compute $descriptor",
           new CaughtException(exception, stackTrace));
       return defaultValue;
     }
   }
 
   /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by resolving the
    * source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the HTML file
    * @param htmlEntry the entry representing the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  Object _getHtmlResolutionData2(Source source, HtmlEntry htmlEntry,
-      DataDescriptor descriptor) {
+  Object _getHtmlResolutionData2(
+      Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
     htmlEntry = _cacheHtmlResolutionData(source, htmlEntry, descriptor);
     if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) {
       _accessedAst(source);
     }
     return htmlEntry.getValue(descriptor);
   }
 
   /**
    * Look at the given source to see whether a task needs to be performed related to it. Return the
    * task that should be performed, or `null` if there is no more work to be done for the
@@ skipping 61 matching lines @@
       List<Source> librariesContaining = dartEntry.containingLibraries;
       for (Source librarySource in librariesContaining) {
         SourceEntry librarySourceEntry = _cache.get(librarySource);
         if (librarySourceEntry is DartEntry) {
           DartEntry libraryEntry = librarySourceEntry;
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
           if (elementState == CacheState.INVALID ||
               (isPriority && elementState == CacheState.FLUSHED)) {
 //            return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
             return new AnalysisContextImpl_TaskData(
-                new ResolveDartLibraryTask(this, source, librarySource),
-                false);
+                new ResolveDartLibraryTask(this, source, librarySource), false);
           }
-          CacheState resolvedUnitState =
-              dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
+          CacheState resolvedUnitState = dartEntry.getStateInLibrary(
+              DartEntry.RESOLVED_UNIT, librarySource);
           if (resolvedUnitState == CacheState.INVALID ||
               (isPriority && resolvedUnitState == CacheState.FLUSHED)) {
             //
             // The commented out lines below are an optimization that doesn't
             // quite work yet. The problem is that if the source was not
             // resolved because it wasn't part of any library, then there won't
             // be any elements in the element model that we can use to resolve
             // it.
             //
 //            LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
 //            if (libraryElement != null) {
 //              return new ResolveDartUnitTask(this, source, libraryElement);
 //            }
             // Possibly replace with:
 //             return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
             return new AnalysisContextImpl_TaskData(
-                new ResolveDartLibraryTask(this, source, librarySource),
-                false);
+                new ResolveDartLibraryTask(this, source, librarySource), false);
           }
           if (_generateSdkErrors || !source.isInSystemLibrary) {
-            CacheState verificationErrorsState =
-                dartEntry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource);
+            CacheState verificationErrorsState = dartEntry.getStateInLibrary(
+                DartEntry.VERIFICATION_ERRORS, librarySource);
             if (verificationErrorsState == CacheState.INVALID ||
                 (isPriority && verificationErrorsState == CacheState.FLUSHED)) {
               return _createGenerateDartErrorsTask(
-                  source,
-                  dartEntry,
-                  librarySource,
-                  libraryEntry);
+                  source, dartEntry, librarySource, libraryEntry);
             }
             if (hintsEnabled) {
               CacheState hintsState =
                   dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource);
               if (hintsState == CacheState.INVALID ||
                   (isPriority && hintsState == CacheState.FLUSHED)) {
                 return _createGenerateDartHintsTask(
-                    source,
-                    dartEntry,
-                    librarySource,
-                    libraryEntry);
+                    source, dartEntry, librarySource, libraryEntry);
               }
             }
             if (lintsEnabled) {
               CacheState lintsState =
                   dartEntry.getStateInLibrary(DartEntry.LINTS, librarySource);
               if (lintsState == CacheState.INVALID ||
                   (isPriority && lintsState == CacheState.FLUSHED)) {
                 return _createGenerateDartLintsTask(
-                    source,
-                    dartEntry,
-                    librarySource,
-                    libraryEntry);
+                    source, dartEntry, librarySource, libraryEntry);
               }
             }
           }
         }
       }
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       CacheState parseErrorsState = htmlEntry.getState(HtmlEntry.PARSE_ERRORS);
       if (parseErrorsState == CacheState.INVALID ||
           (isPriority && parseErrorsState == CacheState.FLUSHED)) {
@@ skipping 81 matching lines @@
   }
 
   /**
    * Return a resolved compilation unit corresponding to the given element in the given library, or
    * `null` if the information is not cached.
    *
    * @param element the element representing the compilation unit
    * @param librarySource the source representing the library containing the unit
    * @return the specified resolved compilation unit
    */
-  TimestampedData<CompilationUnit>
-      _getResolvedUnit(CompilationUnitElement element, Source librarySource) {
+  TimestampedData<CompilationUnit> _getResolvedUnit(
+      CompilationUnitElement element, Source librarySource) {
     SourceEntry sourceEntry = _cache.get(element.source);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       if (dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) ==
           CacheState.VALID) {
-        return new TimestampedData<CompilationUnit>(
-            dartEntry.modificationTime,
-            dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource));
+        return new TimestampedData<CompilationUnit>(dartEntry.modificationTime,
+            dartEntry.getValueInLibrary(
+                DartEntry.RESOLVED_UNIT, librarySource));
       }
     }
     return null;
   }
 
   /**
    * Return an array containing all of the sources known to this context that have the given kind.
    *
    * @param kind the kind of sources to be returned
    * @return all of the sources known to this context that have the given kind
@@ skipping 50 matching lines @@
       }
       for (Source librarySource in getLibrariesContaining(source)) {
         SourceEntry libraryEntry = _cache.get(librarySource);
         if (libraryEntry is DartEntry) {
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
           if (elementState == CacheState.INVALID ||
               (isPriority && elementState == CacheState.FLUSHED)) {
             sources.add(source);
             return;
           }
-          CacheState resolvedUnitState =
-              dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
+          CacheState resolvedUnitState = dartEntry.getStateInLibrary(
+              DartEntry.RESOLVED_UNIT, librarySource);
           if (resolvedUnitState == CacheState.INVALID ||
               (isPriority && resolvedUnitState == CacheState.FLUSHED)) {
             LibraryElement libraryElement =
                 libraryEntry.getValue(DartEntry.ELEMENT);
             if (libraryElement != null) {
               sources.add(source);
               return;
             }
           }
           if (_generateSdkErrors || !source.isInSystemLibrary) {
-            CacheState verificationErrorsState =
-                dartEntry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource);
+            CacheState verificationErrorsState = dartEntry.getStateInLibrary(
+                DartEntry.VERIFICATION_ERRORS, librarySource);
             if (verificationErrorsState == CacheState.INVALID ||
                 (isPriority && verificationErrorsState == CacheState.FLUSHED)) {
               LibraryElement libraryElement =
                   libraryEntry.getValue(DartEntry.ELEMENT);
               if (libraryElement != null) {
                 sources.add(source);
                 return;
               }
             }
             if (hintsEnabled) {
@@ skipping 160 matching lines @@
   }
 
   /**
    * Notify all of the analysis listeners that the errors associated with the given source has been
    * updated to the given errors.
    *
    * @param source the source containing the errors that were computed
    * @param errors the errors that were computed
    * @param lineInfo the line information associated with the source
    */
-  void _notifyErrors(Source source, List<AnalysisError> errors,
-      LineInfo lineInfo) {
+  void _notifyErrors(
+      Source source, List<AnalysisError> errors, LineInfo lineInfo) {
     int count = _listeners.length;
     for (int i = 0; i < count; i++) {
       _listeners[i].computedErrors(this, source, errors, lineInfo);
     }
   }
 
   /**
    * Given that the given [source] (with the corresponding [sourceEntry]) has
    * been invalidated, invalidate all of the libraries that depend on it.
    */
   void _propagateInvalidation(Source source, SourceEntry sourceEntry) {
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       htmlEntry.modificationTime = getModificationStamp(source);
       htmlEntry.invalidateAllInformation();
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.HTML);
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       List<Source> dependentLibraries = getLibrariesDependingOn(source);
       HashSet<Source> librariesToInvalidate = new HashSet<Source>();
       for (Source containingLibrary in containingLibraries) {
         _computeAllLibrariesDependingOn(
-            containingLibrary,
-            librariesToInvalidate);
+            containingLibrary, librariesToInvalidate);
       }
       for (Source dependentLibrary in dependentLibraries) {
         _computeAllLibrariesDependingOn(
-            dependentLibrary,
-            librariesToInvalidate);
+            dependentLibrary, librariesToInvalidate);
       }
       for (Source library in librariesToInvalidate) {
         _invalidateLibraryResolution(library);
       }
       DartEntry dartEntry = _cache.get(source);
       _removeFromParts(source, dartEntry);
       dartEntry.modificationTime = getModificationStamp(source);
       dartEntry.invalidateAllInformation();
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.UNKNOWN);
@@ skipping 92 matching lines @@
     Source source = task.source;
     Source library = task.library;
     DartEntry dartEntry = _cache.get(source);
     CaughtException thrownException = task.exception;
     if (thrownException != null) {
       dartEntry.recordBuildElementErrorInLibrary(library, thrownException);
       throw new AnalysisException('<rethrow>', thrownException);
     }
     dartEntry.setValueInLibrary(DartEntry.BUILT_UNIT, library, task.unit);
     dartEntry.setValueInLibrary(
-        DartEntry.BUILT_ELEMENT,
-        library,
-        task.unitElement);
+        DartEntry.BUILT_ELEMENT, library, task.unitElement);
     ChangeNoticeImpl notice = _getNotice(source);
     LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO);
     notice.setErrors(dartEntry.allErrors, lineInfo);
     return dartEntry;
   }
 
   /**
    * Given a cache entry and a library element, record the library element and other information
    * gleaned from the element in the cache entry.
    *
    * @param dartCopy the cache entry in which data is to be recorded
    * @param library the library element used to record information
    * @param librarySource the source for the library used to record information
    * @param htmlSource the source for the HTML library
    */
   void _recordElementData(DartEntry dartEntry, LibraryElement library,
       Source librarySource, Source htmlSource) {
     dartEntry.setValue(DartEntry.ELEMENT, library);
     dartEntry.setValue(DartEntry.IS_LAUNCHABLE, library.entryPoint != null);
-    dartEntry.setValue(
-        DartEntry.IS_CLIENT,
+    dartEntry.setValue(DartEntry.IS_CLIENT,
         _isClient(library, htmlSource, new HashSet<LibraryElement>()));
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
   DartEntry _recordGenerateDartErrorsTask(GenerateDartErrorsTask task) {
     Source source = task.source;
     DartEntry dartEntry = _cache.get(source);
     Source librarySource = task.libraryElement.source;
     CaughtException thrownException = task.exception;
     if (thrownException != null) {
       dartEntry.recordVerificationErrorInLibrary(
-          librarySource,
-          thrownException);
+          librarySource, thrownException);
       throw new AnalysisException('<rethrow>', thrownException);
     }
     dartEntry.setValueInLibrary(
-        DartEntry.VERIFICATION_ERRORS,
-        librarySource,
-        task.errors);
+        DartEntry.VERIFICATION_ERRORS, librarySource, task.errors);
     ChangeNoticeImpl notice = _getNotice(source);
     LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO);
     notice.setErrors(dartEntry.allErrors, lineInfo);
     return dartEntry;
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
   DartEntry _recordGenerateDartHintsTask(GenerateDartHintsTask task) {
     Source librarySource = task.libraryElement.source;
     CaughtException thrownException = task.exception;
     DartEntry libraryEntry = null;
     HashMap<Source, List<AnalysisError>> hintMap = task.hintMap;
     if (hintMap == null) {
       // We don't have any information about which sources to mark as invalid
       // other than the library source.
       DartEntry libraryEntry = _cache.get(librarySource);
       if (thrownException == null) {
-        String message =
-            "GenerateDartHintsTask returned a null hint map "
-                "without throwing an exception: ${librarySource.fullName}";
+        String message = "GenerateDartHintsTask returned a null hint map "
+            "without throwing an exception: ${librarySource.fullName}";
         thrownException =
             new CaughtException(new AnalysisException(message), null);
       }
       libraryEntry.recordHintErrorInLibrary(librarySource, thrownException);
       throw new AnalysisException('<rethrow>', thrownException);
     }
     hintMap.forEach((Source unitSource, List<AnalysisError> hints) {
       DartEntry dartEntry = _cache.get(unitSource);
       if (unitSource == librarySource) {
         libraryEntry = dartEntry;
@@ skipping 20 matching lines @@
   DartEntry _recordGenerateDartLintsTask(GenerateDartLintsTask task) {
     Source librarySource = task.libraryElement.source;
     CaughtException thrownException = task.exception;
     DartEntry libraryEntry = null;
     HashMap<Source, List<AnalysisError>> lintMap = task.lintMap;
     if (lintMap == null) {
       // We don't have any information about which sources to mark as invalid
       // other than the library source.
       DartEntry libraryEntry = _cache.get(librarySource);
       if (thrownException == null) {
-        String message =
-            "GenerateDartLintsTask returned a null lint map "
-                "without throwing an exception: ${librarySource.fullName}";
+        String message = "GenerateDartLintsTask returned a null lint map "
+            "without throwing an exception: ${librarySource.fullName}";
         thrownException =
             new CaughtException(new AnalysisException(message), null);
       }
       libraryEntry.recordLintErrorInLibrary(librarySource, thrownException);
       throw new AnalysisException('<rethrow>', thrownException);
     }
     lintMap.forEach((Source unitSource, List<AnalysisError> lints) {
       DartEntry dartEntry = _cache.get(unitSource);
       if (unitSource == librarySource) {
         libraryEntry = dartEntry;
@@ skipping 39 matching lines @@
     return sourceEntry;
   }
 
   /**
    * Record the results produced by performing a [IncrementalAnalysisTask].
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  DartEntry
-      _recordIncrementalAnalysisTaskResults(IncrementalAnalysisTask task) {
+  DartEntry _recordIncrementalAnalysisTaskResults(
+      IncrementalAnalysisTask task) {
     CompilationUnit unit = task.compilationUnit;
     if (unit != null) {
       ChangeNoticeImpl notice = _getNotice(task.source);
       notice.resolvedDartUnit = unit;
       _incrementalAnalysisCache =
           IncrementalAnalysisCache.cacheResult(task.cache, unit);
     }
     return null;
   }
 
@@ skipping 17 matching lines @@
       dartEntry.containingLibrary = source;
       _workManager.add(source, SourcePriority.LIBRARY);
     } else if (task.hasPartOfDirective) {
       dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
       dartEntry.removeContainingLibrary(source);
       _workManager.add(source, SourcePriority.NORMAL_PART);
     } else {
       // The file contains no directives.
       List<Source> containingLibraries = dartEntry.containingLibraries;
       if (containingLibraries.length > 1 ||
-          (containingLibraries.length == 1 && containingLibraries[0] != source)) {
+          (containingLibraries.length == 1 &&
+              containingLibraries[0] != source)) {
         dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
         dartEntry.removeContainingLibrary(source);
         _workManager.add(source, SourcePriority.NORMAL_PART);
       } else {
         dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
         dartEntry.containingLibrary = source;
         _workManager.add(source, SourcePriority.LIBRARY);
       }
     }
     List<Source> newParts = task.includedSources;
@@ skipping 13 matching lines @@
     dartEntry.setValue(DartEntry.INCLUDED_PARTS, newParts);
     _cache.storedAst(source);
     ChangeNoticeImpl notice = _getNotice(source);
     if (notice.resolvedDartUnit == null) {
       notice.parsedDartUnit = task.compilationUnit;
     }
     notice.setErrors(dartEntry.allErrors, task.lineInfo);
     // Verify that the incrementally parsed and resolved unit in the incremental
     // cache is structurally equivalent to the fully parsed unit
     _incrementalAnalysisCache = IncrementalAnalysisCache.verifyStructure(
-        _incrementalAnalysisCache,
-        source,
-        task.compilationUnit);
+        _incrementalAnalysisCache, source, task.compilationUnit);
     return dartEntry;
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
   HtmlEntry _recordParseHtmlTaskResults(ParseHtmlTask task) {
     Source source = task.source;
     HtmlEntry htmlEntry = _cache.get(source);
     CaughtException thrownException = task.exception;
     if (thrownException != null) {
       htmlEntry.recordParseError(thrownException);
       _cache.removedAst(source);
       throw new AnalysisException('<rethrow>', thrownException);
     }
     LineInfo lineInfo = task.lineInfo;
     htmlEntry.setValue(SourceEntry.LINE_INFO, lineInfo);
     htmlEntry.setValue(HtmlEntry.PARSED_UNIT, task.htmlUnit);
     htmlEntry.setValue(HtmlEntry.PARSE_ERRORS, task.errors);
     htmlEntry.setValue(
-        HtmlEntry.REFERENCED_LIBRARIES,
-        task.referencedLibraries);
+        HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
     _cache.storedAst(source);
     ChangeNoticeImpl notice = _getNotice(source);
     notice.setErrors(htmlEntry.allErrors, lineInfo);
     return htmlEntry;
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
   DartEntry _recordResolveDartUnitTaskResults(ResolveDartUnitTask task) {
     Source unitSource = task.source;
     DartEntry dartEntry = _cache.get(unitSource);
     Source librarySource = task.librarySource;
     CaughtException thrownException = task.exception;
     if (thrownException != null) {
       dartEntry.recordResolutionErrorInLibrary(librarySource, thrownException);
       _cache.removedAst(unitSource);
       throw new AnalysisException('<rethrow>', thrownException);
     }
     dartEntry.setValueInLibrary(
-        DartEntry.RESOLVED_UNIT,
-        librarySource,
-        task.resolvedUnit);
+        DartEntry.RESOLVED_UNIT, librarySource, task.resolvedUnit);
     _cache.storedAst(unitSource);
     return dartEntry;
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
   HtmlEntry _recordResolveHtmlTaskResults(ResolveHtmlTask task) {
     Source source = task.source;
@@ skipping 144 matching lines @@
     }
     // Check if the content of the source is the same as it was the last time.
     String sourceContent = sourceEntry.getValue(SourceEntry.CONTENT);
     if (sourceContent != null) {
       sourceEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
       try {
         TimestampedData<String> fileContents = getContents(source);
         if (fileContents.data == sourceContent) {
           return;
         }
-      } catch (e) {
-      }
+      } catch (e) {}
     }
     // We have to invalidate the cache.
     _propagateInvalidation(source, sourceEntry);
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been deleted
    */
   void _sourceDeleted(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
-      htmlEntry.recordContentError(
-          new CaughtException(
-              new AnalysisException("This source was marked as being deleted"),
-              null));
+      htmlEntry.recordContentError(new CaughtException(
+          new AnalysisException("This source was marked as being deleted"),
+          null));
     } else if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       HashSet<Source> libraries = new HashSet<Source>();
       for (Source librarySource in getLibrariesContaining(source)) {
         libraries.add(librarySource);
-        for (Source dependentLibrary in getLibrariesDependingOn(
-            librarySource)) {
+        for (Source dependentLibrary
+            in getLibrariesDependingOn(librarySource)) {
           libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
         _invalidateLibraryResolution(librarySource);
       }
-      dartEntry.recordContentError(
-          new CaughtException(
-              new AnalysisException("This source was marked as being deleted"),
-              null));
+      dartEntry.recordContentError(new CaughtException(
+          new AnalysisException("This source was marked as being deleted"),
+          null));
     }
     _workManager.remove(source);
     _removeFromPriorityOrder(source);
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been removed
    */
   void _sourceRemoved(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
-    if (sourceEntry is HtmlEntry) {
-    } else if (sourceEntry is DartEntry) {
+    if (sourceEntry is HtmlEntry) {} else if (sourceEntry is DartEntry) {
       HashSet<Source> libraries = new HashSet<Source>();
       for (Source librarySource in getLibrariesContaining(source)) {
         libraries.add(librarySource);
-        for (Source dependentLibrary in getLibrariesDependingOn(
-            librarySource)) {
+        for (Source dependentLibrary
+            in getLibrariesDependingOn(librarySource)) {
           libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
         _invalidateLibraryResolution(librarySource);
       }
     }
     _cache.remove(source);
     _workManager.remove(source);
     _removeFromPriorityOrder(source);
@@ skipping 25 matching lines @@
       }
       // prepare the existing unit
       CompilationUnit oldUnit =
           getResolvedCompilationUnit2(unitSource, librarySource);
       if (oldUnit == null) {
         return false;
       }
       // do resolution
       Stopwatch perfCounter = new Stopwatch()..start();
       PoorMansIncrementalResolver resolver = new PoorMansIncrementalResolver(
-          typeProvider,
-          unitSource,
-          dartEntry,
-          oldUnit,
+          typeProvider, unitSource, dartEntry, oldUnit,
           analysisOptions.incrementalApi);
       bool success = resolver.resolve(newCode);
       AnalysisEngine.instance.instrumentationService.logPerformance(
-          AnalysisPerformanceKind.INCREMENTAL,
-          perfCounter,
+          AnalysisPerformanceKind.INCREMENTAL, perfCounter,
           'success=$success,context_id=$_id,code_length=${newCode.length}');
       if (!success) {
         return false;
       }
       // if validation, remember the result, but throw it away
       if (analysisOptions.incrementalValidation) {
         incrementalResolutionValidation_lastUnitSource = oldUnit.element.source;
         incrementalResolutionValidation_lastLibrarySource =
             oldUnit.element.library.source;
         incrementalResolutionValidation_lastUnit = oldUnit;
@@ skipping 78 matching lines @@
         incrementalResolutionValidation_lastLibrarySource == null ||
         incrementalResolutionValidation_lastUnit == null) {
       return;
     }
     CompilationUnit fullUnit = getResolvedCompilationUnit2(
         incrementalResolutionValidation_lastUnitSource,
         incrementalResolutionValidation_lastLibrarySource);
     if (fullUnit != null) {
       try {
         assertSameResolution(
-            incrementalResolutionValidation_lastUnit,
-            fullUnit);
+            incrementalResolutionValidation_lastUnit, fullUnit);
       } on IncrementalResolutionMismatch catch (mismatch, stack) {
         String failure = mismatch.message;
         String message =
             'Incremental resolution mismatch:\n$failure\nat\n$stack';
         AnalysisEngine.instance.logger.logError(message);
       }
     }
     incrementalResolutionValidation_lastUnitSource = null;
     incrementalResolutionValidation_lastLibrarySource = null;
     incrementalResolutionValidation_lastUnit = null;
   }
 }
 
 /**
  * An `AnalysisTaskResultRecorder` is used by an analysis context to record the
  * results of a task.
  */
-class AnalysisContextImpl_AnalysisTaskResultRecorder implements
-    AnalysisTaskVisitor<SourceEntry> {
+class AnalysisContextImpl_AnalysisTaskResultRecorder
+    implements AnalysisTaskVisitor<SourceEntry> {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
   AnalysisContextImpl_AnalysisTaskResultRecorder(this.AnalysisContextImpl_this);
 
   @override
   DartEntry visitBuildUnitElementTask(BuildUnitElementTask task) =>
       AnalysisContextImpl_this._recordBuildUnitElementTask(task);
 
   @override
   DartEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) =>
@@ skipping 17 matching lines @@
 
   @override
   DartEntry visitParseDartTask(ParseDartTask task) =>
       AnalysisContextImpl_this._recordParseDartTaskResults(task);
 
   @override
   HtmlEntry visitParseHtmlTask(ParseHtmlTask task) =>
       AnalysisContextImpl_this._recordParseHtmlTaskResults(task);
 
   @override
-  DartEntry
-      visitResolveDartLibraryCycleTask(ResolveDartLibraryCycleTask task) =>
+  DartEntry visitResolveDartLibraryCycleTask(
+          ResolveDartLibraryCycleTask task) =>
       AnalysisContextImpl_this.recordResolveDartLibraryCycleTaskResults(task);
 
   @override
   DartEntry visitResolveDartLibraryTask(ResolveDartLibraryTask task) =>
       AnalysisContextImpl_this.recordResolveDartLibraryTaskResults(task);
 
   @override
   DartEntry visitResolveDartUnitTask(ResolveDartUnitTask task) =>
       AnalysisContextImpl_this._recordResolveDartUnitTaskResults(task);
 
   @override
   HtmlEntry visitResolveHtmlTask(ResolveHtmlTask task) =>
       AnalysisContextImpl_this._recordResolveHtmlTaskResults(task);
 
   @override
   DartEntry visitScanDartTask(ScanDartTask task) =>
       AnalysisContextImpl_this._recordScanDartTaskResults(task);
 }
 
-class AnalysisContextImpl_ContextRetentionPolicy implements CacheRetentionPolicy
-    {
+class AnalysisContextImpl_ContextRetentionPolicy
+    implements CacheRetentionPolicy {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
   AnalysisContextImpl_ContextRetentionPolicy(this.AnalysisContextImpl_this);
 
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) {
     int priorityCount = AnalysisContextImpl_this._priorityOrder.length;
     for (int i = 0; i < priorityCount; i++) {
       if (source == AnalysisContextImpl_this._priorityOrder[i]) {
         return RetentionPriority.HIGH;
@@ skipping 95 matching lines @@
     //
     // Ensure that all of the data needed to resolve them has been computed.
     //
     _ensureImportsAndExports();
     if (_taskData != null) {
       // At least one imported library needs to be resolved before the target
       // library.
       AnalysisTask task = _taskData.task;
       if (task is ResolveDartLibraryTask) {
         AnalysisContextImpl_this._workManager.addFirst(
-            task.librarySource,
-            SourcePriority.LIBRARY);
+            task.librarySource, SourcePriority.LIBRARY);
       }
       return;
     }
     _computePartsInCycle(librarySource);
     if (_taskData != null) {
       // At least one part needs to be parsed.
       return;
     }
     // All of the AST's necessary to perform a resolution of the library cycle
     // have been gathered, so it is no longer necessary to retain them in the
@@ skipping 42 matching lines @@
         _getSources(librarySource, dartEntry, DartEntry.IMPORTED_LIBRARIES);
     if (_taskData != null) {
       return;
     }
     List<Source> exportedSources =
         _getSources(librarySource, dartEntry, DartEntry.EXPORTED_LIBRARIES);
     if (_taskData != null) {
       return;
     }
     _computeLibraryDependenciesFromDirectives(
-        library,
-        importedSources,
-        exportedSources);
+        library, importedSources, exportedSources);
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of
    * the class [Library] to represent them, and record the references in the library
    * objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @param importedSources an array containing the sources that are imported into the given
    *          library
@@ skipping 13 matching lines @@
       } else if (importedSource ==
           AnalysisContextImpl_this._asyncLibrarySource) {
         importsAsync = true;
       }
       if (!_addDependency(library, importedSource, importedLibraries)) {
         return;
       }
     }
     library.explicitlyImportsCore = explicitlyImportsCore;
     if (!explicitlyImportsCore) {
-      if (!_addDependency(
-          library,
-          AnalysisContextImpl_this._coreLibrarySource,
+      if (!_addDependency(library, AnalysisContextImpl_this._coreLibrarySource,
           importedLibraries)) {
         return;
       }
     }
     if (!importsAsync) {
       // Add a dependency on async to ensure that the Future element will be
       // built before we generate errors and warnings for async methods.  Also
       // include it in importedLibraries, so that it will be picked up by
       // LibraryResolver2._buildLibraryMap().
       // TODO(paulberry): this is a bit of a hack, since the async library
       // isn't actually being imported.  Also, it's not clear whether it should
       // be necessary: in theory, dart:core already (indirectly) imports
       // dart:async, so if core has been built, async should have been built
       // too.  However, removing this code causes unit test failures.
-      if (!_addDependency(
-          library,
-          AnalysisContextImpl_this._asyncLibrarySource,
+      if (!_addDependency(library, AnalysisContextImpl_this._asyncLibrarySource,
           importedLibraries)) {
         return;
       }
     }
     library.importedLibraries = importedLibraries;
     int exportCount = exportedSources.length;
     if (exportCount > 0) {
       List<ResolvableLibrary> exportedLibraries = new List<ResolvableLibrary>();
       for (int i = 0; i < exportCount; i++) {
         Source exportedSource = exportedSources[i];
@@ skipping 11 matching lines @@
    * AST structure for each compilation unit, then we gather them. We split the work this way
    * because getting the AST structures can change the state of the cache in such a way that we
    * would have more work to do if any compilation unit didn't have a resolvable AST structure.
    */
   void _computePartsInCycle(Source librarySource) {
     int count = _librariesInCycle.length;
     List<CycleBuilder_LibraryPair> libraryData =
         new List<CycleBuilder_LibraryPair>();
     for (int i = 0; i < count; i++) {
       ResolvableLibrary library = _librariesInCycle[i];
-      libraryData.add(
-          new CycleBuilder_LibraryPair(library, _ensurePartsInLibrary(library)));
+      libraryData.add(new CycleBuilder_LibraryPair(
+          library, _ensurePartsInLibrary(library)));
     }
     AnalysisContextImpl_this._neededForResolution = _gatherSources(libraryData);
     if (AnalysisContextImpl._TRACE_PERFORM_TASK) {
       print(
           "  preserve resolution data for ${AnalysisContextImpl_this._neededForResolution.length} sources while resolving ${librarySource.fullName}");
     }
     if (_taskData != null) {
       return;
     }
     for (int i = 0; i < count; i++) {
@@ skipping 11 matching lines @@
   void _computePartsInLibrary(CycleBuilder_LibraryPair libraryPair) {
     ResolvableLibrary library = libraryPair.library;
     List<CycleBuilder_SourceEntryPair> entryPairs = libraryPair.entryPairs;
     int count = entryPairs.length;
     List<ResolvableCompilationUnit> units =
         new List<ResolvableCompilationUnit>(count);
     for (int i = 0; i < count; i++) {
       CycleBuilder_SourceEntryPair entryPair = entryPairs[i];
       Source source = entryPair.source;
       DartEntry dartEntry = entryPair.entry;
-      units[i] =
-          new ResolvableCompilationUnit(source, dartEntry.resolvableCompilationUnit);
+      units[i] = new ResolvableCompilationUnit(
+          source, dartEntry.resolvableCompilationUnit);
     }
     library.resolvableCompilationUnits = units;
   }
 
   /**
    * Create an object to represent the information about the library defined by the compilation
    * unit with the given source.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @return the library object that was created
@@ skipping 41 matching lines @@
    *
    * @param library the library which needs an element model.
    */
   void _ensureElementModel(ResolvableLibrary library) {
     Source librarySource = library.librarySource;
     DartEntry libraryEntry =
         AnalysisContextImpl_this._getReadableDartEntry(librarySource);
     if (libraryEntry != null &&
         libraryEntry.getState(DartEntry.PARSED_UNIT) != CacheState.ERROR) {
       AnalysisContextImpl_this._workManager.addFirst(
-          librarySource,
-          SourcePriority.LIBRARY);
+          librarySource, SourcePriority.LIBRARY);
       if (_taskData == null) {
         _taskData = AnalysisContextImpl_this._createResolveDartLibraryTask(
-            librarySource,
-            libraryEntry);
+            librarySource, libraryEntry);
       }
     }
   }
 
   /**
    * Ensure that all of the libraries that are exported by the given library (but are not
    * themselves in the cycle) have element models built for them. If another task needs to be
    * executed first in order to build the element model, that task is placed in [taskData].
    *
    * @param library the library being tested
    */
-  void _ensureExports(ResolvableLibrary library,
-      HashSet<Source> visitedLibraries) {
+  void _ensureExports(
+      ResolvableLibrary library, HashSet<Source> visitedLibraries) {
     List<ResolvableLibrary> dependencies = library.exports;
     int dependencyCount = dependencies.length;
     for (int i = 0; i < dependencyCount; i++) {
       ResolvableLibrary dependency = dependencies[i];
       if (!_librariesInCycle.contains(dependency) &&
           visitedLibraries.add(dependency.librarySource)) {
         if (dependency.libraryElement == null) {
           _ensureElementModel(dependency);
         } else {
           _ensureExports(dependency, visitedLibraries);
@@ skipping 47 matching lines @@
     }
   }
 
   /**
    * Ensure that there is a resolvable compilation unit available for all of the compilation units
    * in the given library.
    *
    * @param library the library for which resolvable compilation units must be available
    * @return a list of (source, entry) pairs for all of the compilation units in the library
    */
-  List<CycleBuilder_SourceEntryPair>
-      _ensurePartsInLibrary(ResolvableLibrary library) {
+  List<CycleBuilder_SourceEntryPair> _ensurePartsInLibrary(
+      ResolvableLibrary library) {
     List<CycleBuilder_SourceEntryPair> pairs =
         new List<CycleBuilder_SourceEntryPair>();
     Source librarySource = library.librarySource;
     DartEntry libraryEntry =
         AnalysisContextImpl_this._getReadableDartEntry(librarySource);
     if (libraryEntry == null) {
       throw new AnalysisException(
           "Cannot find entry for ${librarySource.fullName}");
     } else if (libraryEntry.getState(DartEntry.PARSED_UNIT) ==
         CacheState.ERROR) {
       String message =
           "Cannot compute parsed unit for ${librarySource.fullName}";
       CaughtException exception = libraryEntry.exception;
       if (exception == null) {
         throw new AnalysisException(message);
       }
       throw new AnalysisException(
-          message,
-          new CaughtException(exception, null));
+          message, new CaughtException(exception, null));
     }
     _ensureResolvableCompilationUnit(librarySource, libraryEntry);
     pairs.add(new CycleBuilder_SourceEntryPair(librarySource, libraryEntry));
     List<Source> partSources =
         _getSources(librarySource, libraryEntry, DartEntry.INCLUDED_PARTS);
     int count = partSources.length;
     for (int i = 0; i < count; i++) {
       Source partSource = partSources[i];
       DartEntry partEntry =
           AnalysisContextImpl_this._getReadableDartEntry(partSource);
@@ skipping 139 matching lines @@
 }
 
 /**
  * Information about single piece of data in the cache.
  */
 abstract class AnalysisContextStatistics_CacheRow {
   /**
    * List of possible states which can be queried.
    */
   static const List<CacheState> STATES = const <CacheState>[
-      CacheState.ERROR,
-      CacheState.FLUSHED,
-      CacheState.IN_PROCESS,
-      CacheState.INVALID,
-      CacheState.VALID];
+    CacheState.ERROR,
+    CacheState.FLUSHED,
+    CacheState.IN_PROCESS,
+    CacheState.INVALID,
+    CacheState.VALID
+  ];
 
   /**
    * Return the number of entries whose state is [CacheState.ERROR].
    */
   int get errorCount;
 
   /**
    * Return the number of entries whose state is [CacheState.FLUSHED].
    */
   int get flushedCount;
@@ skipping 90 matching lines @@
     row._incState(state);
     if (state == CacheState.ERROR) {
       CaughtException exception = dartEntry.exception;
       if (exception != null) {
         _exceptions.add(exception);
       }
     }
   }
 }
 
-class AnalysisContextStatisticsImpl_CacheRowImpl implements
-    AnalysisContextStatistics_CacheRow {
+class AnalysisContextStatisticsImpl_CacheRowImpl
+    implements AnalysisContextStatistics_CacheRow {
   final String name;
 
   Map<CacheState, int> _counts = <CacheState, int>{};
 
   AnalysisContextStatisticsImpl_CacheRowImpl(this.name);
 
   @override
   int get errorCount => getCount(CacheState.ERROR);
 
   @override
@@ skipping 27 matching lines @@
 
   void _incState(CacheState state) {
     if (_counts[state] == null) {
       _counts[state] = 1;
     } else {
       _counts[state]++;
     }
   }
 }
 
-class AnalysisContextStatisticsImpl_PartitionDataImpl implements
-    AnalysisContextStatistics_PartitionData {
+class AnalysisContextStatisticsImpl_PartitionDataImpl
+    implements AnalysisContextStatistics_PartitionData {
   final int astCount;
 
   final int totalCount;
 
-  AnalysisContextStatisticsImpl_PartitionDataImpl(this.astCount,
-      this.totalCount);
+  AnalysisContextStatisticsImpl_PartitionDataImpl(
+      this.astCount, this.totalCount);
 }
 
 /**
  * Instances of the class `AnalysisDelta` indicate changes to the types of analysis that
  * should be performed.
  */
 class AnalysisDelta {
   /**
    * A mapping from source to what type of analysis should be performed on that source.
    */
@@ skipping 41 matching lines @@
     needsSeparator =
         _appendSources(buffer, needsSeparator, AnalysisLevel.RESOLVED);
     _appendSources(buffer, needsSeparator, AnalysisLevel.NONE);
     return buffer.toString();
   }
 
   /**
    * Appendto the given [builder] all sources with the given analysis [level],
    * prefixed with a label and a separator if [needsSeparator] is `true`.
    */
-  bool _appendSources(StringBuffer buffer, bool needsSeparator,
-      AnalysisLevel level) {
+  bool _appendSources(
+      StringBuffer buffer, bool needsSeparator, AnalysisLevel level) {
     bool first = true;
     _analysisMap.forEach((Source source, AnalysisLevel sourceLevel) {
       if (sourceLevel == level) {
         if (first) {
           first = false;
           if (needsSeparator) {
             buffer.write("; ");
           }
           buffer.write(level);
           buffer.write(" ");
@@ skipping 123 matching lines @@
    * Return `true` if the given file name is assumed to contain Dart source code.
    *
    * @param fileName the name of the file being tested
    * @return `true` if the given file name is assumed to contain Dart source code
    */
   static bool isDartFileName(String fileName) {
     if (fileName == null) {
       return false;
     }
     return javaStringEqualsIgnoreCase(
-        FileNameUtilities.getExtension(fileName),
-        SUFFIX_DART);
+        FileNameUtilities.getExtension(fileName), SUFFIX_DART);
   }
 
   /**
    * Return `true` if the given file name is assumed to contain HTML.
    *
    * @param fileName the name of the file being tested
    * @return `true` if the given file name is assumed to contain HTML
    */
   static bool isHtmlFileName(String fileName) {
     if (fileName == null) {
@@ skipping 141 matching lines @@
    */
   void parsedHtml(AnalysisContext context, Source source, ht.HtmlUnit unit);
 
   /**
    * Reports that the given Dart source was resolved in the given context.
    *
    * @param context the context in which the source was resolved
    * @param source the source that was resolved
    * @param unit the result of resolving the source in the given context
    */
-  void resolvedDart(AnalysisContext context, Source source,
-      CompilationUnit unit);
+  void resolvedDart(
+      AnalysisContext context, Source source, CompilationUnit unit);
 
   /**
    * Reports that the given HTML source was resolved in the given context.
    *
    * @param context the context in which the source was resolved
    * @param source the source that was resolved
    * @param unit the result of resolving the source in the given context
    */
   void resolvedHtml(AnalysisContext context, Source source, ht.HtmlUnit unit);
 }
 
 /**
  * Futures returned by [AnalysisContext] for pending analysis results will
  * complete with this error if it is determined that analysis results will
  * never become available (e.g. because the requested source is not subject to
  * analysis, or because the requested source is a part file which is not a part
  * of any known library).
  */
-class AnalysisNotScheduledError implements Exception {
-}
+class AnalysisNotScheduledError implements Exception {}
 
 /**
  * The interface `AnalysisOptions` defines the behavior of objects that provide access to a
  * set of analysis options used to control the behavior of an analysis context.
  */
 abstract class AnalysisOptions {
   /**
    * If analysis is to parse and analyze all function bodies, return `true`.
    * If analysis is to skip all function bodies, return `false`.  If analysis
    * is to parse and analyze function bodies in some sources and not in others,
@@ skipping 196 matching lines @@
     incrementalApi = options.incrementalApi;
     incrementalValidation = options.incrementalValidation;
     lint = options.lint;
     preserveComments = options.preserveComments;
   }
 
   bool get analyzeFunctionBodies {
     if (identical(analyzeFunctionBodiesPredicate, _analyzeAllFunctionBodies)) {
       return true;
     } else if (identical(
-        analyzeFunctionBodiesPredicate,
-        _analyzeNoFunctionBodies)) {
+        analyzeFunctionBodiesPredicate, _analyzeNoFunctionBodies)) {
       return false;
     } else {
       throw new StateError('analyzeFunctionBodiesPredicate in use');
     }
   }
 
   set analyzeFunctionBodies(bool value) {
     if (value) {
       analyzeFunctionBodiesPredicate = _analyzeAllFunctionBodies;
     } else {
@@ skipping 92 matching lines @@
   final int performTime;
 
   /**
    * Initialize a newly created analysis result to have the given values.
    *
    * @param notices the change notices associated with this result
    * @param getTime the number of milliseconds required to determine which task was to be performed
    * @param taskClassName the name of the class of the task that was performed
    * @param performTime the number of milliseconds required to perform the task
    */
-  AnalysisResult(this._notices, this.getTime, this.taskClassName,
-      this.performTime);
+  AnalysisResult(
+      this._notices, this.getTime, this.taskClassName, this.performTime);
 
   /**
    * Return the change notices associated with this result, or `null` if there were no changes
    * and there is no more work to be done.
    *
    * @return the change notices associated with this result
    */
   List<ChangeNotice> get changeNotices => _notices;
 
   /**
@@ skipping 67 matching lines @@
    */
   Object perform(AnalysisTaskVisitor visitor) {
     try {
       _safelyPerform();
     } on AnalysisException catch (exception, stackTrace) {
       _thrownException = new CaughtException(exception, stackTrace);
       AnalysisEngine.instance.logger.logInformation(
           "Task failed: $taskDescription",
           new CaughtException(exception, stackTrace));
     }
-    return PerformanceStatistics.analysisTaskVisitor.makeCurrentWhile(
-        () => accept(visitor));
+    return PerformanceStatistics.analysisTaskVisitor
+        .makeCurrentWhile(() => accept(visitor));
   }
 
   @override
   String toString() => taskDescription;
 
   /**
    * Perform this analysis task, ensuring that all exceptions are wrapped in an
    * [AnalysisException].
    *
    * @throws AnalysisException if any exception occurs while performing the task
    */
   void _safelyPerform() {
     try {
       String contextName = context.name;
       if (contextName == null) {
         contextName = 'unnamed';
       }
       AnalysisEngine.instance.instrumentationService.logAnalysisTask(
-          contextName,
-          taskDescription);
+          contextName, taskDescription);
       internalPerform();
     } on AnalysisException catch (exception) {
       rethrow;
     } catch (exception, stackTrace) {
       throw new AnalysisException(
-          exception.toString(),
-          new CaughtException(exception, stackTrace));
+          exception.toString(), new CaughtException(exception, stackTrace));
     }
   }
 }
 
 /**
  * An `AnalysisTaskVisitor` visits tasks. While tasks are not structured in any
  * interesting way, this class provides the ability to dispatch to an
  * appropriate method.
  */
 abstract class AnalysisTaskVisitor<E> {
@@ skipping 24 matching lines @@
   /**
    * Visit the given [task], returning the result of the visit. This method will
    * throw an AnalysisException if the visitor throws an exception.
    */
   E visitGetContentTask(GetContentTask task);
 
   /**
    * Visit the given [task], returning the result of the visit. This method will
    * throw an AnalysisException if the visitor throws an exception.
    */
-  E
-      visitIncrementalAnalysisTask(IncrementalAnalysisTask incrementalAnalysisTask);
+  E visitIncrementalAnalysisTask(
+      IncrementalAnalysisTask incrementalAnalysisTask);
 
   /**
    * Visit the given [task], returning the result of the visit. This method will
    * throw an AnalysisException if the visitor throws an exception.
    */
   E visitParseDartTask(ParseDartTask task);
 
   /**
    * Visit the given [task], returning the result of the visit. This method will
    * throw an AnalysisException if the visitor throws an exception.
@@ skipping 368 matching lines @@
    * The data is in the cache and up-to-date.
    *
    * Valid Transitions:
    * * [FLUSHED] if the data is removed in order to manage memory usage
    * * [INVALID] if a source was modified in such a way as to invalidate the
    *   previous data
    */
   static const CacheState VALID = const CacheState('VALID', 4);
 
   static const List<CacheState> values = const [
-      ERROR,
-      FLUSHED,
-      IN_PROCESS,
-      INVALID,
-      VALID];
+    ERROR,
+    FLUSHED,
+    IN_PROCESS,
+    INVALID,
+    VALID
+  ];
 
   const CacheState(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * An object that represents a change to the analysis results associated with a
  * given source.
  */
 abstract class ChangeNotice implements AnalysisErrorInfo {
   /**
@@ skipping 78 matching lines @@
   LineInfo get lineInfo => _lineInfo;
 
   /**
    * Set the errors that changed as a result of the analysis to the given
    * [errors] and set the line information to the given [lineInfo].
    */
   void setErrors(List<AnalysisError> errors, LineInfo lineInfo) {
     this._errors = errors;
     this._lineInfo = lineInfo;
     if (lineInfo == null) {
-      AnalysisEngine.instance.logger.logInformation(
-          "No line info: $source",
+      AnalysisEngine.instance.logger.logInformation("No line info: $source",
           new CaughtException(new AnalysisException(), null));
     }
   }
 
   @override
   String toString() => "Changes for ${source.fullName}";
 }
 
 /**
  * Instances of the class `ChangeSet` indicate which sources have been added, changed,
@@ skipping 51 matching lines @@
    * @return a table mapping the sources whose content has been changed to the current content of
    *         those sources
    */
   Map<Source, String> get changedContents => _changedContent;
 
   /**
    * Return `true` if this change set does not contain any changes.
    *
    * @return `true` if this change set does not contain any changes
    */
-  bool get isEmpty =>
-      addedSources.isEmpty &&
-          changedSources.isEmpty &&
-          _changedContent.isEmpty &&
-          changedRanges.isEmpty &&
-          removedSources.isEmpty &&
-          removedContainers.isEmpty &&
-          deletedSources.isEmpty;
+  bool get isEmpty => addedSources.isEmpty &&
+      changedSources.isEmpty &&
+      _changedContent.isEmpty &&
+      changedRanges.isEmpty &&
+      removedSources.isEmpty &&
+      removedContainers.isEmpty &&
+      deletedSources.isEmpty;
 
   /**
    * Record that the specified source has been added and that its content is the default contents of
    * the source.
    *
    * @param source the source that was added
    */
   void addedSource(Source source) {
     addedSources.add(source);
   }
@@ skipping 64 matching lines @@
     if (source != null) {
       removedSources.add(source);
     }
   }
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     bool needsSeparator =
         _appendSources(buffer, addedSources, false, "addedSources");
-    needsSeparator =
-        _appendSources(buffer, changedSources, needsSeparator, "changedSources");
-    needsSeparator =
-        _appendSources2(buffer, _changedContent, needsSeparator, "changedContent");
+    needsSeparator = _appendSources(
+        buffer, changedSources, needsSeparator, "changedSources");
+    needsSeparator = _appendSources2(
+        buffer, _changedContent, needsSeparator, "changedContent");
     needsSeparator =
         _appendSources2(buffer, changedRanges, needsSeparator, "changedRanges");
-    needsSeparator =
-        _appendSources(buffer, deletedSources, needsSeparator, "deletedSources");
-    needsSeparator =
-        _appendSources(buffer, removedSources, needsSeparator, "removedSources");
+    needsSeparator = _appendSources(
+        buffer, deletedSources, needsSeparator, "deletedSources");
+    needsSeparator = _appendSources(
+        buffer, removedSources, needsSeparator, "removedSources");
     int count = removedContainers.length;
     if (count > 0) {
       if (removedSources.isEmpty) {
         if (needsSeparator) {
           buffer.write("; ");
         }
         buffer.write("removed: from ");
         buffer.write(count);
         buffer.write(" containers");
       } else {
@@ skipping 87 matching lines @@
   final int newLength;
 
   /**
    * Initialize a newly created change object to represent a change to the content of a source.
    *
    * @param contents the new contents of the source
    * @param offset the offset into the current contents
    * @param oldLength the number of characters in the original contents that were replaced
    * @param newLength the number of characters in the replacement text
    */
-  ChangeSet_ContentChange(this.contents, this.offset, this.oldLength,
-      this.newLength);
+  ChangeSet_ContentChange(
+      this.contents, this.offset, this.oldLength, this.newLength);
 }
 
 /**
  * Instances of the class `LibraryPair` hold a library and a list of the (source, entry)
  * pairs for compilation units in the library.
  */
 class CycleBuilder_LibraryPair {
   /**
    * The library containing the compilation units.
    */
@@ skipping 66 matching lines @@
    */
   static final DataDescriptor<CompilationUnit> BUILT_UNIT =
       new DataDescriptor<CompilationUnit>("DartEntry.BUILT_UNIT");
 
   /**
    * The data descriptor representing the list of libraries that contain this
    * compilation unit.
    */
   static final DataDescriptor<List<Source>> CONTAINING_LIBRARIES =
       new DataDescriptor<List<Source>>(
-          "DartEntry.CONTAINING_LIBRARIES",
-          Source.EMPTY_ARRAY);
+          "DartEntry.CONTAINING_LIBRARIES", Source.EMPTY_ARRAY);
 
   /**
    * The data descriptor representing the library element for the library. This
    * data is only available for Dart files that are the defining compilation
    * unit of a library.
    */
   static final DataDescriptor<LibraryElement> ELEMENT =
       new DataDescriptor<LibraryElement>("DartEntry.ELEMENT");
 
   /**
    * The data descriptor representing the list of exported libraries. This data
    * is only available for Dart files that are the defining compilation unit of
    * a library.
    */
   static final DataDescriptor<List<Source>> EXPORTED_LIBRARIES =
       new DataDescriptor<List<Source>>(
-          "DartEntry.EXPORTED_LIBRARIES",
-          Source.EMPTY_ARRAY);
+          "DartEntry.EXPORTED_LIBRARIES", Source.EMPTY_ARRAY);
 
   /**
    * The data descriptor representing the hints resulting from auditing the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> HINTS =
       new DataDescriptor<List<AnalysisError>>(
-          "DartEntry.HINTS",
-          AnalysisError.NO_ERRORS);
+          "DartEntry.HINTS", AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the list of imported libraries. This data
    * is only available for Dart files that are the defining compilation unit of
    * a library.
    */
   static final DataDescriptor<List<Source>> IMPORTED_LIBRARIES =
       new DataDescriptor<List<Source>>(
-          "DartEntry.IMPORTED_LIBRARIES",
-          Source.EMPTY_ARRAY);
+          "DartEntry.IMPORTED_LIBRARIES", Source.EMPTY_ARRAY);
 
   /**
    * The data descriptor representing the list of included parts. This data is
    * only available for Dart files that are the defining compilation unit of a
    * library.
    */
   static final DataDescriptor<List<Source>> INCLUDED_PARTS =
       new DataDescriptor<List<Source>>(
-          "DartEntry.INCLUDED_PARTS",
-          Source.EMPTY_ARRAY);
+          "DartEntry.INCLUDED_PARTS", Source.EMPTY_ARRAY);
 
   /**
    * The data descriptor representing the client flag. This data is only
    * available for Dart files that are the defining compilation unit of a
    * library.
    */
   static final DataDescriptor<bool> IS_CLIENT =
       new DataDescriptor<bool>("DartEntry.IS_CLIENT", false);
 
   /**
    * The data descriptor representing the launchable flag. This data is only
    * available for Dart files that are the defining compilation unit of a
    * library.
    */
   static final DataDescriptor<bool> IS_LAUNCHABLE =
       new DataDescriptor<bool>("DartEntry.IS_LAUNCHABLE", false);
 
   /**
    * The data descriptor representing lint warnings resulting from auditing the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> LINTS =
       new DataDescriptor<List<AnalysisError>>(
-          "DartEntry.LINTS",
-          AnalysisError.NO_ERRORS);
+          "DartEntry.LINTS", AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the errors resulting from parsing the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> PARSE_ERRORS =
       new DataDescriptor<List<AnalysisError>>(
-          "DartEntry.PARSE_ERRORS",
-          AnalysisError.NO_ERRORS);
+          "DartEntry.PARSE_ERRORS", AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the parsed AST structure.
    */
   static final DataDescriptor<CompilationUnit> PARSED_UNIT =
       new DataDescriptor<CompilationUnit>("DartEntry.PARSED_UNIT");
 
   /**
    * The data descriptor representing the public namespace of the library. This
    * data is only available for Dart files that are the defining compilation
    * unit of a library.
    */
   static final DataDescriptor<Namespace> PUBLIC_NAMESPACE =
       new DataDescriptor<Namespace>("DartEntry.PUBLIC_NAMESPACE");
 
   /**
    * The data descriptor representing the errors resulting from resolving the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> RESOLUTION_ERRORS =
       new DataDescriptor<List<AnalysisError>>(
-          "DartEntry.RESOLUTION_ERRORS",
-          AnalysisError.NO_ERRORS);
+          "DartEntry.RESOLUTION_ERRORS", AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the resolved AST structure.
    */
   static final DataDescriptor<CompilationUnit> RESOLVED_UNIT =
       new DataDescriptor<CompilationUnit>("DartEntry.RESOLVED_UNIT");
 
   /**
    * The data descriptor representing the errors resulting from scanning the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> SCAN_ERRORS =
       new DataDescriptor<List<AnalysisError>>(
-          "DartEntry.SCAN_ERRORS",
-          AnalysisError.NO_ERRORS);
+          "DartEntry.SCAN_ERRORS", AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the source kind.
    */
   static final DataDescriptor<SourceKind> SOURCE_KIND =
-      new DataDescriptor<SourceKind>("DartEntry.SOURCE_KIND", SourceKind.UNKNOWN);
+      new DataDescriptor<SourceKind>(
+          "DartEntry.SOURCE_KIND", SourceKind.UNKNOWN);
 
   /**
    * The data descriptor representing the token stream.
    */
   static final DataDescriptor<Token> TOKEN_STREAM =
       new DataDescriptor<Token>("DartEntry.TOKEN_STREAM");
 
   /**
    * The data descriptor representing the errors resulting from verifying the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> VERIFICATION_ERRORS =
       new DataDescriptor<List<AnalysisError>>(
-          "DartEntry.VERIFICATION_ERRORS",
-          AnalysisError.NO_ERRORS);
+          "DartEntry.VERIFICATION_ERRORS", AnalysisError.NO_ERRORS);
 
   /**
    * The list of libraries that contain this compilation unit. The list will be
    * empty if there are no known libraries that contain this compilation unit.
    */
   List<Source> _containingLibraries = new List<Source>();
 
   /**
    * The information known as a result of resolving this compilation unit as
    * part of the library that contains this unit. This field will never be
@@ skipping 72 matching lines @@
    * @param librarySource the source of the single library that the list should contain
    */
   void set containingLibrary(Source librarySource) {
     _containingLibraries.clear();
     _containingLibraries.add(librarySource);
   }
 
   @override
   List<DataDescriptor> get descriptors {
     List<DataDescriptor> result = super.descriptors;
-    result.addAll(
-        <DataDescriptor>[
-            DartEntry.SOURCE_KIND,
-            DartEntry.CONTAINING_LIBRARIES,
-            DartEntry.PARSE_ERRORS,
-            DartEntry.PARSED_UNIT,
-            DartEntry.SCAN_ERRORS,
-            DartEntry.SOURCE_KIND,
-            DartEntry.TOKEN_STREAM]);
+    result.addAll(<DataDescriptor>[
+      DartEntry.SOURCE_KIND,
+      DartEntry.CONTAINING_LIBRARIES,
+      DartEntry.PARSE_ERRORS,
+      DartEntry.PARSED_UNIT,
+      DartEntry.SCAN_ERRORS,
+      DartEntry.SOURCE_KIND,
+      DartEntry.TOKEN_STREAM
+    ]);
     SourceKind kind = getValue(DartEntry.SOURCE_KIND);
     if (kind == SourceKind.LIBRARY) {
-      result.addAll(
-          <DataDescriptor>[
-              DartEntry.ELEMENT,
-              DartEntry.EXPORTED_LIBRARIES,
-              DartEntry.IMPORTED_LIBRARIES,
-              DartEntry.INCLUDED_PARTS,
-              DartEntry.IS_CLIENT,
-              DartEntry.IS_LAUNCHABLE,
-              DartEntry.PUBLIC_NAMESPACE]);
+      result.addAll(<DataDescriptor>[
+        DartEntry.ELEMENT,
+        DartEntry.EXPORTED_LIBRARIES,
+        DartEntry.IMPORTED_LIBRARIES,
+        DartEntry.INCLUDED_PARTS,
+        DartEntry.IS_CLIENT,
+        DartEntry.IS_LAUNCHABLE,
+        DartEntry.PUBLIC_NAMESPACE
+      ]);
     }
     return result;
   }
 
   /**
    * Return `true` if this entry has an AST structure that can be resolved, even
    * if it needs to be copied. Returning `true` implies that the method
    * [resolvableCompilationUnit] will return a non-`null` result.
    */
   bool get hasResolvableCompilationUnit {
@@ skipping 45 matching lines @@
     }
     return result;
   }
 
   /**
    * Get a list of all the library-dependent descriptors for which values may
    * be stored in this SourceEntry.
    */
   List<DataDescriptor> get libraryDescriptors {
     return <DataDescriptor>[
-        DartEntry.BUILT_ELEMENT,
-        DartEntry.BUILT_UNIT,
-        DartEntry.RESOLUTION_ERRORS,
-        DartEntry.RESOLVED_UNIT,
-        DartEntry.VERIFICATION_ERRORS,
-        DartEntry.HINTS,
-        DartEntry.LINTS];
+      DartEntry.BUILT_ELEMENT,
+      DartEntry.BUILT_UNIT,
+      DartEntry.RESOLUTION_ERRORS,
+      DartEntry.RESOLVED_UNIT,
+      DartEntry.VERIFICATION_ERRORS,
+      DartEntry.HINTS,
+      DartEntry.LINTS
+    ];
   }
 
   /**
    * A compilation unit that has not been accessed by any other client and can
    * therefore safely be modified by the reconciler, or `null` if the source has
    * not been parsed.
    */
   CompilationUnit get resolvableCompilationUnit {
     if (getState(PARSED_UNIT) == CacheState.VALID) {
       CompilationUnit unit = getValue(PARSED_UNIT);
@@ skipping 29 matching lines @@
   void flushAstStructures() {
     _flush(TOKEN_STREAM);
     _flush(PARSED_UNIT);
     _resolutionState.flushAstStructures();
   }
 
   /**
    * Return the state of the data represented by the given [descriptor] in the
    * context of the given [librarySource].
    */
-  CacheState getStateInLibrary(DataDescriptor descriptor,
-      Source librarySource) {
+  CacheState getStateInLibrary(
+      DataDescriptor descriptor, Source librarySource) {
     if (!_isValidLibraryDescriptor(descriptor)) {
       throw new ArgumentError("Invalid descriptor: $descriptor");
     }
     ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == state._librarySource) {
         return state.getState(descriptor);
       }
       state = state._nextState;
     }
@@ skipping 86 matching lines @@
     _containingLibraries.clear();
     _discardCachedResolutionInformation(true);
   }
 
   /**
    * Record that an [exception] occurred while attempting to build the element
    * model for the source represented by this entry in the context of the given
    * [library]. This will set the state of all resolution-based information as
    * being in error, but will not change the state of any parse results.
    */
-  void recordBuildElementErrorInLibrary(Source librarySource,
-      CaughtException exception) {
+  void recordBuildElementErrorInLibrary(
+      Source librarySource, CaughtException exception) {
     setStateInLibrary(BUILT_ELEMENT, librarySource, CacheState.ERROR);
     setStateInLibrary(BUILT_UNIT, librarySource, CacheState.ERROR);
     recordResolutionErrorInLibrary(librarySource, exception);
   }
 
   @override
   void recordContentError(CaughtException exception) {
     super.recordContentError(exception);
     recordScanError(exception);
   }
 
   /**
    * Record that an error occurred while attempting to generate hints for the
    * source represented by this entry. This will set the state of all
    * verification information as being in error.
    *
    * @param librarySource the source of the library in which hints were being generated
    * @param exception the exception that shows where the error occurred
    */
-  void recordHintErrorInLibrary(Source librarySource,
-      CaughtException exception) {
+  void recordHintErrorInLibrary(
+      Source librarySource, CaughtException exception) {
     this.exception = exception;
     ResolutionState state = _getOrCreateResolutionState(librarySource);
     state.recordHintError();
   }
 
   /**
    * Record that an error occurred while attempting to generate lints for the
    * source represented by this entry. This will set the state of all
    * verification information as being in error.
    *
    * @param librarySource the source of the library in which lints were being generated
    * @param exception the exception that shows where the error occurred
    */
-  void recordLintErrorInLibrary(Source librarySource,
-      CaughtException exception) {
+  void recordLintErrorInLibrary(
+      Source librarySource, CaughtException exception) {
     this.exception = exception;
     ResolutionState state = _getOrCreateResolutionState(librarySource);
     state.recordLintError();
   }
 
   /**
    * Record that an [exception] occurred while attempting to scan or parse the
    * entry represented by this entry. This will set the state of all information,
    * including any resolution-based information, as being in error.
    */
@@ skipping 25 matching lines @@
   }
 
   /**
    * Record that an error occurred while attempting to resolve the source represented by this entry.
    * This will set the state of all resolution-based information as being in error, but will not
    * change the state of any parse results.
    *
    * @param librarySource the source of the library in which resolution was being performed
    * @param exception the exception that shows where the error occurred
    */
-  void recordResolutionErrorInLibrary(Source librarySource,
-      CaughtException exception) {
+  void recordResolutionErrorInLibrary(
+      Source librarySource, CaughtException exception) {
     this.exception = exception;
     setState(ELEMENT, CacheState.ERROR);
     setState(IS_CLIENT, CacheState.ERROR);
     setState(IS_LAUNCHABLE, CacheState.ERROR);
     setState(PUBLIC_NAMESPACE, CacheState.ERROR);
     ResolutionState state = _getOrCreateResolutionState(librarySource);
     state.recordResolutionError();
   }
 
   /**
@@ skipping 10 matching lines @@
   }
 
   /**
    * Record that an [exception] occurred while attempting to generate errors and
    * warnings for the source represented by this entry. This will set the state
    * of all verification information as being in error.
    *
    * @param librarySource the source of the library in which verification was being performed
    * @param exception the exception that shows where the error occurred
    */
-  void recordVerificationErrorInLibrary(Source librarySource,
-      CaughtException exception) {
+  void recordVerificationErrorInLibrary(
+      Source librarySource, CaughtException exception) {
     this.exception = exception;
     ResolutionState state = _getOrCreateResolutionState(librarySource);
     state.recordVerificationError();
   }
 
   /**
    * Remove the given [library] from the list of libraries that contain this
    * part. This method should only be invoked on entries that represent a part.
    *
    * @param librarySource the source of the library to be removed
@@ skipping 32 matching lines @@
 
   /**
    * Set the state of the data represented by the given descriptor in the context of the given
    * library to the given state.
    *
    * @param descriptor the descriptor representing the data whose state is to be set
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @param cacheState the new state of the data represented by the given descriptor
    */
-  void setStateInLibrary(DataDescriptor descriptor, Source librarySource,
-      CacheState cacheState) {
+  void setStateInLibrary(
+      DataDescriptor descriptor, Source librarySource, CacheState cacheState) {
     if (!_isValidLibraryDescriptor(descriptor)) {
       throw new ArgumentError("Invalid descriptor: $descriptor");
     }
     ResolutionState state = _getOrCreateResolutionState(librarySource);
     state.setState(descriptor, cacheState);
   }
 
   /**
    * Set the value of the data represented by the given descriptor in the context of the given
    * library to the given value, and set the state of that data to [CacheState.VALID].
    *
    * @param descriptor the descriptor representing which data is to have its value set
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @param value the new value of the data represented by the given descriptor and library
    */
-  void setValueInLibrary(DataDescriptor descriptor, Source librarySource,
-      Object value) {
+  void setValueInLibrary(
+      DataDescriptor descriptor, Source librarySource, Object value) {
     if (!_isValidLibraryDescriptor(descriptor)) {
       throw new ArgumentError("Invalid descriptor: $descriptor");
     }
     ResolutionState state = _getOrCreateResolutionState(librarySource);
     state.setValue(descriptor, value);
   }
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    *
@@ skipping 73 matching lines @@
   bool _writeDiffOn(StringBuffer buffer, SourceEntry oldEntry) {
     bool needsSeparator = super._writeDiffOn(buffer, oldEntry);
     if (oldEntry is! DartEntry) {
       if (needsSeparator) {
         buffer.write("; ");
       }
       buffer.write("entry type changed; was ");
       buffer.write(oldEntry.runtimeType.toString());
       return true;
     }
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator, "tokenStream",
+        DartEntry.TOKEN_STREAM, oldEntry);
     needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "tokenStream",
-        DartEntry.TOKEN_STREAM,
-        oldEntry);
+        buffer, needsSeparator, "scanErrors", DartEntry.SCAN_ERRORS, oldEntry);
     needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "scanErrors",
-        DartEntry.SCAN_ERRORS,
-        oldEntry);
+        buffer, needsSeparator, "sourceKind", DartEntry.SOURCE_KIND, oldEntry);
     needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "sourceKind",
-        DartEntry.SOURCE_KIND,
-        oldEntry);
+        buffer, needsSeparator, "parsedUnit", DartEntry.PARSED_UNIT, oldEntry);
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator, "parseErrors",
+        DartEntry.PARSE_ERRORS, oldEntry);
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator,
+        "importedLibraries", DartEntry.IMPORTED_LIBRARIES, oldEntry);
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator,
+        "exportedLibraries", DartEntry.EXPORTED_LIBRARIES, oldEntry);
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator, "includedParts",
+        DartEntry.INCLUDED_PARTS, oldEntry);
     needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "parsedUnit",
-        DartEntry.PARSED_UNIT,
-        oldEntry);
+        buffer, needsSeparator, "element", DartEntry.ELEMENT, oldEntry);
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator,
+        "publicNamespace", DartEntry.PUBLIC_NAMESPACE, oldEntry);
     needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "parseErrors",
-        DartEntry.PARSE_ERRORS,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "importedLibraries",
-        DartEntry.IMPORTED_LIBRARIES,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "exportedLibraries",
-        DartEntry.EXPORTED_LIBRARIES,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "includedParts",
-        DartEntry.INCLUDED_PARTS,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "element",
-        DartEntry.ELEMENT,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "publicNamespace",
-        DartEntry.PUBLIC_NAMESPACE,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "clientServer",
-        DartEntry.IS_CLIENT,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "launchable",
-        DartEntry.IS_LAUNCHABLE,
-        oldEntry);
+        buffer, needsSeparator, "clientServer", DartEntry.IS_CLIENT, oldEntry);
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator, "launchable",
+        DartEntry.IS_LAUNCHABLE, oldEntry);
     // TODO(brianwilkerson) Add better support for containingLibraries.
     // It would be nice to be able to report on size-preserving changes.
     int oldLibraryCount = (oldEntry as DartEntry)._containingLibraries.length;
     int libraryCount = _containingLibraries.length;
     if (oldLibraryCount != libraryCount) {
       if (needsSeparator) {
         buffer.write("; ");
       }
       buffer.write("containingLibraryCount = ");
       buffer.write(oldLibraryCount);
@@ skipping 20 matching lines @@
       if (librarySource != null) {
         ResolutionState oldState = oldStateMap.remove(librarySource);
         if (oldState == null) {
           if (needsSeparator) {
             buffer.write("; ");
           }
           buffer.write("added resolution for ");
           buffer.write(librarySource.fullName);
           needsSeparator = true;
         } else {
-          needsSeparator =
-              oldState._writeDiffOn(buffer, needsSeparator, oldEntry as DartEntry);
+          needsSeparator = oldState._writeDiffOn(
+              buffer, needsSeparator, oldEntry as DartEntry);
         }
       }
       state = state._nextState;
     }
     for (Source librarySource in oldStateMap.keys.toSet()) {
       if (needsSeparator) {
         buffer.write("; ");
       }
       buffer.write("removed resolution for ");
       buffer.write(librarySource.fullName);
@@ skipping 165 matching lines @@
       //
       // TODO(paulberry): as a temporary workaround for issue 21572,
       // ConstantVerifier is being run right after ConstantValueComputer, so we
       // don't need to run it here.  Once issue 21572 is fixed, re-enable the
       // call to ConstantVerifier.
 //      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, libraryElement, typeProvider);
 //      _unit.accept(constantVerifier);
       //
       // Use the ErrorVerifier to compute the rest of the errors.
       //
-      ErrorVerifier errorVerifier = new ErrorVerifier(
-          errorReporter,
-          libraryElement,
-          typeProvider,
-          new InheritanceManager(libraryElement));
+      ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter,
+          libraryElement, typeProvider, new InheritanceManager(libraryElement));
       _unit.accept(errorVerifier);
       _errors = errorListener.getErrorsForSource(source);
     });
   }
 
   /**
    * Check each directive in the given compilation unit to see if the referenced source exists and
    * report an error if it does not.
    *
    * @param context the context in which the library exists
    * @param librarySource the source representing the library containing the directives
    * @param unit the compilation unit containing the directives to be validated
    * @param errorListener the error listener to which errors should be reported
    */
   static void validateDirectives(AnalysisContext context, Source librarySource,
       CompilationUnit unit, AnalysisErrorListener errorListener) {
     for (Directive directive in unit.directives) {
       if (directive is UriBasedDirective) {
         validateReferencedSource(
-            context,
-            librarySource,
-            directive,
-            errorListener);
+            context, librarySource, directive, errorListener);
       }
     }
   }
 
   /**
    * Check the given directive to see if the referenced source exists and report an error if it does
    * not.
    *
    * @param context the context in which the library exists
    * @param librarySource the source representing the library containing the directive
    * @param directive the directive to be verified
    * @param errorListener the error listener to which errors should be reported
    */
   static void validateReferencedSource(AnalysisContext context,
       Source librarySource, UriBasedDirective directive,
       AnalysisErrorListener errorListener) {
     Source source = directive.source;
     if (source != null) {
       if (context.exists(source)) {
         return;
       }
     } else {
       // Don't report errors already reported by ParseDartTask.resolveDirective
       if (directive.validate() != null) {
         return;
       }
     }
     StringLiteral uriLiteral = directive.uri;
-    errorListener.onError(
-        new AnalysisError.con2(
-            librarySource,
-            uriLiteral.offset,
-            uriLiteral.length,
-            CompileTimeErrorCode.URI_DOES_NOT_EXIST,
-            [directive.uriContent]));
+    errorListener.onError(new AnalysisError.con2(librarySource,
+        uriLiteral.offset, uriLiteral.length,
+        CompileTimeErrorCode.URI_DOES_NOT_EXIST, [directive.uriContent]));
   }
 }
 
 /**
  * Instances of the class `GenerateDartHintsTask` generate hints for a single Dart library.
  */
 class GenerateDartHintsTask extends AnalysisTask {
   /**
    * The compilation units that comprise the library, with the defining compilation unit appearing
    * first in the array.
@@ skipping 12 matching lines @@
   HashMap<Source, List<AnalysisError>> _hintMap;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param units the compilation units that comprise the library, with the defining compilation
    *          unit appearing first in the array
    * @param libraryElement the element model for the library being analyzed
    */
-  GenerateDartHintsTask(InternalAnalysisContext context, this._units,
-      this.libraryElement)
+  GenerateDartHintsTask(
+      InternalAnalysisContext context, this._units, this.libraryElement)
       : super(context);
 
   /**
    * Return a table mapping the sources that were analyzed to the hints that were generated for the
    * sources, or `null` if the task has not been performed or if the analysis did not complete
    * normally.
    *
    * @return a table mapping the sources that were analyzed to the hints that were generated for the
    *         sources
    */
@@ skipping 57 matching lines @@
   HashMap<Source, List<AnalysisError>> lintMap;
 
   /// Initialize a newly created task to perform lint checking over these
   /// [_units] belonging to this [libraryElement] within the given [context].
   GenerateDartLintsTask(context, this._units, this.libraryElement)
       : super(context);
 
   @override
   String get taskDescription {
     Source librarySource = libraryElement.source;
-    return (librarySource == null) ?
-        "generate Dart lints for library without source" :
-        "generate Dart lints for ${librarySource.fullName}";
+    return (librarySource == null)
+        ? "generate Dart lints for library without source"
+        : "generate Dart lints for ${librarySource.fullName}";
   }
 
   @override
   accept(AnalysisTaskVisitor visitor) =>
       visitor.visitGenerateDartLintsTask(this);
 
   @override
   void internalPerform() {
-
     Iterable<CompilationUnit> compilationUnits =
         _units.map((TimestampedData<CompilationUnit> unit) => unit.data);
     RecordingErrorListener errorListener = new RecordingErrorListener();
     LintGenerator lintGenerator =
         new LintGenerator(compilationUnits, errorListener);
     lintGenerator.generate();
 
     lintMap = new HashMap<Source, List<AnalysisError>>();
     compilationUnits.forEach((CompilationUnit unit) {
       Source source = unit.element.source;
       lintMap[source] = errorListener.getErrorsForSource(source);
     });
   }
 }
 
-
 /**
  * Instances of the class `GetContentTask` get the contents of a source.
  */
 class GetContentTask extends AnalysisTask {
   /**
    * The source to be read.
    */
   final Source source;
 
   /**
@@ skipping 63 matching lines @@
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGetContentTask(this);
 
   @override
   void internalPerform() {
     _complete = true;
     try {
       TimestampedData<String> data = context.getContents(source);
       _content = data.data;
       _modificationTime = data.modificationTime;
-      AnalysisEngine.instance.instrumentationService.logFileRead(
-          source.fullName,
-          _modificationTime,
-          _content);
+      AnalysisEngine.instance.instrumentationService
+          .logFileRead(source.fullName, _modificationTime, _content);
     } catch (exception, stackTrace) {
-      errors.add(
-          new AnalysisError.con1(
-              source,
-              ScannerErrorCode.UNABLE_GET_CONTENT,
-              [exception]));
-      throw new AnalysisException(
-          "Could not get contents of $source",
+      errors.add(new AnalysisError.con1(
+          source, ScannerErrorCode.UNABLE_GET_CONTENT, [exception]));
+      throw new AnalysisException("Could not get contents of $source",
           new CaughtException(exception, stackTrace));
     }
   }
 }
 
 /**
  * An `HtmlEntry` maintains the information cached by an analysis context about
  * an individual HTML file.
  */
 class HtmlEntry extends SourceEntry {
   /**
    * The data descriptor representing the HTML element.
    */
   static final DataDescriptor<HtmlElement> ELEMENT =
       new DataDescriptor<HtmlElement>("HtmlEntry.ELEMENT");
 
   /**
    * The data descriptor representing the hints resulting from auditing the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> HINTS =
       new DataDescriptor<List<AnalysisError>>(
-          "HtmlEntry.HINTS",
-          AnalysisError.NO_ERRORS);
+          "HtmlEntry.HINTS", AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the errors resulting from parsing the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> PARSE_ERRORS =
       new DataDescriptor<List<AnalysisError>>(
-          "HtmlEntry.PARSE_ERRORS",
-          AnalysisError.NO_ERRORS);
+          "HtmlEntry.PARSE_ERRORS", AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the parsed AST structure.
    */
   static final DataDescriptor<ht.HtmlUnit> PARSED_UNIT =
       new DataDescriptor<ht.HtmlUnit>("HtmlEntry.PARSED_UNIT");
 
   /**
    * The data descriptor representing the resolved AST structure.
    */
   static final DataDescriptor<ht.HtmlUnit> RESOLVED_UNIT =
       new DataDescriptor<ht.HtmlUnit>("HtmlEntry.RESOLVED_UNIT");
 
   /**
    * The data descriptor representing the list of referenced libraries.
    */
   static final DataDescriptor<List<Source>> REFERENCED_LIBRARIES =
       new DataDescriptor<List<Source>>(
-          "HtmlEntry.REFERENCED_LIBRARIES",
-          Source.EMPTY_ARRAY);
+          "HtmlEntry.REFERENCED_LIBRARIES", Source.EMPTY_ARRAY);
 
   /**
    * The data descriptor representing the errors resulting from resolving the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> RESOLUTION_ERRORS =
       new DataDescriptor<List<AnalysisError>>(
-          "HtmlEntry.RESOLUTION_ERRORS",
-          AnalysisError.NO_ERRORS);
+          "HtmlEntry.RESOLUTION_ERRORS", AnalysisError.NO_ERRORS);
 
   /**
    * Return all of the errors associated with the HTML file that are currently
    * cached.
    */
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     errors.addAll(super.allErrors);
     errors.addAll(getValue(PARSE_ERRORS));
     errors.addAll(getValue(RESOLUTION_ERRORS));
@@ skipping 15 matching lines @@
     }
     if (getState(RESOLVED_UNIT) == CacheState.VALID) {
       return getValue(RESOLVED_UNIT);
     }
     return null;
   }
 
   @override
   List<DataDescriptor> get descriptors {
     List<DataDescriptor> result = super.descriptors;
-    result.addAll(
-        [
-            HtmlEntry.ELEMENT,
-            HtmlEntry.PARSE_ERRORS,
-            HtmlEntry.PARSED_UNIT,
-            HtmlEntry.RESOLUTION_ERRORS,
-            HtmlEntry.RESOLVED_UNIT,
-            HtmlEntry.HINTS]);
+    result.addAll([
+      HtmlEntry.ELEMENT,
+      HtmlEntry.PARSE_ERRORS,
+      HtmlEntry.PARSED_UNIT,
+      HtmlEntry.RESOLUTION_ERRORS,
+      HtmlEntry.RESOLVED_UNIT,
+      HtmlEntry.HINTS
+    ]);
     return result;
   }
 
   @override
   SourceKind get kind => SourceKind.HTML;
 
   /**
    * Flush any AST structures being maintained by this entry.
    */
   void flushAstStructures() {
@@ skipping 83 matching lines @@
   bool _writeDiffOn(StringBuffer buffer, SourceEntry oldEntry) {
     bool needsSeparator = super._writeDiffOn(buffer, oldEntry);
     if (oldEntry is! HtmlEntry) {
       if (needsSeparator) {
         buffer.write("; ");
       }
       buffer.write("entry type changed; was ");
       buffer.write(oldEntry.runtimeType);
       return true;
     }
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator, "parseErrors",
+        HtmlEntry.PARSE_ERRORS, oldEntry);
     needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "parseErrors",
-        HtmlEntry.PARSE_ERRORS,
-        oldEntry);
+        buffer, needsSeparator, "parsedUnit", HtmlEntry.PARSED_UNIT, oldEntry);
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator, "resolvedUnit",
+        HtmlEntry.RESOLVED_UNIT, oldEntry);
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator,
+        "resolutionErrors", HtmlEntry.RESOLUTION_ERRORS, oldEntry);
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator,
+        "referencedLibraries", HtmlEntry.REFERENCED_LIBRARIES, oldEntry);
     needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "parsedUnit",
-        HtmlEntry.PARSED_UNIT,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "resolvedUnit",
-        HtmlEntry.RESOLVED_UNIT,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "resolutionErrors",
-        HtmlEntry.RESOLUTION_ERRORS,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "referencedLibraries",
-        HtmlEntry.REFERENCED_LIBRARIES,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "element",
-        HtmlEntry.ELEMENT,
-        oldEntry);
+        buffer, needsSeparator, "element", HtmlEntry.ELEMENT, oldEntry);
     return needsSeparator;
   }
 
   @override
   void _writeOn(StringBuffer buffer) {
     buffer.write("Html: ");
     super._writeOn(buffer);
     _writeStateOn(buffer, "parseErrors", PARSE_ERRORS);
     _writeStateOn(buffer, "parsedUnit", PARSED_UNIT);
     _writeStateOn(buffer, "resolvedUnit", RESOLVED_UNIT);
@@ skipping 20 matching lines @@
 
   String _newContents;
 
   int _offset = 0;
 
   int _oldLength = 0;
 
   int _newLength = 0;
 
   IncrementalAnalysisCache(this.librarySource, this.source, this.resolvedUnit,
-      this.oldContents, String newContents, int offset, int oldLength, int newLength)
-      {
+      this.oldContents, String newContents, int offset, int oldLength,
+      int newLength) {
     this._newContents = newContents;
     this._offset = offset;
     this._oldLength = oldLength;
     this._newLength = newLength;
   }
 
   /**
    * Determine if the cache contains source changes that need to be analyzed
    *
    * @return `true` if the cache contains changes to be analyzed, else `false`
@@ skipping 29 matching lines @@
   int get oldLength => _oldLength;
 
   /**
    * Determine if the incremental analysis result can be cached for the next incremental analysis.
    *
    * @param cache the prior incremental analysis cache
    * @param unit the incrementally updated compilation unit
    * @return the cache used for incremental analysis or `null` if incremental analysis results
    *         cannot be cached for the next incremental analysis
    */
-  static IncrementalAnalysisCache cacheResult(IncrementalAnalysisCache cache,
-      CompilationUnit unit) {
+  static IncrementalAnalysisCache cacheResult(
+      IncrementalAnalysisCache cache, CompilationUnit unit) {
     if (cache != null && unit != null) {
-      return new IncrementalAnalysisCache(
-          cache.librarySource,
-          cache.source,
-          unit,
-          cache._newContents,
-          cache._newContents,
-          0,
-          0,
-          0);
+      return new IncrementalAnalysisCache(cache.librarySource, cache.source,
+          unit, cache._newContents, cache._newContents, 0, 0, 0);
     }
     return null;
   }
 
   /**
    * Determine if the cache should be cleared.
    *
    * @param cache the prior cache or `null` if none
    * @param source the source being updated (not `null`)
    * @return the cache used for incremental analysis or `null` if incremental analysis cannot
    *         be performed
    */
-  static IncrementalAnalysisCache clear(IncrementalAnalysisCache cache,
-      Source source) {
+  static IncrementalAnalysisCache clear(
+      IncrementalAnalysisCache cache, Source source) {
     if (cache == null || cache.source == source) {
       return null;
     }
     return cache;
   }
 
   /**
    * Determine if incremental analysis can be performed from the given information.
    *
    * @param cache the prior cache or `null` if none
@@ skipping 12 matching lines @@
       int oldLength, int newLength, SourceEntry sourceEntry) {
     // Determine the cache resolved unit
     Source librarySource = null;
     CompilationUnit unit = null;
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       List<Source> librarySources = dartEntry.librariesContaining;
       if (librarySources.length == 1) {
         librarySource = librarySources[0];
         if (librarySource != null) {
-          unit =
-              dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
+          unit = dartEntry.getValueInLibrary(
+              DartEntry.RESOLVED_UNIT, librarySource);
         }
       }
     }
     // Create a new cache if there is not an existing cache or the source is
     // different or a new resolved compilation unit is available.
     if (cache == null || cache.source != source || unit != null) {
       if (unit == null) {
         return null;
       }
       if (oldContents == null) {
         if (oldLength != 0) {
           return null;
         }
         oldContents =
             "${newContents.substring(0, offset)}${newContents.substring(offset + newLength)}";
       }
-      return new IncrementalAnalysisCache(
-          librarySource,
-          source,
-          unit,
-          oldContents,
-          newContents,
-          offset,
-          oldLength,
-          newLength);
+      return new IncrementalAnalysisCache(librarySource, source, unit,
+          oldContents, newContents, offset, oldLength, newLength);
     }
     // Update the existing cache if the change is contiguous
     if (cache._oldLength == 0 && cache._newLength == 0) {
       cache._offset = offset;
       cache._oldLength = oldLength;
       cache._newLength = newLength;
     } else {
       if (cache._offset > offset || offset > cache._offset + cache._newLength) {
         return null;
       }
       cache._newLength += newLength - oldLength;
     }
     cache._newContents = newContents;
     return cache;
   }
 
   /**
    * Verify that the incrementally parsed and resolved unit in the incremental cache is structurally
    * equivalent to the fully parsed unit.
    *
    * @param cache the prior cache or `null` if none
    * @param source the source of the compilation unit that was parsed (not `null`)
    * @param unit the compilation unit that was just parsed
    * @return the cache used for incremental analysis or `null` if incremental analysis results
    *         cannot be cached for the next incremental analysis
    */
-  static IncrementalAnalysisCache
-      verifyStructure(IncrementalAnalysisCache cache, Source source,
-      CompilationUnit unit) {
+  static IncrementalAnalysisCache verifyStructure(
+      IncrementalAnalysisCache cache, Source source, CompilationUnit unit) {
     if (cache != null && unit != null && cache.source == source) {
       if (!AstComparator.equalNodes(cache.resolvedUnit, unit)) {
         return null;
       }
     }
     return cache;
   }
 }
 
 /**
@@ skipping 63 matching lines @@
     }
     // Only handle small changes
     if (cache.oldLength > 0 || cache.newLength > 30) {
       return;
     }
     // Produce an updated token stream
     CharacterReader reader = new CharSequenceReader(cache.newContents);
     BooleanErrorListener errorListener = new BooleanErrorListener();
     IncrementalScanner scanner =
         new IncrementalScanner(cache.source, reader, errorListener);
-    scanner.rescan(
-        cache.resolvedUnit.beginToken,
-        cache.offset,
-        cache.oldLength,
-        cache.newLength);
+    scanner.rescan(cache.resolvedUnit.beginToken, cache.offset,
+        cache.oldLength, cache.newLength);
     if (errorListener.errorReported) {
       return;
     }
     // Produce an updated AST
     IncrementalParser parser = new IncrementalParser(
-        cache.source,
-        scanner.tokenMap,
-        AnalysisErrorListener.NULL_LISTENER);
-    _updatedUnit = parser.reparse(
-        cache.resolvedUnit,
-        scanner.leftToken,
-        scanner.rightToken,
-        cache.offset,
-        cache.offset + cache.oldLength);
+        cache.source, scanner.tokenMap, AnalysisErrorListener.NULL_LISTENER);
+    _updatedUnit = parser.reparse(cache.resolvedUnit, scanner.leftToken,
+        scanner.rightToken, cache.offset, cache.offset + cache.oldLength);
     // Update the resolution
     TypeProvider typeProvider = this.typeProvider;
     if (_updatedUnit != null && typeProvider != null) {
       CompilationUnitElement element = _updatedUnit.element;
       if (element != null) {
         LibraryElement library = element.library;
         if (library != null) {
           IncrementalResolver resolver = new IncrementalResolver(
-              element,
-              cache.offset,
-              cache.oldLength,
-              cache.newLength);
+              element, cache.offset, cache.oldLength, cache.newLength);
           resolver.resolve(parser.updatedNode);
         }
       }
     }
   }
 }
 
 /**
  * The interface `InternalAnalysisContext` defines additional behavior for an analysis context
  * that is required by internal users of the context.
@@ skipping 110 matching lines @@
    * Normally it should not be necessary for clients to call this function,
    * since it will be automatically invoked in response to a call to
    * [applyChanges] or [setContents].  However, if this analysis context is
    * sharing its content cache with other contexts, then the client must
    * manually update the content cache and call this function for each context.
    *
    * Return `true` if the change was significant to this context (i.e. [source]
    * is either implicitly or explicitly analyzed by this context, and a change
    * actually occurred).
    */
-  bool handleContentsChanged(Source source, String originalContents,
-      String newContents, bool notify);
+  bool handleContentsChanged(
+      Source source, String originalContents, String newContents, bool notify);
 
   /**
    * Given a table mapping the source for the libraries represented by the corresponding elements to
    * the elements representing the libraries, record those mappings.
    *
    * @param elementMap a table mapping the source for the libraries represented by the elements to
    *          the elements representing the libraries
    */
   void recordLibraryElements(Map<Source, LibraryElement> elementMap);
 
@@ skipping 48 matching lines @@
    */
   @deprecated
   void logInformation2(String message, Object exception);
 }
 
 /**
  * An implementation of [Logger] that does nothing.
  */
 class NullLogger implements Logger {
   @override
-  void logError(String message, [CaughtException exception]) {
-  }
+  void logError(String message, [CaughtException exception]) {}
 
   @override
-  void logError2(String message, Object exception) {
-  }
+  void logError2(String message, Object exception) {}
 
   @override
-  void logInformation(String message, [CaughtException exception]) {
-  }
+  void logInformation(String message, [CaughtException exception]) {}
 
   @override
-  void logInformation2(String message, Object exception) {
-  }
+  void logInformation2(String message, Object exception) {}
 }
 
 /**
  * Instances of the class `ObsoleteSourceAnalysisException` represent an analysis attempt that
  * failed because a source was deleted between the time the analysis started and the time the
  * results of the analysis were ready to be recorded.
  */
 class ObsoleteSourceAnalysisException extends AnalysisException {
   /**
    * The source that was removed while it was being analyzed.
    */
   Source _source;
 
   /**
    * Initialize a newly created exception to represent the removal of the given source.
    *
    * @param source the source that was removed while it was being analyzed
    */
-  ObsoleteSourceAnalysisException(Source source)
-      : super(
+  ObsoleteSourceAnalysisException(Source source) : super(
           "The source '${source.fullName}' was removed while it was being analyzed") {
     this._source = source;
   }
 
   /**
    * Return the source that was removed while it was being analyzed.
    *
    * @return the source that was removed
    */
   Source get source => _source;
@@ skipping 145 matching lines @@
           options.analyzeFunctionBodiesPredicate(source);
       _unit = parser.parseCompilationUnit(_tokenStream);
       _unit.lineInfo = lineInfo;
       AnalysisContext analysisContext = context;
       for (Directive directive in _unit.directives) {
         if (directive is PartOfDirective) {
           _containsPartOfDirective = true;
         } else {
           _containsNonPartOfDirective = true;
           if (directive is UriBasedDirective) {
-            Source referencedSource =
-                resolveDirective(analysisContext, source, directive, errorListener);
+            Source referencedSource = resolveDirective(
+                analysisContext, source, directive, errorListener);
             if (referencedSource != null) {
               if (directive is ExportDirective) {
                 _exportedSources.add(referencedSource);
               } else if (directive is ImportDirective) {
                 _importedSources.add(referencedSource);
               } else if (directive is PartDirective) {
                 if (referencedSource != source) {
                   _includedSources.add(referencedSource);
                 }
               } else {
@@ skipping 45 matching lines @@
       String encodedUriContent = Uri.encodeFull(uriContent);
       Source source =
           context.sourceFactory.resolveUri(librarySource, encodedUriContent);
       directive.source = source;
       return source;
     }
     if (code == UriValidationCode.URI_WITH_DART_EXT_SCHEME) {
       return null;
     }
     if (code == UriValidationCode.URI_WITH_INTERPOLATION) {
-      errorListener.onError(
-          new AnalysisError.con2(
-              librarySource,
-              uriLiteral.offset,
-              uriLiteral.length,
-              CompileTimeErrorCode.URI_WITH_INTERPOLATION));
+      errorListener.onError(new AnalysisError.con2(librarySource,
+          uriLiteral.offset, uriLiteral.length,
+          CompileTimeErrorCode.URI_WITH_INTERPOLATION));
       return null;
     }
     if (code == UriValidationCode.INVALID_URI) {
-      errorListener.onError(
-          new AnalysisError.con2(
-              librarySource,
-              uriLiteral.offset,
-              uriLiteral.length,
-              CompileTimeErrorCode.INVALID_URI,
-              [uriContent]));
+      errorListener.onError(new AnalysisError.con2(librarySource,
+          uriLiteral.offset, uriLiteral.length,
+          CompileTimeErrorCode.INVALID_URI, [uriContent]));
       return null;
     }
     throw new RuntimeException(
         message: "Failed to handle validation code: $code");
   }
 }
 
 /**
  * Instances of the class `ParseHtmlTask` parse a specific source as an HTML file.
  */
@@ skipping 105 matching lines @@
 
   @override
   void internalPerform() {
     try {
       ht.AbstractScanner scanner = new ht.StringScanner(source, _content);
       scanner.passThroughElements = <String>[_TAG_SCRIPT];
       ht.Token token = scanner.tokenize();
       _lineInfo = new LineInfo(scanner.lineStarts);
       RecordingErrorListener errorListener = new RecordingErrorListener();
       _unit = new ht.HtmlParser(source, errorListener).parse(token, _lineInfo);
-      _unit.accept(
-          new RecursiveXmlVisitor_ParseHtmlTask_internalPerform(this, errorListener));
+      _unit.accept(new RecursiveXmlVisitor_ParseHtmlTask_internalPerform(
+          this, errorListener));
       _errors = errorListener.getErrorsForSource(source);
       _referencedLibraries = librarySources;
     } catch (exception, stackTrace) {
       throw new AnalysisException(
-          "Exception",
-          new CaughtException(exception, stackTrace));
+          "Exception", new CaughtException(exception, stackTrace));
     }
   }
 
   /**
    * Resolves directives in the given [CompilationUnit].
    */
-  void _resolveScriptDirectives(CompilationUnit script,
-      AnalysisErrorListener errorListener) {
+  void _resolveScriptDirectives(
+      CompilationUnit script, AnalysisErrorListener errorListener) {
     if (script == null) {
       return;
     }
     AnalysisContext analysisContext = context;
     for (Directive directive in script.directives) {
       if (directive is UriBasedDirective) {
         ParseDartTask.resolveDirective(
-            analysisContext,
-            source,
-            directive,
-            errorListener);
+            analysisContext, source, directive, errorListener);
       }
     }
   }
 }
 
 class ParseHtmlTask_getLibrarySources extends ht.RecursiveXmlVisitor<Object> {
   final ParseHtmlTask _task;
 
   List<Source> libraries;
 
   ParseHtmlTask_getLibrarySources(this._task, this.libraries) : super();
 
   @override
   Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
     ht.XmlAttributeNode scriptAttribute = null;
     for (ht.XmlAttributeNode attribute in node.attributes) {
       if (javaStringEqualsIgnoreCase(
-          attribute.name,
-          ParseHtmlTask._ATTRIBUTE_SRC)) {
+          attribute.name, ParseHtmlTask._ATTRIBUTE_SRC)) {
         scriptAttribute = attribute;
       }
     }
     if (scriptAttribute != null) {
       try {
         Uri uri = Uri.parse(scriptAttribute.text);
         String fileName = uri.path;
         Source librarySource =
             _task.context.sourceFactory.resolveUri(_task.source, fileName);
         if (_task.context.exists(librarySource)) {
@@ skipping 265 matching lines @@
     Source source = error.source;
     HashSet<AnalysisError> errorsForSource = _errors[source];
     if (_errors[source] == null) {
       errorsForSource = new HashSet<AnalysisError>();
       _errors[source] = errorsForSource;
     }
     errorsForSource.add(error);
   }
 }
 
-class RecursiveXmlVisitor_ParseHtmlTask_internalPerform extends
-    ht.RecursiveXmlVisitor<Object> {
+class RecursiveXmlVisitor_ParseHtmlTask_internalPerform
+    extends ht.RecursiveXmlVisitor<Object> {
   final ParseHtmlTask ParseHtmlTask_this;
 
   RecordingErrorListener errorListener;
 
-  RecursiveXmlVisitor_ParseHtmlTask_internalPerform(this.ParseHtmlTask_this,
-      this.errorListener)
+  RecursiveXmlVisitor_ParseHtmlTask_internalPerform(
+      this.ParseHtmlTask_this, this.errorListener)
       : super();
 
   @override
   Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
     ParseHtmlTask_this._resolveScriptDirectives(node.script, errorListener);
     return null;
   }
 }
 
-class RecursiveXmlVisitor_ResolveHtmlTask_internalPerform extends
-    ht.RecursiveXmlVisitor<Object> {
+class RecursiveXmlVisitor_ResolveHtmlTask_internalPerform
+    extends ht.RecursiveXmlVisitor<Object> {
   final ResolveHtmlTask ResolveHtmlTask_this;
 
   RecordingErrorListener errorListener;
 
-  RecursiveXmlVisitor_ResolveHtmlTask_internalPerform(this.ResolveHtmlTask_this,
-      this.errorListener)
+  RecursiveXmlVisitor_ResolveHtmlTask_internalPerform(
+      this.ResolveHtmlTask_this, this.errorListener)
       : super();
 
   @override
   Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
     CompilationUnit script = node.script;
     if (script != null) {
-      GenerateDartErrorsTask.validateDirectives(
-          ResolveHtmlTask_this.context,
-          ResolveHtmlTask_this.source,
-          script,
-          errorListener);
+      GenerateDartErrorsTask.validateDirectives(ResolveHtmlTask_this.context,
+          ResolveHtmlTask_this.source, script, errorListener);
     }
     return null;
   }
 }
 
 /**
  * A `ResolutionEraser` removes any resolution information from an AST
  * structure when used to visit that structure.
  */
 class ResolutionEraser extends GeneralizingAstVisitor<Object> {
@@ skipping 88 matching lines @@
   }
 
   @override
   Object visitPrefixExpression(PrefixExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitPrefixExpression(node);
   }
 
   @override
-  Object
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  Object visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
     node.staticElement = null;
     return super.visitRedirectingConstructorInvocation(node);
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitSimpleIdentifier(node);
   }
@@ skipping 206 matching lines @@
   }
 
   /**
    * Write a textual representation of the difference between the old entry and this entry to the
    * given string builder.
    *
    * @param builder the string builder to which the difference is to be written
    * @param oldEntry the entry that was replaced by this entry
    * @return `true` if some difference was written
    */
-  bool _writeDiffOn(StringBuffer buffer, bool needsSeparator,
-      DartEntry oldEntry) {
+  bool _writeDiffOn(
+      StringBuffer buffer, bool needsSeparator, DartEntry oldEntry) {
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator, "resolvedUnit",
+        DartEntry.RESOLVED_UNIT, oldEntry);
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator,
+        "resolutionErrors", DartEntry.RESOLUTION_ERRORS, oldEntry);
+    needsSeparator = _writeStateDiffOn(buffer, needsSeparator,
+        "verificationErrors", DartEntry.VERIFICATION_ERRORS, oldEntry);
     needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "resolvedUnit",
-        DartEntry.RESOLVED_UNIT,
-        oldEntry);
+        buffer, needsSeparator, "hints", DartEntry.HINTS, oldEntry);
     needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "resolutionErrors",
-        DartEntry.RESOLUTION_ERRORS,
-        oldEntry);
-    needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "verificationErrors",
-        DartEntry.VERIFICATION_ERRORS,
-        oldEntry);
-    needsSeparator =
-        _writeStateDiffOn(buffer, needsSeparator, "hints", DartEntry.HINTS, oldEntry);
-    needsSeparator =
-        _writeStateDiffOn(buffer, needsSeparator, "lints", DartEntry.LINTS, oldEntry);
+        buffer, needsSeparator, "lints", DartEntry.LINTS, oldEntry);
     return needsSeparator;
   }
 
   /**
    * Write a textual representation of this state to the given builder. The result will only be
    * used for debugging purposes.
    *
    * @param builder the builder to which the text should be written
    */
   void _writeOn(StringBuffer buffer) {
     if (_librarySource != null) {
       _writeStateOn(buffer, "builtElement", DartEntry.BUILT_ELEMENT);
       _writeStateOn(buffer, "builtUnit", DartEntry.BUILT_UNIT);
       _writeStateOn(buffer, "resolvedUnit", DartEntry.RESOLVED_UNIT);
       _writeStateOn(buffer, "resolutionErrors", DartEntry.RESOLUTION_ERRORS);
       _writeStateOn(
-          buffer,
-          "verificationErrors",
-          DartEntry.VERIFICATION_ERRORS);
+          buffer, "verificationErrors", DartEntry.VERIFICATION_ERRORS);
       _writeStateOn(buffer, "hints", DartEntry.HINTS);
       _writeStateOn(buffer, "lints", DartEntry.LINTS);
       if (_nextState != null) {
         _nextState._writeOn(buffer);
       }
     }
   }
 
   /**
    * Write a textual representation of the difference between the state of the
@@ skipping 16 matching lines @@
       return true;
     }
     return needsSeparator;
   }
 
   /**
    * Write a textual representation of the state of the value described by the
    * given [descriptor] to the given bugger, prefixed by the given [label] to
    * the given [buffer].
    */
-  void _writeStateOn(StringBuffer buffer, String label,
-      DataDescriptor descriptor) {
+  void _writeStateOn(
+      StringBuffer buffer, String label, DataDescriptor descriptor) {
     CachedResult result = resultMap[descriptor];
     buffer.write("; ");
     buffer.write(label);
     buffer.write(" = ");
     buffer.write(result == null ? CacheState.INVALID : result.state);
   }
 }
 
 /**
  * A `ResolvableCompilationUnit` is a compilation unit that is not referenced by
@@ skipping 102 matching lines @@
    */
   LibraryResolver _resolver;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param unitSource the source representing the file whose compilation unit is to be returned
    * @param librarySource the source representing the library to be resolved
    */
-  ResolveDartLibraryTask(InternalAnalysisContext context, this.unitSource,
-      this.librarySource)
+  ResolveDartLibraryTask(
+      InternalAnalysisContext context, this.unitSource, this.librarySource)
       : super(context);
 
   /**
    * Return the library resolver holding information about the libraries that were resolved.
    *
    * @return the library resolver holding information about the libraries that were resolved
    */
   LibraryResolver get libraryResolver => _resolver;
 
   @override
@@ skipping 35 matching lines @@
    */
   CompilationUnit _resolvedUnit;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param libraryElement the element model for the library containing the source
    */
-  ResolveDartUnitTask(InternalAnalysisContext context, this.source,
-      this._libraryElement)
+  ResolveDartUnitTask(
+      InternalAnalysisContext context, this.source, this._libraryElement)
       : super(context);
 
   /**
    * Return the source for the library containing the source that is to be resolved.
    *
    * @return the source for the library containing the source that is to be resolved
    */
   Source get librarySource => _libraryElement.source;
 
   /**
@@ skipping 26 matching lines @@
     }
     //
     // Resolve names in declarations.
     //
     new DeclarationResolver().resolve(unit, _find(_libraryElement, source));
     //
     // Resolve the type names.
     //
     RecordingErrorListener errorListener = new RecordingErrorListener();
     TypeResolverVisitor typeResolverVisitor = new TypeResolverVisitor.con2(
-        _libraryElement,
-        source,
-        typeProvider,
-        errorListener);
+        _libraryElement, source, typeProvider, errorListener);
     unit.accept(typeResolverVisitor);
     //
     // Resolve the rest of the structure
     //
     InheritanceManager inheritanceManager =
         new InheritanceManager(_libraryElement);
-    ResolverVisitor resolverVisitor = new ResolverVisitor.con2(
-        _libraryElement,
-        source,
-        typeProvider,
-        inheritanceManager,
-        errorListener);
+    ResolverVisitor resolverVisitor = new ResolverVisitor.con2(_libraryElement,
+        source, typeProvider, inheritanceManager, errorListener);
     unit.accept(resolverVisitor);
     //
     // Perform additional error checking.
     //
     PerformanceStatistics.errors.makeCurrentWhile(() {
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       ErrorVerifier errorVerifier = new ErrorVerifier(
-          errorReporter,
-          _libraryElement,
-          typeProvider,
-          inheritanceManager);
+          errorReporter, _libraryElement, typeProvider, inheritanceManager);
       unit.accept(errorVerifier);
       // TODO(paulberry): as a temporary workaround for issue 21572,
       // ConstantVerifier is being run right after ConstantValueComputer, so we
       // don't need to run it here.  Once issue 21572 is fixed, re-enable the
       // call to ConstantVerifier.
 //       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _libraryElement, typeProvider);
 //       unit.accept(constantVerifier);
     });
     //
     // Capture the results.
     //
     _resolvedUnit = unit;
   }
 
   /**
    * Search the compilation units that are part of the given library and return the element
    * representing the compilation unit with the given source. Return `null` if there is no
    * such compilation unit.
    *
    * @param libraryElement the element representing the library being searched through
    * @param unitSource the source for the compilation unit whose element is to be returned
    * @return the element representing the compilation unit
    */
-  CompilationUnitElement _find(LibraryElement libraryElement,
-      Source unitSource) {
+  CompilationUnitElement _find(
+      LibraryElement libraryElement, Source unitSource) {
     CompilationUnitElement element = libraryElement.definingCompilationUnit;
     if (element.source == unitSource) {
       return element;
     }
     for (CompilationUnitElement partElement in libraryElement.parts) {
       if (partElement.source == unitSource) {
         return partElement;
       }
     }
     return null;
@@ skipping 72 matching lines @@
   void internalPerform() {
     //
     // Build the standard HTML element.
     //
     HtmlUnitBuilder builder = new HtmlUnitBuilder(context);
     _element = builder.buildHtmlElement(source, _unit);
     RecordingErrorListener errorListener = builder.errorListener;
     //
     // Validate the directives
     //
-    _unit.accept(
-        new RecursiveXmlVisitor_ResolveHtmlTask_internalPerform(this, errorListener));
+    _unit.accept(new RecursiveXmlVisitor_ResolveHtmlTask_internalPerform(
+        this, errorListener));
     //
     // Record all resolution errors.
     //
     _resolutionErrors = errorListener.getErrorsForSource(source);
     //
     // Remember the resolved unit.
     //
     _resolvedUnit = _unit;
   }
 }
@@ skipping 99 matching lines @@
   Token get tokenStream => _tokenStream;
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitScanDartTask(this);
 
   @override
   void internalPerform() {
     PerformanceStatistics.scan.makeCurrentWhile(() {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       try {
-        Scanner scanner =
-            new Scanner(source, new CharSequenceReader(_content), errorListener);
+        Scanner scanner = new Scanner(
+            source, new CharSequenceReader(_content), errorListener);
         scanner.preserveComments = context.analysisOptions.preserveComments;
         _tokenStream = scanner.tokenize();
         _lineInfo = new LineInfo(scanner.lineStarts);
         _errors = errorListener.getErrorsForSource(source);
       } catch (exception, stackTrace) {
         throw new AnalysisException(
-            "Exception",
-            new CaughtException(exception, stackTrace));
+            "Exception", new CaughtException(exception, stackTrace));
       }
     });
   }
 }
 
 /**
  * Instances of the class `SdkAnalysisContext` implement an [AnalysisContext] that only
  * contains sources for a Dart SDK.
  */
 class SdkAnalysisContext extends AnalysisContextImpl {
@@ skipping 41 matching lines @@
    */
   static final DataDescriptor<String> CONTENT =
       new DataDescriptor<String>("SourceEntry.CONTENT");
 
   /**
    * The data descriptor representing the errors resulting from reading the
    * source content.
    */
   static final DataDescriptor<List<AnalysisError>> CONTENT_ERRORS =
       new DataDescriptor<List<AnalysisError>>(
-          "SourceEntry.CONTENT_ERRORS",
-          AnalysisError.NO_ERRORS);
+          "SourceEntry.CONTENT_ERRORS", AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the line information.
    */
   static final DataDescriptor<LineInfo> LINE_INFO =
       new DataDescriptor<LineInfo>("SourceEntry.LINE_INFO");
 
   /**
    * The index of the flag indicating whether the source was explicitly added to
    * the context or whether the source was implicitly added because it was
@@ skipping 296 matching lines @@
       }
       buffer.write("time = ");
       buffer.write(oldModificationTime);
       buffer.write(" -> ");
       buffer.write(modificationTime);
       needsSeparator = true;
     }
     needsSeparator =
         _writeStateDiffOn(buffer, needsSeparator, "content", CONTENT, oldEntry);
     needsSeparator = _writeStateDiffOn(
-        buffer,
-        needsSeparator,
-        "contentErrors",
-        CONTENT_ERRORS,
-        oldEntry);
-    needsSeparator =
-        _writeStateDiffOn(buffer, needsSeparator, "lineInfo", LINE_INFO, oldEntry);
+        buffer, needsSeparator, "contentErrors", CONTENT_ERRORS, oldEntry);
+    needsSeparator = _writeStateDiffOn(
+        buffer, needsSeparator, "lineInfo", LINE_INFO, oldEntry);
     return needsSeparator;
   }
 
   /**
    * Write a textual representation of this entry to the given [buffer]. The
    * result should only be used for debugging purposes.
    */
   void _writeOn(StringBuffer buffer) {
     buffer.write("time = ");
     buffer.write(modificationTime);
@@ skipping 23 matching lines @@
       return true;
     }
     return needsSeparator;
   }
 
   /**
    * Write a textual representation of the state of the value described by the
    * given [descriptor] to the given bugger, prefixed by the given [label] to
    * the given [buffer].
    */
-  void _writeStateOn(StringBuffer buffer, String label,
-      DataDescriptor descriptor) {
+  void _writeStateOn(
+      StringBuffer buffer, String label, DataDescriptor descriptor) {
     CachedResult result = resultMap[descriptor];
     buffer.write("; ");
     buffer.write(label);
     buffer.write(" = ");
     buffer.write(result == null ? CacheState.INVALID : result.state);
   }
 
   /**
    * Increment the count of the number of times that data represented by the
    * given [descriptor] was transitioned from the current state (as found in the
    * given [result] to a valid state.
    */
   static void countTransition(DataDescriptor descriptor, CachedResult result) {
-    Map<CacheState, int> countMap =
-        transitionMap.putIfAbsent(descriptor, () => new HashMap<CacheState, int>());
+    Map<CacheState, int> countMap = transitionMap.putIfAbsent(
+        descriptor, () => new HashMap<CacheState, int>());
     int count = countMap[result.state];
     countMap[result.state] = count == null ? 1 : count + 1;
   }
 }
 
 /**
  * The enumerated type `Priority` defines the priority levels used to return sources in an
  * optimal order. A smaller ordinal value equates to a higher priority.
  */
 class SourcePriority extends Enum<SourcePriority> {
@@ skipping 20 matching lines @@
    */
   static const SourcePriority NORMAL_PART =
       const SourcePriority('NORMAL_PART', 3);
 
   /**
    * Used for an HTML source.
    */
   static const SourcePriority HTML = const SourcePriority('HTML', 4);
 
   static const List<SourcePriority> values = const [
-      PRIORITY_PART,
-      LIBRARY,
-      UNKNOWN,
-      NORMAL_PART,
-      HTML];
+    PRIORITY_PART,
+    LIBRARY,
+    UNKNOWN,
+    NORMAL_PART,
+    HTML
+  ];
 
   const SourcePriority(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * [SourcesChangedEvent] indicates which sources have been added, removed,
  * or whose contents have changed.
  */
 class SourcesChangedEvent {
 
@@ skipping 334 matching lines @@
    * exception, the future will fail with that exception.
    *
    * If the [computeValue] still returns null after there is no further
    * analysis to be done for [source], then the future will be completed with
    * the error AnalysisNotScheduledError.
    *
    * Since [computeValue] will be called while the state of analysis is being
    * updated, it should be free of side effects so that it doesn't cause
    * reentrant changes to the analysis state.
    */
-  CancelableFuture<T> computeAsync(Source source, T
-      computeValue(SourceEntry sourceEntry)) {
+  CancelableFuture<T> computeAsync(
+      Source source, T computeValue(SourceEntry sourceEntry)) {
     if (_context.isDisposed) {
       // No further analysis is expected, so return a future that completes
       // immediately with AnalysisNotScheduledError.
       return new CancelableFuture.error(new AnalysisNotScheduledError());
     }
     SourceEntry sourceEntry = _context.getReadableSourceEntryOrNull(source);
     if (sourceEntry == null) {
       return new CancelableFuture.error(new AnalysisNotScheduledError());
     }
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, source, computeValue);
     if (!pendingFuture.evaluate(sourceEntry)) {
-      _context._pendingFutureSources.putIfAbsent(
-          source,
-          () => <PendingFuture>[]).add(pendingFuture);
+      _context._pendingFutureSources
+          .putIfAbsent(source, () => <PendingFuture>[])
+          .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }
 
 class _ElementByIdFinder extends GeneralizingElementVisitor {
   final int _id;
   Element result;
 
   _ElementByIdFinder(this._id);
 
   @override
   visitElement(Element element) {
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
-class _ElementByIdFinderException {
-}
+class _ElementByIdFinderException {}