Use ElementAnnotation as the ConstantEvaluationTarget for annotations.

pkg/analysis_server/lib/src/status/validator.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 analysis_server.src.status.validator;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisEngine, AnalysisResult, CacheState, ChangeSet;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/html.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:html/dom.dart' as html;
+import 'package:analyzer/src/dart/element/element.dart';
 
 /**
  * A class used to compare two element models for equality.
  */
 class ElementComparator {
   /**
    * The buffer to which any discovered differences will be recorded.
    */
   final StringBuffer _buffer = new StringBuffer();
 
@@ skipping 1149 matching lines @@
     // Compare possible null values.
     //
     if (first == null) {
       return second == null;
     } else if (second == null) {
       return false;
     }
     //
     // Handle special cases.
     //
-    if (first is ConstantEvaluationTarget_Annotation &&
-        second is ConstantEvaluationTarget_Annotation) {
+    if (first is ElementAnnotationImpl &&
+        second is ElementAnnotationImpl) {
       return _equal(first.source, second.source) &&
           _equal(first.librarySource, second.librarySource) &&
-          _equal(first.annotation, second.annotation);
+          _equal(first.annotationAst, second.annotationAst);
     } else if (first is AstNode && second is AstNode) {
       return first.runtimeType == second.runtimeType &&
           first.offset == second.offset &&
           first.length == second.length;
     }
     //
     // Handle the general case.
     //
     return first == second;
   }
 
   /**
    * Return a hash code for the given [object].
    */
   static int _hashCode(Object object) {
     //
     // Handle special cases.
     //
-    if (object is ConstantEvaluationTarget_Annotation) {
+    if (object is ElementAnnotation) {
       return object.source.hashCode;
     } else if (object is AstNode) {
       return object.offset;
     }
     //
     // Handle the general case.
     //
     return object.hashCode;
   }
 }
@@ skipping 71 matching lines @@
     if (buffer != null) {
       // TODO(brianwilkerson) Compute where the difference is rather than just
       // whether there is a difference.
       buffer.write('Different AST nodes');
     }
     return false;
   }
 
   bool _compareConstantEvaluationTargets(ConstantEvaluationTarget expected,
       ConstantEvaluationTarget actual, StringBuffer buffer) {
-    if (actual is ConstantEvaluationTarget_Annotation) {
-      ConstantEvaluationTarget_Annotation expectedAnnotation = expected;
-      ConstantEvaluationTarget_Annotation actualAnnotation = actual;
+    if (actual is ElementAnnotation) {
+      ElementAnnotationImpl expectedAnnotation = expected;
+      ElementAnnotationImpl actualAnnotation = actual;
       if (actualAnnotation.source == expectedAnnotation.source &&
           actualAnnotation.librarySource == expectedAnnotation.librarySource &&
-          actualAnnotation.annotation == expectedAnnotation.annotation) {
+          actualAnnotation.annotationAst == expectedAnnotation.annotationAst) {
         return true;
       }
       if (buffer != null) {
-        void write(ConstantEvaluationTarget_Annotation target) {
-          Annotation annotation = target.annotation;
+        void write(ElementAnnotationImpl target) {
+          Annotation annotation = target.annotationAst;
           buffer.write(annotation);
           buffer.write(' at ');
           buffer.write(annotation.offset);
           buffer.write(' in ');
           buffer.write(target.source);
           buffer.write(' in ');
           buffer.write(target.librarySource);
         }
 
         buffer.write('Expected ');
@@ skipping 447 matching lines @@
    * Determine whether or not there is any interesting difference between the
    * original and cloned values.
    */
   void _performComparison() {
     StringBuffer buffer = new StringBuffer();
     if (!_compareObjects(cloneValue, originalValue, buffer)) {
       description = buffer.toString();
     }
   }
 }