Remove the 'cache' prefix by hiding the conflicting entities from engine.dart

pkg/analyzer/lib/src/context/context.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.context.context;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/cancelable_future.dart';
-import 'package:analyzer/src/context/cache.dart' as cache;
+import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
-import 'package:analyzer/src/generated/engine.dart' hide WorkManager;
+import 'package:analyzer/src/generated/engine.dart'
+    hide
+        AnalysisCache,
+        CachePartition,
+        SdkCachePartition,
+        UniversalCachePartition,
+        WorkManager;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/html.dart' as ht;
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/task/dart.dart';
@@ skipping 10 matching lines @@
  * the computation can't be performed yet because more analysis is needed,
  * `null` should be returned.
  *
  * The function may also throw an exception, in which case the corresponding
  * future will be completed with failure.
  *
  * Because this function is called while the state of analysis is being updated,
  * it should be free of side effects so that it doesn't cause reentrant changes
  * to the analysis state.
  */
-typedef T PendingFutureComputer<T>(cache.CacheEntry entry);
+typedef T PendingFutureComputer<T>(CacheEntry entry);
 
 /**
  * An [AnalysisContext] in which analysis can be performed.
  */
 class AnalysisContextImpl implements InternalAnalysisContext {
   /**
    * A client-provided name used to identify this context, or `null` if the
    * client has not provided a name.
    */
   String name;
@@ skipping 21 matching lines @@
 
   /**
    * The set of declared variables used when computing constant values.
    */
   DeclaredVariables _declaredVariables = new DeclaredVariables();
 
   /**
    * The partition that contains analysis results that are not shared with other
    * contexts.
    */
-  cache.CachePartition _privatePartition;
+  CachePartition _privatePartition;
 
   /**
    * The cache in which information about the results associated with targets
    * are stored.
    */
-  cache.AnalysisCache _cache;
+  AnalysisCache _cache;
 
   /**
    * The task manager used to manage the tasks used to analyze code.
    */
   TaskManager _taskManager;
 
   /**
    * The [DartWorkManager] instance that performs Dart specific scheduling.
    */
   DartWorkManager dartWorkManager;
@@ skipping 75 matching lines @@
 
   /**
    * A factory to override how [LibraryResolver] is created.
    */
   LibraryResolverFactory libraryResolverFactory;
 
   /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() {
-    _privatePartition = new cache.UniversalCachePartition(this);
+    _privatePartition = new UniversalCachePartition(this);
     _cache = createCacheFromSourceFactory(null);
     _taskManager = AnalysisEngine.instance.taskManager;
     // TODO(scheglov) Get WorkManager(Factory)(s) from plugins.
     dartWorkManager = new DartWorkManager(this);
     driver =
         new AnalysisDriver(_taskManager, <WorkManager>[dartWorkManager], this);
     _onSourcesChangedController =
         new StreamController<SourcesChangedEvent>.broadcast();
   }
 
   @override
-  cache.AnalysisCache get analysisCache => _cache;
+  AnalysisCache get analysisCache => _cache;
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
   void set analysisOptions(AnalysisOptions options) {
     bool needsRecompute = this._options.analyzeFunctionBodiesPredicate !=
             options.analyzeFunctionBodiesPredicate ||
         this._options.generateImplicitErrors !=
             options.generateImplicitErrors ||
@@ skipping 47 matching lines @@
   set contentCache(ContentCache value) {
     _contentCache = value;
   }
 
   @override
   DeclaredVariables get declaredVariables => _declaredVariables;
 
   @override
   List<AnalysisTarget> get explicitTargets {
     List<AnalysisTarget> targets = <AnalysisTarget>[];
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+    MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       if (iterator.value.explicitlyAdded) {
         targets.add(iterator.key);
       }
     }
     return targets;
   }
 
   @override
   List<Source> get htmlSources => _getSources(SourceKind.HTML);
 
   @override
   bool get isDisposed => _disposed;
 
   @override
   List<Source> get launchableClientLibrarySources {
     List<Source> sources = new List<Source>();
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+    MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       AnalysisTarget target = iterator.key;
-      cache.CacheEntry entry = iterator.value;
+      CacheEntry entry = iterator.value;
       if (target is Source &&
           entry.getValue(SOURCE_KIND) == SourceKind.LIBRARY &&
           !target.isInSystemLibrary &&
           isClientLibrary(target)) {
         sources.add(target);
       }
     }
     return sources;
   }
 
   @override
   List<Source> get launchableServerLibrarySources {
     List<Source> sources = new List<Source>();
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+    MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       AnalysisTarget target = iterator.key;
-      cache.CacheEntry entry = iterator.value;
+      CacheEntry entry = iterator.value;
       if (target is Source &&
           entry.getValue(SOURCE_KIND) == SourceKind.LIBRARY &&
           !target.isInSystemLibrary &&
           isServerLibrary(target)) {
         sources.add(target);
       }
     }
     return sources;
   }
 
@@ skipping 32 matching lines @@
     }
     factory.context = this;
     _sourceFactory = factory;
     _cache = createCacheFromSourceFactory(factory);
     _invalidateAllLocalResolutionInformation(true);
   }
 
   @override
   List<Source> get sources {
     List<Source> sources = new List<Source>();
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+    MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       AnalysisTarget target = iterator.key;
       if (target is Source) {
         sources.add(target);
       }
     }
     return sources;
   }
 
   /**
    * Return a list of the sources that would be processed by
    * [performAnalysisTask]. This method duplicates, and must therefore be kept
    * in sync with, [getNextAnalysisTask]. This method is intended to be used for
    * testing purposes only.
    */
   List<Source> get sourcesNeedingProcessing {
     HashSet<Source> sources = new HashSet<Source>();
     bool hintsEnabled = _options.hint;
     bool lintsEnabled = _options.lint;
 
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator =
+    MapIterator<AnalysisTarget, CacheEntry> iterator =
         _privatePartition.iterator();
     while (iterator.moveNext()) {
       AnalysisTarget target = iterator.key;
       if (target is Source) {
         _getSourcesNeedingProcessing(
             target, iterator.value, false, hintsEnabled, lintsEnabled, sources);
       }
     }
     return new List<Source>.from(sources);
   }
@@ skipping 196 matching lines @@
   }
 
   @override
   CancelableFuture<CompilationUnit> computeResolvedCompilationUnitAsync(
       Source unitSource, Source librarySource) {
     if (!AnalysisEngine.isDartFileName(unitSource.shortName) ||
         !AnalysisEngine.isDartFileName(librarySource.shortName)) {
       return new CancelableFuture.error(new AnalysisNotScheduledError());
     }
     return new _AnalysisFutureHelper<CompilationUnit>(this).computeAsync(
-        new LibrarySpecificUnit(librarySource, unitSource),
-        (cache.CacheEntry entry) {
+        new LibrarySpecificUnit(librarySource, unitSource), (CacheEntry entry) {
       CacheState state = entry.getState(RESOLVED_UNIT);
       if (state == CacheState.ERROR) {
         throw entry.exception;
       } else if (state == CacheState.INVALID) {
         return null;
       }
       return entry.getValue(RESOLVED_UNIT);
     });
   }
 
   /**
    * Create an analysis cache based on the given source [factory].
    */
-  cache.AnalysisCache createCacheFromSourceFactory(SourceFactory factory) {
+  AnalysisCache createCacheFromSourceFactory(SourceFactory factory) {
     if (factory == null) {
-      return new cache.AnalysisCache(<cache.CachePartition>[_privatePartition]);
+      return new AnalysisCache(<CachePartition>[_privatePartition]);
     }
     DartSdk sdk = factory.dartSdk;
     if (sdk == null) {
-      return new cache.AnalysisCache(<cache.CachePartition>[_privatePartition]);
+      return new AnalysisCache(<CachePartition>[_privatePartition]);
     }
-    return new cache.AnalysisCache(<cache.CachePartition>[
+    return new AnalysisCache(<CachePartition>[
       AnalysisEngine.instance.partitionManager_new.forSdk(sdk),
       _privatePartition
     ]);
   }
 
   @override
   void dispose() {
     _disposed = true;
     for (List<PendingFuture> pendingFutures in _pendingFutureTargets.values) {
       for (PendingFuture pendingFuture in pendingFutures) {
@@ skipping 38 matching lines @@
     if (source == null) {
       return false;
     }
     if (_contentCache.getContents(source) != null) {
       return true;
     }
     return source.exists();
   }
 
   @override
-  cache.CacheEntry getCacheEntry(AnalysisTarget target) {
-    cache.CacheEntry entry = _cache.get(target);
+  CacheEntry getCacheEntry(AnalysisTarget target) {
+    CacheEntry entry = _cache.get(target);
     if (entry == null) {
-      entry = new cache.CacheEntry(target);
+      entry = new CacheEntry(target);
       _cache.put(entry);
     }
     return entry;
   }
 
   @override
   CompilationUnitElement getCompilationUnitElement(
       Source unitSource, Source librarySource) {
     AnalysisTarget target = new LibrarySpecificUnit(librarySource, unitSource);
     return _cache.getValue(target, COMPILATION_UNIT_ELEMENT);
@@ skipping 81 matching lines @@
   @override
   List<Source> getHtmlFilesReferencing(Source source) {
     SourceKind sourceKind = getKindOf(source);
     if (sourceKind == null) {
       return Source.EMPTY_LIST;
     }
     List<Source> htmlSources = new List<Source>();
     while (true) {
       if (sourceKind == SourceKind.PART) {
         List<Source> librarySources = getLibrariesContaining(source);
-        MapIterator<AnalysisTarget, cache.CacheEntry> iterator =
-            _cache.iterator();
+        MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
         while (iterator.moveNext()) {
-          cache.CacheEntry entry = iterator.value;
+          CacheEntry entry = iterator.value;
           if (entry.getValue(SOURCE_KIND) == SourceKind.HTML) {
             List<Source> referencedLibraries =
                 (entry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
             if (_containsAny(referencedLibraries, librarySources)) {
               htmlSources.add(iterator.key);
             }
           }
         }
       } else {
-        MapIterator<AnalysisTarget, cache.CacheEntry> iterator =
-            _cache.iterator();
+        MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
         while (iterator.moveNext()) {
-          cache.CacheEntry entry = iterator.value;
+          CacheEntry entry = iterator.value;
           if (entry.getValue(SOURCE_KIND) == SourceKind.HTML) {
             List<Source> referencedLibraries =
                 (entry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
             if (_contains(referencedLibraries, source)) {
               htmlSources.add(iterator.key);
             }
           }
         }
       }
       break;
@@ skipping 15 matching lines @@
     return SourceKind.UNKNOWN;
   }
 
   @override
   List<Source> getLibrariesContaining(Source source) {
     SourceKind kind = getKindOf(source);
     if (kind == SourceKind.LIBRARY) {
       return <Source>[source];
     } else if (kind == SourceKind.PART) {
       List<Source> libraries = <Source>[];
-      MapIterator<AnalysisTarget, cache.CacheEntry> iterator =
-          _cache.iterator();
+      MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
       while (iterator.moveNext()) {
         AnalysisTarget target = iterator.key;
         if (target is Source && getKindOf(target) == SourceKind.LIBRARY) {
           List<Source> parts = _cache.getValue(target, INCLUDED_PARTS);
           if (parts.contains(source)) {
             libraries.add(target);
           }
         }
       }
       if (libraries.isNotEmpty) {
         return libraries;
       }
     }
     return Source.EMPTY_ARRAY;
   }
 
   @override
   List<Source> getLibrariesDependingOn(Source librarySource) {
     List<Source> dependentLibraries = new List<Source>();
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+    MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
-      cache.CacheEntry entry = iterator.value;
+      CacheEntry entry = iterator.value;
       if (entry.getValue(SOURCE_KIND) == SourceKind.LIBRARY) {
         if (_contains(entry.getValue(EXPORTED_LIBRARIES), librarySource)) {
           dependentLibraries.add(iterator.key);
         }
         if (_contains(entry.getValue(IMPORTED_LIBRARIES), librarySource)) {
           dependentLibraries.add(iterator.key);
         }
       }
     }
     if (dependentLibraries.isEmpty) {
@@ skipping 39 matching lines @@
     // and it is not used with tasks - instead we compute export namespace once
     // using BuildExportNamespaceTask and reuse in scopes.
     NamespaceBuilder builder = new NamespaceBuilder();
     return builder.createPublicNamespaceForLibrary(library);
   }
 
   /**
    * Return the cache entry associated with the given [target], or `null` if
    * there is no entry associated with the target.
    */
-  cache.CacheEntry getReadableSourceEntryOrNull(AnalysisTarget target) =>
+  CacheEntry getReadableSourceEntryOrNull(AnalysisTarget target) =>
       _cache.get(target);
 
   @override
   CompilationUnit getResolvedCompilationUnit(
       Source unitSource, LibraryElement library) {
     if (library == null ||
         !AnalysisEngine.isDartFileName(unitSource.shortName)) {
       return null;
     }
     return getResolvedCompilationUnit2(unitSource, library.source);
@@ skipping 17 matching lines @@
 //    if (sourceEntry is HtmlEntry) {
 //      HtmlEntry htmlEntry = sourceEntry;
 //      return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
 //    }
     return null;
   }
 
   @override
   List<Source> getSourcesWithFullName(String path) {
     List<Source> sources = <Source>[];
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+    MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       AnalysisTarget target = iterator.key;
       if (target is Source && target.fullName == path) {
         sources.add(target);
       }
     }
     return sources;
   }
 
   @override
   bool handleContentsChanged(
       Source source, String originalContents, String newContents, bool notify) {
-    cache.CacheEntry entry = _cache.get(source);
+    CacheEntry entry = _cache.get(source);
     if (entry == null) {
       return false;
     }
     bool changed = newContents != originalContents;
     if (newContents != null) {
       if (newContents != originalContents) {
         _incrementalAnalysisCache =
             IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         if (!analysisOptions.incremental ||
             !_tryPoorMansIncrementalResolution(source, newContents)) {
           _sourceChanged(source);
         }
         entry.modificationTime = _contentCache.getModificationStamp(source);
-        entry.setValue(CONTENT, newContents, cache.TargetedResult.EMPTY_LIST);
+        entry.setValue(CONTENT, newContents, TargetedResult.EMPTY_LIST);
       } else {
         entry.modificationTime = _contentCache.getModificationStamp(source);
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache =
           IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       changed = newContents != originalContents;
       // We are removing the overlay for the file, check if the file's
       // contents is the same as it was in the overlay.
       try {
         TimestampedData<String> fileContents = getContents(source);
         String fileContentsData = fileContents.data;
         if (fileContentsData == originalContents) {
-          entry.setValue(
-              CONTENT, fileContentsData, cache.TargetedResult.EMPTY_LIST);
+          entry.setValue(CONTENT, fileContentsData, TargetedResult.EMPTY_LIST);
           entry.modificationTime = fileContents.modificationTime;
           changed = false;
         }
       } catch (e) {}
       // If not the same content (e.g. the file is being closed without save),
       // then force analysis.
       if (changed) {
         _sourceChanged(source);
       }
     }
     if (notify && changed) {
       _onSourcesChangedController
           .add(new SourcesChangedEvent.changedContent(source, newContents));
     }
     return changed;
   }
 
   @override
   bool isClientLibrary(Source librarySource) {
-    cache.CacheEntry entry = _cache.get(librarySource);
+    CacheEntry entry = _cache.get(librarySource);
     return entry.getValue(IS_CLIENT) && entry.getValue(IS_LAUNCHABLE);
   }
 
   @override
   bool isServerLibrary(Source librarySource) {
-    cache.CacheEntry entry = _cache.get(librarySource);
+    CacheEntry entry = _cache.get(librarySource);
     return !entry.getValue(IS_CLIENT) && entry.getValue(IS_LAUNCHABLE);
   }
 
   @override
   CompilationUnit parseCompilationUnit(Source source) {
     if (!AnalysisEngine.isDartFileName(source.shortName)) {
       return null;
     }
     return _computeResult(source, PARSED_UNIT);
   }
@@ skipping 25 matching lines @@
       return new AnalysisResult(notices, -1, '', -1);
     });
   }
 
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     elementMap.forEach((Source librarySource, LibraryElement library) {
       //
       // Cache the element in the library's info.
       //
-      cache.CacheEntry entry = getCacheEntry(librarySource);
+      CacheEntry entry = getCacheEntry(librarySource);
       setValue(ResultDescriptor result, value) {
-        entry.setValue(result, value, cache.TargetedResult.EMPTY_LIST);
+        entry.setValue(result, value, TargetedResult.EMPTY_LIST);
       }
       setValue(BUILD_DIRECTIVES_ERRORS, AnalysisError.NO_ERRORS);
       setValue(BUILD_FUNCTION_TYPE_ALIASES_ERRORS, AnalysisError.NO_ERRORS);
       setValue(BUILD_LIBRARY_ERRORS, AnalysisError.NO_ERRORS);
       // CLASS_ELEMENTS
       setValue(COMPILATION_UNIT_ELEMENT, library.definingCompilationUnit);
       // CONSTRUCTORS
       // CONSTRUCTORS_ERRORS
       entry.setState(CONTENT, CacheState.FLUSHED);
       setValue(EXPORTED_LIBRARIES, Source.EMPTY_LIST);
@@ skipping 28 matching lines @@
       entry.setState(RESOLVED_UNIT1, CacheState.FLUSHED);
       entry.setState(RESOLVED_UNIT2, CacheState.FLUSHED);
       entry.setState(RESOLVED_UNIT3, CacheState.FLUSHED);
       entry.setState(RESOLVED_UNIT4, CacheState.FLUSHED);
       entry.setState(RESOLVED_UNIT5, CacheState.FLUSHED);
       // USED_IMPORTED_ELEMENTS
       // USED_LOCAL_ELEMENTS
       setValue(VERIFY_ERRORS, AnalysisError.NO_ERRORS);
     });
 
-    cache.CacheEntry entry = getCacheEntry(AnalysisContextTarget.request);
-    entry.setValue(
-        TYPE_PROVIDER, typeProvider, cache.TargetedResult.EMPTY_LIST);
+    CacheEntry entry = getCacheEntry(AnalysisContextTarget.request);
+    entry.setValue(TYPE_PROVIDER, typeProvider, TargetedResult.EMPTY_LIST);
   }
 
   @override
   void removeListener(AnalysisListener listener) {
     _listeners.remove(listener);
   }
 
   @override
   CompilationUnit resolveCompilationUnit(
       Source unitSource, LibraryElement library) {
@@ skipping 106 matching lines @@
    */
   void visitContentCache(ContentCacheVisitor visitor) {
     _contentCache.accept(visitor);
   }
 
   /**
    * Add all of the sources contained in the given source [container] to the
    * given list of [sources].
    */
   void _addSourcesInContainer(List<Source> sources, SourceContainer container) {
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+    MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
       if (container.contains(source)) {
         sources.add(source);
       }
     }
   }
 
   /**
    * Remove the given [pendingFuture] from [_pendingFutureTargets], since the
    * client has indicated its computation is not needed anymore.
    */
   void _cancelFuture(PendingFuture pendingFuture) {
     List<PendingFuture> pendingFutures =
         _pendingFutureTargets[pendingFuture.target];
     if (pendingFutures != null) {
       pendingFutures.remove(pendingFuture);
       if (pendingFutures.isEmpty) {
         _pendingFutureTargets.remove(pendingFuture.target);
       }
     }
   }
 
   Object /*V*/ _computeResult(
       AnalysisTarget target, ResultDescriptor /*<V>*/ descriptor) {
-    cache.CacheEntry entry = getCacheEntry(target);
+    CacheEntry entry = getCacheEntry(target);
     CacheState state = entry.getState(descriptor);
     if (state == CacheState.FLUSHED || state == CacheState.INVALID) {
       driver.computeResult(target, descriptor);
     }
     state = entry.getState(descriptor);
     if (state == CacheState.ERROR) {
       throw new AnalysisException(
           'Cannot compute $descriptor for $target', entry.exception);
     }
     return entry.getValue(descriptor);
@@ skipping 46 matching lines @@
     if (contents != null) {
       if (contents != originalContents) {
         // TODO(brianwilkerson) Find a better way to do incremental analysis.
 //        if (_options.incremental) {
 //          _incrementalAnalysisCache = IncrementalAnalysisCache.update(
 //              _incrementalAnalysisCache, source, originalContents, contents,
 //              offset, oldLength, newLength, _cache.get(source));
 //        }
         _sourceChanged(source);
         changed = true;
-        cache.CacheEntry entry = _cache.get(source);
+        CacheEntry entry = _cache.get(source);
         if (entry != null) {
           entry.modificationTime = _contentCache.getModificationStamp(source);
-          entry.setValue(CONTENT, contents, cache.TargetedResult.EMPTY_LIST);
+          entry.setValue(CONTENT, contents, TargetedResult.EMPTY_LIST);
         }
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache =
           IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       _sourceChanged(source);
       changed = true;
     }
     return changed;
   }
 
   /**
    * Set the contents of the given [source] to the given [contents] and mark the
    * source as having changed. This has the effect of overriding the default
    * contents of the source. If the contents are `null` the override is removed
    * so that the default contents will be returned. If [notify] is true, a
    * source changed event is triggered.
    */
   void _contentsChanged(Source source, String contents, bool notify) {
     String originalContents = _contentCache.setContents(source, contents);
     handleContentsChanged(source, originalContents, contents, notify);
   }
 
   /**
    * Create a cache entry for the given [source]. The source was explicitly
    * added to this context if [explicitlyAdded] is `true`. Return the cache
    * entry that was created.
    */
-  cache.CacheEntry _createCacheEntry(Source source, bool explicitlyAdded) {
-    cache.CacheEntry entry = new cache.CacheEntry(source);
+  CacheEntry _createCacheEntry(Source source, bool explicitlyAdded) {
+    CacheEntry entry = new CacheEntry(source);
     entry.modificationTime = getModificationStamp(source);
     entry.explicitlyAdded = explicitlyAdded;
     _cache.put(entry);
     return entry;
   }
 
   /**
    * Return a list containing all of the cache entries for targets associated
    * with the given [source].
    */
-  List<cache.CacheEntry> _entriesFor(Source source) {
-    List<cache.CacheEntry> entries = <cache.CacheEntry>[];
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+  List<CacheEntry> _entriesFor(Source source) {
+    List<CacheEntry> entries = <CacheEntry>[];
+    MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       if (iterator.key.source == source) {
         entries.add(iterator.value);
       }
     }
     return entries;
   }
 
   /**
    * Return a list containing all of the change notices that are waiting to be
@@ skipping 25 matching lines @@
     }
     return notice;
   }
 
   /**
    * Return a list containing all of the sources known to this context that have
    * the given [kind].
    */
   List<Source> _getSources(SourceKind kind) {
     List<Source> sources = new List<Source>();
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+    MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       if (iterator.value.getValue(SOURCE_KIND) == kind &&
           iterator.key is Source) {
         sources.add(iterator.key);
       }
     }
     return sources;
   }
 
   /**
    * Look at the given [source] to see whether a task needs to be performed
    * related to it. If so, add the source to the set of sources that need to be
    * processed. This method is intended to be used for testing purposes only.
    */
-  void _getSourcesNeedingProcessing(Source source, cache.CacheEntry entry,
+  void _getSourcesNeedingProcessing(Source source, CacheEntry entry,
       bool isPriority, bool hintsEnabled, bool lintsEnabled,
       HashSet<Source> sources) {
     CacheState state = entry.getState(CONTENT);
     if (state == CacheState.INVALID ||
         (isPriority && state == CacheState.FLUSHED)) {
       sources.add(source);
       return;
     } else if (state == CacheState.ERROR) {
       return;
     }
@@ skipping 23 matching lines @@
       } else if (state == CacheState.ERROR) {
         return;
       }
 //      if (isPriority) {
 //        if (!entry.hasResolvableCompilationUnit) {
 //          sources.add(source);
 //          return;
 //        }
 //      }
       for (Source librarySource in getLibrariesContaining(source)) {
-        cache.CacheEntry libraryEntry = _cache.get(librarySource);
+        CacheEntry libraryEntry = _cache.get(librarySource);
         state = libraryEntry.getState(LIBRARY_ELEMENT);
         if (state == CacheState.INVALID ||
             (isPriority && state == CacheState.FLUSHED)) {
           sources.add(source);
           return;
         } else if (state == CacheState.ERROR) {
           return;
         }
-        cache.CacheEntry unitEntry =
+        CacheEntry unitEntry =
             _cache.get(new LibrarySpecificUnit(librarySource, source));
         state = unitEntry.getState(RESOLVED_UNIT);
         if (state == CacheState.INVALID ||
             (isPriority && state == CacheState.FLUSHED)) {
           sources.add(source);
           return;
         } else if (state == CacheState.ERROR) {
           return;
         }
         if (_shouldErrorsBeAnalyzed(source, unitEntry)) {
@@ skipping 129 matching lines @@
     }
     if (newOrder.length < count) {
       analysisPriorityOrder = newOrder;
     }
   }
 
   /**
    * Return `true` if errors should be produced for the given [source]. The
    * [entry] associated with the source is passed in for efficiency.
    */
-  bool _shouldErrorsBeAnalyzed(Source source, cache.CacheEntry entry) {
+  bool _shouldErrorsBeAnalyzed(Source source, CacheEntry entry) {
     if (source.isInSystemLibrary) {
       return _options.generateSdkErrors;
     } else if (!entry.explicitlyAdded) {
       return _options.generateImplicitErrors;
     } else {
       return true;
     }
   }
 
   /**
    * Create an entry for the newly added [source] and invalidate any sources
    * that referenced the source before it existed.
    */
   void _sourceAvailable(Source source) {
-    cache.CacheEntry entry = _cache.get(source);
+    CacheEntry entry = _cache.get(source);
     if (entry == null) {
       _createCacheEntry(source, true);
     } else {
       // TODO(brianwilkerson) Implement this.
 //      _propagateInvalidation(source, entry);
     }
   }
 
   /**
    * Invalidate the [source] that was changed and any sources that referenced
    * the source before it existed.
    */
   void _sourceChanged(Source source) {
-    cache.CacheEntry entry = _cache.get(source);
+    CacheEntry entry = _cache.get(source);
     // If the source is removed, we don't care about it.
     if (entry == null) {
       return;
     }
     // Check whether the content of the source is the same as it was the last
     // time.
     String sourceContent = entry.getValue(CONTENT);
     if (sourceContent != null) {
       entry.setState(CONTENT, CacheState.FLUSHED);
       try {
         TimestampedData<String> fileContents = getContents(source);
         if (fileContents.data == sourceContent) {
           int time = fileContents.modificationTime;
-          for (cache.CacheEntry entry in _entriesFor(source)) {
+          for (CacheEntry entry in _entriesFor(source)) {
             entry.modificationTime = time;
           }
           return;
         }
       } catch (e) {}
     }
     // We need to invalidate the cache.
     // TODO(brianwilkerson) Implement this.
 //    _propagateInvalidation(source, entry);
   }
@@ skipping 104 matching lines @@
   /**
    * Check the cache for any invalid entries (entries whose modification time
    * does not match the modification time of the source associated with the
    * entry). Invalid entries will be marked as invalid so that the source will
    * be re-analyzed. Return `true` if at least one entry was invalid.
    */
   bool _validateCacheConsistency() {
     int consistencyCheckStart = JavaSystem.nanoTime();
     HashSet<Source> changedSources = new HashSet<Source>();
     HashSet<Source> missingSources = new HashSet<Source>();
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+    MapIterator<AnalysisTarget, CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key.source;
       if (source != null) {
-        cache.CacheEntry entry = iterator.value;
+        CacheEntry entry = iterator.value;
         int sourceTime = getModificationStamp(source);
         if (sourceTime != entry.modificationTime) {
           changedSources.add(source);
         }
         if (entry.exception != null) {
           if (!exists(source)) {
             missingSources.add(source);
           }
         }
       }
@@ skipping 34 matching lines @@
 }
 
 /**
  * An object that manages the partitions that can be shared between analysis
  * contexts.
  */
 class PartitionManager {
   /**
    * A table mapping SDK's to the partitions used for those SDK's.
    */
-  HashMap<DartSdk, cache.SdkCachePartition> _sdkPartitions =
-      new HashMap<DartSdk, cache.SdkCachePartition>();
+  HashMap<DartSdk, SdkCachePartition> _sdkPartitions =
+      new HashMap<DartSdk, SdkCachePartition>();
 
   /**
    * Clear any cached data being maintained by this manager.
    */
   void clearCache() {
     _sdkPartitions.clear();
   }
 
   /**
    * Return the partition being used for the given [sdk], creating the partition
    * if necessary.
    */
-  cache.SdkCachePartition forSdk(DartSdk sdk) {
+  SdkCachePartition forSdk(DartSdk sdk) {
     // Call sdk.context now, because when it creates a new
     // InternalAnalysisContext instance, it calls forSdk() again, so creates an
     // SdkCachePartition instance.
     // So, if we initialize context after "partition == null", we end up
     // with two SdkCachePartition instances.
     InternalAnalysisContext sdkContext = sdk.context;
     // Check cache for an existing partition.
-    cache.SdkCachePartition partition = _sdkPartitions[sdk];
+    SdkCachePartition partition = _sdkPartitions[sdk];
     if (partition == null) {
-      partition = new cache.SdkCachePartition(sdkContext);
+      partition = new SdkCachePartition(sdkContext);
       _sdkPartitions[sdk] = partition;
     }
     return partition;
   }
 }
 
 /**
  * Representation of a pending computation which is based on the results of
  * analysis that may or may not have been completed.
  */
@@ skipping 33 matching lines @@
    * the pending future if it's appropriate to do so.  If the pending future is
    * completed by this call, true is returned; otherwise false is returned.
    *
    * Once this function has returned true, it should not be called again.
    *
    * Other than completing the future, this method is free of side effects.
    * Note that any code the client has attached to the future will be executed
    * in a microtask, so there is no danger of side effects occurring due to
    * client callbacks.
    */
-  bool evaluate(cache.CacheEntry entry) {
+  bool evaluate(CacheEntry entry) {
     assert(!_completer.isCompleted);
     try {
       T result = _computeValue(entry);
       if (result == null) {
         return false;
       } else {
         _completer.complete(result);
         return true;
       }
     } catch (exception, stackTrace) {
@@ skipping 39 matching lines @@
    *
    * If the [computeValue] still returns `null` after there is no further
    * analysis to be done for [target], then the future will be completed with
    * the error AnalysisNotScheduledError.
    *
    * Since [computeValue] will be called while the state of analysis is being
    * updated, it should be free of side effects so that it doesn't cause
    * reentrant changes to the analysis state.
    */
   CancelableFuture<T> computeAsync(
-      AnalysisTarget target, T computeValue(cache.CacheEntry entry)) {
+      AnalysisTarget target, T computeValue(CacheEntry entry)) {
     if (_context.isDisposed) {
       // No further analysis is expected, so return a future that completes
       // immediately with AnalysisNotScheduledError.
       return new CancelableFuture.error(new AnalysisNotScheduledError());
     }
-    cache.CacheEntry entry = _context.getReadableSourceEntryOrNull(target);
+    CacheEntry entry = _context.getReadableSourceEntryOrNull(target);
     if (entry == null) {
       return new CancelableFuture.error(new AnalysisNotScheduledError());
     }
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, target, computeValue);
     if (!pendingFuture.evaluate(entry)) {
       _context._pendingFutureTargets
           .putIfAbsent(target, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }