Evaluate annotations using ConstantValueComputer.

pkg/analyzer/lib/src/generated/constant.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.constant;
 
 import 'dart:collection';
@@ skipping 210 matching lines @@
     DartObjectImpl result =
         expression.accept(new ConstantVisitor.con1(_typeProvider, errorReporter));
     if (result != null) {
       return EvaluationResult.forValue(result);
     }
     return EvaluationResult.forErrors(errorListener.errors);
   }
 }
 
 /**
- * Instances of the class `ConstantFinder` are used to traverse the AST structures of all of
- * the compilation units being resolved and build a table mapping constant variable elements to the
- * declarations of those variables.
+ * Instances of the class `ConstantFinder` are used to traverse the AST
+ * structures of all of the compilation units being resolved and build tables
+ * of the constant variables, constant constructors, constant constructor
+ * invocations, and annotations found in those compilation units.
  */
 class ConstantFinder extends RecursiveAstVisitor<Object> {
   /**
    * A table mapping constant variable elements to the declarations of those variables.
    */
   final HashMap<VariableElement, VariableDeclaration> variableMap =
       new HashMap<VariableElement, VariableDeclaration>();
 
   /**
    * A table mapping constant constructors to the declarations of those constructors.
    */
   final HashMap<ConstructorElement, ConstructorDeclaration> constructorMap =
       new HashMap<ConstructorElement, ConstructorDeclaration>();
 
   /**
    * A collection of constant constructor invocations.
    */
   final List<InstanceCreationExpression> constructorInvocations =
       new List<InstanceCreationExpression>();
 
+  /**
+   * A collection of annotations.
+   */
+  final List<Annotation> annotations = <Annotation>[];
+
+  @override
+  Object visitAnnotation(Annotation node) {
+    super.visitAnnotation(node);
+    annotations.add(node);
+    return null;
+  }
+
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
     if (node.constKeyword != null) {
       ConstructorElement element = node.element;
       if (element != null) {
         constructorMap[element] = node;
       }
     }
     return null;
@@ skipping 86 matching lines @@
    * A table mapping constant constructors to the declarations of those constructors.
    */
   HashMap<ConstructorElement, ConstructorDeclaration> constructorDeclarationMap;
 
   /**
    * A collection of constant constructor invocations.
    */
   List<InstanceCreationExpression> _constructorInvocations;
 
   /**
+   * A collection of annotations.
+   */
+  List<Annotation> _annotations;
+
+  /**
    * The set of variables declared on the command line using '-D'.
    */
   final DeclaredVariables _declaredVariables;
 
   /**
    * Initialize a newly created constant value computer.
    *
    * @param typeProvider the type provider used to access known types
    * @param declaredVariables the set of variables declared on the command line using '-D'
    */
@@ skipping 33 matching lines @@
   void beforeGetParameterDefault(ParameterElement parameter) {
   }
 
   /**
    * Compute values for all of the constants in the compilation units that were added.
    */
   void computeValues() {
     _variableDeclarationMap = _constantFinder.variableMap;
     constructorDeclarationMap = _constantFinder.constructorMap;
     _constructorInvocations = _constantFinder.constructorInvocations;
+    _annotations = _constantFinder.annotations;
     _variableDeclarationMap.values.forEach((VariableDeclaration declaration) {
       ReferenceFinder referenceFinder = new ReferenceFinder(
           declaration,
           referenceGraph,
           _variableDeclarationMap,
           constructorDeclarationMap);
       referenceGraph.addNode(declaration);
       declaration.initializer.accept(referenceFinder);
     });
     constructorDeclarationMap.forEach(
@@ skipping 68 matching lines @@
         referenceGraph.computeTopologicalSort();
     for (List<AstNode> constantsInCycle in topologicalSort) {
       if (constantsInCycle.length == 1) {
         _computeValueFor(constantsInCycle[0]);
       } else {
         for (AstNode constant in constantsInCycle) {
           _generateCycleError(constantsInCycle, constant);
         }
       }
     }
+    // Since no constant can depend on an annotation, we don't waste time
+    // including them in the topological sort.  We just process all the
+    // annotations after all other constants are finished.
+    for (Annotation annotation in _annotations) {
+      _computeValueFor(annotation);
+    }
   }
 
   /**
    * Create the ConstantVisitor used to evaluate constants. Unit tests will override this method to
    * introduce additional error checking.
    */
   ConstantVisitor createConstantVisitor(ErrorReporter errorReporter) =>
       new ConstantVisitor.con1(typeProvider, errorReporter);
 
   ConstructorDeclaration
@@ skipping 129 matching lines @@
         if (defaultValue != null) {
           RecordingErrorListener errorListener = new RecordingErrorListener();
           ErrorReporter errorReporter =
               new ErrorReporter(errorListener, element.source);
           DartObjectImpl dartObject =
               defaultValue.accept(createConstantVisitor(errorReporter));
           (element as ParameterElementImpl).evaluationResult =
               new EvaluationResultImpl.con2(dartObject, errorListener.errors);
         }
       }
+    } else if (constNode is Annotation) {
+      ElementAnnotationImpl elementAnnotation = constNode.elementAnnotation;
+      // elementAnnotation is null if the annotation couldn't be resolved, in
+      // which case we skip it.
+      if (elementAnnotation != null) {
+        Element element = elementAnnotation.element;
+        if (element is PropertyAccessorElement &&
+            element.variable is VariableElementImpl) {
+          // The annotation is a reference to a compile-time constant variable.
+          // Just copy the evaluation result.
+          VariableElementImpl variableElement =
+              element.variable as VariableElementImpl;
+          elementAnnotation.evaluationResult = variableElement.evaluationResult;
+        } else if (element is ConstructorElementImpl &&
+            constNode.arguments != null) {
+          RecordingErrorListener errorListener = new RecordingErrorListener();
+          CompilationUnit sourceCompilationUnit =
+              constNode.getAncestor((node) => node is CompilationUnit);
+          ErrorReporter errorReporter =
+              new ErrorReporter(errorListener, sourceCompilationUnit.element.source);
+          ConstantVisitor constantVisitor =
+              createConstantVisitor(errorReporter);
+          DartObjectImpl result = _evaluateConstructorCall(
+              constNode,
+              constNode.arguments.arguments,
+              element,
+              constantVisitor,
+              errorReporter);
+          elementAnnotation.evaluationResult =
+              new EvaluationResultImpl.con2(result, errorListener.errors);
+        } else {
+          // This may happen for invalid code (e.g. failing to pass arguments
+          // to an annotation which references a const constructor).  The error
+          // is detected elsewhere, so just silently ignore it here.
+          elementAnnotation.evaluationResult =
+              new EvaluationResultImpl.con1(null);
+        }
+      }
     } else {
       // Should not happen.
       AnalysisEngine.instance.logger.logError(
           "Constant value computer trying to compute the value of a node which is not a VariableDeclaration, InstanceCreationExpression, FormalParameter, or ConstructorDeclaration");
       return;
     }
   }
 
   /**
    * Evaluate a call to fromEnvironment() on the bool, int, or String class.
@@ skipping 4464 matching lines @@
       return BoolState.from(_element == rightElement);
     } else if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.FALSE_STATE;
   }
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }