Explicitly compute analysis results for sources to check errors.

pkg/analyzer/test/generated/resolver_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.
 
 library analyzer.test.generated.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
@@ skipping 154 matching lines @@
 class A {
   void m(int i) {
     switch (i) {
       l: case 0:
         break;
       case 1:
         break l;
     }
   }
 }''');
+    await computeAnalysisResult(source);
     await assertErrors(
         source, [ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER]);
     verify([source]);
   }
 
   test_continueLabelOnSwitch() async {
     Source source = addSource(r'''
 class A {
   void m(int i) {
     l: switch (i) {
       case 0:
         continue l;
     }
   }
 }''');
-    await assertErrors(source, [ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH]);
+    await computeAnalysisResult(source); await assertErrors(source, [ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH]);

[Brian Wilkerson, 2017/01/10 20:53:34]

Perhaps format file this so that the two statements are on different lines?

     verify([source]);
   }
 
   test_enclosingElement_invalidLocalFunction() async {
     Source source = addSource(r'''
 class C {
   C() {
     int get x => 0;
   }
 }''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     var unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     var types = unit.types;
     expect(types, isNotNull);
     expect(types, hasLength(1));
     var type = types[0];
     expect(type, isNotNull);
     var constructors = type.constructors;
     expect(constructors, isNotNull);
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     List<FunctionElement> functions = constructor.functions;
     expect(functions, isNotNull);
     expect(functions, hasLength(1));
     expect(functions[0].enclosingElement, constructor);
-    await assertErrors(source, [ParserErrorCode.GETTER_IN_FUNCTION]);
+    await computeAnalysisResult(source); await assertErrors(source, [ParserErrorCode.GETTER_IN_FUNCTION]);
   }
 }
 
 /**
  * Tests for generic method and function resolution that do not use strong mode.
  */
 @reflectiveTest
 class GenericMethodResolverTest extends StaticTypeAnalyzer2TestShared {
   test_genericMethod_propagatedType_promotion() async {
     // Regression test for:
@@ skipping 385 matching lines @@
 @reflectiveTest
 class StrictModeTest extends ResolverTestCase {
   fail_for() async {
     Source source = addSource(r'''
 int f(List<int> list) {
   num sum = 0;
   for (num i = 0; i < list.length; i++) {
     sum += list[i];
   }
 }''');
-    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await computeAnalysisResult(source); await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   @override
   void setUp() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.hint = false;
     resetWithOptions(options);
   }
 
   test_assert_is() async {
     Source source = addSource(r'''
 int f(num n) {
   assert (n is int);
   return n & 0x0F;
 }''');
-    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await computeAnalysisResult(source); await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   test_conditional_and_is() async {
     Source source = addSource(r'''
 int f(num n) {
   return (n is int && n > 0) ? n & 0x0F : 0;
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
   }
 
   test_conditional_is() async {
     Source source = addSource(r'''
 int f(num n) {
   return (n is int) ? n & 0x0F : 0;
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
   }
 
   test_conditional_isNot() async {
     Source source = addSource(r'''
 int f(num n) {
   return (n is! int) ? 0 : n & 0x0F;
 }''');
-    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await computeAnalysisResult(source); await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   test_conditional_or_is() async {
     Source source = addSource(r'''
 int f(num n) {
   return (n is! int || n < 0) ? 0 : n & 0x0F;
 }''');
-    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await computeAnalysisResult(source); await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   test_forEach() async {
     Source source = addSource(r'''
 int f(List<int> list) {
   num sum = 0;
   for (num n in list) {
     sum += n & 0x0F;
   }
 }''');
-    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await computeAnalysisResult(source); await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   test_if_and_is() async {
     Source source = addSource(r'''
 int f(num n) {
   if (n is int && n > 0) {
     return n & 0x0F;
   }
   return 0;
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
   }
 
   test_if_is() async {
     Source source = addSource(r'''
 int f(num n) {
   if (n is int) {
     return n & 0x0F;
   }
   return 0;
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
   }
 
   test_if_isNot() async {
     Source source = addSource(r'''
 int f(num n) {
   if (n is! int) {
     return 0;
   } else {
     return n & 0x0F;
   }
 }''');
-    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await computeAnalysisResult(source); await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   test_if_isNot_abrupt() async {
     Source source = addSource(r'''
 int f(num n) {
   if (n is! int) {
     return 0;
   }
   return n & 0x0F;
 }''');
-    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await computeAnalysisResult(source); await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   test_if_or_is() async {
     Source source = addSource(r'''
 int f(num n) {
   if (n is! int || n < 0) {
     return 0;
   } else {
     return n & 0x0F;
   }
 }''');
-    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await computeAnalysisResult(source); await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   test_localVar() async {
     Source source = addSource(r'''
 int f() {
   num n = 1234;
   return n & 0x0F;
 }''');
-    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await computeAnalysisResult(source); await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 }
 
 @reflectiveTest
 class SubtypeManagerTest {
   /**
    * The inheritance manager being tested.
    */
   SubtypeManager _subtypeManager;
 
@@ skipping 309 matching lines @@
   bool get g => true;
 }
 A f(var p) {
   if ((p as A).g) {
     return p;
   } else {
     return null;
   }
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_assert() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   assert (p is A);
   return p;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_assignment() async {
     Source source = addSource(r'''
 f() {
   var v;
   v = 0;
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeProvider.intType));
   }
 
   test_assignment_afterInitializer() async {
     Source source = addSource(r'''
 f() {
   var v = 0;
   v = 1.0;
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeProvider.doubleType));
   }
 
   test_assignment_null() async {
     String code = r'''
 main() {
   int v; // declare
   v = null;
   return v; // return
 }''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
       LibraryElement library = resolve2(source);
-      await assertNoErrors(source);
+      await computeAnalysisResult(source); await assertNoErrors(source);
       verify([source]);
       unit = resolveCompilationUnit(source, library);
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "v; // declare", (node) => node is SimpleIdentifier);
       expect(identifier.staticType, same(typeProvider.intType));
       expect(identifier.propagatedType, same(null));
     }
     {
@@ skipping 11 matching lines @@
   }
 
   test_CanvasElement_getContext() async {
     String code = r'''
 import 'dart:html';
 main(CanvasElement canvas) {
   var context = canvas.getContext('2d');
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     SimpleIdentifier identifier = EngineTestCase.findNode(
         unit, code, "context", (node) => node is SimpleIdentifier);
     expect(resolutionMap.propagatedTypeForExpression(identifier).name,
         "CanvasRenderingContext2D");
   }
 
   test_forEach() async {
     String code = r'''
 main() {
   var list = <String> [];
   for (var e in list) {
     e;
   }
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     InterfaceType stringType = typeProvider.stringType;
     // in the declaration
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e in", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, same(stringType));
     }
     // in the loop body
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e;", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, same(stringType));
     }
   }
 
   test_forEach_async() async {
     String code = r'''
 import 'dart:async';
 f(Stream<String> stream) async {
   await for (var e in stream) {
     e;
   }
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     InterfaceType stringType = typeProvider.stringType;
     // in the declaration
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e in", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, same(stringType));
     }
     // in the loop body
@@ skipping 11 matching lines @@
     String code = r'''
 import 'dart:async';
 abstract class MyCustomStream<T> implements Stream<List<T>> {}
 f(MyCustomStream<String> stream) async {
   await for (var e in stream) {
     e;
   }
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     InterfaceType listOfStringType =
         typeProvider.listType.instantiate([typeProvider.stringType]);
     // in the declaration
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e in", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, equals(listOfStringType));
     }
@@ skipping 11 matching lines @@
   forEach(f(K key, V value)) {}
 }
 f(MyMap<int, String> m) {
   m.forEach((k, v) {
     k;
     v;
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // k
     DartType intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(
         unit, code, "k, ", (node) => node is SimpleFormalParameter);
     expect(kParameter.identifier.propagatedType, same(intType));
     SimpleIdentifier kIdentifier = EngineTestCase.findNode(
         unit, code, "k;", (node) => node is SimpleIdentifier);
     expect(kIdentifier.propagatedType, same(intType));
@@ skipping 13 matching lines @@
     String code = r'''
 class MyMap<K, V> {
   forEach(f(K key, V value)) {}
 }
 f(MyMap<int, String> m) {
   var m2 = m;
   m2.forEach((k, v) {});
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // k
     DartType intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(
         unit, code, "k, ", (node) => node is SimpleFormalParameter);
     expect(kParameter.identifier.propagatedType, same(intType));
     // v
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(
         unit, code, "v)", (node) => node is SimpleFormalParameter);
     expect(vParameter.identifier.propagatedType, same(stringType));
   }
 
   test_functionExpression_asInvocationArgument_functionExpressionInvocation() async {
     String code = r'''
 main() {
   (f(String value)) {} ((v) {
     v;
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // v
     DartType dynamicType = typeProvider.dynamicType;
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(
         unit, code, "v)", (node) => node is FormalParameter);
     expect(vParameter.identifier.propagatedType, same(stringType));
     expect(vParameter.identifier.staticType, same(dynamicType));
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(
         unit, code, "v;", (node) => node is SimpleIdentifier);
     expect(vIdentifier.propagatedType, same(stringType));
     expect(vIdentifier.staticType, same(dynamicType));
   }
 
   test_functionExpression_asInvocationArgument_keepIfLessSpecific() async {
     String code = r'''
 class MyList {
   forEach(f(Object value)) {}
 }
 f(MyList list) {
   list.forEach((int v) {
     v;
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // v
     DartType intType = typeProvider.intType;
     FormalParameter vParameter = EngineTestCase.findNode(
         unit, code, "v)", (node) => node is SimpleFormalParameter);
     expect(vParameter.identifier.propagatedType, same(null));
     expect(vParameter.identifier.staticType, same(intType));
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(
         unit, code, "v;", (node) => node is SimpleIdentifier);
     expect(vIdentifier.staticType, same(intType));
     expect(vIdentifier.propagatedType, same(null));
   }
 
   test_functionExpression_asInvocationArgument_notSubtypeOfStaticType() async {
     String code = r'''
 class A {
   m(void f(int i)) {}
 }
 x() {
   A a = new A();
   a.m(() => 0);
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
+    await computeAnalysisResult(source);
     await assertErrors(
         source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // () => 0
     FunctionExpression functionExpression = EngineTestCase.findNode(
         unit, code, "() => 0)", (node) => node is FunctionExpression);
     expect((functionExpression.staticType as FunctionType).parameters.length,
         same(0));
     expect(functionExpression.propagatedType, same(null));
   }
 
   test_functionExpression_asInvocationArgument_replaceIfMoreSpecific() async {
     String code = r'''
 class MyList<E> {
   forEach(f(E value)) {}
 }
 f(MyList<String> list) {
   list.forEach((Object v) {
     v;
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // v
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(
         unit, code, "v)", (node) => node is SimpleFormalParameter);
     expect(vParameter.identifier.propagatedType, same(stringType));
     expect(vParameter.identifier.staticType, same(typeProvider.objectType));
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(
         unit, code, "v;", (node) => node is SimpleIdentifier);
     expect(vIdentifier.propagatedType, same(stringType));
   }
 
   test_Future_then() async {
     String code = r'''
 import 'dart:async';
 main(Future<int> firstFuture) {
   firstFuture.then((p1) {
     return 1.0;
   }).then((p2) {
     return new Future<String>.value('str');
   }).then((p3) {
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // p1
     FormalParameter p1 = EngineTestCase.findNode(
         unit, code, "p1) {", (node) => node is SimpleFormalParameter);
     expect(p1.identifier.propagatedType, same(typeProvider.intType));
     // p2
     FormalParameter p2 = EngineTestCase.findNode(
         unit, code, "p2) {", (node) => node is SimpleFormalParameter);
     expect(p2.identifier.propagatedType, same(typeProvider.doubleType));
     // p3
     FormalParameter p3 = EngineTestCase.findNode(
         unit, code, "p3) {", (node) => node is SimpleFormalParameter);
     expect(p3.identifier.propagatedType, same(typeProvider.stringType));
   }
 
   test_initializer() async {
     Source source = addSource(r'''
 f() {
   var v = 0;
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     NodeList<Statement> statements = body.block.statements;
     // Type of 'v' in declaration.
     {
       VariableDeclarationStatement statement =
           statements[0] as VariableDeclarationStatement;
@@ skipping 27 matching lines @@
     expect(variableName.propagatedType, same(typeProvider.stringType));
   }
 
   test_initializer_hasStaticType() async {
     Source source = addSource(r'''
 f() {
   int v = 0;
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     NodeList<Statement> statements = body.block.statements;
     // Type of 'v' in declaration.
     {
       VariableDeclarationStatement statement =
           statements[0] as VariableDeclarationStatement;
@@ skipping 10 matching lines @@
     }
   }
 
   test_initializer_hasStaticType_parameterized() async {
     Source source = addSource(r'''
 f() {
   List<int> v = <int>[];
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     NodeList<Statement> statements = body.block.statements;
     // Type of 'v' in declaration.
     {
       VariableDeclarationStatement statement =
           statements[0] as VariableDeclarationStatement;
@@ skipping 13 matching lines @@
   test_initializer_null() async {
     String code = r'''
 main() {
   int v = null;
   return v; // marker
 }''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
       LibraryElement library = resolve2(source);
-      await assertNoErrors(source);
+      await computeAnalysisResult(source); await assertNoErrors(source);
       verify([source]);
       unit = resolveCompilationUnit(source, library);
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "v = null;", (node) => node is SimpleIdentifier);
       expect(identifier.staticType, same(typeProvider.intType));
       expect(identifier.propagatedType, same(null));
     }
     {
@@ skipping 23 matching lines @@
     expect(methodInvoke.methodName.propagatedElement, isNull);
   }
 
   test_is_conditional() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is A) ? p : null;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional =
         statement.expression as ConditionalExpression;
     SimpleIdentifier variableName =
         conditional.thenExpression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_is_if() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A) {
     return p;
   } else {
     return null;
   }
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // prepare A
     InterfaceType typeA;
     {
       ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
       typeA = resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     }
     // verify "f"
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
@@ skipping 19 matching lines @@
     Source source = addSource(r'''
 class A {}
 A f(A p) {
   if (p is String) {
     return p;
   } else {
     return null;
   }
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
 //    ClassDeclaration classA = (ClassDeclaration) unit.getDeclarations().get(0);
 //    InterfaceType typeA = classA.getElement().getType();
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(null));
   }
 
   test_is_if_logicalAnd() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A && p != null) {
     return p;
   } else {
     return null;
   }
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_is_postConditional() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   A a = (p is A) ? p : throw null;
   return p;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_is_postIf() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A) {
     A a = p;
   } else {
     return null;
   }
   return p;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_is_subclass() async {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   B m() => this;
 }
 A f(A p) {
   if (p is B) {
     return p.m();
   }
   return p;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[2] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
     expect(invocation.methodName.staticElement, isNotNull);
     expect(invocation.methodName.propagatedElement, isNull);
   }
 
   test_is_while() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   while (p is A) {
     return p;
   }
   return p;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     WhileStatement whileStatement = body.block.statements[0] as WhileStatement;
     ReturnStatement statement =
         (whileStatement.body as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_isNot_conditional() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is! A) ? null : p;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional =
         statement.expression as ConditionalExpression;
     SimpleIdentifier variableName =
         conditional.elseExpression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_isNot_if() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A) {
     return null;
   } else {
     return p;
   }
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_isNot_if_logicalOr() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A || null == p) {
     return null;
   } else {
     return p;
   }
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_isNot_postConditional() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   A a = (p is! A) ? throw null : p;
   return p;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_isNot_postIf() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A) {
     return null;
   }
   return p;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
@@ skipping 54 matching lines @@
     await assertTypeOfMarkedExpression(code, null, tB);
   }
 
   test_listLiteral_different() async {
     Source source = addSource(r'''
 f() {
   var v = [0, '1', 2];
   return v[2];
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
     expect(indexExpression.propagatedType, isNull);
   }
 
   test_listLiteral_same() async {
     Source source = addSource(r'''
 f() {
   var v = [0, 1, 2];
   return v[2];
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
     expect(indexExpression.propagatedType, isNull);
     Expression v = indexExpression.target;
     InterfaceType propagatedType = v.propagatedType as InterfaceType;
     expect(propagatedType.element, same(typeProvider.listType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
     expect(typeArguments, hasLength(1));
     expect(typeArguments[0], same(typeProvider.dynamicType));
   }
 
   test_mapLiteral_different() async {
     Source source = addSource(r'''
 f() {
   var v = {'0' : 0, 1 : '1', '2' : 2};
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
     expect(propagatedType.element, same(typeProvider.mapType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
     expect(typeArguments, hasLength(2));
     expect(typeArguments[0], same(typeProvider.dynamicType));
     expect(typeArguments[1], same(typeProvider.dynamicType));
   }
 
   test_mapLiteral_same() async {
     Source source = addSource(r'''
 f() {
   var v = {'a' : 0, 'b' : 1, 'c' : 2};
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
     expect(propagatedType.element, same(typeProvider.mapType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
@@ skipping 105 matching lines @@
   }
 }
 
 void g() {
   Base x = null;
   if (x is Derived) {
     print(x.y); // GOOD
   }
   x = null;
 }''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
   }
 
   test_objectAccessInference_disabled_for_library_prefix() async {
     String name = 'hashCode';
     addNamedSource(
         '/helper.dart',
         '''
 library helper;
 dynamic get $name => 42;
 ''');
@@ skipping 163 matching lines @@
   var v7 = query('select#id');
   // invocation of method
   var m1 = document.query('div');
  // unsupported currently
   var b1 = query('noSuchTag');
   var b2 = query('DART_EDITOR_NO_SUCH_TYPE');
   var b3 = query('body div');
   return [v1, v2, v3, v4, v5, v6, v7, m1, b1, b2, b3];
 }''');
     LibraryElement library = resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source); await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration main = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = main.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[11] as ReturnStatement;
     NodeList<Expression> elements =
         (statement.expression as ListLiteral).elements;
     expect(resolutionMap.propagatedTypeForExpression(elements[0]).name,
         "AnchorElement");
     expect(resolutionMap.propagatedTypeForExpression(elements[1]).name,
@@ skipping 1223 matching lines @@
  */
 class _StaleElement extends ElementImpl {
   _StaleElement() : super("_StaleElement", -1);
 
   @override
   get kind => throw "_StaleElement's kind shouldn't be accessed";
 
   @override
   /*=T*/ accept/*<T>*/(_) => throw "_StaleElement shouldn't be visited";
 }