Move validation logic for constant evaluation into its own class.

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';
@@ skipping 448 matching lines @@
       for (int start in lineStarts) {
         buffer.write(start);
         buffer.write(", ");
       }
       fail(buffer.toString());
     }
     return firstToken;
   }
 }
 
+/**
+ * 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;
+
+  @override
+  void beforeComputeValue(AstNode constNode) {
+    _nodeBeingEvaluated = constNode;
+  }
+
+  @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);
+    }
+  }
+
+  @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);
+    }
+  }
+
+  @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);
+    }
+  }
+
+  @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);
+    }
+  }
+}
+
 @reflectiveTest
 class ConstantEvaluatorTest extends ResolverTestCase {
   void fail_constructor() {
     EvaluationResult result = _getExpressionValue("?");
     expect(result.isValid, isTrue);
     DartObject value = result.value;
     expect(value, null);
   }
 
   void fail_identifier_class() {
@@ skipping 947 matching lines @@
 class A {
   const A() : x = 5;
   final int x;
 }
 class B extends A {
   const B();
 }
 const B b = const B();''');
   }
 
+  void test_dependencyOnInitializedFinal() {
+    // a depends on A() depends on A.x
+    _assertProperDependencies('''
+class A {
+  const A();
+  final int x = 1;
+}
+const A a = const A();
+''');
+  }
+
   void test_dependencyOnInitializedNonStaticConst() {
     // Even though non-static consts are not allowed by the language, we need
     // to handle them for error recovery purposes.
     // a depends on A() depends on A.x
     _assertProperDependencies('''
 class A {
   const A();
   const int x = 1;
 }
 const A a = const A();
 ''', [CompileTimeErrorCode.CONST_INSTANCE_FIELD]);
   }
 
-  void test_dependencyOnInitializedFinal() {
-    // a depends on A() depends on A.x
-    _assertProperDependencies('''
-class A {
-  const A();
-  final int x = 1;
-}
-const A a = const A();
-''');
-  }
-
   void test_dependencyOnNonFactoryRedirect() {
     // a depends on A.foo() depends on A.bar()
     _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this.bar();
   const A.bar();
 }''');
   }
 
@@ skipping 81 matching lines @@
 
 const A a = const A();
 ''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, 'a');
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "i", 123);
   }
 
-  void test_non_static_const_initialized_at_declaration() {
-    // Even though non-static consts are not allowed by the language, we need
-    // to handle them for error recovery purposes.
-    CompilationUnit compilationUnit = resolveSource('''
-class A {
-  const int i = 123;
-  const A();
-}
-
-const A a = const A();
-''');
-    EvaluationResultImpl result =
-        _evaluateInstanceCreationExpression(compilationUnit, 'a');
-    Map<String, DartObjectImpl> fields = _assertType(result, "A");
-    expect(fields, hasLength(1));
-    _assertIntField(fields, "i", 123);
-  }
-
   void test_fromEnvironment_bool_default_false() {
     expect(_assertValidBool(_check_fromEnvironment_bool(null, "false")), false);
   }
 
   void test_fromEnvironment_bool_default_overridden() {
     expect(
         _assertValidBool(_check_fromEnvironment_bool("false", "true")), false);
   }
 
   void test_fromEnvironment_bool_default_parseError() {
@@ skipping 481 matching lines @@
     expect(ConstantValueComputer.isValidPublicSymbol("if"), isFalse);
     expect(ConstantValueComputer.isValidPublicSymbol("if.foo"), isFalse);
     expect(ConstantValueComputer.isValidPublicSymbol("foo.if"), isFalse);
     expect(ConstantValueComputer.isValidPublicSymbol("foo=.bar"), isFalse);
     expect(ConstantValueComputer.isValidPublicSymbol("foo."), isFalse);
     expect(ConstantValueComputer.isValidPublicSymbol("+.foo"), isFalse);
     expect(ConstantValueComputer.isValidPublicSymbol("void.foo"), isFalse);
     expect(ConstantValueComputer.isValidPublicSymbol("foo.void"), isFalse);
   }
 
+  void test_non_static_const_initialized_at_declaration() {
+    // Even though non-static consts are not allowed by the language, we need
+    // to handle them for error recovery purposes.
+    CompilationUnit compilationUnit = resolveSource('''
+class A {
+  const int i = 123;
+  const A();
+}
+
+const A a = const A();
+''');
+    EvaluationResultImpl result =
+        _evaluateInstanceCreationExpression(compilationUnit, 'a');
+    Map<String, DartObjectImpl> fields = _assertType(result, "A");
+    expect(fields, hasLength(1));
+    _assertIntField(fields, "i", 123);
+  }
+
   void test_symbolLiteral_void() {
     CompilationUnit compilationUnit =
         resolveSource("const voidSymbol = #void;");
     VariableDeclaration voidSymbol =
         findTopLevelDeclaration(compilationUnit, "voidSymbol");
     EvaluationResultImpl voidSymbolResult =
         (voidSymbol.element as VariableElementImpl).evaluationResult;
     DartObjectImpl value = voidSymbolResult.value;
     expect(value.type, typeProvider.symbolType);
     expect(value.value, "void");
@@ skipping 197 matching lines @@
   }
 
   EvaluationResultImpl _evaluateInstanceCreationExpression(
       CompilationUnit compilationUnit, String name) {
     Expression expression =
         findTopLevelConstantExpression(compilationUnit, name);
     return (expression as InstanceCreationExpression).evaluationResult;
   }
 
   ConstantValueComputer _makeConstantValueComputer() {
-    return new ValidatingConstantValueComputer(
-        analysisContext2.typeProvider, analysisContext2.declaredVariables);
+    ConstantEvaluationValidator_ForTest validator =
+        new ConstantEvaluationValidator_ForTest();
+    validator.computer = new ConstantValueComputer(
+        analysisContext2.typeProvider, analysisContext2.declaredVariables,
+        validator);
+    return validator.computer;
   }
 
   void _validate(bool shouldBeValid, VariableDeclarationList declarationList) {
     for (VariableDeclaration declaration in declarationList.variables) {
       VariableElementImpl element = declaration.element as VariableElementImpl;
       expect(element, isNotNull);
       EvaluationResultImpl result = element.evaluationResult;
       if (shouldBeValid) {
         expect(result.value, isNotNull);
       } else {
         expect(result.value, isNull);
       }
     }
   }
 }
 
-class ConstantValueComputerTest_ValidatingConstantVisitor
-    extends ConstantVisitor {
-  final DirectedGraph<AstNode> _referenceGraph;
-  final AstNode _nodeBeingEvaluated;
-
-  ConstantValueComputerTest_ValidatingConstantVisitor(TypeProvider typeProvider,
-      this._referenceGraph, this._nodeBeingEvaluated,
-      ErrorReporter errorReporter)
-      : super.con1(typeProvider, errorReporter);
-
-  @override
-  void beforeGetEvaluationResult(AstNode node) {
-    super.beforeGetEvaluationResult(node);
-    // If we are getting the evaluation result for a node in the graph,
-    // make sure we properly recorded the dependency.
-    if (_referenceGraph.nodes.contains(node)) {
-      expect(_referenceGraph.containsPath(_nodeBeingEvaluated, node), isTrue);
-    }
-  }
-}
-
 @reflectiveTest
 class ConstantVisitorTest extends ResolverTestCase {
   void test_visitConditionalExpression_false() {
     Expression thenExpression = AstFactory.integer(1);
     Expression elseExpression = AstFactory.integer(0);
     ConditionalExpression expression = AstFactory.conditionalExpression(
         AstFactory.booleanLiteral(false), thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
-    _assertValue(0, expression.accept(
-        new ConstantVisitor.con1(new TestTypeProvider(), errorReporter)));
+    _assertValue(0, expression
+        .accept(new ConstantVisitor(new TestTypeProvider(), errorReporter)));
     errorListener.assertNoErrors();
   }
 
   void test_visitConditionalExpression_instanceCreation_invalidFieldInitializer() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     LibraryElementImpl libraryElement = ElementFactory.library(null, "lib");
     String className = "C";
     ClassElementImpl classElement = ElementFactory.classElement2(className);
     (libraryElement.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[classElement];
     ConstructorElementImpl constructorElement = ElementFactory
         .constructorElement(classElement, null, true, [typeProvider.intType]);
     constructorElement.parameters[0] =
         new FieldFormalParameterElementImpl(AstFactory.identifier3("x"));
     InstanceCreationExpression expression = AstFactory
         .instanceCreationExpression2(Keyword.CONST,
             AstFactory.typeName4(className), [AstFactory.integer(0)]);
     expression.staticElement = constructorElement;
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
-    expression.accept(new ConstantVisitor.con1(typeProvider, errorReporter));
+    expression.accept(new ConstantVisitor(typeProvider, errorReporter));
     errorListener
         .assertErrorsWithCodes([CompileTimeErrorCode.INVALID_CONSTANT]);
   }
 
   void test_visitConditionalExpression_nonBooleanCondition() {
     Expression thenExpression = AstFactory.integer(1);
     Expression elseExpression = AstFactory.integer(0);
     NullLiteral conditionExpression = AstFactory.nullLiteral();
     ConditionalExpression expression = AstFactory.conditionalExpression(
         conditionExpression, thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
-    DartObjectImpl result = expression.accept(
-        new ConstantVisitor.con1(new TestTypeProvider(), errorReporter));
+    DartObjectImpl result = expression
+        .accept(new ConstantVisitor(new TestTypeProvider(), errorReporter));
     expect(result, isNull);
     errorListener
         .assertErrorsWithCodes([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL]);
   }
 
   void test_visitConditionalExpression_nonConstantElse() {
     Expression thenExpression = AstFactory.integer(1);
     Expression elseExpression = AstFactory.identifier3("x");
     ConditionalExpression expression = AstFactory.conditionalExpression(
         AstFactory.booleanLiteral(true), thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
-    DartObjectImpl result = expression.accept(
-        new ConstantVisitor.con1(new TestTypeProvider(), errorReporter));
+    DartObjectImpl result = expression
+        .accept(new ConstantVisitor(new TestTypeProvider(), errorReporter));
     expect(result, isNull);
     errorListener
         .assertErrorsWithCodes([CompileTimeErrorCode.INVALID_CONSTANT]);
   }
 
   void test_visitConditionalExpression_nonConstantThen() {
     Expression thenExpression = AstFactory.identifier3("x");
     Expression elseExpression = AstFactory.integer(0);
     ConditionalExpression expression = AstFactory.conditionalExpression(
         AstFactory.booleanLiteral(true), thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
-    DartObjectImpl result = expression.accept(
-        new ConstantVisitor.con1(new TestTypeProvider(), errorReporter));
+    DartObjectImpl result = expression
+        .accept(new ConstantVisitor(new TestTypeProvider(), errorReporter));
     expect(result, isNull);
     errorListener
         .assertErrorsWithCodes([CompileTimeErrorCode.INVALID_CONSTANT]);
   }
 
   void test_visitConditionalExpression_true() {
     Expression thenExpression = AstFactory.integer(1);
     Expression elseExpression = AstFactory.integer(0);
     ConditionalExpression expression = AstFactory.conditionalExpression(
         AstFactory.booleanLiteral(true), thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
-    _assertValue(1, expression.accept(
-        new ConstantVisitor.con1(new TestTypeProvider(), errorReporter)));
+    _assertValue(1, expression
+        .accept(new ConstantVisitor(new TestTypeProvider(), errorReporter)));
     errorListener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_className() {
     CompilationUnit compilationUnit = resolveSource('''
 const a = C;
 class C {}
 ''');
     DartObjectImpl result = _evaluateConstant(compilationUnit, 'a', null);
     expect(result.type, typeProvider.typeType);
@@ skipping 49 matching lines @@
     return new NonExistingSource("foo.dart", UriKind.FILE_URI);
   }
 
   DartObjectImpl _evaluateConstant(CompilationUnit compilationUnit, String name,
       Map<String, DartObjectImpl> lexicalEnvironment) {
     Source source = compilationUnit.element.source;
     Expression expression =
         findTopLevelConstantExpression(compilationUnit, name);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
-    DartObjectImpl result = expression.accept(new ConstantVisitor.con2(
-        typeProvider, lexicalEnvironment, errorReporter));
+    DartObjectImpl result = expression.accept(new ConstantVisitor(
+        typeProvider, errorReporter, null, lexicalEnvironment));
     errorListener.assertNoErrors();
     return result;
   }
 }
 
 @reflectiveTest
 class ContentCacheTest {
   void test_setContents() {
     Source source = new TestSource();
     ContentCache cache = new ContentCache();
@@ skipping 5930 matching lines @@
 
   @override
   Source resolveAbsolute(Uri uri) {
     if (uri.toString() == encoding) {
       return new TestSource();
     }
     return null;
   }
 }
 
-class ValidatingConstantValueComputer extends ConstantValueComputer {
-  AstNode _nodeBeingEvaluated;
-  ValidatingConstantValueComputer(
-      TypeProvider typeProvider, DeclaredVariables declaredVariables)
-      : super(typeProvider, declaredVariables);
-
-  @override
-  void beforeComputeValue(AstNode constNode) {
-    super.beforeComputeValue(constNode);
-    _nodeBeingEvaluated = constNode;
-  }
-
-  @override
-  void beforeGetFieldEvaluationResult(FieldElementImpl field) {
-    super.beforeGetFieldEvaluationResult(field);
-    // If we are getting the constant value for a node in the graph, make sure
-    // we properly recorded the dependency.
-    VariableDeclaration node = findVariableDeclaration(field);
-    if (node != null && referenceGraph.nodes.contains(node)) {
-      expect(referenceGraph.containsPath(_nodeBeingEvaluated, node), isTrue);
-    }
-  }
-
-  @override
-  void beforeGetConstantInitializers(ConstructorElement constructor) {
-    super.beforeGetConstantInitializers(constructor);
-    // If we are getting the constant initializers for a node in the graph,
-    // make sure we properly recorded the dependency.
-    ConstructorDeclaration node = findConstructorDeclaration(constructor);
-    if (node != null && referenceGraph.nodes.contains(node)) {
-      expect(referenceGraph.containsPath(_nodeBeingEvaluated, node), isTrue);
-    }
-  }
-
-  @override
-  void beforeGetParameterDefault(ParameterElement parameter) {
-    super.beforeGetParameterDefault(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 =
-        constructorDeclarationMap[constructor];
-    if (constructorNode != null) {
-      FormalParameter parameterNode =
-          constructorNode.parameters.parameters[parameterIndex];
-      expect(referenceGraph.nodes.contains(parameterNode), isTrue);
-      expect(referenceGraph.containsPath(_nodeBeingEvaluated, parameterNode),
-          isTrue);
-    }
-  }
-
-  @override
-  ConstantVisitor createConstantVisitor(ErrorReporter errorReporter) {
-    return new ConstantValueComputerTest_ValidatingConstantVisitor(
-        typeProvider, referenceGraph, _nodeBeingEvaluated, errorReporter);
-  }
-}
-
 /**
  * Instances of `XmlValidator` traverse an [XmlNode] structure and validate the node
  * hierarchy.
  */
 class XmlValidator extends ht.RecursiveXmlVisitor<Object> {
   /**
    * A list containing the errors found while traversing the AST structure.
    */
   List<String> _errors = new List<String>();
   /**
@@ skipping 253 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");
     }
   }
 }