Explicitly compute analysis results for sources to check errors.

pkg/analyzer/test/generated/simple_resolver_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.generated.simple_resolver_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 379 matching lines @@
   }
 
   test_class_definesCall() async {
     Source source = addSource(r'''
 class A {
   int call(int x) { return x; }
 }
 int f(A a) {
   return a(0);
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_class_extends_implements() async {
     Source source = addSource(r'''
 class A extends B implements C {}
 class B {}
 class C {}''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_commentReference_class() async {
     Source source = addSource(r'''
 f() {}
 /** [A] [new A] [A.n] [new A.n] [m] [f] */
 class A {
   A() {}
   A.n() {}
   m() {}
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_commentReference_parameter() async {
     Source source = addSource(r'''
 class A {
   A() {}
   A.n() {}
   /** [e] [f] */
   m(e, f()) {}
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_commentReference_singleLine() async {
     Source source = addSource(r'''
 /// [A]
 class A {}''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_continueTarget_labeled() async {
     // Verify that the target of the label is correctly found and is recorded
     // as the unlabeled portion of the statement.
     String text = r'''
 void f() {
   loop1: while (true) {
     loop2: for (int i = 0; i < 10; i++) {
@@ skipping 112 matching lines @@
 }
 ''';
     CompilationUnit unit = resolveSource(text);
     ContinueStatement continueStatement = EngineTestCase.findNode(
         unit, text, 'continue', (n) => n is ContinueStatement);
     expect(continueStatement.target, isNull);
   }
 
   test_empty() async {
     Source source = addSource("");
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_entryPoint_exported() async {
     addNamedSource(
         "/two.dart",
         r'''
 library two;
 main() {}''');
     Source source = addNamedSource(
         "/one.dart",
         r'''
 library one;
 export 'two.dart';''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     FunctionElement main = library.entryPoint;
     expect(main, isNotNull);
     expect(main.library, isNot(same(library)));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_entryPoint_local() async {
     Source source = addNamedSource(
         "/one.dart",
         r'''
 library one;
 main() {}''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     FunctionElement main = library.entryPoint;
     expect(main, isNotNull);
     expect(main.library, same(library));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_entryPoint_none() async {
     Source source = addNamedSource("/one.dart", "library one;");
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     expect(library.entryPoint, isNull);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_enum_externalLibrary() async {
     addNamedSource(
         "/my_lib.dart",
         r'''
 library my_lib;
 enum EEE {A, B, C}''');
     Source source = addSource(r'''
 import 'my_lib.dart';
 main() {
   EEE e = null;
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_extractedMethodAsConstant() async {
     Source source = addSource(r'''
 abstract class Comparable<T> {
   int compareTo(T other);
   static int compare(Comparable a, Comparable b) => a.compareTo(b);
 }
 class A {
   void sort([compare = Comparable.compare]) {}
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_fieldFormalParameter() async {
     Source source = addSource(r'''
 class A {
   int x;
   int y;
   A(this.x) : y = x {}
 }''');
     CompilationUnit unit =
         analysisContext2.resolveCompilationUnit2(source, source);
     ClassDeclaration classA = unit.declarations[0];
     FieldDeclaration field = classA.members[0];
     ConstructorDeclaration constructor = classA.members[2];
     ParameterElement paramElement =
         constructor.parameters.parameters[0].element;
     expect(paramElement, new isInstanceOf<FieldFormalParameterElement>());
     expect((paramElement as FieldFormalParameterElement).field,
         field.fields.variables[0].element);
     ConstructorFieldInitializer initializer = constructor.initializers[0];
     SimpleIdentifier identifierX = initializer.expression;
     expect(identifierX.staticElement, paramElement);
 
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_forEachLoops_nonConflicting() async {
     Source source = addSource(r'''
 f() {
   List list = [1,2,3];
   for (int x in list) {}
   for (int x in list) {}
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_forLoops_nonConflicting() async {
     Source source = addSource(r'''
 f() {
   for (int i = 0; i < 3; i++) {
   }
   for (int i = 0; i < 3; i++) {
   }
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_functionTypeAlias() async {
     Source source = addSource(r'''
 typedef bool P(e);
 class A {
   P p;
   m(e) {
     if (p(e)) {}
   }
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_getter_and_setter_fromMixins_bare_identifier() async {
     Source source = addSource('''
 class B {}
 class M1 {
   get x => null;
   set x(value) {}
 }
 class M2 {
   get x => null;
   set x(value) {}
 }
 class C extends B with M1, M2 {
   void f() {
     x += 1;
   }
 }
 ''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
     // Verify that both the getter and setter for "x" in C.f() refer to the
     // accessors defined in M2.
     ClassElement classC = library.definingCompilationUnit.types[3];
     MethodDeclaration f = classC.getMethod('f').computeNode();
     BlockFunctionBody body = f.body;
     ExpressionStatement stmt = body.block.statements[0];
     AssignmentExpression assignment = stmt.expression;
     SimpleIdentifier leftHandSide = assignment.leftHandSide;
     expect(
@@ skipping 20 matching lines @@
 class M2 {
   get x => null;
   set x(value) {}
 }
 class C extends B with M1, M2 {}
 void main() {
   new C().x += 1;
 }
 ''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
     // Verify that both the getter and setter for "x" in "new C().x" refer to
     // the accessors defined in M2.
     FunctionDeclaration main =
         library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     AssignmentExpression assignment = stmt.expression;
     PropertyAccess propertyAccess = assignment.leftHandSide;
     expect(
@@ skipping 17 matching lines @@
 class M2 {
   get x => null;
 }
 class C extends B with M1, M2 {
   f() {
     return x;
   }
 }
 ''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
     // Verify that the getter for "x" in C.f() refers to the getter defined in
     // M2.
     ClassElement classC = library.definingCompilationUnit.types[3];
     MethodDeclaration f = classC.getMethod('f').computeNode();
     BlockFunctionBody body = f.body;
     ReturnStatement stmt = body.block.statements[0];
     SimpleIdentifier x = stmt.expression;
     expect(resolutionMap.staticElementForIdentifier(x).enclosingElement.name,
         'M2');
   }
 
   test_getter_fromMixins_property_access() async {
     Source source = addSource('''
 class B {}
 class M1 {
   get x => null;
 }
 class M2 {
   get x => null;
 }
 class C extends B with M1, M2 {}
 void main() {
   var y = new C().x;
 }
 ''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
     // Verify that the getter for "x" in "new C().x" refers to the getter
     // defined in M2.
     FunctionDeclaration main =
         library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     VariableDeclarationStatement stmt = body.block.statements[0];
     PropertyAccess propertyAccess = stmt.variables.variables[0].initializer;
     expect(
         resolutionMap
             .staticElementForIdentifier(propertyAccess.propertyName)
             .enclosingElement
             .name,
         'M2');
   }
 
   test_getterAndSetterWithDifferentTypes() async {
     Source source = addSource(r'''
 class A {
   int get f => 0;
   void set f(String s) {}
 }
 g (A a) {
   a.f = a.f.toString();
 }''');
-    await assertErrors(
+    await computeAnalysisResult(source);
+    assertErrors(
         source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
 
   test_hasReferenceToSuper() async {
     Source source = addSource(r'''
 class A {}
 class B {toString() => super.toString();}''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     expect(classes, hasLength(2));
     expect(classes[0].hasReferenceToSuper, isFalse);
     expect(classes[1].hasReferenceToSuper, isTrue);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_import_hide() async {
     addNamedSource(
         "/lib1.dart",
         r'''
 library lib1;
 set foo(value) {}
 class A {}''');
     addNamedSource(
         "/lib2.dart",
         r'''
 library lib2;
 set foo(value) {}''');
     Source source = addNamedSource(
         "/lib3.dart",
         r'''
 import 'lib1.dart' hide foo;
 import 'lib2.dart';
 
 main() {
   foo = 0;
 }
 A a;''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_import_prefix() async {
     addNamedSource(
         "/two.dart",
         r'''
 library two;
 f(int x) {
   return x * x;
 }''');
     Source source = addNamedSource(
         "/one.dart",
         r'''
 library one;
 import 'two.dart' as _two;
 main() {
   _two.f(0);
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_import_prefix_doesNotExist() async {
     //
     // The primary purpose of this test is to ensure that we are only getting a
     // single error generated when the only problem is that an imported file
     // does not exist.
     //
     Source source = addNamedSource(
         "/a.dart",
         r'''
 import 'missing.dart' as p;
 int a = p.q + p.r.s;
 String b = p.t(a) + p.u(v: 0);
 p.T c = new p.T();
 class D<E> extends p.T {
   D(int i) : super(i);
   p.U f = new p.V();
 }
 class F implements p.T {
   p.T m(p.U u) => null;
 }
 class G extends Object with p.V {}
 class H extends D<p.W> {
   H(int i) : super(i);
 }
 ''');
-    await assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
+    await computeAnalysisResult(source);
+    assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
     verify([source]);
   }
 
   test_import_show_doesNotExist() async {
     //
     // The primary purpose of this test is to ensure that we are only getting a
     // single error generated when the only problem is that an imported file
     // does not exist.
     //
     Source source = addNamedSource(
         "/a.dart",
         r'''
 import 'missing.dart' show q, r, t, u, T, U, V, W;
 int a = q + r.s;
 String b = t(a) + u(v: 0);
 T c = new T();
 class D<E> extends T {
   D(int i) : super(i);
   U f = new V();
 }
 class F implements T {
   T m(U u) => null;
 }
 class G extends Object with V {}
 class H extends D<W> {
   H(int i) : super(i);
 }
 ''');
-    await assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
+    await computeAnalysisResult(source);
+    assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
     verify([source]);
   }
 
   test_import_spaceInUri() async {
     addNamedSource(
         "/sub folder/lib.dart",
         r'''
 library lib;
 foo() {}''');
     Source source = addNamedSource(
         "/app.dart",
         r'''
 import 'sub folder/lib.dart';
 
 main() {
   foo();
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_indexExpression_typeParameters() async {
     Source source = addSource(r'''
 f() {
   List<int> a;
   a[0];
   List<List<int>> b;
   b[0][0];
   List<List<List<int>>> c;
   c[0][0][0];
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_indexExpression_typeParameters_invalidAssignmentWarning() async {
     Source source = addSource(r'''
 f() {
   List<List<int>> b;
   b[0][0] = 'hi';
 }''');
-    await assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+    await computeAnalysisResult(source);
+    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   test_indirectOperatorThroughCall() async {
     Source source = addSource(r'''
 class A {
   B call() { return new B(); }
 }
 
 class B {
   int operator [](int i) { return i; }
 }
 
 A f = new A();
 
 g(int x) {}
 
 main() {
   g(f()[0]);
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_invoke_dynamicThroughGetter() async {
     Source source = addSource(r'''
 class A {
   List get X => [() => 0];
   m(A a) {
     X.last;
   }
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_isValidMixin_badSuperclass() async {
     Source source = addSource(r'''
 class A extends B {}
 class B {}
 class C = Object with A;''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     ClassElement a = unit.getType('A');
     expect(a.isValidMixin, isFalse);
-    await assertErrors(
-        source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
+    await computeAnalysisResult(source);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
     verify([source]);
   }
 
   test_isValidMixin_badSuperclass_withSuperMixins() async {
     resetWithOptions(new AnalysisOptionsImpl()..enableSuperMixins = true);
     Source source = addSource(r'''
 class A extends B {}
 class B {}
 class C = Object with A;''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     ClassElement a = unit.getType('A');
     expect(a.isValidMixin, isTrue);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_isValidMixin_constructor() async {
     Source source = addSource(r'''
 class A {
   A() {}
 }
 class C = Object with A;''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     ClassElement a = unit.getType('A');
     expect(a.isValidMixin, isFalse);
-    await assertErrors(
-        source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
+    await computeAnalysisResult(source);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
 
   test_isValidMixin_constructor_withSuperMixins() async {
     resetWithOptions(new AnalysisOptionsImpl()..enableSuperMixins = true);
     Source source = addSource(r'''
 class A {
   A() {}
 }
 class C = Object with A;''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     ClassElement a = unit.getType('A');
     expect(a.isValidMixin, isFalse);
-    await assertErrors(
-        source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
+    await computeAnalysisResult(source);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
 
   test_isValidMixin_factoryConstructor() async {
     Source source = addSource(r'''
 class A {
   factory A() => null;
 }
 class C = Object with A;''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     ClassElement a = unit.getType('A');
     expect(a.isValidMixin, isTrue);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_isValidMixin_factoryConstructor_withSuperMixins() async {
     resetWithOptions(new AnalysisOptionsImpl()..enableSuperMixins = true);
     Source source = addSource(r'''
 class A {
   factory A() => null;
 }
 class C = Object with A;''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     ClassElement a = unit.getType('A');
     expect(a.isValidMixin, isTrue);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_isValidMixin_super() async {
     Source source = addSource(r'''
 class A {
   toString() {
     return super.toString();
   }
 }
 class C = Object with A;''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     ClassElement a = unit.getType('A');
     expect(a.isValidMixin, isFalse);
-    await assertErrors(source, [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER]);
+    await computeAnalysisResult(source);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER]);
     verify([source]);
   }
 
   test_isValidMixin_super_withSuperMixins() async {
     resetWithOptions(new AnalysisOptionsImpl()..enableSuperMixins = true);
     Source source = addSource(r'''
 class A {
   toString() {
     return super.toString();
   }
 }
 class C = Object with A;''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     ClassElement a = unit.getType('A');
     expect(a.isValidMixin, isTrue);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_isValidMixin_valid() async {
     Source source = addSource('''
 class A {}
 class C = Object with A;''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     ClassElement a = unit.getType('A');
     expect(a.isValidMixin, isTrue);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_isValidMixin_valid_withSuperMixins() async {
     resetWithOptions(new AnalysisOptionsImpl()..enableSuperMixins = true);
     Source source = addSource('''
 class A {}
 class C = Object with A;''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     ClassElement a = unit.getType('A');
     expect(a.isValidMixin, isTrue);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_labels_switch() async {
     Source source = addSource(r'''
 void doSwitch(int target) {
   switch (target) {
     l0: case 0:
       continue l1;
     l1: case 1:
       continue l0;
     default:
       continue l1;
   }
 }''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_localVariable_types_invoked() async {
     Source source = addSource(r'''
 const A = null;
 main() {
   var myVar = (int p) => 'foo';
   myVar(42);
 }''');
@@ skipping 18 matching lines @@
 const A = null;
 @A class C<A> {}''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unitElement = library.definingCompilationUnit;
     expect(unitElement, isNotNull);
     List<ClassElement> classes = unitElement.types;
     expect(classes, hasLength(1));
     List<ElementAnnotation> annotations = classes[0].metadata;
     expect(annotations, hasLength(1));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(2));
     Element expectedElement = (declarations[0] as TopLevelVariableDeclaration)
         .variables
         .variables[0]
         .name
         .staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement,
@@ skipping 12 matching lines @@
 }''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     expect(classes, hasLength(1));
     FieldElement field = classes[0].fields[0];
     List<ElementAnnotation> annotations = field.metadata;
     expect(annotations, hasLength(1));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_metadata_fieldFormalParameter() async {
     Source source = addSource(r'''
 const A = null;
 class C {
   int f;
   C(@A this.f);
 }''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     expect(classes, hasLength(1));
     List<ConstructorElement> constructors = classes[0].constructors;
     expect(constructors, hasLength(1));
     List<ParameterElement> parameters = constructors[0].parameters;
     expect(parameters, hasLength(1));
     List<ElementAnnotation> annotations = parameters[0].metadata;
     expect(annotations, hasLength(1));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_metadata_function() async {
     Source source = addSource(r'''
 const A = null;
 @A f() {}''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
     expect(functions, hasLength(1));
     List<ElementAnnotation> annotations = functions[0].metadata;
     expect(annotations, hasLength(1));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_metadata_functionTypedParameter() async {
     Source source = addSource(r'''
 const A = null;
 f(@A int p(int x)) {}''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
     expect(functions, hasLength(1));
     List<ParameterElement> parameters = functions[0].parameters;
     expect(parameters, hasLength(1));
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     expect(annotations1, hasLength(1));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_metadata_libraryDirective() async {
     Source source = addSource(r'''
 @A library lib;
 const A = null;''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     List<ElementAnnotation> annotations = library.metadata;
     expect(annotations, hasLength(1));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_metadata_method() async {
     Source source = addSource(r'''
 const A = null;
 class C {
   @A void m() {}
 }''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     expect(classes, hasLength(1));
     MethodElement method = classes[0].methods[0];
     List<ElementAnnotation> annotations = method.metadata;
     expect(annotations, hasLength(1));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_metadata_namedParameter() async {
     Source source = addSource(r'''
 const A = null;
 f({@A int p : 0}) {}''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
     expect(functions, hasLength(1));
     List<ParameterElement> parameters = functions[0].parameters;
     expect(parameters, hasLength(1));
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     expect(annotations1, hasLength(1));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_metadata_positionalParameter() async {
     Source source = addSource(r'''
 const A = null;
 f([@A int p = 0]) {}''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
     expect(functions, hasLength(1));
     List<ParameterElement> parameters = functions[0].parameters;
     expect(parameters, hasLength(1));
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     expect(annotations1, hasLength(1));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_metadata_simpleParameter() async {
     Source source = addSource(r'''
 const A = null;
 f(@A p1, @A int p2) {}''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
     expect(functions, hasLength(1));
     List<ParameterElement> parameters = functions[0].parameters;
     expect(parameters, hasLength(2));
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     expect(annotations1, hasLength(1));
     List<ElementAnnotation> annotations2 = parameters[1].metadata;
     expect(annotations2, hasLength(1));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_metadata_typedef() async {
     Source source = addSource(r'''
 const A = null;
 @A typedef F<A>();''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unitElement = library.definingCompilationUnit;
     expect(unitElement, isNotNull);
     List<FunctionTypeAliasElement> aliases = unitElement.functionTypeAliases;
     expect(aliases, hasLength(1));
     List<ElementAnnotation> annotations = aliases[0].metadata;
     expect(annotations, hasLength(1));
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(2));
     Element expectedElement = (declarations[0] as TopLevelVariableDeclaration)
         .variables
         .variables[0]
         .name
         .staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement,
@@ skipping 10 matching lines @@
   bar() => 1;
 }
 class A {
   foo() => 2;
 }
 
 class C extends B with A {
   bar() => super.bar();
   foo() => super.foo();
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_method_fromMixins() async {
     Source source = addSource('''
 class B {}
 class M1 {
   void f() {}
 }
 class M2 {
   void f() {}
 }
 class C extends B with M1, M2 {}
 void main() {
   new C().f();
 }
 ''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
     // Verify that the "f" in "new C().f()" refers to the "f" defined in M2.
     FunctionDeclaration main =
         library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     MethodInvocation expr = stmt.expression;
     expect(
         resolutionMap
             .staticElementForIdentifier(expr.methodName)
@@ skipping 11 matching lines @@
 class M2 {
   void f() {}
 }
 class C extends B with M1, M2 {
   void g() {
     f();
   }
 }
 ''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
     // Verify that the call to f() in C.g() refers to the method defined in M2.
     ClassElement classC = library.definingCompilationUnit.types[3];
     MethodDeclaration g = classC.getMethod('g').computeNode();
     BlockFunctionBody body = g.body;
     ExpressionStatement stmt = body.block.statements[0];
     MethodInvocation invocation = stmt.expression;
     SimpleIdentifier methodName = invocation.methodName;
     expect(
         resolutionMap
@@ skipping 11 matching lines @@
 }
 class M2 {
   void f() {}
 }
 class C extends B with M1, M2 {}
 void main() {
   new C().f();
 }
 ''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
     // Verify that the call to f() in "new C().f()" refers to the method
     // defined in M2.
     FunctionDeclaration main =
         library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     MethodInvocation invocation = stmt.expression;
     expect(
         resolutionMap
             .staticElementForIdentifier(invocation.methodName)
             .enclosingElement
             .name,
         'M2');
   }
 
   test_method_fromSuperclassMixin() async {
     Source source = addSource(r'''
 class A {
   void m1() {}
 }
 class B extends Object with A {
 }
 class C extends B {
 }
 f(C c) {
   c.m1();
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_methodCascades() async {
     Source source = addSource(r'''
 class A {
   void m1() {}
   void m2() {}
   void m() {
     A a = new A();
     a..m1()
      ..m2();
   }
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_methodCascades_withSetter() async {
     Source source = addSource(r'''
 class A {
   String name;
   void m1() {}
   void m2() {}
   void m() {
     A a = new A();
     a..m1()
      ..name = 'name'
      ..m2();
   }
 }''');
     // failing with error code: INVOCATION_OF_NON_FUNCTION
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_resolveAgainstNull() async {
     Source source = addSource(r'''
 f(var p) {
   return null == p;
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
   }
 
   test_setter_fromMixins_bare_identifier() async {
     Source source = addSource('''
 class B {}
 class M1 {
   set x(value) {}
 }
 class M2 {
   set x(value) {}
 }
 class C extends B with M1, M2 {
   void f() {
     x = 1;
   }
 }
 ''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
     // Verify that the setter for "x" in C.f() refers to the setter defined in
     // M2.
     ClassElement classC = library.definingCompilationUnit.types[3];
     MethodDeclaration f = classC.getMethod('f').computeNode();
     BlockFunctionBody body = f.body;
     ExpressionStatement stmt = body.block.statements[0];
     AssignmentExpression assignment = stmt.expression;
     SimpleIdentifier leftHandSide = assignment.leftHandSide;
     expect(
@@ skipping 12 matching lines @@
 }
 class M2 {
   set x(value) {}
 }
 class C extends B with M1, M2 {}
 void main() {
   new C().x = 1;
 }
 ''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
     // Verify that the setter for "x" in "new C().x" refers to the setter
     // defined in M2.
     FunctionDeclaration main =
         library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     AssignmentExpression assignment = stmt.expression;
     PropertyAccess propertyAccess = assignment.leftHandSide;
     expect(
         resolutionMap
             .staticElementForIdentifier(propertyAccess.propertyName)
             .enclosingElement
             .name,
         'M2');
   }
 
   test_setter_inherited() async {
     Source source = addSource(r'''
 class A {
   int get x => 0;
   set x(int p) {}
 }
 class B extends A {
   int get x => super.x == null ? 0 : super.x;
   int f() => x = 1;
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_setter_static() async {
     Source source = addSource(r'''
 set s(x) {
 }
 
 main() {
   s = 123;
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   @failingTest
   test_staticInvocation() async {
     Source source = addSource(r'''
 class A {
   static int get g => (a,b) => 0;
 }
 class B {
   f() {
     A.g(1,0);
   }
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   /**
    * Resolve the given source and verify that the arguments in a specific method invocation were
    * correctly resolved.
    *
    * The source is expected to be source for a compilation unit, the first declaration is expected
    * to be a class, the first member of which is expected to be a method with a block body, and the
    * first statement in the body is expected to be an expression statement whose expression is a
@@ skipping 64 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }