Put fully resolved analysis results (just errors now) into the byte cache.

pkg/analyzer/lib/src/dart/analysis/driver.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 218 matching lines @@
         }
 
         // TODO(scheglov) analyze requested files
 
         // Analyze a priority file.
         if (_priorityFiles.isNotEmpty) {
           bool analyzed = false;
           for (String path in _priorityFiles) {
             if (_filesToAnalyze.remove(path)) {
               _File file = _fileForPath(path);
-              AnalysisResult result = _computeAnalysisResult(file);
+              AnalysisResult result =
+                  _computeAnalysisResult(file, withUnit: true);
               yield result;
               break;
             }
           }
           // Repeat the processing loop.
           if (analyzed) {
             _hasWork.notify();
             continue;
           }
         }
 
         // Analyze a general file.
         if (_filesToAnalyze.isNotEmpty) {
           String path = _removeFirst(_filesToAnalyze);
           _File file = _fileForPath(path);
-          AnalysisResult result = _computeAnalysisResult(file);
+          AnalysisResult result = _computeAnalysisResult(file, withUnit: false);
           yield result;
           // Repeat the processing loop.
           _hasWork.notify();
           continue;
         }
 
         // There is nothing to do.
         analysisSection.exit();
         analysisSection = null;
       }
@@ skipping 93 matching lines @@
    *
    * We need to clean this up.
    */
   void _addToStoreUnlinked(
       SummaryDataStore store, String uri, UnlinkedUnit unlinked) {
     store.unlinkedMap[uri] = unlinked;
   }
 
   /**
    * Compute the [AnalysisResult] for the [file].
+   *
+   * The result will have the fully resolved unit only if [withUnit] is `true`.
    */
-  AnalysisResult _computeAnalysisResult(_File file) {
+  AnalysisResult _computeAnalysisResult(_File file, {bool withUnit: false}) {
+    // If we don't need to the fully resolved unit, check for a cached result.
+    if (!withUnit) {
+      AnalysisResult result = _getCachedAnalysisResult(file);
+      if (result != null) {
+        return result;
+      }
+    }
+
+    // We need the fully resolved unit, or the result is not cached.
     return _logger.run('Compute analysis result for $file', () {
       _LibraryContext libraryContext = _createLibraryContext(file);
+
+      // We recomputed the dependency hash, and we might have a cached result.
+      if (!withUnit) {

[Paul Berry, 2016/10/31 17:02:53]

AFAICT this block will never execute, since the same effect is already achieved
by lines 375-380.

[scheglov, 2016/10/31 17:07:06]

Both this block and the block in lines 375-380 uses the current dependency hash.
But if the dependency hash is not in _dependencySignatureMap, then
_getCachedAnalysisResult(file) will return null. Call to
_createLibraryContext(file) recomputes the dependency hash and puts it into
_dependencySignatureMap. So, this block might still be able to find a previous
result for the newly computed dependency hash.

[Paul Berry, 2016/10/31 21:35:34]

Ok, I understand now.  Thanks.

+        AnalysisResult result = _getCachedAnalysisResult(file);
+        if (result != null) {
+          _logger.writeln('Return the cached analysis result.');
+          return result;
+        }
+      }
+
+      // Still no result, compute and store it.
       AnalysisContext analysisContext = _createAnalysisContext(libraryContext);
       try {
         analysisContext.setContents(file.source, file.content);
         // TODO(scheglov) Add support for parts.
         CompilationUnit resolvedUnit =
             analysisContext.resolveCompilationUnit2(file.source, file.source);
         List<AnalysisError> errors = analysisContext.computeErrors(file.source);
+
+        // Store the result into the cache.
+        {
+          List<int> bytes = new AnalysisDriverResolvedUnitBuilder(
+                  errors: errors
+                      .map((error) => new AnalysisDriverUnitErrorBuilder(
+                          offset: error.offset,
+                          length: error.length,
+                          uniqueName: error.errorCode.uniqueName,
+                          message: error.message,
+                          correction: error.correction))
+                      .toList())
+              .toBuffer();
+          String key = _getResolvedUnitKey(file);
+          _byteStore.put(key, bytes);
+        }
+
+        // Return the full result.
+        _logger.writeln('Computed new analysis result.');
         return new AnalysisResult(file.path, file.uri, file.content,
             file.contentHash, resolvedUnit, errors);
       } finally {
         analysisContext.dispose();
       }
     });
   }
 
   AnalysisContext _createAnalysisContext(_LibraryContext libraryContext) {
     AnalysisContextImpl analysisContext =
@@ skipping 130 matching lines @@
    * Return the [_File] for the given [path] in [_sourceFactory].
    */
   _File _fileForPath(String path) {
     Source fileSource = _resourceProvider.getFile(path).createSource();
     Uri uri = _sourceFactory.restoreUri(fileSource);
     Source source = _resourceProvider.getFile(path).createSource(uri);
     return new _File.forResolution(this, source);
   }
 
   /**
+   * If we know the dependency signature for the [file], try to load the
+   * analysis result from the cache. Return `null` if not found.
+   */
+  AnalysisResult _getCachedAnalysisResult(_File file) {
+    String key = _getResolvedUnitKey(file);
+    if (key != null) {
+      List<int> bytes = _byteStore.get(key);
+      if (bytes != null) {
+        var unit = new AnalysisDriverResolvedUnit.fromBuffer(bytes);
+        List<AnalysisError> errors = unit.errors
+            .map((error) => new AnalysisError.forValues(
+                file.source,
+                error.offset,
+                error.length,
+                ErrorCode.byUniqueName(error.uniqueName),
+                error.message,
+                error.correction))
+            .toList();
+        return new AnalysisResult(
+            file.path, file.uri, null, file.contentHash, null, errors);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the key to store fully resolved results for the [file] into the
+   * cache. Return `null` if the dependency signature is not known yet.
+   */
+  String _getResolvedUnitKey(_File file) {
+    String dependencyHash = _dependencySignatureMap[file.uri];
+    if (dependencyHash != null) {
+      ApiSignature signature = new ApiSignature();
+      signature.addString(dependencyHash);
+      signature.addString(file.contentHash);
+      return '${signature.toHex()}.resolved';
+    }
+    return null;
+  }
+
+  /**
    * Verify the API signature for the file with the given [path], and decide
    * which linked libraries should be invalidated, and files reanalyzed.
    *
    * TODO(scheglov) I see that adding a local var changes (full) API signature.
    */
   void _verifyApiSignatureOfChangedFile(String path) {
     _logger.run('Verify API signature of $path', () {
       String oldSignature = _fileApiSignatureMap[path];
       // Compute the new API signature.
       // _File.forResolution() also updates the content hash in the cache.
@@ skipping 459 matching lines @@
       }
     }
     for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
       referenced.exported.add(export.uri);
     }
     return referenced;
   }
 
   _ReferencedUris._();
 }