Begin making copies of AST nodes for constants during resolution.

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 127 matching lines @@
 
   /**
    * Return the boolean state representing the given boolean [value].
    */
   static BoolState from(bool value) =>
       value ? BoolState.TRUE_STATE : BoolState.FALSE_STATE;
 }
 
 /**
  * An [AstCloner] that copies the necessary information from the AST to allow
- * const constructor initializers to be evaluated.
+ * constants to be evaluated.
  */
 class ConstantAstCloner extends AstCloner {
   ConstantAstCloner() : super(true);
 
   @override
   InstanceCreationExpression visitInstanceCreationExpression(
       InstanceCreationExpression node) {
     InstanceCreationExpression expression =
         super.visitInstanceCreationExpression(node);
-    expression.evaluationResult = node.evaluationResult;
+    expression.constantHandle = node.constantHandle;
     return expression;
   }
 
   @override
   RedirectingConstructorInvocation visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     RedirectingConstructorInvocation invocation =
         super.visitRedirectingConstructorInvocation(node);
     invocation.staticElement = node.staticElement;
     return invocation;
@@ skipping 106 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.
    */
-  final HashMap<VariableElement, VariableDeclaration> variableMap =
-      new HashMap<VariableElement, VariableDeclaration>();
+  final HashMap<PotentiallyConstVariableElementImpl, VariableDeclaration> variableMap =
+      new HashMap<PotentiallyConstVariableElementImpl, 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.
@@ skipping 32 matching lines @@
       constructorInvocations.add(node);
     }
     return null;
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Expression initializer = node.initializer;
     if (initializer != null && node.isConst) {
-      VariableElement element = node.element;
+      PotentiallyConstVariableElementImpl element = node.element;
       if (element != null) {
         variableMap[element] = node;
       }
     }
     return null;
   }
 }
 
 /**
  * An object used to compute the values of constant variables and constant
@@ skipping 50 matching lines @@
 
   /**
    * 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>();
 
   /**
    * A table mapping constant variables to the declarations of those variables.
    */
-  HashMap<VariableElement, VariableDeclaration> _variableDeclarationMap;
+  HashMap<PotentiallyConstVariableElementImpl, VariableDeclaration> _variableDeclarationMap;
 
   /**
    * A table mapping constant constructors to the declarations of those
    * constructors.
    */
   HashMap<ConstructorElement, ConstructorDeclaration> constructorDeclarationMap;
 
   /**
    * A collection of constant constructor invocations.
    */
@@ skipping 54 matching lines @@
     _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((ConstructorElement element,
+    constructorDeclarationMap.forEach((ConstructorElementImpl element,
         ConstructorDeclaration declaration) {
+      element.isCycleFree = false;
       ConstructorElement redirectedConstructor =
           _getConstRedirectedConstructor(element);
       if (redirectedConstructor != null) {
         ConstructorElement redirectedConstructorBase =
             _getConstructorBase(redirectedConstructor);
         ConstructorDeclaration redirectedConstructorDeclaration =
             findConstructorDeclaration(redirectedConstructorBase);
         referenceGraph.addEdge(declaration, redirectedConstructorDeclaration);
         return;
       }
@@ skipping 147 matching lines @@
     String name = argumentValues[0].stringValue;
     return isValidPublicSymbol(name);
   }
 
   /**
    * Compute a value for the given [constNode].
    */
   void _computeValueFor(AstNode constNode) {
     beforeComputeValue(constNode);
     if (constNode is VariableDeclaration) {
-      VariableDeclaration declaration = constNode;
-      VariableElement element = declaration.element;
+      PotentiallyConstVariableElementImpl element = constNode.element;
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter =
           new ErrorReporter(errorListener, element.source);
-      DartObjectImpl dartObject =
-          declaration.initializer.accept(createConstantVisitor(errorReporter));
+      DartObjectImpl dartObject = element.constantInitializer
+          .accept(createConstantVisitor(errorReporter));
       if (dartObject != null) {
         if (!_runtimeTypeMatch(dartObject, element.type)) {
-          errorReporter.reportErrorForNode(
-              CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
-              declaration, [dartObject.type, 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 InstanceCreationExpression) {
       InstanceCreationExpression expression = constNode;
       ConstructorElement constructor = expression.staticElement;
       if (constructor == null) {
         // Couldn't resolve the constructor so we can't compute a value.
         // No problem - the error has already been reported.
         // But we still need to store an evaluation result.
-        expression.evaluationResult = new EvaluationResultImpl.con1(null);
+        expression.constantHandle.evaluationResult =
+            new EvaluationResultImpl.con1(null);
         return;
       }
       RecordingErrorListener errorListener = new RecordingErrorListener();
       CompilationUnit sourceCompilationUnit =
           expression.getAncestor((node) => node is CompilationUnit);
       ErrorReporter errorReporter = new ErrorReporter(
           errorListener, sourceCompilationUnit.element.source);
       ConstantVisitor constantVisitor = createConstantVisitor(errorReporter);
       DartObjectImpl result = _evaluateConstructorCall(constNode,
           expression.argumentList.arguments, constructor, constantVisitor,
           errorReporter);
-      expression.evaluationResult =
+      expression.constantHandle.evaluationResult =
           new EvaluationResultImpl.con2(result, errorListener.errors);
     } else if (constNode is ConstructorDeclaration) {
-      ConstructorDeclaration declaration = constNode;
-      NodeList<ConstructorInitializer> initializers = declaration.initializers;
-      ConstructorElementImpl constructor =
-          declaration.element as ConstructorElementImpl;
-      constructor.constantInitializers =
-          new ConstantAstCloner().cloneNodeList(initializers);
+      // 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) {
         DefaultFormalParameter parameter = constNode;
         ParameterElement element = parameter.element;
         Expression defaultValue = parameter.defaultValue;
         if (defaultValue != null) {
           RecordingErrorListener errorListener = new RecordingErrorListener();
           ErrorReporter errorReporter =
               new ErrorReporter(errorListener, element.source);
           DartObjectImpl dartObject =
@@ skipping 77 matching lines @@
         // that for analysis because it's likely to lead to cascading errors.
         // So just leave [value] in the unknown state.
       }
     }
     return value;
   }
 
   DartObjectImpl _evaluateConstructorCall(AstNode node,
       NodeList<Expression> arguments, ConstructorElement constructor,
       ConstantVisitor constantVisitor, ErrorReporter errorReporter) {
+    if (!_getConstructorBase(constructor).isCycleFree) {
+      // It's not safe to evaluate this constructor, so bail out.
+      return new DartObjectImpl.validWithUnknownValue(constructor.returnType);

[Brian Wilkerson, 2015/04/01 20:31:54]

I'm guessing that we will create (or will have created) an error for this case
at some other point.

[Paul Berry, 2015/04/02 15:18:49]

Correct.  Currently we report the unhelpful error message "Initializer
expressions in constant constructors must be constants", and frankly I'm not
exactly sure how that message arises.  By the time I'm done reworking constant
evaluation for the new task model I hope to have this replaced with a much more
meaningful message (something like "compile-time constant expression depends on
itself").

I've added a TODO comment to help remind myself that this needs to be cleaned
up.

+    }
     int argumentCount = arguments.length;
     List<DartObjectImpl> argumentValues =
         new List<DartObjectImpl>(argumentCount);
     List<Expression> argumentNodes = new List<Expression>(argumentCount);
     HashMap<String, DartObjectImpl> namedArgumentValues =
         new HashMap<String, DartObjectImpl>();
     HashMap<String, NamedExpression> namedArgumentNodes =
         new HashMap<String, NamedExpression>();
     for (int i = 0; i < argumentCount; i++) {
       Expression argument = arguments[i];
@@ skipping 57 matching lines @@
         String argumentValue = argumentValues[0].stringValue;
         return new DartObjectImpl(
             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 constantVisitor._validWithUnknownValue(definingClass);
+      return new DartObjectImpl.validWithUnknownValue(definingClass);
     }
     beforeGetConstantInitializers(constructor);
-    ConstructorElementImpl constructorBase =
-        _getConstructorBase(constructor) as ConstructorElementImpl;
+    ConstructorElementImpl constructorBase = _getConstructorBase(constructor);
     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 constantVisitor._validWithUnknownValue(definingClass);
+      return new DartObjectImpl.validWithUnknownValue(definingClass);
     }
     HashMap<String, DartObjectImpl> fieldMap =
         new HashMap<String, DartObjectImpl>();
     HashMap<String, DartObjectImpl> parameterMap =
         new HashMap<String, DartObjectImpl>();
     List<ParameterElement> parameters = constructor.parameters;
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       ParameterElement parameter = parameters[i];
       ParameterElement baseParameter = parameter;
@@ skipping 196 matching lines @@
     }
     if (!redirectedConstructor.isConst) {
       // Delegating to a non-const constructor--this is not allowed (and
       // is checked elsewhere--see
       // [ErrorVerifier.checkForRedirectToNonConstConstructor()]).
       return null;
     }
     return redirectedConstructor;
   }
 
-  ConstructorElement _getConstructorBase(ConstructorElement constructor) {
+  ConstructorElementImpl _getConstructorBase(ConstructorElement constructor) {
     while (constructor is ConstructorMember) {
       constructor = (constructor as ConstructorMember).baseElement;
     }
     return constructor;
   }
 
   /**
    * Check if the object [obj] matches the type [type] according to runtime type
    * checking rules.
    */
@@ skipping 239 matching lines @@
     if (conditionResult == null) {
       return conditionResult;
     }
     if (conditionResult.isTrue) {
       return thenResult;
     } else if (conditionResult.isFalse) {
       return elseResult;
     }
     ParameterizedType thenType = thenResult.type;
     ParameterizedType elseType = elseResult.type;
-    return _validWithUnknownValue(
+    return new DartObjectImpl.validWithUnknownValue(
         thenType.getLeastUpperBound(elseType) as InterfaceType);
   }
 
   @override
   DartObjectImpl visitDoubleLiteral(DoubleLiteral node) =>
       new DartObjectImpl(_typeProvider.doubleType, new DoubleState(node.value));
 
   @override
   DartObjectImpl visitInstanceCreationExpression(
       InstanceCreationExpression node) {
@@ skipping 283 matching lines @@
     } else if (element is ClassElement ||
         element is FunctionTypeAliasElement ||
         element is DynamicElementImpl) {
       return new DartObjectImpl(_typeProvider.typeType, new TypeState(element));
     }
     // TODO(brianwilkerson) Figure out which error to report.
     _error(node, null);
     return null;
   }
 
-  DartObjectImpl _validWithUnknownValue(InterfaceType type) {
-    if (type.element.library.isDartCore) {
-      String typeName = type.name;
-      if (typeName == "bool") {
-        return new DartObjectImpl(type, BoolState.UNKNOWN_VALUE);
-      } else if (typeName == "double") {
-        return new DartObjectImpl(type, DoubleState.UNKNOWN_VALUE);
-      } else if (typeName == "int") {
-        return new DartObjectImpl(type, IntState.UNKNOWN_VALUE);
-      } else if (typeName == "String") {
-        return new DartObjectImpl(type, StringState.UNKNOWN_VALUE);
-      }
-    }
-    return new DartObjectImpl(type, GenericState.UNKNOWN_VALUE);
-  }
-
   /**
    * Return the value of the given [expression], or a representation of 'null'
    * if the expression cannot be evaluated.
    */
   DartObjectImpl _valueOf(Expression expression) {
     DartObjectImpl expressionValue = expression.accept(this);
     if (expressionValue != null) {
       return expressionValue;
     }
     return _typeProvider.nullObject;
@@ skipping 429 matching lines @@
   /**
    * The state of the object.
    */
   final InstanceState _state;
 
   /**
    * Initialize a newly created object to have the given [type] and [_state].
    */
   DartObjectImpl(this.type, this._state);
 
+  /**
+   * Create an object to represent an unknown value.
+   */
+  factory DartObjectImpl.validWithUnknownValue(InterfaceType type) {
+    if (type.element.library.isDartCore) {
+      String typeName = type.name;
+      if (typeName == "bool") {
+        return new DartObjectImpl(type, BoolState.UNKNOWN_VALUE);
+      } else if (typeName == "double") {
+        return new DartObjectImpl(type, DoubleState.UNKNOWN_VALUE);
+      } else if (typeName == "int") {
+        return new DartObjectImpl(type, IntState.UNKNOWN_VALUE);
+      } else if (typeName == "String") {
+        return new DartObjectImpl(type, StringState.UNKNOWN_VALUE);
+      }
+    }
+    return new DartObjectImpl(type, GenericState.UNKNOWN_VALUE);
+  }
+
   @override
   bool get boolValue {
     if (_state is BoolState) {
       return (_state as BoolState).value;
     }
     return null;
   }
 
   @override
   double get doubleValue {
@@ skipping 2643 matching lines @@
   /**
    * 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<VariableElement, VariableDeclaration> _variableDeclarationMap;
+  final HashMap<PotentiallyConstVariableElementImpl, VariableDeclaration> _variableDeclarationMap;
 
   /**
    * A table mapping constant constructors to the declarations of those
    * constructors.
    */
   final HashMap<ConstructorElement, ConstructorDeclaration> _constructorDeclarationMap;
 
   /**
    * 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.
@@ skipping 282 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;
 }