Use ElementAnnotation as the ConstantEvaluationTarget for annotations.

pkg/analyzer/test/generated/constant_test.dart

 // Copyright (c) 2016, 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.constant_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 481 matching lines @@
     _typeProvider = new TestTypeProvider();
     _context = new _TestAnalysisContext();
     _source = new TestSource();
   }
 
   /**
    * Test an annotation that consists solely of an identifier (and hence
    * represents a reference to a compile-time constant variable).
    */
   void test_visitAnnotation_constantVariable() {
-    _node = AstFactory.annotation(AstFactory.identifier3('x'));
+    CompilationUnitElement compilationUnitElement =
+        ElementFactory.compilationUnit('/test.dart', _source)..source = _source;
+    ElementFactory.library(_context, 'L').definingCompilationUnit =
+        compilationUnitElement;
+    ElementAnnotationImpl elementAnnotation =
+        new ElementAnnotationImpl(compilationUnitElement);
+    _node = elementAnnotation.annotationAst = AstFactory.annotation(
+        AstFactory.identifier3('x'))..elementAnnotation = elementAnnotation;
     expect(_findAnnotations(), contains(_node));
   }
 
   /**
    * Test an annotation that represents the invocation of a constant
    * constructor.
    */
   void test_visitAnnotation_invocation() {
-    _node = AstFactory.annotation2(
+    CompilationUnitElement compilationUnitElement =
+        ElementFactory.compilationUnit('/test.dart', _source)..source = _source;
+    ElementFactory.library(_context, 'L').definingCompilationUnit =
+        compilationUnitElement;
+    ElementAnnotationImpl elementAnnotation =
+        new ElementAnnotationImpl(compilationUnitElement);
+    _node = elementAnnotation.annotationAst = AstFactory.annotation2(
+        AstFactory.identifier3('A'), null, AstFactory.argumentList())
+      ..elementAnnotation = elementAnnotation;
+    expect(_findAnnotations(), contains(_node));
+  }
+
+  void test_visitAnnotation_partOf() {
+    // Analyzer ignores annotations on "part of" directives.
+    Annotation annotation = AstFactory.annotation2(
         AstFactory.identifier3('A'), null, AstFactory.argumentList());
-    expect(_findAnnotations(), contains(_node));
+    _node = AstFactory.partOfDirective2(
+        <Annotation>[annotation], AstFactory.libraryIdentifier2(<String>['L']));
+    expect(_findConstants(), isEmpty);
   }
 
   void test_visitConstructorDeclaration_const() {
     ConstructorElement element = _setupConstructorDeclaration("A", true);
     expect(_findConstants(), contains(element));
   }
 
   void test_visitConstructorDeclaration_nonConst() {
     _setupConstructorDeclaration("A", false);
     expect(_findConstants(), isEmpty);
@@ skipping 59 matching lines @@
 
   void test_visitVariableDeclaration_uninitialized_static_const_inClass() {
     _setupFieldDeclaration('C', 'f', Keyword.CONST,
         isStatic: true, isInitialized: false);
     expect(_findConstants(), isEmpty);
   }
 
   List<Annotation> _findAnnotations() {
     Set<Annotation> annotations = new Set<Annotation>();
     for (ConstantEvaluationTarget target in _findConstants()) {
-      if (target is ConstantEvaluationTarget_Annotation) {
+      if (target is ElementAnnotationImpl) {
         expect(target.context, same(_context));
         expect(target.source, same(_source));
-        annotations.add(target.annotation);
+        annotations.add(target.annotationAst);
       }
     }
     return new List<Annotation>.from(annotations);
   }
 
   Set<ConstantEvaluationTarget> _findConstants() {
     ConstantFinder finder = new ConstantFinder(_context, _source, _source);
     _node.accept(finder);
     Set<ConstantEvaluationTarget> constants = finder.constantsToCompute;
     expect(constants, isNotNull);
@@ skipping 1210 matching lines @@
   bool _assertValidBool(EvaluationResultImpl result) {
     expect(result.value, isNotNull);
     DartObjectImpl value = result.value;
     expect(value.type, typeProvider.boolType);
     bool boolValue = value.toBoolValue();
     expect(boolValue, isNotNull);
     return boolValue;
   }
 
   int _assertValidInt(EvaluationResultImpl result) {
+    expect(result, isNotNull);
     expect(result.value, isNotNull);
     DartObjectImpl value = result.value;
     expect(value.type, typeProvider.intType);
     return value.toIntValue();
   }
 
   void _assertValidNull(EvaluationResultImpl result) {
     expect(result.value, isNotNull);
     DartObjectImpl value = result.value;
     expect(value.type, typeProvider.nullType);
@@ skipping 2669 matching lines @@
 
   void _visitNode(AstNode node) {
     node.accept(_createReferenceFinder(_head));
   }
 }
 
 class _TestAnalysisContext extends TestAnalysisContext {
   @override
   InternalAnalysisContext getContextFor(Source source) => this;
 }