Prepare CompilationUnitElementDelta in IncrementalCompilationUnitElementBuilder.

pkg/analyzer/lib/src/task/incremental_element_builder.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.incremental_element_builder;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 /**
+ * The change of a single [CompilationUnitElement].
+ */
+class CompilationUnitElementDelta {
+  /**
+   * One or more directives were added/removed.
+   */
+  bool hasDirectiveChange = false;
+
+  /**
+   * The list of added top-level element.
+   */
+  final List<Element> addedDeclarations = <Element>[];
+
+  /**
+   * The list of removed top-level elements.
+   */
+  final List<Element> removedDeclarations = <Element>[];
+}
+
+/**
  * Incrementally updates the existing [unitElement] and builds elements for
  * the [newUnit].
  */
 class IncrementalCompilationUnitElementBuilder {
-  final Source source;
+  final Source unitSource;
   final Source librarySource;
   final CompilationUnit oldUnit;
   final CompilationUnitElementImpl unitElement;
   final CompilationUnit newUnit;
   final ElementHolder holder = new ElementHolder();
 
-  IncrementalCompilationUnitElementBuilder(
-      CompilationUnit oldUnit, this.newUnit)
-      : oldUnit = oldUnit,
-        unitElement = oldUnit.element,
-        source = oldUnit.element.source,
-        librarySource = (oldUnit.element as CompilationUnitElementImpl).librarySource;
+  /**
+   * The change between element models of [oldUnit] and [newUnit].
+   */
+  final CompilationUnitElementDelta unitDelta =
+      new CompilationUnitElementDelta();
 
+  factory IncrementalCompilationUnitElementBuilder(
+      CompilationUnit oldUnit, CompilationUnit newUnit) {
+    CompilationUnitElementImpl unitElement = oldUnit.element;
+    return new IncrementalCompilationUnitElementBuilder._(unitElement.source,
+        unitElement.librarySource, oldUnit, newUnit, unitElement);
+  }
+
+  IncrementalCompilationUnitElementBuilder._(this.unitSource,
+      this.librarySource, this.oldUnit, this.newUnit, this.unitElement);
+
+  /**
+   * Updates [oldUnit] to have the same directives and declarations, in the
+   * same order as in [newUnit]. Existing resolution is kept where possible.
+   *
+   * Updates [unitElement] by adding/removing elements as needed.
+   *
+   * Fills [unitDelta] with added/remove elements.
+   */
   void build() {
     new CompilationUnitBuilder().buildCompilationUnit(
-        source, newUnit, librarySource);
+        unitSource, newUnit, librarySource);
     _processDirectives();
     _processUnitMembers();
     newUnit.element = unitElement;
-  }
-
-  void _addElementsToHolder(CompilationUnitMember node) {
-    List<Element> elements = _getElements(node);
-    elements.forEach(_addElementToHolder);
+    oldUnit.replaceWith(newUnit);
   }
 
   void _addElementToHolder(Element element) {
     if (element is PropertyAccessorElement) {
       holder.addAccessor(element);
     } else if (element is ClassElement) {
       if (element.isEnum) {
         holder.addEnum(element);
       } else {
         holder.addType(element);
       }
     } else if (element is FunctionElement) {
       holder.addFunction(element);
     } else if (element is FunctionTypeAliasElement) {
       holder.addTypeAlias(element);
     } else if (element is TopLevelVariableElement) {
       holder.addTopLevelVariable(element);
     }
   }
 
   void _processDirectives() {
     Map<String, Directive> oldDirectiveMap = new HashMap<String, Directive>();
     for (Directive oldDirective in oldUnit.directives) {
       String code = TokenUtils.getFullCode(oldDirective);
       oldDirectiveMap[code] = oldDirective;
     }
     // Replace new nodes with the identical old nodes.
+    Set<Directive> removedDirectives = oldUnit.directives.toSet();
     for (Directive newDirective in newUnit.directives) {
       String code = TokenUtils.getFullCode(newDirective);
       // Prepare an old directive.
       Directive oldDirective = oldDirectiveMap[code];
       if (oldDirective == null) {
+        unitDelta.hasDirectiveChange = true;
         continue;
       }
       // URI's must be resolved to the same sources.
       if (newDirective is UriBasedDirective &&
           oldDirective is UriBasedDirective) {
         if (oldDirective.source != newDirective.source) {
           continue;
         }
       }
       // Do replacement.
       _replaceNode(newDirective, oldDirective);
+      removedDirectives.remove(oldDirective);
+    }
+    // If there are any directives left, then these directives were removed.
+    if (removedDirectives.isNotEmpty) {
+      unitDelta.hasDirectiveChange = true;
     }
   }
 
   void _processUnitMembers() {
     Map<String, CompilationUnitMember> oldNodeMap =
         new HashMap<String, CompilationUnitMember>();
     for (CompilationUnitMember oldNode in oldUnit.declarations) {
       String code = TokenUtils.getFullCode(oldNode);
       oldNodeMap[code] = oldNode;
     }
+    // Prepare all old top-level elements.
+    Set<Element> removedElements = new Set<Element>();
+    removedElements.addAll(unitElement.accessors);
+    removedElements.addAll(unitElement.enums);
+    removedElements.addAll(unitElement.functions);
+    removedElements.addAll(unitElement.functionTypeAliases);
+    removedElements.addAll(unitElement.types);
+    removedElements.addAll(unitElement.topLevelVariables);
     // Replace new nodes with the identical old nodes.
     for (CompilationUnitMember newNode in newUnit.declarations) {
       String code = TokenUtils.getFullCode(newNode);
       // Prepare an old node.
       CompilationUnitMember oldNode = oldNodeMap[code];
       if (oldNode == null) {
-        _addElementsToHolder(newNode);
+        List<Element> elements = _getElements(newNode);
+        elements.forEach(_addElementToHolder);
+        elements.forEach(unitDelta.addedDeclarations.add);
         continue;
       }
       // Do replacement.
       _replaceNode(newNode, oldNode);
-      _addElementsToHolder(oldNode);
+      List<Element> elements = _getElements(oldNode);
+      elements.forEach(_addElementToHolder);
+      elements.forEach(removedElements.remove);
     }
+    unitDelta.removedDeclarations.addAll(removedElements);
     // Update CompilationUnitElement.
     unitElement.accessors = holder.accessors;
     unitElement.enums = holder.enums;
     unitElement.functions = holder.functions;
     unitElement.typeAliases = holder.typeAliases;
     unitElement.types = holder.types;
     unitElement.topLevelVariables = holder.topLevelVariables;
     holder.validate();
   }
 
@@ skipping 165 matching lines @@
     }
     int oldOffset = element.nameOffset;
     int newOffset = map[oldOffset];
     assert(newOffset != null);
     (element as ElementImpl).nameOffset = newOffset;
     if (element is! LibraryElement) {
       super.visitElement(element);
     }
   }
 }