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

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 410 matching lines @@
             definingClass, new SymbolState(argumentValue));
       }
       // Either it's an external const factory constructor that we can't
       // emulate, or an error occurred (a cycle, or a const constructor trying
       // to delegate to a non-const constructor).
       // In the former case, the best we can do is consider it an unknown value.
       // In the latter case, the error has already been reported, so considering
       // it an unknown value will suppress further errors.
       return new DartObjectImpl.validWithUnknownValue(definingClass);
     }
-    validator.beforeGetConstantInitializers(constructor);
     ConstructorElementImpl constructorBase = _getConstructorBase(constructor);
+    validator.beforeGetConstantInitializers(constructorBase);
     List<ConstructorInitializer> initializers =
         constructorBase.constantInitializers;
     if (initializers == null) {
       // This can happen in some cases where there are compile errors in the
       // code being analyzed (for example if the code is trying to create a
       // const instance using a non-const constructor, or the node we're
       // visiting is involved in a cycle).  The error has already been reported,
       // so consider it an unknown value to suppress further errors.
       return new DartObjectImpl.validWithUnknownValue(definingClass);
     }
@@ skipping 252 matching lines @@
   }
 }
 
 /**
  * Interface used by unit tests to verify correct dependency analysis during
  * constant evaluation.
  */
 abstract class ConstantEvaluationValidator {
   /**
    * This method is called just before computing the constant value associated
-   * with [constNode]. Unit tests will override this method to introduce
+   * with [element]. Unit tests will override this method to introduce
    * additional error checking.
    */
-  void beforeComputeValue(AstNode constNode);
+  void beforeComputeValue(Element element);
 
   /**
    * This method is called just before getting the constant initializers
    * associated with the [constructor]. Unit tests will override this method to
    * introduce additional error checking.
    */
   void beforeGetConstantInitializers(ConstructorElement constructor);
 
   /**
    * This method is called just before retrieving an evaluation result from an
-   * AST node. Unit tests will override it to introduce additional error
+   * element. Unit tests will override it to introduce additional error
    * checking.
    */
-  void beforeGetEvaluationResult(AstNode node);
+  void beforeGetEvaluationResult(Element element);
 
   /**
    * This method is called just before getting the constant value of a field
    * with an initializer.  Unit tests will override this method to introduce
    * additional error checking.
    */
   void beforeGetFieldEvaluationResult(FieldElementImpl field);
 
   /**
    * This method is called just before getting a parameter's default value. Unit
    * tests will override this method to introduce additional error checking.
    */
   void beforeGetParameterDefault(ParameterElement parameter);
 }
 
 /**
  * Implementation of [ConstantEvaluationValidator] used in production; does no
  * validation.
  */
 class ConstantEvaluationValidator_ForProduction
     implements ConstantEvaluationValidator {
   @override
-  void beforeComputeValue(AstNode constNode) {}
+  void beforeComputeValue(Element element) {}
 
   @override
   void beforeGetConstantInitializers(ConstructorElement constructor) {}
 
   @override
-  void beforeGetEvaluationResult(AstNode node) {}
+  void beforeGetEvaluationResult(Element element) {}
 
   @override
   void beforeGetFieldEvaluationResult(FieldElementImpl field) {}
 
   @override
   void beforeGetParameterDefault(ParameterElement parameter) {}
 }
 
 /**
  * Instances of the class `ConstantEvaluator` evaluate constant expressions to
@@ skipping 83 matching lines @@
 }
 
 /**
  * A visitor 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.
+   * The elements whose constant values need to be computed, with the exception
+   * of annotations.
    */
-  final HashMap<PotentiallyConstVariableElement, VariableDeclaration> variableMap =
-      new HashMap<PotentiallyConstVariableElement, VariableDeclaration>();
-
-  /**
-   * A table mapping constant constructors to the declarations of those
-   * constructors.
-   */
-  final HashMap<ConstructorElement, ConstructorDeclaration> constructorMap =
-      new HashMap<ConstructorElement, ConstructorDeclaration>();
+  HashSet<Element> constantsToCompute = new HashSet<Element>();
 
   /**
    * A collection of annotations.
    */
   final List<Annotation> annotations = <Annotation>[];
 
   /**
    * True if instance variables marked as "final" should be treated as "const".
    */
   bool treatFinalInstanceVarAsConst = false;
