Remove computeLibrarySourceErrors().

pkg/analyzer/test/generated/simple_resolver_test.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.test.generated.simple_resolver_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 379 matching lines @@
   }
 
   void test_class_definesCall() {
     Source source = addSource(r'''
 class A {
   int call(int x) { return x; }
 }
 int f(A a) {
   return a(0);
 }''');
-    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 {}''');
-    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() {}
 }''');
-    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_commentReference_parameter() {
     Source source = addSource(r'''
 class A {
   A() {}
   A.n() {}
   /** [e] [f] */
   m(e, f()) {}
 }''');
-    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_commentReference_singleLine() {
     Source source = addSource(r'''
 /// [A]
 class A {}''');
-    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("");
-    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_exported() {
     addNamedSource(
         "/two.dart",
         r'''
 library two;
 main() {}''');
@@ skipping 39 matching lines @@
     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;
 }''');
-    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]) {}
 }''');
-    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameter() {
     Source source = addSource(r'''
 class A {
   int x;
   int y;
   A(this.x) : y = x {}
 }''');
     CompilationUnit unit =
         analysisContext2.resolveCompilationUnit2(source, source);
     ClassDeclaration classA = unit.declarations[0];
     FieldDeclaration field = classA.members[0];
     ConstructorDeclaration constructor = classA.members[2];
     ParameterElement paramElement =
         constructor.parameters.parameters[0].element;
     expect(paramElement, new isInstanceOf<FieldFormalParameterElement>());
     expect((paramElement as FieldFormalParameterElement).field,
         field.fields.variables[0].element);
     ConstructorFieldInitializer initializer = constructor.initializers[0];
     SimpleIdentifier identifierX = initializer.expression;
     expect(identifierX.staticElement, paramElement);
 
-    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) {}
 }''');
-    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++) {
   }
 }''');
-    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)) {}
   }
 }''');
-    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) {}
@@ skipping 135 matching lines @@
 
   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();
 }''');
-    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 = resolve2(source);
@@ skipping 23 matching lines @@
     Source source = addNamedSource(
         "/lib3.dart",
         r'''
 import 'lib1.dart' hide foo;
 import 'lib2.dart';
 
 main() {
   foo = 0;
 }
 A a;''');
-    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);
 }''');
-    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_prefix_doesNotExist() {
     //
     // The primary purpose of this test is to ensure that we are only getting a
     // single error generated when the only problem is that an imported file
     // does not exist.
     //
     Source source = addNamedSource(
         "/a.dart",
         r'''
 import 'missing.dart' as p;
 int a = p.q + p.r.s;
 String b = p.t(a) + p.u(v: 0);
 p.T c = new p.T();
 class D<E> extends p.T {
   D(int i) : super(i);
   p.U f = new p.V();
 }
 class F implements p.T {
   p.T m(p.U u) => null;
 }
 class G extends Object with p.V {}
 class H extends D<p.W> {
   H(int i) : super(i);
 }
 ''');
-    computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
     verify([source]);
   }
 
   void test_import_show_doesNotExist() {
     //
     // The primary purpose of this test is to ensure that we are only getting a
     // single error generated when the only problem is that an imported file
     // does not exist.
     //
     Source source = addNamedSource(
         "/a.dart",
         r'''
 import 'missing.dart' show q, r, t, u, T, U, V, W;
 int a = q + r.s;
 String b = t(a) + u(v: 0);
 T c = new T();
 class D<E> extends T {
   D(int i) : super(i);
   U f = new V();
 }
 class F implements T {
   T m(U u) => null;
 }
 class G extends Object with V {}
 class H extends D<W> {
   H(int i) : super(i);
 }
 ''');
-    computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
     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();
 }''');
-    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];
 }''');
-    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_indexExpression_typeParameters_invalidAssignmentWarning() {
     Source source = addSource(r'''
 f() {
   List<List<int>> b;
   b[0][0] = 'hi';
 }''');
-    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]);
 }''');
-    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;
   }
 }''');
-    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_badSuperclass() {
     Source source = addSource(r'''
 class A extends B {}
 class B {}
 class C = Object with A;''');
     LibraryElement library = resolve2(source);
@@ skipping 424 matching lines @@
   bar() => 1;
 }
 class A {
   foo() => 2;
 }
 
 class C extends B with A {
   bar() => super.bar();
   foo() => super.foo();
 }''');
-    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_method_fromMixins() {
     Source source = addSource('''
 class B {}
 class M1 {
   void f() {}
 }
@@ skipping 92 matching lines @@
 class A {
   void m1() {}
 }
 class B extends Object with A {
 }
 class C extends B {
 }
 f(C c) {
   c.m1();
 }''');
-    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();
   }
 }''');
-    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();
   }
 }''');
-    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;
 }''');
-    computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_setter_fromMixins_bare_identifier() {
     Source source = addSource('''
 class B {}
 class M1 {
   set x(value) {}
 }
 class M2 {
@@ skipping 60 matching lines @@
   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;
 }''');
-    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_setter_static() {
     Source source = addSource(r'''
 set s(x) {
 }
 
 main() {
   s = 123;
 }''');
-    computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   @failingTest
   void test_staticInvocation() {
     Source source = addSource(r'''
 class A {
   static int get g => (a,b) => 0;
 }
 class B {
   f() {
     A.g(1,0);
   }
 }''');
-    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
@@ skipping 65 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;
   }
 }