Do nothing if [changeFile] reported, but the file content is the same.

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 190 matching lines @@
   /**
    * Return the [Stream] that produces [AnalysisResult]s for added files.
    *
    * Analysis starts when the client starts listening to the stream, and stops
    * when the client cancels the subscription.
    *
    * When the client starts listening, the analysis state transitions to
    * "analyzing" and an analysis result is produced for every added file prior
    * to the next time the analysis state transitions to "idle".
    *
-   * At least one analysis result is produced for every file passed to
-   * [addFile] or [changeFile] prior to the next time the analysis state
-   * transitions to "idle", unless the file is later removed from analysis
-   * using [removeFile]. Analysis results for other files are produced only if
-   * the changes affect analysis results of other files.
-   *
    * More than one result might be produced for the same file, even if the
    * 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 {
       PerformanceLogSection analysisSection = null;
       while (true) {
@@ skipping 71 matching lines @@
    * Return the stream that produces [AnalysisStatus] events.
    */
   Stream<AnalysisStatus> get status => _statusController.stream;
 
   /**
    * Add the file with the given [path] to the set of files to analyze.
    *
    * The [path] must be absolute and normalized.
    *
    * The results of analysis are eventually produced by the [results] stream.
+   *
+   * Causes the analysis state to transition to "analyzing" (if it is not in
+   * that state already). At least one analysis result will be produced the
+   * file prior to the next time the analysis state transitions to "idle",
+   * unless the file is later removed from analysis using [removeFile].
    */
   void addFile(String path) {
     _explicitFiles.add(path);
     _filesToAnalyze.add(path);
     _transitionToAnalyzing();
     _hasWork.notify();
   }
 
   /**
    * The file with the given [path] might have changed - updated, added or
    * removed. Or not, we don't know. Or it might have, but then changed back.
    *
    * The [path] must be absolute and normalized.
    *
    * The [path] can be any file - explicitly or implicitly analyzed, or neither.
    *
    * Causes the analysis state to transition to "analyzing" (if it is not in
    * 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".
    *
+   * If the file content is the same, no new results will be produced because
+   * of this notification, including no result for the file itself. Otherwise,
+   * one or more results will be produced - for the file itself and other
+   * files that that change in the file might affect.

[Brian Wilkerson, 2016/10/31 14:06:04]

"that that" --> "that the"

+   *
    * 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) {
     _changedFiles.add(path);
     if (_explicitFiles.contains(path)) {
       _filesToAnalyze.add(path);
     }
@@ skipping 335 matching lines @@
   }
 
   /**
    * 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 oldContentHash = _fileContentHashMap[path];
       String oldSignature = _fileApiSignatureMap[path];
       // Compute the new API signature.
       // _File.forResolution() also updates the content hash in the cache.
       Source source = _sourceForPath(path);
       _File newFile = new _File.forResolution(this, source);
-      String newSignature = newFile.unlinked.apiSignature;
+      // If the file content hash is the same, we don't need analyzing it.

[Brian Wilkerson, 2016/10/31 14:06:04]

"need analyzing it" --> "need to analyze it"

+      if (newFile.contentHash == oldContentHash) {
+        _filesToAnalyze.remove(path);
+        return;
+      }
       // 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.
+      String newSignature = newFile.unlinked.apiSignature;
       if (oldSignature != null && oldSignature != newSignature) {
         _logger.writeln('API signatures mismatch found for $newFile');
         _dependencySignatureMap.clear();
         _filesToAnalyze.addAll(_explicitFiles);
       }
     });
   }
 
   /**
    * Remove and return the first item in the given [set].
@@ skipping 493 matching lines @@
       }
     }
     for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
       referenced.exported.add(export.uri);
     }
     return referenced;
   }
 
   _ReferencedUris._();
 }