Another fix incremental constants - annotations should use the old unit element.

pkg/analyzer/test/src/task/incremental_element_builder_test.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.test.src.task.incremental_element_builder_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 1631 matching lines @@
     _buildNewUnit(r'''
 class A {
   b
 
   /// CCC
   A();
 }
 ''');
   }
 
+  test_update_annotation_add() {
+    _buildOldUnit(r'''
+const myAnnotation = const Object();
+foo() {}
+''');
+    _buildNewUnit(r'''
+const myAnnotation = const Object();
+@myAnnotation
+foo() {}
+''');
+  }
+
   test_update_beforeClassWithDelta_nameOffset() {
     _buildOldUnit(r'''
 class A {}
 
 class B {
   A a;
 }
 ''');
     _buildNewUnit(r'''
 class A2 {}
@@ skipping 197 matching lines @@
     }
     // Field elements referenced by field formal parameters of constructors
     // must by fields of the enclosing class element.
     if (actual is FieldFormalParameter) {
       FieldFormalParameterElement parameterElement = actual.element;
       FieldElement element = parameterElement.field;
       ClassDeclaration classNode =
           actual.getAncestor((n) => n is ClassDeclaration);
       expect(element.enclosingElement, same(classNode.element));
     }
+    // ElementAnnotationImpl must use the enclosing CompilationUnitElement.
+    if (actual is Annotation) {
+      AstNode parent = actual.parent;
+      if (parent is Declaration) {
+        ElementAnnotationImpl actualElement = actual.elementAnnotation;
+        CompilationUnitElement enclosingUnitElement =
+            parent.element.getAncestor((a) => a is CompilationUnitElement);
+        expect(actualElement.compilationUnit, same(enclosingUnitElement));
+      }
+    }
     // Identifiers like 'a.b' in 'new a.b()' might be rewritten if resolver
     // sees that 'a' is actually a class name, so 'b' is a constructor name.
     //
     if (expected is ConstructorName && actual is ConstructorName) {
       Identifier expectedTypeName = expected.type.name;
       Identifier actualTypeName = actual.type.name;
       if (expectedTypeName is PrefixedIdentifier &&
           actualTypeName is SimpleIdentifier) {
         return isEqualNodes(expectedTypeName.prefix, actualTypeName) &&
             isEqualNodes(expectedTypeName.identifier, actual.name);
@@ skipping 80 matching lines @@
     expect(oldClass, isNotNull);
     element = oldClass.element;
     oldVersion = element.version;
     oldMembers = oldClass.members.toList();
   }
 
   ClassDeclaration _findClassNode(CompilationUnit unit, String name) =>
       unit.declarations.singleWhere((unitMember) =>
           unitMember is ClassDeclaration && unitMember.name.name == name);
 }