Remove const instance creation expressions from the dependency graph.

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 947 matching lines @@
   void test_visitConstructorDeclaration_const() {
     ConstructorElement element = _setupConstructorDeclaration("A", true);
     expect(_findConstantDeclarations()[element], same(_node));
   }
 
   void test_visitConstructorDeclaration_nonConst() {
     _setupConstructorDeclaration("A", false);
     expect(_findConstantDeclarations().isEmpty, isTrue);
   }
 
-  void test_visitInstanceCreationExpression_const() {
-    _setupInstanceCreationExpression("A", true);
-    expect(_findConstructorInvocations().contains(_node), isTrue);
-  }
-
-  void test_visitInstanceCreationExpression_nonConst() {
-    _setupInstanceCreationExpression("A", false);
-    expect(_findConstructorInvocations().isEmpty, isTrue);
-  }
-
   void test_visitVariableDeclaration_const() {
     VariableElement element = _setupVariableDeclaration("v", true, true);
     expect(_findVariableDeclarations()[element], same(_node));
   }
 
   void test_visitVariableDeclaration_final_inClass() {
     _setupFieldDeclaration('C', 'f', Keyword.FINAL);
     expect(_findVariableDeclarations(), isEmpty);
   }
 
@@ skipping 58 matching lines @@
 
   Map<ConstructorElement, ConstructorDeclaration> _findConstantDeclarations() {
     ConstantFinder finder = new ConstantFinder();
     _node.accept(finder);
     Map<ConstructorElement, ConstructorDeclaration> constructorMap =
         finder.constructorMap;
     expect(constructorMap, isNotNull);
     return constructorMap;
   }
 
-  List<InstanceCreationExpression> _findConstructorInvocations() {
-    ConstantFinder finder = new ConstantFinder();
-    _node.accept(finder);
-    List<InstanceCreationExpression> constructorInvocations =
-        finder.constructorInvocations;
-    expect(constructorInvocations, isNotNull);
-    return constructorInvocations;
-  }
-
   Map<PotentiallyConstVariableElement, VariableDeclaration> _findVariableDeclarations() {
     ConstantFinder finder = new ConstantFinder();
     _node.accept(finder);
     Map<PotentiallyConstVariableElement, VariableDeclaration> variableMap =
         finder.variableMap;
     expect(variableMap, isNotNull);
     return variableMap;
   }
 
   ConstructorElement _setupConstructorDeclaration(String name, bool isConst) {
@@ skipping 38 matching lines @@
               AstFactory.blockFunctionBody2());
       classDeclaration.members.add(constructorDeclaration);
       ConstructorElement constructorElement =
           ElementFactory.constructorElement(classElement, '', true);
       constructorDeclaration.element = constructorElement;
       classElement.constructors = <ConstructorElement>[constructorElement];
     }
     return variableDeclaration;
   }
 
-  void _setupInstanceCreationExpression(String name, bool isConst) {
-    _node = AstFactory.instanceCreationExpression2(
-        isConst ? Keyword.CONST : null,
-        AstFactory.typeName3(AstFactory.identifier3(name)));
-  }
-
   VariableElement _setupVariableDeclaration(
       String name, bool isConst, bool isInitialized, {isFinal: false}) {
     VariableDeclaration variableDeclaration = isInitialized
         ? AstFactory.variableDeclaration2(name, AstFactory.integer(0))
         : AstFactory.variableDeclaration(name);
     SimpleIdentifier identifier = variableDeclaration.name;
     VariableElement element = ElementFactory.localVariableElement(identifier);
     identifier.staticElement = element;
     Keyword keyword = isConst ? Keyword.CONST : isFinal ? Keyword.FINAL : null;
     AstFactory.variableDeclarationList2(keyword, [variableDeclaration]);
@@ skipping 484 matching lines @@
   void test_final_initialized_at_declaration() {
     CompilationUnit compilationUnit = resolveSource('''
 class A {
   final int i = 123;
   const A();
 }
 
 const A a = const A();
 ''');
     EvaluationResultImpl result =
-        _evaluateInstanceCreationExpression(compilationUnit, 'a');
+        _evaluateTopLevelVariable(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() {
@@ skipping 88 matching lines @@
   }
 
   void test_instanceCreationExpression_computedField() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A(4, 5);
 class A {
   const A(int i, int j) : k = 2 * i + j;
   final int k;
 }''');
     EvaluationResultImpl result =
-        _evaluateInstanceCreationExpression(compilationUnit, "foo");
+        _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "k", 13);
   }
 
   void test_instanceCreationExpression_computedField_namedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(false, true, true);
   }
 
   void test_instanceCreationExpression_computedField_namedOptionalWithoutDefault() {
@@ skipping 13 matching lines @@
 const foo = const A(3);
 class A {
   const A(int i) : b = const B(4);
   final int b;
 }
 class B {
   const B(this.k);
   final int k;
 }''');
     EvaluationResultImpl result =
-        _evaluateInstanceCreationExpression(compilationUnit, "foo");
+        _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fieldsOfA = _assertType(result, "A");
     expect(fieldsOfA, hasLength(1));
     Map<String, DartObjectImpl> fieldsOfB =
         _assertFieldType(fieldsOfA, "b", "B");
     expect(fieldsOfB, hasLength(1));
     _assertIntField(fieldsOfB, "k", 4);
   }
 
   void test_instanceCreationExpression_computedField_usesStaticConst() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A(3);
 class A {
   const A(int i) : k = i + B.bar;
   final int k;
 }
 class B {
   static const bar = 4;
 }''');
     EvaluationResultImpl result =
-        _evaluateInstanceCreationExpression(compilationUnit, "foo");
+        _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "k", 7);
   }
 
   void test_instanceCreationExpression_computedField_usesToplevelConst() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A(3);
 const bar = 4;
 class A {
   const A(int i) : k = i + bar;
   final int k;
 }''');
     EvaluationResultImpl result =
-        _evaluateInstanceCreationExpression(compilationUnit, "foo");
+        _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "k", 7);
   }
 
   void test_instanceCreationExpression_explicitSuper() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const B(4, 5);
 class A {
   const A(this.x);
   final int x;
 }
 class B extends A {
   const B(int x, this.y) : super(x * 2);
   final int y;
 }''');
     EvaluationResultImpl result =
-        _evaluateInstanceCreationExpression(compilationUnit, "foo");
+        _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "B");
     expect(fields, hasLength(2));
     _assertIntField(fields, "y", 5);
     Map<String, DartObjectImpl> superclassFields =
         _assertFieldType(fields, GenericState.SUPERCLASS_FIELD, "A");
     expect(superclassFields, hasLength(1));
     _assertIntField(superclassFields, "x", 8);
   }
 
   void test_instanceCreationExpression_fieldFormalParameter() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A(42);
 class A {
   int x;
   const A(this.x)
 }''');
     EvaluationResultImpl result =
-        _evaluateInstanceCreationExpression(compilationUnit, "foo");
+        _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "x", 42);
   }
 
   void test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(true, true, true);
   }
 
   void test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithoutDefault() {
@@ skipping 13 matching lines @@
 const foo = const B(4);
 class A {
   const A() : x = 3;
   final int x;
 }
 class B extends A {
   const B(this.y);
   final int y;
 }''');
     EvaluationResultImpl result =
-        _evaluateInstanceCreationExpression(compilationUnit, "foo");
+        _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "B");
     expect(fields, hasLength(2));
     _assertIntField(fields, "y", 4);
     Map<String, DartObjectImpl> superclassFields =
         _assertFieldType(fields, GenericState.SUPERCLASS_FIELD, "A");
     expect(superclassFields, hasLength(1));
     _assertIntField(superclassFields, "x", 3);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1();
 class A {
   const A.a1() : this.a2();
   const A.a2() : x = 5;
   final int x;
 }''');
-    Map<String, DartObjectImpl> aFields = _assertType(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"), "A");
+    Map<String, DartObjectImpl> aFields =
+        _assertType(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'x', 5);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_arg() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1(1);
 class A {
   const A.a1(x) : this.a2(x + 100);
   const A.a2(x) : y = x + 10;
   final int y;
 }''');
-    Map<String, DartObjectImpl> aFields = _assertType(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"), "A");
+    Map<String, DartObjectImpl> aFields =
+        _assertType(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'y', 111);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_cycle() {
     // It is an error to have a cycle in non-factory redirects; however, we
     // need to make sure that even if the error occurs, attempting to evaluate
     // the constant will terminate.
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A();
 class A {
   const A() : this.b();
   const A.b() : this();
 }''');
-    _assertValidUnknown(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"));
+    _assertValidUnknown(_evaluateTopLevelVariable(compilationUnit, "foo"));
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_defaultArg() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1();
 class A {
   const A.a1() : this.a2();
   const A.a2([x = 100]) : y = x + 10;
   final int y;
 }''');
-    Map<String, DartObjectImpl> aFields = _assertType(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"), "A");
+    Map<String, DartObjectImpl> aFields =
+        _assertType(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'y', 110);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_toMissing() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1();
 class A {
   const A.a1() : this.a2();
 }''');
     // We don't care what value foo evaluates to (since there is a compile
     // error), but we shouldn't crash, and we should figure
     // out that it evaluates to an instance of class A.
-    _assertType(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"), "A");
+    _assertType(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_toNonConst() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1();
 class A {
   const A.a1() : this.a2();
   A.a2();
 }''');
     // We don't care what value foo evaluates to (since there is a compile
     // error), but we shouldn't crash, and we should figure
     // out that it evaluates to an instance of class A.
-    _assertType(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"), "A");
+    _assertType(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_unnamed() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1();
 class A {
   const A.a1() : this();
   const A() : x = 5;
   final int x;
 }''');
-    Map<String, DartObjectImpl> aFields = _assertType(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"), "A");
+    Map<String, DartObjectImpl> aFields =
+        _assertType(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'x', 5);
   }
 
   void test_instanceCreationExpression_redirect() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A();
 class A {
   const factory A() = B;
 }
 class B implements A {
   const B();
 }''');
-    _assertType(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"), "B");
+    _assertType(_evaluateTopLevelVariable(compilationUnit, "foo"), "B");
   }
 
   void test_instanceCreationExpression_redirect_cycle() {
     // It is an error to have a cycle in factory redirects; however, we need
     // to make sure that even if the error occurs, attempting to evaluate the
     // constant will terminate.
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A();
 class A {
   const factory A() = A.b;
   const factory A.b() = A;
 }''');
-    _assertValidUnknown(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"));
+    _assertValidUnknown(_evaluateTopLevelVariable(compilationUnit, "foo"));
   }
 
   void test_instanceCreationExpression_redirect_extern() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A();
 class A {
   external const factory A();
 }''');
-    _assertValidUnknown(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"));
+    _assertValidUnknown(_evaluateTopLevelVariable(compilationUnit, "foo"));
   }
 
   void test_instanceCreationExpression_redirect_nonConst() {
     // It is an error for a const factory constructor redirect to a non-const
     // constructor; however, we need to make sure that even if the error
     // attempting to evaluate the constant won't cause a crash.
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A();
 class A {
   const factory A() = A.b;
   A.b();
 }''');
-    _assertValidUnknown(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"));
+    _assertValidUnknown(_evaluateTopLevelVariable(compilationUnit, "foo"));
   }
 
   void test_instanceCreationExpression_redirectWithTypeParams() {
     CompilationUnit compilationUnit = resolveSource(r'''
 class A {
   const factory A(var a) = B<int>;
 }
 
 class B<T> implements A {
   final T x;
   const B(this.x);
 }
 
 const A a = const A(10);''');
     EvaluationResultImpl result =
-        _evaluateInstanceCreationExpression(compilationUnit, "a");
+        _evaluateTopLevelVariable(compilationUnit, "a");
     Map<String, DartObjectImpl> fields = _assertType(result, "B<int>");
     expect(fields, hasLength(1));
     _assertIntField(fields, "x", 10);
   }
 
   void test_instanceCreationExpression_redirectWithTypeSubstitution() {
     // To evaluate the redirection of A<int>,
     // A's template argument (T=int) must be substituted
     // into B's template argument (B<U> where U=T) to get B<int>.
     CompilationUnit compilationUnit = resolveSource(r'''
 class A<T> {
   const factory A(var a) = B<T>;
 }
 
 class B<U> implements A {
   final U x;
   const B(this.x);
 }
 
 const A<int> a = const A<int>(10);''');
     EvaluationResultImpl result =
-        _evaluateInstanceCreationExpression(compilationUnit, "a");
+        _evaluateTopLevelVariable(compilationUnit, "a");
     Map<String, DartObjectImpl> fields = _assertType(result, "B<int>");
     expect(fields, hasLength(1));
     _assertIntField(fields, "x", 10);
   }
 
   void test_instanceCreationExpression_symbol() {
     CompilationUnit compilationUnit =
         resolveSource("const foo = const Symbol('a');");
     EvaluationResultImpl evaluationResult =
-        _evaluateInstanceCreationExpression(compilationUnit, "foo");
+        _evaluateTopLevelVariable(compilationUnit, "foo");
     expect(evaluationResult.value, isNotNull);
     DartObjectImpl value = evaluationResult.value;
     expect(value.type, typeProvider.symbolType);
     expect(value.value, "a");
   }
 
   void test_instanceCreationExpression_withSupertypeParams_explicit() {
     _checkInstanceCreation_withSupertypeParams(true);
   }
 
   void test_instanceCreationExpression_withSupertypeParams_implicit() {
     _checkInstanceCreation_withSupertypeParams(false);
   }
 
   void test_instanceCreationExpression_withTypeParams() {
     CompilationUnit compilationUnit = resolveSource(r'''
 class C<E> {
   const C();
 }
 const c_int = const C<int>();
 const c_num = const C<num>();''');
     EvaluationResultImpl c_int =
-        _evaluateInstanceCreationExpression(compilationUnit, "c_int");
+        _evaluateTopLevelVariable(compilationUnit, "c_int");
     _assertType(c_int, "C<int>");
     DartObjectImpl c_int_value = c_int.value;
     EvaluationResultImpl c_num =
-        _evaluateInstanceCreationExpression(compilationUnit, "c_num");
+        _evaluateTopLevelVariable(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(ConstantEvaluationEngine.isValidPublicSymbol(""), isTrue);
     expect(ConstantEvaluationEngine.isValidPublicSymbol("foo"), isTrue);
     expect(ConstantEvaluationEngine.isValidPublicSymbol("foo.bar"), isTrue);
     expect(ConstantEvaluationEngine.isValidPublicSymbol("foo\$"), isTrue);
@@ skipping 52 matching lines @@
     // 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');
+        _evaluateTopLevelVariable(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");
@@ skipping 84 matching lines @@
       String valueInEnvironment, String defaultExpr) {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
         defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
     CompilationUnit compilationUnit = resolveSource(
         "const $varName = const bool.fromEnvironment('$envVarName'$defaultArg);");
-    return _evaluateInstanceCreationExpression(compilationUnit, varName);
+    return _evaluateTopLevelVariable(compilationUnit, varName);
   }
 
   EvaluationResultImpl _check_fromEnvironment_int(
       String valueInEnvironment, String defaultExpr) {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
         defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
     CompilationUnit compilationUnit = resolveSource(
         "const $varName = const int.fromEnvironment('$envVarName'$defaultArg);");
-    return _evaluateInstanceCreationExpression(compilationUnit, varName);
+    return _evaluateTopLevelVariable(compilationUnit, varName);
   }
 
   EvaluationResultImpl _check_fromEnvironment_string(
       String valueInEnvironment, String defaultExpr) {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
         defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
     CompilationUnit compilationUnit = resolveSource(
         "const $varName = const String.fromEnvironment('$envVarName'$defaultArg);");
-    return _evaluateInstanceCreationExpression(compilationUnit, varName);
+    return _evaluateTopLevelVariable(compilationUnit, varName);
   }
 
   void _checkInstanceCreation_withSupertypeParams(bool isExplicit) {
     String superCall = isExplicit ? " : super()" : "";
     CompilationUnit compilationUnit = resolveSource("""
 class A<T> {
   const A();
 }
 class B<T, U> extends A<T> {
   const B()$superCall;
 }
 class C<T, U> extends A<U> {
   const C()$superCall;
 }
 const b_int_num = const B<int, num>();
 const c_int_num = const C<int, num>();""");
     EvaluationResultImpl b_int_num =
-        _evaluateInstanceCreationExpression(compilationUnit, "b_int_num");
+        _evaluateTopLevelVariable(compilationUnit, "b_int_num");
     Map<String, DartObjectImpl> b_int_num_fields =
         _assertType(b_int_num, "B<int, num>");
     _assertFieldType(b_int_num_fields, GenericState.SUPERCLASS_FIELD, "A<int>");
     EvaluationResultImpl c_int_num =
-        _evaluateInstanceCreationExpression(compilationUnit, "c_int_num");
+        _evaluateTopLevelVariable(compilationUnit, "c_int_num");
     Map<String, DartObjectImpl> c_int_num_fields =
         _assertType(c_int_num, "C<int, num>");
     _assertFieldType(c_int_num_fields, GenericState.SUPERCLASS_FIELD, "A<num>");
   }
 
   void _checkInstanceCreationOptionalParams(
       bool isFieldFormal, bool isNamed, bool hasDefault) {
     String fieldName = "j";
     String paramName = isFieldFormal ? fieldName : "i";
     String formalParam =
         "${isFieldFormal ? "this." : "int "}$paramName${hasDefault ? " = 3" : ""}";
     CompilationUnit compilationUnit = resolveSource("""
 const x = const A();
 const y = const A(${isNamed ? '$paramName: ' : ''}10);
 class A {
   const A(${isNamed ? "{$formalParam}" : "[$formalParam]"})${isFieldFormal ? "" : " : $fieldName = $paramName"};
   final int $fieldName;
 }""");
-    EvaluationResultImpl x =
-        _evaluateInstanceCreationExpression(compilationUnit, "x");
+    EvaluationResultImpl x = _evaluateTopLevelVariable(compilationUnit, "x");
     Map<String, DartObjectImpl> fieldsOfX = _assertType(x, "A");
     expect(fieldsOfX, hasLength(1));
     if (hasDefault) {
       _assertIntField(fieldsOfX, fieldName, 3);
     } else {
       _assertNullField(fieldsOfX, fieldName);
     }
-    EvaluationResultImpl y =
-        _evaluateInstanceCreationExpression(compilationUnit, "y");
+    EvaluationResultImpl y = _evaluateTopLevelVariable(compilationUnit, "y");
     Map<String, DartObjectImpl> fieldsOfY = _assertType(y, "A");
     expect(fieldsOfY, hasLength(1));
     _assertIntField(fieldsOfY, fieldName, 10);
   }
 
   /**
    * Search [compilationUnit] for a class named [className], containing a
    * method [methodName], with exactly one annotation.  Return the constant
    * value of the annotation.
    */
   EvaluationResultImpl _evaluateAnnotation(
       CompilationUnit compilationUnit, String className, String memberName) {
     for (CompilationUnitMember member in compilationUnit.declarations) {
       if (member is ClassDeclaration && member.name.name == className) {
         for (ClassMember classMember in member.members) {
           if (classMember is MethodDeclaration &&
               classMember.name.name == memberName) {
             expect(classMember.metadata, hasLength(1));
             ElementAnnotationImpl elementAnnotation =
                 classMember.metadata[0].elementAnnotation;
             return elementAnnotation.evaluationResult;
           }
         }
       }
     }
     fail('Class member not found');
     return null;
   }
 
-  EvaluationResultImpl _evaluateInstanceCreationExpression(
+  EvaluationResultImpl _evaluateTopLevelVariable(
       CompilationUnit compilationUnit, String name) {
-    Expression expression =
-        findTopLevelConstantExpression(compilationUnit, name);
-    return (expression as InstanceCreationExpression).evaluationResult;
+    VariableDeclaration varDecl =
+        findTopLevelDeclaration(compilationUnit, name);
+    ConstTopLevelVariableElementImpl varElement = varDecl.element;
+    return varElement.evaluationResult;
   }
 
   ConstantValueComputer _makeConstantValueComputer() {
     ConstantEvaluationValidator_ForTest validator =
         new ConstantEvaluationValidator_ForTest();
     validator.computer = new ConstantValueComputer(
         analysisContext2.typeProvider, analysisContext2.declaredVariables,
         validator);
     return validator.computer;
   }
@@ skipping 21 matching lines @@
         AstFactory.booleanLiteral(false), thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
     _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(
-        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(
@@ skipping 5628 matching lines @@
   AstNode _tail;
   @override
   void setUp() {
     _referenceGraph = new DirectedGraph<AstNode>();
     _variableDeclarationMap =
         new HashMap<PotentiallyConstVariableElement, VariableDeclaration>();
     _constructorDeclarationMap =
         new HashMap<ConstructorElement, ConstructorDeclaration>();
     _head = AstFactory.variableDeclaration("v1");
   }
-  void test_visitInstanceCreationExpression_const() {
-    _visitNode(_makeTailConstructor("A", true, true, true));
-    _assertOneArc(_tail);
-  }
-  void test_visitInstanceCreationExpression_nonConstDeclaration() {
-    // In the source:
-    //   const x = const A();
-    // x depends on "const A()" even if the A constructor
-    // isn't declared as const.
-    _visitNode(_makeTailConstructor("A", false, true, true));
-    _assertOneArc(_tail);
-  }
-  void test_visitInstanceCreationExpression_nonConstUsage() {
-    _visitNode(_makeTailConstructor("A", true, false, true));
-    _assertNoArcs();
-  }
-  void test_visitInstanceCreationExpression_notInMap() {
-    // In the source:
-    //   const x = const A();
-    // x depends on "const A()" even if the AST for the A constructor
-    // isn't available.
-    _visitNode(_makeTailConstructor("A", true, true, false));
-    _assertOneArc(_tail);
-  }
   void test_visitSimpleIdentifier_const() {
     _visitNode(_makeTailVariable("v2", true, true));
     _assertOneArc(_tail);
   }
   void test_visitSimpleIdentifier_nonConst() {
     _visitNode(_makeTailVariable("v2", false, true));
     _assertNoArcs();
   }
   void test_visitSimpleIdentifier_notInMap() {
     _visitNode(_makeTailVariable("v2", true, false));
@@ skipping 23 matching lines @@
     expect(tails, hasLength(0));
   }
   void _assertOneArc(AstNode tail) {
     Set<AstNode> tails = _referenceGraph.getTails(_head);
     expect(tails, hasLength(1));
     expect(tails.first, same(tail));
   }
   ReferenceFinder _createReferenceFinder(AstNode source) => new ReferenceFinder(
       source, _referenceGraph, _variableDeclarationMap,
       _constructorDeclarationMap);
-  InstanceCreationExpression _makeTailConstructor(
-      String name, bool isConstDeclaration, bool isConstUsage, bool inMap) {
-    List<ConstructorInitializer> initializers =
-        new List<ConstructorInitializer>();
-    ConstructorDeclaration constructorDeclaration = AstFactory
-        .constructorDeclaration(AstFactory.identifier3(name), null,
-            AstFactory.formalParameterList(), initializers);
-    if (isConstDeclaration) {
-      constructorDeclaration.constKeyword = new KeywordToken(Keyword.CONST, 0);
-    }
-    ClassElementImpl classElement = ElementFactory.classElement2(name);
-    SimpleIdentifier identifier = AstFactory.identifier3(name);
-    TypeName type = AstFactory.typeName3(identifier);
-    InstanceCreationExpression instanceCreationExpression = AstFactory
-        .instanceCreationExpression2(
-            isConstUsage ? Keyword.CONST : Keyword.NEW, type);
-    _tail = instanceCreationExpression;
-    ConstructorElementImpl constructorElement = ElementFactory
-        .constructorElement(classElement, name, isConstDeclaration);
-    if (inMap) {
-      _constructorDeclarationMap[constructorElement] = constructorDeclaration;
-    }
-    instanceCreationExpression.staticElement = constructorElement;
-    return instanceCreationExpression;
-  }
   SuperConstructorInvocation _makeTailSuperConstructorInvocation(
       String name, bool isConst, bool inMap) {
     List<ConstructorInitializer> initializers =
         new List<ConstructorInitializer>();
     ConstructorDeclaration constructorDeclaration = AstFactory
         .constructorDeclaration(AstFactory.identifier3(name), null,
             AstFactory.formalParameterList(), initializers);
     _tail = constructorDeclaration;
     if (isConst) {
       constructorDeclaration.constKeyword = new KeywordToken(Keyword.CONST, 0);
@@ skipping 595 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");
     }
   }
 }