Remove cache entry copying

pkg/analyzer/lib/src/generated/engine.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import 'dart:collection';
@@ skipping 394 matching lines @@
    * This method should be used rather than the method [Source#exists] because contexts can
    * have local overrides of the content of a source that the source is not aware of and a source
    * with local content is considered to exist even if there is no file on disk.
    *
    * @param source the source whose modification stamp is to be returned
    * @return `true` if the source exists
    */
   bool exists(Source source);
 
   /**
-   * Create a new context in which analysis can be performed. Any sources in the specified container
-   * will be removed from this context and added to the newly created context.
-   *
-   * @param container the container containing sources that should be removed from this context and
-   *          added to the returned context
-   * @return the analysis context that was created
-   */
-  AnalysisContext extractContext(SourceContainer container);
-
-  /**
    * Return the set of analysis options controlling the behavior of this context. Clients should not
    * modify the returned set of options. The options should only be set by invoking the method
    * [setAnalysisOptions].
    *
    * @return the set of analysis options controlling the behavior of this context
    */
   AnalysisOptions get analysisOptions;
 
   /**
    * Return the Angular application that contains the HTML file defined by the given source, or
@@ skipping 276 matching lines @@
    * to be a library that cannot be run on the server, this method will also return `false` if
    * the source is not known to be a library or if we do not know whether it can be run on the
    * server.
    *
    * @param librarySource the source being tested
    * @return `true` if the given source is known to be a library that can be run on the server
    */
   bool isServerLibrary(Source librarySource);
 
   /**
-   * Add the sources contained in the specified context to this context's collection of sources.
-   * This method is called when an existing context's pubspec has been removed, and the contained
-   * sources should be reanalyzed as part of this context.
-   *
-   * @param context the context being merged
-   */
-  void mergeContext(AnalysisContext context);
-
-  /**
    * Parse a single source to produce an AST structure. The resulting AST structure may or may not
    * be resolved, and may have a slightly different structure depending upon whether it is resolved.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source to be parsed
    * @return the AST structure representing the content of the source
    * @throws AnalysisException if the analysis could not be performed
    */
   CompilationUnit parseCompilationUnit(Source source);
@@ skipping 359 matching lines @@
         SourceEntry sourceEntry = iterator.value;
         if (!source.isInSystemLibrary && (sourceEntry is DartEntry || sourceEntry is HtmlEntry)) {
           sourcesToInvalidate.add(source);
         }
       }
       int count = sourcesToInvalidate.length;
       for (int i = 0; i < count; i++) {
         Source source = sourcesToInvalidate[i];
         SourceEntry entry = _getReadableSourceEntry(source);
         if (entry is DartEntry) {
-          DartEntry dartEntry = entry;
-          DartEntryImpl dartCopy = dartEntry.writableCopy;
-          dartCopy.invalidateAllResolutionInformation(false);
-          _cache.put(source, dartCopy);
-          _workManager.add(source, _computePriority(dartCopy));
+          (entry as DartEntryImpl).invalidateAllResolutionInformation(false);
+          _workManager.add(source, _computePriority(entry));
         } else if (entry is HtmlEntry) {
-          HtmlEntry htmlEntry = entry;
-          HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-          htmlCopy.invalidateAllResolutionInformation(false);
-          _cache.put(source, htmlCopy);
+          (entry as HtmlEntryImpl).invalidateAllResolutionInformation(false);
           _workManager.add(source, SourcePriority.HTML);
         }
       }
     }
   }
 
   @override
   String computeDocumentationComment(Element element) {
     if (element == null) {
       return null;
@@ skipping 116 matching lines @@
         return _getDartScanData2(source, SourceEntry.LINE_INFO, null);
       }
     } on ObsoleteSourceAnalysisException catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Could not compute ${SourceEntry.LINE_INFO.toString()}", exception);
     }
     return null;
   }
 
   @override
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) {
-    DartEntry dartEntry = _getReadableDartEntry(source);
+    DartEntryImpl dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       throw new AnalysisException("computeResolvableCompilationUnit for non-Dart: ${source.fullName}");
     }
     dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
-    DartEntryImpl dartCopy = dartEntry.writableCopy;
-    CompilationUnit unit = dartCopy.resolvableCompilationUnit;
+    CompilationUnit unit = dartEntry.resolvableCompilationUnit;
     if (unit == null) {
       throw new AnalysisException("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", new CaughtException(dartEntry.exception, null));
     }
-    _cache.put(source, dartCopy);
-    return new ResolvableCompilationUnit.con1(dartCopy.modificationTime, unit);
+    return new ResolvableCompilationUnit.con1(dartEntry.modificationTime, unit);
   }
 
   @override
   void dispose() {
     _disposed = true;
   }
 
   @override
   bool exists(Source source) {
     if (source == null) {
       return false;
     }
     if (_contentCache.getContents(source) != null) {
       return true;
     }
     return source.exists();
   }
 
   @override
-  AnalysisContext extractContext(SourceContainer container) => extractContextInto(container, AnalysisEngine.instance.createAnalysisContext() as InternalAnalysisContext);
-
-  @override
-  InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext) {
-    List<Source> sourcesToRemove = new List<Source>();
-    // Move sources in the specified directory to the new context
-    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
-    while (iterator.moveNext()) {
-      Source source = iterator.key;
-      SourceEntry sourceEntry = iterator.value;
-      if (container.contains(source)) {
-        sourcesToRemove.add(source);
-        newContext.addSourceInfo(source, sourceEntry.writableCopy);
-      }
-    }
-    return newContext;
-  }
-
-  @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
   AngularApplication getAngularApplicationWithHtml(Source htmlSource) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       AngularApplication application = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
       if (application != null) {
         return application;
@@ skipping 248 matching lines @@
   }
 
   @override
   List<Source> get prioritySources => _priorityOrder;
 
   @override
   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);
+    DartEntryImpl 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.createPublicNamespaceForLibrary(library);
-      dartEntry = _getReadableDartEntry(source);
       if (dartEntry == null) {
         AnalysisEngine.instance.logger.logError2("Could not compute the public namespace for ${library.source.fullName}", new CaughtException(new AnalysisException("A Dart file became a non-Dart file: ${source.fullName}"), null));
         return null;
       }
       if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
-        DartEntryImpl dartCopy = _getReadableDartEntry(source).writableCopy;
-        dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
-        _cache.put(source, dartCopy);
+        dartEntry.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
       }
     }
     return namespace;
   }
 
   @override
   List<Source> get refactoringUnsafeSources {
     List<Source> sources = new List<Source>();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
@@ skipping 148 matching lines @@
   bool isServerLibrary(Source librarySource) {
     SourceEntry sourceEntry = _getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return !dartEntry.getValue(DartEntry.IS_CLIENT) && dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
     }
     return false;
   }
 
   @override
-  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.
-    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
-    while (iterator.moveNext()) {
-      Source newSource = iterator.key;
-      SourceEntry existingEntry = _getReadableSourceEntry(newSource);
-      if (existingEntry == null) {
-        // TODO(brianwilkerson) Decide whether we really need to copy the info.
-        _cache.put(newSource, iterator.value.writableCopy);
-      } else {
-        // TODO(brianwilkerson) Decide whether/how to merge the entries.
-      }
-    }
-  }
-
-  @override
   CompilationUnit parseCompilationUnit(Source source) => _getDartParseData2(source, DartEntry.PARSED_UNIT, null);
 
   @override
   ht.HtmlUnit parseHtmlUnit(Source source) => _getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
 
   @override
   AnalysisResult performAnalysisTask() {
     if (_TRACE_PERFORM_TASK) {
       print("----------------------------------------");
     }
@@ skipping 54 matching lines @@
 
   @override
   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);
+      DartEntryImpl dartEntry = _getReadableDartEntry(librarySource);
       if (dartEntry != null) {
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        _recordElementData(dartCopy, library, library.source, htmlSource);
-        dartCopy.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
-        dartCopy.setValue(SourceEntry.LINE_INFO, new LineInfo(<int> [0]));
-        dartCopy.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
+        _recordElementData(dartEntry, library, library.source, htmlSource);
+        dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
+        dartEntry.setValue(SourceEntry.LINE_INFO, new LineInfo(<int> [0]));
+        dartEntry.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
         // DartEntry.ELEMENT - set in recordElementData
-        dartCopy.setValue(DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
-        dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
-        dartCopy.setValue(DartEntry.INCLUDED_PARTS, Source.EMPTY_ARRAY);
+        dartEntry.setValue(DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+        dartEntry.setValue(DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+        dartEntry.setValue(DartEntry.INCLUDED_PARTS, Source.EMPTY_ARRAY);
         // DartEntry.IS_CLIENT - set in recordElementData
         // DartEntry.IS_LAUNCHABLE - set in recordElementData
-        dartCopy.setValue(DartEntry.PARSE_ERRORS, AnalysisError.NO_ERRORS);
-        dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
-        dartCopy.setState(DartEntry.PUBLIC_NAMESPACE, CacheState.FLUSHED);
-        dartCopy.setValue(DartEntry.SCAN_ERRORS, AnalysisError.NO_ERRORS);
-        dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
-        dartCopy.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
-        dartCopy.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, AnalysisError.NO_ERRORS);
-        dartCopy.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.FLUSHED);
-        dartCopy.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, AnalysisError.NO_ERRORS);
-        dartCopy.setValueInLibrary(DartEntry.HINTS, librarySource, AnalysisError.NO_ERRORS);
-        _cache.put(librarySource, dartCopy);
+        dartEntry.setValue(DartEntry.PARSE_ERRORS, AnalysisError.NO_ERRORS);
+        dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
+        dartEntry.setState(DartEntry.PUBLIC_NAMESPACE, CacheState.FLUSHED);
+        dartEntry.setValue(DartEntry.SCAN_ERRORS, AnalysisError.NO_ERRORS);
+        dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
+        dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
+        dartEntry.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, AnalysisError.NO_ERRORS);
+        dartEntry.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.FLUSHED);
+        dartEntry.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, AnalysisError.NO_ERRORS);
+        dartEntry.setValueInLibrary(DartEntry.HINTS, librarySource, AnalysisError.NO_ERRORS);
       }
     }
   }
 
   @override
   void removeListener(AnalysisListener listener) {
     _listeners.remove(listener);
   }
 
   @override