@@ skipping 20 matching lines @@
       treatFinalInstanceVarAsConst = prevTreatFinalInstanceVarAsConst;
     }
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
     if (node.constKeyword != null) {
       ConstructorElement element = node.element;
       if (element != null) {
-        constructorMap[element] = node;
+        constantsToCompute.add(element);
+        constantsToCompute.addAll(element.parameters);
       }
     }
     return null;
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Expression initializer = node.initializer;
     VariableElement element = node.element;
     if (initializer != null &&
         (node.isConst ||
             treatFinalInstanceVarAsConst &&
                 element is FieldElement &&
                 node.isFinal &&
                 !element.isStatic)) {
       if (node.element != null) {
-        variableMap[node.element as PotentiallyConstVariableElement] = node;
+        constantsToCompute.add(node.element);
       }
     }
     return null;
   }
 }
 
 /**
  * An object used to compute the values of constant variables and constant
  * constructor invocations in one or more compilation units. The expected usage
  * pattern is for the compilation units to be added to this computer using the
@@ skipping 19 matching lines @@
   /**
    * The object used to find constant variables and constant constructor
    * invocations in the compilation units that were added.
    */
   ConstantFinder _constantFinder = new ConstantFinder();
 
   /**
    * A graph in which the nodes are the constants, and the edges are from each
    * constant to the other constants that are referenced by it.
    */
-  DirectedGraph<AstNode> referenceGraph = new DirectedGraph<AstNode>();
+  DirectedGraph<Element> referenceGraph = new DirectedGraph<Element>();
 
   /**
-   * A table mapping constant variables to the declarations of those variables.
+   * The elements whose constant values need to be computed.  Any elements
+   * which appear in [referenceGraph] but not in this set either belong to a
+   * different library cycle (and hence don't need to be recomputed) or were
+   * computed during a previous stage of resolution stage (e.g. constants
+   * associated with enums).
    */
-  HashMap<PotentiallyConstVariableElement, VariableDeclaration> _variableDeclarationMap;
-
-  /**
-   * A table mapping constant constructors to the declarations of those
-   * constructors.
-   */
-  HashMap<ConstructorElement, ConstructorDeclaration> constructorDeclarationMap;
+  HashSet<Element> _constantsToCompute;
 
   /**
    * A collection of annotations.
    */
   List<Annotation> _annotations;
 
   /**
    * The evaluation engine that does the work of evaluating instance creation
    * expressions.
    */
@@ skipping 16 matching lines @@
    */
   void add(CompilationUnit unit) {
     unit.accept(_constantFinder);
   }
 
   /**
    * Compute values for all of the constants in the compilation units that were
    * added.
    */
   void computeValues() {
-    _variableDeclarationMap = _constantFinder.variableMap;
-    constructorDeclarationMap = _constantFinder.constructorMap;
+    _constantsToCompute = _constantFinder.constantsToCompute;
     _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((ConstructorElementImpl element,
-        ConstructorDeclaration declaration) {
-      element.isCycleFree = false;
-      ConstructorElement redirectedConstructor =
-          evaluationEngine.getConstRedirectedConstructor(element);
-      if (redirectedConstructor != null) {
-        ConstructorElement redirectedConstructorBase =
-            ConstantEvaluationEngine._getConstructorBase(redirectedConstructor);
-        ConstructorDeclaration redirectedConstructorDeclaration =
-            findConstructorDeclaration(redirectedConstructorBase);
-        referenceGraph.addEdge(declaration, redirectedConstructorDeclaration);
-        return;
-      }
-      ReferenceFinder referenceFinder = new ReferenceFinder(declaration,
-          referenceGraph, _variableDeclarationMap, constructorDeclarationMap);
-      referenceGraph.addNode(declaration);
-      bool superInvocationFound = false;
-      NodeList<ConstructorInitializer> initializers = declaration.initializers;
-      for (ConstructorInitializer initializer in initializers) {
-        if (initializer is SuperConstructorInvocation) {
-          superInvocationFound = true;
-        }
-        initializer.accept(referenceFinder);
-      }
-      if (!superInvocationFound) {
-        // No explicit superconstructor invocation found, so we need to
-        // manually insert a reference to the implicit superconstructor.
-        InterfaceType superclass =
-            (element.returnType as InterfaceType).superclass;
-        if (superclass != null && !superclass.isObject) {
-          ConstructorElement unnamedConstructor =
-              superclass.element.unnamedConstructor;
-          ConstructorDeclaration superConstructorDeclaration =
-              findConstructorDeclaration(unnamedConstructor);
-          if (superConstructorDeclaration != null) {
-            referenceGraph.addEdge(declaration, superConstructorDeclaration);
-          }
-        }
-      }
-      for (FieldElement field in element.enclosingElement.fields) {
-        // Note: non-static const isn't allowed but we handle it anyway so that
-        // we won't be confused by incorrect code.
-        if ((field.isFinal || field.isConst) && !field.isStatic) {
-          VariableDeclaration fieldDeclaration = _variableDeclarationMap[field];
-          if (fieldDeclaration != null) {
-            referenceGraph.addEdge(declaration, fieldDeclaration);
-          }
-        }
-      }
-      for (FormalParameter parameter in declaration.parameters.parameters) {
-        referenceGraph.addNode(parameter);
-        referenceGraph.addEdge(declaration, parameter);
-        if (parameter is DefaultFormalParameter) {
-          Expression defaultValue = parameter.defaultValue;
+    for (Element element in _constantsToCompute) {
+      referenceGraph.addNode(element);
+      if (element is ParameterElement) {
+        if (element.initializer != null) {
+          Expression defaultValue =
+              (element as ConstVariableElement).constantInitializer;
           if (defaultValue != null) {
-            ReferenceFinder parameterReferenceFinder = new ReferenceFinder(
-                parameter, referenceGraph, _variableDeclarationMap,
-                constructorDeclarationMap);
+            ReferenceFinder parameterReferenceFinder =
+                new ReferenceFinder(element, referenceGraph);
             defaultValue.accept(parameterReferenceFinder);
           }
         }
+      } else if (element is PotentiallyConstVariableElement) {
+        ReferenceFinder referenceFinder =
+            new ReferenceFinder(element, referenceGraph);
+        element.constantInitializer.accept(referenceFinder);
+      } else if (element is ConstructorElementImpl) {
+        element.isCycleFree = false;
+        ConstructorElement redirectedConstructor =
+            evaluationEngine.getConstRedirectedConstructor(element);
+        if (redirectedConstructor != null) {
+          ConstructorElement redirectedConstructorBase =
+              ConstantEvaluationEngine
+                  ._getConstructorBase(redirectedConstructor);
+          referenceGraph.addEdge(element, redirectedConstructorBase);
+          continue;
+        }
+        ReferenceFinder referenceFinder =
+            new ReferenceFinder(element, referenceGraph);
+        bool superInvocationFound = false;
+        List<ConstructorInitializer> initializers =
+            element.constantInitializers;
+        for (ConstructorInitializer initializer in initializers) {
+          if (initializer is SuperConstructorInvocation) {
+            superInvocationFound = true;
+          }
+          initializer.accept(referenceFinder);
+        }
+        if (!superInvocationFound) {
+          // No explicit superconstructor invocation found, so we need to
+          // manually insert a reference to the implicit superconstructor.
+          InterfaceType superclass =
+              (element.returnType as InterfaceType).superclass;
+          if (superclass != null && !superclass.isObject) {
+            ConstructorElement unnamedConstructor = ConstantEvaluationEngine
+                ._getConstructorBase(superclass.element.unnamedConstructor);
+            if (unnamedConstructor != null) {
+              referenceGraph.addEdge(element, unnamedConstructor);
+            }
+          }
+        }
+        for (FieldElement field in element.enclosingElement.fields) {
+          // Note: non-static const isn't allowed but we handle it anyway so that
+          // we won't be confused by incorrect code.
+          if ((field.isFinal || field.isConst) &&
+              !field.isStatic &&
+              field.initializer != null) {
+            referenceGraph.addEdge(element, field);
+          }
+        }
+        for (ParameterElement parameterElement in element.parameters) {
+          referenceGraph.addEdge(element, parameterElement);
+        }
+      } else {
+        // Should not happen.
+        assert(false);
+        AnalysisEngine.instance.logger.logError(
+            "Constant value computer trying to compute the value of a node of type ${element.runtimeType}");
       }
-    });
-    List<List<AstNode>> topologicalSort =
+    }
+    List<List<Element>> topologicalSort =
         referenceGraph.computeTopologicalSort();
-    for (List<AstNode> constantsInCycle in topologicalSort) {
+    for (List<Element> constantsInCycle in topologicalSort) {
       if (constantsInCycle.length == 1) {
         _computeValueFor(constantsInCycle[0]);
       } else {
-        for (AstNode constant in constantsInCycle) {
+        for (Element 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);
+      _computeValueForAnnotation(annotation);
     }
   }
 
-  ConstructorDeclaration findConstructorDeclaration(
-          ConstructorElement constructor) => constructorDeclarationMap[
-      ConstantEvaluationEngine._getConstructorBase(constructor)];
-
-  VariableDeclaration findVariableDeclaration(
-          PotentiallyConstVariableElement variable) =>
-      _variableDeclarationMap[variable];
-
   /**
-   * Compute a value for the given [constNode].
+   * Compute a value for the given [element].
    */
-  void _computeValueFor(AstNode constNode) {
-    evaluationEngine.validator.beforeComputeValue(constNode);
-    if (constNode is VariableDeclaration) {
-      VariableElement element = constNode.element;
+  void _computeValueFor(Element element) {
+    if (!_constantsToCompute.contains(element)) {
+      // Element is in the dependency graph but should have been computed by
+      // a previous stage of analysis.
+      return;
+    }
+    evaluationEngine.validator.beforeComputeValue(element);
+    if (element is ParameterElement) {
+      if (element.initializer != null) {
+        Expression defaultValue =
+            (element as PotentiallyConstVariableElement).constantInitializer;
+        if (defaultValue != null) {
+          RecordingErrorListener errorListener = new RecordingErrorListener();
+          ErrorReporter errorReporter =
+              new ErrorReporter(errorListener, element.source);
+          DartObjectImpl dartObject = defaultValue
+              .accept(new ConstantVisitor(evaluationEngine, errorReporter));
+          (element as ParameterElementImpl).evaluationResult =
+              new EvaluationResultImpl.con2(dartObject, errorListener.errors);
+        }
+      }
+    } else if (element is VariableElement) {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter =
           new ErrorReporter(errorListener, element.source);
       DartObjectImpl dartObject =
           (element as PotentiallyConstVariableElement).constantInitializer
               .accept(new ConstantVisitor(evaluationEngine, errorReporter));
       // Only check the type for truly const declarations (don't check final
       // fields with initializers, since their types may be generic.  The type
       // of the final field will be checked later, when the constructor is
       // invoked).
-      if (dartObject != null && constNode.isConst) {
+      if (dartObject != null && element.isConst) {
         if (!evaluationEngine.runtimeTypeMatch(dartObject, element.type)) {
           errorReporter.reportErrorForElement(
               CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH, element, [
             dartObject.type,
             element.type
           ]);
         }
       }
       (element as VariableElementImpl).evaluationResult =
           new EvaluationResultImpl.con2(dartObject, errorListener.errors);
-    } else if (constNode is ConstructorDeclaration) {
+    } else if (element is ConstructorElement) {
       // No evaluation needs to be done; constructor declarations are only in
       // the dependency graph to ensure that any constants referred to in
       // initializer lists and parameter defaults are evaluated before
       // invocations of the constructor.  However we do need to annotate the
       // element as being free of constant evaluation cycles so that later code
       // will know that it is safe to evaluate.
-      ConstructorElementImpl constructor = constNode.element;
-      constructor.isCycleFree = true;
-    } else if (constNode is FormalParameter) {
-      if (constNode is DefaultFormalParameter) {
-        ParameterElement element = constNode.element;
-        Expression defaultValue =
-            (element as PotentiallyConstVariableElement).constantInitializer;
-        if (defaultValue != null) {
-          RecordingErrorListener errorListener = new RecordingErrorListener();
-          ErrorReporter errorReporter =
-              new ErrorReporter(errorListener, element.source);
-          DartObjectImpl dartObject = defaultValue
-              .accept(new ConstantVisitor(evaluationEngine, 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 =
-              new ConstantVisitor(evaluationEngine, errorReporter);
-          DartObjectImpl result = evaluationEngine.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);
-        }
-      }
+      (element as ConstructorElementImpl).isCycleFree = true;
     } else {
       // Should not happen.
       assert(false);
       AnalysisEngine.instance.logger.logError(
-          "Constant value computer trying to compute the value of a node which is not a VariableDeclaration, InstanceCreationExpression, FormalParameter, or ConstructorDeclaration");
+          "Constant value computer trying to compute the value of a node of type ${element.runtimeType}");
       return;
     }
   }
 
   /**
+   * Compute a value for the given annotation.
+   */
+  void _computeValueForAnnotation(Annotation constNode) {
+    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 =
+            new ConstantVisitor(evaluationEngine, errorReporter);
+        DartObjectImpl result = evaluationEngine.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);
+      }
+    }
+  }
+
+  /**
    * Generate an error indicating that the given [constNode] is not a valid
    * compile-time constant because it references at least one of the constants
    * in the given [cycle], each of which directly or indirectly references the
    * constant.
    */
-  void _generateCycleError(List<AstNode> cycle, AstNode constNode) {
-    if (constNode is VariableDeclaration) {
-      VariableElement element = constNode.element;
+  void _generateCycleError(List<Element> cycle, Element element) {
+    if (element is VariableElement) {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter =
           new ErrorReporter(errorListener, element.source);
       // TODO(paulberry): It would be really nice if we could extract enough
       // information from the 'cycle' argument to provide the user with a
       // description of the cycle.
       errorReporter.reportErrorForElement(
           CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT, element, []);
       (element as VariableElementImpl).evaluationResult =
           new EvaluationResultImpl.con2(null, errorListener.errors);
-    } else if (constNode is ConstructorDeclaration) {
+    } else if (element is ConstructorElement) {
       // We don't report cycle errors on constructor declarations since there
       // is nowhere to put the error information.
     } else {
       // Should not happen.  Formal parameter defaults and annotations should
       // never appear as part of a cycle because they can't be referred to.
       assert(false);
       AnalysisEngine.instance.logger.logError(
-          "Constant value computer trying to report a cycle error for a node of type ${constNode.runtimeType}");
+          "Constant value computer trying to report a cycle error for a node of type ${element.runtimeType}");
     }
   }
 }
 
 /**
  * A visitor used to evaluate constant expressions to produce their compile-time
  * value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
  *
  * * A literal number.
@@ skipping 470 matching lines @@
    * Return the constant value of the static constant represented by the given
    * [element]. The [node] is the node to be used if an error needs to be
    * reported.
    */
   DartObjectImpl _getConstantValue(AstNode node, Element element) {
     if (element is PropertyAccessorElement) {
       element = (element as PropertyAccessorElement).variable;
     }
     if (element is VariableElementImpl) {
       VariableElementImpl variableElementImpl = element;
-      evaluationEngine.validator.beforeGetEvaluationResult(node);
+      evaluationEngine.validator.beforeGetEvaluationResult(element);
       EvaluationResultImpl value = variableElementImpl.evaluationResult;
       if (variableElementImpl.isConst && value != null) {
         return value.value;
       }
     } else if (element is ExecutableElement) {
       ExecutableElement function = element;
       if (function.isStatic) {
         ParameterizedType functionType = function.type;
         if (functionType == null) {
           functionType = _typeProvider.functionType;
@@ skipping 3134 matching lines @@
 }
 
 /**
  * An object used to add reference information for a given variable to the
  * bi-directional mapping used to order the evaluation of constants.
  */
 class ReferenceFinder extends RecursiveAstVisitor<Object> {
   /**
    * The element representing the construct that will be visited.
    */
-  final AstNode _source;
+  final Element _source;
 
   /**
    * A graph in which the nodes are the constant variables and the edges are
    * from each variable to the other constant variables that are referenced in
    * the head's initializer.
    */
-  final DirectedGraph<AstNode> _referenceGraph;
-
-  /**
-   * A table mapping constant variables to the declarations of those variables.
-   */
-  final HashMap<PotentiallyConstVariableElement, VariableDeclaration> _variableDeclarationMap;
-
-  /**
-   * A table mapping constant constructors to the declarations of those
-   * constructors.
-   */
-  final HashMap<ConstructorElement, ConstructorDeclaration> _constructorDeclarationMap;
+  final DirectedGraph<Element> _referenceGraph;
 
   /**
    * Initialize a newly created reference finder to find references from a given
    * variable to other variables and to add those references to the given graph.
    * The [source] is the element representing the variable whose initializer
    * will be visited. The [referenceGraph] is a graph recording which variables
-   * (heads) reference which other variables (tails) in their initializers. The
-   * [variableDeclarationMap] is a table mapping constant variables to the
-   * declarations of those variables. The [constructorDeclarationMap] is a table
-   * mapping constant constructors to the declarations of those constructors.
+   * (heads) reference which other variables (tails) in their initializers.
    */
-  ReferenceFinder(this._source, this._referenceGraph,
-      this._variableDeclarationMap, this._constructorDeclarationMap);
-
-  ConstructorDeclaration findConstructorDeclaration(
-          ConstructorElement constructor) => _constructorDeclarationMap[
-      ConstantEvaluationEngine._getConstructorBase(constructor)];
+  ReferenceFinder(this._source, this._referenceGraph);
 
   @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (node.isConst) {
-      ConstructorElement constructor = node.staticElement;
+      ConstructorElement constructor =
+          ConstantEvaluationEngine._getConstructorBase(node.staticElement);
       if (constructor != null) {
-        ConstructorDeclaration declaration =
-            findConstructorDeclaration(constructor);
-        if (declaration != null) {
-          _referenceGraph.addEdge(_source, declaration);
-        }
+        _referenceGraph.addEdge(_source, constructor);
       }
     }
     return super.visitInstanceCreationExpression(node);
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     super.visitRedirectingConstructorInvocation(node);
-    ConstructorElement target = node.staticElement;
+    ConstructorElement target =
+        ConstantEvaluationEngine._getConstructorBase(node.staticElement);
     if (target != null && target.isConst) {
-      ConstructorDeclaration targetDeclaration =
-          _constructorDeclarationMap[target];
-      if (targetDeclaration != null) {
-        _referenceGraph.addEdge(_source, targetDeclaration);
-      }
+      _referenceGraph.addEdge(_source, target);
     }
     return null;
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is PropertyAccessorElement) {
       element = (element as PropertyAccessorElement).variable;
     }
     if (element is VariableElement) {
       if (element.isConst) {
-        VariableDeclaration variableDeclaration =
-            _variableDeclarationMap[element];
-        // The declaration will be null when the variable is not defined in the
-        // compilation units that were used to produce the
-        // variableDeclarationMap.  In such cases, the variable should already
-        // have a value associated with it, but we don't bother to check because
-        // there's nothing we can do about it at this point.
-        if (variableDeclaration != null) {
-          _referenceGraph.addEdge(_source, variableDeclaration);
-        }
+        _referenceGraph.addEdge(_source, element);
       }
     }
     return null;
   }
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     super.visitSuperConstructorInvocation(node);
-    ConstructorElement constructor = node.staticElement;
+    ConstructorElement constructor =
+        ConstantEvaluationEngine._getConstructorBase(node.staticElement);
     if (constructor != null && constructor.isConst) {
-      ConstructorDeclaration constructorDeclaration =
-          _constructorDeclarationMap[constructor];
-      // The declaration will be null when the constructor is not defined in the
-      // compilation units that were used to produce the
-      // constructorDeclarationMap.  In such cases, the constructor should
-      // already have its initializer AST's stored in it, but we don't bother
-      // to check because there's nothing we can do about it at this point.
-      if (constructorDeclaration != null) {
-        _referenceGraph.addEdge(_source, constructorDeclaration);
-      }
+      _referenceGraph.addEdge(_source, constructor);
     }
     return null;
   }
 }
 
 /**
  * The state of an object representing a string.
  */
 class StringState extends InstanceState {
   /**
@@ skipping 201 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;
 }