Explicitly compute library errors in tests.

pkg/analyzer/test/generated/all_the_rest_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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.all_the_rest_test;
 
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 860 matching lines @@
     DartObject value = result.value;
     expect(value, isNotNull);
     ParameterizedType type = value.type;
     expect(type, isNotNull);
     expect(type.name, "String");
     expect(value.stringValue, expectedValue);
   }
 
   EvaluationResult _getExpressionValue(String contents) {
     Source source = addSource("var x = $contents;");
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, library);
     expect(unit, isNotNull);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember declaration = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration,
         TopLevelVariableDeclaration, declaration);
     NodeList<VariableDeclaration> variables =
         (declaration as TopLevelVariableDeclaration).variables.variables;
@@ skipping 367 matching lines @@
     _evaluateAnnotation(compilationUnit, "C", "f");
   }
 
   void test_computeValues_cycle() {
     TestLogger logger = new TestLogger();
     AnalysisEngine.instance.logger = logger;
     Source librarySource = addSource(r'''
 const int a = c;
 const int b = a;
 const int c = b;''');
-    LibraryElement libraryElement = resolve(librarySource);
+    LibraryElement libraryElement = resolve2(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     analysisContext.computeErrors(librarySource);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit, librarySource, librarySource);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
     expect(members, hasLength(3));
     _validate(false, (members[0] as TopLevelVariableDeclaration).variables);
     _validate(false, (members[1] as TopLevelVariableDeclaration).variables);
     _validate(false, (members[2] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_dependentVariables() {
     Source librarySource = addSource(r'''
 const int b = a;
 const int a = 0;''');
-    LibraryElement libraryElement = resolve(librarySource);
+    LibraryElement libraryElement = resolve2(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit, librarySource, librarySource);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
     expect(members, hasLength(2));
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
     _validate(true, (members[1] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_empty() {
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.computeValues();
   }
 
   void test_computeValues_multipleSources() {
     Source librarySource = addNamedSource("/lib.dart", r'''
 library lib;
 part 'part.dart';
 const int c = b;
 const int a = 0;''');
     Source partSource = addNamedSource("/part.dart", r'''
 part of lib;
 const int b = a;
 const int d = c;''');
-    LibraryElement libraryElement = resolve(librarySource);
+    LibraryElement libraryElement = resolve2(librarySource);
     CompilationUnit libraryUnit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(libraryUnit, isNotNull);
     CompilationUnit partUnit =
         analysisContext.resolveCompilationUnit(partSource, libraryElement);
     expect(partUnit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(libraryUnit, librarySource, librarySource);
     computer.add(partUnit, partSource, librarySource);
     computer.computeValues();
     NodeList<CompilationUnitMember> libraryMembers = libraryUnit.declarations;
     expect(libraryMembers, hasLength(2));
     _validate(
         true, (libraryMembers[0] as TopLevelVariableDeclaration).variables);
     _validate(
         true, (libraryMembers[1] as TopLevelVariableDeclaration).variables);
     NodeList<CompilationUnitMember> partMembers = libraryUnit.declarations;
     expect(partMembers, hasLength(2));
     _validate(true, (partMembers[0] as TopLevelVariableDeclaration).variables);
     _validate(true, (partMembers[1] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_singleVariable() {
     Source librarySource = addSource("const int a = 0;");
-    LibraryElement libraryElement = resolve(librarySource);
+    LibraryElement libraryElement = resolve2(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit, librarySource, librarySource);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
     expect(members, hasLength(1));
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_value_depends_on_enum() {
     Source librarySource = addSource('''
 enum E { id0, id1 }
 const E e = E.id0;
 ''');
-    LibraryElement libraryElement = resolve(librarySource);
+    LibraryElement libraryElement = resolve2(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit, librarySource, librarySource);
     computer.computeValues();
     TopLevelVariableDeclaration declaration = unit.declarations
         .firstWhere((member) => member is TopLevelVariableDeclaration);
     _validate(true, declaration.variables);
   }
@@ skipping 795 matching lines @@
   }
 
   void _assertNullField(Map<String, DartObjectImpl> fields, String fieldName) {
     DartObjectImpl field = fields[fieldName];
     expect(field.isNull, isTrue);
   }
 
   void _assertProperDependencies(String sourceText,
       [List<ErrorCode> expectedErrorCodes = ErrorCode.EMPTY_LIST]) {
     Source source = addSource(sourceText);
-    LibraryElement element = resolve(source);
+    LibraryElement element = resolve2(source);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, element);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit, source, source);
     computer.computeValues();
     assertErrors(source, expectedErrorCodes);
   }
 
   Map<String, DartObjectImpl> _assertType(
@@ skipping 4401 matching lines @@
    *
    * [code] the code to resolve.
    *
    * Returns the result of resolving the AST structure representing the content
    * of the source.
    *
    * Throws if source cannot be verified.
    */
   CompilationUnit _resolveContents(String code) {
     Source source = addSource(code);
-    LibraryElement library = resolve(source);
+    LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     return analysisContext.resolveCompilationUnit(source, library);
   }
 }
 
 @reflectiveTest
 class EnumMemberBuilderTest extends EngineTestCase {
   void test_visitEnumDeclaration_multiple() {
     String firstName = "ONE";
@@ skipping 718 matching lines @@
   var x;
   switch (e) {
     case A:
       x = 'A';
     case B:
       x = 'B';
   }
   return x;
 }
 ''');
-    LibraryElement element = resolve(source);
+    LibraryElement element = resolve2(source);
     CompilationUnit unit = resolveCompilationUnit(source, element);
     FunctionDeclaration function = unit.declarations.last;
     BlockFunctionBody body = function.functionExpression.body;
     Statement statement = body.block.statements[1];
     expect(ExitDetector.exits(statement), false);
   }
 
   void test_switch_withEnum_false_withDefault() {
     Source source = addSource(r'''
 enum E { A, B }
 String f(E e) {
   var x;
   switch (e) {
     case A:
       x = 'A';
     default:
       x = '?';
   }
   return x;
 }
 ''');
-    LibraryElement element = resolve(source);
+    LibraryElement element = resolve2(source);
     CompilationUnit unit = resolveCompilationUnit(source, element);
     FunctionDeclaration function = unit.declarations.last;
     BlockFunctionBody body = function.functionExpression.body;
     Statement statement = body.block.statements[1];
     expect(ExitDetector.exits(statement), false);
   }
 
   void test_switch_withEnum_true_noDefault() {
     Source source = addSource(r'''
 enum E { A, B }
 String f(E e) {
   switch (e) {
     case A:
       return 'A';
     case B:
       return 'B';
   }
 }
 ''');
-    LibraryElement element = resolve(source);
+    LibraryElement element = resolve2(source);
     CompilationUnit unit = resolveCompilationUnit(source, element);
     FunctionDeclaration function = unit.declarations.last;
     BlockFunctionBody body = function.functionExpression.body;
     Statement statement = body.block.statements[0];
     expect(ExitDetector.exits(statement), true);
   }
 
   void test_switch_withEnum_true_withDefault() {
     Source source = addSource(r'''
 enum E { A, B }
 String f(E e) {
   switch (e) {
     case A:
       return 'A';
     default:
       return '?';
   }
 }
 ''');
-    LibraryElement element = resolve(source);
+    LibraryElement element = resolve2(source);
     CompilationUnit unit = resolveCompilationUnit(source, element);
     FunctionDeclaration function = unit.declarations.last;
     BlockFunctionBody body = function.functionExpression.body;
     Statement statement = body.block.statements[0];
     expect(ExitDetector.exits(statement), true);
   }
 }
 
 @reflectiveTest
 class FileBasedSourceTest {
@@ skipping 1346 matching lines @@
     if (_expectedExternalScriptName == null) {
       expect(scriptSource, isNull, reason: "script $scriptIndex");
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(actualExternalScriptName, _expectedExternalScriptName,
           reason: "script $scriptIndex");
     }
   }
 }