Don't sent errors for general files if the file has the same signature.

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:typed_data';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 191 matching lines @@
    * The set of part files that are currently scheduled for analysis.
    */
   final _partsToAnalyze = new LinkedHashSet<String>();
 
   /**
    * The controller for the [results] stream.
    */
   final _resultController = new StreamController<AnalysisResult>();
 
   /**
+   * Resolution signatures of the most recently produced results for files.
+   */
+  final Map<String, String> _lastProducedSignatures = {};
+
+  /**
    * Cached results for [_priorityFiles].
    */
   final Map<String, AnalysisResult> _priorityResults = {};
 
   /**
    * The controller for the [exceptions] stream.
    */
   final StreamController<ExceptionResult> _exceptionController =
       new StreamController<ExceptionResult>();
 
@@ skipping 466 matching lines @@
   /**
    * Return the cached or newly computed analysis result of the file with the
    * given [path].
    *
    * The result will have the fully resolved unit and will always be newly
    * compute only if [withUnit] is `true`.
    *
    * Return `null` if the file is a part of an unknown library, so cannot be
    * analyzed yet. But [asIsIfPartWithoutLibrary] is `true`, then the file is
    * analyzed anyway, even without a library.
+   *
+   * Return [AnalysisResult._UNCHANGED] if [skipIfSameSignature] is `true` and
+   * the resolved signature of the file in its library is the same as the one
+   * that was the most recently produced to the client.
    */
   AnalysisResult _computeAnalysisResult(String path,
-      {bool withUnit: false, bool asIsIfPartWithoutLibrary: false}) {
+      {bool withUnit: false,
+      bool asIsIfPartWithoutLibrary: false,
+      bool skipIfSameSignature: false}) {
     FileState file = _fileTracker.fsState.getFileForPath(path);
 
     // Prepare the library - the file itself, or the known library.
     FileState library = file.isPart ? file.library : file;
     if (library == null) {
       if (asIsIfPartWithoutLibrary) {
         library = file;
       } else {
         return null;
       }
     }
 
+    // Prepare the signature and key.
+    String signature = _getResolvedUnitSignature(library, file);
+    String key = _getResolvedUnitKey(signature);
+
+    // Skip reading if the signature, so errors, are the same as the last time.
+    if (skipIfSameSignature) {
+      assert(!withUnit);
+      if (_lastProducedSignatures[path] == signature) {
+        return AnalysisResult._UNCHANGED;
+      }
+    }
+
     // If we don't need the fully resolved unit, check for the cached result.
     if (!withUnit) {
-      String key = _getResolvedUnitKey(library, file);
       List<int> bytes = _byteStore.get(key);
       if (bytes != null) {
-        return _getAnalysisResultFromBytes(file, bytes);
+        return _getAnalysisResultFromBytes(file, signature, bytes);
       }
     }
 
     // We need the fully resolved unit, or the result is not cached.
     return _logger.run('Compute analysis result for $path', () {
       try {
         LibraryContext libraryContext = _createLibraryContext(library);
         try {
           CompilationUnit resolvedUnit;
           List<int> bytes;
           if (analyzeWithoutTasks) {
             LibraryAnalyzer analyzer = new LibraryAnalyzer(
                 analysisOptions,
                 declaredVariables,
                 sourceFactory,
                 _fileTracker.fsState,
                 libraryContext.store,
                 library);
             Map<FileState, UnitAnalysisResult> results = analyzer.analyze();
             for (FileState unitFile in results.keys) {
               UnitAnalysisResult unitResult = results[unitFile];
-              List<int> unitBytes = _storeResolvedUnit(
-                  library, unitFile, unitResult.unit, unitResult.errors);
+              List<int> unitBytes =
+                  _serializeResolvedUnit(unitResult.unit, unitResult.errors);
+              String unitSignature =
+                  _getResolvedUnitSignature(library, unitFile);
+              String unitKey = _getResolvedUnitKey(unitSignature);
+              _byteStore.put(unitKey, unitBytes);
               if (unitFile == file) {
                 bytes = unitBytes;
                 resolvedUnit = unitResult.unit;
               }
             }
           } else {
             ResolutionResult resolutionResult =
                 libraryContext.resolveUnit(library.source, file.source);
             resolvedUnit = resolutionResult.resolvedUnit;
             List<AnalysisError> errors = resolutionResult.errors;
 
             // Store the result into the cache.
-            bytes = _storeResolvedUnit(library, file, resolvedUnit, errors);
+            bytes = _serializeResolvedUnit(resolvedUnit, errors);
+            _byteStore.put(key, bytes);
           }
 
           // Return the result, full or partial.
           _logger.writeln('Computed new analysis result.');
-          AnalysisResult result = _getAnalysisResultFromBytes(file, bytes,
+          AnalysisResult result = _getAnalysisResultFromBytes(
+              file, signature, bytes,
               content: withUnit ? file.content : null,
               withErrors: _fileTracker.addedFiles.contains(path),
               resolvedUnit: withUnit ? resolvedUnit : null);
           if (withUnit && _priorityFiles.contains(path)) {
             _priorityResults[path] = result;
           }
           return result;
         } finally {
           libraryContext.dispose();
         }
@@ skipping 70 matching lines @@
     assert(crossContextOptions.length == AnalysisOptions.signatureLength);
     for (int i = 0; i < crossContextOptions.length; i++) {
       _salt[i + 1] = crossContextOptions[i];
     }
   }
 
   /**
    * Load the [AnalysisResult] for the given [file] from the [bytes]. Set
    * optional [content] and [resolvedUnit].
    */
-  AnalysisResult _getAnalysisResultFromBytes(FileState file, List<int> bytes,
+  AnalysisResult _getAnalysisResultFromBytes(
+      FileState file, String signature, List<int> bytes,
       {String content, bool withErrors: true, CompilationUnit resolvedUnit}) {
     var unit = new AnalysisDriverResolvedUnit.fromBuffer(bytes);
     List<AnalysisError> errors = withErrors
         ? _getErrorsFromSerialized(file, unit.errors)
         : const <AnalysisError>[];
     return new AnalysisResult(
         this,
         _sourceFactory,
         file.path,
         file.uri,
         file.exists,
         content,
         file.contentHash,
         file.lineInfo,
+        signature,
         resolvedUnit,
         errors,
         unit.index);
   }
 
   /**
    * Return [AnalysisError]s for the given [serialized] errors.
    */
   List<AnalysisError> _getErrorsFromSerialized(
       FileState file, List<AnalysisDriverUnitError> serialized) {
     return serialized.map((error) {
       String errorName = error.uniqueName;
       ErrorCode errorCode =
           errorCodeByUniqueName(errorName) ?? _lintCodeByUniqueName(errorName);
       if (errorCode == null) {
         // This could fail because the error code is no longer defined, or, in
         // the case of a lint rule, if the lint rule has been disabled since the
         // errors were written.
         throw new StateError('No ErrorCode for $errorName in $file');
       }
       return new AnalysisError.forValues(file.source, error.offset,
           error.length, errorCode, error.message, error.correction);
     }).toList();
   }
 
   /**
-   * Return the key to store fully resolved results for the [file] in the
-   * [library] into the cache.
+   * Return the key to store fully resolved results for the [signature].
    */
-  String _getResolvedUnitKey(FileState library, FileState file) {
-    String signature = _getResolvedUnitSignature(library, file);
+  String _getResolvedUnitKey(String signature) {
     return '$signature.resolved';
   }
 
   /**
    * Return the signature that identifies fully resolved results for the [file]
    * in the [library], e.g. element model, errors, index, etc.
    */
   String _getResolvedUnitSignature(FileState library, FileState file) {
     ApiSignature signature = new ApiSignature();
     signature.addUint32List(_salt);
@@ skipping 132 matching lines @@
           } catch (exception, stackTrace) {
             _reportException(path, exception, stackTrace);
           } finally {
             _fileTracker.fileWasAnalyzed(path);
           }
           return;
         }
       }
     }
 
+    // Analyze a general file.
     if (_fileTracker.hasPendingFiles) {
-      // Analyze a general file.
       String path = _fileTracker.anyPendingFile;
       try {
-        AnalysisResult result = _computeAnalysisResult(path, withUnit: false);
+        AnalysisResult result = _computeAnalysisResult(path,
+            withUnit: false, skipIfSameSignature: true);
         if (result == null) {
           _partsToAnalyze.add(path);
+        } else if (result == AnalysisResult._UNCHANGED) {
+          // We found that the set of errors is the same as we produced the
+          // last time, so we don't need to produce it again now.
         } else {
           _resultController.add(result);
+          _lastProducedSignatures[result.path] = result._signature;
         }
       } catch (exception, stackTrace) {
         _reportException(path, exception, stackTrace);
       } finally {
         _fileTracker.fileWasAnalyzed(path);
       }
       return;
     }
 
     // Analyze a requested part file.
@@ skipping 39 matching lines @@
     if (exception is _ExceptionState) {
       var state = exception as _ExceptionState;
       exception = state.exception;
       stackTrace = state.stackTrace;
       contextKey = state.contextKey;
     }
     CaughtException caught = new CaughtException(exception, stackTrace);
     _exceptionController.add(new ExceptionResult(path, caught, contextKey));
   }
 
+  /**
+   * Serialize the given [resolvedUnit] errors and index into bytes.
+   */
+  List<int> _serializeResolvedUnit(
+      CompilationUnit resolvedUnit, List<AnalysisError> errors) {
+    AnalysisDriverUnitIndexBuilder index = indexUnit(resolvedUnit);
+    return 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(),
+            index: index)
+        .toBuffer();
+  }
+
   String _storeExceptionContext(
       String path, FileState libraryFile, exception, StackTrace stackTrace) {
     if (allowedNumberOfContextsToWrite <= 0) {
       return null;
     } else {
       allowedNumberOfContextsToWrite--;
     }
     try {
       List<AnalysisDriverExceptionFileBuilder> contextFiles = libraryFile
           .transitiveFiles
@@ skipping 28 matching lines @@
       String sec = _twoDigits(time.second);
       String ms = _threeDigits(time.millisecond);
       String key = 'exception_${time.year}$m$d' '_$h$min$sec' + '_$ms';
 
       _byteStore.put(key, bytes);
       return key;
     } catch (_) {
       return null;
     }
   }
-
-  /**
-   * Store the fully resolved results for the [file] in the [library] into the
-   * cache and return the stored bytes.
-   */
-  List<int> _storeResolvedUnit(FileState library, FileState file,
-      CompilationUnit resolvedUnit, List<AnalysisError> errors) {
-    AnalysisDriverUnitIndexBuilder index = indexUnit(resolvedUnit);
-
-    String key = _getResolvedUnitKey(library, file);
-    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(),
-            index: index)
-        .toBuffer();
-    _byteStore.put(key, bytes);
-    return bytes;
-  }
 }
 
 /**
  * Priorities of [AnalysisDriver] work. The farther a priority to the beginning
  * of the list, the earlier the corresponding [AnalysisDriver] should be asked
  * to perform work.
  */
 enum AnalysisDriverPriority { nothing, general, priority, interactive }
 
 /**
@@ skipping 180 matching lines @@
  *
  * 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.
  *
  * Every result is independent, and is not guaranteed to be consistent with
  * any previously returned result, even inside of the same library.
  */
 class AnalysisResult {
+  static final _UNCHANGED = new AnalysisResult(
+      null, null, null, null, null, null, null, null, null, null, null, null);
+
   /**
    * The [AnalysisDriver] that produced this result.
    */
   final AnalysisDriver driver;
 
   /**
    * The [SourceFactory] with which the file was analyzed.
    */
   final SourceFactory sourceFactory;
 
@@ skipping 23 matching lines @@
    * The MD5 hash of the [content].
    */
   final String contentHash;
 
   /**
    * Information about lines in the [content].
    */
   final LineInfo lineInfo;
 
   /**
+   * The signature of the result based on the content of the file, and the
+   * transitive closure of files imported and exported by the the library of
+   * the requested file.
+   */
+  final String _signature;
+
+  /**
    * The fully resolved compilation unit for the [content].
    */
   final CompilationUnit unit;
 
   /**
    * The full list of computed analysis errors, both syntactic and semantic.
    */
   final List<AnalysisError> errors;
 
   /**
    * The index of the unit.
    */
   final AnalysisDriverUnitIndex _index;
 
   AnalysisResult(
       this.driver,
       this.sourceFactory,
       this.path,
       this.uri,
       this.exists,
       this.content,
       this.contentHash,
       this.lineInfo,
+      this._signature,
       this.unit,
       this.errors,
       this._index);
 }
 
 /**
  * The errors in a single file.
  *
  * These results are self-consistent, i.e. [content], [contentHash], [errors]
  * correspond to each other. But none of the results is guaranteed to be
@@ skipping 401 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }