Run more analysis tests with the new analysis driver.

pkg/analyzer/test/generated/resolver_test_case.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.resolver_test_case;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 499 matching lines @@
   /**
    * Change the contents of the given [source] to the given [contents].
    */
   void changeSource(Source source, String contents) {
     analysisContext2.setContents(source, contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedSource(source);
     analysisContext2.applyChanges(changeSet);
   }
 
-  Future<Null> computeAnalysisResult(Source source) async {
+  Future<TestAnalysisResult> computeAnalysisResult(Source source) async {
+    TestAnalysisResult analysisResult;
     if (enableNewAnalysisDriver) {
       AnalysisResult result = await driver.getResult(source.fullName);
-      analysisResults[source] =
+      analysisResult =
           new TestAnalysisResult(source, result.unit, result.errors);
     } else {
       analysisContext2.computeKindOf(source);
       List<Source> libraries = analysisContext2.getLibrariesContaining(source);
       if (libraries.length > 0) {
         CompilationUnit unit =
             analysisContext.resolveCompilationUnit2(source, libraries.first);
         List<AnalysisError> errors = analysisContext.computeErrors(source);
-        analysisResults[source] = new TestAnalysisResult(source, unit, errors);
+        analysisResult = new TestAnalysisResult(source, unit, errors);
       }
     }
+    analysisResults[source] = analysisResult;
+    return analysisResult;
   }
 
   /**
    * 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");
@@ skipping 364 matching lines @@
 
   SimpleIdentifier findIdentifier(String search) {
     SimpleIdentifier identifier = EngineTestCase.findNode(
         testUnit, testCode, search, (node) => node is SimpleIdentifier);
     return identifier;
   }
 
   Future<Null> resolveTestUnit(String code) async {
     testCode = code;
     testSource = addSource(testCode);
-    LibraryElement library = resolve2(testSource);
-    await computeAnalysisResult(testSource);
+    TestAnalysisResult analysisResult = await computeAnalysisResult(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
-    testUnit = resolveCompilationUnit(testSource, library);
+    testUnit = analysisResult.unit;
   }
 
   /**
    * Validates that [type] matches [expected].
    *
    * If [expected] is a string, validates that the type stringifies to that
    * text. Otherwise, [expected] is used directly a [Matcher] to match the type.
    */
   _expectType(DartType type, expected) {
     if (expected is String) {
       expect(type.toString(), expected);
     } else {
       expect(type, expected);
     }
   }
 }
 
 class TestAnalysisResult {
   final Source source;
   final CompilationUnit unit;
   final List<AnalysisError> errors;
   TestAnalysisResult(this.source, this.unit, this.errors);
 }