Run the rest of the analysis tests with the new analysis driver.

pkg/analyzer/test/src/dart/constant/evaluation_test.dart

 // Copyright (c) 2016, 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.
 
 library analyzer.test.constant_test;
 
 import 'dart:async';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 77 matching lines @@
 $text''');
       }
     }
     fail(out.toString());
   }
 }
 
 @reflectiveTest
 class ConstantValueComputerTest extends ResolverTestCase {
   test_annotation_constConstructor() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 class A {
   final int i;
   const A(this.i);
 }
 
 class C {
   @A(5)
   f() {}
 }
 ''');
     EvaluationResultImpl result =
         _evaluateAnnotation(compilationUnit, "C", "f");
     Map<String, DartObjectImpl> annotationFields = _assertType(result, 'A');
     _assertIntField(annotationFields, 'i', 5);
   }
 
   test_annotation_constConstructor_named() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 class A {
   final int i;
   const A.named(this.i);
 }
 
 class C {
   @A.named(5)
   f() {}
 }
 ''');
     EvaluationResultImpl result =
         _evaluateAnnotation(compilationUnit, "C", "f");
     Map<String, DartObjectImpl> annotationFields = _assertType(result, 'A');
     _assertIntField(annotationFields, 'i', 5);
   }
 
   test_annotation_constConstructor_noArgs() async {
     // Failing to pass arguments to an annotation which is a constant
     // constructor is illegal, but shouldn't crash analysis.
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 class A {
   final int i;
   const A(this.i);
 }
 
 class C {
   @A
   f() {}
 }
 ''');
     _evaluateAnnotation(compilationUnit, "C", "f");
   }
 
   test_annotation_constConstructor_noArgs_named() async {
     // Failing to pass arguments to an annotation which is a constant
     // constructor is illegal, but shouldn't crash analysis.
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 class A {
   final int i;
   const A.named(this.i);
 }
 
 class C {
   @A.named
   f() {}
 }
 ''');
     _evaluateAnnotation(compilationUnit, "C", "f");
   }
 
   test_annotation_nonConstConstructor() async {
     // Calling a non-const constructor from an annotation that is illegal, but
     // shouldn't crash analysis.
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 class A {
   final int i;
   A(this.i);
 }
 
 class C {
   @A(5)
   f() {}
 }
 ''');
     _evaluateAnnotation(compilationUnit, "C", "f");
   }
 
   test_annotation_staticConst() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 class C {
   static const int i = 5;
 
   @i
   f() {}
 }
 ''');
     EvaluationResultImpl result =
         _evaluateAnnotation(compilationUnit, "C", "f");
     expect(_assertValidInt(result), 5);
   }
 
   test_annotation_staticConst_args() async {
     // Applying arguments to an annotation that is a static const is
     // illegal, but shouldn't crash analysis.
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 class C {
   static const int i = 5;
 
   @i(1)
   f() {}
 }
 ''');
     _evaluateAnnotation(compilationUnit, "C", "f");
   }
 
   test_annotation_staticConst_otherClass() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 class A {
   static const int i = 5;
 }
 
 class C {
   @A.i
   f() {}
 }
 ''');
     EvaluationResultImpl result =
         _evaluateAnnotation(compilationUnit, "C", "f");
     expect(_assertValidInt(result), 5);
   }
 
   test_annotation_staticConst_otherClass_args() async {
     // Applying arguments to an annotation that is a static const is
     // illegal, but shouldn't crash analysis.
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 class A {
   static const int i = 5;
 }
 
 class C {
   @A.i(1)
   f() {}
 }
 ''');
     _evaluateAnnotation(compilationUnit, "C", "f");
   }
 
   test_annotation_topLevelVariable() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const int i = 5;
 class C {
   @i
   f() {}
 }
 ''');
     EvaluationResultImpl result =
         _evaluateAnnotation(compilationUnit, "C", "f");
     expect(_assertValidInt(result), 5);
   }
 
   test_annotation_topLevelVariable_args() async {
     // Applying arguments to an annotation that is a top-level variable is
     // illegal, but shouldn't crash analysis.
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const int i = 5;
 class C {
   @i(1)
   f() {}
 }
 ''');
     _evaluateAnnotation(compilationUnit, "C", "f");
   }
 
   test_computeValues_cycle() async {
@@ skipping 324 matching lines @@
   }
 
   test_dependencyOnVariable() async {
     // x depends on y
     await _assertProperDependencies(r'''
 const x = y + 1;
 const y = 2;''');
   }
 
   test_final_initialized_at_declaration() async {
-    CompilationUnit compilationUnit = resolveSource('''
+    CompilationUnit compilationUnit = await resolveSource('''
 class A {
   final int i = 123;
   const A();
 }
 
 const A a = const A();
 ''');
     EvaluationResultImpl result =
         _evaluateTopLevelVariable(compilationUnit, 'a');
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "i", 123);
   }
 
   test_fromEnvironment_bool_default_false() async {
-    expect(_assertValidBool(_check_fromEnvironment_bool(null, "false")), false);
+    expect(_assertValidBool(await _check_fromEnvironment_bool(null, "false")),
+        false);
   }
 
   test_fromEnvironment_bool_default_overridden() async {
-    expect(
-        _assertValidBool(_check_fromEnvironment_bool("false", "true")), false);
+    expect(_assertValidBool(await _check_fromEnvironment_bool("false", "true")),
+        false);
   }
 
   test_fromEnvironment_bool_default_parseError() async {
-    expect(_assertValidBool(_check_fromEnvironment_bool("parseError", "true")),
+    expect(
+        _assertValidBool(
+            await _check_fromEnvironment_bool("parseError", "true")),
         true);
   }
 
   test_fromEnvironment_bool_default_true() async {
-    expect(_assertValidBool(_check_fromEnvironment_bool(null, "true")), true);
+    expect(_assertValidBool(await _check_fromEnvironment_bool(null, "true")),
+        true);
   }
 
   test_fromEnvironment_bool_false() async {
-    expect(_assertValidBool(_check_fromEnvironment_bool("false", null)), false);
+    expect(_assertValidBool(await _check_fromEnvironment_bool("false", null)),
+        false);
   }
 
   test_fromEnvironment_bool_parseError() async {
-    expect(_assertValidBool(_check_fromEnvironment_bool("parseError", null)),
+    expect(
+        _assertValidBool(await _check_fromEnvironment_bool("parseError", null)),
         false);
   }
 
   test_fromEnvironment_bool_true() async {
-    expect(_assertValidBool(_check_fromEnvironment_bool("true", null)), true);
+    expect(_assertValidBool(await _check_fromEnvironment_bool("true", null)),
+        true);
   }
 
   test_fromEnvironment_bool_undeclared() async {
-    _assertValidUnknown(_check_fromEnvironment_bool(null, null));
+    _assertValidUnknown(await _check_fromEnvironment_bool(null, null));
   }
 
   test_fromEnvironment_int_default_overridden() async {
-    expect(_assertValidInt(_check_fromEnvironment_int("234", "123")), 234);
+    expect(
+        _assertValidInt(await _check_fromEnvironment_int("234", "123")), 234);
   }
 
   test_fromEnvironment_int_default_parseError() async {
     expect(
-        _assertValidInt(_check_fromEnvironment_int("parseError", "123")), 123);
+        _assertValidInt(await _check_fromEnvironment_int("parseError", "123")),
+        123);
   }
 
   test_fromEnvironment_int_default_undeclared() async {
-    expect(_assertValidInt(_check_fromEnvironment_int(null, "123")), 123);
+    expect(_assertValidInt(await _check_fromEnvironment_int(null, "123")), 123);
   }
 
   test_fromEnvironment_int_ok() async {
-    expect(_assertValidInt(_check_fromEnvironment_int("234", null)), 234);
+    expect(_assertValidInt(await _check_fromEnvironment_int("234", null)), 234);
   }
 
   test_fromEnvironment_int_parseError() async {
-    _assertValidNull(_check_fromEnvironment_int("parseError", null));
+    _assertValidNull(await _check_fromEnvironment_int("parseError", null));
   }
 
   test_fromEnvironment_int_parseError_nullDefault() async {
-    _assertValidNull(_check_fromEnvironment_int("parseError", "null"));
+    _assertValidNull(await _check_fromEnvironment_int("parseError", "null"));
   }
 
   test_fromEnvironment_int_undeclared() async {
-    _assertValidUnknown(_check_fromEnvironment_int(null, null));
+    _assertValidUnknown(await _check_fromEnvironment_int(null, null));
   }
 
   test_fromEnvironment_int_undeclared_nullDefault() async {
-    _assertValidNull(_check_fromEnvironment_int(null, "null"));
+    _assertValidNull(await _check_fromEnvironment_int(null, "null"));
   }
 
   test_fromEnvironment_string_default_overridden() async {
-    expect(_assertValidString(_check_fromEnvironment_string("abc", "'def'")),
+    expect(
+        _assertValidString(await _check_fromEnvironment_string("abc", "'def'")),
         "abc");
   }
 
   test_fromEnvironment_string_default_undeclared() async {
-    expect(_assertValidString(_check_fromEnvironment_string(null, "'def'")),
+    expect(
+        _assertValidString(await _check_fromEnvironment_string(null, "'def'")),
         "def");
   }
 
   test_fromEnvironment_string_empty() async {
-    expect(_assertValidString(_check_fromEnvironment_string("", null)), "");
+    expect(
+        _assertValidString(await _check_fromEnvironment_string("", null)), "");
   }
 
   test_fromEnvironment_string_ok() async {
-    expect(
-        _assertValidString(_check_fromEnvironment_string("abc", null)), "abc");
+    expect(_assertValidString(await _check_fromEnvironment_string("abc", null)),
+        "abc");
   }
 
   test_fromEnvironment_string_undeclared() async {
-    _assertValidUnknown(_check_fromEnvironment_string(null, null));
+    _assertValidUnknown(await _check_fromEnvironment_string(null, null));
   }
 
   test_fromEnvironment_string_undeclared_nullDefault() async {
-    _assertValidNull(_check_fromEnvironment_string(null, "null"));
+    _assertValidNull(await _check_fromEnvironment_string(null, "null"));
   }
 
   test_instanceCreationExpression_computedField() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await 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 =
         _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "k", 13);
   }
 
   test_instanceCreationExpression_computedField_namedOptionalWithDefault() async {
-    _checkInstanceCreationOptionalParams(false, true, true);
+    await _checkInstanceCreationOptionalParams(false, true, true);
   }
 
   test_instanceCreationExpression_computedField_namedOptionalWithoutDefault() async {
-    _checkInstanceCreationOptionalParams(false, true, false);
+    await _checkInstanceCreationOptionalParams(false, true, false);
   }
 
   test_instanceCreationExpression_computedField_unnamedOptionalWithDefault() async {
-    _checkInstanceCreationOptionalParams(false, false, true);
+    await _checkInstanceCreationOptionalParams(false, false, true);
   }
 
   test_instanceCreationExpression_computedField_unnamedOptionalWithoutDefault() async {
-    _checkInstanceCreationOptionalParams(false, false, false);
+    await _checkInstanceCreationOptionalParams(false, false, false);
   }
 
   test_instanceCreationExpression_computedField_usesConstConstructor() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 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 =
         _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);
   }
 
   test_instanceCreationExpression_computedField_usesStaticConst() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await 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 =
         _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "k", 7);
   }
 
   test_instanceCreationExpression_computedField_usesTopLevelConst() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const foo = const A(3);
 const bar = 4;
 class A {
   const A(int i) : k = i + bar;
   final int k;
 }''');
     EvaluationResultImpl result =
         _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "k", 7);
   }
 
   test_instanceCreationExpression_explicitSuper() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await 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 =
         _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);
   }
 
   test_instanceCreationExpression_fieldFormalParameter() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const foo = const A(42);
 class A {
   int x;
   const A(this.x)
 }''');
     EvaluationResultImpl result =
         _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "x", 42);
   }
 
   test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithDefault() async {
-    _checkInstanceCreationOptionalParams(true, true, true);
+    await _checkInstanceCreationOptionalParams(true, true, true);
   }
 
   test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithoutDefault() async {
-    _checkInstanceCreationOptionalParams(true, true, false);
+    await _checkInstanceCreationOptionalParams(true, true, false);
   }
 
   test_instanceCreationExpression_fieldFormalParameter_unnamedOptionalWithDefault() async {
-    _checkInstanceCreationOptionalParams(true, false, true);
+    await _checkInstanceCreationOptionalParams(true, false, true);
   }
 
   test_instanceCreationExpression_fieldFormalParameter_unnamedOptionalWithoutDefault() async {
-    _checkInstanceCreationOptionalParams(true, false, false);
+    await _checkInstanceCreationOptionalParams(true, false, false);
   }
 
   test_instanceCreationExpression_implicitSuper() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 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 =
         _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);
   }
 
   test_instanceCreationExpression_nonFactoryRedirect() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await 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(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'x', 5);
   }
 
   test_instanceCreationExpression_nonFactoryRedirect_arg() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await 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(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'y', 111);
   }
 
   test_instanceCreationExpression_nonFactoryRedirect_cycle() async {
     // 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'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const foo = const A();
 class A {
   const A() : this.b();
   const A.b() : this();
 }''');
     _assertValidUnknown(_evaluateTopLevelVariable(compilationUnit, "foo"));
   }
 
   test_instanceCreationExpression_nonFactoryRedirect_defaultArg() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await 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(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'y', 110);
   }
 
   test_instanceCreationExpression_nonFactoryRedirect_toMissing() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await 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(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
   }
 
   test_instanceCreationExpression_nonFactoryRedirect_toNonConst() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await 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(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
   }
 
   test_instanceCreationExpression_nonFactoryRedirect_unnamed() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await 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(_evaluateTopLevelVariable(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'x', 5);
   }
 
   test_instanceCreationExpression_redirect() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const foo = const A();
 class A {
   const factory A() = B;
 }
 class B implements A {
   const B();
 }''');
     _assertType(_evaluateTopLevelVariable(compilationUnit, "foo"), "B");
   }
 
   test_instanceCreationExpression_redirect_cycle() async {
     // 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'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const foo = const A();
 class A {
   const factory A() = A.b;
   const factory A.b() = A;
 }''');
     _assertValidUnknown(_evaluateTopLevelVariable(compilationUnit, "foo"));
   }
 
   test_instanceCreationExpression_redirect_external() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const foo = const A();
 class A {
   external const factory A();
 }''');
     _assertValidUnknown(_evaluateTopLevelVariable(compilationUnit, "foo"));
   }
 
   test_instanceCreationExpression_redirect_nonConst() async {
     // 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'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const foo = const A();
 class A {
   const factory A() = A.b;
   A.b();
 }''');
     _assertValidUnknown(_evaluateTopLevelVariable(compilationUnit, "foo"));
   }
 
   test_instanceCreationExpression_redirectWithTypeParams() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await 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 =
         _evaluateTopLevelVariable(compilationUnit, "a");
     Map<String, DartObjectImpl> fields = _assertType(result, "B<int>");
     expect(fields, hasLength(1));
     _assertIntField(fields, "x", 10);
   }
 
   test_instanceCreationExpression_redirectWithTypeSubstitution() async {
     // 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'''
+    CompilationUnit compilationUnit = await 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 =
         _evaluateTopLevelVariable(compilationUnit, "a");
     Map<String, DartObjectImpl> fields = _assertType(result, "B<int>");
     expect(fields, hasLength(1));
     _assertIntField(fields, "x", 10);
   }
 
   test_instanceCreationExpression_symbol() async {
     CompilationUnit compilationUnit =
-        resolveSource("const foo = const Symbol('a');");
+        await resolveSource("const foo = const Symbol('a');");
     EvaluationResultImpl evaluationResult =
         _evaluateTopLevelVariable(compilationUnit, "foo");
     expect(evaluationResult.value, isNotNull);
     DartObjectImpl value = evaluationResult.value;
     expect(value.type, typeProvider.symbolType);
     expect(value.toSymbolValue(), "a");
   }
 
   test_instanceCreationExpression_withSupertypeParams_explicit() async {
-    _checkInstanceCreation_withSupertypeParams(true);
+    await _checkInstanceCreation_withSupertypeParams(true);
   }
 
   test_instanceCreationExpression_withSupertypeParams_implicit() async {
-    _checkInstanceCreation_withSupertypeParams(false);
+    await _checkInstanceCreation_withSupertypeParams(false);
   }
 
   test_instanceCreationExpression_withTypeParams() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 class C<E> {
   const C();
 }
 const c_int = const C<int>();
 const c_num = const C<num>();''');
     EvaluationResultImpl c_int =
         _evaluateTopLevelVariable(compilationUnit, "c_int");
     _assertType(c_int, "C<int>");
     DartObjectImpl c_int_value = c_int.value;
     EvaluationResultImpl c_num =
@@ skipping 27 matching lines @@
     expect(ConstantEvaluationEngine.isValidPublicSymbol("foo."), isFalse);
     expect(ConstantEvaluationEngine.isValidPublicSymbol("+.foo"), isFalse);
     expect(ConstantEvaluationEngine.isValidPublicSymbol("void.foo"), isFalse);
     expect(ConstantEvaluationEngine.isValidPublicSymbol("foo.void"), isFalse);
   }
 
   test_length_of_improperly_typed_string_expression() async {
     // 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('''
+    CompilationUnit compilationUnit = await resolveSource('''
 const int s1 = 'alpha';
 const int s2 = 'beta';
 const int i = (true ? s1 : s2).length;
 ''');
     ConstTopLevelVariableElementImpl element =
         findTopLevelDeclaration(compilationUnit, 'i').element;
     EvaluationResultImpl result = element.evaluationResult;
     expect(_assertValidInt(result), 5);
   }
 
   test_length_of_improperly_typed_string_identifier() async {
     // Since type annotations are ignored in unchecked mode, the improper type
     // on s shouldn't prevent us from evaluating i to 'alpha'.length.
-    CompilationUnit compilationUnit = resolveSource('''
+    CompilationUnit compilationUnit = await resolveSource('''
 const int s = 'alpha';
 const int i = s.length;
 ''');
     ConstTopLevelVariableElementImpl element =
         findTopLevelDeclaration(compilationUnit, 'i').element;
     EvaluationResultImpl result = element.evaluationResult;
     expect(_assertValidInt(result), 5);
   }
 
   test_non_static_const_initialized_at_declaration() async {
     // Even though non-static consts are not allowed by the language, we need
     // to handle them for error recovery purposes.
-    CompilationUnit compilationUnit = resolveSource('''
+    CompilationUnit compilationUnit = await resolveSource('''
 class A {
   const int i = 123;
   const A();
 }
 
 const A a = const A();
 ''');
     EvaluationResultImpl result =
         _evaluateTopLevelVariable(compilationUnit, 'a');
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "i", 123);
   }
 
   test_symbolLiteral_void() async {
     CompilationUnit compilationUnit =
-        resolveSource("const voidSymbol = #void;");
+        await 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.toSymbolValue(), "void");
   }
 
   Map<String, DartObjectImpl> _assertFieldType(
@@ skipping 68 matching lines @@
     expect(value.type, typeProvider.stringType);
     return value.toStringValue();
   }
 
   void _assertValidUnknown(EvaluationResultImpl result) {
     expect(result.value, isNotNull);
     DartObjectImpl value = result.value;
     expect(value.isUnknown, isTrue);
   }
 
-  EvaluationResultImpl _check_fromEnvironment_bool(
-      String valueInEnvironment, String defaultExpr) {
+  Future<EvaluationResultImpl> _check_fromEnvironment_bool(
+      String valueInEnvironment, String defaultExpr) async {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
         defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
-    CompilationUnit compilationUnit = resolveSource(
+    CompilationUnit compilationUnit = await resolveSource(
         "const $varName = const bool.fromEnvironment('$envVarName'$defaultArg);");
     return _evaluateTopLevelVariable(compilationUnit, varName);
   }
 
-  EvaluationResultImpl _check_fromEnvironment_int(
-      String valueInEnvironment, String defaultExpr) {
+  Future<EvaluationResultImpl> _check_fromEnvironment_int(
+      String valueInEnvironment, String defaultExpr) async {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
         defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
-    CompilationUnit compilationUnit = resolveSource(
+    CompilationUnit compilationUnit = await resolveSource(
         "const $varName = const int.fromEnvironment('$envVarName'$defaultArg);");
     return _evaluateTopLevelVariable(compilationUnit, varName);
   }
 
-  EvaluationResultImpl _check_fromEnvironment_string(
-      String valueInEnvironment, String defaultExpr) {
+  Future<EvaluationResultImpl> _check_fromEnvironment_string(
+      String valueInEnvironment, String defaultExpr) async {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
         defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
-    CompilationUnit compilationUnit = resolveSource(
+    CompilationUnit compilationUnit = await resolveSource(
         "const $varName = const String.fromEnvironment('$envVarName'$defaultArg);");
     return _evaluateTopLevelVariable(compilationUnit, varName);
   }
 
-  void _checkInstanceCreation_withSupertypeParams(bool isExplicit) {
+  Future<Null> _checkInstanceCreation_withSupertypeParams(
+      bool isExplicit) async {
     String superCall = isExplicit ? " : super()" : "";
-    CompilationUnit compilationUnit = resolveSource("""
+    CompilationUnit compilationUnit = await 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 =
         _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 =
         _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) {
+  Future<Null> _checkInstanceCreationOptionalParams(
+      bool isFieldFormal, bool isNamed, bool hasDefault) async {
     String fieldName = "j";
     String paramName = isFieldFormal ? fieldName : "i";
     String formalParam =
         "${isFieldFormal ? "this." : "int "}$paramName${hasDefault ? " = 3" : ""}";
-    CompilationUnit compilationUnit = resolveSource("""
+    CompilationUnit compilationUnit = await 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 = _evaluateTopLevelVariable(compilationUnit, "x");
     Map<String, DartObjectImpl> fieldsOfX = _assertType(x, "A");
     expect(fieldsOfX, hasLength(1));
     if (hasDefault) {
@@ skipping 174 matching lines @@
     ConditionalExpression expression = AstTestFactory.conditionalExpression(
         AstTestFactory.booleanLiteral(true), thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
     _assertValue(1, _evaluate(expression, errorReporter));
     errorListener.assertNoErrors();
   }
 
   test_visitSimpleIdentifier_className() async {
-    CompilationUnit compilationUnit = resolveSource('''
+    CompilationUnit compilationUnit = await resolveSource('''
 const a = C;
 class C {}
 ''');
     DartObjectImpl result = _evaluateConstant(compilationUnit, 'a', null);
     expect(result.type, typeProvider.typeType);
     expect(result.toTypeValue().name, 'C');
   }
 
   test_visitSimpleIdentifier_dynamic() async {
-    CompilationUnit compilationUnit = resolveSource('''
+    CompilationUnit compilationUnit = await resolveSource('''
 const a = dynamic;
 ''');
     DartObjectImpl result = _evaluateConstant(compilationUnit, 'a', null);
     expect(result.type, typeProvider.typeType);
     expect(result.toTypeValue(), typeProvider.dynamicType);
   }
 
   test_visitSimpleIdentifier_inEnvironment() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const a = b;
 const b = 3;''');
     Map<String, DartObjectImpl> environment = new Map<String, DartObjectImpl>();
     DartObjectImpl six =
         new DartObjectImpl(typeProvider.intType, new IntState(6));
     environment["b"] = six;
     _assertValue(6, _evaluateConstant(compilationUnit, "a", environment));
   }
 
   test_visitSimpleIdentifier_notInEnvironment() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const a = b;
 const b = 3;''');
     Map<String, DartObjectImpl> environment = new Map<String, DartObjectImpl>();
     DartObjectImpl six =
         new DartObjectImpl(typeProvider.intType, new IntState(6));
     environment["c"] = six;
     _assertValue(3, _evaluateConstant(compilationUnit, "a", environment));
   }
 
   test_visitSimpleIdentifier_withoutEnvironment() async {
-    CompilationUnit compilationUnit = resolveSource(r'''
+    CompilationUnit compilationUnit = await resolveSource(r'''
 const a = b;
 const b = 3;''');
     _assertValue(3, _evaluateConstant(compilationUnit, "a", null));
   }
 
   void _assertValue(int expectedValue, DartObjectImpl result) {
     expect(result, isNotNull);
     expect(result.type.name, "int");
     expect(result.toIntValue(), expectedValue);
   }
@@ skipping 29 matching lines @@
   }
 }
 
 @reflectiveTest
 class StrongConstantValueComputerTest extends ConstantValueComputerTest {
   void setUp() {
     super.setUp();
     resetWith(options: new AnalysisOptionsImpl()..strongMode = true);
   }
 }