Delay invalidating linked hashes until after checking the API signature of the changed file.

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 103 matching lines @@
    * [getResult] to the [Completer]s to report the result.
    */
   final _requestedFiles = <String, List<Completer<AnalysisResult>>>{};
 
   /**
    * The set of explicitly analyzed files.
    */
   final _explicitFiles = new LinkedHashSet<String>();
 
   /**
+   * The set of files were reported as changed through [changeFile] and for
+   * which API signatures should be recomputed and compared before performing
+   * any other analysis.
+   */
+  final _filesToVerifyUnlinkedSignature = new Set<String>();
+
+  /**
    * The set of files that are currently scheduled for analysis.
    */
   final _filesToAnalyze = new LinkedHashSet<String>();
 
   /**
    * Cache of URI resolution. The outer map key is the absolute URI of the
    * containing file. The inner map key is the URI text of a directive
    * contained in that file. The inner map value is the [Source] object which
    * that URI text resolves to.
    */
@@ skipping 51 matching lines @@
    * client does not change the state of the files.
    *
    * Results might be produced even for files that have never been added
    * using [addFile], for example when [getResult] was called for a file.
    */
   Stream<AnalysisResult> get results async* {
     try {
       while (true) {
         // TODO(scheglov) implement state transitioning
         await for (String why in _hasWorkStreamController.stream) {
+          _verifyUnlinkedSignatureOfChangedFiles();
+
           // Analyze the first file in the general queue.
           if (_filesToAnalyze.isNotEmpty) {
             _logger.run('Analyze ${_filesToAnalyze.length} files', () {
               while (_filesToAnalyze.isNotEmpty) {
                 String path = _filesToAnalyze.first;
                 _filesToAnalyze.remove(path);
                 _File file = _fileForPath(path);
                 _computeAndPrintErrors(file);
                 // TODO(scheglov) yield the result
               }
@@ skipping 32 matching lines @@
    * that state already). Schedules the file contents for [path] to be read
    * into the current file state prior to the next time the analysis state
    * transitions to "idle".
    *
    * Invocation of this method will not prevent a [Future] returned from
    * [getResult] from completing with a result, but the result is not
    * guaranteed to be consistent with the new current file state after this
    * [changeFile] invocation.
    */
   void changeFile(String path) {
-    // TODO(scheglov) Don't clear, schedule API signature validation.
-    _fileContentHashMap.clear();
-    _dependencySignatureMap.clear();
+    _filesToVerifyUnlinkedSignature.add(path);
     _filesToAnalyze.add(path);
-    _filesToAnalyze.addAll(_explicitFiles);
-    // TODO(scheglov) name?!
     _hasWorkStreamController.add('do it!');
   }
 
   /**
    * Return the [Future] that completes with a [AnalysisResult] for the file
    * with the given [path].
    *
    * The [path] must be absolute and normalized.
    *
    * The [path] can be any file - explicitly or implicitly analyzed, or neither.
@@ skipping 237 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(this, source);
   }
 
   /**
+   * Return the unlinked bundle of [file] for the current file state, or `null`.
+   */
+  PackageBundle _getCurrentUnlinked(_File file) {
+    String key = '${file.currentContentHash}.unlinked';
+    List<int> bytes = _byteStore.get(key);
+    return bytes != null ? new PackageBundle.fromBuffer(bytes) : null;
+  }
+
+  /**
    * TODO(scheglov) It would be nice to get URIs of "parts" from unlinked.
    */
   _ReferencedUris _getReferencedUris(_File file) {
     // Try to get from the store.
     {
       String key = '${file.contentHash}.uris';
       List<int> bytes = _byteStore.get(key);
       if (bytes != null) {
         fb.BufferContext bp = new fb.BufferContext.fromBytes(bytes);
         int table = bp.derefObject(0);
@@ skipping 56 matching lines @@
     // So, we need to update the key.
     String key = '${file.contentHash}.uris';
     _byteStore.put(key, bytes);
 
     return referencedUris;
   }
 
   /**
    * Return the unlinked bundle of [file] for the current file state.
    *
-   * That is, if there is an existing bundle for the current content hash
-   * of the [file] in the [_byteStore], then it is returned. Otherwise, the
-   * [file] content is read, the content hash is computed and the current file
-   * state is updated accordingly. That the content is parsed into the
-   * [CompilationUnit] and serialized into a new unlinked bundle. The bundle
-   * is then put into the [_byteStore] and returned.
+   * Return [_getCurrentUnlinked] or read the [file] content is read, compute
+   * the content hash and update the current file state accordingly. Parse the
+   * content into the [CompilationUnit] and serialize into a new unlinked
+   * bundle. The bundle is then put into the [_byteStore] and returned.
    */
   PackageBundle _getUnlinked(_File file) {
-    // Try to get bytes for file's unlinked bundle.
-    List<int> bytes;
-    {
-      String key = '${file.contentHash}.unlinked';
-      bytes = _byteStore.get(key);
+    return _getCurrentUnlinked(file) ??
+        _logger.run('Create unlinked for $file', () {
+          String key = '${file.contentHash}.unlinked';
+          UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(file.unit);
+          PackageBundleAssembler assembler = new PackageBundleAssembler();
+          assembler.addUnlinkedUnitWithHash(
+              file.uri.toString(), unlinkedUnit, key);
+          List<int> bytes = assembler.assemble().toBuffer();
+          _byteStore.put(key, bytes);
+          return new PackageBundle.fromBuffer(bytes);
+        });
+  }
+
+  /**
+   * Verify the API signatures for the changed files, and decide which linked
+   * libraries should be invalidated, and files reanalyzed.
+   */
+  void _verifyUnlinkedSignatureOfChangedFiles() {
+    if (_filesToVerifyUnlinkedSignature.isEmpty) {
+      return;
     }
-    // If no cached unlinked bundle, compute it.
-    if (bytes == null) {
-      _logger.run('Create unlinked for $file', () {
-        // We read the content and recomputed the hash.
-        // So, we need to update the key.
-        String key = '${file.contentHash}.unlinked';
-        UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(file.unit);
-        PackageBundleAssembler assembler = new PackageBundleAssembler();
-        assembler.addUnlinkedUnitWithHash(
-            file.uri.toString(), unlinkedUnit, key);
-        bytes = assembler.assemble().toBuffer();
-        _byteStore.put(key, bytes);
-      });
-    }
-    return new PackageBundle.fromBuffer(bytes);
+    int numOfFiles = _filesToVerifyUnlinkedSignature.length;
+    _logger.run('Verify API signatures of $numOfFiles files', () {
+      for (String path in _filesToVerifyUnlinkedSignature) {
+        _File file = _fileForPath(path);
+        // Get the existing old API signature, maybe null.
+        String oldSignature = _getCurrentUnlinked(file)?.apiSignature;
+        // Clear the content hash cache, so force the file reading.
+        _fileContentHashMap.remove(path);
+        // Compute the new API signature.
+        String newSignature = _getUnlinked(file).apiSignature;
+        // If the signatures are not the same, then potentially every linked
+        // library is inconsistent and should be recomputed, and every explicit
+        // file has inconsistent analysis results which also should be recomputed.
+        if (oldSignature != newSignature) {
+          _logger.writeln('API signature mismatch found for $file.');
+          _dependencySignatureMap.clear();
+          _filesToAnalyze.addAll(_explicitFiles);
+          // Stop the verification, and restart analysis.
+          break;
+        }
+      }
+      _filesToVerifyUnlinkedSignature.clear();
+    });
   }
 }
 
 /**
  * The result of analyzing of a single file.
  *
  * These results are self-consistent, i.e. [content], [contentHash], the
  * resolved [unit] correspond to each other. All referenced elements, even
  * external ones, are also self-consistent. But none of the results is
  * guaranteed to be consistent with the state of the files.
@@ skipping 115 matching lines @@
    * current file state is updated.
    */
   String get content {
     if (_content == null) {
       _readContentAndComputeHash();
     }
     return _content;
   }
 
   /**
-   * Ensure that the [contentHash] is filled.
+   * Ensure that the content hash is set for this [_File] instance, return it.
    *
-   * If the hash is already in the current file state, return the current
-   * value. Otherwise, read the [content], compute the hash, put it into
-   * the current file state, and update the [contentHash] field.
+   * If the content hash has already been set for this [_File] instance, it is
+   * not updated here. But the hash value might be updated on [content] access.
+   *
+   * If the content hash is known in the current file state, use it.
+   *
+   * Otherwise, read the [content], compute the hash, put it into the current
+   * file state, and update the [contentHash] field.
    *
    * The client should not remember values of this property, because its value
    * might change when [content] is read and the hash is recomputed.
    */
   String get contentHash {
-    _contentHash ??= driver._fileContentHashMap[path];
+    _contentHash ??= currentContentHash;
     if (_contentHash == null) {
       _readContentAndComputeHash();
     }
     return _contentHash;
   }
 
+  /**
+   * Return the hash of the file content in the current file state, or `null`
+   * if the current file state does not know the current file content hash.
+   */
+  String get currentContentHash {
+    return driver._fileContentHashMap[path];
+  }
+
   String get path => source.fullName;
 
   /**
    * Return the unresolved [CompilationUnit] of the file.
    *
    * Performing resolution and computing errors is done in a separate analysis
    * context. In the future we might push the existing unresolved unit into the
    * analysis context, so at some point the unit might become resolved.
    */
   CompilationUnit get unit {
@@ skipping 175 matching lines @@
 
 /**
  * TODO(scheglov) document
  */
 class _ReferencedUris {
   bool isLibrary = true;
   final List<String> imported = <String>[];
   final List<String> exported = <String>[];
   final List<String> parted = <String>[];
 }