Separate gathering Delta changes and validation.

pkg/analyzer/lib/src/task/dart.dart

 // Copyright (c) 2015, 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.
 
 library analyzer.src.task.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 2507 matching lines @@
    * The cache of libraries in which all results are valid.
    */
   final Set<Source> librariesWithAllValidResults = new Set<Source>();
 
   /**
    * The cache of libraries with all, but [HINTS] and [VERIFY_ERRORS] results
    * are valid.
    */
   final Set<Source> libraryWithInvalidErrors = new Set<Source>();
 
+  /**
+   * This set is cleared in every [gatherEnd], and [gatherChanges] uses it
+   * to find changes in every source only once per visit process.
+   */
+  final Set<Source> currentVisitUnits = new Set<Source>();
+
   DartDelta(Source source) : super(source);
 
   /**
    * Add names that are changed in the given [references].
+   * Return `true` if any change was added.
    */
-  void addChangedElements(ReferencedNames references, Source refLibrary) {
-    bool hasProgress = true;
-    while (hasProgress) {
-      hasProgress = false;
+  bool addChangedElements(ReferencedNames references, Source refLibrary) {
+    int numberOfChanges = 0;
+    int lastNumberOfChange = -1;
+    while (numberOfChanges != lastNumberOfChange) {
+      lastNumberOfChange = numberOfChanges;
       // Classes that extend changed classes are also changed.
       // If there is a delta for a superclass, use it for the subclass.
       // Otherwise mark the subclass as "general name change".
       references.superToSubs.forEach((String superName, Set<String> subNames) {
         ClassElementDelta superDelta = changedClasses[superName];
         for (String subName in subNames) {
           if (superDelta != null) {
             ClassElementDelta subDelta = changedClasses.putIfAbsent(subName,
                 () => new ClassElementDelta(null, refLibrary, subName));
             _log(() => '$subName in $refLibrary has delta because of its '
                 'superclass $superName has delta');
             if (subDelta.superDeltas.add(superDelta)) {
-              hasProgress = true;
+              numberOfChanges++;
             }
           } else if (isChanged(refLibrary, superName)) {
             if (nameChanged(refLibrary, subName)) {
               _log(() => '$subName in $refLibrary is changed because its '
                   'superclass $superName is changed');
-              hasProgress = true;
+              numberOfChanges++;
             }
           }
         }
       });
       // If a user element uses a changed top-level element, then the user is
       // also changed. Note that if a changed class with delta is used, this
       // does not make the user changed - classes with delta keep their
       // original elements, so resolution of their names does not change.
       references.userToDependsOn.forEach((user, dependencies) {
         for (String dependency in dependencies) {
           if (isChangedOrClassMember(refLibrary, dependency)) {
             if (nameChanged(refLibrary, user)) {
               _log(() => '$user in $refLibrary is changed because '
                   'of $dependency in $dependencies');
-              hasProgress = true;
+              numberOfChanges++;
             }
           }
         }
       });
     }
+    return numberOfChanges != 0;
   }
 
   void classChanged(ClassElementDelta classDelta) {
     changedClasses[classDelta.name] = classDelta;
   }
 
   void elementChanged(Element element) {
     Source librarySource = element.library.source;
     nameChanged(librarySource, element.name);
   }
 
+  @override
+  bool gatherChanges(InternalAnalysisContext context, AnalysisTarget target,
+      ResultDescriptor descriptor, Object value) {
+    // Prepare target source.
+    Source targetUnit = target.source;
+    Source targetLibrary = target.librarySource;
+    if (target is Source) {
+      if (context.getKindOf(target) == SourceKind.LIBRARY) {
+        targetLibrary = target;
+      }
+    }
+    // We don't know what to do with the given target.
+    if (targetUnit == null || targetUnit != targetLibrary) {
+      return false;
+    }
+    // Attempt to find new changed names for the unit only once.
+    if (!currentVisitUnits.add(targetUnit)) {
+      return false;
+    }
+    // Add changes.
+    ReferencedNames referencedNames =
+        context.getResult(targetUnit, REFERENCED_NAMES);
+    if (referencedNames == null) {
+      return false;
+    }
+    return addChangedElements(referencedNames, targetLibrary);
+  }
+
+  @override
+  void gatherEnd() {
+    currentVisitUnits.clear();
+  }
+
   bool hasAffectedHintsVerifyErrors(
       ReferencedNames references, Source refLibrary) {
     for (String superName in references.superToSubs.keys) {
       if (isChangedOrClass(refLibrary, superName)) {
         _log(() => '$refLibrary hints/verify errors are affected because '
             '${references.superToSubs[superName]} subclasses $superName');
         return true;
       }
     }
     return false;
@@ skipping 85 matching lines @@
     }
     // Prepare target source.
     Source targetUnit = target.source;
     Source targetLibrary = target.librarySource;
     if (target is Source) {
       if (context.getKindOf(target) == SourceKind.LIBRARY) {
         targetLibrary = target;
       }
     }
     // We don't know what to do with the given target, invalidate it.
-    if (targetUnit == null) {
+    if (targetUnit == null || targetUnit != targetLibrary) {
       return DeltaResult.INVALIDATE;
     }
     // Keep results that don't change: any library.
     if (_isTaskResult(ScanDartTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(ParseDartTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(BuildCompilationUnitElementTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(BuildLibraryElementTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(BuildDirectiveElementsTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(ResolveDirectiveElementsTask.DESCRIPTOR, descriptor) ||
         _isTaskResult(BuildEnumMemberElementsTask.DESCRIPTOR, descriptor) ||
@@ skipping 28 matching lines @@
           return DeltaResult.INVALIDATE_NO_DELTA;
         }
         return DeltaResult.KEEP_CONTINUE;
       }
       // Compute the library result.
       ReferencedNames referencedNames =
           context.getResult(targetUnit, REFERENCED_NAMES);
       if (referencedNames == null) {
         return DeltaResult.INVALIDATE_NO_DELTA;
       }
-      addChangedElements(referencedNames, targetLibrary);
       if (hasAffectedReferences(referencedNames, targetLibrary)) {
         librariesWithAllInvalidResults.add(targetLibrary);
         return DeltaResult.INVALIDATE;
       }
       if (hasAffectedHintsVerifyErrors(referencedNames, targetLibrary)) {
         libraryWithInvalidErrors.add(targetLibrary);
         return DeltaResult.KEEP_CONTINUE;
       }
       librariesWithAllValidResults.add(targetLibrary);
       return DeltaResult.STOP;
@@ skipping 3729 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }