Add AnalysisCache.getState() and getValue().

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';
@@ skipping 195 matching lines @@
 
   @override
   void set analysisOptions(AnalysisOptions options) {
     bool needsRecompute = this._options.analyzeFunctionBodiesPredicate !=
             options.analyzeFunctionBodiesPredicate ||
         this._options.generateImplicitErrors !=
             options.generateImplicitErrors ||
         this._options.generateSdkErrors != options.generateSdkErrors ||
         this._options.dart2jsHint != options.dart2jsHint ||
         (this._options.hint && !options.hint) ||
-        (this._options.lint && !options.lint) || 
+        (this._options.lint && !options.lint) ||
         this._options.preserveComments != options.preserveComments ||
         this._options.enableNullAwareOperators !=
             options.enableNullAwareOperators ||
         this._options.enableStrictCallChecks != options.enableStrictCallChecks;
     int cacheSize = options.cacheSize;
     if (this._options.cacheSize != cacheSize) {
       this._options.cacheSize = cacheSize;
     }
     this._options.analyzeFunctionBodiesPredicate =
         options.analyzeFunctionBodiesPredicate;
@@ skipping 410 matching lines @@
   }
 
   @override
   List<CompilationUnit> ensureResolvedDartUnits(Source unitSource) {
     // Check every library.
     List<CompilationUnit> units = <CompilationUnit>[];
     List<Source> containingLibraries = getLibrariesContaining(unitSource);
     for (Source librarySource in containingLibraries) {
       LibrarySpecificUnit target =
           new LibrarySpecificUnit(librarySource, unitSource);
-      CompilationUnit unit = _getResult(target, RESOLVED_UNIT);
+      CompilationUnit unit = _cache.getValue(target, RESOLVED_UNIT);
       if (unit == null) {
         units = null;
         break;
       }
       units.add(unit);
     }
     // If we have results, then we're done.
     if (units != null) {
       return units;
     }
     // Schedule recomputing RESOLVED_UNIT results.
     for (Source librarySource in containingLibraries) {
       LibrarySpecificUnit target =
           new LibrarySpecificUnit(librarySource, unitSource);
-      if (_getResultState(target, RESOLVED_UNIT) == CacheState.FLUSHED) {
+      if (_cache.getState(target, RESOLVED_UNIT) == CacheState.FLUSHED) {
         dartWorkManager.addPriorityResult(target, RESOLVED_UNIT);
       }
     }
     return null;
   }
 
   @override
   bool exists(Source source) {
     if (source == null) {
       return false;
@@ skipping 11 matching lines @@
       entry = new cache.CacheEntry(target);
       _cache.put(entry);
     }
     return entry;
   }
 
   @override
   CompilationUnitElement getCompilationUnitElement(
       Source unitSource, Source librarySource) {
     AnalysisTarget target = new LibrarySpecificUnit(librarySource, unitSource);
-    return _getResult(target, COMPILATION_UNIT_ELEMENT);
+    return _cache.getValue(target, COMPILATION_UNIT_ELEMENT);
   }
 
   @override
   TimestampedData<String> getContents(Source source) {
     String contents = _contentCache.getContents(source);
     if (contents != null) {
       return new TimestampedData<String>(
           _contentCache.getModificationStamp(source), contents);
     }
     return source.contents;
@@ skipping 34 matching lines @@
   }
 
   @override
   AnalysisErrorInfo getErrors(Source source) {
     // TODO(brianwilkerson) Figure out how to implement this cleanly. The
     // problem is that _getResult doesn't know to go into the individual inputs
     // for the task to get their values for tasks that are just merging other
     // result values. Therefore, if some, but not all, of the error lists have
     // been computed, no errors will be returned by it.
     List<List<AnalysisError>> errorLists = <List<AnalysisError>>[];
-    errorLists.add(_getResult(source, BUILD_DIRECTIVES_ERRORS));
-    errorLists.add(_getResult(source, BUILD_LIBRARY_ERRORS));
-    errorLists.add(_getResult(source, PARSE_ERRORS));
-    errorLists.add(_getResult(source, SCAN_ERRORS));
+    errorLists.add(_cache.getValue(source, BUILD_DIRECTIVES_ERRORS));
+    errorLists.add(_cache.getValue(source, BUILD_LIBRARY_ERRORS));
+    errorLists.add(_cache.getValue(source, PARSE_ERRORS));
+    errorLists.add(_cache.getValue(source, SCAN_ERRORS));
     for (Source library in getLibrariesContaining(source)) {
       LibrarySpecificUnit unit = new LibrarySpecificUnit(library, source);
-      errorLists.add(_getResult(unit, BUILD_FUNCTION_TYPE_ALIASES_ERRORS));
-      errorLists.add(_getResult(unit, HINTS));
-      errorLists.add(_getResult(unit, RESOLVE_REFERENCES_ERRORS));
-      errorLists.add(_getResult(unit, RESOLVE_TYPE_NAMES_ERRORS));
-      errorLists.add(_getResult(unit, VERIFY_ERRORS));
+      errorLists.add(_cache.getValue(unit, BUILD_FUNCTION_TYPE_ALIASES_ERRORS));
+      errorLists.add(_cache.getValue(unit, HINTS));
+      errorLists.add(_cache.getValue(unit, RESOLVE_REFERENCES_ERRORS));
+      errorLists.add(_cache.getValue(unit, RESOLVE_TYPE_NAMES_ERRORS));
+      errorLists.add(_cache.getValue(unit, VERIFY_ERRORS));
     }
-    LineInfo lineInfo = _getResult(source, LINE_INFO);
+    LineInfo lineInfo = _cache.getValue(source, LINE_INFO);
     return new AnalysisErrorInfoImpl(
         AnalysisError.mergeLists(errorLists), lineInfo);
   }
 
   @override
   HtmlElement getHtmlElement(Source source) {
     // TODO(brianwilkerson) Implement this.
 //    SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
 //    if (sourceEntry is HtmlEntry) {
 //      return sourceEntry.getValue(HtmlEntry.ELEMENT);
@@ skipping 42 matching lines @@
     if (htmlSources.isEmpty) {
       return Source.EMPTY_LIST;
     }
     return htmlSources;
   }
 
   @override
   SourceKind getKindOf(Source source) {
     String name = source.shortName;
     if (AnalysisEngine.isDartFileName(name)) {
-      return _getResult(source, SOURCE_KIND);
+      return _cache.getValue(source, SOURCE_KIND);
     } else if (AnalysisEngine.isHtmlFileName(name)) {
       return SourceKind.HTML;
     }
     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();
       while (iterator.moveNext()) {
         AnalysisTarget target = iterator.key;
         if (target is Source && getKindOf(target) == SourceKind.LIBRARY) {
-          List<Source> parts = _getResult(target, INCLUDED_PARTS);
+          List<Source> parts = _cache.getValue(target, INCLUDED_PARTS);
           if (parts.contains(source)) {
             libraries.add(target);
           }
         }
       }
       if (libraries.isNotEmpty) {
         return libraries;
       }
     }
     return Source.EMPTY_ARRAY;
@@ skipping 26 matching lines @@
 //    cache.CacheEntry entry = getReadableSourceEntryOrNull(htmlSource);
 //    if (entry is HtmlEntry) {
 //      HtmlEntry htmlEntry = entry;
 //      return htmlEntry.getValue(HtmlEntry.REFERENCED_LIBRARIES);
 //    }
     return Source.EMPTY_LIST;
   }
 
   @override
   LibraryElement getLibraryElement(Source source) =>
-      _getResult(source, LIBRARY_ELEMENT);
+      _cache.getValue(source, LIBRARY_ELEMENT);
 
   @override
-  LineInfo getLineInfo(Source source) => _getResult(source, LINE_INFO);
+  LineInfo getLineInfo(Source source) => _cache.getValue(source, LINE_INFO);
 
   @override
   int getModificationStamp(Source source) {
     int stamp = _contentCache.getModificationStamp(source);
     if (stamp != null) {
       return stamp;
     }
     return source.modificationStamp;
   }
 
@@ skipping 27 matching lines @@
     return getResolvedCompilationUnit2(unitSource, library.source);
   }
 
   @override
   CompilationUnit getResolvedCompilationUnit2(
       Source unitSource, Source librarySource) {
     if (!AnalysisEngine.isDartFileName(unitSource.shortName) ||
         !AnalysisEngine.isDartFileName(librarySource.shortName)) {
       return null;
     }
-    return _getResult(
+    return _cache.getValue(
         new LibrarySpecificUnit(librarySource, unitSource), RESOLVED_UNIT);
   }
 
   @override
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
     // TODO(brianwilkerson) Implement this.
 //    SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource);
 //    if (sourceEntry is HtmlEntry) {
 //      HtmlEntry htmlEntry = sourceEntry;
 //      return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
@@ skipping 504 matching lines @@
   ChangeNoticeImpl _getNotice(Source source) {
     // Used in commented out code.
     ChangeNoticeImpl notice = _pendingNotices[source];
     if (notice == null) {
       notice = new ChangeNoticeImpl(source);
       _pendingNotices[source] = notice;
     }
     return notice;
   }
 
-  Object _getResult(AnalysisTarget target, ResultDescriptor descriptor) {
-    cache.CacheEntry entry = _cache.get(target);
-    if (entry == null) {
-      return descriptor.defaultValue;
-    }
-    if (entry.isValid(descriptor)) {
-      return entry.getValue(descriptor);
-    }
-    return descriptor.defaultValue;
-  }
-
-  CacheState _getResultState(
-      AnalysisTarget target, ResultDescriptor descriptor) {
-    cache.CacheEntry entry = _cache.get(target);
-    if (entry == null) {
-      return CacheState.INVALID;
-    }
-    return entry.getState(descriptor);
-  }
-
   /**
    * 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();
     while (iterator.moveNext()) {
       if (iterator.value.getValue(SOURCE_KIND) == kind &&
           iterator.key is Source) {
@@ skipping 589 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, target, computeValue);
     if (!pendingFuture.evaluate(entry)) {
       _context._pendingFutureTargets
           .putIfAbsent(target, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }