Create a class for evaluating const instance creation expressions.

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 2093 matching lines @@
     _assertType(c_int, "C<int>");
     DartObjectImpl c_int_value = c_int.value;
     EvaluationResultImpl c_num =
         _evaluateInstanceCreationExpression(compilationUnit, "c_num");
     _assertType(c_num, "C<num>");
     DartObjectImpl c_num_value = c_num.value;
     expect(c_int_value == c_num_value, isFalse);
   }
 
   void test_isValidSymbol() {
-    expect(ConstantValueComputer.isValidPublicSymbol(""), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("foo"), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("foo.bar"), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("foo\$"), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("foo\$bar"), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("iff"), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("gif"), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("if\$"), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("\$if"), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("foo="), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("foo.bar="), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("foo.+"), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("void"), isTrue);
-    expect(ConstantValueComputer.isValidPublicSymbol("_foo"), isFalse);
-    expect(ConstantValueComputer.isValidPublicSymbol("_foo.bar"), isFalse);
-    expect(ConstantValueComputer.isValidPublicSymbol("foo._bar"), isFalse);
-    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);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol(""), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo"), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo.bar"), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo\$"), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo\$bar"), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("iff"), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("gif"), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("if\$"), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("\$if"), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo="), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo.bar="), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo.+"), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("void"), isTrue);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("_foo"), isFalse);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("_foo.bar"), isFalse);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo._bar"), isFalse);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("if"), isFalse);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("if.foo"), isFalse);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo.if"), isFalse);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo=.bar"), isFalse);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo."), isFalse);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("+.foo"), isFalse);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("void.foo"), isFalse);
+    expect(ConstantEvaluationEngine.isValidPublicSymbol("foo.void"), isFalse);
   }
 
   void test_length_of_improperly_typed_string_expression() {
     // Since type annotations are ignored in unchecked mode, the improper
     // types on s1 and s2 shouldn't prevent us from evaluating i to
     // 'alpha'.length.
     CompilationUnit compilationUnit = resolveSource('''
 const int s1 = 'alpha';
 const int s2 = 'beta';
 const int i = (true ? s1 : s2).length;
@@ skipping 277 matching lines @@
 @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(new TestTypeProvider(), errorReporter)));
+    _assertValue(0, expression.accept(new ConstantVisitor(
+        new ConstantEvaluationEngine(
+            new TestTypeProvider(), new DeclaredVariables()), 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(typeProvider, errorReporter));
+    expression.accept(new ConstantVisitor(
+        new ConstantEvaluationEngine(typeProvider, new DeclaredVariables()),
+        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(new TestTypeProvider(), errorReporter));
+    DartObjectImpl result = expression.accept(new ConstantVisitor(
+        new ConstantEvaluationEngine(
+            new TestTypeProvider(), new DeclaredVariables()), 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(new TestTypeProvider(), errorReporter));
+    DartObjectImpl result = expression.accept(new ConstantVisitor(
+        new ConstantEvaluationEngine(
+            new TestTypeProvider(), new DeclaredVariables()), 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(new TestTypeProvider(), errorReporter));
+    DartObjectImpl result = expression.accept(new ConstantVisitor(
+        new ConstantEvaluationEngine(
+            new TestTypeProvider(), new DeclaredVariables()), 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(new TestTypeProvider(), errorReporter)));
+    _assertValue(1, expression.accept(new ConstantVisitor(
+        new ConstantEvaluationEngine(
+            new TestTypeProvider(), new DeclaredVariables()), 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 50 matching lines @@
   }
 
   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(
-        typeProvider, errorReporter, lexicalEnvironment: lexicalEnvironment));
+        new ConstantEvaluationEngine(typeProvider, new DeclaredVariables()),
+        errorReporter, lexicalEnvironment: lexicalEnvironment));
     errorListener.assertNoErrors();
     return result;
   }
 }
 
 @reflectiveTest
 class ContentCacheTest {
   void test_setContents() {
     Source source = new TestSource();
     ContentCache cache = new ContentCache();
@@ skipping 6203 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");
     }
   }
 }