Evaluate annotations using ConstantValueComputer.

pkg/analyzer/test/generated/all_the_rest_test.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.all_the_rest_test;
 
 import 'dart:collection';
@@ skipping 3361 matching lines @@
         source,
         (analysisContext as AnalysisContextImpl).typeProvider);
     return evaluator.evaluate(variables[0].initializer);
   }
 }
 
 
 class ConstantFinderTest extends EngineTestCase {
   AstNode _node;
 
+  /**
+   * 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'));
+    expect(_findAnnotations(), contains(_node));
+  }
+
+  /**
+   * Test an annotation that represents the invocation of a constant
+   * constructor.
+   */
+  void test_visitAnnotation_invocation() {
+    _node = AstFactory.annotation2(
+        AstFactory.identifier3('A'),
+        null,
+        AstFactory.argumentList());
+    expect(_findAnnotations(), contains(_node));
+  }
+
   void test_visitConstructorDeclaration_const() {
     ConstructorElement element = _setupConstructorDeclaration("A", true);
     expect(_findConstantDeclarations()[element], same(_node));
   }
 
   void test_visitConstructorDeclaration_nonConst() {
     _setupConstructorDeclaration("A", false);
     expect(_findConstantDeclarations().isEmpty, isTrue);
   }
 
@@ skipping 15 matching lines @@
   void test_visitVariableDeclaration_noInitializer() {
     _setupVariableDeclaration("v", true, false);
     expect(_findVariableDeclarations().isEmpty, isTrue);
   }
 
   void test_visitVariableDeclaration_nonConst() {
     _setupVariableDeclaration("v", false, true);
     expect(_findVariableDeclarations().isEmpty, isTrue);
   }
 
+  List<Annotation> _findAnnotations() {
+    ConstantFinder finder = new ConstantFinder();
+    _node.accept(finder);
+    List<Annotation> annotations = finder.annotations;
+    expect(annotations, isNotNull);
+    return annotations;
+  }
+
   Map<ConstructorElement, ConstructorDeclaration> _findConstantDeclarations() {
     ConstantFinder finder = new ConstantFinder();
     _node.accept(finder);
     Map<ConstructorElement, ConstructorDeclaration> constructorMap =
         finder.constructorMap;
     expect(constructorMap, isNotNull);
     return constructorMap;
   }
 
   List<InstanceCreationExpression> _findConstructorInvocations() {
@@ skipping 49 matching lines @@
     AstFactory.variableDeclarationList2(
         isConst ? Keyword.CONST : null,
         [variableDeclaration]);
     _node = variableDeclaration;
     return element;
   }
 }
 
 
 class ConstantValueComputerTest extends ResolverTestCase {
+  void test_annotation_constConstructor() {
+    CompilationUnit compilationUnit = resolveSource(r'''
+class A {
+  final int i;
+  const A(this.i);
+}
+
+class C {
+  @A(5)
+  f() {}
+}
+''');
+    EvaluationResultImpl result =
+        _evaluateAnnotation(compilationUnit, "C", "f");
+    Map<String, DartObjectImpl> annotationFields = _assertType(result, 'A');
+    _assertIntField(annotationFields, 'i', 5);
+  }
+
+  void test_annotation_constConstructor_named() {
+    CompilationUnit compilationUnit = resolveSource(r'''
+class A {
+  final int i;
+  const A.named(this.i);
+}
+
+class C {
+  @A.named(5)
+  f() {}
+}
+''');
+    EvaluationResultImpl result =
+        _evaluateAnnotation(compilationUnit, "C", "f");
+    Map<String, DartObjectImpl> annotationFields = _assertType(result, 'A');
+    _assertIntField(annotationFields, 'i', 5);
+  }
+
+  void test_annotation_constConstructor_noArgs() {
+    // Failing to pass arguments to an annotation which is a constant
+    // constructor is illegal, but shouldn't crash analysis.
+    CompilationUnit compilationUnit = resolveSource(r'''
+class A {
+  final int i;
+  const A(this.i);
+}
+
+class C {
+  @A
+  f() {}
+}
+''');
+    _evaluateAnnotation(compilationUnit, "C", "f");
+  }
+
+  void test_annotation_constConstructor_noArgs_named() {
+    // Failing to pass arguments to an annotation which is a constant
+    // constructor is illegal, but shouldn't crash analysis.
+    CompilationUnit compilationUnit = resolveSource(r'''
+class A {
+  final int i;
+  const A.named(this.i);
+}
+
+class C {
+  @A.named
+  f() {}
+}
+''');
+    _evaluateAnnotation(compilationUnit, "C", "f");
+  }
+
+  void test_annotation_nonConstConstructor() {
+    // Calling a non-const constructor from an annotation that is illegal, but
+    // shouldn't crash analysis.
+    CompilationUnit compilationUnit = resolveSource(r'''
+class A {
+  final int i;
+  A(this.i);
+}
+
+class C {
+  @A(5)
+  f() {}
+}
+''');
+    _evaluateAnnotation(compilationUnit, "C", "f");
+  }
+
+  void test_annotation_staticConst() {
+    CompilationUnit compilationUnit = resolveSource(r'''
+class C {
+  static const int i = 5;
+
+  @i
+  f() {}
+}
+''');
+    EvaluationResultImpl result =
+        _evaluateAnnotation(compilationUnit, "C", "f");
+    expect(_assertValidInt(result), 5);
+  }
+
+  void test_annotation_staticConst_args() {
+    // Applying arguments to an annotation that is a static const is
+    // illegal, but shouldn't crash analysis.
+    CompilationUnit compilationUnit = resolveSource(r'''
+class C {
+  static const int i = 5;
+
+  @i(1)
+  f() {}
+}
+''');
+    _evaluateAnnotation(compilationUnit, "C", "f");
+  }
+
+  void test_annotation_staticConst_otherClass() {
+    CompilationUnit compilationUnit = resolveSource(r'''
+class A {
+  static const int i = 5;
+}
+
+class C {
+  @A.i
+  f() {}
+}
+''');
+    EvaluationResultImpl result =
+        _evaluateAnnotation(compilationUnit, "C", "f");
+    expect(_assertValidInt(result), 5);
+  }
+
+  void test_annotation_staticConst_otherClass_args() {
+    // Applying arguments to an annotation that is a static const is
+    // illegal, but shouldn't crash analysis.
+    CompilationUnit compilationUnit = resolveSource(r'''
+class A {
+  static const int i = 5;
+}
+
+class C {
+  @A.i(1)
+  f() {}
+}
+''');
+    _evaluateAnnotation(compilationUnit, "C", "f");
+  }
+
+  void test_annotation_toplevelVariable() {
+    CompilationUnit compilationUnit = resolveSource(r'''
+const int i = 5;
+class C {
+  @i
+  f() {}
+}
+''');
+    EvaluationResultImpl result =
+        _evaluateAnnotation(compilationUnit, "C", "f");
+    expect(_assertValidInt(result), 5);
+  }
+
+  void test_annotation_toplevelVariable_args() {
+    // Applying arguments to an annotation that is a toplevel variable is
+    // illegal, but shouldn't crash analysis.
+    CompilationUnit compilationUnit = resolveSource(r'''
+const int i = 5;
+class C {
+  @i(1)
+  f() {}
+}
+''');
+    _evaluateAnnotation(compilationUnit, "C", "f");
+  }
+
   void test_computeValues_cycle() {
     TestLogger logger = new TestLogger();
     AnalysisEngine.instance.logger = logger;
     Source librarySource = addSource(r'''
 const int a = c;
 const int b = a;
 const int c = b;''');
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
@@ skipping 965 matching lines @@
     } else {
       _assertNullField(fieldsOfX, fieldName);
     }
     EvaluationResultImpl y =
         _evaluateInstanceCreationExpression(compilationUnit, "y");
     Map<String, DartObjectImpl> fieldsOfY = _assertType(y, "A");
     expect(fieldsOfY, hasLength(1));
     _assertIntField(fieldsOfY, fieldName, 10);
   }
 
+  /**
+   * Search [compilationUnit] for a class named [className], containing a
+   * method [methodName], with exactly one annotation.  Return the constant
+   * value of the annotation.
+   */
+  EvaluationResultImpl _evaluateAnnotation(CompilationUnit compilationUnit,
+      String className, String memberName) {
+    for (CompilationUnitMember member in compilationUnit.declarations) {
+      if (member is ClassDeclaration && member.name.name == className) {
+        for (ClassMember classMember in member.members) {
+          if (classMember is MethodDeclaration &&
+              classMember.name.name == memberName) {
+            expect(classMember.metadata, hasLength(1));
+            ElementAnnotationImpl elementAnnotation =
+                classMember.metadata[0].elementAnnotation;
+            return elementAnnotation.evaluationResult;
+          }
+        }
+      }
+    }
+    fail('Class member not found');
+    return null;
+  }
+
   EvaluationResultImpl
       _evaluateInstanceCreationExpression(CompilationUnit compilationUnit,
       String name) {
     Expression expression =
         findTopLevelConstantExpression(compilationUnit, name);
     return (expression as InstanceCreationExpression).evaluationResult;
   }
 
   ConstantValueComputer _makeConstantValueComputer() {
     return new ValidatingConstantValueComputer(
@@ skipping 6664 matching lines @@
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(
           actualExternalScriptName,
           _expectedExternalScriptName,
           reason: "script $scriptIndex");
     }
   }
 }