@@ skipping 77 matching lines @@
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     _recentTasks.clear();
     _reportedLoop = false;
     String originalContents = _contentCache.setContents(source, contents);
     if (contents != null) {
       if (contents != originalContents) {
         if (_options.incremental) {
           _incrementalAnalysisCache = IncrementalAnalysisCache.update(_incrementalAnalysisCache, source, originalContents, contents, offset, oldLength, newLength, _getReadableSourceEntry(source));
         }
         _sourceChanged(source);
-        SourceEntry sourceEntry = _cache.get(source);
+        SourceEntryImpl 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);
+          sourceEntry.modificationTime = _contentCache.getModificationStamp(source);
+          sourceEntry.setValue(SourceEntry.CONTENT, contents);
         }
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       _sourceChanged(source);
     }
   }
 
   @override
   void setContents(Source source, String contents) {
     _recentTasks.clear();
     _reportedLoop = false;
     String originalContents = _contentCache.setContents(source, contents);
     if (contents != null) {
       if (contents != originalContents) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         _sourceChanged(source);
-        SourceEntry sourceEntry = _cache.get(source);
+        SourceEntryImpl 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);
+          sourceEntry.modificationTime = _contentCache.getModificationStamp(source);
+          sourceEntry.setValue(SourceEntry.CONTENT, contents);
         }
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       _sourceChanged(source);
     }
   }
 
   @override
   void set sourceFactory(SourceFactory factory) {
@@ skipping 35 matching lines @@
    * Record the results produced by performing a [ResolveDartLibraryCycleTask]. 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 recordResolveDartLibraryCycleTaskResults(ResolveDartLibraryCycleTask task) {
     LibraryResolver2 resolver = task.libraryResolver;
     CaughtException thrownException = task.exception;
-    DartEntry unitEntry = null;
+    DartEntryImpl unitEntry = null;
     Source unitSource = task.unitSource;
     if (resolver != null) {
       //
       // The resolver should only be null if an exception was thrown before (or while) it was
       // being created.
       //
       List<ResolvableLibrary> resolvedLibraries = resolver.resolvedLibraries;
       if (resolvedLibraries == null) {
         //
         // The resolved libraries should only be null if an exception was thrown during resolution.
         //
         unitEntry = _getReadableDartEntry(unitSource);
         if (unitEntry == null) {
           throw new AnalysisException("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
-        DartEntryImpl dartCopy = unitEntry.writableCopy;
         if (thrownException == null) {
-          dartCopy.recordResolutionError(new CaughtException(new AnalysisException("In recordResolveDartLibraryCycleTaskResults, resolvedLibraries was null and there was no thrown exception"), null));
+          unitEntry.recordResolutionError(new CaughtException(new AnalysisException("In recordResolveDartLibraryCycleTaskResults, resolvedLibraries was null and there was no thrown exception"), null));
         } else {
-          dartCopy.recordResolutionError(thrownException);
+          unitEntry.recordResolutionError(thrownException);
         }
-        _cache.put(unitSource, dartCopy);
         _cache.remove(unitSource);
         if (thrownException != null) {
           throw new AnalysisException('<rethrow>', thrownException);
         }
-        return dartCopy;
+        return unitEntry;
       }
       if (_allModificationTimesMatch(resolvedLibraries)) {
         Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
         RecordingErrorListener errorListener = resolver.errorListener;
         for (ResolvableLibrary library in resolvedLibraries) {
           Source librarySource = library.librarySource;
           for (Source source in library.compilationUnitSources) {
             CompilationUnit unit = library.getAST(source);
             List<AnalysisError> errors = errorListener.getErrorsForSource(source);
             LineInfo lineInfo = getLineInfo(source);
-            DartEntryImpl dartCopy = _cache.get(source).writableCopy as DartEntryImpl;
+            DartEntryImpl dartEntry = _cache.get(source);
             if (thrownException == null) {
-              dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
-              dartCopy.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit);
-              dartCopy.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
+              dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
+              dartEntry.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit);
+              dartEntry.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
               if (source == librarySource) {
-                _recordElementData(dartCopy, library.libraryElement, librarySource, htmlSource);
+                _recordElementData(dartEntry, library.libraryElement, librarySource, htmlSource);
               }
               _cache.storedAst(source);
             } else {
-              dartCopy.recordResolutionErrorInLibrary(librarySource, thrownException);
+              dartEntry.recordResolutionErrorInLibrary(librarySource, thrownException);
               _cache.remove(source);
             }
-            _cache.put(source, dartCopy);
             if (source != librarySource) {
               _workManager.add(source, SourcePriority.PRIORITY_PART);
             }
             if (source == unitSource) {
-              unitEntry = dartCopy;
+              unitEntry = dartEntry;
             }
             ChangeNoticeImpl notice = _getNotice(source);
             notice.compilationUnit = unit;
-            notice.setErrors(dartCopy.allErrors, lineInfo);
+            notice.setErrors(dartEntry.allErrors, lineInfo);
           }
         }
       } else {
         PrintStringWriter writer = new PrintStringWriter();
         writer.println("Library resolution results discarded for");
         for (ResolvableLibrary library in resolvedLibraries) {
           for (Source source in library.compilationUnitSources) {
-            DartEntry dartEntry = _getReadableDartEntry(source);
+            DartEntryImpl 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();
+                dartEntry.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(thrownException);
+                dartEntry.recordResolutionError(thrownException);
                 _cache.remove(source);
               }
-              _cache.put(source, dartCopy);
               if (source == unitSource) {
-                unitEntry = dartCopy;
+                unitEntry = dartEntry;
               }
             } else {
               writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
             }
           }
         }
         _logInformation(writer.toString());
       }
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', thrownException);
     }
     if (unitEntry == null) {
       unitEntry = _getReadableDartEntry(unitSource);
       if (unitEntry == null) {
         throw new AnalysisException("A Dart file became a non-Dart file: ${unitSource.fullName}");
       }
     }
     return unitEntry;
   }
 
   DartEntry recordResolveDartLibraryTaskResults(ResolveDartLibraryTask task) {
     LibraryResolver resolver = task.libraryResolver;
     CaughtException thrownException = task.exception;
-    DartEntry unitEntry = null;
+    DartEntryImpl unitEntry = null;
     Source unitSource = task.unitSource;
     if (resolver != null) {
       //
       // The resolver should only be null if an exception was thrown before (or while) it was
       // being created.
       //
       Set<Library> resolvedLibraries = resolver.resolvedLibraries;
       if (resolvedLibraries == null) {
         //
         // The resolved libraries should only be null if an exception was thrown during resolution.
         //
         unitEntry = _getReadableDartEntry(unitSource);
         if (unitEntry == null) {
           throw new AnalysisException("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
-        DartEntryImpl dartCopy = unitEntry.writableCopy;
         if (thrownException == null) {
-          dartCopy.recordResolutionError(new CaughtException(new AnalysisException("In recordResolveDartLibraryTaskResults, resolvedLibraries was null and there was no thrown exception"), null));
+          unitEntry.recordResolutionError(new CaughtException(new AnalysisException("In recordResolveDartLibraryTaskResults, resolvedLibraries was null and there was no thrown exception"), null));
         } else {
-          dartCopy.recordResolutionError(thrownException);
+          unitEntry.recordResolutionError(thrownException);
         }
-        _cache.put(unitSource, dartCopy);
         _cache.remove(unitSource);
         if (thrownException != null) {
           throw new AnalysisException('<rethrow>', thrownException);
         }
-        return dartCopy;
+        return unitEntry;
       }
       if (_allModificationTimesMatch2(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.getErrorsForSource(source);
             LineInfo lineInfo = getLineInfo(source);
-            DartEntry dartEntry = _cache.get(source) as DartEntry;
+            DartEntryImpl dartEntry = _cache.get(source);
             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("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.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit);
-              dartCopy.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
+              dartEntry.setValue(SourceEntry.LINE_INFO, lineInfo);
+              dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
+              dartEntry.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit);
+              dartEntry.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
               if (source == librarySource) {
-                _recordElementData(dartCopy, library.libraryElement, librarySource, htmlSource);
+                _recordElementData(dartEntry, library.libraryElement, librarySource, htmlSource);
               }
               _cache.storedAst(source);
             } else {
-              dartCopy.recordResolutionErrorInLibrary(librarySource, thrownException);
+              dartEntry.recordResolutionErrorInLibrary(librarySource, thrownException);
               _cache.remove(source);
             }
-            _cache.put(source, dartCopy);
             if (source != librarySource) {
               _workManager.add(source, SourcePriority.PRIORITY_PART);
             }
             if (source == unitSource) {
-              unitEntry = dartCopy;
+              unitEntry = dartEntry;
             }
             ChangeNoticeImpl notice = _getNotice(source);
             notice.compilationUnit = unit;
-            notice.setErrors(dartCopy.allErrors, lineInfo);
+            notice.setErrors(dartEntry.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);
+            DartEntryImpl 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();
+                dartEntry.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(thrownException);
+                dartEntry.recordResolutionError(thrownException);
                 _cache.remove(source);
               }
-              _cache.put(source, dartCopy);
               if (source == unitSource) {
-                unitEntry = dartCopy;
+                unitEntry = dartEntry;
               }
             } else {
               writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
             }
           }
         }
         _logInformation(writer.toString());
       }
     }
     if (thrownException != null) {
@@ skipping 444 matching lines @@
    * Create a [GenerateDartErrorsTask] for the given source, marking the verification errors
    * as being in-process. The compilation unit and the library can be the same if the compilation
    * unit is the defining compilation unit of the library.
    *
    * @param unitSource the source for the compilation unit to be verified
    * @param unitEntry the entry for the compilation unit
    * @param librarySource the source for the library containing the compilation unit
    * @param libraryEntry the entry for the library
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createGenerateDartErrorsTask(Source unitSource, DartEntry unitEntry, Source librarySource, DartEntry libraryEntry) {
+  AnalysisContextImpl_TaskData _createGenerateDartErrorsTask(Source unitSource, DartEntryImpl unitEntry, Source librarySource, DartEntry libraryEntry) {
     if (unitEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) != CacheState.VALID || libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) {
       return _createResolveDartLibraryTask(librarySource, libraryEntry);
     }
     CompilationUnit unit = unitEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
     if (unit == null) {
       CaughtException exception = new CaughtException(new AnalysisException("Entry has VALID state for RESOLVED_UNIT but null value for ${unitSource.fullName} in ${librarySource.fullName}"), null);
       AnalysisEngine.instance.logger.logInformation2(exception.toString(), exception);
-      DartEntryImpl dartCopy = unitEntry.writableCopy;
-      dartCopy.recordResolutionError(exception);
-      _cache.put(unitSource, dartCopy);
+      unitEntry.recordResolutionError(exception);
       return new AnalysisContextImpl_TaskData(null, false);
     }
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-    DartEntryImpl dartCopy = unitEntry.writableCopy;
-    dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
-    _cache.put(unitSource, dartCopy);
-    return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, unitSource, dartCopy.modificationTime, unit, libraryElement), false);
+    unitEntry.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
+    return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, unitSource, unitEntry.modificationTime, unit, libraryElement), false);
   }
 
   /**
    * Create a [GenerateDartHintsTask] for the given source, marking the hints as being
    * in-process.
    *
    * @param source the source whose content is to be verified
    * @param dartEntry the entry for the source
    * @param librarySource the source for the library containing the source
    * @param libraryEntry the entry for the library
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createGenerateDartHintsTask(Source source, DartEntry dartEntry, Source librarySource, DartEntry libraryEntry) {
+  AnalysisContextImpl_TaskData _createGenerateDartHintsTask(Source source, DartEntryImpl dartEntry, Source librarySource, DartEntry libraryEntry) {
     if (libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) {
       return _createResolveDartLibraryTask(librarySource, libraryEntry);
     }
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
     CompilationUnitElement definingUnit = libraryElement.definingCompilationUnit;
     List<CompilationUnitElement> parts = libraryElement.parts;
     List<TimestampedData<CompilationUnit>> units = new List<TimestampedData>(parts.length + 1);
     units[0] = _getResolvedUnit(definingUnit, librarySource);
     if (units[0] == null) {
       // TODO(brianwilkerson) We should return a ResolveDartUnitTask (unless there are multiple ASTs
       // that need to be resolved.
       return _createResolveDartLibraryTask(librarySource, libraryEntry);
     }
     for (int i = 0; i < parts.length; i++) {
       units[i + 1] = _getResolvedUnit(parts[i], librarySource);
       if (units[i + 1] == null) {
         // TODO(brianwilkerson) We should return a ResolveDartUnitTask (unless there are multiple
         // ASTs that need to be resolved.
         return _createResolveDartLibraryTask(librarySource, libraryEntry);
       }
     }
-    DartEntryImpl dartCopy = dartEntry.writableCopy;
-    dartCopy.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.IN_PROCESS);
-    _cache.put(source, dartCopy);
+    dartEntry.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new GenerateDartHintsTask(this, units, libraryElement), false);
   }
 
   /**
    * Create a [GetContentTask] for the given source, marking the content as being in-process.
    *
    * @param source the source whose content is to be accessed
    * @param sourceEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createGetContentTask(Source source, SourceEntry sourceEntry) {
-    SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
-    sourceCopy.setState(SourceEntry.CONTENT, CacheState.IN_PROCESS);
-    _cache.put(source, sourceCopy);
+  AnalysisContextImpl_TaskData _createGetContentTask(Source source, SourceEntryImpl sourceEntry) {
+    sourceEntry.setState(SourceEntry.CONTENT, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new GetContentTask(this, source), false);
   }
 
   /**
    * Create a [ParseDartTask] for the given source, marking the parse errors as being
    * in-process.
    *
    * @param source the source whose content is to be parsed
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createParseDartTask(Source source, DartEntry dartEntry) {
+  AnalysisContextImpl_TaskData _createParseDartTask(Source source, DartEntryImpl dartEntry) {
     if (dartEntry.getState(DartEntry.TOKEN_STREAM) != CacheState.VALID || dartEntry.getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
       return _createScanDartTask(source, dartEntry);
     }
     Token tokenStream = dartEntry.getValue(DartEntry.TOKEN_STREAM);
-    DartEntryImpl dartCopy = dartEntry.writableCopy;
-    dartCopy.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
-    dartCopy.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
-    _cache.put(source, dartCopy);
-    return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source, dartCopy.modificationTime, tokenStream, dartEntry.getValue(SourceEntry.LINE_INFO)), false);
+    dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
+    dartEntry.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
+    return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source, dartEntry.modificationTime, tokenStream, dartEntry.getValue(SourceEntry.LINE_INFO)), false);
   }
 
   /**
    * Create a [ParseHtmlTask] for the given source, marking the parse errors as being
    * in-process.
    *
    * @param source the source whose content is to be parsed
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createParseHtmlTask(Source source, HtmlEntry htmlEntry) {
+  AnalysisContextImpl_TaskData _createParseHtmlTask(Source source, HtmlEntryImpl htmlEntry) {
     if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, htmlEntry);
     }
     String content = htmlEntry.getValue(SourceEntry.CONTENT);
-    HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-    htmlCopy.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
-    htmlCopy.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
-    _cache.put(source, htmlCopy);
-    return new AnalysisContextImpl_TaskData(new ParseHtmlTask(this, source, htmlCopy.modificationTime, content), false);
+    htmlEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
+    htmlEntry.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
+    return new AnalysisContextImpl_TaskData(new ParseHtmlTask(this, source, htmlEntry.modificationTime, content), false);
   }
 
   /**
    * Create a [PolymerBuildHtmlTask] for the given source, marking the Polymer elements as
    * being in-process.
    *
    * @param source the source whose content is to be processed
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createPolymerBuildHtmlTask(Source source, HtmlEntry htmlEntry) {
+  AnalysisContextImpl_TaskData _createPolymerBuildHtmlTask(Source source, HtmlEntryImpl htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
-    HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-    htmlCopy.setState(HtmlEntry.POLYMER_BUILD_ERRORS, CacheState.IN_PROCESS);
-    _cache.put(source, htmlCopy);
-    return new AnalysisContextImpl_TaskData(new PolymerBuildHtmlTask(this, source, htmlCopy.modificationTime, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT)), false);
+    htmlEntry.setState(HtmlEntry.POLYMER_BUILD_ERRORS, CacheState.IN_PROCESS);
+    return new AnalysisContextImpl_TaskData(new PolymerBuildHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
   }
 
   /**
    * Create a [PolymerResolveHtmlTask] for the given source, marking the Polymer errors as
    * being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createPolymerResolveHtmlTask(Source source, HtmlEntry htmlEntry) {
+  AnalysisContextImpl_TaskData _createPolymerResolveHtmlTask(Source source, HtmlEntryImpl htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
-    HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-    htmlCopy.setState(HtmlEntry.POLYMER_RESOLUTION_ERRORS, CacheState.IN_PROCESS);
-    _cache.put(source, htmlCopy);
-    return new AnalysisContextImpl_TaskData(new PolymerResolveHtmlTask(this, source, htmlCopy.modificationTime, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT)), false);
+    htmlEntry.setState(HtmlEntry.POLYMER_RESOLUTION_ERRORS, CacheState.IN_PROCESS);
+    return new AnalysisContextImpl_TaskData(new PolymerResolveHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
   }
 
   /**
    * Create a [ResolveAngularComponentTemplateTask] for the given source, marking the angular
    * errors as being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createResolveAngularComponentTemplateTask(Source source, HtmlEntry htmlEntry) {
+  AnalysisContextImpl_TaskData _createResolveAngularComponentTemplateTask(Source source, HtmlEntryImpl htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
     AngularApplication application = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
     AngularComponentElement component = htmlEntry.getValue(HtmlEntry.ANGULAR_COMPONENT);
-    HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-    htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.IN_PROCESS);
-    _cache.put(source, htmlCopy);
-    return new AnalysisContextImpl_TaskData(new ResolveAngularComponentTemplateTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT), component, application), false);
+    htmlEntry.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.IN_PROCESS);
+    return new AnalysisContextImpl_TaskData(new ResolveAngularComponentTemplateTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT), component, application), false);
   }
 
   /**
    * Create a [ResolveAngularEntryHtmlTask] for the given source, marking the angular entry as
    * being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createResolveAngularEntryHtmlTask(Source source, HtmlEntry htmlEntry) {
+  AnalysisContextImpl_TaskData _createResolveAngularEntryHtmlTask(Source source, HtmlEntryImpl htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
-    HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-    htmlCopy.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.IN_PROCESS);
-    _cache.put(source, htmlCopy);
-    return new AnalysisContextImpl_TaskData(new ResolveAngularEntryHtmlTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT)), false);
+    htmlEntry.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.IN_PROCESS);
+    return new AnalysisContextImpl_TaskData(new ResolveAngularEntryHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
   }
 
   /**
    * Create a [ResolveDartLibraryTask] for the given source, marking ? as being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createResolveDartLibraryTask(Source source, DartEntry dartEntry) {
+  AnalysisContextImpl_TaskData _createResolveDartLibraryTask(Source source, DartEntryImpl dartEntry) {
     try {
       AnalysisContextImpl_CycleBuilder builder = new AnalysisContextImpl_CycleBuilder(this);
       builder.computeCycleContaining(source);
       AnalysisContextImpl_TaskData taskData = builder.taskData;
       if (taskData != null) {
         return taskData;
       }
       return new AnalysisContextImpl_TaskData(new ResolveDartLibraryCycleTask(this, source, source, builder.librariesInCycle), false);
     } on AnalysisException catch (exception, stackTrace) {
-      DartEntryImpl dartCopy = dartEntry.writableCopy;
-      dartCopy.recordResolutionError(new CaughtException(exception, stackTrace));
-      _cache.put(source, dartCopy);
+      dartEntry.recordResolutionError(new CaughtException(exception, stackTrace));
       AnalysisEngine.instance.logger.logError2("Internal error trying to create a ResolveDartLibraryTask", new CaughtException(exception, stackTrace));
     }
     return new AnalysisContextImpl_TaskData(null, false);
   }
 
   /**
    * Create a [ResolveHtmlTask] for the given source, marking the resolved unit as being
    * in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createResolveHtmlTask(Source source, HtmlEntry htmlEntry) {
+  AnalysisContextImpl_TaskData _createResolveHtmlTask(Source source, HtmlEntryImpl htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.PARSED_UNIT) != CacheState.VALID) {
       return _createParseHtmlTask(source, htmlEntry);
     }
-    HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-    htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.IN_PROCESS);
-    _cache.put(source, htmlCopy);
-    return new AnalysisContextImpl_TaskData(new ResolveHtmlTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.PARSED_UNIT)), false);
+    htmlEntry.setState(HtmlEntry.RESOLVED_UNIT, CacheState.IN_PROCESS);
+    return new AnalysisContextImpl_TaskData(new ResolveHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(HtmlEntry.PARSED_UNIT)), false);
   }
 
   /**
    * Create a [ScanDartTask] for the given source, marking the scan errors as being
    * in-process.
    *
    * @param source the source whose content is to be scanned
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createScanDartTask(Source source, DartEntry dartEntry) {
+  AnalysisContextImpl_TaskData _createScanDartTask(Source source, DartEntryImpl dartEntry) {
     if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, dartEntry);
     }
     String content = dartEntry.getValue(SourceEntry.CONTENT);
-    DartEntryImpl dartCopy = dartEntry.writableCopy;
-    dartCopy.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
-    dartCopy.setState(DartEntry.SCAN_ERRORS, CacheState.IN_PROCESS);
-    _cache.put(source, dartCopy);
-    return new AnalysisContextImpl_TaskData(new ScanDartTask(this, source, dartCopy.modificationTime, content), false);
+    dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
+    dartEntry.setState(DartEntry.SCAN_ERRORS, CacheState.IN_PROCESS);
+    return new AnalysisContextImpl_TaskData(new ScanDartTask(this, source, dartEntry.modificationTime, content), false);
   }
 
   /**
    * Create a source information object suitable for the given source. Return the source information
    * object that was created, or `null` if the source should not be tracked by this context.
    *
    * @param source the source for which an information object is being created
    * @param explicitlyAdded `true` if the source was explicitly added to the context
    * @return the source information object that was created
    */
@@ skipping 424 matching lines @@
       return _createGetContentTask(source, sourceEntry);
     } else if (contentState == CacheState.IN_PROCESS) {
       // We are already in the process of getting the content. There's nothing else we can do with
       // this source until that's complete.
       return new AnalysisContextImpl_TaskData(null, true);
     } else if (contentState == CacheState.ERROR) {
       // We have done all of the analysis we can for this source because we cannot get its content.
       return new AnalysisContextImpl_TaskData(null, false);
     }
     if (sourceEntry is DartEntry) {
-      DartEntry dartEntry = sourceEntry;
+      DartEntryImpl dartEntry = sourceEntry;
       CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS);
       if (scanErrorsState == CacheState.INVALID || (isPriority && scanErrorsState == CacheState.FLUSHED)) {
         return _createScanDartTask(source, dartEntry);
       }
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
       if (parseErrorsState == CacheState.INVALID || (isPriority && parseErrorsState == CacheState.FLUSHED)) {
         return _createParseDartTask(source, dartEntry);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         if (!dartEntry.hasResolvableCompilationUnit) {
           return _createParseDartTask(source, dartEntry);
         }
       }
       SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
       if (kind == SourceKind.UNKNOWN) {
         return _createParseDartTask(source, dartEntry);
       } else if (kind == SourceKind.LIBRARY) {
         CacheState elementState = dartEntry.getState(DartEntry.ELEMENT);
         if (elementState == CacheState.INVALID) {
           return _createResolveDartLibraryTask(source, dartEntry);
         }
       }
       List<Source> librariesContaining = dartEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
       for (Source librarySource in librariesContaining) {
         SourceEntry librarySourceEntry = _cache.get(librarySource);
         if (librarySourceEntry is DartEntry) {
-          DartEntry libraryEntry = librarySourceEntry;
+          DartEntryImpl libraryEntry = librarySourceEntry;
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
           if (elementState == CacheState.INVALID || (isPriority && elementState == CacheState.FLUSHED)) {
             //return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
-            DartEntryImpl libraryCopy = libraryEntry.writableCopy;
-            libraryCopy.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
-            _cache.put(librarySource, libraryCopy);
+            libraryEntry.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
             return new AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false);
           }
           CacheState resolvedUnitState = dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
           if (resolvedUnitState == CacheState.INVALID || (isPriority && resolvedUnitState == CacheState.FLUSHED)) {
             //
             // The commented out lines below are an optimization that doesn't quite work yet. The
             // problem is that if the source was not resolved because it wasn't part of any library,
             // then there won't be any elements in the element model that we can use to resolve it.
             //
             //LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
             //if (libraryElement != null) {
             //  return new ResolveDartUnitTask(this, source, libraryElement);
             //}
             // Possibly replace with: return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
-            DartEntryImpl dartCopy = dartEntry.writableCopy;
-            dartCopy.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.IN_PROCESS);
-            _cache.put(source, dartCopy);
+            dartEntry.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.IN_PROCESS);
             return new AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false);
           }
           if (_generateSdkErrors || !source.isInSystemLibrary) {
             CacheState verificationErrorsState = dartEntry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource);
             if (verificationErrorsState == CacheState.INVALID || (isPriority && verificationErrorsState == CacheState.FLUSHED)) {
               return _createGenerateDartErrorsTask(source, dartEntry, librarySource, libraryEntry);
             }
             if (hintsEnabled) {
               CacheState hintsState = dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource);
               if (hintsState == CacheState.INVALID || (isPriority && hintsState == CacheState.FLUSHED)) {
@@ skipping 290 matching lines @@
    * @param invalidateUris `true` if the cached results of converting URIs to source files
    *          should also be invalidated.
    */
   void _invalidateAllLocalResolutionInformation(bool invalidateUris) {
     HashMap<Source, List<Source>> oldPartMap = new HashMap<Source, List<Source>>();
     MapIterator<Source, SourceEntry> iterator = _privatePartition.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry is HtmlEntry) {
-        HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
-        htmlCopy.invalidateAllResolutionInformation(invalidateUris);
-        iterator.value = htmlCopy;
+        HtmlEntryImpl htmlEntry = sourceEntry;
+        htmlEntry.invalidateAllResolutionInformation(invalidateUris);
+        iterator.value = htmlEntry;
         _workManager.add(source, SourcePriority.HTML);
       } else if (sourceEntry is DartEntry) {
-        DartEntry dartEntry = sourceEntry;
+        DartEntryImpl dartEntry = sourceEntry;
         oldPartMap[source] = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        dartCopy.invalidateAllResolutionInformation(invalidateUris);
-        iterator.value = dartCopy;
-        _workManager.add(source, _computePriority(dartCopy));
+        dartEntry.invalidateAllResolutionInformation(invalidateUris);
+        iterator.value = dartEntry;
+        _workManager.add(source, _computePriority(dartEntry));
       }
     }
     _removeFromPartsUsingMap(oldPartMap);
     _recentTasks.clear();
     _reportedLoop = false;
   }
 
   /**
    * In response to a change to Angular entry point [HtmlElement], invalidate any results that
    * depend on it.
@@ skipping 13 matching lines @@
     _angularApplications.remove(application);
     // invalidate Entry
     entryCopy.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.INVALID);
     // reset HTML sources
     List<AngularElement> oldAngularElements = application.elements;
     for (AngularElement angularElement in oldAngularElements) {
       if (angularElement is AngularHasTemplateElement) {
         AngularHasTemplateElement hasTemplate = angularElement;
         Source templateSource = hasTemplate.templateSource;
         if (templateSource != null) {
-          HtmlEntry htmlEntry = _getReadableHtmlEntry(templateSource);
-          HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-          htmlCopy.setValue(HtmlEntry.ANGULAR_APPLICATION, null);
-          htmlCopy.setValue(HtmlEntry.ANGULAR_COMPONENT, null);
-          htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
-          _cache.put(templateSource, htmlCopy);
+          HtmlEntryImpl htmlEntry = _getReadableHtmlEntry(templateSource);
+          htmlEntry.setValue(HtmlEntry.ANGULAR_APPLICATION, null);
+          htmlEntry.setValue(HtmlEntry.ANGULAR_COMPONENT, null);
+          htmlEntry.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
           _workManager.add(templateSource, SourcePriority.HTML);
         }
       }
     }
     // reset Dart sources
     List<Source> oldElementSources = application.elementSources;
     for (Source elementSource in oldElementSources) {
-      DartEntry dartEntry = _getReadableDartEntry(elementSource);
-      DartEntryImpl dartCopy = dartEntry.writableCopy;
-      dartCopy.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
-      _cache.put(elementSource, dartCopy);
+      DartEntryImpl dartEntry = _getReadableDartEntry(elementSource);
+      dartEntry.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
       // notify about (disappeared) Angular errors
       ChangeNoticeImpl notice = _getNotice(elementSource);
-      notice.setErrors(dartCopy.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
+      notice.setErrors(dartEntry.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
     }
   }
 
   /**
    * In response to a change to at least one of the compilation units in the given library,
    * invalidate any results that are dependent on the result of resolving that library.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be
    * re-accessed after this method returns.
    *
    * @param librarySource the source of the library being invalidated
    */
   void _invalidateLibraryResolution(Source librarySource) {
     // TODO(brianwilkerson) This could be optimized. There's no need to flush all of these entries
     // if the public namespace hasn't changed, which will be a fairly common case. The question is
     // whether we can afford the time to compute the namespace to look for differences.
-    DartEntry libraryEntry = _getReadableDartEntry(librarySource);
+    DartEntryImpl libraryEntry = _getReadableDartEntry(librarySource);
     if (libraryEntry != null) {
       List<Source> includedParts = libraryEntry.getValue(DartEntry.INCLUDED_PARTS);
-      DartEntryImpl libraryCopy = libraryEntry.writableCopy;
-      libraryCopy.invalidateAllResolutionInformation(false);
-      _cache.put(librarySource, libraryCopy);
+      libraryEntry.invalidateAllResolutionInformation(false);
       _workManager.add(librarySource, SourcePriority.LIBRARY);
       for (Source partSource in includedParts) {
         SourceEntry partEntry = _cache.get(partSource);
         if (partEntry is DartEntry) {
-          DartEntryImpl partCopy = partEntry.writableCopy;
-          partCopy.invalidateAllResolutionInformation(false);
-          _cache.put(partSource, partCopy);
+          (partEntry as DartEntryImpl).invalidateAllResolutionInformation(false);
         }
       }
     }
     // invalidate Angular applications
     List<AngularApplication> angularApplicationsCopy = [];
     for (AngularApplication application in angularApplicationsCopy) {
       if (application.dependsOn(librarySource)) {
         Source entryPointSource = application.entryPoint;
-        HtmlEntry entry = _getReadableHtmlEntry(entryPointSource);
-        HtmlEntryImpl entryCopy = entry.writableCopy;
-        _invalidateAngularResolution(entryCopy);
-        _cache.put(entryPointSource, entryCopy);
+        HtmlEntryImpl htmlEntry = _getReadableHtmlEntry(entryPointSource);
+        _invalidateAngularResolution(htmlEntry);
         _workManager.add(entryPointSource, SourcePriority.HTML);
       }
     }
   }
 
   /**
    * Return `true` if this library is, or depends on, dart:html.
    *
    * @param library the library being tested
    * @param visitedLibraries a collection of the libraries that have been visited, used to prevent
@@ skipping 161 matching lines @@
       _angularApplications.add(application);
       // if this is an entry point, then we already resolved it
       entry.setValue(HtmlEntry.ANGULAR_ERRORS, task.entryErrors);
       // schedule HTML templates analysis
       List<AngularElement> newAngularElements = application.elements;
       for (AngularElement angularElement in newAngularElements) {
         if (angularElement is AngularHasTemplateElement) {
           AngularHasTemplateElement hasTemplate = angularElement;
           Source templateSource = hasTemplate.templateSource;
           if (templateSource != null) {
-            HtmlEntry htmlEntry = _getReadableHtmlEntry(templateSource);
-            HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-            htmlCopy.setValue(HtmlEntry.ANGULAR_APPLICATION, application);
+            HtmlEntryImpl htmlEntry = _getReadableHtmlEntry(templateSource);
+            htmlEntry.setValue(HtmlEntry.ANGULAR_APPLICATION, application);
             if (hasTemplate is AngularComponentElement) {
               AngularComponentElement component = hasTemplate;
-              htmlCopy.setValue(HtmlEntry.ANGULAR_COMPONENT, component);
+              htmlEntry.setValue(HtmlEntry.ANGULAR_COMPONENT, component);
             }
-            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
-            _cache.put(templateSource, htmlCopy);
+            htmlEntry.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
             _workManager.add(templateSource, SourcePriority.HTML);
           }
         }
       }
       // update Dart sources errors
       List<Source> newElementSources = application.elementSources;
       for (Source elementSource in newElementSources) {
-        DartEntry dartEntry = _getReadableDartEntry(elementSource);
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
-        dartCopy.setValue(DartEntry.ANGULAR_ERRORS, task.getErrors(elementSource));
-        _cache.put(elementSource, dartCopy);
+        DartEntryImpl dartEntry = _getReadableDartEntry(elementSource);
+        dartEntry.setValue(DartEntry.ANGULAR_ERRORS, task.getErrors(elementSource));
         // notify about Dart errors
         ChangeNoticeImpl notice = _getNotice(elementSource);
-        notice.setErrors(dartCopy.allErrors, computeLineInfo(elementSource));
+        notice.setErrors(dartEntry.allErrors, computeLineInfo(elementSource));
       }
     }
     // remember Angular entry point
     entry.setValue(HtmlEntry.ANGULAR_ENTRY, application);
   }
 
   /**
    * Given a cache entry and a library element, record the library element and other information
    * gleaned from the element in the cache entry.
    *
    * @param dartCopy the cache entry in which data is to be recorded
    * @param library the library element used to record information
    * @param librarySource the source for the library used to record information
    * @param htmlSource the source for the HTML library
    */
-  void _recordElementData(DartEntryImpl dartCopy, LibraryElement library, Source librarySource, Source htmlSource) {
-    dartCopy.setValue(DartEntry.ELEMENT, library);
-    dartCopy.setValue(DartEntry.IS_LAUNCHABLE, library.entryPoint != null);
-    dartCopy.setValue(DartEntry.IS_CLIENT, _isClient(library, htmlSource, new HashSet<LibraryElement>()));
+  void _recordElementData(DartEntryImpl dartEntry, LibraryElement library, Source librarySource, Source htmlSource) {
+    dartEntry.setValue(DartEntry.ELEMENT, library);
+    dartEntry.setValue(DartEntry.IS_LAUNCHABLE, library.entryPoint != null);
+    dartEntry.setValue(DartEntry.IS_CLIENT, _isClient(library, htmlSource, new HashSet<LibraryElement>()));
   }
 
   /**
    * Record the results produced by performing a [GenerateDartErrorsTask]. 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 _recordGenerateDartErrorsTask(GenerateDartErrorsTask task) {
     Source source = task.source;
     Source librarySource = task.libraryElement.source;
     CaughtException thrownException = task.exception;
-    DartEntry dartEntry = null;
+    DartEntryImpl 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("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("A Dart file became a non-Dart file: ${source.fullName}");
         }
       }
-      DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
-        dartCopy.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, task.errors);
+        dartEntry.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, task.errors);
         ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+        notice.setErrors(dartEntry.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
       } else {
-        dartCopy.recordVerificationErrorInLibrary(librarySource, thrownException);
+        dartEntry.recordVerificationErrorInLibrary(librarySource, 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;
+        dartEntry.invalidateAllInformation();
+        dartEntry.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.recordVerificationErrorInLibrary(librarySource, thrownException);
+        dartEntry.recordVerificationErrorInLibrary(librarySource, thrownException);
       }
-      _cache.put(source, dartCopy);
-      dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', 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.
@@ skipping 14 matching lines @@
       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("Internal error: attempting to generate hints for non-Dart file as a Dart file: ${librarySource.fullName}");
       }
       if (thrownException == null) {
         thrownException = new CaughtException(new AnalysisException("GenerateDartHintsTask returned a null hint map without throwing an exception: ${librarySource.fullName}"), null);
       }
-      DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
-      dartCopy.recordHintErrorInLibrary(librarySource, thrownException);
-      _cache.put(librarySource, dartCopy);
+      (sourceEntry as DartEntryImpl).recordHintErrorInLibrary(librarySource, thrownException);
       throw new AnalysisException('<rethrow>', 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("Internal error: attempting to parse non-Dart file as a Dart file: ${unitSource.fullName}");
       }
-      DartEntry dartEntry = sourceEntry as DartEntry;
+      DartEntryImpl dartEntry = sourceEntry;
       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("A Dart file became a non-Dart file: ${unitSource.fullName}");
           }
         }
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null) {
-          dartCopy.setValueInLibrary(DartEntry.HINTS, librarySource, results.data);
+          dartEntry.setValueInLibrary(DartEntry.HINTS, librarySource, results.data);
           ChangeNoticeImpl notice = _getNotice(unitSource);
-          notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+          notice.setErrors(dartEntry.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
         } else {
-          dartCopy.recordHintErrorInLibrary(librarySource, thrownException);
+          dartEntry.recordHintErrorInLibrary(librarySource, thrownException);
         }
-        _cache.put(unitSource, dartCopy);
-        dartEntry = dartCopy;
       } else {
         _logInformation2("Generated hints discarded for ${_debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
         if (dartEntry.getStateInLibrary(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;
+            dartEntry.invalidateAllInformation();
+            dartEntry.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.recordHintErrorInLibrary(librarySource, thrownException);
+            dartEntry.recordHintErrorInLibrary(librarySource, thrownException);
           }
-          _cache.put(unitSource, dartCopy);
-          dartEntry = dartCopy;
         }
       }
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', 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;
     CaughtException thrownException = task.exception;
-    SourceEntry sourceEntry = null;
+    SourceEntryImpl 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);
+      sourceEntry.modificationTime = task.modificationTime;
+      sourceEntry.setValue(SourceEntry.CONTENT, task.content);
     } else {
-      sourceCopy.recordContentError(thrownException);
+      sourceEntry.recordContentError(thrownException);
       _workManager.remove(source);
     }
-    _cache.put(source, sourceCopy);
-    sourceEntry = sourceCopy;
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', thrownException);
     }
     return sourceEntry;
   }
 
   /**
    * Record the results produced by performing a [IncrementalAnalysisTask].
    *
    * @param task the task that was performed
@@ skipping 14 matching lines @@
    * 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;
     CaughtException thrownException = task.exception;
-    DartEntry dartEntry = null;
+    DartEntryImpl 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("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("A Dart file became a non-Dart file: ${source.fullName}");
         }
       }
       _removeFromParts(source, dartEntry);
-      DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         if (task.hasNonPartOfDirective) {
-          dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
-          dartCopy.containingLibrary = source;
+          dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
+          dartEntry.containingLibrary = source;
           _workManager.add(source, SourcePriority.LIBRARY);
         } else if (task.hasPartOfDirective) {
-          dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
-          dartCopy.removeContainingLibrary(source);
+          dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
+          dartEntry.removeContainingLibrary(source);
           _workManager.add(source, SourcePriority.NORMAL_PART);
         } else {
           // The file contains no directives.
-          List<Source> containingLibraries = dartCopy.containingLibraries;
+          List<Source> containingLibraries = dartEntry.containingLibraries;
           if (containingLibraries.length > 1 || (containingLibraries.length == 1 && containingLibraries[0] != source)) {
-            dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
-            dartCopy.removeContainingLibrary(source);
+            dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
+            dartEntry.removeContainingLibrary(source);
             _workManager.add(source, SourcePriority.NORMAL_PART);
           } else {
-            dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
-            dartCopy.containingLibrary = source;
+            dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
+            dartEntry.containingLibrary = source;
             _workManager.add(source, SourcePriority.LIBRARY);
           }
         }
         List<Source> newParts = task.includedSources;
         for (int i = 0; i < newParts.length; i++) {
           Source partSource = newParts[i];
-          DartEntry partEntry = _getReadableDartEntry(partSource);
+          DartEntryImpl partEntry = _getReadableDartEntry(partSource);
           if (partEntry != null && !identical(partEntry, dartEntry)) {
-            DartEntryImpl partCopy = partEntry.writableCopy;
             // TODO(brianwilkerson) Change the kind of the "part" if it was marked as a library
             // and it has no directives.
-            partCopy.addContainingLibrary(source);
-            _cache.put(partSource, partCopy);
+            partEntry.addContainingLibrary(source);
           }
         }
-        dartCopy.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
-        dartCopy.setValue(DartEntry.PARSE_ERRORS, task.errors);
-        dartCopy.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
-        dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
-        dartCopy.setValue(DartEntry.INCLUDED_PARTS, newParts);
+        dartEntry.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
+        dartEntry.setValue(DartEntry.PARSE_ERRORS, task.errors);
+        dartEntry.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
+        dartEntry.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
+        dartEntry.setValue(DartEntry.INCLUDED_PARTS, newParts);
         _cache.storedAst(source);
         ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(dartCopy.allErrors, task.lineInfo);
+        notice.setErrors(dartEntry.allErrors, task.lineInfo);
         // Verify that the incrementally parsed and resolved unit in the incremental cache
         // is structurally equivalent to the fully parsed unit
         _incrementalAnalysisCache = IncrementalAnalysisCache.verifyStructure(_incrementalAnalysisCache, source, task.compilationUnit);
       } else {
         _removeFromParts(source, dartEntry);
-        dartCopy.recordParseError(thrownException);
+        dartEntry.recordParseError(thrownException);
         _cache.removedAst(source);
       }
-      _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;
+        dartEntry.invalidateAllInformation();
+        dartEntry.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(thrownException);
+        dartEntry.recordParseError(thrownException);
       }
-      _cache.put(source, dartCopy);
-      dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', 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;
     CaughtException 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("Internal error: attempting to parse non-HTML file as a HTML file: ${source.fullName}");
     }
-    htmlEntry = sourceEntry as HtmlEntry;
+    HtmlEntryImpl htmlEntry = sourceEntry;
     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("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);
+        htmlEntry.setValue(SourceEntry.LINE_INFO, lineInfo);
+        htmlEntry.setValue(HtmlEntry.PARSED_UNIT, unit);
+        htmlEntry.setValue(HtmlEntry.PARSE_ERRORS, task.errors);
+        htmlEntry.setValue(HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
         _cache.storedAst(source);
         ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(htmlCopy.allErrors, lineInfo);
+        notice.setErrors(htmlEntry.allErrors, lineInfo);
       } else {
-        htmlCopy.recordParseError(thrownException);
+        htmlEntry.recordParseError(thrownException);
         _cache.removedAst(source);
       }
-      _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;
+        htmlEntry.invalidateAllInformation();
+        htmlEntry.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.recordParseError(thrownException);
+        htmlEntry.recordParseError(thrownException);
       }
-      _cache.put(source, htmlCopy);
-      htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', thrownException);
     }
     return htmlEntry;
   }
 
   /**
    * Record the results produced by performing a [PolymerBuildHtmlTask]. 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 _recordPolymerBuildHtmlTaskResults(PolymerBuildHtmlTask task) {
     Source source = task.source;
     CaughtException 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("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
-    htmlEntry = sourceEntry as HtmlEntry;
+    HtmlEntryImpl htmlEntry = sourceEntry;
     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("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
-      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
-        htmlCopy.setValue(HtmlEntry.POLYMER_BUILD_ERRORS, task.errors);
+        htmlEntry.setValue(HtmlEntry.POLYMER_BUILD_ERRORS, task.errors);
         // notify about errors
         ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+        notice.setErrors(htmlEntry.allErrors, htmlEntry.getValue(SourceEntry.LINE_INFO));
       } else {
-        htmlCopy.recordResolutionError(thrownException);
+        htmlEntry.recordResolutionError(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.
         //
-        htmlCopy.invalidateAllInformation();
-        htmlCopy.modificationTime = sourceTime;
+        htmlEntry.invalidateAllInformation();
+        htmlEntry.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(thrownException);
+        htmlEntry.recordResolutionError(thrownException);
       }
-      _cache.put(source, htmlCopy);
-      htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', thrownException);
     }
     return htmlEntry;
   }
 
   /**
    * Record the results produced by performing a [PolymerResolveHtmlTask]. 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 _recordPolymerResolveHtmlTaskResults(PolymerResolveHtmlTask task) {
     Source source = task.source;
     CaughtException 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("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
-    htmlEntry = sourceEntry as HtmlEntry;
+    HtmlEntryImpl htmlEntry = sourceEntry;
     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("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
-      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
-        htmlCopy.setValue(HtmlEntry.POLYMER_RESOLUTION_ERRORS, task.errors);
+        htmlEntry.setValue(HtmlEntry.POLYMER_RESOLUTION_ERRORS, task.errors);
         // notify about errors
         ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+        notice.setErrors(htmlEntry.allErrors, htmlEntry.getValue(SourceEntry.LINE_INFO));
       } else {
-        htmlCopy.recordResolutionError(thrownException);
+        htmlEntry.recordResolutionError(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.
         //
-        htmlCopy.invalidateAllInformation();
-        htmlCopy.modificationTime = sourceTime;
+        htmlEntry.invalidateAllInformation();
+        htmlEntry.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(thrownException);
+        htmlEntry.recordResolutionError(thrownException);
       }
-      _cache.put(source, htmlCopy);
-      htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', 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;
     CaughtException 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("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
-    htmlEntry = sourceEntry as HtmlEntry;
+    HtmlEntryImpl htmlEntry = sourceEntry;
     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("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
-      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
-        htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, task.resolutionErrors);
+        htmlEntry.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));
+        notice.setErrors(htmlEntry.allErrors, htmlEntry.getValue(SourceEntry.LINE_INFO));
       } else {
-        htmlCopy.recordResolutionError(thrownException);
+        htmlEntry.recordResolutionError(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;
+        htmlEntry.invalidateAllInformation();
+        htmlEntry.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(thrownException);
+        htmlEntry.recordResolutionError(thrownException);
       }
-      _cache.put(source, htmlCopy);
-      htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', 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;
     CaughtException thrownException = task.exception;
-    HtmlEntry htmlEntry = null;
+    HtmlEntryImpl 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("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("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);
+        htmlEntry.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
+        _recordAngularEntryPoint(htmlEntry, task);
         _cache.storedAst(source);
         ChangeNoticeImpl notice = _getNotice(source);
         notice.htmlUnit = task.resolvedUnit;
-        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+        notice.setErrors(htmlEntry.allErrors, htmlEntry.getValue(SourceEntry.LINE_INFO));
       } else {
-        htmlCopy.recordResolutionError(thrownException);
+        htmlEntry.recordResolutionError(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;
+        htmlEntry.invalidateAllInformation();
+        htmlEntry.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(thrownException);
+        htmlEntry.recordResolutionError(thrownException);
       }
-      _cache.put(source, htmlCopy);
-      htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', thrownException);
     }
     return htmlEntry;
   }
 
   /**
    * 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;
     CaughtException thrownException = task.exception;
-    DartEntry dartEntry = null;
+    DartEntryImpl 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("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("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
       }
-      DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
-        dartCopy.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, task.resolvedUnit);
+        dartEntry.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, task.resolvedUnit);
         _cache.storedAst(unitSource);
       } else {
-        dartCopy.recordResolutionErrorInLibrary(librarySource, thrownException);
+        dartEntry.recordResolutionErrorInLibrary(librarySource, thrownException);
         _cache.removedAst(unitSource);
       }
-      _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;
+        dartEntry.invalidateAllInformation();
+        dartEntry.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.recordResolutionErrorInLibrary(librarySource, thrownException);
+        dartEntry.recordResolutionErrorInLibrary(librarySource, thrownException);
       }
-      _cache.put(unitSource, dartCopy);
-      dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', 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;
     CaughtException thrownException = task.exception;
-    HtmlEntry htmlEntry = null;
+    HtmlEntryImpl 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("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("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);
+        htmlEntry.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
+        htmlEntry.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
+        htmlEntry.setValue(HtmlEntry.ELEMENT, task.element);
+        htmlEntry.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));
+        notice.setErrors(htmlEntry.allErrors, htmlEntry.getValue(SourceEntry.LINE_INFO));
       } else {
-        htmlCopy.recordResolutionError(thrownException);
+        htmlEntry.recordResolutionError(thrownException);
         _cache.removedAst(source);
       }
-      _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;
+        htmlEntry.invalidateAllInformation();
+        htmlEntry.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(thrownException);
+        htmlEntry.recordResolutionError(thrownException);
       }
-      _cache.put(source, htmlCopy);
-      htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', 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;
     CaughtException thrownException = task.exception;
-    DartEntry dartEntry = null;
+    DartEntryImpl 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("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("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);
+        dartEntry.setValue(SourceEntry.LINE_INFO, lineInfo);
+        dartEntry.setValue(DartEntry.TOKEN_STREAM, task.tokenStream);
+        dartEntry.setValue(DartEntry.SCAN_ERRORS, task.errors);
         _cache.storedAst(source);
         ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(dartEntry.allErrors, lineInfo);
       } else {
         _removeFromParts(source, dartEntry);
-        dartCopy.recordScanError(thrownException);
+        dartEntry.recordScanError(thrownException);
         _cache.removedAst(source);
       }
-      _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;
+        dartEntry.invalidateAllInformation();
+        dartEntry.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(thrownException);
+        dartEntry.recordScanError(thrownException);
       }
-      _cache.put(source, dartCopy);
-      dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', thrownException);
     }
     return dartEntry;
   }
 
   /**
    * Remove the given library from the list of containing libraries for all of the parts referenced
    * by the given entry.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param librarySource the library to be removed
    * @param dartEntry the entry containing the list of included parts
    */
   void _removeFromParts(Source librarySource, DartEntry dartEntry) {
     List<Source> oldParts = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
     for (int i = 0; i < oldParts.length; i++) {
       Source partSource = oldParts[i];
-      DartEntry partEntry = _getReadableDartEntry(partSource);
+      DartEntryImpl partEntry = _getReadableDartEntry(partSource);
       if (partEntry != null && !identical(partEntry, dartEntry)) {
-        DartEntryImpl partCopy = partEntry.writableCopy;
-        partCopy.removeContainingLibrary(librarySource);
-        if (partCopy.containingLibraries.length == 0 && !exists(partSource)) {
+        partEntry.removeContainingLibrary(librarySource);
+        if (partEntry.containingLibraries.length == 0 && !exists(partSource)) {
           _cache.remove(partSource);
-        } else {
-          _cache.put(partSource, partCopy);
         }
       }
     }
   }
 
   /**
    * Remove the given libraries that are keys in the given map from the list of containing libraries
    * for each of the parts in the corresponding value.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param oldPartMap the table containing the parts associated with each library
    */
   void _removeFromPartsUsingMap(HashMap<Source, List<Source>> oldPartMap) {
     for (MapEntry<Source, List<Source>> entry in getMapEntrySet(oldPartMap)) {
       Source librarySource = entry.getKey();
       List<Source> oldParts = entry.getValue();
       for (int i = 0; i < oldParts.length; i++) {
         Source partSource = oldParts[i];
         if (partSource != librarySource) {
-          DartEntry partEntry = _getReadableDartEntry(partSource);
+          DartEntryImpl partEntry = _getReadableDartEntry(partSource);
           if (partEntry != null) {
-            DartEntryImpl partCopy = partEntry.writableCopy;
-            partCopy.removeContainingLibrary(librarySource);
-            if (partCopy.containingLibraries.length == 0 && !exists(partSource)) {
+            partEntry.removeContainingLibrary(librarySource);
+            if (partEntry.containingLibraries.length == 0 && !exists(partSource)) {
               _cache.remove(partSource);
-            } else {
-              _cache.put(partSource, partCopy);
             }
           }
         }
       }
     }
   }
 
   /**
    * Remove the given source from the priority order if it is in the list.
    *
@@ skipping 43 matching lines @@
    * @param source the source that has been changed
    */
   void _sourceChanged(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null || sourceEntry.modificationTime == getModificationStamp(source)) {
       // Either we have removed this source, in which case we don't care that it is changed, or we
       // have already invalidated the cache and don't need to invalidate it again.
       return;
     }
     if (sourceEntry is HtmlEntry) {
-      HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
-      htmlCopy.modificationTime = getModificationStamp(source);
-      _invalidateAngularResolution(htmlCopy);
-      htmlCopy.invalidateAllInformation();
-      _cache.put(source, htmlCopy);
+      HtmlEntryImpl htmlEntry = sourceEntry;
+      htmlEntry.modificationTime = getModificationStamp(source);
+      _invalidateAngularResolution(htmlEntry);
+      htmlEntry.invalidateAllInformation();
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.HTML);
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       HashSet<Source> librariesToInvalidate = new HashSet<Source>();
       for (Source containingLibrary in containingLibraries) {
         _computeAllLibrariesDependingOn(containingLibrary, librariesToInvalidate);
       }
       for (Source library in librariesToInvalidate) {
         _invalidateLibraryResolution(library);
       }
-      _removeFromParts(source, _cache.get(source) as DartEntry);
-      DartEntryImpl dartCopy = (_cache.get(source) as DartEntry).writableCopy;
-      dartCopy.modificationTime = getModificationStamp(source);
-      dartCopy.invalidateAllInformation();
-      _cache.put(source, dartCopy);
+      DartEntryImpl dartEntry = _cache.get(source);
+      _removeFromParts(source, dartEntry);
+      dartEntry.modificationTime = getModificationStamp(source);
+      dartEntry.invalidateAllInformation();
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.UNKNOWN);
     }
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been deleted
    */
   void _sourceDeleted(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is HtmlEntry) {
-      HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
-      _invalidateAngularResolution(htmlCopy);
-      htmlCopy.recordContentError(new CaughtException(new AnalysisException("This source was marked as being deleted"), null));
-      _cache.put(source, htmlCopy);
+      HtmlEntryImpl htmlEntry = sourceEntry;
+      _invalidateAngularResolution(htmlEntry);
+      htmlEntry.recordContentError(new CaughtException(new AnalysisException("This source was marked as being deleted"), null));
     } else if (sourceEntry is DartEntry) {
+      DartEntryImpl dartEntry = sourceEntry;
       HashSet<Source> libraries = new HashSet<Source>();
       for (Source librarySource in getLibrariesContaining(source)) {
         libraries.add(librarySource);
         for (Source dependentLibrary in getLibrariesDependingOn(librarySource)) {
           libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
         _invalidateLibraryResolution(librarySource);
       }
-      DartEntryImpl dartCopy = sourceEntry.writableCopy;
-      dartCopy.recordContentError(new CaughtException(new AnalysisException("This source was marked as being deleted"), null));
-      _cache.put(source, dartCopy);
+      dartEntry.recordContentError(new CaughtException(new AnalysisException("This source was marked as being deleted"), null));
     }
     _workManager.remove(source);
     _removeFromPriorityOrder(source);
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been removed
    */
   void _sourceRemoved(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is HtmlEntry) {
-      HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
-      _invalidateAngularResolution(htmlCopy);
+      _invalidateAngularResolution(sourceEntry);
     } else if (sourceEntry is DartEntry) {
       HashSet<Source> libraries = new HashSet<Source>();
       for (Source librarySource in getLibrariesContaining(source)) {
         libraries.add(librarySource);
         for (Source dependentLibrary in getLibrariesDependingOn(librarySource)) {
           libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
         _invalidateLibraryResolution(librarySource);
@@ skipping 385 matching lines @@
    *          for all of the compilation units in the library
    */
   void _computePartsInLibrary(CycleBuilder_LibraryPair libraryPair) {
     ResolvableLibrary library = libraryPair.library;
     List<CycleBuilder_SourceEntryPair> entryPairs = libraryPair.entryPairs;
     int count = entryPairs.length;
     List<ResolvableCompilationUnit> units = new List<ResolvableCompilationUnit>(count);
     for (int i = 0; i < count; i++) {
       CycleBuilder_SourceEntryPair entryPair = entryPairs[i];
       Source source = entryPair.source;
-      DartEntryImpl dartCopy = entryPair.entry.writableCopy;
-      units[i] = new ResolvableCompilationUnit.con2(dartCopy.modificationTime, dartCopy.resolvableCompilationUnit, source);
-      AnalysisContextImpl_this._cache.put(source, dartCopy);
+      DartEntryImpl dartEntry = entryPair.entry;
+      units[i] = new ResolvableCompilationUnit.con2(dartEntry.modificationTime, dartEntry.resolvableCompilationUnit, source);
     }
     library.resolvableCompilationUnits = units;
   }
 
   /**
    * Create an object to represent the information about the library defined by the compilation
    * unit with the given source.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @return the library object that was created
@@ skipping 2435 matching lines @@
    *
    * @return `true` if a structure was flushed
    */
   bool _flushAstFromCache() {
     Source removedSource = _removeAstToFlush();
     if (removedSource == null) {
       return false;
     }
     SourceEntry sourceEntry = _sourceMap[removedSource];
     if (sourceEntry is HtmlEntry) {
-      HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
-      htmlCopy.flushAstStructures();
-      _sourceMap[removedSource] = htmlCopy;
+      HtmlEntryImpl htmlEntry = sourceEntry;
+      htmlEntry.flushAstStructures();
     } else if (sourceEntry is DartEntry) {
-      DartEntryImpl dartCopy = sourceEntry.writableCopy;
-      dartCopy.flushAstStructures();
-      _sourceMap[removedSource] = dartCopy;
+      DartEntryImpl dartEntry = sourceEntry;
+      dartEntry.flushAstStructures();
     }
     return true;
   }
 
   /**
    * Remove and return one source from the list of recently used sources whose AST structure can be
    * flushed from the cache. The source that will be returned will be the source that has been
    * unreferenced for the longest period of time but that is not a priority for analysis.
    *
    * @return the source that was removed
@@ skipping 641 matching lines @@
    * Return the value of the data represented by the given descriptor in the context of the given
    * library, or `null` if the data represented by the descriptor is not in the cache.
    *
    * @param descriptor the descriptor representing which data is to be returned
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @return the value of the data represented by the given descriptor and library
    */
   Object getValueInLibrary(DataDescriptor descriptor, Source librarySource);
 
-  @override
-  DartEntryImpl get writableCopy;
-
   /**
    * Return `true` if the data represented by the given descriptor is marked as being invalid.
    * If the descriptor represents library-specific data then this method will return `true` if
    * the data associated with any library it marked as invalid.
    *
    * @param descriptor the descriptor representing which data is being tested
    * @return `true` if the data is marked as being invalid
    */
   bool hasInvalidData(DataDescriptor descriptor);
 
@@ skipping 419 matching lines @@
     if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
       return AnalysisError.NO_ERRORS;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       return null;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   @override
-  DartEntryImpl get writableCopy {
-    DartEntryImpl copy = new DartEntryImpl();
-    copy.copyFrom(this);
-    return copy;
-  }
-
-  @override
   bool hasInvalidData(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return _elementState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibrariesState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return _importedLibrariesState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return _includedPartsState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
@@ skipping 552 matching lines @@
     } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
       state._verificationErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._verificationErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.HINTS)) {
       state._hints = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._hintsState = CacheState.VALID;
     }
   }
 
   @override
-  void copyFrom(SourceEntryImpl entry) {
-    super.copyFrom(entry);
-    DartEntryImpl other = entry as DartEntryImpl;
-    _scanErrorsState = other._scanErrorsState;
-    _scanErrors = other._scanErrors;
-    _tokenStreamState = other._tokenStreamState;
-    _tokenStream = other._tokenStream;
-    _sourceKindState = other._sourceKindState;
-    _sourceKind = other._sourceKind;
-    _parsedUnitState = other._parsedUnitState;
-    _parsedUnit = other._parsedUnit;
-    _parsedUnitAccessed = other._parsedUnitAccessed;
-    _parseErrorsState = other._parseErrorsState;
-    _parseErrors = other._parseErrors;
-    _includedPartsState = other._includedPartsState;
-    _includedParts = other._includedParts;
-    _exportedLibrariesState = other._exportedLibrariesState;
-    _exportedLibraries = other._exportedLibraries;
-    _importedLibrariesState = other._importedLibrariesState;
-    _importedLibraries = other._importedLibraries;
-    _containingLibraries = new List<Source>.from(other._containingLibraries);
-    _resolutionState.copyFrom(other._resolutionState);
-    _elementState = other._elementState;
-    _element = other._element;
-    _publicNamespaceState = other._publicNamespaceState;
-    _publicNamespace = other._publicNamespace;
-    _clientServerState = other._clientServerState;
-    _launchableState = other._launchableState;
-    _angularErrors = other._angularErrors;
-  }
-
-  @override
   bool get hasErrorState => super.hasErrorState || _scanErrorsState == CacheState.ERROR || _tokenStreamState == CacheState.ERROR || _sourceKindState == CacheState.ERROR || _parsedUnitState == CacheState.ERROR || _parseErrorsState == CacheState.ERROR || _importedLibrariesState == CacheState.ERROR || _exportedLibrariesState == CacheState.ERROR || _includedPartsState == CacheState.ERROR || _elementState == CacheState.ERROR || _publicNamespaceState == CacheState.ERROR || _clientServerState == CacheState.ERROR || _launchableState == CacheState.ERROR || _resolutionState.hasErrorState;
 
   @override
   bool writeDiffOn(JavaStringBuilder builder, SourceEntry oldEntry) {
     bool needsSeparator = super.writeDiffOn(builder, oldEntry);
     if (oldEntry is! DartEntryImpl) {
       if (needsSeparator) {
         builder.append("; ");
       }
       builder.append("entry type changed; was ${oldEntry.runtimeType.toString()}");
@@ skipping 246 matching lines @@
    */
   CacheState _hintsState = CacheState.INVALID;
 
   /**
    * The hints produced while auditing the compilation unit, or an empty array if the hints are
    * not currently cached.
    */
   List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
 
   /**
-   * Set this state to be exactly like the given state, recursively copying the next state as
-   * necessary.
-   *
-   * @param other the state to be copied
-   */
-  void copyFrom(DartEntryImpl_ResolutionState other) {
-    _librarySource = other._librarySource;
-    _builtUnitState = other._builtUnitState;
-    _builtUnit = other._builtUnit;
-    _buildElementErrorsState = other._buildElementErrorsState;
-    _buildElementErrors = other._buildElementErrors;
-    _resolvedUnitState = other._resolvedUnitState;
-    _resolvedUnit = other._resolvedUnit;
-    _resolutionErrorsState = other._resolutionErrorsState;
-    _resolutionErrors = other._resolutionErrors;
-    _verificationErrorsState = other._verificationErrorsState;
-    _verificationErrors = other._verificationErrors;
-    _hintsState = other._hintsState;
-    _hints = other._hints;
-    if (other._nextState != null) {
-      _nextState = new DartEntryImpl_ResolutionState();
-      _nextState.copyFrom(other._nextState);
-    }
-  }
-
-  /**
    * Flush any AST structures being maintained by this state.
    */
   void flushAstStructures() {
     if (_builtUnitState == CacheState.VALID) {
       _builtUnitState = CacheState.FLUSHED;
       _builtUnit = null;
     }
     if (_resolvedUnitState == CacheState.VALID) {
       _resolvedUnitState = CacheState.FLUSHED;
       _resolvedUnit = null;
@@ skipping 647 matching lines @@
    */
   List<AnalysisError> get allErrors;
 
   /**
    * Return a valid parsed unit, either an unresolved AST structure or the result of resolving the
    * AST structure, or `null` if there is no parsed unit available.
    *
    * @return a valid parsed unit
    */
   ht.HtmlUnit get anyParsedUnit;
-
-  @override
-  HtmlEntryImpl get writableCopy;
 }
 
 /**
  * Instances of the class `HtmlEntryImpl` implement an [HtmlEntry].
  */
 class HtmlEntryImpl extends SourceEntryImpl implements HtmlEntry {
   /**
    * The state of the cached parsed (but not resolved) HTML unit.
    */
   CacheState _parsedUnitState = CacheState.INVALID;
@@ skipping 263 matching lines @@
       return _hints;
     } else if (identical(descriptor, HtmlEntry.POLYMER_BUILD_ERRORS)) {
       return _polymerBuildErrors;
     } else if (identical(descriptor, HtmlEntry.POLYMER_RESOLUTION_ERRORS)) {
       return _polymerResolutionErrors;
     }
     return super.getValue(descriptor);
   }
 
   @override
-  HtmlEntryImpl get writableCopy {
-    HtmlEntryImpl copy = new HtmlEntryImpl();
-    copy.copyFrom(this);
-    return copy;
-  }
-
-  @override
   void invalidateAllInformation() {
     super.invalidateAllInformation();
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.INVALID;
     _parsedUnit = null;
     _parsedUnitState = CacheState.INVALID;
     _resolvedUnit = null;
     _resolvedUnitState = CacheState.INVALID;
     invalidateAllResolutionInformation(true);
   }
@@ skipping 159 matching lines @@
       _polymerBuildErrorsState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.POLYMER_RESOLUTION_ERRORS)) {
       _polymerResolutionErrors = value as List<AnalysisError>;
       _polymerResolutionErrorsState = CacheState.VALID;
     } else {
       super.setValue(descriptor, value);
     }
   }
 
   @override
-  void copyFrom(SourceEntryImpl entry) {
-    super.copyFrom(entry);
-    HtmlEntryImpl other = entry as HtmlEntryImpl;
-    _angularApplicationState = other._angularApplicationState;
-    _angularApplication = other._angularApplication;
-    _angularComponentState = other._angularComponentState;
-    _angularComponent = other._angularComponent;
-    _angularEntryState = other._angularEntryState;
-    _angularEntry = other._angularEntry;
-    _angularErrorsState = other._angularErrorsState;
-    _angularErrors = other._angularErrors;
-    _parseErrorsState = other._parseErrorsState;
-    _parseErrors = other._parseErrors;
-    _parsedUnitState = other._parsedUnitState;
-    _parsedUnit = other._parsedUnit;
-    _resolvedUnitState = other._resolvedUnitState;
-    _resolvedUnit = other._resolvedUnit;
-    _referencedLibrariesState = other._referencedLibrariesState;
-    _referencedLibraries = other._referencedLibraries;
-    _resolutionErrorsState = other._resolutionErrorsState;
-    _resolutionErrors = other._resolutionErrors;
-    _elementState = other._elementState;
-    _element = other._element;
-    _hintsState = other._hintsState;
-    _hints = other._hints;
-    _polymerBuildErrorsState = other._polymerBuildErrorsState;
-    _polymerBuildErrors = other._polymerBuildErrors;
-    _polymerResolutionErrorsState = other._polymerResolutionErrorsState;
-    _polymerResolutionErrors = other._polymerResolutionErrors;
-  }
-
-  @override
   bool get hasErrorState => super.hasErrorState || _parsedUnitState == CacheState.ERROR || _resolvedUnitState == CacheState.ERROR || _parseErrorsState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _referencedLibrariesState == CacheState.ERROR || _elementState == CacheState.ERROR || _angularErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR || _polymerBuildErrorsState == CacheState.ERROR || _polymerResolutionErrorsState == CacheState.ERROR;
 
   @override
   bool writeDiffOn(JavaStringBuilder builder, SourceEntry oldEntry) {
     bool needsSeparator = super.writeDiffOn(builder, oldEntry);
     if (oldEntry is! HtmlEntryImpl) {
       if (needsSeparator) {
         builder.append("; ");
       }
       builder.append("entry type changed; was ${oldEntry.runtimeType.toString()}");
@@ skipping 504 matching lines @@
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.exists(source);
     } finally {
       instrumentation.log();
     }
   }
 
   @override
-  AnalysisContext extractContext(SourceContainer container) {
-    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-extractContext");
-    _checkThread(instrumentation);
-    try {
-      instrumentation.metric3("contextId", _contextId);
-      InstrumentedAnalysisContextImpl newContext = new InstrumentedAnalysisContextImpl();
-      _basis.extractContextInto(container, newContext._basis);
-      return newContext;
-    } finally {
-      instrumentation.log();
-    }
-  }
-
-  @override
-  InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext) => _basis.extractContextInto(container, newContext);
-
-  @override
   AnalysisOptions get analysisOptions {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getAnalysisOptions");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.analysisOptions;
     } finally {
       instrumentation.log();
     }
   }
@@ skipping 371 matching lines @@
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.isServerLibrary(librarySource);
     } finally {
       instrumentation.log();
     }
   }
 
   @override
-  void mergeContext(AnalysisContext context) {
-    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-mergeContext");
-    _checkThread(instrumentation);
-    try {
-      instrumentation.metric3("contextId", _contextId);
-      if (context is InstrumentedAnalysisContextImpl) {
-        context = (context as InstrumentedAnalysisContextImpl)._basis;
-      }
-      _basis.mergeContext(context);
-    } finally {
-      instrumentation.log();
-    }
-  }
-
-  @override
   CompilationUnit parseCompilationUnit(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-parseCompilationUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.parseCompilationUnit(source);
     } on AnalysisException catch (e, stackTrace) {
       _recordAnalysisException(instrumentation, new CaughtException(e, stackTrace));
       throw e;
     } finally {
@@ skipping 191 matching lines @@
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the compilation unit for which an AST structure should be returned
    * @return the AST structure representing the content of the source
    * @throws AnalysisException if the analysis could not be performed
    */
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source);
 
   /**
-   * Initialize the specified context by removing the specified sources from the receiver and adding
-   * them to the specified context.
-   *
-   * @param container the container containing sources that should be removed from this context and
-   *          added to the returned context
-   * @param newContext the context to be initialized
-   * @return the analysis context that was initialized
-   */
-  InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext);
-
-  /**
    * Return context that owns the given source.
    *
    * @param source the source whose context is to be returned
    * @return the context that owns the partition that contains the source
    */
   InternalAnalysisContext getContextFor(Source source);
 
   /**
    * Return an array containing all of the sources that have been marked as priority sources.
    * Clients must not modify the returned array.
@@ skipping 2437 matching lines @@
   CacheState getState(DataDescriptor descriptor);
 
   /**
    * Return the value of the data represented by the given descriptor, or `null` if the data
    * represented by the descriptor is not in the cache.
    *
    * @param descriptor the descriptor representing which data is to be returned
    * @return the value of the data represented by the given descriptor
    */
   Object getValue(DataDescriptor descriptor);
-
-  /**
-   * Return a new entry that is initialized to the same state as this entry but that can be
-   * modified.
-   *
-   * @return a writable copy of this entry
-   */
-  SourceEntryImpl get writableCopy;
 }
 
 /**
  * Instances of the abstract class `SourceEntryImpl` implement the behavior common to all
  * [SourceEntry].
  */
 abstract class SourceEntryImpl implements SourceEntry {
   /**
    * The most recent time at which the state of the source matched the state represented by this
    * entry.
@@ skipping 214 matching lines @@
    *
    * @param indexes the indexes of the flags whose value is to be set to false
    */
   void clearFlags(List<int> indexes) {
     for (int i = 0; i < indexes.length; i++) {
       _flags = BooleanArray.set(_flags, indexes[i], false);
     }
   }
 
   /**
-   * Copy the information from the given cache entry.
-   *
-   * @param entry the cache entry from which information will be copied
-   */
-  void copyFrom(SourceEntryImpl entry) {
-    _modificationTime = entry._modificationTime;
-    _flags = entry._flags;
-    _exception = entry._exception;
-    _contentState = entry._contentState;
-    _content = entry._content;
-    _lineInfoState = entry._lineInfoState;
-    _lineInfo = entry._lineInfo;
-  }
-
-  /**
    * Return the value of the flag with the given index.
    *
    * @param index the index of the flag whose value is to be returned
    * @return the value of the flag with the given index
    */
   bool getFlag(int index) => BooleanArray.get(_flags, index);
 
   /**
    * Return `true` if the state of any data value is [CacheState#ERROR].
    *
@@ skipping 432 matching lines @@
     _index++;
     if (_index >= _manager._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < _manager._workQueues.length && _manager._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }