Run the most of error generating 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';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/error.dart';
+import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
+import 'package:analyzer/source/package_map_resolver.dart';
+import 'package:analyzer/src/dart/analysis/byte_store.dart';
+import 'package:analyzer/src/dart/analysis/driver.dart';
+import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/error/codes.dart';
-import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/engine.dart' hide AnalysisResult;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:test/test.dart';
 
+import '../src/dart/analysis/physical_sdk.dart' as physical_sdk;
 import 'analysis_context_factory.dart';
 import 'test_support.dart';
 
 /**
  * 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> {
   /**
    * A set containing nodes that are known to not be resolvable and should
@@ skipping 283 matching lines @@
    */
   bool enableUnusedElement = false;
 
   /**
    * Specifies if [assertErrors] should check for [HintCode.UNUSED_LOCAL_VARIABLE].
    */
   bool enableUnusedLocalVariable = false;
 
   final Map<Source, TestAnalysisResult> analysisResults = {};
 
+  StringBuffer _logBuffer = new StringBuffer();
+  FileContentOverlay _fileContentOverlay = new FileContentOverlay();
+  AnalysisDriver driver;
+
   AnalysisContext get analysisContext => analysisContext2;
 
+  bool get enableNewAnalysisDriver => false;
+
   /**
    * Return a type provider that can be used to test the results of resolution.
    *
    * @return a type provider
    * @throws AnalysisException if dart:core cannot be resolved
    */
-  TypeProvider get typeProvider => analysisContext2.typeProvider;
+  TypeProvider get typeProvider {
+    if (enableNewAnalysisDriver) {
+      return driver.sourceFactory.dartSdk.context.typeProvider;
+    } else {
+      return analysisContext2.typeProvider;
+    }
+  }
 
   /**
    * Return a type system that can be used to test the results of resolution.
    *
    * @return a type system
    */
   TypeSystem get typeSystem => analysisContext2.typeSystem;
 
   /**
    * Add a source file with the given [filePath] in the root of the file system.
    * The file path should be absolute. The file will have the given [contents]
    * set in the content provider. Return the source representing the added file.
    */
   Source addNamedSource(String filePath, String contents) {
-    Source source =
-        cacheSource(resourceProvider.convertPath(filePath), contents);
-    ChangeSet changeSet = new ChangeSet();
-    changeSet.addedSource(source);
-    analysisContext2.applyChanges(changeSet);
+    filePath = resourceProvider.convertPath(filePath);
+    File file = resourceProvider.newFile(filePath, contents);
+    Source source = file.createSource();
+    if (enableNewAnalysisDriver) {
+      driver.addFile(filePath);
+    } else {
+      analysisContext2.setContents(source, contents);
+      ChangeSet changeSet = new ChangeSet();
+      changeSet.addedSource(source);
+      analysisContext2.applyChanges(changeSet);
+    }
     return source;
   }
 
   /**
    * Add a source file named 'test.dart' in the root of the file system. The
    * file will have the given [contents] set in the content provider. Return the
    * source representing the added file.
    */
   Source addSource(String contents) => addNamedSource("/test.dart", contents);
 
@@ skipping 109 matching lines @@
       DartType expectedStaticType, DartType expectedPropagatedType) async {
     SimpleIdentifier identifier =
         await findMarkedIdentifier(code, "; // marker");
     if (expectedStaticType != null) {
       expect(identifier.staticType, expectedStaticType);
     }
     expect(identifier.propagatedType, expectedPropagatedType);
   }
 
   /**
-   * Cache the [contents] for the file at the given [filePath] but don't add the
-   * source to the analysis context. The file path must be absolute.
-   */
-  Source cacheSource(String filePath, String contents) {
-    Source source = resourceProvider.getFile(filePath).createSource();
-    analysisContext2.setContents(source, contents);
-    return source;
-  }
-
-  /**
    * 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 {
-    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);
+    if (enableNewAnalysisDriver) {
+      AnalysisResult result = await driver.getResult(source.fullName);
+      analysisResults[source] =
+          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);
+      }
     }
   }
 
   /**
    * 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() =>
@@ skipping 57 matching lines @@
    *
    * @param code source code to analyze.
    * @param marker marker identifying sought after expression in source code.
    * @return expression marked by the marker.
    * @throws Exception
    */
   Future<SimpleIdentifier> findMarkedIdentifier(
       String code, String marker) async {
     try {
       Source source = addSource(code);
-      LibraryElement library = resolve2(source);
       await computeAnalysisResult(source);
       assertNoErrors(source);
       verify([source]);
-      CompilationUnit unit = resolveCompilationUnit(source, library);
-      // Could generalize this further by making [SimpleIdentifier.class] a
-      // parameter.
+      CompilationUnit unit = analysisResults[source].unit;
       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
       // "fail_*" tests. However, an assertion failure is success for the
       // purpose of "fail_*" tests, so without catching them here "fail_*" tests
       // can succeed by failing for the wrong reason.
       throw new StateError("Unexpected assertion failure: $exception");
     }
   }
 
   Expression findTopLevelConstantExpression(
           CompilationUnit compilationUnit, String name) =>
       findTopLevelDeclaration(compilationUnit, name).initializer;
-
   VariableDeclaration findTopLevelDeclaration(
       CompilationUnit compilationUnit, String name) {
     for (CompilationUnitMember member in compilationUnit.declarations) {
       if (member is TopLevelVariableDeclaration) {
         for (VariableDeclaration variable in member.variables.variables) {
           if (variable.name.name == name) {
             return variable;
           }
         }
       }
     }
     return null;
     // Not found
   }
 
   /**
    * Re-create the analysis context being used by the test case.
    */
-  void reset() {
-    analysisContext2 = AnalysisContextFactory.contextWithCore(
-        resourceProvider: resourceProvider);
+  void reset({List<List<String>> packages}) {
+    if (enableNewAnalysisDriver) {
+      PerformanceLog log = new PerformanceLog(_logBuffer);
+      AnalysisDriverScheduler scheduler = new AnalysisDriverScheduler(log);
+
+      List<UriResolver> resolvers = <UriResolver>[
+        new DartUriResolver(physical_sdk.sdk),
+        new ResourceUriResolver(resourceProvider)
+      ];
+      if (packages != null) {
+        var packageMap = <String, List<Folder>>{};
+        packages.forEach((args) {
+          String name = args[0];
+          String path =
+              resourceProvider.convertPath('/packages/$name/$name.dart');
+          String content = args[1];
+          File file = resourceProvider.newFile(path, content);
+          packageMap[name] = <Folder>[file.parent];
+        });
+        resolvers.add(new PackageMapUriResolver(resourceProvider, packageMap));
+      }
+      SourceFactory sourceFactory = new SourceFactory(resolvers);
+
+      driver = new AnalysisDriver(
+          scheduler,
+          log,
+          resourceProvider,
+          new MemoryByteStore(),
+          _fileContentOverlay,
+          sourceFactory,
+          new AnalysisOptionsImpl());
+      scheduler.start();
+    } else {
+      if (packages != null) {
+        var packageMap = <String, String>{};
+        packages.forEach((args) {
+          String name = args[0];
+          String content = args[1];
+          packageMap['package:$name/$name.dart'] = content;
+        });
+        analysisContext2 = AnalysisContextFactory.contextWithCoreAndPackages(
+            packageMap,
+            resourceProvider: resourceProvider);
+      } else {
+        analysisContext2 = AnalysisContextFactory.contextWithCore(
+            resourceProvider: resourceProvider);
+      }
+    }
   }
 
   /**
    * Re-create the analysis context being used by the test case and set the
    * [options] in the newly created context to the given [options].
    */
   void resetWithOptions(AnalysisOptions options) {
-    analysisContext2 = AnalysisContextFactory.contextWithCoreAndOptions(options,
-        resourceProvider: resourceProvider);
+    // TODO(scheglov) remove duplication
+    if (enableNewAnalysisDriver) {
+      PerformanceLog log = new PerformanceLog(_logBuffer);
+      AnalysisDriverScheduler scheduler = new AnalysisDriverScheduler(log);
+
+      List<UriResolver> resolvers = <UriResolver>[
+        new DartUriResolver(
+            options.strongMode ? physical_sdk.strongSdk : physical_sdk.sdk),
+        new ResourceUriResolver(resourceProvider)
+      ];
+      SourceFactory sourceFactory = new SourceFactory(resolvers);
+      driver = new AnalysisDriver(scheduler, log, resourceProvider,
+          new MemoryByteStore(), _fileContentOverlay, sourceFactory, options);
+      scheduler.start();
+    } else {
+      analysisContext2 = AnalysisContextFactory.contextWithCoreAndOptions(
+          options,
+          resourceProvider: resourceProvider);
+    }
   }
 
   /**
    * 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
@@ skipping 205 matching lines @@
     }
   }
 }
 
 class TestAnalysisResult {
   final Source source;
   final CompilationUnit unit;
   final List<AnalysisError> errors;
   TestAnalysisResult(this.source, this.unit, this.errors);
 }