Unroll 'synchronized {}' in java2dart.

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 'java_core.dart';
@@ skipping 3671 matching lines @@
   void addSourceInfo(Source source, SourceEntry info) {
     // This implementation assumes that the access to the cache does not need to be synchronized
     // because no other object can have access to this context while this method is being invoked.
     _cache.put(source, info);
   }
 
   void applyChanges(ChangeSet changeSet) {
     if (changeSet.isEmpty) {
       return;
     }
-    {
-      _recentTasks.clear();
-      //
-      // First, compute the list of sources that have been removed.
-      //
-      List<Source> removedSources = new List<Source>.from(changeSet.removed3);
-      for (SourceContainer container in changeSet.removedContainers) {
-        addSourcesInContainer(removedSources, container);
+    _recentTasks.clear();
+    //
+    // First, compute the list of sources that have been removed.
+    //
+    List<Source> removedSources = new List<Source>.from(changeSet.removed3);
+    for (SourceContainer container in changeSet.removedContainers) {
+      addSourcesInContainer(removedSources, container);
+    }
+    //
+    // Then determine which cached results are no longer valid.
+    //
+    bool addedDartSource = false;
+    for (Source source in changeSet.added3) {
+      if (sourceAvailable(source)) {
+        addedDartSource = true;
       }
-      //
-      // Then determine which cached results are no longer valid.
-      //
-      bool addedDartSource = false;
-      for (Source source in changeSet.added3) {
-        if (sourceAvailable(source)) {
-          addedDartSource = true;
-        }
-      }
-      for (Source source in changeSet.changed3) {
-        sourceChanged(source);
-      }
-      for (Source source in removedSources) {
-        sourceRemoved(source);
-      }
-      if (addedDartSource) {
-        // TODO(brianwilkerson) This is hugely inefficient, but we need to re-analyze any libraries
-        // that might have been referencing the not-yet-existing source that was just added. Longer
-        // term we need to keep track of which libraries are referencing non-existing sources and
-        // only re-analyze those libraries.
-        logInformation("Added Dart sources, invalidating all resolution information");
-        for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
-          Source source = mapEntry.getKey();
-          SourceEntry sourceEntry = mapEntry.getValue();
-          if (!source.isInSystemLibrary && sourceEntry is DartEntry) {
-            DartEntry dartEntry = sourceEntry;
-            DartEntryImpl dartCopy = dartEntry.writableCopy;
-            removeFromParts(source, dartEntry);
-            dartCopy.invalidateAllResolutionInformation();
-            mapEntry.setValue(dartCopy);
-            SourcePriority priority = SourcePriority.UNKNOWN;
-            SourceKind kind = dartCopy.kind;
-            if (identical(kind, SourceKind.LIBRARY)) {
-              priority = SourcePriority.LIBRARY;
-            } else if (identical(kind, SourceKind.PART)) {
-              priority = SourcePriority.NORMAL_PART;
-            }
-            _workManager.add(source, priority);
+    }
+    for (Source source in changeSet.changed3) {
+      sourceChanged(source);
+    }
+    for (Source source in removedSources) {
+      sourceRemoved(source);
+    }
+    if (addedDartSource) {
+      // TODO(brianwilkerson) This is hugely inefficient, but we need to re-analyze any libraries
+      // that might have been referencing the not-yet-existing source that was just added. Longer
+      // term we need to keep track of which libraries are referencing non-existing sources and
+      // only re-analyze those libraries.
+      logInformation("Added Dart sources, invalidating all resolution information");
+      for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
+        Source source = mapEntry.getKey();
+        SourceEntry sourceEntry = mapEntry.getValue();
+        if (!source.isInSystemLibrary && sourceEntry is DartEntry) {
+          DartEntry dartEntry = sourceEntry;
+          DartEntryImpl dartCopy = dartEntry.writableCopy;
+          removeFromParts(source, dartEntry);
+          dartCopy.invalidateAllResolutionInformation();
+          mapEntry.setValue(dartCopy);
+          SourcePriority priority = SourcePriority.UNKNOWN;
+          SourceKind kind = dartCopy.kind;
+          if (identical(kind, SourceKind.LIBRARY)) {
+            priority = SourcePriority.LIBRARY;
+          } else if (identical(kind, SourceKind.PART)) {
+            priority = SourcePriority.NORMAL_PART;
           }
+          _workManager.add(source, priority);
         }
       }
     }
   }
 
   String computeDocumentationComment(Element element) {
     if (element == null) {
       return null;
     }
     Source source = element.source;
@@ skipping 121 matching lines @@
     ht.HtmlUnit unit = htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
     if (unit == null) {
       AnalysisException cause = htmlEntry.exception;
       throw new AnalysisException.con2("Internal error: computeResolvableAngularComponentHtmlUnit could not resolve ${source.fullName}", cause);
     }
     // If the unit is ever modified by resolution then we will need to create a copy of it.
     return new ResolvableHtmlUnit(htmlEntry.modificationTime, unit);
   }
 
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) {
-    {
-      DartEntry dartEntry = getReadableDartEntry(source);
-      if (dartEntry == null) {
-        throw new AnalysisException.con1("computeResolvableCompilationUnit for non-Dart: ${source.fullName}");
-      }
-      dartEntry = cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
-      DartEntryImpl dartCopy = dartEntry.writableCopy;
-      CompilationUnit unit = dartCopy.resolvableCompilationUnit;
-      if (unit == null) {
-        throw new AnalysisException.con2("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", dartEntry.exception);
-      }
-      _cache.put(source, dartCopy);
-      return new ResolvableCompilationUnit(dartCopy.modificationTime, unit);
+    DartEntry dartEntry = getReadableDartEntry(source);
+    if (dartEntry == null) {
+      throw new AnalysisException.con1("computeResolvableCompilationUnit for non-Dart: ${source.fullName}");
     }
+    dartEntry = cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
+    DartEntryImpl dartCopy = dartEntry.writableCopy;
+    CompilationUnit unit = dartCopy.resolvableCompilationUnit;
+    if (unit == null) {
+      throw new AnalysisException.con2("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", dartEntry.exception);
+    }
+    _cache.put(source, dartCopy);
+    return new ResolvableCompilationUnit(dartCopy.modificationTime, unit);
   }
 
   ResolvableHtmlUnit computeResolvableHtmlUnit(Source source) {
     HtmlEntry htmlEntry = getReadableHtmlEntry(source);
     if (htmlEntry == null) {
       throw new AnalysisException.con1("computeResolvableHtmlUnit invoked for non-HTML file: ${source.fullName}");
     }
     htmlEntry = cacheHtmlParseData(source, htmlEntry, HtmlEntry.PARSED_UNIT);
     ht.HtmlUnit unit = htmlEntry.getValue(HtmlEntry.PARSED_UNIT);
     if (unit == null) {
       throw new AnalysisException.con1("Internal error: computeResolvableHtmlUnit could not parse ${source.fullName}");
     }
     // If the unit is ever modified by resolution then we will need to create a copy of it.
     return new ResolvableHtmlUnit(htmlEntry.modificationTime, unit);
   }
 
   bool exists(Source source) {
     if (source == null) {
       return false;
     }
-    {
-      if (_contentCache.getContents(source) != null) {
-        return true;
-      }
+    if (_contentCache.getContents(source) != null) {
+      return true;
     }
     return source.exists();
   }
 
   AnalysisContext extractContext(SourceContainer container) => extractContextInto(container, AnalysisEngine.instance.createAnalysisContext() as InternalAnalysisContext);
 
   InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext) {
     List<Source> sourcesToRemove = new List<Source>();
-    {
-      // Move sources in the specified directory to the new context
-      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        Source source = entry.getKey();
-        if (container.contains(source)) {
-          sourcesToRemove.add(source);
-          newContext.addSourceInfo(source, entry.getValue().writableCopy);
-        }
+    // Move sources in the specified directory to the new context
+    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
+      Source source = entry.getKey();
+      if (container.contains(source)) {
+        sourcesToRemove.add(source);
+        newContext.addSourceInfo(source, entry.getValue().writableCopy);
       }
     }
     return newContext;
   }
 
   AnalysisOptions get analysisOptions => _options;
 
   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;
   }
 
   TimestampedData<String> getContents(Source source) {
-    {
-      String contents = _contentCache.getContents(source);
-      if (contents != null) {
-        return new TimestampedData<String>(_contentCache.getModificationStamp(source), contents);
-      }
+    String contents = _contentCache.getContents(source);
+    if (contents != null) {
+      return new TimestampedData<String>(_contentCache.getModificationStamp(source), contents);
     }
     return source.contents;
   }
 
   void getContentsToReceiver(Source source, Source_ContentReceiver receiver) {
-    {
-      String contents = _contentCache.getContents(source);
-      if (contents != null) {
-        receiver.accept(contents, _contentCache.getModificationStamp(source));
-        return;
-      }
+    String contents = _contentCache.getContents(source);
+    if (contents != null) {
+      receiver.accept(contents, _contentCache.getModificationStamp(source));
+      return;
     }
     source.getContentsToReceiver(receiver);
   }
 
   Element getElement(ElementLocation location) {
     // TODO(brianwilkerson) This should not be a "get" method.
     try {
       List<String> components = (location as ElementLocationImpl).components;
       Source librarySource = computeSourceFromEncoding(components[0]);
       ElementImpl element = computeLibraryElement(librarySource) as ElementImpl;
@@ skipping 27 matching lines @@
       return sourceEntry.getValue(HtmlEntry.ELEMENT);
     }
     return null;
   }
 
   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.LIBRARY) {
-        } else if (sourceKind == SourceKind.PART) {
-          List<Source> librarySources = getLibrariesContaining(source);
-          for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-            SourceEntry sourceEntry = entry.getValue();
-            if (identical(sourceEntry.kind, SourceKind.HTML)) {
-              List<Source> referencedLibraries = (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
-              if (containsAny(referencedLibraries, librarySources)) {
-                htmlSources.add(entry.getKey());
-              }
+    List<Source> htmlSources = new List<Source>();
+    while (true) {
+      if (sourceKind == SourceKind.LIBRARY) {
+      } else if (sourceKind == SourceKind.PART) {
+        List<Source> librarySources = getLibrariesContaining(source);
+        for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
+          SourceEntry sourceEntry = entry.getValue();
+          if (identical(sourceEntry.kind, SourceKind.HTML)) {
+            List<Source> referencedLibraries = (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
+            if (containsAny(referencedLibraries, librarySources)) {
+              htmlSources.add(entry.getKey());
             }
           }
         }
-        break;
       }
-      if (htmlSources.isEmpty) {
-        return Source.EMPTY_ARRAY;
-      }
-      return new List.from(htmlSources);
+      break;
     }
+    if (htmlSources.isEmpty) {
+      return Source.EMPTY_ARRAY;
+    }
+    return new List.from(htmlSources);
   }
 
   List<Source> get htmlSources => getSources(SourceKind.HTML);
 
   SourceKind getKindOf(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     }
     return sourceEntry.kind;
   }
 
   List<Source> get launchableClientLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that do not reference dart:html,
     // either directly or indirectly.
     List<Source> sources = new List<Source>();
-    {
-      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        Source source = entry.getKey();
-        SourceEntry sourceEntry = entry.getValue();
-        if (identical(sourceEntry.kind, SourceKind.LIBRARY) && !source.isInSystemLibrary) {
-          //          DartEntry dartEntry = (DartEntry) sourceEntry;
-          //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && dartEntry.getValue(DartEntry.IS_CLIENT)) {
-          sources.add(source);
-        }
+    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
+      Source source = entry.getKey();
+      SourceEntry sourceEntry = entry.getValue();
+      if (identical(sourceEntry.kind, SourceKind.LIBRARY) && !source.isInSystemLibrary) {
+        //          DartEntry dartEntry = (DartEntry) sourceEntry;
+        //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && dartEntry.getValue(DartEntry.IS_CLIENT)) {
+        sources.add(source);
       }
     }
     return new List.from(sources);
   }
 
   List<Source> get launchableServerLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that reference dart:html, either
     // directly or indirectly.
     List<Source> sources = new List<Source>();
-    {
-      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        Source source = entry.getKey();
-        SourceEntry sourceEntry = entry.getValue();
-        if (identical(sourceEntry.kind, SourceKind.LIBRARY) && !source.isInSystemLibrary) {
-          //          DartEntry dartEntry = (DartEntry) sourceEntry;
-          //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && !dartEntry.getValue(DartEntry.IS_CLIENT)) {
-          sources.add(source);
-        }
+    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
+      Source source = entry.getKey();
+      SourceEntry sourceEntry = entry.getValue();
+      if (identical(sourceEntry.kind, SourceKind.LIBRARY) && !source.isInSystemLibrary) {
+        //          DartEntry dartEntry = (DartEntry) sourceEntry;
+        //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && !dartEntry.getValue(DartEntry.IS_CLIENT)) {
+        sources.add(source);
       }
     }
     return new List.from(sources);
   }
 
   List<Source> getLibrariesContaining(Source source) {
     DartEntry dartEntry = getReadableDartEntry(source);
     if (dartEntry == null) {
       return Source.EMPTY_ARRAY;
     }
     return dartEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
   }
 
   List<Source> getLibrariesDependingOn(Source librarySource) {
-    {
-      List<Source> dependentLibraries = new List<Source>();
-      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        SourceEntry sourceEntry = entry.getValue();
-        if (identical(sourceEntry.kind, SourceKind.LIBRARY)) {
-          if (contains((sourceEntry as DartEntry).getValue(DartEntry.EXPORTED_LIBRARIES), librarySource)) {
-            dependentLibraries.add(entry.getKey());
-          }
-          if (contains((sourceEntry as DartEntry).getValue(DartEntry.IMPORTED_LIBRARIES), librarySource)) {
-            dependentLibraries.add(entry.getKey());
-          }
+    List<Source> dependentLibraries = new List<Source>();
+    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
+      SourceEntry sourceEntry = entry.getValue();
+      if (identical(sourceEntry.kind, SourceKind.LIBRARY)) {
+        if (contains((sourceEntry as DartEntry).getValue(DartEntry.EXPORTED_LIBRARIES), librarySource)) {
+          dependentLibraries.add(entry.getKey());
+        }
+        if (contains((sourceEntry as DartEntry).getValue(DartEntry.IMPORTED_LIBRARIES), librarySource)) {
+          dependentLibraries.add(entry.getKey());
         }
       }
-      if (dependentLibraries.isEmpty) {
-        return Source.EMPTY_ARRAY;
-      }
-      return new List.from(dependentLibraries);
     }
+    if (dependentLibraries.isEmpty) {
+      return Source.EMPTY_ARRAY;
+    }
+    return new List.from(dependentLibraries);
   }
 
   LibraryElement getLibraryElement(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValue(DartEntry.ELEMENT);
     }
     return null;
   }
 
   List<Source> get librarySources => getSources(SourceKind.LIBRARY);
 
   LineInfo getLineInfo(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry != null) {
       return sourceEntry.getValue(SourceEntry.LINE_INFO);
     }
     return null;
   }
 
   int getModificationStamp(Source source) {
-    {
-      int stamp = _contentCache.getModificationStamp(source);
-      if (stamp != null) {
-        return stamp;
-      }
+    int stamp = _contentCache.getModificationStamp(source);
+    if (stamp != null) {
+      return stamp;
     }
     return source.modificationStamp;
   }
 
   Namespace getPublicNamespace(LibraryElement library) {
     // TODO(brianwilkerson) Rename this to not start with 'get'. Note that this is not part of the
     // API of the interface.
     Source source = library.definingCompilationUnit.source;
     DartEntry dartEntry = getReadableDartEntry(source);
     if (dartEntry == null) {
       return null;
     }
     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.createPublicNamespace(library);
-      {
-        dartEntry = getReadableDartEntry(source);
-        if (dartEntry == null) {
-          AnalysisEngine.instance.logger.logError2("Could not compute the public namespace for ${library.source.fullName}", new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}"));
-          return null;
-        }
-        if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
-          DartEntryImpl dartCopy = getReadableDartEntry(source).writableCopy;
-          dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
-          _cache.put(source, dartCopy);
-        }
+      dartEntry = getReadableDartEntry(source);
+      if (dartEntry == null) {
+        AnalysisEngine.instance.logger.logError2("Could not compute the public namespace for ${library.source.fullName}", new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}"));
+        return null;
+      }
+      if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
+        DartEntryImpl dartCopy = getReadableDartEntry(source).writableCopy;
+        dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
+        _cache.put(source, dartCopy);
       }
     }
     return namespace;
   }
 
   Namespace getPublicNamespace2(Source source) {
     // TODO(brianwilkerson) Rename this to not start with 'get'. Note that this is not part of the
     // API of the interface.
     DartEntry dartEntry = getReadableDartEntry(source);
     if (dartEntry == null) {
       return null;
     }
     Namespace namespace = dartEntry.getValue(DartEntry.PUBLIC_NAMESPACE);
     if (namespace == null) {
       LibraryElement library = computeLibraryElement(source);
       if (library == null) {
         return null;
       }
       NamespaceBuilder builder = new NamespaceBuilder();
       namespace = builder.createPublicNamespace(library);
-      {
-        dartEntry = getReadableDartEntry(source);
-        if (dartEntry == null) {
-          throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
-        }
-        if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
-          DartEntryImpl dartCopy = getReadableDartEntry(source).writableCopy;
-          dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
-          _cache.put(source, dartCopy);
-        }
+      dartEntry = getReadableDartEntry(source);
+      if (dartEntry == null) {
+        throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+      }
+      if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
+        DartEntryImpl dartCopy = getReadableDartEntry(source).writableCopy;
+        dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
+        _cache.put(source, dartCopy);
       }
     }
     return namespace;
   }
 
   List<Source> get refactoringUnsafeSources {
     List<Source> sources = new List<Source>();
-    {
-      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        SourceEntry sourceEntry = entry.getValue();
-        if (sourceEntry is DartEntry) {
-          if (!sourceEntry.isRefactoringSafe) {
-            sources.add(entry.getKey());
-          }
+    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
+      SourceEntry sourceEntry = entry.getValue();
+      if (sourceEntry is DartEntry) {
+        if (!sourceEntry.isRefactoringSafe) {
+          sources.add(entry.getKey());
         }
       }
     }
     return new List.from(sources);
   }
 
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
@@ skipping 21 matching lines @@
 
   /**
    * Return a list of the sources that would be processed by [performAnalysisTask]. This
    * method duplicates, and must therefore be kept in sync with, [getNextAnalysisTask].
    * This method is intended to be used for testing purposes only.
    *
    * @return a list of the sources that would be processed by [performAnalysisTask]
    */
   List<Source> get sourcesNeedingProcessing {
     Set<Source> sources = new Set<Source>();
-    {
-      bool hintsEnabled = _options.hint;
-      //
-      // Look for priority sources that need to be analyzed.
-      //
-      for (Source source in _priorityOrder) {
-        getSourcesNeedingProcessing2(source, _cache.get(source), true, hintsEnabled, sources);
-      }
-      //
-      // Look for non-priority sources that need to be analyzed.
-      //
-      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        getSourcesNeedingProcessing2(entry.getKey(), entry.getValue(), false, hintsEnabled, sources);
-      }
+    bool hintsEnabled = _options.hint;
+    //
+    // Look for priority sources that need to be analyzed.
+    //
+    for (Source source in _priorityOrder) {
+      getSourcesNeedingProcessing2(source, _cache.get(source), true, hintsEnabled, sources);
+    }
+    //
+    // Look for non-priority sources that need to be analyzed.
+    //
+    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
+      getSourcesNeedingProcessing2(entry.getKey(), entry.getValue(), false, hintsEnabled, sources);
     }
     return new List<Source>.from(sources);
   }
 
   AnalysisContentStatistics get statistics {
     AnalysisContentStatisticsImpl statistics = new AnalysisContentStatisticsImpl();
-    {
-      for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
-        statistics.addSource(mapEntry.getKey());
-        SourceEntry entry = mapEntry.getValue();
-        if (entry is DartEntry) {
-          Source source = mapEntry.getKey();
-          DartEntry dartEntry = entry;
-          SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
-          // get library independent values
-          statistics.putCacheItem2(dartEntry, SourceEntry.LINE_INFO);
-          statistics.putCacheItem2(dartEntry, DartEntry.PARSE_ERRORS);
-          statistics.putCacheItem2(dartEntry, DartEntry.PARSED_UNIT);
-          statistics.putCacheItem2(dartEntry, DartEntry.SOURCE_KIND);
-          if (identical(kind, SourceKind.LIBRARY)) {
-            statistics.putCacheItem2(dartEntry, DartEntry.ELEMENT);
-            statistics.putCacheItem2(dartEntry, DartEntry.EXPORTED_LIBRARIES);
-            statistics.putCacheItem2(dartEntry, DartEntry.IMPORTED_LIBRARIES);
-            statistics.putCacheItem2(dartEntry, DartEntry.INCLUDED_PARTS);
-            statistics.putCacheItem2(dartEntry, DartEntry.IS_CLIENT);
-            statistics.putCacheItem2(dartEntry, DartEntry.IS_LAUNCHABLE);
-          }
-          // get library-specific values
-          List<Source> librarySources = getLibrariesContaining(source);
-          for (Source librarySource in librarySources) {
-            statistics.putCacheItem(dartEntry, librarySource, DartEntry.HINTS);
-            statistics.putCacheItem(dartEntry, librarySource, DartEntry.RESOLUTION_ERRORS);
-            statistics.putCacheItem(dartEntry, librarySource, DartEntry.RESOLVED_UNIT);
-            statistics.putCacheItem(dartEntry, librarySource, DartEntry.VERIFICATION_ERRORS);
-          }
-        } else if (entry is HtmlEntry) {
-          HtmlEntry htmlEntry = entry;
-          statistics.putCacheItem2(htmlEntry, SourceEntry.LINE_INFO);
-          statistics.putCacheItem2(htmlEntry, HtmlEntry.PARSE_ERRORS);
-          statistics.putCacheItem2(htmlEntry, HtmlEntry.PARSED_UNIT);
-          statistics.putCacheItem2(htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
-          statistics.putCacheItem2(htmlEntry, HtmlEntry.RESOLVED_UNIT);
-          statistics.putCacheItem2(htmlEntry, HtmlEntry.HINTS);
+    for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
+      statistics.addSource(mapEntry.getKey());
+      SourceEntry entry = mapEntry.getValue();
+      if (entry is DartEntry) {
+        Source source = mapEntry.getKey();
+        DartEntry dartEntry = entry;
+        SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
+        // get library independent values
+        statistics.putCacheItem2(dartEntry, SourceEntry.LINE_INFO);
+        statistics.putCacheItem2(dartEntry, DartEntry.PARSE_ERRORS);
+        statistics.putCacheItem2(dartEntry, DartEntry.PARSED_UNIT);
+        statistics.putCacheItem2(dartEntry, DartEntry.SOURCE_KIND);
+        if (identical(kind, SourceKind.LIBRARY)) {
+          statistics.putCacheItem2(dartEntry, DartEntry.ELEMENT);
+          statistics.putCacheItem2(dartEntry, DartEntry.EXPORTED_LIBRARIES);
+          statistics.putCacheItem2(dartEntry, DartEntry.IMPORTED_LIBRARIES);
+          statistics.putCacheItem2(dartEntry, DartEntry.INCLUDED_PARTS);
+          statistics.putCacheItem2(dartEntry, DartEntry.IS_CLIENT);
+          statistics.putCacheItem2(dartEntry, DartEntry.IS_LAUNCHABLE);
         }
+        // get library-specific values
+        List<Source> librarySources = getLibrariesContaining(source);
+        for (Source librarySource in librarySources) {
+          statistics.putCacheItem(dartEntry, librarySource, DartEntry.HINTS);
+          statistics.putCacheItem(dartEntry, librarySource, DartEntry.RESOLUTION_ERRORS);
+          statistics.putCacheItem(dartEntry, librarySource, DartEntry.RESOLVED_UNIT);
+          statistics.putCacheItem(dartEntry, librarySource, DartEntry.VERIFICATION_ERRORS);
+        }
+      } else if (entry is HtmlEntry) {
+        HtmlEntry htmlEntry = entry;
+        statistics.putCacheItem2(htmlEntry, SourceEntry.LINE_INFO);
+        statistics.putCacheItem2(htmlEntry, HtmlEntry.PARSE_ERRORS);
+        statistics.putCacheItem2(htmlEntry, HtmlEntry.PARSED_UNIT);
+        statistics.putCacheItem2(htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
+        statistics.putCacheItem2(htmlEntry, HtmlEntry.RESOLVED_UNIT);
+        statistics.putCacheItem2(htmlEntry, HtmlEntry.HINTS);
       }
     }
     return statistics;
   }
 
   TypeProvider get typeProvider {
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     return new TypeProviderImpl(computeLibraryElement(coreSource));
   }
 
@@ skipping 47 matching lines @@
     return false;
   }
 
   void mergeContext(AnalysisContext context) {
     if (context is InstrumentedAnalysisContextImpl) {
       context = (context as InstrumentedAnalysisContextImpl).basis;
     }
     if (context is! AnalysisContextImpl) {
       return;
     }
-    {
-      // TODO(brianwilkerson) This does not lock against the other context's cacheLock.
-      for (MapEntry<Source, SourceEntry> entry in (context as AnalysisContextImpl)._cache.entrySet()) {
-        Source newSource = entry.getKey();
-        SourceEntry existingEntry = getReadableSourceEntry(newSource);
-        if (existingEntry == null) {
-          // TODO(brianwilkerson) Decide whether we really need to copy the info.
-          _cache.put(newSource, entry.getValue().writableCopy);
-        } else {
-        }
+    // TODO(brianwilkerson) This does not lock against the other context's cacheLock.
+    for (MapEntry<Source, SourceEntry> entry in (context as AnalysisContextImpl)._cache.entrySet()) {
+      Source newSource = entry.getKey();
+      SourceEntry existingEntry = getReadableSourceEntry(newSource);
+      if (existingEntry == null) {
+        // TODO(brianwilkerson) Decide whether we really need to copy the info.
+        _cache.put(newSource, entry.getValue().writableCopy);
+      } else {
       }
     }
   }
 
   CompilationUnit parseCompilationUnit(Source source) => getDartParseData2(source, DartEntry.PARSED_UNIT, null);
 
   ht.HtmlUnit parseHtmlUnit(Source source) => getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
 
   AnalysisResult performAnalysisTask() {
     int getStart = JavaSystem.currentTimeMillis();
@@ skipping 19 matching lines @@
     } on AnalysisException catch (exception) {
       if (exception.cause is! JavaIOException) {
         AnalysisEngine.instance.logger.logError2("Internal error while performing the task: ${task}", exception);
       }
     }
     int performEnd = JavaSystem.currentTimeMillis();
     return new AnalysisResult(getChangeNotices(false), getEnd - getStart, task.runtimeType.toString(), performEnd - performStart);
   }
 
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
-    {
-      Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
-      for (MapEntry<Source, LibraryElement> entry in getMapEntrySet(elementMap)) {
-        Source librarySource = entry.getKey();
-        LibraryElement library = entry.getValue();
-        //
-        // Cache the element in the library's info.
-        //
-        DartEntry dartEntry = getReadableDartEntry(librarySource);
-        if (dartEntry != null) {
-          DartEntryImpl dartCopy = dartEntry.writableCopy;
-          recordElementData(dartEntry, dartCopy, library, library.source, htmlSource);
-          _cache.put(librarySource, dartCopy);
-        }
+    Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
+    for (MapEntry<Source, LibraryElement> entry in getMapEntrySet(elementMap)) {
+      Source librarySource = entry.getKey();
+      LibraryElement library = entry.getValue();
+      //
+      // Cache the element in the library's info.
+      //
+      DartEntry dartEntry = getReadableDartEntry(librarySource);
+      if (dartEntry != null) {
+        DartEntryImpl dartCopy = dartEntry.writableCopy;
+        recordElementData(dartEntry, dartCopy, library, library.source, htmlSource);
+        _cache.put(librarySource, dartCopy);
       }
     }
   }
 
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return resolveCompilationUnit2(unitSource, library.source);
   }
 
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) => getDartResolutionData2(unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
 
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     computeHtmlElement(htmlSource);
     return parseHtmlUnit(htmlSource);
   }
 
   void set analysisOptions(AnalysisOptions options) {
-    {
-      bool needsRecompute = this._options.analyzeFunctionBodies != options.analyzeFunctionBodies || 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.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 = newPriorityOrder;
-        }
+    bool needsRecompute = this._options.analyzeFunctionBodies != options.analyzeFunctionBodies || 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.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 = newPriorityOrder;
       }
-      this._options.analyzeFunctionBodies = options.analyzeFunctionBodies;
-      this._options.dart2jsHint = options.dart2jsHint;
-      this._options.hint = options.hint;
-      this._options.incremental = options.incremental;
-      this._options.preserveComments = options.preserveComments;
-      if (needsRecompute) {
-        invalidateAllResolutionInformation();
-      }
+    }
+    this._options.analyzeFunctionBodies = options.analyzeFunctionBodies;
+    this._options.dart2jsHint = options.dart2jsHint;
+    this._options.hint = options.hint;
+    this._options.incremental = options.incremental;
+    this._options.preserveComments = options.preserveComments;
+    if (needsRecompute) {
+      invalidateAllResolutionInformation();
     }
   }
 
   void set analysisPriorityOrder(List<Source> sources) {
-    {
-      if (sources == null || sources.isEmpty) {
+    if (sources == null || sources.isEmpty) {
+      _priorityOrder = Source.EMPTY_ARRAY;
+    } else {
+      while (sources.remove(null)) {
+      }
+      if (sources.isEmpty) {
         _priorityOrder = Source.EMPTY_ARRAY;
-      } else {
-        while (sources.remove(null)) {
-        }
-        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);
-        _priorityOrder = new List<Source>(count);
-        for (int i = 0; i < count; i++) {
-          _priorityOrder[i] = sources[i];
-        }
+      }
+      //
+      // 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);
+      _priorityOrder = new List<Source>(count);
+      for (int i = 0; i < count; i++) {
+        _priorityOrder[i] = sources[i];
       }
     }
   }
 
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
-    {
-      _recentTasks.clear();
-      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));
-          }
-          sourceChanged(source);
-          SourceEntry sourceEntry = _cache.get(source);
-          if (sourceEntry != null) {
-            SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
-            sourceCopy.modificationTime = _contentCache.getModificationStamp(source);
-            sourceCopy.setValue(SourceEntry.CONTENT, contents);
-            _cache.put(source, sourceCopy);
-          }
+    _recentTasks.clear();
+    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));
         }
-      } else if (originalContents != null) {
-        _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         sourceChanged(source);
+        SourceEntry sourceEntry = _cache.get(source);
+        if (sourceEntry != null) {
+          SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
+          sourceCopy.modificationTime = _contentCache.getModificationStamp(source);
+          sourceCopy.setValue(SourceEntry.CONTENT, contents);
+          _cache.put(source, sourceCopy);
+        }
       }
+    } else if (originalContents != null) {
+      _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
+      sourceChanged(source);
     }
   }
 
   void setContents(Source source, String contents) {
-    {
-      _recentTasks.clear();
-      String originalContents = _contentCache.setContents(source, contents);
-      if (contents != null) {
-        if (contents != originalContents) {
-          _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
-          sourceChanged(source);
-          SourceEntry sourceEntry = _cache.get(source);
-          if (sourceEntry != null) {
-            SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
-            sourceCopy.modificationTime = _contentCache.getModificationStamp(source);
-            sourceCopy.setValue(SourceEntry.CONTENT, contents);
-            _cache.put(source, sourceCopy);
-          }
-        }
-      } else if (originalContents != null) {
+    _recentTasks.clear();
+    String originalContents = _contentCache.setContents(source, contents);
+    if (contents != null) {
+      if (contents != originalContents) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         sourceChanged(source);
+        SourceEntry sourceEntry = _cache.get(source);
+        if (sourceEntry != null) {
+          SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
+          sourceCopy.modificationTime = _contentCache.getModificationStamp(source);
+          sourceCopy.setValue(SourceEntry.CONTENT, contents);
+          _cache.put(source, sourceCopy);
+        }
       }
+    } else if (originalContents != null) {
+      _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
+      sourceChanged(source);
     }
   }
 
   void set sourceFactory(SourceFactory factory) {
-    {
-      if (identical(_sourceFactory, factory)) {
-        return;
-      } else if (factory.context != null) {
-        throw new IllegalStateException("Source factories cannot be shared between contexts");
-      }
-      if (_sourceFactory != null) {
-        _sourceFactory.context = null;
-      }
-      factory.context = this;
-      _sourceFactory = factory;
-      invalidateAllResolutionInformation();
+    if (identical(_sourceFactory, factory)) {
+      return;
+    } else if (factory.context != null) {
+      throw new IllegalStateException("Source factories cannot be shared between contexts");
     }
+    if (_sourceFactory != null) {
+      _sourceFactory.context = null;
+    }
+    factory.context = this;
+    _sourceFactory = factory;
+    invalidateAllResolutionInformation();
   }
 
   /**
    * Record the results produced by performing a [ResolveDartLibraryTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
@@ skipping 19 matching lines @@
         DartEntryImpl dartCopy = unitEntry.writableCopy;
         dartCopy.recordResolutionError();
         dartCopy.exception = thrownException;
         _cache.put(unitSource, dartCopy);
         _cache.remove(unitSource);
         if (thrownException != null) {
           throw thrownException;
         }
         return dartCopy;
       }
-      {
-        if (allModificationTimesMatch(resolvedLibraries)) {
-          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.getErrors2(source);
-              LineInfo lineInfo = getLineInfo(source);
-              DartEntry dartEntry = _cache.get(source) as DartEntry;
-              int sourceTime = getModificationStamp(source);
-              if (dartEntry.modificationTime != sourceTime) {
-                // The source has changed without the context being notified. Simulate notification.
-                sourceChanged(source);
-                dartEntry = getReadableDartEntry(source);
-                if (dartEntry == null) {
-                  throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
-                }
+      if (allModificationTimesMatch(resolvedLibraries)) {
+        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.getErrors2(source);
+            LineInfo lineInfo = getLineInfo(source);
+            DartEntry dartEntry = _cache.get(source) as DartEntry;
+            int sourceTime = getModificationStamp(source);
+            if (dartEntry.modificationTime != sourceTime) {
+              // The source has changed without the context being notified. Simulate notification.
+              sourceChanged(source);
+              dartEntry = getReadableDartEntry(source);
+              if (dartEntry == null) {
+                throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
               }
+            }
+            DartEntryImpl dartCopy = dartEntry.writableCopy;
+            if (thrownException == null) {
+              dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
+              dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
+              dartCopy.setValue2(DartEntry.RESOLVED_UNIT, librarySource, unit);
+              dartCopy.setValue2(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
+              if (source == librarySource) {
+                recordElementData(dartEntry, dartCopy, library.libraryElement, librarySource, htmlSource);
+              }
+              _cache.storedAst(source);
+            } else {
+              dartCopy.recordResolutionError();
+              _cache.remove(source);
+            }
+            dartCopy.exception = thrownException;
+            _cache.put(source, dartCopy);
+            if (source != librarySource) {
+              _workManager.add(source, SourcePriority.PRIORITY_PART);
+            }
+            if (source == unitSource) {
+              unitEntry = dartCopy;
+            }
+            ChangeNoticeImpl notice = getNotice(source);
+            notice.compilationUnit = unit;
+            notice.setErrors(dartCopy.allErrors, lineInfo);
+          }
+        }
+      } else {
+        PrintStringWriter writer = new PrintStringWriter();
+        writer.println("Library resolution results discarded for");
+        for (Library library in resolvedLibraries) {
+          for (Source source in library.compilationUnitSources) {
+            DartEntry dartEntry = getReadableDartEntry(source);
+            if (dartEntry != null) {
+              int resultTime = library.getModificationTime(source);
+              writer.println("  ${debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}");
               DartEntryImpl dartCopy = dartEntry.writableCopy;
-              if (thrownException == null) {
-                dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
-                dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
-                dartCopy.setValue2(DartEntry.RESOLVED_UNIT, librarySource, unit);
-                dartCopy.setValue2(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
-                if (source == librarySource) {
-                  recordElementData(dartEntry, dartCopy, library.libraryElement, librarySource, htmlSource);
-                }
-                _cache.storedAst(source);
+              if (thrownException == null || resultTime >= 0) {
+                //
+                // The analysis was performed on out-of-date sources. Mark the cache so that the
+                // sources will be re-analyzed using the up-to-date sources.
+                //
+                dartCopy.recordResolutionNotInProcess();
               } else {
+                //
+                // We could not determine whether the sources were up-to-date or out-of-date. Mark
+                // the cache so that we won't attempt to re-analyze the sources until there's a
+                // good chance that we'll be able to do so without error.
+                //
                 dartCopy.recordResolutionError();
                 _cache.remove(source);
               }
               dartCopy.exception = thrownException;
               _cache.put(source, dartCopy);
-              if (source != librarySource) {
-                _workManager.add(source, SourcePriority.PRIORITY_PART);
-              }
               if (source == unitSource) {
                 unitEntry = dartCopy;
               }
-              ChangeNoticeImpl notice = getNotice(source);
-              notice.compilationUnit = unit;
-              notice.setErrors(dartCopy.allErrors, lineInfo);
+            } else {
+              writer.println("  ${debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
             }
           }
-        } else {
-          PrintStringWriter writer = new PrintStringWriter();
-          writer.println("Library resolution results discarded for");
-          for (Library library in resolvedLibraries) {
-            for (Source source in library.compilationUnitSources) {
-              DartEntry dartEntry = getReadableDartEntry(source);
-              if (dartEntry != null) {
-                int resultTime = library.getModificationTime(source);
-                writer.println("  ${debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}");
-                DartEntryImpl dartCopy = dartEntry.writableCopy;
-                if (thrownException == null || resultTime >= 0) {
-                  //
-                  // The analysis was performed on out-of-date sources. Mark the cache so that the
-                  // sources will be re-analyzed using the up-to-date sources.
-                  //
-                  dartCopy.recordResolutionNotInProcess();
-                } else {
-                  //
-                  // We could not determine whether the sources were up-to-date or out-of-date. Mark
-                  // the cache so that we won't attempt to re-analyze the sources until there's a
-                  // good chance that we'll be able to do so without error.
-                  //
-                  dartCopy.recordResolutionError();
-                  _cache.remove(source);
-                }
-                dartCopy.exception = thrownException;
-                _cache.put(source, dartCopy);
-                if (source == unitSource) {
-                  unitEntry = dartCopy;
-                }
-              } else {
-                writer.println("  ${debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
-              }
-            }
-          }
-          logInformation(writer.toString());
         }
+        logInformation(writer.toString());
       }
     }
     if (thrownException != null) {
       throw thrownException;
     }
     if (unitEntry == null) {
       unitEntry = getReadableDartEntry(unitSource);
       if (unitEntry == null) {
         throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
       }
     }
     return unitEntry;
   }
 
   /**
    * Record that we have accessed the AST structure associated with the given source. At the moment,
    * there is no differentiation between the parsed and resolved forms of the AST.
    *
    * @param source the source whose AST structure was accessed
    */
   void accessedAst(Source source) {
-    {
-      _cache.accessedAst(source);
-    }
+    _cache.accessedAst(source);
   }
 
   /**
    * Add all of the sources contained in the given source container to the given list of sources.
    *
    * Note: This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param sources the list to which sources are to be added
    * @param container the source container containing the sources to be added to the list
    */
@@ skipping 295 matching lines @@
     }
     return htmlEntry;
   }
 
   /**
    * Given the encoded form of a source, use the source factory to reconstitute the original source.
    *
    * @param encoding the encoded form of a source
    * @return the source represented by the encoding
    */
-  Source computeSourceFromEncoding(String encoding) {
-    {
-      return _sourceFactory.fromEncoding(encoding);
-    }
-  }
+  Source computeSourceFromEncoding(String encoding) => _sourceFactory.fromEncoding(encoding);
 
   /**
    * Return `true` if the given array of sources contains the given source.
    *
    * @param sources the sources being searched
    * @param targetSource the source being searched for
    * @return `true` if the given source is in the array
    */
   bool contains(List<Source> sources, Source targetSource) {
     for (Source source in sources) {
@@ skipping 53 matching lines @@
 
   /**
    * Return an array containing all of the change notices that are waiting to be returned. If there
    * are no notices, then return either `null` or an empty array, depending on the value of
    * the argument.
    *
    * @param nullIfEmpty `true` if `null` should be returned when there are no notices
    * @return the change notices that are waiting to be returned
    */
   List<ChangeNotice> getChangeNotices(bool nullIfEmpty) {
-    {
-      if (_pendingNotices.isEmpty) {
-        if (nullIfEmpty) {
-          return null;
-        }
-        return ChangeNoticeImpl.EMPTY_ARRAY;
+    if (_pendingNotices.isEmpty) {
+      if (nullIfEmpty) {
+        return null;
       }
-      List<ChangeNotice> notices = new List.from(_pendingNotices.values);
-      _pendingNotices.clear();
-      return notices;
+      return ChangeNoticeImpl.EMPTY_ARRAY;
     }
+    List<ChangeNotice> notices = new List.from(_pendingNotices.values);
+    _pendingNotices.clear();
+    return notices;
   }
 
   /**
    * 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 resolving the
    * directives in the source if they are not already cached.
    *
    * @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
@@ skipping 274 matching lines @@
     return htmlEntry.getValue(descriptor);
   }
 
   /**
    * Look through the cache for a task that needs to be performed. Return the task that was found,
    * or `null` if there is no more work to be done.
    *
    * @return the next task that needs to be performed
    */
   AnalysisTask get nextAnalysisTask {
-    {
-      bool hintsEnabled = _options.hint;
-      bool sdkErrorsEnabled = _options.generateSdkErrors;
-      bool hasBlockedTask = false;
-      //
-      // Look for incremental analysis
-      //
-      if (_incrementalAnalysisCache != null && _incrementalAnalysisCache.hasWork()) {
-        AnalysisTask task = new IncrementalAnalysisTask(this, _incrementalAnalysisCache);
-        _incrementalAnalysisCache = null;
+    bool hintsEnabled = _options.hint;
+    bool sdkErrorsEnabled = _options.generateSdkErrors;
+    bool hasBlockedTask = false;
+    //
+    // Look for incremental analysis
+    //
+    if (_incrementalAnalysisCache != null && _incrementalAnalysisCache.hasWork()) {
+      AnalysisTask task = new IncrementalAnalysisTask(this, _incrementalAnalysisCache);
+      _incrementalAnalysisCache = null;
+      return task;
+    }
+    //
+    // Look for a priority source that needs to be analyzed.
+    //
+    for (Source source in _priorityOrder) {
+      AnalysisContextImpl_TaskData taskData = getNextNondependentAnalysisTask(source, hintsEnabled, sdkErrorsEnabled);
+      AnalysisTask task = taskData.task;
+      if (task != null) {
         return task;
+      } else if (taskData.isBlocked) {
+        hasBlockedTask = true;
       }
-      //
-      // Look for a priority source that needs to be analyzed.
-      //
-      for (Source source in _priorityOrder) {
-        AnalysisContextImpl_TaskData taskData = getNextNondependentAnalysisTask(source, hintsEnabled, sdkErrorsEnabled);
-        AnalysisTask task = taskData.task;
-        if (task != null) {
-          return task;
-        } else if (taskData.isBlocked) {
-          hasBlockedTask = true;
-        }
+    }
+    //
+    // Look for a non-priority source that needs to be analyzed.
+    //
+    Source source = _workManager.nextSource;
+    while (source != null) {
+      AnalysisContextImpl_TaskData taskData = getNextNondependentAnalysisTask(source, hintsEnabled, sdkErrorsEnabled);
+      AnalysisTask task = taskData.task;
+      if (task != null) {
+        return task;
+      } else if (taskData.isBlocked) {
+        hasBlockedTask = true;
+      } else {
+        _workManager.remove(source);
       }
-      //
-      // Look for a non-priority source that needs to be analyzed.
-      //
-      Source source = _workManager.nextSource;
-      while (source != null) {
-        AnalysisContextImpl_TaskData taskData = getNextNondependentAnalysisTask(source, hintsEnabled, sdkErrorsEnabled);
-        AnalysisTask task = taskData.task;
-        if (task != null) {
-          return task;
-        } else if (taskData.isBlocked) {
-          hasBlockedTask = true;
-        } else {
-          _workManager.remove(source);
-        }
-        source = _workManager.nextSource;
-      }
-      //      //
-      //      // Look for a non-priority source that needs to be analyzed and was missed by the loop above.
-      //      //
-      //      for (Map.Entry<Source, SourceEntry> entry : cache.entrySet()) {
-      //        source = entry.getKey();
-      //        TaskData taskData = getNextAnalysisTaskForSource(source, entry.getValue(), false, hintsEnabled);
-      //        AnalysisTask task = taskData.getTask();
-      //        if (task != null) {
-      //          System.out.println("Failed to analyze " + source.getFullName());
-      //          return task;
-      //        }
-      //      }
-      if (hasBlockedTask) {
-        return WaitForAsyncTask.instance;
-      }
-      return null;
+      source = _workManager.nextSource;
     }
+    //      //
+    //      // Look for a non-priority source that needs to be analyzed and was missed by the loop above.
+    //      //
+    //      for (Map.Entry<Source, SourceEntry> entry : cache.entrySet()) {
+    //        source = entry.getKey();
+    //        TaskData taskData = getNextAnalysisTaskForSource(source, entry.getValue(), false, hintsEnabled);
+    //        AnalysisTask task = taskData.getTask();
+    //        if (task != null) {
+    //          System.out.println("Failed to analyze " + source.getFullName());
+    //          return task;
+    //        }
+    //      }
+    if (hasBlockedTask) {
+      return WaitForAsyncTask.instance;
+    }
+    return null;
   }
 
   /**
    * 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
    * source.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source to be checked
@@ skipping 228 matching lines @@
   }
 
   /**
    * Return the cache entry associated with the given source, or `null` if the source is not a
    * Dart file.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
    */
   DartEntry getReadableDartEntry(Source source) {
-    {
-      SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        sourceEntry = createSourceEntry(source);
-      }
-      if (sourceEntry is DartEntry) {
-        return sourceEntry as DartEntry;
-      }
-      return null;
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      sourceEntry = createSourceEntry(source);
     }
+    if (sourceEntry is DartEntry) {
+      return sourceEntry as DartEntry;
+    }
+    return null;
   }
 
   /**
    * Return the cache entry associated with the given source, or `null` if the source is not
    * an HTML file.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
    */
   HtmlEntry getReadableHtmlEntry(Source source) {
-    {
-      SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        sourceEntry = createSourceEntry(source);
-      }
-      if (sourceEntry is HtmlEntry) {
-        return sourceEntry as HtmlEntry;
-      }
-      return null;
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      sourceEntry = createSourceEntry(source);
     }
+    if (sourceEntry is HtmlEntry) {
+      return sourceEntry as HtmlEntry;
+    }
+    return null;
   }
 
   /**
    * 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 getReadableSourceEntry(Source source) {
-    {
-      SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        sourceEntry = createSourceEntry(source);
-      }
-      return sourceEntry;
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      sourceEntry = createSourceEntry(source);
     }
+    return sourceEntry;
   }
 
   /**
    * 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
    */
   List<Source> getSources(SourceKind kind) {
     List<Source> sources = new List<Source>();
-    {
-      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        if (identical(entry.getValue().kind, kind)) {
-          sources.add(entry.getKey());
-        }
+    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
+      if (identical(entry.getValue().kind, kind)) {
+        sources.add(entry.getKey());
       }
     }
     return new List.from(sources);
   }
 
   /**
    * Look at the given source to see whether a task needs to be performed related to it. If so, add
    * the source to the set of sources that need to be processed. This method duplicates, and must
    * therefore be kept in sync with,
    * [getNextAnalysisTask]. This method is intended to
@@ skipping 367 matching lines @@
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordGenerateDartErrorsTask(GenerateDartErrorsTask task) {
     Source source = task.source;
     Source librarySource = task.libraryElement.source;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
-    {
-      SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        throw new ObsoleteSourceAnalysisException(source);
-      } else if (sourceEntry is! DartEntry) {
-        // This shouldn't be possible because we should never have performed the task if the source
-        // didn't represent a Dart file, but check to be safe.
-        throw new AnalysisException.con1("Internal error: attempting to verify non-Dart file as a Dart file: ${source.fullName}");
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(source);
+    } else if (sourceEntry is! DartEntry) {
+      // This shouldn't be possible because we should never have performed the task if the source
+      // didn't represent a Dart file, but check to be safe.
+      throw new AnalysisException.con1("Internal error: attempting to verify non-Dart file as a Dart file: ${source.fullName}");
+    }
+    dartEntry = sourceEntry as DartEntry;
+    int sourceTime = getModificationStamp(source);
+    int resultTime = task.modificationTime;
+    if (sourceTime == resultTime) {
+      if (dartEntry.modificationTime != sourceTime) {
+        // The source has changed without the context being notified. Simulate notification.
+        sourceChanged(source);
+        dartEntry = getReadableDartEntry(source);
+        if (dartEntry == null) {
+          throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+        }
       }
-      dartEntry = sourceEntry as DartEntry;
-      int sourceTime = getModificationStamp(source);
-      int resultTime = task.modificationTime;
-      if (sourceTime == resultTime) {
-        if (dartEntry.modificationTime != sourceTime) {
-          // The source has changed without the context being notified. Simulate notification.
-          sourceChanged(source);
-          dartEntry = getReadableDartEntry(source);
-          if (dartEntry == null) {
-            throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
-          }
-        }
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        if (thrownException == null) {
-          dartCopy.setValue2(DartEntry.VERIFICATION_ERRORS, librarySource, task.errors);
-          ChangeNoticeImpl notice = getNotice(source);
-          notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
-        } else {
-          dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
-        }
-        dartCopy.exception = thrownException;
-        _cache.put(source, dartCopy);
-        dartEntry = dartCopy;
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      if (thrownException == null) {
+        dartCopy.setValue2(DartEntry.VERIFICATION_ERRORS, librarySource, task.errors);
+        ChangeNoticeImpl notice = getNotice(source);
+        notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
       } else {
-        logInformation2("Generated errors discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        if (thrownException == null || resultTime >= 0) {
-          //
-          // The analysis was performed on out-of-date sources. Mark the cache so that the source
-          // will be re-verified using the up-to-date sources.
-          //
-          //          dartCopy.setState(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.INVALID);
-          removeFromParts(source, dartEntry);
-          dartCopy.invalidateAllInformation();
-          dartCopy.modificationTime = sourceTime;
-          _cache.removedAst(source);
-          _workManager.add(source, SourcePriority.UNKNOWN);
-        } else {
-          //
-          // We could not determine whether the sources were up-to-date or out-of-date. Mark the
-          // cache so that we won't attempt to re-verify the source until there's a good chance
-          // that we'll be able to do so without error.
-          //
-          dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
-        }
-        dartCopy.exception = thrownException;
-        _cache.put(source, dartCopy);
-        dartEntry = dartCopy;
+        dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
       }
+      dartCopy.exception = thrownException;
+      _cache.put(source, dartCopy);
+      dartEntry = dartCopy;
+    } else {
+      logInformation2("Generated errors discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      if (thrownException == null || resultTime >= 0) {
+        //
+        // The analysis was performed on out-of-date sources. Mark the cache so that the source
+        // will be re-verified using the up-to-date sources.
+        //
+        //          dartCopy.setState(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.INVALID);
+        removeFromParts(source, dartEntry);
+        dartCopy.invalidateAllInformation();
+        dartCopy.modificationTime = sourceTime;
+        _cache.removedAst(source);
+        _workManager.add(source, SourcePriority.UNKNOWN);
+      } else {
+        //
+        // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+        // cache so that we won't attempt to re-verify the source until there's a good chance
+        // that we'll be able to do so without error.
+        //
+        dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
+      }
+      dartCopy.exception = thrownException;
+      _cache.put(source, dartCopy);
+      dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return dartEntry;
   }
 
   /**
    * Record the results produced by performing a [GenerateDartHintsTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordGenerateDartHintsTask(GenerateDartHintsTask task) {
     Source librarySource = task.libraryElement.source;
     AnalysisException thrownException = task.exception;
     DartEntry libraryEntry = null;
     Map<Source, TimestampedData<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.
-        SourceEntry sourceEntry = _cache.get(librarySource);
-        if (sourceEntry == null) {
-          throw new ObsoleteSourceAnalysisException(librarySource);
-        } else if (sourceEntry is! DartEntry) {
-          // This shouldn't be possible because we should never have performed the task if the source
-          // didn't represent a Dart file, but check to be safe.
-          throw new AnalysisException.con1("Internal error: attempting to generate hints for non-Dart file as a Dart file: ${librarySource.fullName}");
-        }
-        if (thrownException == null) {
-          thrownException = new AnalysisException.con1("GenerateDartHintsTask returned a null hint map without throwing an exception: ${librarySource.fullName}");
-        }
-        DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
-        dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.ERROR);
-        dartCopy.exception = thrownException;
-        _cache.put(librarySource, dartCopy);
+      // We don't have any information about which sources to mark as invalid other than the library
+      // source.
+      SourceEntry sourceEntry = _cache.get(librarySource);
+      if (sourceEntry == null) {
+        throw new ObsoleteSourceAnalysisException(librarySource);
+      } else if (sourceEntry is! DartEntry) {
+        // This shouldn't be possible because we should never have performed the task if the source
+        // didn't represent a Dart file, but check to be safe.
+        throw new AnalysisException.con1("Internal error: attempting to generate hints for non-Dart file as a Dart file: ${librarySource.fullName}");
       }
+      if (thrownException == null) {
+        thrownException = new AnalysisException.con1("GenerateDartHintsTask returned a null hint map without throwing an exception: ${librarySource.fullName}");
+      }
+      DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
+      dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.ERROR);
+      dartCopy.exception = thrownException;
+      _cache.put(librarySource, dartCopy);
       throw thrownException;
     }
     for (MapEntry<Source, TimestampedData<List<AnalysisError>>> entry in getMapEntrySet(hintMap)) {
       Source unitSource = entry.getKey();
       TimestampedData<List<AnalysisError>> results = entry.getValue();
-      {
-        SourceEntry sourceEntry = _cache.get(unitSource);
-        if (sourceEntry is! DartEntry) {
-          // This shouldn't be possible because we should never have performed the task if the source
-          // didn't represent a Dart file, but check to be safe.
-          throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${unitSource.fullName}");
+      SourceEntry sourceEntry = _cache.get(unitSource);
+      if (sourceEntry is! DartEntry) {
+        // This shouldn't be possible because we should never have performed the task if the source
+        // didn't represent a Dart file, but check to be safe.
+        throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${unitSource.fullName}");
+      }
+      DartEntry dartEntry = sourceEntry as DartEntry;
+      if (unitSource == librarySource) {
+        libraryEntry = dartEntry;
+      }
+      int sourceTime = getModificationStamp(unitSource);
+      int resultTime = results.modificationTime;
+      if (sourceTime == resultTime) {
+        if (dartEntry.modificationTime != sourceTime) {
+          // The source has changed without the context being notified. Simulate notification.
+          sourceChanged(unitSource);
+          dartEntry = getReadableDartEntry(unitSource);
+          if (dartEntry == null) {
+            throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
+          }
         }
-        DartEntry dartEntry = sourceEntry as DartEntry;
-        if (unitSource == librarySource) {
-          libraryEntry = dartEntry;
+        DartEntryImpl dartCopy = dartEntry.writableCopy;
+        if (thrownException == null) {
+          dartCopy.setValue2(DartEntry.HINTS, librarySource, results.data);
+          ChangeNoticeImpl notice = getNotice(unitSource);
+          notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+        } else {
+          dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.ERROR);
         }
-        int sourceTime = getModificationStamp(unitSource);
-        int resultTime = results.modificationTime;
-        if (sourceTime == resultTime) {
-          if (dartEntry.modificationTime != sourceTime) {
-            // The source has changed without the context being notified. Simulate notification.
-            sourceChanged(unitSource);
-            dartEntry = getReadableDartEntry(unitSource);
-            if (dartEntry == null) {
-              throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
-            }
-          }
+        dartCopy.exception = thrownException;
+        _cache.put(unitSource, dartCopy);
+        dartEntry = dartCopy;
+      } else {
+        logInformation2("Generated hints discarded for ${debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+        if (identical(dartEntry.getState2(DartEntry.HINTS, librarySource), CacheState.IN_PROCESS)) {
           DartEntryImpl dartCopy = dartEntry.writableCopy;
-          if (thrownException == null) {
-            dartCopy.setValue2(DartEntry.HINTS, librarySource, results.data);
-            ChangeNoticeImpl notice = getNotice(unitSource);
-            notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+          if (thrownException == null || resultTime >= 0) {
+            //
+            // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+            // will be re-analyzed using the up-to-date sources.
+            //
+            //              dartCopy.setState(DartEntry.HINTS, librarySource, CacheState.INVALID);
+            removeFromParts(unitSource, dartEntry);
+            dartCopy.invalidateAllInformation();
+            dartCopy.modificationTime = sourceTime;
+            _cache.removedAst(unitSource);
+            _workManager.add(unitSource, SourcePriority.UNKNOWN);
           } else {
+            //
+            // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+            // cache so that we won't attempt to re-analyze the sources until there's a good chance
+            // that we'll be able to do so without error.
+            //
             dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.ERROR);
           }
           dartCopy.exception = thrownException;
           _cache.put(unitSource, dartCopy);
           dartEntry = dartCopy;
-        } else {
-          logInformation2("Generated hints discarded for ${debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
-          if (identical(dartEntry.getState2(DartEntry.HINTS, librarySource), CacheState.IN_PROCESS)) {
-            DartEntryImpl dartCopy = dartEntry.writableCopy;
-            if (thrownException == null || resultTime >= 0) {
-              //
-              // The analysis was performed on out-of-date sources. Mark the cache so that the sources
-              // will be re-analyzed using the up-to-date sources.
-              //
-              //              dartCopy.setState(DartEntry.HINTS, librarySource, CacheState.INVALID);
-              removeFromParts(unitSource, dartEntry);
-              dartCopy.invalidateAllInformation();
-              dartCopy.modificationTime = sourceTime;
-              _cache.removedAst(unitSource);
-              _workManager.add(unitSource, SourcePriority.UNKNOWN);
-            } else {
-              //
-              // We could not determine whether the sources were up-to-date or out-of-date. Mark the
-              // cache so that we won't attempt to re-analyze the sources until there's a good chance
-              // that we'll be able to do so without error.
-              //
-              dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.ERROR);
-            }
-            dartCopy.exception = thrownException;
-            _cache.put(unitSource, dartCopy);
-            dartEntry = dartCopy;
-          }
         }
       }
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return libraryEntry;
   }
 
   /**
    * Record the results produced by performing a [GetContentTask].
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   SourceEntry recordGetContentsTask(GetContentTask task) {
     if (!task.isComplete) {
       return null;
     }
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     SourceEntry sourceEntry = null;
-    {
-      sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        throw new ObsoleteSourceAnalysisException(source);
-      }
-      SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
-      if (thrownException == null) {
-        sourceCopy.modificationTime = task.modificationTime;
-        sourceCopy.setValue(SourceEntry.CONTENT, task.content);
-      } else {
-        sourceCopy.exception = thrownException;
-        sourceCopy.recordContentError();
-        _workManager.remove(source);
-      }
-      _cache.put(source, sourceCopy);
-      sourceEntry = sourceCopy;
+    sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(source);
     }
+    SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
+    if (thrownException == null) {
+      sourceCopy.modificationTime = task.modificationTime;
+      sourceCopy.setValue(SourceEntry.CONTENT, task.content);
+    } else {
+      sourceCopy.exception = thrownException;
+      sourceCopy.recordContentError();
+      _workManager.remove(source);
+    }
+    _cache.put(source, sourceCopy);
+    sourceEntry = sourceCopy;
     if (thrownException != null) {
       throw thrownException;
     }
     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) {
-    {
-      CompilationUnit unit = task.compilationUnit;
-      if (unit != null) {
-        ChangeNoticeImpl notice = getNotice(task.source);
-        notice.compilationUnit = unit;
-        _incrementalAnalysisCache = IncrementalAnalysisCache.cacheResult(task.cache, unit);
-      }
+    CompilationUnit unit = task.compilationUnit;
+    if (unit != null) {
+      ChangeNoticeImpl notice = getNotice(task.source);
+      notice.compilationUnit = unit;
+      _incrementalAnalysisCache = IncrementalAnalysisCache.cacheResult(task.cache, unit);
     }
     return null;
   }
 
   /**
    * Record the results produced by performing a [ParseDartTask]. If the results were computed
    * from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordParseDartTaskResults(ParseDartTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
-    {
-      SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        throw new ObsoleteSourceAnalysisException(source);
-      } else if (sourceEntry is! DartEntry) {
-        // This shouldn't be possible because we should never have performed the task if the source
-        // didn't represent a Dart file, but check to be safe.
-        throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(source);
+    } else if (sourceEntry is! DartEntry) {
+      // This shouldn't be possible because we should never have performed the task if the source
+      // didn't represent a Dart file, but check to be safe.
+      throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
+    }
+    dartEntry = sourceEntry as DartEntry;
+    int sourceTime = getModificationStamp(source);
+    int resultTime = task.modificationTime;
+    if (sourceTime == resultTime) {
+      if (dartEntry.modificationTime != sourceTime) {
+        // The source has changed without the context being notified. Simulate notification.
+        sourceChanged(source);
+        dartEntry = getReadableDartEntry(source);
+        if (dartEntry == null) {
+          throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+        }
       }
-      dartEntry = sourceEntry as DartEntry;
-      int sourceTime = getModificationStamp(source);
-      int resultTime = task.modificationTime;
-      if (sourceTime == resultTime) {
-        if (dartEntry.modificationTime != sourceTime) {
-          // The source has changed without the context being notified. Simulate notification.
-          sourceChanged(source);
-          dartEntry = getReadableDartEntry(source);
-          if (dartEntry == null) {
-            throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
-          }
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      if (thrownException == null) {
+        if (task.hasPartOfDirective() && !task.hasLibraryDirective()) {
+          dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
+          dartCopy.removeContainingLibrary(source);
+          _workManager.add(source, SourcePriority.NORMAL_PART);
+        } else {
+          dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
+          dartCopy.containingLibrary = source;
+          _workManager.add(source, SourcePriority.LIBRARY);
         }
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        if (thrownException == null) {
-          if (task.hasPartOfDirective() && !task.hasLibraryDirective()) {
-            dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
-            dartCopy.removeContainingLibrary(source);
-            _workManager.add(source, SourcePriority.NORMAL_PART);
-          } else {
-            dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
-            dartCopy.containingLibrary = source;
-            _workManager.add(source, SourcePriority.LIBRARY);
-          }
-          dartCopy.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
-          dartCopy.setValue(DartEntry.PARSE_ERRORS, task.errors);
-          _cache.storedAst(source);
-          ChangeNoticeImpl notice = getNotice(source);
-          notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
-          // 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);
-        } else {
-          removeFromParts(source, dartEntry);
-          dartCopy.recordParseError();
-          _cache.removedAst(source);
-        }
-        dartCopy.exception = thrownException;
-        _cache.put(source, dartCopy);
-        dartEntry = dartCopy;
+        dartCopy.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
+        dartCopy.setValue(DartEntry.PARSE_ERRORS, task.errors);
+        _cache.storedAst(source);
+        ChangeNoticeImpl notice = getNotice(source);
+        notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+        // 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);
       } else {
-        logInformation2("Parse results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        if (thrownException == null || resultTime >= 0) {
-          //
-          // The analysis was performed on out-of-date sources. Mark the cache so that the sources
-          // will be re-analyzed using the up-to-date sources.
-          //
-          //          dartCopy.recordParseNotInProcess();
-          removeFromParts(source, dartEntry);
-          dartCopy.invalidateAllInformation();
-          dartCopy.modificationTime = sourceTime;
-          _cache.removedAst(source);
-          _workManager.add(source, SourcePriority.UNKNOWN);
-        } else {
-          //
-          // We could not determine whether the sources were up-to-date or out-of-date. Mark the
-          // cache so that we won't attempt to re-analyze the sources until there's a good chance
-          // that we'll be able to do so without error.
-          //
-          dartCopy.recordParseError();
-        }
-        dartCopy.exception = thrownException;
-        _cache.put(source, dartCopy);
-        dartEntry = dartCopy;
+        removeFromParts(source, dartEntry);
+        dartCopy.recordParseError();
+        _cache.removedAst(source);
       }
+      dartCopy.exception = thrownException;
+      _cache.put(source, dartCopy);
+      dartEntry = dartCopy;
+    } else {
+      logInformation2("Parse results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      if (thrownException == null || resultTime >= 0) {
+        //
+        // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+        // will be re-analyzed using the up-to-date sources.
+        //
+        //          dartCopy.recordParseNotInProcess();
+        removeFromParts(source, dartEntry);
+        dartCopy.invalidateAllInformation();
+        dartCopy.modificationTime = sourceTime;
+        _cache.removedAst(source);
+        _workManager.add(source, SourcePriority.UNKNOWN);
+      } else {
+        //
+        // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+        // cache so that we won't attempt to re-analyze the sources until there's a good chance
+        // that we'll be able to do so without error.
+        //
+        dartCopy.recordParseError();
+      }
+      dartCopy.exception = thrownException;
+      _cache.put(source, dartCopy);
+      dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return dartEntry;
   }
 
   /**
    * Record the results produced by performing a [ParseHtmlTask]. If the results were computed
    * from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   HtmlEntry recordParseHtmlTaskResults(ParseHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
-    {
-      SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        throw new ObsoleteSourceAnalysisException(source);
-      } else if (sourceEntry is! HtmlEntry) {
-        // This shouldn't be possible because we should never have performed the task if the source
-        // didn't represent an HTML file, but check to be safe.
-        throw new AnalysisException.con1("Internal error: attempting to parse non-HTML file as a HTML file: ${source.fullName}");
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(source);
+    } else if (sourceEntry is! HtmlEntry) {
+      // This shouldn't be possible because we should never have performed the task if the source
+      // didn't represent an HTML file, but check to be safe.
+      throw new AnalysisException.con1("Internal error: attempting to parse non-HTML file as a HTML file: ${source.fullName}");
+    }
+    htmlEntry = sourceEntry as HtmlEntry;
+    int sourceTime = getModificationStamp(source);
+    int resultTime = task.modificationTime;
+    if (sourceTime == resultTime) {
+      if (htmlEntry.modificationTime != sourceTime) {
+        // The source has changed without the context being notified. Simulate notification.
+        sourceChanged(source);
+        htmlEntry = getReadableHtmlEntry(source);
+        if (htmlEntry == null) {
+          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+        }
       }
-      htmlEntry = sourceEntry as HtmlEntry;
-      int sourceTime = getModificationStamp(source);
-      int resultTime = task.modificationTime;
-      if (sourceTime == resultTime) {
-        if (htmlEntry.modificationTime != sourceTime) {
-          // The source has changed without the context being notified. Simulate notification.
-          sourceChanged(source);
-          htmlEntry = getReadableHtmlEntry(source);
-          if (htmlEntry == null) {
-            throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
-          }
-        }
-        HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
-        if (thrownException == null) {
-          LineInfo lineInfo = task.lineInfo;
-          ht.HtmlUnit unit = task.htmlUnit;
-          htmlCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
-          htmlCopy.setValue(HtmlEntry.PARSED_UNIT, unit);
-          htmlCopy.setValue(HtmlEntry.PARSE_ERRORS, task.errors);
-          htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
-          _cache.storedAst(source);
-          ChangeNoticeImpl notice = getNotice(source);
-          notice.setErrors(htmlCopy.allErrors, lineInfo);
-        } else {
-          htmlCopy.recordParseError();
-          _cache.removedAst(source);
-        }
-        htmlCopy.exception = thrownException;
-        _cache.put(source, htmlCopy);
-        htmlEntry = htmlCopy;
+      HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
+      if (thrownException == null) {
+        LineInfo lineInfo = task.lineInfo;
+        ht.HtmlUnit unit = task.htmlUnit;
+        htmlCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
+        htmlCopy.setValue(HtmlEntry.PARSED_UNIT, unit);
+        htmlCopy.setValue(HtmlEntry.PARSE_ERRORS, task.errors);
+        htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
+        _cache.storedAst(source);
+        ChangeNoticeImpl notice = getNotice(source);
+        notice.setErrors(htmlCopy.allErrors, lineInfo);
       } else {
-        logInformation2("Parse results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
-        HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
-        if (thrownException == null || resultTime >= 0) {
-          //
-          // The analysis was performed on out-of-date sources. Mark the cache so that the sources
-          // will be re-analyzed using the up-to-date sources.
-          //
-          //          if (htmlCopy.getState(SourceEntry.LINE_INFO) == CacheState.IN_PROCESS) {
-          //            htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.INVALID);
-          //          }
-          //          if (htmlCopy.getState(HtmlEntry.PARSED_UNIT) == CacheState.IN_PROCESS) {
-          //            htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.INVALID);
-          //          }
-          //          if (htmlCopy.getState(HtmlEntry.REFERENCED_LIBRARIES) == CacheState.IN_PROCESS) {
-          //            htmlCopy.setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.INVALID);
-          //          }
-          htmlCopy.invalidateAllInformation();
-          htmlCopy.modificationTime = sourceTime;
-          _cache.removedAst(source);
-        } else {
-          //
-          // We could not determine whether the sources were up-to-date or out-of-date. Mark the
-          // cache so that we won't attempt to re-analyze the sources until there's a good chance
-          // that we'll be able to do so without error.
-          //
-          htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.ERROR);
-          htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.ERROR);
-          htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.ERROR);
-          htmlCopy.setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.ERROR);
-        }
-        htmlCopy.exception = thrownException;
-        _cache.put(source, htmlCopy);
-        htmlEntry = htmlCopy;
+        htmlCopy.recordParseError();
+        _cache.removedAst(source);
       }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
+    } else {
+      logInformation2("Parse results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
+      HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
+      if (thrownException == null || resultTime >= 0) {
+        //
+        // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+        // will be re-analyzed using the up-to-date sources.
+        //
+        //          if (htmlCopy.getState(SourceEntry.LINE_INFO) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.INVALID);
+        //          }
+        //          if (htmlCopy.getState(HtmlEntry.PARSED_UNIT) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.INVALID);
+        //          }
+        //          if (htmlCopy.getState(HtmlEntry.REFERENCED_LIBRARIES) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.INVALID);
+        //          }
+        htmlCopy.invalidateAllInformation();
+        htmlCopy.modificationTime = sourceTime;
+        _cache.removedAst(source);
+      } else {
+        //
+        // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+        // cache so that we won't attempt to re-analyze the sources until there's a good chance
+        // that we'll be able to do so without error.
+        //
+        htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.ERROR);
+        htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.ERROR);
+        htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.ERROR);
+        htmlCopy.setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.ERROR);
+      }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
    * Record the results produced by performing a [ResolveAngularComponentTemplateTask]. If the
    * results were computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @throws AnalysisException if the results could not be recorded
    */
   HtmlEntry recordResolveAngularComponentTemplateTaskResults(ResolveAngularComponentTemplateTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
-    {
-      SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        throw new ObsoleteSourceAnalysisException(source);
-      } else if (sourceEntry is! HtmlEntry) {
-        // This shouldn't be possible because we should never have performed the task if the source
-        // didn't represent an HTML file, but check to be safe.
-        throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(source);
+    } else if (sourceEntry is! HtmlEntry) {
+      // This shouldn't be possible because we should never have performed the task if the source
+      // didn't represent an HTML file, but check to be safe.
+      throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+    }
+    htmlEntry = sourceEntry as HtmlEntry;
+    int sourceTime = getModificationStamp(source);
+    int resultTime = task.modificationTime;
+    if (sourceTime == resultTime) {
+      if (htmlEntry.modificationTime != sourceTime) {
+        // The source has changed without the context being notified. Simulate notification.
+        sourceChanged(source);
+        htmlEntry = getReadableHtmlEntry(source);
+        if (htmlEntry == null) {
+          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+        }
       }
-      htmlEntry = sourceEntry as HtmlEntry;
-      int sourceTime = getModificationStamp(source);
-      int resultTime = task.modificationTime;
-      if (sourceTime == resultTime) {
-        if (htmlEntry.modificationTime != sourceTime) {
-          // The source has changed without the context being notified. Simulate notification.
-          sourceChanged(source);
-          htmlEntry = getReadableHtmlEntry(source);
-          if (htmlEntry == null) {
-            throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
-          }
-        }
-        HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-        if (thrownException == null) {
-          htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, task.resolutionErrors);
-          // notify about errors
-          ChangeNoticeImpl notice = getNotice(source);
-          notice.htmlUnit = task.resolvedUnit;
-          notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
-        } else {
-          htmlCopy.recordResolutionError();
-        }
-        htmlCopy.exception = thrownException;
-        _cache.put(source, htmlCopy);
-        htmlEntry = htmlCopy;
+      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+      if (thrownException == null) {
+        htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, task.resolutionErrors);
+        // notify about errors
+        ChangeNoticeImpl notice = getNotice(source);
+        notice.htmlUnit = task.resolvedUnit;
+        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
-        HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-        if (thrownException == null || resultTime >= 0) {
-          //
-          // The analysis was performed on out-of-date sources. Mark the cache so that the sources
-          // will be re-analyzed using the up-to-date sources.
-          //
-          //          if (htmlCopy.getState(HtmlEntry.ANGULAR_ERRORS) == CacheState.IN_PROCESS) {
-          //            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
-          //          }
-          //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
-          //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
-          //          }
-          //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
-          //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
-          //          }
-          htmlCopy.invalidateAllInformation();
-          htmlCopy.modificationTime = sourceTime;
-          _cache.removedAst(source);
-        } else {
-          //
-          // We could not determine whether the sources were up-to-date or out-of-date. Mark the
-          // cache so that we won't attempt to re-analyze the sources until there's a good chance
-          // that we'll be able to do so without error.
-          //
-          htmlCopy.recordResolutionError();
-        }
-        htmlCopy.exception = thrownException;
-        _cache.put(source, htmlCopy);
-        htmlEntry = htmlCopy;
+        htmlCopy.recordResolutionError();
       }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
+    } else {
+      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+      if (thrownException == null || resultTime >= 0) {
+        //
+        // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+        // will be re-analyzed using the up-to-date sources.
+        //
+        //          if (htmlCopy.getState(HtmlEntry.ANGULAR_ERRORS) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
+        //          }
+        //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
+        //          }
+        //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
+        //          }
+        htmlCopy.invalidateAllInformation();
+        htmlCopy.modificationTime = sourceTime;
+        _cache.removedAst(source);
+      } else {
+        //
+        // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+        // cache so that we won't attempt to re-analyze the sources until there's a good chance
+        // that we'll be able to do so without error.
+        //
+        htmlCopy.recordResolutionError();
+      }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
    * Record the results produced by performing a [ResolveAngularEntryHtmlTask]. If the results
    * were computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @throws AnalysisException if the results could not be recorded
    */
   HtmlEntry recordResolveAngularEntryHtmlTaskResults(ResolveAngularEntryHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
-    {
-      SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        throw new ObsoleteSourceAnalysisException(source);
-      } else if (sourceEntry is! HtmlEntry) {
-        // This shouldn't be possible because we should never have performed the task if the source
-        // didn't represent an HTML file, but check to be safe.
-        throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(source);
+    } else if (sourceEntry is! HtmlEntry) {
+      // This shouldn't be possible because we should never have performed the task if the source
+      // didn't represent an HTML file, but check to be safe.
+      throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+    }
+    htmlEntry = sourceEntry as HtmlEntry;
+    int sourceTime = getModificationStamp(source);
+    int resultTime = task.modificationTime;
+    if (sourceTime == resultTime) {
+      if (htmlEntry.modificationTime != sourceTime) {
+        // The source has changed without the context being notified. Simulate notification.
+        sourceChanged(source);
+        htmlEntry = getReadableHtmlEntry(source);
+        if (htmlEntry == null) {
+          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+        }
       }
-      htmlEntry = sourceEntry as HtmlEntry;
-      int sourceTime = getModificationStamp(source);
-      int resultTime = task.modificationTime;
-      if (sourceTime == resultTime) {
-        if (htmlEntry.modificationTime != sourceTime) {
-          // The source has changed without the context being notified. Simulate notification.
-          sourceChanged(source);
-          htmlEntry = getReadableHtmlEntry(source);
-          if (htmlEntry == null) {
-            throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
-          }
-        }
-        HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-        if (thrownException == null) {
-          htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
-          recordAngularEntryPoint(htmlCopy, task);
-          _cache.storedAst(source);
-          ChangeNoticeImpl notice = getNotice(source);
-          notice.htmlUnit = task.resolvedUnit;
-          notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
-        } else {
-          htmlCopy.recordResolutionError();
-        }
-        htmlCopy.exception = thrownException;
-        _cache.put(source, htmlCopy);
-        htmlEntry = htmlCopy;
+      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+      if (thrownException == null) {
+        htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
+        recordAngularEntryPoint(htmlCopy, task);
+        _cache.storedAst(source);
+        ChangeNoticeImpl notice = getNotice(source);
+        notice.htmlUnit = task.resolvedUnit;
+        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
-        HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-        if (thrownException == null || resultTime >= 0) {
-          //
-          // The analysis was performed on out-of-date sources. Mark the cache so that the sources
-          // will be re-analyzed using the up-to-date sources.
-          //
-          //          if (htmlCopy.getState(HtmlEntry.ANGULAR_ERRORS) == CacheState.IN_PROCESS) {
-          //            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
-          //          }
-          //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
-          //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
-          //          }
-          //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
-          //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
-          //          }
-          htmlCopy.invalidateAllInformation();
-          htmlCopy.modificationTime = sourceTime;
-          _cache.removedAst(source);
-        } else {
-          //
-          // We could not determine whether the sources were up-to-date or out-of-date. Mark the
-          // cache so that we won't attempt to re-analyze the sources until there's a good chance
-          // that we'll be able to do so without error.
-          //
-          htmlCopy.recordResolutionError();
-        }
-        htmlCopy.exception = thrownException;
-        _cache.put(source, htmlCopy);
-        htmlEntry = htmlCopy;
+        htmlCopy.recordResolutionError();
       }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
+    } else {
+      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+      if (thrownException == null || resultTime >= 0) {
+        //
+        // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+        // will be re-analyzed using the up-to-date sources.
+        //
+        //          if (htmlCopy.getState(HtmlEntry.ANGULAR_ERRORS) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
+        //          }
+        //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
+        //          }
+        //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
+        //          }
+        htmlCopy.invalidateAllInformation();
+        htmlCopy.modificationTime = sourceTime;
+        _cache.removedAst(source);
+      } else {
+        //
+        // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+        // cache so that we won't attempt to re-analyze the sources until there's a good chance
+        // that we'll be able to do so without error.
+        //
+        htmlCopy.recordResolutionError();
+      }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
    * Record the results produced by performing a [ResolveDartDependenciesTask]. If the results
    * were computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordResolveDartDependenciesTaskResults(ResolveDartDependenciesTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
-    {
-      SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        throw new ObsoleteSourceAnalysisException(source);
-      } else if (sourceEntry is! DartEntry) {
-        // This shouldn't be possible because we should never have performed the task if the source
-        // didn't represent a Dart file, but check to be safe.
-        throw new AnalysisException.con1("Internal error: attempting to resolve Dart dependencies in a non-Dart file: ${source.fullName}");
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(source);
+    } else if (sourceEntry is! DartEntry) {
+      // This shouldn't be possible because we should never have performed the task if the source
+      // didn't represent a Dart file, but check to be safe.
+      throw new AnalysisException.con1("Internal error: attempting to resolve Dart dependencies in a non-Dart file: ${source.fullName}");
+    }
+    dartEntry = sourceEntry as DartEntry;
+    int sourceTime = getModificationStamp(source);
+    int resultTime = task.modificationTime;
+    if (sourceTime == resultTime) {
+      if (dartEntry.modificationTime != sourceTime) {
+        // The source has changed without the context being notified. Simulate notification.
+        sourceChanged(source);
+        dartEntry = getReadableDartEntry(source);
+        if (dartEntry == null) {
+          throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+        }
       }
-      dartEntry = sourceEntry as DartEntry;
-      int sourceTime = getModificationStamp(source);
-      int resultTime = task.modificationTime;
-      if (sourceTime == resultTime) {
-        if (dartEntry.modificationTime != sourceTime) {
-          // The source has changed without the context being notified. Simulate notification.
-          sourceChanged(source);
-          dartEntry = getReadableDartEntry(source);
-          if (dartEntry == null) {
-            throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+      removeFromParts(source, dartEntry);
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      if (thrownException == null) {
+        List<Source> newParts = task.includedSources;
+        for (int i = 0; i < newParts.length; i++) {
+          Source partSource = newParts[i];
+          DartEntry partEntry = getReadableDartEntry(partSource);
+          if (partEntry != null && partEntry != dartEntry) {
+            DartEntryImpl partCopy = partEntry.writableCopy;
+            partCopy.addContainingLibrary(source);
+            _cache.put(partSource, partCopy);
           }
         }
+        dartCopy.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
+        dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
+        dartCopy.setValue(DartEntry.INCLUDED_PARTS, newParts);
+      } else {
+        dartCopy.recordDependencyError();
+      }
+      dartCopy.exception = thrownException;
+      _cache.put(source, dartCopy);
+      dartEntry = dartCopy;
+    } else {
+      logInformation2("Dependency resolution results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      if (thrownException == null || resultTime >= 0) {
+        //
+        // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+        // will be re-analyzed using the up-to-date sources.
+        //
+        //          dartCopy.recordDependencyNotInProcess();
         removeFromParts(source, dartEntry);
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        if (thrownException == null) {
-          List<Source> newParts = task.includedSources;
-          for (int i = 0; i < newParts.length; i++) {
-            Source partSource = newParts[i];
-            DartEntry partEntry = getReadableDartEntry(partSource);
-            if (partEntry != null && partEntry != dartEntry) {
-              DartEntryImpl partCopy = partEntry.writableCopy;
-              partCopy.addContainingLibrary(source);
-              _cache.put(partSource, partCopy);
-            }
-          }
-          dartCopy.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
-          dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
-          dartCopy.setValue(DartEntry.INCLUDED_PARTS, newParts);
-        } else {
-          dartCopy.recordDependencyError();
-        }
-        dartCopy.exception = thrownException;
-        _cache.put(source, dartCopy);
-        dartEntry = dartCopy;
+        dartCopy.invalidateAllInformation();
+        dartCopy.modificationTime = sourceTime;
+        _cache.removedAst(source);
+        _workManager.add(source, SourcePriority.UNKNOWN);
       } else {
-        logInformation2("Dependency resolution results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        if (thrownException == null || resultTime >= 0) {
-          //
-          // The analysis was performed on out-of-date sources. Mark the cache so that the sources
-          // will be re-analyzed using the up-to-date sources.
-          //
-          //          dartCopy.recordDependencyNotInProcess();
-          removeFromParts(source, dartEntry);
-          dartCopy.invalidateAllInformation();
-          dartCopy.modificationTime = sourceTime;
-          _cache.removedAst(source);
-          _workManager.add(source, SourcePriority.UNKNOWN);
-        } else {
-          //
-          // We could not determine whether the sources were up-to-date or out-of-date. Mark the
-          // cache so that we won't attempt to re-analyze the sources until there's a good chance
-          // that we'll be able to do so without error.
-          //
-          dartCopy.setState(DartEntry.EXPORTED_LIBRARIES, CacheState.ERROR);
-          dartCopy.setState(DartEntry.IMPORTED_LIBRARIES, CacheState.ERROR);
-          dartCopy.setState(DartEntry.INCLUDED_PARTS, CacheState.ERROR);
-        }
-        dartCopy.exception = thrownException;
-        _cache.put(source, dartCopy);
-        dartEntry = dartCopy;
+        //
+        // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+        // cache so that we won't attempt to re-analyze the sources until there's a good chance
+        // that we'll be able to do so without error.
+        //
+        dartCopy.setState(DartEntry.EXPORTED_LIBRARIES, CacheState.ERROR);
+        dartCopy.setState(DartEntry.IMPORTED_LIBRARIES, CacheState.ERROR);
+        dartCopy.setState(DartEntry.INCLUDED_PARTS, CacheState.ERROR);
       }
+      dartCopy.exception = thrownException;
+      _cache.put(source, dartCopy);
+      dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return dartEntry;
   }
 
   /**
    * Record the results produced by performing a [ResolveDartUnitTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordResolveDartUnitTaskResults(ResolveDartUnitTask task) {
     Source unitSource = task.source;
     Source librarySource = task.librarySource;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
-    {
-      SourceEntry sourceEntry = _cache.get(unitSource);
-      if (sourceEntry == null) {
-        throw new ObsoleteSourceAnalysisException(unitSource);
-      } else if (sourceEntry is! DartEntry) {
-        // This shouldn't be possible because we should never have performed the task if the source
-        // didn't represent a Dart file, but check to be safe.
-        throw new AnalysisException.con1("Internal error: attempting to resolve non-Dart file as a Dart file: ${unitSource.fullName}");
+    SourceEntry sourceEntry = _cache.get(unitSource);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(unitSource);
+    } else if (sourceEntry is! DartEntry) {
+      // This shouldn't be possible because we should never have performed the task if the source
+      // didn't represent a Dart file, but check to be safe.
+      throw new AnalysisException.con1("Internal error: attempting to resolve non-Dart file as a Dart file: ${unitSource.fullName}");
+    }
+    dartEntry = sourceEntry as DartEntry;
+    int sourceTime = getModificationStamp(unitSource);
+    int resultTime = task.modificationTime;
+    if (sourceTime == resultTime) {
+      if (dartEntry.modificationTime != sourceTime) {
+        // The source has changed without the context being notified. Simulate notification.
+        sourceChanged(unitSource);
+        dartEntry = getReadableDartEntry(unitSource);
+        if (dartEntry == null) {
+          throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
+        }
       }
-      dartEntry = sourceEntry as DartEntry;
-      int sourceTime = getModificationStamp(unitSource);
-      int resultTime = task.modificationTime;
-      if (sourceTime == resultTime) {
-        if (dartEntry.modificationTime != sourceTime) {
-          // The source has changed without the context being notified. Simulate notification.
-          sourceChanged(unitSource);
-          dartEntry = getReadableDartEntry(unitSource);
-          if (dartEntry == null) {
-            throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
-          }
-        }
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        if (thrownException == null) {
-          dartCopy.setValue2(DartEntry.RESOLVED_UNIT, librarySource, task.resolvedUnit);
-          _cache.storedAst(unitSource);
-        } else {
-          dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.ERROR);
-          _cache.removedAst(unitSource);
-        }
-        dartCopy.exception = thrownException;
-        _cache.put(unitSource, dartCopy);
-        dartEntry = dartCopy;
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      if (thrownException == null) {
+        dartCopy.setValue2(DartEntry.RESOLVED_UNIT, librarySource, task.resolvedUnit);
+        _cache.storedAst(unitSource);
       } else {
-        logInformation2("Resolution results discarded for ${debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        if (thrownException == null || resultTime >= 0) {
-          //
-          // The analysis was performed on out-of-date sources. Mark the cache so that the sources
-          // will be re-analyzed using the up-to-date sources.
-          //
-          //          if (dartCopy.getState(DartEntry.RESOLVED_UNIT) == CacheState.IN_PROCESS) {
-          //            dartCopy.setState(DartEntry.RESOLVED_UNIT, librarySource, CacheState.INVALID);
-          //          }
-          removeFromParts(unitSource, dartEntry);
-          dartCopy.invalidateAllInformation();
-          dartCopy.modificationTime = sourceTime;
-          _cache.removedAst(unitSource);
-          _workManager.add(unitSource, SourcePriority.UNKNOWN);
-        } else {
-          //
-          // We could not determine whether the sources were up-to-date or out-of-date. Mark the
-          // cache so that we won't attempt to re-analyze the sources until there's a good chance
-          // that we'll be able to do so without error.
-          //
-          dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.ERROR);
-        }
-        dartCopy.exception = thrownException;
-        _cache.put(unitSource, dartCopy);
-        dartEntry = dartCopy;
+        dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.ERROR);
+        _cache.removedAst(unitSource);
       }
+      dartCopy.exception = thrownException;
+      _cache.put(unitSource, dartCopy);
+      dartEntry = dartCopy;
+    } else {
+      logInformation2("Resolution results discarded for ${debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      if (thrownException == null || resultTime >= 0) {
+        //
+        // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+        // will be re-analyzed using the up-to-date sources.
+        //
+        //          if (dartCopy.getState(DartEntry.RESOLVED_UNIT) == CacheState.IN_PROCESS) {
+        //            dartCopy.setState(DartEntry.RESOLVED_UNIT, librarySource, CacheState.INVALID);
+        //          }
+        removeFromParts(unitSource, dartEntry);
+        dartCopy.invalidateAllInformation();
+        dartCopy.modificationTime = sourceTime;
+        _cache.removedAst(unitSource);
+        _workManager.add(unitSource, SourcePriority.UNKNOWN);
+      } else {
+        //
+        // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+        // cache so that we won't attempt to re-analyze the sources until there's a good chance
+        // that we'll be able to do so without error.
+        //
+        dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.ERROR);
+      }
+      dartCopy.exception = thrownException;
+      _cache.put(unitSource, dartCopy);
+      dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return dartEntry;
   }
 
   /**
    * Record the results produced by performing a [ResolveHtmlTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   HtmlEntry recordResolveHtmlTaskResults(ResolveHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
-    {
-      SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        throw new ObsoleteSourceAnalysisException(source);
-      } else if (sourceEntry is! HtmlEntry) {
-        // This shouldn't be possible because we should never have performed the task if the source
-        // didn't represent an HTML file, but check to be safe.
-        throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(source);
+    } else if (sourceEntry is! HtmlEntry) {
+      // This shouldn't be possible because we should never have performed the task if the source
+      // didn't represent an HTML file, but check to be safe.
+      throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+    }
+    htmlEntry = sourceEntry as HtmlEntry;
+    int sourceTime = getModificationStamp(source);
+    int resultTime = task.modificationTime;
+    if (sourceTime == resultTime) {
+      if (htmlEntry.modificationTime != sourceTime) {
+        // The source has changed without the context being notified. Simulate notification.
+        sourceChanged(source);
+        htmlEntry = getReadableHtmlEntry(source);
+        if (htmlEntry == null) {
+          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+        }
       }
-      htmlEntry = sourceEntry as HtmlEntry;
-      int sourceTime = getModificationStamp(source);
-      int resultTime = task.modificationTime;
-      if (sourceTime == resultTime) {
-        if (htmlEntry.modificationTime != sourceTime) {
-          // The source has changed without the context being notified. Simulate notification.
-          sourceChanged(source);
-          htmlEntry = getReadableHtmlEntry(source);
-          if (htmlEntry == null) {
-            throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
-          }
-        }
-        HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-        if (thrownException == null) {
-          htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
-          htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
-          htmlCopy.setValue(HtmlEntry.ELEMENT, task.element);
-          htmlCopy.setValue(HtmlEntry.RESOLUTION_ERRORS, task.resolutionErrors);
-          _cache.storedAst(source);
-          ChangeNoticeImpl notice = getNotice(source);
-          notice.htmlUnit = task.resolvedUnit;
-          notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
-        } else {
-          htmlCopy.recordResolutionError();
-          _cache.removedAst(source);
-        }
-        htmlCopy.exception = thrownException;
-        _cache.put(source, htmlCopy);
-        htmlEntry = htmlCopy;
+      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+      if (thrownException == null) {
+        htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
+        htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
+        htmlCopy.setValue(HtmlEntry.ELEMENT, task.element);
+        htmlCopy.setValue(HtmlEntry.RESOLUTION_ERRORS, task.resolutionErrors);
+        _cache.storedAst(source);
+        ChangeNoticeImpl notice = getNotice(source);
+        notice.htmlUnit = task.resolvedUnit;
+        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
-        logInformation2("Resolution results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
-        HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-        if (thrownException == null || resultTime >= 0) {
-          //
-          // The analysis was performed on out-of-date sources. Mark the cache so that the sources
-          // will be re-analyzed using the up-to-date sources.
-          //
-          //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
-          //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
-          //          }
-          //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
-          //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
-          //          }
-          htmlCopy.invalidateAllInformation();
-          htmlCopy.modificationTime = sourceTime;
-          _cache.removedAst(source);
-        } else {
-          //
-          // We could not determine whether the sources were up-to-date or out-of-date. Mark the
-          // cache so that we won't attempt to re-analyze the sources until there's a good chance
-          // that we'll be able to do so without error.
-          //
-          htmlCopy.recordResolutionError();
-        }
-        htmlCopy.exception = thrownException;
-        _cache.put(source, htmlCopy);
-        htmlEntry = htmlCopy;
+        htmlCopy.recordResolutionError();
+        _cache.removedAst(source);
       }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
+    } else {
+      logInformation2("Resolution results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
+      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+      if (thrownException == null || resultTime >= 0) {
+        //
+        // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+        // will be re-analyzed using the up-to-date sources.
+        //
+        //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
+        //          }
+        //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
+        //          }
+        htmlCopy.invalidateAllInformation();
+        htmlCopy.modificationTime = sourceTime;
+        _cache.removedAst(source);
+      } else {
+        //
+        // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+        // cache so that we won't attempt to re-analyze the sources until there's a good chance
+        // that we'll be able to do so without error.
+        //
+        htmlCopy.recordResolutionError();
+      }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
    * Record the results produced by performing a [ScanDartTask]. If the results were computed
    * from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordScanDartTaskResults(ScanDartTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
-    {
-      SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry == null) {
-        throw new ObsoleteSourceAnalysisException(source);
-      } else if (sourceEntry is! DartEntry) {
-        // This shouldn't be possible because we should never have performed the task if the source
-        // didn't represent a Dart file, but check to be safe.
-        throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(source);
+    } else if (sourceEntry is! DartEntry) {
+      // This shouldn't be possible because we should never have performed the task if the source
+      // didn't represent a Dart file, but check to be safe.
+      throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
+    }
+    dartEntry = sourceEntry as DartEntry;
+    int sourceTime = getModificationStamp(source);
+    int resultTime = task.modificationTime;
+    if (sourceTime == resultTime) {
+      if (dartEntry.modificationTime != sourceTime) {
+        // The source has changed without the context being notified. Simulate notification.
+        sourceChanged(source);
+        dartEntry = getReadableDartEntry(source);
+        if (dartEntry == null) {
+          throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+        }
       }
-      dartEntry = sourceEntry as DartEntry;
-      int sourceTime = getModificationStamp(source);
-      int resultTime = task.modificationTime;
-      if (sourceTime == resultTime) {
-        if (dartEntry.modificationTime != sourceTime) {
-          // The source has changed without the context being notified. Simulate notification.
-          sourceChanged(source);
-          dartEntry = getReadableDartEntry(source);
-          if (dartEntry == null) {
-            throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
-          }
-        }
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        if (thrownException == null) {
-          LineInfo lineInfo = task.lineInfo;
-          dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
-          dartCopy.setValue(DartEntry.TOKEN_STREAM, task.tokenStream);
-          dartCopy.setValue(DartEntry.SCAN_ERRORS, task.errors);
-          _cache.storedAst(source);
-          _workManager.add(source, SourcePriority.NORMAL_PART);
-          ChangeNoticeImpl notice = getNotice(source);
-          notice.setErrors(dartEntry.allErrors, lineInfo);
-        } else {
-          removeFromParts(source, dartEntry);
-          dartCopy.recordScanError();
-          _cache.removedAst(source);
-        }
-        dartCopy.exception = thrownException;
-        _cache.put(source, dartCopy);
-        dartEntry = dartCopy;
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      if (thrownException == null) {
+        LineInfo lineInfo = task.lineInfo;
+        dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
+        dartCopy.setValue(DartEntry.TOKEN_STREAM, task.tokenStream);
+        dartCopy.setValue(DartEntry.SCAN_ERRORS, task.errors);
+        _cache.storedAst(source);
+        _workManager.add(source, SourcePriority.NORMAL_PART);
+        ChangeNoticeImpl notice = getNotice(source);
+        notice.setErrors(dartEntry.allErrors, lineInfo);
       } else {
-        logInformation2("Scan results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        if (thrownException == null || resultTime >= 0) {
-          //
-          // The analysis was performed on out-of-date sources. Mark the cache so that the sources
-          // will be re-analyzed using the up-to-date sources.
-          //
-          //          dartCopy.recordScanNotInProcess();
-          removeFromParts(source, dartEntry);
-          dartCopy.invalidateAllInformation();
-          dartCopy.modificationTime = sourceTime;
-          _cache.removedAst(source);
-          _workManager.add(source, SourcePriority.UNKNOWN);
-        } else {
-          //
-          // We could not determine whether the sources were up-to-date or out-of-date. Mark the
-          // cache so that we won't attempt to re-analyze the sources until there's a good chance
-          // that we'll be able to do so without error.
-          //
-          dartCopy.recordScanError();
-        }
-        dartCopy.exception = thrownException;
-        _cache.put(source, dartCopy);
-        dartEntry = dartCopy;
+        removeFromParts(source, dartEntry);
+        dartCopy.recordScanError();
+        _cache.removedAst(source);
       }
+      dartCopy.exception = thrownException;
+      _cache.put(source, dartCopy);
+      dartEntry = dartCopy;
+    } else {
+      logInformation2("Scan results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      if (thrownException == null || resultTime >= 0) {
+        //
+        // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+        // will be re-analyzed using the up-to-date sources.
+        //
+        //          dartCopy.recordScanNotInProcess();
+        removeFromParts(source, dartEntry);
+        dartCopy.invalidateAllInformation();
+        dartCopy.modificationTime = sourceTime;
+        _cache.removedAst(source);
+        _workManager.add(source, SourcePriority.UNKNOWN);
+      } else {
+        //
+        // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+        // cache so that we won't attempt to re-analyze the sources until there's a good chance
+        // that we'll be able to do so without error.
+        //
+        dartCopy.recordScanError();
+      }
+      dartCopy.exception = thrownException;
+      _cache.put(source, dartCopy);
+      dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return dartEntry;
   }
 
   /**
    * Remove the given library from the list of containing libraries for all of the parts referenced
    * by the given entry.
@@ skipping 158 matching lines @@
    * invalid so that the source will be re-analyzed.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @return `true` if at least one entry was invalid
    */
   bool validateCacheConsistency() {
     int consistencyCheckStart = JavaSystem.nanoTime();
     List<Source> missingSources = new List<Source>();
     int inconsistentCount = 0;
-    {
-      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        Source source = entry.getKey();
-        SourceEntry sourceEntry = entry.getValue();
-        int sourceTime = getModificationStamp(source);
-        if (sourceTime != sourceEntry.modificationTime) {
-          sourceChanged(source);
-          inconsistentCount++;
-        }
-        if (sourceEntry.exception != null) {
-          if (!exists(source)) {
-            missingSources.add(source);
-          }
+    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
+      Source source = entry.getKey();
+      SourceEntry sourceEntry = entry.getValue();
+      int sourceTime = getModificationStamp(source);
+      if (sourceTime != sourceEntry.modificationTime) {
+        sourceChanged(source);
+        inconsistentCount++;
+      }
+      if (sourceEntry.exception != null) {
+        if (!exists(source)) {
+          missingSources.add(source);
         }
       }
     }
     int consistencyCheckEnd = JavaSystem.nanoTime();
     PrintStringWriter writer = new PrintStringWriter();
     writer.print("Consistency check took ");
     writer.print((consistencyCheckEnd - consistencyCheckStart) / 1000000.0);
     writer.println(" ms and found");
     writer.print("  ");
     writer.print(inconsistentCount);
@@ skipping 4752 matching lines @@
 
   void logError2(String message, Exception exception) {
   }
 
   void logInformation(String message) {
   }
 
   void logInformation3(String message, Exception exception) {
   }
 }