Explicitly compute library errors in tests.

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 engine.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/context.dart' as newContext;
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 577 matching lines @@
   const A();
 }
 class B extends A {
   const B();
 }
 class C {
   final A a;
   const C(this.a);
 }
 var v = const C(const B());''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_fieldType_unresolved_null() {
     // Null always passes runtime type checks, even when the type is
     // unresolved.
     Source source = addSource(r'''
 class A {
   final Unresolved x;
   const A(String this.x);
 }
 var v = const A(null);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_implements() {
     // According to checked-mode type checking rules, a value of type B is
     // assignable to a field of type A, because B implements A (and hence is a
     // subtype of A).
     Source source = addSource(r'''
 class A {}
 class B implements A {
   const B();
 }
 class C {
   final A a;
   const C(this.a);
 }
 var v = const C(const B());''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_list_dynamic() {
     // [1, 2, 3] has type List<dynamic>, which is a subtype of List<int>.
     Source source = addSource(r'''
 class A {
   const A(List<int> x);
 }
 var x = const A(const [1, 2, 3]);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_list_nonDynamic() {
     // <int>[1, 2, 3] has type List<int>, which is a subtype of List<num>.
     Source source = addSource(r'''
 class A {
   const A(List<num> x);
 }
 var x = const A(const <int>[1, 2, 3]);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_map_dynamic() {
     // {1: 2} has type Map<dynamic, dynamic>, which is a subtype of
     // Map<int, int>.
     Source source = addSource(r'''
 class A {
   const A(Map<int, int> x);
 }
 var x = const A(const {1: 2});''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_map_keyDifferent() {
     // <int, int>{1: 2} has type Map<int, int>, which is a subtype of
     // Map<num, int>.
     Source source = addSource(r'''
 class A {
   const A(Map<num, int> x);
 }
 var x = const A(const <int, int>{1: 2});''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_map_valueDifferent() {
     // <int, int>{1: 2} has type Map<int, int>, which is a subtype of
     // Map<int, num>.
     Source source = addSource(r'''
 class A {
   const A(Map<int, num> x);
 }
 var x = const A(const <int, int>{1: 2});''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_notype() {
     // If a field is declared without a type, then any value may be assigned to
     // it.
     Source source = addSource(r'''
 class A {
   final x;
   const A(this.x);
 }
 var v = const A(5);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_null() {
     // Null is assignable to anything.
     Source source = addSource(r'''
 class A {
   final int x;
   const A(this.x);
 }
 var v = const A(null);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_typedef() {
     // foo has the runtime type dynamic -> dynamic, so it should be assignable
     // to A.f.
     Source source = addSource(r'''
 typedef String Int2String(int x);
 class A {
   final Int2String f;
   const A(this.f);
 }
 foo(x) => 1;
 var v = const A(foo);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_typeSubstitution() {
     // foo has the runtime type dynamic -> dynamic, so it should be assignable
     // to A.f.
     Source source = addSource(r'''
 class A<T> {
   final T x;
   const A(this.x);
 }
 var v = const A<int>(3);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField() {
     Source source = addSource(r'''
 class A {
   final int x;
   const A(this.x);
 }
 var v = const A('foo');''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
       StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE
     ]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_extends() {
     // According to checked-mode type checking rules, a value of type A is not
     // assignable to a field of type B, because B extends A (the subtyping
     // relationship is in the wrong direction).
     Source source = addSource(r'''
 class A {
   const A();
 }
 class B extends A {
   const B();
 }
 class C {
   final B b;
   const C(this.b);
 }
 var v = const C(const A());''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH
     ]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_fieldType() {
     Source source = addSource(r'''
 class A {
   final int x;
   const A(String this.x);
 }
 var v = const A('foo');''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
       StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE
     ]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_fieldType_unresolved() {
     Source source = addSource(r'''
 class A {
   final Unresolved x;
   const A(String this.x);
 }
 var v = const A('foo');''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
       StaticWarningCode.UNDEFINED_CLASS
     ]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_implements() {
     // According to checked-mode type checking rules, a value of type A is not
     // assignable to a field of type B, because B implements A (the subtyping
     // relationship is in the wrong direction).
     Source source = addSource(r'''
 class A {
   const A();
 }
 class B implements A {}
 class C {
   final B b;
   const C(this.b);
 }
 var v = const C(const A());''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH
     ]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_list() {
     // <num>[1, 2, 3] has type List<num>, which is not a subtype of List<int>.
     Source source = addSource(r'''
 class A {
   const A(List<int> x);
 }
 var x = const A(const <num>[1, 2, 3]);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH
     ]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_map_keyMismatch() {
     // <num, int>{1: 2} has type Map<num, int>, which is not a subtype of
     // Map<int, int>.
     Source source = addSource(r'''
 class A {
   const A(Map<int, int> x);
 }
 var x = const A(const <num, int>{1: 2});''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH
     ]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_map_valueMismatch() {
     // <int, num>{1: 2} has type Map<int, num>, which is not a subtype of
     // Map<int, int>.
     Source source = addSource(r'''
 class A {
   const A(Map<int, int> x);
 }
 var x = const A(const <int, num>{1: 2});''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH
     ]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_optional() {
     Source source = addSource(r'''
 class A {
   final int x;
   const A([this.x = 'foo']);
 }
 var v = const A();''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
       StaticTypeWarningCode.INVALID_ASSIGNMENT
     ]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_typedef() {
     // foo has the runtime type String -> int, so it should not be assignable
     // to A.f (A.f requires it to be int -> String).
     Source source = addSource(r'''
 typedef String Int2String(int x);
 class A {
   final Int2String f;
   const A(this.f);
 }
 int foo(String x) => 1;
 var v = const A(foo);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
       StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE
     ]);
     verify([source]);
   }
 
   void test_fieldInitializerNotAssignable() {
     Source source = addSource(r'''
 class A {
   final int x;
   const A() : x = '';
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE,
       StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE
     ]);
     verify([source]);
   }
 
   void test_fieldTypeMismatch() {
     Source source = addSource(r'''
 class A {
   const A(x) : y = x;
   final int y;
 }
 var v = const A('foo');''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH
     ]);
     verify([source]);
   }
 
   void test_fieldTypeMismatch_generic() {
     Source source = addSource(r'''
 class C<T> {
   final T x = y;
   const C();
 }
 const y = 1;
 var v = const C<String>();
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
       HintCode.INVALID_ASSIGNMENT
     ]);
     verify([source]);
   }
 
   void test_fieldTypeMismatch_unresolved() {
     Source source = addSource(r'''
 class A {
   const A(x) : y = x;
   final Unresolved y;
 }
 var v = const A('foo');''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
       StaticWarningCode.UNDEFINED_CLASS
     ]);
     verify([source]);
   }
 
   void test_fieldTypeOk_generic() {
     Source source = addSource(r'''
 class C<T> {
   final T x = y;
   const C();
 }
 const y = 1;
 var v = const C<int>();
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_fieldTypeOk_null() {
     Source source = addSource(r'''
 class A {
   const A(x) : y = x;
   final int y;
 }
 var v = const A(null);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldTypeOk_unresolved_null() {
     // Null always passes runtime type checks, even when the type is
     // unresolved.
     Source source = addSource(r'''
 class A {
   const A(x) : y = x;
   final Unresolved y;
 }
 var v = const A(null);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 
   void test_listElementTypeNotAssignable() {
     Source source = addSource("var v = const <String> [42];");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE,
       StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE
     ]);
     verify([source]);
   }
 
   void test_mapKeyTypeNotAssignable() {
     Source source = addSource("var v = const <String, int > {1 : 2};");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE,
       StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE
     ]);
     verify([source]);
   }
 
   void test_mapValueTypeNotAssignable() {
     Source source = addSource("var v = const <String, String> {'a' : 2};");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE,
       StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE
     ]);
     verify([source]);
   }
 
   void test_parameterAssignable_null() {
     // Null is assignable to anything.
     Source source = addSource(r'''
 class A {
   const A(int x);
 }
 var v = const A(null);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_parameterAssignable_typeSubstitution() {
     Source source = addSource(r'''
 class A<T> {
   const A(T x);
 }
 var v = const A<int>(3);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_parameterAssignable_undefined_null() {
     // Null always passes runtime type checks, even when the type is
     // unresolved.
     Source source = addSource(r'''
 class A {
   const A(Unresolved x);
 }
 var v = const A(null);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 
   void test_parameterNotAssignable() {
     Source source = addSource(r'''
 class A {
   const A(int x);
 }
 var v = const A('foo');''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
       StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE
     ]);
     verify([source]);
   }
 
   void test_parameterNotAssignable_typeSubstitution() {
     Source source = addSource(r'''
 class A<T> {
   const A(T x);
 }
 var v = const A<int>('foo');''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
       StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE
     ]);
     verify([source]);
   }
 
   void test_parameterNotAssignable_undefined() {
     Source source = addSource(r'''
 class A {
   const A(Unresolved x);
 }
 var v = const A('foo');''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
       StaticWarningCode.UNDEFINED_CLASS
     ]);
     verify([source]);
   }
 
   void test_redirectingConstructor_paramTypeMismatch() {
     Source source = addSource(r'''
 class A {
   const A.a1(x) : this.a2(x);
   const A.a2(String x);
 }
 var v = const A.a1(0);''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH
     ]);
     verify([source]);
   }
 
   void test_topLevelVarAssignable_null() {
     Source source = addSource("const int x = null;");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_topLevelVarAssignable_undefined_null() {
     // Null always passes runtime type checks, even when the type is
     // unresolved.
     Source source = addSource("const Unresolved x = null;");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 
   void test_topLevelVarNotAssignable() {
     Source source = addSource("const int x = 'foo';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
       StaticTypeWarningCode.INVALID_ASSIGNMENT
     ]);
     verify([source]);
   }
 
   void test_topLevelVarNotAssignable_undefined() {
     Source source = addSource("const Unresolved x = 'foo';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
       StaticWarningCode.UNDEFINED_CLASS
     ]);
     verify([source]);
   }
 }
 
 @reflectiveTest
 class ElementResolverTest extends EngineTestCase {
@@ skipping 940 matching lines @@
 class A {
   void m(int i) {
     switch (i) {
       l: case 0:
         break;
       case 1:
         break l;
     }
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER]);
     verify([source]);
   }
 
   void test_continueLabelOnSwitch() {
     Source source = addSource(r'''
 class A {
   void m(int i) {
     l: switch (i) {
       case 0:
         continue l;
     }
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH]);
     verify([source]);
   }
 
   void test_enclosingElement_invalidLocalFunction() {
     Source source = addSource(r'''
 class C {
   C() {
     int get x => 0;
   }
 }''');
-    LibraryElement library = resolve(source);
+    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);
@@ skipping 13 matching lines @@
   void fail_deadCode_statementAfterRehrow() {
     Source source = addSource(r'''
 f() {
   try {
     var one = 1;
   } catch (e) {
     rethrow;
     var two = 2;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void fail_deadCode_statementAfterThrow() {
     Source source = addSource(r'''
 f() {
   var one = 1;
   throw 'Stop here';
   var two = 2;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void fail_isInt() {
     Source source = addSource("var v = 1 is int;");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.IS_INT]);
     verify([source]);
   }
 
   void fail_isNotInt() {
     Source source = addSource("var v = 1 is! int;");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.IS_NOT_INT]);
     verify([source]);
   }
 
   void fail_overrideEqualsButNotHashCode() {
     Source source = addSource(r'''
 class A {
   bool operator ==(x) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE]);
     verify([source]);
   }
 
   void fail_unusedImport_as_equalPrefixes() {
     // See todo at ImportsVerifier.prefixElementMap.
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' as one;
 import 'lib2.dart' as one;
 one.A a;''');
     Source source2 = addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}''');
     Source source3 = addNamedSource("/lib2.dart", r'''
 library lib2;
 class B {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     assertNoErrors(source3);
     verify([source, source2, source3]);
   }
 
   void test_argumentTypeNotAssignable_functionType() {
     Source source = addSource(r'''
 m() {
   var a = new A();
   a.n(() => 0);
 }
 class A {
   n(void f(int i)) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_argumentTypeNotAssignable_message() {
     // The implementation of HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE assumes that
     // StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE has the same message.
     expect(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE.message,
         HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE.message);
   }
 
   void test_argumentTypeNotAssignable_type() {
     Source source = addSource(r'''
 m() {
   var i = '';
   n(i);
 }
 n(int i) {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalElse() {
     Source source = addSource(r'''
 f() {
   true ? 1 : 2;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalElse_nested() {
     // test that a dead else-statement can't generate additional violations
     Source source = addSource(r'''
 f() {
   true ? true : false && false;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalIf() {
     Source source = addSource(r'''
 f() {
   false ? 1 : 2;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalIf_nested() {
     // test that a dead then-statement can't generate additional violations
     Source source = addSource(r'''
 f() {
   false ? false && false : true;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_else() {
     Source source = addSource(r'''
 f() {
   if(true) {} else {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_else_nested() {
     // test that a dead else-statement can't generate additional violations
     Source source = addSource(r'''
 f() {
   if(true) {} else {if (false) {}}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if() {
     Source source = addSource(r'''
 f() {
   if(false) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_nested() {
     // test that a dead then-statement can't generate additional violations
     Source source = addSource(r'''
 f() {
   if(false) {if(false) {}}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_while() {
     Source source = addSource(r'''
 f() {
   while(false) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_while_nested() {
     // test that a dead while body can't generate additional violations
     Source source = addSource(r'''
 f() {
   while(false) {if(false) {}}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch() {
     Source source = addSource(r'''
 class A {}
 f() {
   try {} catch (e) {} catch (e) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch_nested() {
     // test that a dead catch clause can't generate additional violations
     Source source = addSource(r'''
 class A {}
 f() {
   try {} catch (e) {} catch (e) {if(false) {}}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch_object() {
     Source source = addSource(r'''
 f() {
   try {} on Object catch (e) {} catch (e) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch_object_nested() {
     // test that a dead catch clause can't generate additional violations
     Source source = addSource(r'''
 f() {
   try {} on Object catch (e) {} catch (e) {if(false) {}}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_onCatchSubtype() {
     Source source = addSource(r'''
 class A {}
 class B extends A {}
 f() {
   try {} on A catch (e) {} on B catch (e) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE_ON_CATCH_SUBTYPE]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_onCatchSubtype_nested() {
     // test that a dead catch clause can't generate additional violations
     Source source = addSource(r'''
 class A {}
 class B extends A {}
 f() {
   try {} on A catch (e) {} on B catch (e) {if(false) {}}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE_ON_CATCH_SUBTYPE]);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_and() {
     Source source = addSource(r'''
 f() {
   bool b = false && false;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_and_nested() {
     Source source = addSource(r'''
 f() {
   bool b = false && (false && false);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_or() {
     Source source = addSource(r'''
 f() {
   bool b = true || true;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_or_nested() {
     Source source = addSource(r'''
 f() {
   bool b = true || (false && false);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterBreak_inDefaultCase() {
     Source source = addSource(r'''
 f(v) {
   switch(v) {
     case 1:
     default:
       break;
       var a;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterBreak_inForEachStatement() {
     Source source = addSource(r'''
 f() {
   var list;
   for(var l in list) {
     break;
     var a;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterBreak_inForStatement() {
     Source source = addSource(r'''
 f() {
   for(;;) {
     break;
     var a;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterBreak_inSwitchCase() {
     Source source = addSource(r'''
 f(v) {
   switch(v) {
     case 1:
       break;
       var a;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterBreak_inWhileStatement() {
     Source source = addSource(r'''
 f(v) {
   while(v) {
     break;
     var a;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterContinue_inForEachStatement() {
     Source source = addSource(r'''
 f() {
   var list;
   for(var l in list) {
     continue;
     var a;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterContinue_inForStatement() {
     Source source = addSource(r'''
 f() {
   for(;;) {
     continue;
     var a;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterContinue_inWhileStatement() {
     Source source = addSource(r'''
 f(v) {
   while(v) {
     continue;
     var a;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterReturn_function() {
     Source source = addSource(r'''
 f() {
   var one = 1;
   return;
   var two = 2;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterReturn_ifStatement() {
     Source source = addSource(r'''
 f(bool b) {
   if(b) {
     var one = 1;
     return;
     var two = 2;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterReturn_method() {
     Source source = addSource(r'''
 class A {
   m() {
     var one = 1;
     return;
     var two = 2;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterReturn_nested() {
     Source source = addSource(r'''
 f() {
   var one = 1;
   return;
   if(false) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterReturn_twoReturns() {
     Source source = addSource(r'''
 f() {
   var one = 1;
   return;
   var two = 2;
   return;
   var three = 3;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_assignment() {
     Source source = addSource(r'''
 class A {
   @deprecated
   A operator+(A a) { return a; }
 }
 f(A a) {
   A b;
   a += b;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_Deprecated() {
     Source source = addSource(r'''
 class A {
   @Deprecated('0.9')
   m() {}
   n() {m();}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_deprecated() {
     Source source = addSource(r'''
 class A {
   @deprecated
   m() {}
   n() {m();}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_export() {
     Source source = addSource("export 'deprecated_library.dart';");
     addNamedSource("/deprecated_library.dart", r'''
 @deprecated
 library deprecated_library;
 class A {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_getter() {
     Source source = addSource(r'''
 class A {
   @deprecated
   get m => 1;
 }
 f(A a) {
   return a.m;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_import() {
     Source source = addSource(r'''
 import 'deprecated_library.dart';
 f(A a) {}''');
     addNamedSource("/deprecated_library.dart", r'''
 @deprecated
 library deprecated_library;
 class A {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_indexExpression() {
     Source source = addSource(r'''
 class A {
   @deprecated
   operator[](int i) {}
 }
 f(A a) {
   return a[1];
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_instanceCreation() {
     Source source = addSource(r'''
 class A {
   @deprecated
   A(int i) {}
 }
 f() {
   A a = new A(1);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_instanceCreation_namedConstructor() {
     Source source = addSource(r'''
 class A {
   @deprecated
   A.named(int i) {}
 }
 f() {
   A a = new A.named(1);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_operator() {
     Source source = addSource(r'''
 class A {
   @deprecated
   operator+(A a) {}
 }
 f(A a) {
   A b;
   return a + b;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_setter() {
     Source source = addSource(r'''
 class A {
   @deprecated
   set s(v) {}
 }
 f(A a) {
   return a.s = 1;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_superConstructor() {
     Source source = addSource(r'''
 class A {
   @deprecated
   A() {}
 }
 class B extends A {
   B() : super() {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_superConstructor_namedConstructor() {
     Source source = addSource(r'''
 class A {
   @deprecated
   A.named() {}
 }
 class B extends A {
   B() : super.named() {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_divisionOptimization_double() {
     Source source = addSource(r'''
 f(double x, double y) {
   var v = (x / y).toInt();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
     verify([source]);
   }
 
   void test_divisionOptimization_int() {
     Source source = addSource(r'''
 f(int x, int y) {
   var v = (x / y).toInt();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
     verify([source]);
   }
 
   void test_divisionOptimization_propagatedType() {
     // Tests the propagated type information of the '/' method
     Source source = addSource(r'''
 f(x, y) {
   x = 1;
   y = 1;
   var v = (x / y).toInt();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
     verify([source]);
   }
 
   void test_divisionOptimization_wrappedBinaryExpression() {
     Source source = addSource(r'''
 f(int x, int y) {
   var v = (((x / y))).toInt();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
     verify([source]);
   }
 
   void test_duplicateImport() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart';
 A a;''');
     addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DUPLICATE_IMPORT]);
     verify([source]);
   }
 
   void test_duplicateImport2() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart';
 import 'lib1.dart';
 A a;''');
     addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(
         source, [HintCode.DUPLICATE_IMPORT, HintCode.DUPLICATE_IMPORT]);
     verify([source]);
   }
 
   void test_duplicateImport3() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' as M show A hide B;
 import 'lib1.dart' as M show A hide B;
 M.A a;''');
     addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}
 class B {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DUPLICATE_IMPORT]);
     verify([source]);
   }
 
   void test_importDeferredLibraryWithLoadFunction() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 loadLibrary() {}
 f() {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as lib1;
 main() { lib1.f(); }'''
     ], <ErrorCode>[HintCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION]);
   }
 
   void test_invalidAssignment_instanceVariable() {
     Source source = addSource(r'''
 class A {
   int x;
 }
 f(var y) {
   A a;
   if(y is String) {
     a.x = y;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_invalidAssignment_localVariable() {
     Source source = addSource(r'''
 f(var y) {
   if(y is String) {
     int x = y;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_invalidAssignment_message() {
     // The implementation of HintCode.INVALID_ASSIGNMENT assumes that
     // StaticTypeWarningCode.INVALID_ASSIGNMENT has the same message.
     expect(StaticTypeWarningCode.INVALID_ASSIGNMENT.message,
         HintCode.INVALID_ASSIGNMENT.message);
   }
 
   void test_invalidAssignment_staticVariable() {
     Source source = addSource(r'''
 class A {
   static int x;
 }
 f(var y) {
   if(y is String) {
     A.x = y;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_invalidAssignment_variableDeclaration() {
     // 17971
     Source source = addSource(r'''
 class Point {
   final num x, y;
   Point(this.x, this.y);
   Point operator +(Point other) {
     return new Point(x+other.x, y+other.y);
   }
 }
 main() {
   var p1 = new Point(0, 0);
   var p2 = new Point(10, 10);
   int n = p1 + p2;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_isDouble() {
     Source source = addSource("var v = 1 is double;");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.IS_DOUBLE]);
     verify([source]);
   }
 
   void test_isNotDouble() {
     Source source = addSource("var v = 1 is! double;");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.IS_NOT_DOUBLE]);
     verify([source]);
   }
 
   void test_missingReturn_async() {
     Source source = addSource('''
 import 'dart:async';
 Future<int> f() async {}
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.MISSING_RETURN]);
     verify([source]);
   }
 
   void test_missingReturn_function() {
     Source source = addSource("int f() {}");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.MISSING_RETURN]);
     verify([source]);
   }
 
   void test_missingReturn_method() {
     Source source = addSource(r'''
 class A {
   int m() {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.MISSING_RETURN]);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingGetter_invalid() {
     Source source = addSource(r'''
 library dart.core;
 const override = null;
 class A {
 }
 class B extends A {
   @override
   int get m => 1;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.OVERRIDE_ON_NON_OVERRIDING_GETTER]);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingMethod_invalid() {
     Source source = addSource(r'''
 library dart.core;
 const override = null;
 class A {
 }
 class B extends A {
   @override
   int m() => 1;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD]);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingSetter_invalid() {
     Source source = addSource(r'''
 library dart.core;
 const override = null;
 class A {
 }
 class B extends A {
   @override
   set m(int x) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.OVERRIDE_ON_NON_OVERRIDING_SETTER]);
     verify([source]);
   }
 
   void test_typeCheck_type_is_Null() {
     Source source = addSource(r'''
 m(i) {
   bool b = i is Null;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.TYPE_CHECK_IS_NULL]);
     verify([source]);
   }
 
   void test_typeCheck_type_not_Null() {
     Source source = addSource(r'''
 m(i) {
   bool b = i is! Null;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.TYPE_CHECK_IS_NOT_NULL]);
     verify([source]);
   }
 
   void test_undefinedGetter() {
     Source source = addSource(r'''
 class A {}
 f(var a) {
   if(a is A) {
     return a.m;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedGetter_message() {
     // The implementation of HintCode.UNDEFINED_SETTER assumes that
     // UNDEFINED_SETTER in StaticTypeWarningCode and StaticWarningCode are the
     // same, this verifies that assumption.
     expect(StaticWarningCode.UNDEFINED_GETTER.message,
         StaticTypeWarningCode.UNDEFINED_GETTER.message);
   }
 
   void test_undefinedMethod() {
     Source source = addSource(r'''
 f() {
   var a = 'str';
   a.notAMethodOnString();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_assignmentExpression() {
     Source source = addSource(r'''
 class A {}
 class B {
   f(var a, var a2) {
     a = new A();
     a2 = new A();
     a += a2;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedOperator_binaryExpression() {
     Source source = addSource(r'''
 class A {}
 f(var a) {
   if(a is A) {
     a + 1;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_indexBoth() {
     Source source = addSource(r'''
 class A {}
 f(var a) {
   if(a is A) {
     a[0]++;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_indexGetter() {
     Source source = addSource(r'''
 class A {}
 f(var a) {
   if(a is A) {
     a[0];
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_indexSetter() {
     Source source = addSource(r'''
 class A {}
 f(var a) {
   if(a is A) {
     a[0] = 1;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_postfixExpression() {
     Source source = addSource(r'''
 class A {}
 f(var a) {
   if(a is A) {
     a++;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_prefixExpression() {
     Source source = addSource(r'''
 class A {}
 f(var a) {
   if(a is A) {
     ++a;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedSetter() {
     Source source = addSource(r'''
 class A {}
 f(var a) {
   if(a is A) {
     a.m = 0;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNDEFINED_SETTER]);
   }
 
   void test_undefinedSetter_message() {
     // The implementation of HintCode.UNDEFINED_SETTER assumes that
     // UNDEFINED_SETTER in StaticTypeWarningCode and StaticWarningCode are the
     // same, this verifies that assumption.
     expect(StaticWarningCode.UNDEFINED_SETTER.message,
         StaticTypeWarningCode.UNDEFINED_SETTER.message);
   }
 
   void test_unnecessaryCast_type_supertype() {
     Source source = addSource(r'''
 m(int i) {
   var b = i as Object;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNNECESSARY_CAST]);
     verify([source]);
   }
 
   void test_unnecessaryCast_type_type() {
     Source source = addSource(r'''
 m(num i) {
   var b = i as num;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNNECESSARY_CAST]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_null_is_Null() {
     Source source = addSource("bool b = null is Null;");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_TRUE]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_null_not_Null() {
     Source source = addSource("bool b = null is! Null;");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_FALSE]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_type_is_dynamic() {
     Source source = addSource(r'''
 m(i) {
   bool b = i is dynamic;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_TRUE]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_type_is_object() {
     Source source = addSource(r'''
 m(i) {
   bool b = i is Object;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_TRUE]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_type_not_dynamic() {
     Source source = addSource(r'''
 m(i) {
   bool b = i is! dynamic;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_FALSE]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_type_not_object() {
     Source source = addSource(r'''
 m(i) {
   bool b = i is! Object;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_FALSE]);
     verify([source]);
   }
 
   void test_unusedElement_class_isUsed_extends() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class _A {}
 class B extends _A {}
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_class_isUsed_implements() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class _A {}
 class B implements _A {}
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_class_isUsed_instanceCreation() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class _A {}
 main() {
   new _A();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_class_isUsed_staticFieldAccess() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class _A {
   static const F = 42;
 }
 main() {
   _A.F;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_class_isUsed_staticMethodInvocation() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class _A {
   static m() {}
 }
 main() {
   _A.m();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_class_isUsed_typeArgument() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class _A {}
 main() {
   var v = new List<_A>();
   print(v);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_class_notUsed_inClassMember() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class _A {
   static staticMethod() {
     new _A();
   }
   instanceMethod() {
     new _A();
   }
 }
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_class_notUsed_inConstructorName() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class _A {
   _A() {}
   _A.named() {}
 }
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_class_notUsed_isExpression() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class _A {}
 main(p) {
   if (p is _A) {
   }
 }
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_class_notUsed_noReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class _A {}
 main() {
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_class_notUsed_variableDeclaration() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class _A {}
 main() {
   _A v;
   print(v);
 }
 print(x) {}
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_enum_isUsed_fieldReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 enum _MyEnum {A, B, C}
 main() {
   print(_MyEnum.B);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_enum_notUsed_noReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 enum _MyEnum {A, B, C}
 main() {
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_functionLocal_isUsed_closure() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 main() {
   print(() {});
 }
 print(x) {}
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_functionLocal_isUsed_invocation() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 main() {
   f() {}
   f();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_functionLocal_isUsed_reference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 main() {
   f() {}
   print(f);
 }
 print(x) {}
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_functionLocal_notUsed_noReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 main() {
   f() {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_functionLocal_notUsed_referenceFromItself() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 main() {
   _f(int p) {
     _f(p - 1);
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_functionTop_isUsed_invocation() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 _f() {}
 main() {
   _f();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_functionTop_isUsed_reference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 _f() {}
 main() {
   print(_f);
 }
 print(x) {}
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_functionTop_notUsed_noReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 _f() {}
 main() {
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_functionTop_notUsed_referenceFromItself() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 _f(int p) {
   _f(p - 1);
 }
 main() {
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_functionTypeAlias_isUsed_isExpression() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 typedef _F(a, b);
 main(f) {
   if (f is _F) {
     print('F');
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_functionTypeAlias_isUsed_reference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 typedef _F(a, b);
 main(_F f) {
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_functionTypeAlias_isUsed_typeArgument() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 typedef _F(a, b);
 main() {
   var v = new List<_F>();
   print(v);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_functionTypeAlias_isUsed_variableDeclaration() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 typedef _F(a, b);
 class A {
   _F f;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_functionTypeAlias_notUsed_noReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 typedef _F(a, b);
 main() {
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_getter_isUsed_invocation_implicitThis() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   get _g => null;
   useGetter() {
     var v = _g;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_getter_isUsed_invocation_PrefixedIdentifier() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   get _g => null;
 }
 main(A a) {
   var v = a._g;
 }
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_getter_isUsed_invocation_PropertyAccess() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   get _g => null;
 }
 main() {
   var v = new A()._g;
 }
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_getter_notUsed_noReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   get _g => null;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_getter_notUsed_referenceFromItself() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   get _g {
     return _g;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_hasReference_implicitThis() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   _m() {}
   useMethod() {
     print(_m);
   }
 }
 print(x) {}
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_hasReference_implicitThis_subclass() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   _m() {}
   useMethod() {
     print(_m);
   }
 }
 class B extends A {
   _m() {}
 }
 print(x) {}
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_hasReference_PrefixedIdentifier() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   _m() {}
 }
 main(A a) {
   a._m;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_hasReference_PropertyAccess() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   _m() {}
 }
 main() {
   new A()._m;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_invocation_implicitThis() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   _m() {}
   useMethod() {
     _m();
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_invocation_implicitThis_subclass() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   _m() {}
   useMethod() {
     _m();
   }
 }
 class B extends A {
   _m() {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_invocation_MemberElement() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A<T> {
   _m(T t) {}
 }
 main(A<int> a) {
   a._m(0);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_invocation_propagated() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   _m() {}
 }
 main() {
   var a = new A();
   a._m();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_invocation_static() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   _m() {}
 }
 main() {
   A a = new A();
   a._m();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_invocation_subclass() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   _m() {}
 }
 class B extends A {
   _m() {}
 }
 main(A a) {
   a._m();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_notPrivate() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   m() {}
 }
 main() {
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_staticInvocation() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   static _m() {}
 }
 main() {
   A._m();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_notUsed_noReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   static _m() {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_method_notUsed_referenceFromItself() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   static _m(int p) {
     _m(p - 1);
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_setter_isUsed_invocation_implicitThis() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   set _s(x) {}
   useSetter() {
     _s = 42;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_setter_isUsed_invocation_PrefixedIdentifier() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   set _s(x) {}
 }
 main(A a) {
   a._s = 42;
 }
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_setter_isUsed_invocation_PropertyAccess() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   set _s(x) {}
 }
 main() {
   new A()._s = 42;
 }
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_setter_notUsed_noReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   set _s(x) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_setter_notUsed_referenceFromItself() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   set _s(int x) {
     if (x > 5) {
       _s = x - 1;
     }
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedField_isUsed_argument() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f = 0;
   main() {
     print(++_f);
   }
 }
 print(x) {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_unusedField_isUsed_reference_implicitThis() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f;
   main() {
     print(_f);
   }
 }
 print(x) {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_unusedField_isUsed_reference_implicitThis_expressionFunctionBody() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f;
   m() => _f;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_unusedField_isUsed_reference_implicitThis_subclass() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f;
   main() {
     print(_f);
   }
 }
 class B extends A {
   int _f;
 }
 print(x) {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_unusedField_isUsed_reference_qualified_propagatedElement() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f;
 }
 main() {
   var a = new A();
   print(a._f);
 }
 print(x) {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_unusedField_isUsed_reference_qualified_staticElement() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f;
 }
 main() {
   A a = new A();
   print(a._f);
 }
 print(x) {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_unusedField_isUsed_reference_qualified_unresolved() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f;
 }
 main(a) {
   print(a._f);
 }
 print(x) {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_unusedField_notUsed_compoundAssign() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f;
   main() {
     _f += 2;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_FIELD]);
     verify([source]);
   }
 
   void test_unusedField_notUsed_noReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f;
 }
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_FIELD]);
     verify([source]);
   }
 
   void test_unusedField_notUsed_postfixExpr() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f = 0;
   main() {
     _f++;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_FIELD]);
     verify([source]);
   }
 
   void test_unusedField_notUsed_prefixExpr() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f = 0;
   main() {
     ++_f;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_FIELD]);
     verify([source]);
   }
 
   void test_unusedField_notUsed_simpleAssignment() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   int _f;
   m() {
     _f = 1;
   }
 }
 main(A a) {
   a._f = 2;
 }
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_FIELD]);
     verify([source]);
   }
 
   void test_unusedImport() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';''');
     Source source2 = addNamedSource("/lib1.dart", "library lib1;");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_unusedImport_as() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart' as one;
 one.A a;''');
     Source source2 = addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_unusedImport_hide() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart' hide A;
 A a;''');
     Source source2 = addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_unusedImport_show() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' show A;
 import 'lib1.dart' show B;
 A a;''');
     Source source2 = addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}
 class B {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_unusedLocalVariable_inCatch_exception() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   try {
   } on String catch (exception) {
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_CATCH_CLAUSE]);
     verify([source]);
   }
 
   void test_unusedLocalVariable_inCatch_exception_hasStack() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   try {
   } catch (exception, stack) {
     print(stack);
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedLocalVariable_inCatch_exception_noOnClause() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   try {
   } catch (exception) {
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedLocalVariable_inCatch_stackTrace() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   try {
   } catch (exception, stackTrace) {
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_CATCH_STACK]);
     verify([source]);
   }
 
   void test_unusedLocalVariable_inCatch_stackTrace_used() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   try {
   } catch (exception, stackTrace) {
     print('exception at $stackTrace');
   }
 }
 print(x) {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_unusedLocalVariable_inFor_underscore_ignored() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   for (var _ in [1,2,3]) {
     for (var __ in [4,5,6]) {
       // do something
     }
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_unusedLocalVariable_inFunction() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   var v = 1;
   v = 2;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
     verify([source]);
   }
 
   void test_unusedLocalVariable_inMethod() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 class A {
   foo() {
     var v = 1;
     v = 2;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
     verify([source]);
   }
 
   void test_unusedLocalVariable_isInvoked() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 typedef Foo();
 main() {
   Foo foo;
   foo();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_unusedLocalVariable_isRead_notUsed_compoundAssign() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   var v = 1;
   v += 2;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
     verify([source]);
   }
 
   void test_unusedLocalVariable_isRead_notUsed_postfixExpr() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   var v = 1;
   v++;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
     verify([source]);
   }
 
   void test_unusedLocalVariable_isRead_notUsed_prefixExpr() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   var v = 1;
   ++v;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
     verify([source]);
   }
 
   void test_unusedLocalVariable_isRead_usedArgument() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   var v = 1;
   print(++v);
 }
 print(x) {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_unusedLocalVariable_isRead_usedInvocationTarget() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 class A {
   foo() {}
 }
 main() {
   var a = new A();
   a.foo();
 }
 ''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source]);
   }
 
   void test_useOfVoidResult_assignmentExpression_function() {
     Source source = addSource(r'''
 void f() {}
 class A {
   n() {
     var a;
     a = f();
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 
   void test_useOfVoidResult_assignmentExpression_method() {
     Source source = addSource(r'''
 class A {
   void m() {}
   n() {
     var a;
     a = m();
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 
   void test_useOfVoidResult_inForLoop() {
     Source source = addSource(r'''
 class A {
   void m() {}
   n() {
     for(var a = m();;) {}
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 
   void test_useOfVoidResult_variableDeclaration_function() {
     Source source = addSource(r'''
 void f() {}
 class A {
   n() {
     var a = f();
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 
   void test_useOfVoidResult_variableDeclaration_method() {
     Source source = addSource(r'''
 class A {
   void m() {}
   n() {
     var a = m();
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 
   void test_useOfVoidResult_variableDeclaration_method2() {
     Source source = addSource(r'''
 class A {
   void m() {}
   n() {
     var a = m(), b = m();
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(
         source, [HintCode.USE_OF_VOID_RESULT, HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 }
 
 @reflectiveTest
 class InheritanceManagerTest extends EngineTestCase {
   /**
    * The type provider used to access the types.
@@ skipping 1917 matching lines @@
 }
 
 @reflectiveTest
 class NonHintCodeTest extends ResolverTestCase {
   void test_deadCode_deadBlock_conditionalElse_debugConst() {
     Source source = addSource(r'''
 const bool DEBUG = true;
 f() {
   DEBUG ? 1 : 2;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalIf_debugConst() {
     Source source = addSource(r'''
 const bool DEBUG = false;
 f() {
   DEBUG ? 1 : 2;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_else() {
     Source source = addSource(r'''
 const bool DEBUG = true;
 f() {
   if(DEBUG) {} else {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_debugConst_prefixedIdentifier() {
     Source source = addSource(r'''
 class A {
   static const bool DEBUG = false;
 }
 f() {
   if(A.DEBUG) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_debugConst_prefixedIdentifier2() {
     Source source = addSource(r'''
 library L;
 import 'lib2.dart';
 f() {
   if(A.DEBUG) {}
 }''');
     addNamedSource("/lib2.dart", r'''
 library lib2;
 class A {
   static const bool DEBUG = false;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_debugConst_propertyAccessor() {
     Source source = addSource(r'''
 library L;
 import 'lib2.dart' as LIB;
 f() {
   if(LIB.A.DEBUG) {}
 }''');
     addNamedSource("/lib2.dart", r'''
 library lib2;
 class A {
   static const bool DEBUG = false;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_debugConst_simpleIdentifier() {
     Source source = addSource(r'''
 const bool DEBUG = false;
 f() {
   if(DEBUG) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_while_debugConst() {
     Source source = addSource(r'''
 const bool DEBUG = false;
 f() {
   while(DEBUG) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_onCatchSubtype() {
     Source source = addSource(r'''
 class A {}
 class B extends A {}
 f() {
   try {} on B catch (e) {} on A catch (e) {} catch (e) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_and_debugConst() {
     Source source = addSource(r'''
 const bool DEBUG = false;
 f() {
   bool b = DEBUG && false;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_or_debugConst() {
     Source source = addSource(r'''
 const bool DEBUG = true;
 f() {
   bool b = DEBUG || true;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_divisionOptimization() {
     Source source = addSource(r'''
 f(int x, int y) {
   var v = x / y.toInt();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_divisionOptimization_supressIfDivisionNotDefinedInCore() {
     Source source = addSource(r'''
 f(x, y) {
   var v = (x / y).toInt();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_divisionOptimization_supressIfDivisionOverridden() {
     Source source = addSource(r'''
 class A {
   num operator /(x) { return x; }
 }
 f(A x, A y) {
   var v = (x / y).toInt();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_duplicateImport_as() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart' as one;
 A a;
 one.A a2;''');
     addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_duplicateImport_hide() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart' hide A;
 A a;
 B b;''');
     addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}
 class B {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_duplicateImport_show() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart' show A;
 A a;
 B b;''');
     addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}
 class B {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_importDeferredLibraryWithLoadFunction() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 f() {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as lib1;
 main() { lib1.f(); }'''
     ], ErrorCode.EMPTY_LIST);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_1() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     Source source = addSource(r'''
 f(var message, var dynamic_) {
   if (message is Function) {
     message = dynamic_;
   }
   int s = message;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_3() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     Source source = addSource(r'''
 f(var message) {
   var dynamic_;
   if (message is Function) {
     message = dynamic_;
   } else {
     return;
   }
   int s = message;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_4() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     Source source = addSource(r'''
 f(var message) {
   if (message is Function) {
     message = '';
   } else {
     return;
   }
   String s = message;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_missingReturn_emptyFunctionBody() {
     Source source = addSource(r'''
 abstract class A {
   int m();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_missingReturn_expressionFunctionBody() {
     Source source = addSource("int f() => 0;");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_missingReturn_noReturnType() {
     Source source = addSource("f() {}");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_missingReturn_voidReturnType() {
     Source source = addSource("void f() {}");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideEqualsButNotHashCode() {
     Source source = addSource(r'''
 class A {
   bool operator ==(x) { return x; }
   get hashCode => 0;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingGetter_inInterface() {
     Source source = addSource(r'''
 library dart.core;
 const override = null;
 class A {
   int get m => 0;
 }
 class B implements A {
   @override
   int get m => 1;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingGetter_inSuperclass() {
     Source source = addSource(r'''
 library dart.core;
 const override = null;
 class A {
   int get m => 0;
 }
 class B extends A {
   @override
   int get m => 1;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingMethod_inInterface() {
     Source source = addSource(r'''
 library dart.core;
 const override = null;
 class A {
   int m() => 0;
 }
 class B implements A {
   @override
   int m() => 1;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingMethod_inSuperclass() {
     Source source = addSource(r'''
 library dart.core;
 const override = null;
 class A {
   int m() => 0;
 }
 class B extends A {
   @override
   int m() => 1;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingSetter_inInterface() {
     Source source = addSource(r'''
 library dart.core;
 const override = null;
 class A {
   set m(int x) {}
 }
 class B implements A {
   @override
   set m(int x) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingSetter_inSuperclass() {
     Source source = addSource(r'''
 library dart.core;
 const override = null;
 class A {
   set m(int x) {}
 }
 class B extends A {
   @override
   set m(int x) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_propagatedFieldType() {
     Source source = addSource(r'''
 class A { }
 class X<T> {
   final x = new List<T>();
 }
 class Z {
   final X<A> y = new X<A>();
   foo() {
     y.x.add(new A());
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_proxy_annotation_prefixed() {
     Source source = addSource(r'''
 library L;
 @proxy
 class A {}
 f(var a) {
   a = new A();
   a.m();
   var x = a.g;
   a.s = 1;
   var y = a + a;
   a++;
   ++a;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_proxy_annotation_prefixed2() {
     Source source = addSource(r'''
 library L;
 @proxy
 class A {}
 class B {
   f(var a) {
     a = new A();
     a.m();
     var x = a.g;
     a.s = 1;
     var y = a + a;
     a++;
     ++a;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_proxy_annotation_prefixed3() {
     Source source = addSource(r'''
 library L;
 class B {
   f(var a) {
     a = new A();
     a.m();
     var x = a.g;
     a.s = 1;
     var y = a + a;
     a++;
     ++a;
   }
 }
 @proxy
 class A {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedGetter_inSubtype() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   get b => 0;
 }
 f(var a) {
   if(a is A) {
     return a.b;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedMethod_assignmentExpression_inSubtype() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   operator +(B b) {return new B();}
 }
 f(var a, var a2) {
   a = new A();
   a2 = new A();
   a += a2;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedMethod_dynamic() {
     Source source = addSource(r'''
 class D<T extends dynamic> {
   fieldAccess(T t) => t.abc;
   methodAccess(T t) => t.xyz(1, 2, 'three');
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedMethod_inSubtype() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   b() {}
 }
 f() {
   var a = new A();
   a.b();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedMethod_unionType_all() {
     Source source = addSource(r'''
 class A {
   int m(int x) => 0;
 }
 class B {
   String m() => '0';
 }
 f(A a, B b) {
   var ab;
   if (0 < 1) {
     ab = a;
   } else {
     ab = b;
   }
   ab.m();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedMethod_unionType_some() {
     Source source = addSource(r'''
 class A {
   int m(int x) => 0;
 }
 class B {}
 f(A a, B b) {
   var ab;
   if (0 < 1) {
     ab = a;
   } else {
     ab = b;
   }
   ab.m(0);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_binaryExpression_inSubtype() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   operator +(B b) {}
 }
 f(var a) {
   if(a is A) {
     a + 1;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_indexBoth_inSubtype() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   operator [](int index) {}
 }
 f(var a) {
   if(a is A) {
     a[0]++;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_indexGetter_inSubtype() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   operator [](int index) {}
 }
 f(var a) {
   if(a is A) {
     a[0];
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_indexSetter_inSubtype() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   operator []=(i, v) {}
 }
 f(var a) {
   if(a is A) {
     a[0] = 1;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_postfixExpression() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   operator +(B b) {return new B();}
 }
 f(var a) {
   if(a is A) {
     a++;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_prefixExpression() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   operator +(B b) {return new B();}
 }
 f(var a) {
   if(a is A) {
     ++a;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_undefinedSetter_inSubtype() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   set b(x) {}
 }
 f(var a) {
   if(a is A) {
     a.b = 0;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_unnecessaryCast_13855_parameter_A() {
     // dartbug.com/13855, dartbug.com/13732
     Source source = addSource(r'''
 class A{
   a() {}
 }
 class B<E> {
   E e;
   m() {
     (e as A).a();
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unnecessaryCast_conditionalExpression() {
     Source source = addSource(r'''
 abstract class I {}
 class A implements I {}
 class B implements I {}
 I m(A a, B b) {
   return a == null ? b as I : a as I;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unnecessaryCast_dynamic_type() {
     Source source = addSource(r'''
 m(v) {
   var b = v as Object;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unnecessaryCast_generics() {
     // dartbug.com/18953
     Source source = addSource(r'''
 import 'dart:async';
 Future<int> f() => new Future.value(0);
 void g(bool c) {
   (c ? f(): new Future.value(0) as Future<int>).then((int value) {});
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unnecessaryCast_type_dynamic() {
     Source source = addSource(r'''
 m(v) {
   var b = Object as dynamic;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_annotationOnDirective() {
     Source source = addSource(r'''
 library L;
 @A()
 import 'lib1.dart';''');
     Source source2 = addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {
   const A() {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source, source2]);
   }
 
   void test_unusedImport_as_equalPrefixes() {
     // 18818
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' as one;
 import 'lib2.dart' as one;
 one.A a;
 one.B b;''');
     Source source2 = addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}''');
     Source source3 = addNamedSource("/lib2.dart", r'''
 library lib2;
 class B {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source);
     assertNoErrors(source2);
     assertNoErrors(source3);
     verify([source, source2, source3]);
   }
 
   void test_unusedImport_core_library() {
     Source source = addSource(r'''
 library L;
 import 'dart:core';''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_export() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 Two two;''');
     addNamedSource("/lib1.dart", r'''
 library lib1;
 export 'lib2.dart';
 class One {}''');
     addNamedSource("/lib2.dart", r'''
 library lib2;
 class Two {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_export2() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 Three three;''');
     addNamedSource("/lib1.dart", r'''
 library lib1;
 export 'lib2.dart';
 class One {}''');
     addNamedSource("/lib2.dart", r'''
 library lib2;
 export 'lib3.dart';
 class Two {}''');
     addNamedSource("/lib3.dart", r'''
 library lib3;
 class Three {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_export_infiniteLoop() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 Two two;''');
     addNamedSource("/lib1.dart", r'''
 library lib1;
 export 'lib2.dart';
 class One {}''');
     addNamedSource("/lib2.dart", r'''
 library lib2;
 export 'lib3.dart';
 class Two {}''');
     addNamedSource("/lib3.dart", r'''
 library lib3;
 export 'lib2.dart';
 class Three {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_metadata() {
     Source source = addSource(r'''
 library L;
 @A(x)
 import 'lib1.dart';
 class A {
   final int value;
   const A(this.value);
 }''');
     addNamedSource("/lib1.dart", r'''
 library lib1;
 const x = 0;''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_prefix_topLevelFunction() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' hide topLevelFunction;
 import 'lib1.dart' as one show topLevelFunction;
 class A {
   static void x() {
     One o;
     one.topLevelFunction();
   }
 }''');
     addNamedSource("/lib1.dart", r'''
 library lib1;
 class One {}
 topLevelFunction() {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_useOfVoidResult_implicitReturnValue() {
     Source source = addSource(r'''
 f() {}
 class A {
   n() {
     var a = f();
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_useOfVoidResult_nonVoidReturnValue() {
     Source source = addSource(r'''
 int f() => 1;
 g() {
   var a = f();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 }
 
 class PubSuggestionCodeTest extends ResolverTestCase {
   void test_import_package() {
     Source source = addSource("import 'package:somepackage/other.dart';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
 
   void test_import_packageWithDotDot() {
     Source source = addSource("import 'package:somepackage/../other.dart';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CompileTimeErrorCode.URI_DOES_NOT_EXIST,
       HintCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT
     ]);
   }
 
   void test_import_packageWithLeadingDotDot() {
     Source source = addSource("import 'package:../other.dart';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [
       CompileTimeErrorCode.URI_DOES_NOT_EXIST,
       HintCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT
     ]);
   }
 
   void test_import_referenceIntoLibDirectory() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/lib/other.dart", "");
     Source source =
         addNamedSource("/myproj/web/test.dart", "import '../lib/other.dart';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(
         source, [HintCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE]);
   }
 
   void test_import_referenceIntoLibDirectory_no_pubspec() {
     cacheSource("/myproj/lib/other.dart", "");
     Source source =
         addNamedSource("/myproj/web/test.dart", "import '../lib/other.dart';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_import_referenceOutOfLibDirectory() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/web/other.dart", "");
     Source source =
         addNamedSource("/myproj/lib/test.dart", "import '../web/other.dart';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(
         source, [HintCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE]);
   }
 
   void test_import_referenceOutOfLibDirectory_no_pubspec() {
     cacheSource("/myproj/web/other.dart", "");
     Source source =
         addNamedSource("/myproj/lib/test.dart", "import '../web/other.dart';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_import_valid_inside_lib1() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/lib/other.dart", "");
     Source source =
         addNamedSource("/myproj/lib/test.dart", "import 'other.dart';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_import_valid_inside_lib2() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/lib/bar/other.dart", "");
     Source source = addNamedSource(
         "/myproj/lib/foo/test.dart", "import '../bar/other.dart';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_import_valid_outside_lib() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/web/other.dart", "");
     Source source =
         addNamedSource("/myproj/lib2/test.dart", "import '../web/other.dart';");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 }
 
 /**
  * An AST visitor used to verify that all of the nodes in an AST structure that
  * should have been resolved were resolved.
  */
 class ResolutionVerifier extends RecursiveAstVisitor<Object> {
   /**
@@ skipping 360 matching lines @@
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the cached file
    */
   Source cacheSource(String filePath, String contents) {
     Source source = new FileBasedSource(FileUtilities2.createFile(filePath));
     analysisContext2.setContents(source, contents);
     return source;
   }
 
   /**
+   * Computes errors for the given [librarySource].
+   * This assumes that the given [librarySource] and its parts have already
+   * been added to the content provider using the method [addNamedSource].
+   */
+  void computeLibrarySourceErrors(Source librarySource) {
+    analysisContext.computeErrors(librarySource);
+  }
+
+  /**
    * Create a library element that represents a library named `"test"` containing a single
    * empty compilation unit.
    *
    * @return the library element that was created
    */
   LibraryElementImpl createDefaultTestLibrary() =>
       createTestLibrary(AnalysisContextFactory.contextWithCore(), "test");
 
   /**
    * Create a library element that represents a library with the given name containing a single
@@ skipping 76 matching lines @@
 
   /**
    * Given a library and all of its parts, resolve the contents of the library and the contents of
    * the parts. This assumes that the sources for the library and its parts have already been added
    * to the content provider using the method [addNamedSource].
    *
    * @param librarySource the source for the compilation unit that defines the library
    * @return the element representing the resolved library
    * @throws AnalysisException if the analysis could not be performed
    */
-  LibraryElement resolve(Source librarySource) =>
+  LibraryElement resolve2(Source librarySource) =>
       analysisContext2.computeLibraryElement(librarySource);
 
   /**
    * Return the resolved compilation unit corresponding to the given source in the given library.
    *
    * @param source the source of the compilation unit to be returned
    * @param library the library in which the compilation unit is to be resolved
    * @return the resolved compilation unit
    * @throws Exception if the compilation unit could not be resolved
    */
@@ skipping 186 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 = resolve(source);
+    LibraryElement library = resolve2(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(
         propertyAccess.propertyName.staticElement.enclosingElement.name, 'M2');
     expect(
         propertyAccess.propertyName.auxiliaryElements.staticElement.enclosingElement.name,
         'M2');
   }
 
   void fail_staticInvocation() {
     Source source = addSource(r'''
 class A {
   static int get g => (a,b) => 0;
 }
 class B {
   f() {
     A.g(1,0);
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_argumentResolution_required_matching() {
     Source source = addSource(r'''
 class A {
   void f() {
     g(1, 2, 3);
   }
@@ skipping 92 matching lines @@
 
   void test_argumentResolution_setter_propagated() {
     Source source = addSource(r'''
 main() {
   var a = new A();
   a.sss = 0;
 }
 class A {
   set sss(x) {}
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
           statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
@@ skipping 15 matching lines @@
 main() {
   var a = new A();
   a.b.sss = 0;
 }
 class A {
   B b = new B();
 }
 class B {
   set sss(x) {}
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
           statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
@@ skipping 12 matching lines @@
 
   void test_argumentResolution_setter_static() {
     Source source = addSource(r'''
 main() {
   A a = new A();
   a.sss = 0;
 }
 class A {
   set sss(x) {}
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
           statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
@@ skipping 14 matching lines @@
 main() {
   A a = new A();
   a.b.sss = 0;
 }
 class A {
   B b = new B();
 }
 class B {
   set sss(x) {}
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
           statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
@@ skipping 137 matching lines @@
   }
 
   void test_class_definesCall() {
     Source source = addSource(r'''
 class A {
   int call(int x) { return x; }
 }
 int f(A a) {
   return a(0);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_class_extends_implements() {
     Source source = addSource(r'''
 class A extends B implements C {}
 class B {}
 class C {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_commentReference_class() {
     Source source = addSource(r'''
 f() {}
 /** [A] [new A] [A.n] [new A.n] [m] [f] */
 class A {
   A() {}
   A.n() {}
   m() {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_commentReference_parameter() {
     Source source = addSource(r'''
 class A {
   A() {}
   A.n() {}
   /** [e] [f] */
   m(e, f()) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_commentReference_singleLine() {
     Source source = addSource(r'''
 /// [A]
 class A {}''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_continueTarget_labeled() {
     // 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) {
@@ skipping 113 matching lines @@
 }
 ''';
     CompilationUnit unit = resolveSource(text);
     ContinueStatement continueStatement = EngineTestCase.findNode(
         unit, text, 'continue', (n) => n is ContinueStatement);
     expect(continueStatement.target, isNull);
   }
 
   void test_empty() {
     Source source = addSource("");
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_exported() {
     addNamedSource("/two.dart", r'''
 library two;
 main() {}''');
     Source source = addNamedSource("/one.dart", r'''
 library one;
 export 'two.dart';''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     FunctionElement main = library.entryPoint;
     expect(main, isNotNull);
     expect(main.library, isNot(same(library)));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_local() {
     Source source = addNamedSource("/one.dart", r'''
 library one;
 main() {}''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     FunctionElement main = library.entryPoint;
     expect(main, isNotNull);
     expect(main.library, same(library));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_none() {
     Source source = addNamedSource("/one.dart", "library one;");
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     expect(library.entryPoint, isNull);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_enum_externalLibrary() {
     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;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_extractedMethodAsConstant() {
     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]) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameter() {
     Source source = addSource(r'''
 class A {
   int x;
   A(this.x) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_forEachLoops_nonConflicting() {
     Source source = addSource(r'''
 f() {
   List list = [1,2,3];
   for (int x in list) {}
   for (int x in list) {}
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_forLoops_nonConflicting() {
     Source source = addSource(r'''
 f() {
   for (int i = 0; i < 3; i++) {
   }
   for (int i = 0; i < 3; i++) {
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_functionTypeAlias() {
     Source source = addSource(r'''
 typedef bool P(e);
 class A {
   P p;
   m(e) {
     if (p(e)) {}
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_getter_and_setter_fromMixins_bare_identifier() {
     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 = resolve(source);
+    LibraryElement library = resolve2(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;
@@ skipping 10 matching lines @@
 }
 class M2 {
   get x => null;
 }
 class C extends B with M1, M2 {
   f() {
     return x;
   }
 }
 ''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(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(x.staticElement.enclosingElement.name, 'M2');
   }
 
   void test_getter_fromMixins_property_access() {
     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 = resolve(source);
+    LibraryElement library = resolve2(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(
         propertyAccess.propertyName.staticElement.enclosingElement.name, 'M2');
   }
 
   void test_getterAndSetterWithDifferentTypes() {
     Source source = addSource(r'''
 class A {
   int get f => 0;
   void set f(String s) {}
 }
 g (A a) {
   a.f = a.f.toString();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(
         source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
 
   void test_hasReferenceToSuper() {
     Source source = addSource(r'''
 class A {}
 class B {toString() => super.toString();}''');
-    LibraryElement library = resolve(source);
+    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);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_hide() {
     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;''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_prefix() {
     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);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_spaceInUri() {
     addNamedSource("sub folder/lib.dart", r'''
 library lib;
 foo() {}''');
     Source source = addNamedSource("app.dart", r'''
 import 'sub folder/lib.dart';
 
 main() {
   foo();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_indexExpression_typeParameters() {
     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];
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_indexExpression_typeParameters_invalidAssignmentWarning() {
     Source source = addSource(r'''
 f() {
   List<List<int>> b;
   b[0][0] = 'hi';
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_indirectOperatorThroughCall() {
     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]);
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_invoke_dynamicThroughGetter() {
     Source source = addSource(r'''
 class A {
   List get X => [() => 0];
   m(A a) {
     X.last;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_badSuperclass() {
     Source source = addSource(r'''
 class A extends B {}
 class B {}''');
-    LibraryElement library = resolve(source);
+    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].isValidMixin, isFalse);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_constructor() {
     Source source = addSource(r'''
 class A {
   A() {}
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     expect(classes, hasLength(1));
     expect(classes[0].isValidMixin, isFalse);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_super() {
     Source source = addSource(r'''
 class A {
   toString() {
     return super.toString();
   }
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     expect(classes, hasLength(1));
     expect(classes[0].isValidMixin, isFalse);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_valid() {
     Source source = addSource("class A {}");
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     expect(classes, hasLength(1));
     expect(classes[0].isValidMixin, isTrue);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_labels_switch() {
     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 = resolve(source);
+    LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_localVariable_types_invoked() {
     Source source = addSource(r'''
 const A = null;
 main() {
   var myVar = (int p) => 'foo';
   myVar(42);
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, library);
     expect(unit, isNotNull);
     List<bool> found = [false];
     List<CaughtException> thrownException = new List<CaughtException>(1);
     unit.accept(new _SimpleResolverTest_localVariable_types_invoked(
         this, found, thrownException));
     if (thrownException[0] != null) {
       throw new AnalysisException(
           "Exception", new CaughtException(thrownException[0], null));
     }
     expect(found[0], isTrue);
   }
 
   void test_metadata_class() {
     Source source = addSource(r'''
 const A = null;
 @A class C<A> {}''');
-    LibraryElement library = resolve(source);
+    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));
     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,
         PropertyInducingElement, expectedElement);
     expectedElement = (expectedElement as PropertyInducingElement).getter;
     Element actualElement =
         (declarations[1] as ClassDeclaration).metadata[0].name.staticElement;
     expect(actualElement, same(expectedElement));
   }
 
   void test_metadata_field() {
     Source source = addSource(r'''
 const A = null;
 class C {
   @A int f;
 }''');
-    LibraryElement library = resolve(source);
+    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));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_fieldFormalParameter() {
     Source source = addSource(r'''
 const A = null;
 class C {
   int f;
   C(@A this.f);
 }''');
-    LibraryElement library = resolve(source);
+    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));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_function() {
     Source source = addSource(r'''
 const A = null;
 @A f() {}''');
-    LibraryElement library = resolve(source);
+    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));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_functionTypedParameter() {
     Source source = addSource(r'''
 const A = null;
 f(@A int p(int x)) {}''');
-    LibraryElement library = resolve(source);
+    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));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_libraryDirective() {
     Source source = addSource(r'''
 @A library lib;
 const A = null;''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     List<ElementAnnotation> annotations = library.metadata;
     expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_method() {
     Source source = addSource(r'''
 const A = null;
 class C {
   @A void m() {}
 }''');
-    LibraryElement library = resolve(source);
+    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));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_namedParameter() {
     Source source = addSource(r'''
 const A = null;
 f({@A int p : 0}) {}''');
-    LibraryElement library = resolve(source);
+    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));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_positionalParameter() {
     Source source = addSource(r'''
 const A = null;
 f([@A int p = 0]) {}''');
-    LibraryElement library = resolve(source);
+    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));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_simpleParameter() {
     Source source = addSource(r'''
 const A = null;
 f(@A p1, @A int p2) {}''');
-    LibraryElement library = resolve(source);
+    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));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_typedef() {
     Source source = addSource(r'''
 const A = null;
 @A typedef F<A>();''');
-    LibraryElement library = resolve(source);
+    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));
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
@@ skipping 16 matching lines @@
   bar() => 1;
 }
 class A {
   foo() => 2;
 }
 
 class C extends B with A {
   bar() => super.bar();
   foo() => super.foo();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_method_fromMixins() {
     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 = resolve(source);
+    LibraryElement library = resolve2(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(expr.methodName.staticElement.enclosingElement.name, 'M2');
   }
 
   void test_method_fromMixins_bare_identifier() {
     Source source = addSource('''
 class B {}
 class M1 {
   void f() {}
 }
 class M2 {
   void f() {}
 }
 class C extends B with M1, M2 {
   void g() {
     f();
   }
 }
 ''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(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(methodName.staticElement.enclosingElement.name, 'M2');
   }
 
   void test_method_fromMixins_invked_from_outside_class() {
     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 = resolve(source);
+    LibraryElement library = resolve2(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(invocation.methodName.staticElement.enclosingElement.name, 'M2');
   }
 
   void test_method_fromSuperclassMixin() {
     Source source = addSource(r'''
 class A {
   void m1() {}
 }
 class B extends Object with A {
 }
 class C extends B {
 }
 f(C c) {
   c.m1();
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_methodCascades() {
     Source source = addSource(r'''
 class A {
   void m1() {}
   void m2() {}
   void m() {
     A a = new A();
     a..m1()
      ..m2();
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_methodCascades_withSetter() {
     Source source = addSource(r'''
 class A {
   String name;
   void m1() {}
   void m2() {}
   void m() {
     A a = new A();
     a..m1()
      ..name = 'name'
      ..m2();
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     // failing with error code: INVOCATION_OF_NON_FUNCTION
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_resolveAgainstNull() {
     Source source = addSource(r'''
 f(var p) {
   return null == p;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_setter_fromMixins_bare_identifier() {
     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 = resolve(source);
+    LibraryElement library = resolve2(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(leftHandSide.staticElement.enclosingElement.name, 'M2');
   }
 
   void test_setter_fromMixins_property_access() {
     Source source = addSource('''
 class B {}
 class M1 {
   set x(value) {}
 }
 class M2 {
   set x(value) {}
 }
 class C extends B with M1, M2 {}
 void main() {
   new C().x = 1;
 }
 ''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(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(
         propertyAccess.propertyName.staticElement.enclosingElement.name, 'M2');
   }
 
   void test_setter_inherited() {
     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;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_setter_static() {
     Source source = addSource(r'''
 set s(x) {
 }
 
 main() {
   s = 123;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(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
    * method invocation. It is the arguments to that method invocation that are tested. The method
    * invocation can contain errors.
    *
    * The arguments were resolved correctly if the number of expressions in the list matches the
    * length of the array of indices and if, for each index in the array of indices, the parameter to
    * which the argument expression was resolved is the parameter in the invoked method's list of
    * parameters at that index. Arguments that should not be resolved to a parameter because of an
    * error can be denoted by including a negative index in the array of indices.
    *
    * @param source the source to be resolved
    * @param indices the array of indices used to associate arguments with parameters
    * @throws Exception if the source could not be resolved or if the structure of the source is not
    *           valid
    */
   void _validateArgumentResolution(Source source, List<int> indices) {
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     ClassElement classElement = library.definingCompilationUnit.types[0];
     List<ParameterElement> parameters = classElement.methods[1].parameters;
     CompilationUnit unit = resolveCompilationUnit(source, library);
     expect(unit, isNotNull);
     ClassDeclaration classDeclaration =
         unit.declarations[0] as ClassDeclaration;
     MethodDeclaration methodDeclaration =
         classDeclaration.members[0] as MethodDeclaration;
     Block block = (methodDeclaration.body as BlockFunctionBody).block;
@@ skipping 123 matching lines @@
 
   SimpleIdentifier _findIdentifier(String search) {
     SimpleIdentifier identifier = EngineTestCase.findNode(
         testUnit, testCode, search, (node) => node is SimpleIdentifier);
     return identifier;
   }
 
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
-    LibraryElement library = resolve(testSource);
+    LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }
 
 @reflectiveTest
 class StaticTypeAnalyzerTest extends EngineTestCase {
   /**
    * The error listener to which errors will be reported.
@@ skipping 1579 matching lines @@
 @reflectiveTest
 class StrictModeTest extends ResolverTestCase {
   void fail_for() {
     Source source = addSource(r'''
 int f(List<int> list) {
   num sum = 0;
   for (num i = 0; i < list.length; i++) {
     sum += list[i];
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   @override
   void setUp() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.hint = false;
     resetWithOptions(options);
   }
 
   void test_assert_is() {
     Source source = addSource(r'''
 int f(num n) {
   assert (n is int);
   return n & 0x0F;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_conditional_and_is() {
     Source source = addSource(r'''
 int f(num n) {
   return (n is int && n > 0) ? n & 0x0F : 0;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_conditional_is() {
     Source source = addSource(r'''
 int f(num n) {
   return (n is int) ? n & 0x0F : 0;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_conditional_isNot() {
     Source source = addSource(r'''
 int f(num n) {
   return (n is! int) ? 0 : n & 0x0F;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_conditional_or_is() {
     Source source = addSource(r'''
 int f(num n) {
   return (n is! int || n < 0) ? 0 : n & 0x0F;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_forEach() {
     Source source = addSource(r'''
 int f(List<int> list) {
   num sum = 0;
   for (num n in list) {
     sum += n & 0x0F;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_if_and_is() {
     Source source = addSource(r'''
 int f(num n) {
   if (n is int && n > 0) {
     return n & 0x0F;
   }
   return 0;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_if_is() {
     Source source = addSource(r'''
 int f(num n) {
   if (n is int) {
     return n & 0x0F;
   }
   return 0;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_if_isNot() {
     Source source = addSource(r'''
 int f(num n) {
   if (n is! int) {
     return 0;
   } else {
     return n & 0x0F;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_if_isNot_abrupt() {
     Source source = addSource(r'''
 int f(num n) {
   if (n is! int) {
     return 0;
   }
   return n & 0x0F;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_if_or_is() {
     Source source = addSource(r'''
 int f(num n) {
   if (n is! int || n < 0) {
     return 0;
   } else {
     return n & 0x0F;
   }
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_localVar() {
     Source source = addSource(r'''
 int f() {
   num n = 1234;
   return n & 0x0F;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 }
 
 @reflectiveTest
 class SubtypeManagerTest extends EngineTestCase {
   /**
    * The inheritance manager being tested.
    */
   SubtypeManager _subtypeManager;
@@ skipping 387 matching lines @@
 class A {
   bool get g => true;
 }
 A f(var p) {
   if ((p as A).g) {
     return p;
   } else {
     return null;
   }
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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));
   }
 
   void test_assert() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   assert (p is A);
   return p;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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));
   }
 
   void test_assignment() {
     Source source = addSource(r'''
 f() {
   var v;
   v = 0;
   return v;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
   }
 
   void test_assignment_afterInitializer() {
     Source source = addSource(r'''
 f() {
   var v = 0;
   v = 1.0;
   return v;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
   }
 
   void test_assignment_null() {
     String code = r'''
 main() {
   int v; // declare
   v = null;
   return v; // return
 }''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
-      LibraryElement library = resolve(source);
+      LibraryElement library = resolve2(source);
       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 @@
     }
   }
 
   void test_CanvasElement_getContext() {
     String code = r'''
 import 'dart:html';
 main(CanvasElement canvas) {
   var context = canvas.getContext('2d');
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     SimpleIdentifier identifier = EngineTestCase.findNode(
         unit, code, "context", (node) => node is SimpleIdentifier);
     expect(identifier.propagatedType.name, "CanvasRenderingContext2D");
   }
 
   void test_forEach() {
     String code = r'''
 main() {
   var list = <String> [];
   for (var e in list) {
     e;
   }
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
     }
@@ skipping 10 matching lines @@
 class MyMap<K, V> {
   forEach(f(K key, V value)) {}
 }
 f(MyMap<int, String> m) {
   m.forEach((k, v) {
     k;
     v;
   });
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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);
@@ skipping 13 matching lines @@
   void test_functionExpression_asInvocationArgument_fromInferredInvocation() {
     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 = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
   }
 
   void test_functionExpression_asInvocationArgument_functionExpressionInvocation() {
     String code = r'''
 main() {
   (f(String value)) {} ((v) {
     v;
   });
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
   }
 
   void test_functionExpression_asInvocationArgument_keepIfLessSpecific() {
     String code = r'''
 class MyList {
   forEach(f(Object value)) {}
 }
 f(MyList list) {
   list.forEach((int v) {
     v;
   });
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
   }
 
   void test_functionExpression_asInvocationArgument_notSubtypeOfStaticType() {
     String code = r'''
 class A {
   m(void f(int i)) {}
 }
 x() {
   A a = new A();
   a.m(() => 0);
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
   }
 
   void test_functionExpression_asInvocationArgument_replaceIfMoreSpecific() {
     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 = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
   }
 
   void test_Future_then() {
     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 = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
   }
 
   void test_initializer() {
     Source source = addSource(r'''
 f() {
   var v = 0;
   return v;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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;
       SimpleIdentifier variableName = statement.variables.variables[0].name;
       expect(variableName.staticType, same(typeProvider.dynamicType));
       expect(variableName.propagatedType, same(typeProvider.intType));
     }
     // Type of 'v' in reference.
     {
       ReturnStatement statement = statements[1] as ReturnStatement;
       SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
       expect(variableName.propagatedType, same(typeProvider.intType));
     }
   }
 
   void test_initializer_dereference() {
     Source source = addSource(r'''
 f() {
   var v = 'String';
   v.
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ExpressionStatement statement =
         body.block.statements[1] as ExpressionStatement;
     PrefixedIdentifier invocation = statement.expression as PrefixedIdentifier;
     SimpleIdentifier variableName = invocation.prefix;
     expect(variableName.propagatedType, same(typeProvider.stringType));
   }
 
   void test_initializer_hasStaticType() {
     Source source = addSource(r'''
 f() {
   int v = 0;
   return v;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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 =
@@ skipping 10 matching lines @@
       expect(variableName.propagatedType, isNull);
     }
   }
 
   void test_initializer_hasStaticType_parameterized() {
     Source source = addSource(r'''
 f() {
   List<int> v = <int>[];
   return v;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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 =
@@ skipping 13 matching lines @@
 
   void test_initializer_null() {
     String code = r'''
 main() {
   int v = null;
   return v; // marker
 }''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
-      LibraryElement library = resolve(source);
+      LibraryElement library = resolve2(source);
       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));
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "v; // marker", (node) => node is SimpleIdentifier);
       expect(identifier.staticType, same(typeProvider.intType));
       expect(identifier.propagatedType, same(null));
     }
   }
 
   void test_is_conditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is A) ? p : null;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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));
   }
 
   void test_is_if() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A) {
     return p;
   } else {
     return null;
   }
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // prepare A
     InterfaceType typeA;
     {
       ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
       typeA = classA.element.type;
     }
     // verify "f"
@@ skipping 19 matching lines @@
   void test_is_if_lessSpecific() {
     Source source = addSource(r'''
 class A {}
 A f(A p) {
   if (p is String) {
     return p;
   } else {
     return null;
   }
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
   }
 
   void test_is_if_logicalAnd() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A && p != null) {
     return p;
   } else {
     return null;
   }
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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));
   }
 
   void test_is_postConditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   A a = (p is A) ? p : throw null;
   return p;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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));
   }
 
   void test_is_postIf() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A) {
     A a = p;
   } else {
     return null;
   }
   return p;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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));
   }
 
   void test_is_subclass() {
     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 = resolve(source);
+    LibraryElement library = resolve2(source);
     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);
   }
 
   void test_is_while() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   while (p is A) {
     return p;
   }
   return p;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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));
   }
 
   void test_isNot_conditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is! A) ? null : p;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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));
   }
 
   void test_isNot_if() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A) {
     return null;
   } else {
     return p;
   }
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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));
   }
 
   void test_isNot_if_logicalOr() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A || null == p) {
     return null;
   } else {
     return p;
   }
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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));
   }
 
   void test_isNot_postConditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   A a = (p is! A) ? throw null : p;
   return p;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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));
   }
 
   void test_isNot_postIf() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A) {
     return null;
   }
   return p;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.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 53 matching lines @@
     DartType tB = _findMarkedIdentifier(code, "; // B").propagatedType;
     _assertTypeOfMarkedExpression(code, null, tB);
   }
 
   void test_listLiteral_different() {
     Source source = addSource(r'''
 f() {
   var v = [0, '1', 2];
   return v[2];
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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);
   }
 
   void test_listLiteral_same() {
     Source source = addSource(r'''
 f() {
   var v = [0, 1, 2];
   return v[2];
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
   }
 
   void test_mapLiteral_different() {
     Source source = addSource(r'''
 f() {
   var v = {'0' : 0, 1 : '1', '2' : 2};
   return v;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
   }
 
   void test_mapLiteral_same() {
     Source source = addSource(r'''
 f() {
   var v = {'a' : 0, 'b' : 1, 'c' : 2};
   return v;
 }''');
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     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));
@@ skipping 94 matching lines @@
   }
 }
 
 void g() {
   Base x = null;
   if (x is Derived) {
     print(x.y); // GOOD
   }
   x = null;
 }''');
-    resolve(source);
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_objectMethodOnDynamicExpression_doubleEquals() {
     // https://code.google.com/p/dart/issues/detail?id=20342
     //
     // This was not actually part of Issue 20342, since the spec specifies a
     // static type of [bool] for [==] comparison and the implementation
     // was already consistent with the spec there. But, it's another
     // [Object] method, so it's included here.
@@ skipping 120 matching lines @@
   var v6 = query('input#id');
   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 = resolve(source);
+    LibraryElement library = resolve2(source);
     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(elements[0].propagatedType.name, "AnchorElement");
     expect(elements[1].propagatedType.name, "AnchorElement");
@@ skipping 41 matching lines @@
    * errors and be verifiable.
    *
    * @param code source code to analyze.
    * @param marker marker identifying sought after expression in source code.
    * @return expression marked by the marker.
    * @throws Exception
    */
   SimpleIdentifier _findMarkedIdentifier(String code, String marker) {
     try {
       Source source = addSource(code);
-      LibraryElement library = resolve(source);
+      LibraryElement library = resolve2(source);
       assertNoErrors(source);
       verify([source]);
       CompilationUnit unit = resolveCompilationUnit(source, library);
       // Could generalize this further by making [SimpleIdentifier.class] a
       // parameter.
       return EngineTestCase.findNode(
           unit, code, marker, (node) => node is SimpleIdentifier);
     } catch (exception) {
       // Is there a better exception to throw here? The point is that an
       // assertion failure here should be a failure, in both "test_*" and
@@ skipping 648 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;
   }
 }