Try to load the existing unlinked bundle by the content hash.

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 217 matching lines @@
           continue;
         }
 
         // 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, withUnit: true);
+                  _computeAnalysisResult(path, 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, withUnit: false);
+          AnalysisResult result = _computeAnalysisResult(path, withUnit: false);
           yield result;
           // Repeat the processing loop.
           _hasWork.notify();
           continue;
         }
 
         // There is nothing to do.
         analysisSection.exit();
         analysisSection = null;
       }
@@ skipping 92 matching lines @@
    * add [UnlinkedUnit] with wrong URI.
    *
    * We need to clean this up.
    */
   void _addToStoreUnlinked(
       SummaryDataStore store, String uri, UnlinkedUnit unlinked) {
     store.unlinkedMap[uri] = unlinked;
   }
 
   /**
-   * Compute the [AnalysisResult] for the [file].
+   * Return the cached or newly computed analysis result of the file with the
+   * given [path].
    *
-   * The result will have the fully resolved unit only if [withUnit] is `true`.
+   * The result will have the fully resolved unit and will always be newly
+   * compute only if [withUnit] is `true`.
    */
-  AnalysisResult _computeAnalysisResult(_File file, {bool withUnit: false}) {
-    // If we don't need to the fully resolved unit, check for a cached result.
+  AnalysisResult _computeAnalysisResult(String path, {bool withUnit: false}) {
+    Source source = _sourceForPath(path);
+
+    // If we don't need the fully resolved unit, check for the cached result.
     if (!withUnit) {
-      AnalysisResult result = _getCachedAnalysisResult(file);
+      _File file = new _File.forLinking(this, source);
+      // Prepare the key for the cached result.
+      String key = _getResolvedUnitKey(file);
+      if (key == null) {
+        _logger.run('Compute the dependency hash for $source', () {
+          _createLibraryContext(file);
+          key = _getResolvedUnitKey(file);
+        });
+      }
+      // Check for the cached result.
+      AnalysisResult result = _getCachedAnalysisResult(file, key);
       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', () {
+    return _logger.run('Compute analysis result for $source', () {
+      // Still no result, compute and store it.
+      _File file = new _File.forResolution(this, source);
       _LibraryContext libraryContext = _createLibraryContext(file);
-
-      // We recomputed the dependency hash, and we might have a cached result.
-      if (!withUnit) {
-        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.
         {
@@ skipping 146 matching lines @@
         PackageBundle linked = new PackageBundle.fromBuffer(bytes);
         _addToStoreLinked(store, uri, linked.linkedLibraries.single);
         _byteStore.put(key, bytes);
       });
 
       return new _LibraryContext(libraryFile, libraryNode, store);
     });
   }
 
   /**
-   * Return the [_File] for the given [path] in [_sourceFactory].
+   * If we know the result [key] for the [file], try to load the analysis
+   * result from the cache. Return `null` if not found.
    */
-  _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);
-      }
+  AnalysisResult _getCachedAnalysisResult(_File file, String key) {
+    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;
   }
 
   /**
+   * Return the [Source] for the given [path] in [_sourceFactory].
+   */
+  Source _sourceForPath(String path) {
+    Source fileSource = _resourceProvider.getFile(path).createSource();
+    Uri uri = _sourceFactory.restoreUri(fileSource);
+    return _resourceProvider.getFile(path).createSource(uri);
+  }
+
+  /**
    * 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.
-      _File newFile = _fileForPath(path);
+      Source source = _sourceForPath(path);
+      _File newFile = new _File.forResolution(this, source);
       String newSignature = newFile.unlinked.apiSignature;
       // If the old API signature is not null, then the file was used to
       // compute at least one dependency signature. If the new API signature
       // is different, then potentially all dependency signatures and
       // resolution results are invalid.
       if (oldSignature != null && oldSignature != newSignature) {
         _logger.writeln('API signatures mismatch found for $newFile');
         _dependencySignatureMap.clear();
         _filesToAnalyze.addAll(_explicitFiles);
       }
@@ skipping 175 matching lines @@
   /**
    * The unlinked bundle, not `null`.
    */
   final PackageBundle unlinked;
 
   /**
    * The unresolved unit, not `null` if this file is for resolution.
    */
   final CompilationUnit unit;
 
