Issue 22044. A changes in annotations should be considered as a mismatch.

pkg/analyzer/lib/src/generated/incremental_resolver.dart

 // Copyright (c) 2014, 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 engine.incremental_resolver;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'ast.dart';
@@ skipping 118 matching lines @@
   visitBlockFunctionBody(BlockFunctionBody node) {
     // ignore bodies
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
     String name = node.name.name;
     ClassElement element = _findElement(_enclosingUnit.types, name);
     _enclosingClass = element;
     _processElement(element);
+    _assertSameAnnotations(node, element);
     _assertSameTypeParameters(node.typeParameters, element.typeParameters);
     // check for missing clauses
     if (node.extendsClause == null) {
       _assertTrue(element.supertype.name == 'Object');
     }
     if (node.implementsClause == null) {
       _assertTrue(element.interfaces.isEmpty);
     }
     if (node.withClause == null) {
       _assertTrue(element.mixins.isEmpty);
@@ skipping 108 matching lines @@
     // prepare element
     Token property = node.propertyKeyword;
     ExecutableElementImpl element;
     if (property == null) {
       element = _findElement(_enclosingUnit.functions, name);
     } else {
       element = _findElement(_enclosingUnit.accessors, name);
     }
     // process element
     _processElement(element);
+    _assertSameAnnotations(node, element);
     _assertFalse(element.isSynthetic);
     _assertSameType(node.returnType, element.returnType);
     _assertCompatibleParameters(
         node.functionExpression.parameters,
         element.parameters);
     // matches, update the existing element
     ExecutableElement newElement = node.element;
     node.name.staticElement = element;
     node.functionExpression.element = element;
     _setLocalElements(element, newElement);
@@ skipping 54 matching lines @@
     ExecutableElementImpl element;
     if (property == null) {
       element = _findElement(_enclosingClass.methods, name);
     } else {
       element = _findElement(_enclosingClass.accessors, name);
     }
     // process element
     ExecutableElement newElement = node.element;
     try {
       _assertNotNull(element);
+      _assertSameAnnotations(node, element);
       _assertEquals(node.isStatic, element.isStatic);
       _assertSameType(node.returnType, element.returnType);
       _assertCompatibleParameters(node.parameters, element.parameters);
       _removedElements.remove(element);
       // matches, update the existing element
       node.name.staticElement = element;
       _setLocalElements(element, newElement);
     } on _DeclarationMismatchException catch (e) {
       _addedElements.add(newElement);
       _removeElement(element);
@@ skipping 36 matching lines @@
     // prepare variable
     String name = node.name.name;
     PropertyInducingElement element;
     if (_inTopLevelVariableDeclaration) {
       element = _findElement(_enclosingUnit.topLevelVariables, name);
     } else {
       element = _findElement(_enclosingClass.fields, name);
     }
     // verify
     PropertyInducingElement newElement = node.name.staticElement;
-    _assertNotNull(element);
     _processElement(element);
+    _assertSameAnnotations(node, element);
     _assertEquals(node.isConst, element.isConst);
     _assertEquals(node.isFinal, element.isFinal);
     if (_enclosingFieldNode != null) {
       _assertEquals(_enclosingFieldNode.isStatic, element.isStatic);
     }
     _assertSameType(
         (node.parent as VariableDeclarationList).type,
         element.type);
     // matches, restore the existing element
     node.name.staticElement = element;
@@ skipping 95 matching lines @@
       throw new _DeclarationMismatchException();
     }
   }
 
   void _assertNull(Object object) {
     if (object != null) {
       throw new _DeclarationMismatchException();
     }
   }
 
+  void _assertSameAnnotation(Annotation node, ElementAnnotation annotation) {
+    _assertNull(node.arguments);
+    Element element = annotation.element;
+    _assertTrue(element is PropertyAccessorElement);
+    _assertTrue(node.name is SimpleIdentifier);
+    String nodeName = node.name.name;
+    String elementName = element.displayName;
+    _assertEquals(nodeName, elementName);
+  }
+
+  void _assertSameAnnotations(AnnotatedNode node, Element element) {
+    List<Annotation> nodeAnnotaitons = node.metadata;
+    List<ElementAnnotation> elementAnnotations = element.metadata;
+    int length = nodeAnnotaitons.length;
+    _assertEquals(elementAnnotations.length, length);
+    for (int i = 0; i < length; i++) {
+      _assertSameAnnotation(nodeAnnotaitons[i], elementAnnotations[i]);
+    }
+  }
+
   void _assertSameType(TypeName node, DartType type) {
     // no return type == dynamic
     if (node == null) {
       return _assertTrue(type == null || type.isDynamic);
     }
     if (type == null) {
       return _assertTrue(false);
     }
     // prepare name
     Identifier nameIdentifier = node.name;
@@ skipping 1303 matching lines @@
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }