Verify one changed file at a time.

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 101 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.
+   * The set of files were reported as changed through [changeFile] and not
+   * checked for actual changes yet.
    */
-  final _filesToVerifyUnlinkedSignature = new Set<String>();
+  final _changedFiles = new LinkedHashSet<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
@@ skipping 61 matching lines @@
    * 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) {
-        // TODO(scheglov) implement state transitioning
         await _hasWork.signal;
 
+        // TODO(scheglov) implement state transitioning
         if (analysisSection == null) {
           analysisSection = _logger.enter('Analyzing');
         }
 
-        // TODO(scheglov) verify one file at a time
-        _verifyUnlinkedSignatureOfChangedFiles();
+        // Verify all changed files one at a time.
+        if (_changedFiles.isNotEmpty) {
+          String path = _removeFirst(_changedFiles);
+          _verifyApiSignatureOfChangedFile(path);
+          // Repeat the processing loop.
+          _hasWork.notify();
+          continue;
+        }
 
         // Analyze the first file in the general queue.
         if (_filesToAnalyze.isNotEmpty) {
-          String path = _filesToAnalyze.first;
-          _filesToAnalyze.remove(path);
+          String path = _removeFirst(_filesToAnalyze);
           _File file = _fileForPath(path);
           AnalysisResult result = _computeAnalysisResult(file);
           yield result;
+          // Repeat the processing loop.
+          _hasWork.notify();
+          continue;
         }
 
-        // If there is work to do, notify the monitor.
-        if (_filesToAnalyze.isNotEmpty) {
-          _hasWork.notify();
-        } else {
-          analysisSection.exit();
-          analysisSection = null;
-        }
+        // There is nothing to do.
+        analysisSection.exit();
+        analysisSection = null;
       }
       // TODO(scheglov) implement
     } finally {
       print('The stream was cancelled.');
     }
   }
 
   /**
    * Add the file with the given [path] to the set of files to analyze.
    *
@@ skipping 19 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) {
-    _filesToVerifyUnlinkedSignature.add(path);
+    _changedFiles.add(path);
     _filesToAnalyze.add(path);
     _hasWork.notify();
   }
 
   /**
    * Return the [Future] that completes with a [AnalysisResult] for the file
    * with the given [path].
    *
    * The [path] must be absolute and normalized.
    *
@@ skipping 226 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);
   }
 
   /**
-   * Verify the API signatures for the changed files, and decide which linked
-   * libraries should be invalidated, and files reanalyzed.
+   * 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 _verifyUnlinkedSignatureOfChangedFiles() {
-    if (_filesToVerifyUnlinkedSignature.isEmpty) {
-      return;
-    }
-    int numOfFiles = _filesToVerifyUnlinkedSignature.length;
-    _logger.run('Verify API signatures of $numOfFiles files', () {
-      bool hasMismatch = false;
-      for (String path in _filesToVerifyUnlinkedSignature) {
-        String oldSignature = _fileApiSignatureMap[path];
-        // Compute the new API signature.
-        // _File.forResolution() also updates the content hash in the cache.
-        _File newFile = _fileForPath(path);
-        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 signature mismatch found for $newFile.');
-          hasMismatch = true;
-        }
-      }
-      if (hasMismatch) {
+  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);
+      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);
-      } else {
-        _logger.writeln('All API signatures match.');
       }
-      _filesToVerifyUnlinkedSignature.clear();
     });
   }
+
+  /**
+   * Remove and return the first item in the given [set].
+   */
+  static Object/*=T*/ _removeFirst/*<T>*/(LinkedHashSet<Object/*=T*/ > set) {
+    Object/*=T*/ element = set.first;
+    set.remove(element);
+    return element;
+  }
 }
 
 /**
  * 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 427 matching lines @@
       }
     }
     for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
       referenced.exported.add(export.uri);
     }
     return referenced;
   }
 
   _ReferencedUris._();
 }