-  factory _File.forLinking(AnalysisDriver driver, Source source) {
-    // If we have enough cached information, use it.
-    String contentHash = driver._fileContentHashMap[source.fullName];
-    if (contentHash != null) {
-      String key = '$contentHash.unlinked';
-      List<int> bytes = driver._byteStore.get(key);
-      if (bytes != null) {
-        PackageBundle unlinked = new PackageBundle.fromBuffer(bytes);
-        return new _File._(driver, source, null, contentHash, unlinked, null);
-      }
-    }
-    // Otherwise, read the source, parse and build a new unlinked bundle.
-    return new _File.forResolution(driver, source);
-  }
-
-  factory _File.forResolution(AnalysisDriver driver, Source source) {
+  /**
+   * Return the file with consistent [content] and [contentHash].
+   */
+  factory _File.forContent(AnalysisDriver driver, Source source) {
     String path = source.fullName;
     // Read the content.
     String content;
     try {
       content = driver._contentCache.getContents(source);
       content ??= source.contents.data;
     } catch (_) {
       content = '';
       // TODO(scheglov) We fail to report URI_DOES_NOT_EXIST.
       // On one hand we need to provide an unlinked bundle to prevent
       // analysis context from reading the file (we want it to work
       // hermetically and handle one one file at a time). OTOH,
       // ResynthesizerResultProvider happily reports that any source in the
       // SummaryDataStore has MODIFICATION_TIME `0`. We need to return `-1`
       // for missing files. Maybe add this feature to SummaryDataStore?
     }
     // Compute the content hash.
     List<int> textBytes = UTF8.encode(content);
     List<int> hashBytes = md5.convert(textBytes).bytes;
     String contentHash = hex.encode(hashBytes);
     driver._fileContentHashMap[path] = contentHash;
+    // Return information about the file content.
+    return new _File._(driver, source, content, contentHash, null, null);
+  }
+
+  factory _File.forLinking(AnalysisDriver driver, Source source) {
+    String path = source.fullName;
+    String contentHash = driver._fileContentHashMap[path];
+    // If we don't have the file content hash, compute it.
+    if (contentHash == null) {
+      _File file = new _File.forContent(driver, source);
+      contentHash = file.contentHash;
+    }
+    // If we have the cached unlinked bundle, use it.
+    {
+      String key = '$contentHash.unlinked';
+      List<int> bytes = driver._byteStore.get(key);
+      if (bytes != null) {
+        PackageBundle unlinked = new PackageBundle.fromBuffer(bytes);
+        driver._fileApiSignatureMap[path] = unlinked.apiSignature;
+        return new _File._(driver, source, null, contentHash, unlinked, null);
+      }
+    }
+    // Otherwise, read the source, parse and build a new unlinked bundle.
+    return new _File.forResolution(driver, source);
+  }
+
+  factory _File.forResolution(AnalysisDriver driver, Source source) {
+    _File file = new _File.forContent(driver, source);
+    String path = file.path;
+    String content = file.content;
+    String contentHash = file.contentHash;
     // Parse the unit.
     CompilationUnit unit = _parse(driver, source, content);
     // Prepare the unlinked bundle.
     PackageBundle unlinked;
     {
       String key = '$contentHash.unlinked';
       List<int> bytes = driver._byteStore.get(key);
       if (bytes == null) {
         driver._logger.run('Create unlinked for $path', () {
           UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(unit);
           PackageBundleAssembler assembler = new PackageBundleAssembler();
           assembler.addUnlinkedUnitWithHash(
               source.uri.toString(), unlinkedUnit, contentHash);
           bytes = assembler.assemble().toBuffer();
           driver._byteStore.put(key, bytes);
         });
       }
       unlinked = new PackageBundle.fromBuffer(bytes);
       driver._fileApiSignatureMap[path] = unlinked.apiSignature;
     }
-    // Update the current file state.
+    // Return the full file.
     return new _File._(driver, source, content, contentHash, unlinked, unit);
   }
 
   _File._(this.driver, this.source, this.content, this.contentHash,
       this.unlinked, this.unit);
 
   String get path => source.fullName;
 
   Uri get uri => source.uri;
 
@@ skipping 195 matching lines @@
       }
     }
     for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
       referenced.exported.add(export.uri);
     }
     return referenced;
   }
 
   _ReferencedUris._();
 }