Unify evaluation of annotations with evaluation of other constants.

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 'package:analyzer/file_system/file_system.dart';
@@ skipping 15 matching lines @@
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/sdk_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/testing/html_factory.dart';
 import 'package:analyzer/src/generated/testing/test_type_provider.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:analyzer/src/task/dart.dart';
 import 'package:path/src/context.dart';
 import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
+import 'engine_test.dart';
 import 'parser_test.dart';
 import 'resolver_test.dart';
 import 'test_support.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(ConstantEvaluatorTest);
   runReflectiveTests(ConstantFinderTest);
   runReflectiveTests(ConstantValueComputerTest);
   runReflectiveTests(ConstantVisitorTest);
@@ skipping 416 matching lines @@
 
 /**
  * Implementation of [ConstantEvaluationValidator] used during unit tests;
  * verifies that any nodes referenced during constant evaluation are present in
  * the dependency graph.
  */
 class ConstantEvaluationValidator_ForTest
     implements ConstantEvaluationValidator {
   ConstantValueComputer computer;
 
-  Element _nodeBeingEvaluated;
+  ConstantEvaluationTarget _nodeBeingEvaluated;
 
   @override
-  void beforeComputeValue(Element element) {
-    _nodeBeingEvaluated = element;
+  void beforeComputeValue(ConstantEvaluationTarget constant) {
+    _nodeBeingEvaluated = constant;
   }
 
   @override
   void beforeGetConstantInitializers(ConstructorElement constructor) {
     // Make sure we properly recorded the dependency.
     expect(
         computer.referenceGraph.containsPath(_nodeBeingEvaluated, constructor),
         isTrue);
   }
 
   @override
-  void beforeGetEvaluationResult(Element element) {
+  void beforeGetEvaluationResult(ConstantEvaluationTarget constant) {
     // Make sure we properly recorded the dependency.
-    expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, element),
+    expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, constant),
         isTrue);
   }
 
   @override
   void beforeGetFieldEvaluationResult(FieldElementImpl field) {
     // Make sure we properly recorded the dependency.
     expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, field),
         isTrue);
   }
 
@@ skipping 382 matching lines @@
     expect(variables, hasLength(1));
     ConstantEvaluator evaluator =
         new ConstantEvaluator(source, analysisContext.typeProvider);
     return evaluator.evaluate(variables[0].initializer);
   }
 }
 
 @reflectiveTest
 class ConstantFinderTest extends EngineTestCase {
   AstNode _node;
-
   TypeProvider _typeProvider;
+  AnalysisContext _context;
+  Source _source;
 
   void setUp() {
     super.setUp();
     _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'));
     expect(_findAnnotations(), contains(_node));
   }
@@ skipping 73 matching lines @@
     expect(_findConstants(), isNot(contains(field.element)));
   }
 
   void test_visitVariableDeclaration_uninitialized_static_const_inClass() {
     _setupFieldDeclaration('C', 'f', Keyword.CONST,
         isStatic: true, isInitialized: false);
     expect(_findConstants(), isEmpty);
   }
 
   List<Annotation> _findAnnotations() {
-    ConstantFinder finder = new ConstantFinder();
-    _node.accept(finder);
-    List<Annotation> annotations = finder.annotations;
-    expect(annotations, isNotNull);
-    return annotations;
+    Set<Annotation> annotations = new Set<Annotation>();
+    for (ConstantEvaluationTarget target in _findConstants()) {
+      if (target is ConstantEvaluationTarget_Annotation) {
+        expect(target.context, same(_context));
+        expect(target.source, same(_source));
+        annotations.add(target.annotation);
+      }
+    }
+    return new List<Annotation>.from(annotations);
   }
 
-  Set<Element> _findConstants() {
-    ConstantFinder finder = new ConstantFinder();
+  Set<ConstantEvaluationTarget> _findConstants() {
+    ConstantFinder finder = new ConstantFinder(_context, _source, _source);
     _node.accept(finder);
-    Set<Element> constants = finder.constantsToCompute;
+    Set<ConstantEvaluationTarget> constants = finder.constantsToCompute;
     expect(constants, isNotNull);
     return constants;
   }
 
   ConstructorElement _setupConstructorDeclaration(String name, bool isConst) {
     Keyword constKeyword = isConst ? Keyword.CONST : null;
     ConstructorDeclaration constructorDeclaration = AstFactory
         .constructorDeclaration2(constKeyword, null, null, name,
             AstFactory.formalParameterList(), null,
             AstFactory.blockFunctionBody2());
@@ skipping 236 matching lines @@
     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);
     analysisContext.computeErrors(librarySource);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(unit);
+    computer.add(unit, librarySource, librarySource);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
     expect(members, hasLength(3));
     _validate(false, (members[0] as TopLevelVariableDeclaration).variables);
     _validate(false, (members[1] as TopLevelVariableDeclaration).variables);
     _validate(false, (members[2] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_dependentVariables() {
     Source librarySource = addSource(r'''
 const int b = a;
 const int a = 0;''');
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(unit);
+    computer.add(unit, librarySource, librarySource);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
     expect(members, hasLength(2));
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
     _validate(true, (members[1] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_empty() {
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.computeValues();
@@ skipping 10 matching lines @@
 const int b = a;
 const int d = c;''');
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit libraryUnit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(libraryUnit, isNotNull);
     CompilationUnit partUnit =
         analysisContext.resolveCompilationUnit(partSource, libraryElement);
     expect(partUnit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(libraryUnit);
-    computer.add(partUnit);
+    computer.add(libraryUnit, librarySource, librarySource);
+    computer.add(partUnit, partSource, librarySource);
     computer.computeValues();
     NodeList<CompilationUnitMember> libraryMembers = libraryUnit.declarations;
     expect(libraryMembers, hasLength(2));
     _validate(
         true, (libraryMembers[0] as TopLevelVariableDeclaration).variables);
     _validate(
         true, (libraryMembers[1] as TopLevelVariableDeclaration).variables);
     NodeList<CompilationUnitMember> partMembers = libraryUnit.declarations;
     expect(partMembers, hasLength(2));
     _validate(true, (partMembers[0] as TopLevelVariableDeclaration).variables);
     _validate(true, (partMembers[1] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_singleVariable() {
     Source librarySource = addSource("const int a = 0;");
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(unit);
+    computer.add(unit, librarySource, librarySource);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
     expect(members, hasLength(1));
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_value_depends_on_enum() {
     Source librarySource = addSource('''
 enum E { id0, id1 }
 const E e = E.id0;
 ''');
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(unit);
+    computer.add(unit, librarySource, librarySource);
     computer.computeValues();
     TopLevelVariableDeclaration declaration = unit.declarations
         .firstWhere((member) => member is TopLevelVariableDeclaration);
     _validate(true, declaration.variables);
   }
 
   void test_dependencyOnConstructor() {
     // x depends on "const A()"
     _assertProperDependencies(r'''
 class A {
@@ skipping 795 matching lines @@
   }
 
   void _assertProperDependencies(String sourceText,
       [List<ErrorCode> expectedErrorCodes = ErrorCode.EMPTY_LIST]) {
     Source source = addSource(sourceText);
     LibraryElement element = resolve(source);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, element);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(unit);
+    computer.add(unit, source, source);
     computer.computeValues();
     assertErrors(source, expectedErrorCodes);
   }
 
   Map<String, DartObjectImpl> _assertType(
       EvaluationResultImpl result, String typeName) {
     expect(result.value, isNotNull);
     DartObjectImpl value = result.value;
     expect(value.type.displayName, typeName);
     return value.fields;
@@ skipping 157 matching lines @@
       CompilationUnit compilationUnit, String name) {
     VariableDeclaration varDecl =
         findTopLevelDeclaration(compilationUnit, name);
     ConstTopLevelVariableElementImpl varElement = varDecl.element;
     return varElement.evaluationResult;
   }
 
   ConstantValueComputer _makeConstantValueComputer() {
     ConstantEvaluationValidator_ForTest validator =
         new ConstantEvaluationValidator_ForTest();
-    validator.computer = new ConstantValueComputer(
+    validator.computer = new ConstantValueComputer(analysisContext2,
         analysisContext2.typeProvider, analysisContext2.declaredVariables,
         validator);
     return validator.computer;
   }
 
   void _validate(bool shouldBeValid, VariableDeclarationList declarationList) {
     for (VariableDeclaration declaration in declarationList.variables) {
       VariableElementImpl element = declaration.element as VariableElementImpl;
       expect(element, isNotNull);
       EvaluationResultImpl result = element.evaluationResult;
@@ skipping 5649 matching lines @@
 
   @override
   SdkLibrary getSdkLibrary(String dartUri) => null;
 
   @override
   Source mapDartUri(String dartUri) => null;
 }
 
 @reflectiveTest
 class ReferenceFinderTest extends EngineTestCase {
-  DirectedGraph<Element> _referenceGraph;
+  DirectedGraph<ConstantEvaluationTarget> _referenceGraph;
   VariableElement _head;
   Element _tail;
   @override
   void setUp() {
-    _referenceGraph = new DirectedGraph<Element>();
+    _referenceGraph = new DirectedGraph<ConstantEvaluationTarget>();
     _head = ElementFactory.topLevelVariableElement2("v1");
   }
   void test_visitSimpleIdentifier_const() {
     _visitNode(_makeTailVariable("v2", true));
     _assertOneArc(_tail);
   }
   void test_visitSimpleIdentifier_nonConst() {
     _visitNode(_makeTailVariable("v2", false));
     _assertNoArcs();
   }
   void test_visitSuperConstructorInvocation_const() {
     _visitNode(_makeTailSuperConstructorInvocation("A", true));
     _assertOneArc(_tail);
   }
   void test_visitSuperConstructorInvocation_nonConst() {
     _visitNode(_makeTailSuperConstructorInvocation("A", false));
     _assertNoArcs();
   }
   void test_visitSuperConstructorInvocation_unresolved() {
     SuperConstructorInvocation superConstructorInvocation =
         AstFactory.superConstructorInvocation();
     _visitNode(superConstructorInvocation);
     _assertNoArcs();
   }
   void _assertNoArcs() {
-    Set<Element> tails = _referenceGraph.getTails(_head);
+    Set<ConstantEvaluationTarget> tails = _referenceGraph.getTails(_head);
     expect(tails, hasLength(0));
   }
   void _assertOneArc(Element tail) {
-    Set<Element> tails = _referenceGraph.getTails(_head);
+    Set<ConstantEvaluationTarget> tails = _referenceGraph.getTails(_head);
     expect(tails, hasLength(1));
     expect(tails.first, same(tail));
   }
-  ReferenceFinder _createReferenceFinder(Element source) =>
-      new ReferenceFinder((Element dependency) {
+  ReferenceFinder _createReferenceFinder(ConstantEvaluationTarget source) =>
+      new ReferenceFinder((ConstantEvaluationTarget dependency) {
     _referenceGraph.addEdge(source, dependency);
   });
   SuperConstructorInvocation _makeTailSuperConstructorInvocation(
       String name, bool isConst) {
     List<ConstructorInitializer> initializers =
         new List<ConstructorInitializer>();
     ConstructorDeclaration constructorDeclaration = AstFactory
         .constructorDeclaration(AstFactory.identifier3(name), null,
             AstFactory.formalParameterList(), initializers);
     if (isConst) {
@@ skipping 591 matching lines @@
     if (_expectedExternalScriptName == null) {
       expect(scriptSource, isNull, reason: "script $scriptIndex");
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(actualExternalScriptName, _expectedExternalScriptName,
           reason: "script $scriptIndex");
     }
   }
 }