Move validation logic for constant evaluation into its own class.

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 168 matching lines @@
   SuperConstructorInvocation visitSuperConstructorInvocation(
       SuperConstructorInvocation node) {
     SuperConstructorInvocation invocation =
         super.visitSuperConstructorInvocation(node);
     invocation.staticElement = node.staticElement;
     return invocation;
   }
 }
 
 /**
+ * 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
+   * additional error checking.
+   */
+  void beforeComputeValue(AstNode constNode);
+
+  /**
+   * 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
+   * checking.
+   */
+  void beforeGetEvaluationResult(AstNode node);
+
+  /**
+   * 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) {}
+
+  @override
+  void beforeGetConstantInitializers(ConstructorElement constructor) {}
+
+  @override
+  void beforeGetEvaluationResult(AstNode node) {}
+
+  @override
+  void beforeGetFieldEvaluationResult(FieldElementImpl field) {}
+
+  @override
+  void beforeGetParameterDefault(ParameterElement parameter) {}
+}
+
+/**
  * Instances of the class `ConstantEvaluator` 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.
  * * A literal boolean.
  * * A literal string where any interpolated expression is a compile-time
  *   constant that evaluates to a numeric, string or boolean value or to
  *   <b>null</b>.
@@ skipping 56 matching lines @@
   /**
    * Initialize a newly created evaluator to evaluate expressions in the given
    * [source]. The [typeProvider] is the type provider used to access known
    * types.
    */
   ConstantEvaluator(this._source, this._typeProvider);
 
   EvaluationResult evaluate(Expression expression) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
-    DartObjectImpl result = expression
-        .accept(new ConstantVisitor.con1(_typeProvider, errorReporter));
+    DartObjectImpl result =
+        expression.accept(new ConstantVisitor(_typeProvider, errorReporter));
     if (result != null) {
       return EvaluationResult.forValue(result);
     }
     return EvaluationResult.forErrors(errorListener.errors);
   }
 }
 
 /**
  * A visitor used to traverse the AST structures of all of the compilation units
  * being resolved and build tables of the constant variables, constant
@@ skipping 132 matching lines @@
   /**
    * RegExp that validates a non-empty non-private symbol.
    * From sdk/lib/internal/symbol.dart.
    */
   static RegExp _PUBLIC_SYMBOL_PATTERN = new RegExp(
       "^(?:${ConstantValueComputer._OPERATOR_RE}\$|$_PUBLIC_IDENTIFIER_RE(?:=?\$|[.](?!\$)))+?\$");
 
   /**
    * The type provider used to access the known types.
    */
-  TypeProvider typeProvider;
+  final TypeProvider typeProvider;
+
+  /**
+   * Validator used to verify correct dependency analysis when running unit
+   * tests.
+   */
+  final ConstantEvaluationValidator validator;
 
   /**
    * 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.
@@ skipping 24 matching lines @@
   /**
    * The set of variables declared on the command line using '-D'.
    */
   final DeclaredVariables _declaredVariables;
 
   /**
    * Initialize a newly created constant value computer. The [typeProvider] is
    * the type provider used to access known types. The [declaredVariables] is
    * the set of variables declared on the command line using '-D'.
    */
-  ConstantValueComputer(TypeProvider typeProvider, this._declaredVariables) {
-    this.typeProvider = typeProvider;
-  }
+  ConstantValueComputer(this.typeProvider, this._declaredVariables,
+      [ConstantEvaluationValidator validator])
+      : validator = validator != null
+          ? validator
+          : new ConstantEvaluationValidator_ForProduction();
 
   /**
    * Add the constants in the given compilation [unit] to the list of constants
    * whose value needs to be computed.
    */
   void add(CompilationUnit unit) {
     unit.accept(_constantFinder);
   }
 
   /**
-   * This method is called just before computing the constant value associated
-   * with [constNode]. Unit tests will override this method to introduce
-   * additional error checking.
-   */
-  void beforeComputeValue(AstNode constNode) {}
-
-  /**
-   * 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 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 getting a parameter's default value. Unit
-   * tests will override this method to introduce additional error checking.
-   */
-  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,
@@ skipping 93 matching lines @@
       }
     }
     // 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 findConstructorDeclaration(
           ConstructorElement constructor) =>
       constructorDeclarationMap[_getConstructorBase(constructor)];
 
   VariableDeclaration findVariableDeclaration(
           PotentiallyConstVariableElement variable) =>
       _variableDeclarationMap[variable];
 
   /**
    * Check that the arguments to a call to fromEnvironment() are correct. The
@@ skipping 56 matching lines @@
       return false;
     }
     String name = argumentValues[0].stringValue;
     return isValidPublicSymbol(name);
   }
 
   /**
    * Compute a value for the given [constNode].
    */
   void _computeValueFor(AstNode constNode) {
-    beforeComputeValue(constNode);
+    validator.beforeComputeValue(constNode);
     if (constNode is VariableDeclaration) {
       VariableElement element = constNode.element;
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter =
           new ErrorReporter(errorListener, element.source);
       DartObjectImpl dartObject =
           (element as PotentiallyConstVariableElement).constantInitializer
-              .accept(createConstantVisitor(errorReporter));
+              .accept(
+                  new ConstantVisitor(typeProvider, errorReporter, validator));
       if (dartObject != null) {
         if (!_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 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.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);
+      ConstantVisitor constantVisitor =
+          new ConstantVisitor(typeProvider, errorReporter, validator);
       DartObjectImpl result = _evaluateConstructorCall(constNode,
           expression.argumentList.arguments, constructor, constantVisitor,
           errorReporter);
       expression.constantHandle.evaluationResult =
           new EvaluationResultImpl.con2(result, errorListener.errors);
     } else if (constNode is ConstructorDeclaration) {
       // 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 =
-              defaultValue.accept(createConstantVisitor(errorReporter));
+          DartObjectImpl dartObject = defaultValue.accept(
+              new ConstantVisitor(typeProvider, errorReporter, validator));
           (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);
+              new ConstantVisitor(typeProvider, errorReporter, validator);
           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 =
@@ skipping 127 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);
     }
-    beforeGetConstantInitializers(constructor);
+    validator.beforeGetConstantInitializers(constructor);
     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 new DartObjectImpl.validWithUnknownValue(definingClass);
     }
     HashMap<String, DartObjectImpl> fieldMap =
         new HashMap<String, DartObjectImpl>();
     // Start with final fields that are initialized at their declaration site.
     for (FieldElement field in constructor.enclosingElement.fields) {
       if ((field.isFinal || field.isConst) &&
           !field.isStatic &&
           field is ConstFieldElementImpl) {
-        beforeGetFieldEvaluationResult(field);
+        validator.beforeGetFieldEvaluationResult(field);
         EvaluationResultImpl evaluationResult = field.evaluationResult;
         DartType fieldType =
             FieldMember.from(field, constructor.returnType).type;
         DartObjectImpl fieldValue = evaluationResult.value;
         if (fieldValue != null && !_runtimeTypeMatch(fieldValue, fieldType)) {
           errorReporter.reportErrorForNode(
               CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
               node, [fieldValue.type, field.name, fieldType]);
         }
         fieldMap[field.name] = evaluationResult.value;
@@ skipping 21 matching lines @@
       }
       if (errorTarget == null) {
         // No argument node that we can direct error messages to, because we
         // are handling an optional parameter that wasn't specified.  So just
         // direct error messages to the constructor call.
         errorTarget = node;
       }
       if (argumentValue == null && baseParameter is ParameterElementImpl) {
         // The parameter is an optional positional parameter for which no value
         // was provided, so use the default value.
-        beforeGetParameterDefault(baseParameter);
+        validator.beforeGetParameterDefault(baseParameter);
         EvaluationResultImpl evaluationResult = baseParameter.evaluationResult;
         if (evaluationResult == null) {
           // No default was provided, so the default value is null.
           argumentValue = typeProvider.nullObject;
         } else if (evaluationResult.value != null) {
           argumentValue = evaluationResult.value;
         }
       }
       if (argumentValue != null) {
         if (!_runtimeTypeMatch(argumentValue, parameter.type)) {
@@ skipping 17 matching lines @@
             }
             String fieldName = field.name;
             fieldMap[fieldName] = argumentValue;
           }
         } else {
           String name = baseParameter.name;
           parameterMap[name] = argumentValue;
         }
       }
     }
-    ConstantVisitor initializerVisitor =
-        new ConstantVisitor.con2(typeProvider, parameterMap, errorReporter);
+    ConstantVisitor initializerVisitor = new ConstantVisitor(
+        typeProvider, errorReporter, validator, parameterMap);
     String superName = null;
     NodeList<Expression> superArguments = null;
     for (ConstructorInitializer initializer in initializers) {
       if (initializer is ConstructorFieldInitializer) {
         ConstructorFieldInitializer constructorFieldInitializer = initializer;
         Expression initializerExpression =
             constructorFieldInitializer.expression;
         DartObjectImpl evaluationResult =
             initializerExpression.accept(initializerVisitor);
         if (evaluationResult != null) {
@@ skipping 216 matching lines @@
  *   <i>e<sub>3</sub></i> are constant expressions, and <i>e<sub>1</sub></i>
  *   evaluates to a boolean value.
  * </blockquote>
  */
 class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
   /**
    * The type provider used to access the known types.
    */
   final TypeProvider _typeProvider;
 
-  HashMap<String, DartObjectImpl> _lexicalEnvironment;
+  final HashMap<String, DartObjectImpl> _lexicalEnvironment;
+
+  /**
+   * Validator used to verify correct dependency analysis when running unit
+   * tests.
+   */
+  final ConstantEvaluationValidator validator;
 
   /**
    * Error reporter that we use to report errors accumulated while computing the
    * constant.
    */
   final ErrorReporter _errorReporter;
 
   /**
    * Helper class used to compute constant values.
    */
   DartObjectComputer _dartObjectComputer;
 
   /**
    * Initialize a newly created constant visitor. The [_typeProvider] is the
-   * type provider used to access known types. The [_errorReporter] is used to
-   * report errors found during evaluation.
+   * type provider used to access known types. The [_lexicalEnvironment] is a
+   * map containing values which should override identifiers, or `null` if no
+   * overriding is necessary. The [_errorReporter] is used to report errors
+   * found during evaluation.  The [validator] is used by unit tests to verify
+   * correct dependency analysis.
    */
-  ConstantVisitor.con1(this._typeProvider, this._errorReporter) {
-    this._lexicalEnvironment = null;
+  ConstantVisitor(this._typeProvider, this._errorReporter,
+      [ConstantEvaluationValidator validator, this._lexicalEnvironment])

[Brian Wilkerson, 2015/05/05 00:22:47]

It might be better to make these named parameters, given that there's no
requirement that a validator be provided if a lexical environment is provided.
On the other hand, "lexicalEnvironment" is a long name...

[Paul Berry, 2015/05/05 14:16:21]

Done.

+      : validator = validator != null
+          ? validator
+          : new ConstantEvaluationValidator_ForProduction() {
     this._dartObjectComputer =
         new DartObjectComputer(_errorReporter, _typeProvider);
   }
 
   /**
-   * Initialize a newly created constant visitor. The [_typeProvider] is the
-   * type provider used to access known types. The [lexicalEnvironment] is a map
-   * containing values which should override identifiers, or `null` if no
-   * overriding is necessary. The [_errorReporter] is used to report errors
-   * found during evaluation.
-   */
-  ConstantVisitor.con2(this._typeProvider,
-      HashMap<String, DartObjectImpl> lexicalEnvironment, this._errorReporter) {
-    this._lexicalEnvironment = lexicalEnvironment;
-    this._dartObjectComputer =
-        new DartObjectComputer(_errorReporter, _typeProvider);
-  }
-
-  /**
-   * This method is called just before retrieving an evaluation result from an
-   * AST node. Unit tests will override it to introduce additional error
-   * checking.
-   */
-  void beforeGetEvaluationResult(AstNode node) {}
-
-  /**
    * Return `true` if the given [element] represents the `length` getter in
    * class 'String'.
    */
   bool isStringLength(Element element) {
     if (element is PropertyAccessorElement) {
       if (element.isGetter && element.name == 'length') {
         return element.enclosingElement == _typeProvider.stringType.element;
       }
     }
     return false;
@@ skipping 119 matching lines @@
       new DartObjectImpl(_typeProvider.doubleType, new DoubleState(node.value));
 
   @override
   DartObjectImpl visitInstanceCreationExpression(
       InstanceCreationExpression node) {
     if (!node.isConst) {
       // TODO(brianwilkerson) Figure out which error to report.
       _error(node, null);
       return null;
     }
-    beforeGetEvaluationResult(node);
+    validator.beforeGetEvaluationResult(node);
     EvaluationResultImpl result = node.evaluationResult;
     if (result != null) {
       return result.value;
     }
     // TODO(brianwilkerson) Figure out which error to report.
     _error(node, null);
     return null;
   }
 
   @override
@@ skipping 243 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;
-      beforeGetEvaluationResult(node);
+      validator.beforeGetEvaluationResult(node);
       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 3437 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;
 }