Explicitly compute analysis results for sources to check errors.

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';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/constant.dart';
@@ skipping 359 matching lines @@
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit);
     computer.computeValues();
     TopLevelVariableDeclaration declaration = unit.declarations
         .firstWhere((member) => member is TopLevelVariableDeclaration);
     _validate(true, declaration.variables);
   }
 
   test_dependencyOnConstructor() async {
     // x depends on "const A()"
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 class A {
   const A();
 }
 const x = const A();''');
   }
 
   test_dependencyOnConstructorArgument() async {
     // "const A(x)" depends on x
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 class A {
   const A(this.next);
   final A next;
 }
 const A x = const A(null);
 const A y = const A(x);''');
   }
 
   test_dependencyOnConstructorArgument_unresolvedConstructor() async {
     // "const A.a(x)" depends on x even if the constructor A.a can't be found.
-    await _assertProperDependencies2(
+    await _assertProperDependencies(
         r'''
 class A {
 }
 const int x = 1;
 const A y = const A.a(x);''',
         [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR]);
   }
 
   test_dependencyOnConstructorInitializer() async {
     // "const A()" depends on x
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 const int x = 1;
 class A {
   const A() : v = x;
   final int v;
 }''');
   }
 
   test_dependencyOnExplicitSuperConstructor() async {
     // b depends on B() depends on A()
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 class A {
   const A(this.x);
   final int x;
 }
 class B extends A {
   const B() : super(5);
 }
 const B b = const B();''');
   }
 
   test_dependencyOnExplicitSuperConstructorParameters() async {
     // b depends on B() depends on i
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 class A {
   const A(this.x);
   final int x;
 }
 class B extends A {
   const B() : super(i);
 }
 const B b = const B();
 const int i = 5;''');
   }
 
   test_dependencyOnFactoryRedirect() async {
     // a depends on A.foo() depends on A.bar()
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   factory const A.foo() = A.bar;
   const A.bar();
 }''');
   }
 
   test_dependencyOnFactoryRedirectWithTypeParams() async {
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(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);''');
   }
 
   test_dependencyOnImplicitSuperConstructor() async {
     // b depends on B() depends on A()
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 class A {
   const A() : x = 5;
   final int x;
 }
 class B extends A {
   const B();
 }
 const B b = const B();''');
   }
 
   test_dependencyOnInitializedFinal() async {
     // a depends on A() depends on A.x
-    await _assertProperDependencies2('''
+    await _assertProperDependencies('''
 class A {
   const A();
   final int x = 1;
 }
 const A a = const A();
 ''');
   }
 
   test_dependencyOnInitializedNonStaticConst() async {
     // 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
-    await _assertProperDependencies2(
+    await _assertProperDependencies(
         '''
 class A {
   const A();
   const int x = 1;
 }
 const A a = const A();
 ''',
         [CompileTimeErrorCode.CONST_INSTANCE_FIELD]);
   }
 
   test_dependencyOnNonFactoryRedirect() async {
     // a depends on A.foo() depends on A.bar()
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this.bar();
   const A.bar();
 }''');
   }
 
   test_dependencyOnNonFactoryRedirect_arg() async {
     // a depends on A.foo() depends on b
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 const A a = const A.foo();
 const int b = 1;
 class A {
   const A.foo() : this.bar(b);
   const A.bar(x) : y = x;
   final int y;
 }''');
   }
 
   test_dependencyOnNonFactoryRedirect_defaultValue() async {
     // a depends on A.foo() depends on A.bar() depends on b
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 const A a = const A.foo();
 const int b = 1;
 class A {
   const A.foo() : this.bar();
   const A.bar([x = b]) : y = x;
   final int y;
 }''');
   }
 
   test_dependencyOnNonFactoryRedirect_toMissing() async {
     // a depends on A.foo() which depends on nothing, since A.bar() is
     // missing.
-    await _assertProperDependencies2(
+    await _assertProperDependencies(
         r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this.bar();
 }''',
         [CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR]);
   }
 
   test_dependencyOnNonFactoryRedirect_toNonConst() async {
     // a depends on A.foo() which depends on nothing, since A.bar() is
     // non-const.
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this.bar();
   A.bar();
 }''');
   }
 
   test_dependencyOnNonFactoryRedirect_unnamed() async {
     // a depends on A.foo() depends on A()
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this();
   const A();
 }''');
   }
 
   test_dependencyOnOptionalParameterDefault() async {
     // a depends on A() depends on B()
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 class A {
   const A([x = const B()]) : b = x;
   final B b;
 }
 class B {
   const B();
 }
 const A a = const A();''');
   }
 
   test_dependencyOnVariable() async {
     // x depends on y
-    await _assertProperDependencies2(r'''
+    await _assertProperDependencies(r'''
 const x = y + 1;
 const y = 2;''');
   }
 
   test_final_initialized_at_declaration() async {
     CompilationUnit compilationUnit = resolveSource('''
 class A {
   final int i = 123;
   const A();
 }
@@ skipping 573 matching lines @@
     DartObjectImpl field = fields[fieldName];
     expect(field.type.name, "int");
     expect(field.toIntValue(), expectedValue);
   }
 
   void _assertNullField(Map<String, DartObjectImpl> fields, String fieldName) {
     DartObjectImpl field = fields[fieldName];
     expect(field.isNull, isTrue);
   }
 
-  Future<Null> _assertProperDependencies2(String sourceText,
+  Future<Null> _assertProperDependencies(String sourceText,
       [List<ErrorCode> expectedErrorCodes = const <ErrorCode>[]]) async {
     Source source = addSource(sourceText);
     LibraryElement element = resolve2(source);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, element);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit);
     computer.computeValues();
-    await assertErrors(source, expectedErrorCodes);
+    await computeAnalysisResult(source);
+    assertErrors(source, expectedErrorCodes);
   }
 
   Map<String, DartObjectImpl> _assertType(
       EvaluationResultImpl result, String typeName) {
     expect(result.value, isNotNull);
     DartObjectImpl value = result.value;
     expect(value.type.displayName, typeName);
     return value.fields;
   }
 
@@ skipping 386 matching lines @@
   }
 }
 
 @reflectiveTest
 class StrongConstantValueComputerTest extends ConstantValueComputerTest {
   void setUp() {
     super.setUp();
     resetWithOptions(new AnalysisOptionsImpl()..strongMode = true);
   }
 }