Store elements in the constant eval dependency graph rather than AST nodes.

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';
-
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/html.dart' as ht;
@@ skipping 446 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;
 
-  AstNode _nodeBeingEvaluated;
+  Element _nodeBeingEvaluated;
 
   @override
-  void beforeComputeValue(AstNode constNode) {
-    _nodeBeingEvaluated = constNode;
+  void beforeComputeValue(Element element) {
+    _nodeBeingEvaluated = element;
   }
 
   @override
   void beforeGetConstantInitializers(ConstructorElement constructor) {
-    // If we are getting the constant initializers for a node in the graph,
-    // make sure we properly recorded the dependency.
-    ConstructorDeclaration node =
-        computer.findConstructorDeclaration(constructor);
-    if (node != null && computer.referenceGraph.nodes.contains(node)) {
-      expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, node),
-          isTrue);
-    }
+    // Make sure we properly recorded the dependency.
+    expect(
+        computer.referenceGraph.containsPath(_nodeBeingEvaluated, constructor),
+        isTrue);
   }
 
   @override
-  void beforeGetEvaluationResult(AstNode node) {
-    // If we are getting the evaluation result for a node in the graph,
-    // make sure we properly recorded the dependency.
-    if (computer.referenceGraph.nodes.contains(node)) {
-      expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, node),
-          isTrue);
-    }
+  void beforeGetEvaluationResult(Element element) {
+    // Make sure we properly recorded the dependency.
+    expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, element),
+        isTrue);
   }
 
   @override
   void beforeGetFieldEvaluationResult(FieldElementImpl field) {
-    // If we are getting the constant value for a node in the graph, make sure
-    // we properly recorded the dependency.
-    VariableDeclaration node = computer.findVariableDeclaration(field);
-    if (node != null && computer.referenceGraph.nodes.contains(node)) {
-      expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, node),
-          isTrue);
-    }
+    // Make sure we properly recorded the dependency.
+    expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, field),
+        isTrue);
   }
 
   @override
   void beforeGetParameterDefault(ParameterElement parameter) {
-    // Find the ConstructorElement and figure out which
-    // parameter we're talking about.
-    ConstructorElement constructor =
-        parameter.getAncestor((element) => element is ConstructorElement);
-    int parameterIndex;
-    List<ParameterElement> parameters = constructor.parameters;
-    int numParameters = parameters.length;
-    for (parameterIndex = 0; parameterIndex < numParameters; parameterIndex++) {
-      if (identical(parameters[parameterIndex], parameter)) {
-        break;
-      }
-    }
-    expect(parameterIndex < numParameters, isTrue);
-    // If we are getting the default parameter for a constructor in the graph,
-    // make sure we properly recorded the dependency on the parameter.
-    ConstructorDeclaration constructorNode =
-        computer.constructorDeclarationMap[constructor];
-    if (constructorNode != null) {
-      FormalParameter parameterNode =
-          constructorNode.parameters.parameters[parameterIndex];
-      expect(computer.referenceGraph.nodes.contains(parameterNode), isTrue);
-      expect(computer.referenceGraph.containsPath(
-          _nodeBeingEvaluated, parameterNode), isTrue);
-    }
+    // Make sure we properly recorded the dependency.
+    expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, parameter),
+        isTrue);
   }
 }
 
 @reflectiveTest
 class ConstantEvaluatorTest extends ResolverTestCase {
   void fail_constructor() {
     EvaluationResult result = _getExpressionValue("?");
     expect(result.isValid, isTrue);
     DartObject value = result.value;
     expect(value, null);
@@ skipping 396 matching lines @@
    * 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));
+    expect(_findConstants(), contains(element));
   }
 
   void test_visitConstructorDeclaration_nonConst() {
     _setupConstructorDeclaration("A", false);
-    expect(_findConstantDeclarations().isEmpty, isTrue);
+    expect(_findConstants(), isEmpty);
   }
 
   void test_visitVariableDeclaration_const() {
     VariableElement element = _setupVariableDeclaration("v", true, true);
-    expect(_findVariableDeclarations()[element], same(_node));
+    expect(_findConstants(), contains(element));
   }
 
   void test_visitVariableDeclaration_final_inClass() {
     _setupFieldDeclaration('C', 'f', Keyword.FINAL);
-    expect(_findVariableDeclarations(), isEmpty);
+    expect(_findConstants(), isEmpty);
   }
 
   void test_visitVariableDeclaration_final_inClassWithConstConstructor() {
     VariableDeclaration field = _setupFieldDeclaration('C', 'f', Keyword.FINAL,
         hasConstConstructor: true);
-    expect(_findVariableDeclarations()[field.element], same(field));
+    expect(_findConstants(), contains(field.element));
   }
 
   void test_visitVariableDeclaration_final_outsideClass() {
     _setupVariableDeclaration('v', false, true, isFinal: true);
-    expect(_findVariableDeclarations(), isEmpty);
+    expect(_findConstants(), isEmpty);
   }
 
   void test_visitVariableDeclaration_noInitializer() {
     _setupVariableDeclaration("v", true, false);
-    expect(_findVariableDeclarations().isEmpty, isTrue);
+    expect(_findConstants(), isEmpty);
   }
 
   void test_visitVariableDeclaration_nonConst() {
     _setupVariableDeclaration("v", false, true);
-    expect(_findVariableDeclarations().isEmpty, isTrue);
+    expect(_findConstants(), isEmpty);
   }
 
   void test_visitVariableDeclaration_static_const_inClass() {
     VariableDeclaration field =
         _setupFieldDeclaration('C', 'f', Keyword.CONST, isStatic: true);
-    expect(_findVariableDeclarations()[field.element], same(field));
+    expect(_findConstants(), contains(field.element));
   }
 
   void test_visitVariableDeclaration_static_const_inClassWithConstConstructor() {
     VariableDeclaration field = _setupFieldDeclaration('C', 'f', Keyword.CONST,
         isStatic: true, hasConstConstructor: true);
-    expect(_findVariableDeclarations()[field.element], same(field));
+    expect(_findConstants(), contains(field.element));
   }
 
   void test_visitVariableDeclaration_static_final_inClassWithConstConstructor() {
-    _setupFieldDeclaration('C', 'f', Keyword.FINAL,
+    VariableDeclaration field = _setupFieldDeclaration('C', 'f', Keyword.FINAL,
         isStatic: true, hasConstConstructor: true);
-    expect(_findVariableDeclarations(), isEmpty);
+    expect(_findConstants(), isNot(contains(field.element)));
   }
 
   void test_visitVariableDeclaration_uninitialized_final_inClassWithConstConstructor() {
-    _setupFieldDeclaration('C', 'f', Keyword.FINAL,
+    VariableDeclaration field = _setupFieldDeclaration('C', 'f', Keyword.FINAL,
         isInitialized: false, hasConstConstructor: true);
-    expect(_findVariableDeclarations(), isEmpty);
+    expect(_findConstants(), isNot(contains(field.element)));
   }
 
   void test_visitVariableDeclaration_uninitialized_static_const_inClass() {
     _setupFieldDeclaration('C', 'f', Keyword.CONST,
         isStatic: true, isInitialized: false);
-    expect(_findVariableDeclarations(), isEmpty);
+    expect(_findConstants(), isEmpty);
   }
 
   List<Annotation> _findAnnotations() {
     ConstantFinder finder = new ConstantFinder();
     _node.accept(finder);
     List<Annotation> annotations = finder.annotations;
     expect(annotations, isNotNull);
     return annotations;
   }
 
-  Map<ConstructorElement, ConstructorDeclaration> _findConstantDeclarations() {
+  Set<Element> _findConstants() {
     ConstantFinder finder = new ConstantFinder();
     _node.accept(finder);
-    Map<ConstructorElement, ConstructorDeclaration> constructorMap =
-        finder.constructorMap;
-    expect(constructorMap, isNotNull);
-    return constructorMap;
-  }
-
-  Map<PotentiallyConstVariableElement, VariableDeclaration> _findVariableDeclarations() {
-    ConstantFinder finder = new ConstantFinder();
-    _node.accept(finder);
-    Map<PotentiallyConstVariableElement, VariableDeclaration> variableMap =
-        finder.variableMap;
-    expect(variableMap, isNotNull);
-    return variableMap;
+    Set<Element> 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());
     ClassElement classElement = ElementFactory.classElement2(name);
     ConstructorElement element =
@@ skipping 312 matching lines @@
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit);
     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.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 {
   const A();
 }
 const x = const A();''');
   }
 
   void test_dependencyOnConstructorArgument() {
@@ skipping 6637 matching lines @@
 
   @override
   SdkLibrary getSdkLibrary(String dartUri) => null;
 
   @override
   Source mapDartUri(String dartUri) => null;
 }
 
 @reflectiveTest
 class ReferenceFinderTest extends EngineTestCase {
-  DirectedGraph<AstNode> _referenceGraph;
-  Map<PotentiallyConstVariableElement, VariableDeclaration> _variableDeclarationMap;
-  Map<ConstructorElement, ConstructorDeclaration> _constructorDeclarationMap;
-  VariableDeclaration _head;
-  AstNode _tail;
+  DirectedGraph<Element> _referenceGraph;
+  VariableElement _head;
+  Element _tail;
   @override
   void setUp() {
-    _referenceGraph = new DirectedGraph<AstNode>();
-    _variableDeclarationMap =
-        new HashMap<PotentiallyConstVariableElement, VariableDeclaration>();
-    _constructorDeclarationMap =
-        new HashMap<ConstructorElement, ConstructorDeclaration>();
-    _head = AstFactory.variableDeclaration("v1");
+    _referenceGraph = new DirectedGraph<Element>();
+    _head = ElementFactory.topLevelVariableElement2("v1");
   }
   void test_visitSimpleIdentifier_const() {
-    _visitNode(_makeTailVariable("v2", true, true));
+    _visitNode(_makeTailVariable("v2", true));
     _assertOneArc(_tail);
   }
   void test_visitSimpleIdentifier_nonConst() {
-    _visitNode(_makeTailVariable("v2", false, true));
-    _assertNoArcs();
-  }
-  void test_visitSimpleIdentifier_notInMap() {
-    _visitNode(_makeTailVariable("v2", true, false));
+    _visitNode(_makeTailVariable("v2", false));
     _assertNoArcs();
   }
   void test_visitSuperConstructorInvocation_const() {
-    _visitNode(_makeTailSuperConstructorInvocation("A", true, true));
+    _visitNode(_makeTailSuperConstructorInvocation("A", true));
     _assertOneArc(_tail);
   }
   void test_visitSuperConstructorInvocation_nonConst() {
-    _visitNode(_makeTailSuperConstructorInvocation("A", false, true));
-    _assertNoArcs();
-  }
-  void test_visitSuperConstructorInvocation_notInMap() {
-    _visitNode(_makeTailSuperConstructorInvocation("A", true, false));
+    _visitNode(_makeTailSuperConstructorInvocation("A", false));
     _assertNoArcs();
   }
   void test_visitSuperConstructorInvocation_unresolved() {
     SuperConstructorInvocation superConstructorInvocation =
         AstFactory.superConstructorInvocation();
-    _tail = superConstructorInvocation;
     _visitNode(superConstructorInvocation);
     _assertNoArcs();
   }
   void _assertNoArcs() {
-    Set<AstNode> tails = _referenceGraph.getTails(_head);
+    Set<Element> tails = _referenceGraph.getTails(_head);
     expect(tails, hasLength(0));
   }
-  void _assertOneArc(AstNode tail) {
-    Set<AstNode> tails = _referenceGraph.getTails(_head);
+  void _assertOneArc(Element tail) {
+    Set<Element> tails = _referenceGraph.getTails(_head);
     expect(tails, hasLength(1));
     expect(tails.first, same(tail));
   }
-  ReferenceFinder _createReferenceFinder(AstNode source) => new ReferenceFinder(
-      source, _referenceGraph, _variableDeclarationMap,
-      _constructorDeclarationMap);
+  ReferenceFinder _createReferenceFinder(Element source) =>
+      new ReferenceFinder(source, _referenceGraph);
   SuperConstructorInvocation _makeTailSuperConstructorInvocation(
-      String name, bool isConst, bool inMap) {
+      String name, bool isConst) {
     List<ConstructorInitializer> initializers =
         new List<ConstructorInitializer>();
     ConstructorDeclaration constructorDeclaration = AstFactory
         .constructorDeclaration(AstFactory.identifier3(name), null,
             AstFactory.formalParameterList(), initializers);
-    _tail = constructorDeclaration;
     if (isConst) {
       constructorDeclaration.constKeyword = new KeywordToken(Keyword.CONST, 0);
     }
     ClassElementImpl classElement = ElementFactory.classElement2(name);
     SuperConstructorInvocation superConstructorInvocation =
         AstFactory.superConstructorInvocation();
     ConstructorElementImpl constructorElement =
         ElementFactory.constructorElement(classElement, name, isConst);
-    if (inMap) {
-      _constructorDeclarationMap[constructorElement] = constructorDeclaration;
-    }
+    _tail = constructorElement;
     superConstructorInvocation.staticElement = constructorElement;
     return superConstructorInvocation;
   }
-  SimpleIdentifier _makeTailVariable(String name, bool isConst, bool inMap) {
+  SimpleIdentifier _makeTailVariable(String name, bool isConst) {
     VariableDeclaration variableDeclaration =
         AstFactory.variableDeclaration(name);
-    _tail = variableDeclaration;
     ConstLocalVariableElementImpl variableElement =
         ElementFactory.constLocalVariableElement(name);
+    _tail = variableElement;
     variableElement.const3 = isConst;
     AstFactory.variableDeclarationList2(
         isConst ? Keyword.CONST : Keyword.VAR, [variableDeclaration]);
-    if (inMap) {
-      _variableDeclarationMap[variableElement] = variableDeclaration;
-    }
     SimpleIdentifier identifier = AstFactory.identifier3(name);
     identifier.staticElement = variableElement;
     return identifier;
   }
   void _visitNode(AstNode node) {
     node.accept(_createReferenceFinder(_head));
   }
 }
 
 @reflectiveTest
@@ skipping 561 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");
     }
   }
 }