Remove many explicit references to AnalysisContextImpl and enable testing of the new task model

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';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/element_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
@@ skipping 49 matching lines @@
  */
 class AnalysisContextFactory {
   static String _DART_MATH = "dart:math";
 
   static String _DART_INTERCEPTORS = "dart:_interceptors";
 
   static String _DART_JS_HELPER = "dart:_js_helper";
 
   /**
    * Create an analysis context that has a fake core library already resolved.
-   *
-   * @return the analysis context that was created
+   * Return the context that was created.
    */
-  static AnalysisContextImpl contextWithCore() {
+  static InternalAnalysisContext contextWithCore() {
+    if (AnalysisEngine.instance.useTaskModel) {
+      NewAnalysisContextForTests context = new NewAnalysisContextForTests();
+      return initContextWithCore(context);
+    }
     AnalysisContextForTests context = new AnalysisContextForTests();
     return initContextWithCore(context);
   }
 
   /**
-   * Create an analysis context that uses the given options and has a fake core library already
-   * resolved.
-   *
-   * @param options the options to be applied to the context
-   * @return the analysis context that was created
+   * Create an analysis context that uses the given [options] and has a fake
+   * core library already resolved. Return the context that was created.
    */
-  static AnalysisContextImpl contextWithCoreAndOptions(
+  static InternalAnalysisContext contextWithCoreAndOptions(
       AnalysisOptions options) {
+    if (AnalysisEngine.instance.useTaskModel) {
+      NewAnalysisContextForTests context = new NewAnalysisContextForTests();
+      context._internalSetAnalysisOptions(options);
+      return initContextWithCore(context);
+    }
     AnalysisContextForTests context = new AnalysisContextForTests();
     context._internalSetAnalysisOptions(options);
     return initContextWithCore(context);
   }
 
   /**
    * Initialize the given analysis context with a fake core library already resolved.
    *
    * @param context the context to be initialized (not `null`)
    * @return the analysis context that was created
    */
-  static AnalysisContextImpl initContextWithCore(AnalysisContextImpl context) {
+  static InternalAnalysisContext initContextWithCore(
+      InternalAnalysisContext context) {
     DirectoryBasedDartSdk sdk = new _AnalysisContextFactory_initContextWithCore(
         new JavaFile("/fake/sdk"));
     SourceFactory sourceFactory =
         new SourceFactory([new DartUriResolver(sdk), new FileUriResolver()]);
     context.sourceFactory = sourceFactory;
     AnalysisContext coreContext = sdk.context;
     //
     // dart:core
     //
     TestTypeProvider provider = new TestTypeProvider();
@@ skipping 222 matching lines @@
     //
     HashMap<Source, LibraryElement> elementMap =
         new HashMap<Source, LibraryElement>();
     elementMap[coreSource] = coreLibrary;
     elementMap[asyncSource] = asyncLibrary;
     elementMap[htmlSource] = htmlLibrary;
     elementMap[mathSource] = mathLibrary;
     context.recordLibraryElements(elementMap);
     return context;
   }
+
+  /**
+   * Create an analysis context that has a fake core library already resolved.
+   * Return the context that was created.
+   */
+  static AnalysisContextImpl oldContextWithCore() {
+    AnalysisContextForTests context = new AnalysisContextForTests();
+    return initContextWithCore(context);
+  }
+
+  /**
+   * Create an analysis context that uses the given [options] and has a fake
+   * core library already resolved. Return the context that was created.
+   */
+  static AnalysisContextImpl oldContextWithCoreAndOptions(
+      AnalysisOptions options) {
+    AnalysisContextForTests context = new AnalysisContextForTests();
+    context._internalSetAnalysisOptions(options);
+    return initContextWithCore(context);
+  }
 }
 
 /**
  * Instances of the class `AnalysisContextForTests` implement an analysis context that has a
  * fake SDK that is much smaller and faster for testing purposes.
  */
 class AnalysisContextForTests extends AnalysisContextImpl {
   @override
   void set analysisOptions(AnalysisOptions options) {
     AnalysisOptions currentOptions = analysisOptions;
@@ skipping 46 matching lines @@
   }
 }
 
 /**
  * Helper for creating and managing single [AnalysisContext].
  */
 class AnalysisContextHelper {
   AnalysisContext context;
 
   /**
-   * Creates new [AnalysisContext] using [AnalysisContextFactory.contextWithCore].
+   * Creates new [AnalysisContext] using [AnalysisContextFactory].
    */
   AnalysisContextHelper([AnalysisOptionsImpl options]) {
     if (options == null) {
       options = new AnalysisOptionsImpl();
     }
     options.cacheSize = 256;
     context = AnalysisContextFactory.contextWithCoreAndOptions(options);
   }
 
   Source addSource(String path, String code) {
@@ skipping 1455 matching lines @@
         0] as NamedExpression).name.label.staticElement, same(parameter));
     _listener.assertNoErrors();
   }
 
   /**
    * Create the resolver used by the tests.
    *
    * @return the resolver that was created
    */
   ElementResolver _createResolver() {
-    AnalysisContextImpl context = new AnalysisContextImpl();
-    SourceFactory sourceFactory = new SourceFactory(
-        [new DartUriResolver(DirectoryBasedDartSdk.defaultSdk)]);
-    context.sourceFactory = sourceFactory;
+    InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     FileBasedSource source =
         new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     CompilationUnitElementImpl definingCompilationUnit =
         new CompilationUnitElementImpl("test.dart");
     definingCompilationUnit.librarySource =
         definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
     Library library = new Library(context, _listener, source);
     library.libraryElement = _definingLibrary;
@@ skipping 3797 matching lines @@
   void _assertNoErrors(ClassElement classElt) {
     _assertErrors(classElt);
   }
 
   /**
    * Create the inheritance manager used by the tests.
    *
    * @return the inheritance manager that was created
    */
   InheritanceManager _createInheritanceManager() {
-    AnalysisContextImpl context = AnalysisContextFactory.contextWithCore();
+    AnalysisContext context = AnalysisContextFactory.contextWithCore();
     FileBasedSource source =
         new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     CompilationUnitElementImpl definingCompilationUnit =
         new CompilationUnitElementImpl("test.dart");
     definingCompilationUnit.librarySource =
         definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
     return new InheritanceManager(_definingLibrary);
   }
 }
 
 @reflectiveTest
 class LibraryElementBuilderTest extends EngineTestCase {
   /**
    * The analysis context used to analyze sources.
    */
-  AnalysisContextImpl _context;
+  InternalAnalysisContext _context;
 
   /**
    * Add a source file to the content provider. The file path should be absolute.
    *
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addSource(String filePath, String contents) {
     Source source = new FileBasedSource(FileUtilities2.createFile(filePath));
     _context.setContents(source, contents);
     return source;
   }
 
   @override
   void setUp() {
-    SourceFactory sourceFactory = new SourceFactory([
-      new DartUriResolver(DirectoryBasedDartSdk.defaultSdk),
-      new FileUriResolver()
-    ]);
-    _context = new AnalysisContextImpl();
-    _context.sourceFactory = sourceFactory;
+    _context = AnalysisContextFactory.contextWithCore();
   }
 
   @override
   void tearDown() {
     _context = null;
     super.tearDown();
   }
 
   void test_accessorsAcrossFiles() {
     Source librarySource = addSource("/lib.dart", r'''
@@ skipping 139 matching lines @@
     GatheringErrorListener listener = new GatheringErrorListener();
     listener.addAll2(resolver.errorListener);
     listener.assertErrorsWithCodes(expectedErrorCodes);
     return element;
   }
 }
 
 @reflectiveTest
 class LibraryImportScopeTest extends ResolverTestCase {
   void test_conflictingImports() {
-    AnalysisContext context = new AnalysisContextImpl();
-    context.sourceFactory = new SourceFactory([]);
+    AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String typeNameA = "A";
     String typeNameB = "B";
     String typeNameC = "C";
     ClassElement typeA = ElementFactory.classElement2(typeNameA);
     ClassElement typeB1 = ElementFactory.classElement2(typeNameB);
     ClassElement typeB2 = ElementFactory.classElement2(typeNameB);
     ClassElement typeC = ElementFactory.classElement2(typeNameC);
     LibraryElement importedLibrary1 = createTestLibrary(context, "imported1");
     (importedLibrary1.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[typeA, typeB1];
@@ skipping 45 matching lines @@
     }
   }
 
   void test_creation_empty() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     new LibraryImportScope(definingLibrary, errorListener);
   }
 
   void test_creation_nonEmpty() {
-    AnalysisContext context = new AnalysisContextImpl();
-    context.sourceFactory = new SourceFactory([]);
+    AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String importedTypeName = "A";
     ClassElement importedType =
         new ClassElementImpl.forNode(AstFactory.identifier3(importedTypeName));
     LibraryElement importedLibrary = createTestLibrary(context, "imported");
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[importedType];
     LibraryElementImpl definingLibrary =
         createTestLibrary(context, "importing");
     ImportElementImpl importElement = new ImportElementImpl(0);
     importElement.importedLibrary = importedLibrary;
@@ skipping 30 matching lines @@
     importingLibrary.imports = <ImportElement>[importCore, importLib];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
     expect(
         scope.lookup(AstFactory.identifier3(typeName), importingLibrary), type);
     errorListener
         .assertErrorsWithCodes([StaticWarningCode.CONFLICTING_DART_IMPORT]);
   }
 
   void test_nonConflictingImports_sameElement() {
-    AnalysisContext context = new AnalysisContextImpl();
-    context.sourceFactory = new SourceFactory([]);
+    AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String typeNameA = "A";
     String typeNameB = "B";
     ClassElement typeA = ElementFactory.classElement2(typeNameA);
     ClassElement typeB = ElementFactory.classElement2(typeNameB);
     LibraryElement importedLibrary = createTestLibrary(context, "imported");
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[typeA, typeB];
     ImportElementImpl import1 = ElementFactory.importFor(importedLibrary, null);
     ImportElementImpl import2 = ElementFactory.importFor(importedLibrary, null);
     LibraryElementImpl importingLibrary =
         createTestLibrary(context, "importing");
     importingLibrary.imports = <ImportElement>[import1, import2];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
     expect(scope.lookup(AstFactory.identifier3(typeNameA), importingLibrary),
         typeA);
     errorListener.assertNoErrors();
     expect(scope.lookup(AstFactory.identifier3(typeNameB), importingLibrary),
         typeB);
     errorListener.assertNoErrors();
   }
 
   void test_prefixedAndNonPrefixed() {
-    AnalysisContext context = new AnalysisContextImpl();
-    context.sourceFactory = new SourceFactory([]);
+    AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String typeName = "C";
     String prefixName = "p";
     ClassElement prefixedType = ElementFactory.classElement2(typeName);
     ClassElement nonPrefixedType = ElementFactory.classElement2(typeName);
     LibraryElement prefixedLibrary =
         createTestLibrary(context, "import.prefixed");
     (prefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[prefixedType];
     ImportElementImpl prefixedImport = ElementFactory.importFor(
         prefixedLibrary, ElementFactory.prefix(prefixName));
@@ skipping 120 matching lines @@
 
 @reflectiveTest
 class LibraryScopeTest extends ResolverTestCase {
   void test_creation_empty() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     new LibraryScope(definingLibrary, errorListener);
   }
 
   void test_creation_nonEmpty() {
-    AnalysisContext context = new AnalysisContextImpl();
-    context.sourceFactory = new SourceFactory([]);
+    AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String importedTypeName = "A";
     ClassElement importedType =
         new ClassElementImpl.forNode(AstFactory.identifier3(importedTypeName));
     LibraryElement importedLibrary = createTestLibrary(context, "imported");
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[importedType];
     LibraryElementImpl definingLibrary =
         createTestLibrary(context, "importing");
     ImportElementImpl importElement = new ImportElementImpl(0);
     importElement.importedLibrary = importedLibrary;
@@ skipping 14 matching lines @@
 }
 
 @reflectiveTest
 class LibraryTest extends EngineTestCase {
   /**
    * The error listener to which all errors will be reported.
    */
   GatheringErrorListener _errorListener;
 
   /**
-   * The source factory used to create libraries.
-   */
-  SourceFactory _sourceFactory;
-
-  /**
    * The analysis context to pass in to all libraries created by the tests.
    */
-  AnalysisContextImpl _analysisContext;
+  InternalAnalysisContext _analysisContext;
 
   /**
    * The library used by the tests.
    */
   Library _library;
 
   @override
   void setUp() {
-    _sourceFactory = new SourceFactory([new FileUriResolver()]);
-    _analysisContext = new AnalysisContextImpl();
-    _analysisContext.sourceFactory = _sourceFactory;
+    _analysisContext = AnalysisContextFactory.contextWithCore();
     _errorListener = new GatheringErrorListener();
     _library = _createLibrary("/lib.dart");
   }
 
   @override
   void tearDown() {
     _errorListener = null;
-    _sourceFactory = null;
     _analysisContext = null;
     _library = null;
     super.tearDown();
   }
 
   void test_getExplicitlyImportsCore() {
     expect(_library.explicitlyImportsCore, isFalse);
     _errorListener.assertNoErrors();
   }
 
@@ skipping 103 matching lines @@
   void test_MemberMap_put() {
     MethodElement m1 = ElementFactory.methodElement("m1", _nullType);
     MemberMap map = new MemberMap();
     expect(map.size, 0);
     map.put(m1.name, m1);
     expect(map.size, 1);
     expect(map.get("m1"), m1);
   }
 }
 
+/**
+ * An analysis context that has a fake SDK that is much smaller and faster for
+ * testing purposes.
+ */
+class NewAnalysisContextForTests extends newContext.AnalysisContextImpl {
+  @override
+  void set analysisOptions(AnalysisOptions options) {
+    AnalysisOptions currentOptions = analysisOptions;
+    bool needsRecompute = currentOptions.analyzeFunctionBodiesPredicate !=
+            options.analyzeFunctionBodiesPredicate ||
+        currentOptions.generateImplicitErrors !=
+            options.generateImplicitErrors ||
+        currentOptions.generateSdkErrors != options.generateSdkErrors ||
+        currentOptions.dart2jsHint != options.dart2jsHint ||
+        (currentOptions.hint && !options.hint) ||
+        currentOptions.preserveComments != options.preserveComments ||
+        currentOptions.enableNullAwareOperators !=
+            options.enableNullAwareOperators ||
+        currentOptions.enableStrictCallChecks != options.enableStrictCallChecks;
+    if (needsRecompute) {
+      fail(
+          "Cannot set options that cause the sources to be reanalyzed in a test context");
+    }
+    super.analysisOptions = options;
+  }
+
+  @override
+  bool exists(Source source) =>
+      super.exists(source) || sourceFactory.dartSdk.context.exists(source);
+
+  @override
+  TimestampedData<String> getContents(Source source) {
+    if (source.isInSystemLibrary) {
+      return sourceFactory.dartSdk.context.getContents(source);
+    }
+    return super.getContents(source);
+  }
+
+  @override
+  int getModificationStamp(Source source) {
+    if (source.isInSystemLibrary) {
+      return sourceFactory.dartSdk.context.getModificationStamp(source);
+    }
+    return super.getModificationStamp(source);
+  }
+
+  /**
+   * Set the analysis options, even if they would force re-analysis. This method should only be
+   * invoked before the fake SDK is initialized.
+   *
+   * @param options the analysis options to be set
+   */
+  void _internalSetAnalysisOptions(AnalysisOptions options) {
+    super.analysisOptions = options;
+  }
+}
+
 @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);
     assertNoErrors(source);
@@ skipping 1260 matching lines @@
       buffer.write(identifier.offset);
       buffer.writeln(")");
     }
   }
 }
 
 class ResolverTestCase extends EngineTestCase {
   /**
    * The analysis context used to parse the compilation units being resolved.
    */
-  AnalysisContextImpl analysisContext2;
+  InternalAnalysisContext analysisContext2;
 
   /**
    * Specifies if [assertErrors] should check for [HintCode.UNUSED_ELEMENT] and
    * [HintCode.UNUSED_FIELD].
    */
   bool enableUnusedElement = false;
 
   /**
    * Specifies if [assertErrors] should check for [HintCode.UNUSED_LOCAL_VARIABLE].
    */
@@ skipping 89 matching lines @@
     return source;
   }
 
   /**
    * 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(new AnalysisContextImpl(), "test");
+      createTestLibrary(AnalysisContextFactory.contextWithCore(), "test");
 
   /**
    * Create a library element that represents a library with the given name containing a single
    * empty compilation unit.
    *
    * @param libraryName the name of the library to be created
    * @return the library element that was created
    */
   LibraryElementImpl createTestLibrary(
       AnalysisContext context, String libraryName, [List<String> typeNames]) {
@@ skipping 3202 matching lines @@
     // TODO(brianwilkerson) Compare other kinds of types then make this a shared
     // utility method.
   }
 
   /**
    * Create the analyzer used by the tests.
    *
    * @return the analyzer to be used by the tests
    */
   StaticTypeAnalyzer _createAnalyzer() {
-    AnalysisContextImpl context = new AnalysisContextImpl();
-    SourceFactory sourceFactory = new SourceFactory(
-        [new DartUriResolver(DirectoryBasedDartSdk.defaultSdk)]);
-    context.sourceFactory = sourceFactory;
+    InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     FileBasedSource source =
         new FileBasedSource(FileUtilities2.createFile("/lib.dart"));
     CompilationUnitElementImpl definingCompilationUnit =
         new CompilationUnitElementImpl("lib.dart");
     definingCompilationUnit.librarySource =
         definingCompilationUnit.source = source;
     LibraryElementImpl definingLibrary =
         new LibraryElementImpl.forNode(context, null);
     definingLibrary.definingCompilationUnit = definingCompilationUnit;
     Library library = new Library(context, _listener, source);
@@ skipping 484 matching lines @@
   SubtypeManager _subtypeManager;
 
   /**
    * The compilation unit element containing all of the types setup in each test.
    */
   CompilationUnitElementImpl _definingCompilationUnit;
 
   @override
   void setUp() {
     super.setUp();
-    AnalysisContextImpl context = AnalysisContextFactory.contextWithCore();
+    AnalysisContext context = AnalysisContextFactory.contextWithCore();
     FileBasedSource source =
         new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     _definingCompilationUnit = new CompilationUnitElementImpl("test.dart");
     _definingCompilationUnit.librarySource =
         _definingCompilationUnit.source = source;
     LibraryElementImpl definingLibrary =
         ElementFactory.library(context, "test");
     definingLibrary.definingCompilationUnit = _definingCompilationUnit;
     _subtypeManager = new SubtypeManager();
   }
@@ skipping 1687 matching lines @@
       mapType.element,
       objectType.element,
       stackTraceType.element,
       stringType.element,
       symbolType.element,
       typeType.element
     ];
     CompilationUnitElementImpl asyncUnit =
         new CompilationUnitElementImpl("async.dart");
     asyncUnit.types = <ClassElement>[futureType.element, streamType.element];
-    AnalysisContextImpl context = new AnalysisContextImpl();
+    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     LibraryElementImpl coreLibrary = new LibraryElementImpl.forNode(
         context, AstFactory.libraryIdentifier2(["dart.core"]));
     coreLibrary.definingCompilationUnit = coreUnit;
     LibraryElementImpl asyncLibrary = new LibraryElementImpl.forNode(
         context, AstFactory.libraryIdentifier2(["dart.async"]));
     asyncLibrary.definingCompilationUnit = asyncUnit;
     //
     // Create a type provider and ensure that it can return the expected types.
     //
     TypeProviderImpl provider = new TypeProviderImpl(coreLibrary, asyncLibrary);
@@ skipping 102 matching lines @@
     VariableDeclaration node = AstFactory.variableDeclaration("a");
     AstFactory.variableDeclarationList(null, AstFactory.typeName(type), [node]);
     //resolve(node);
     expect(node.name.staticType, same(type.type));
     _listener.assertNoErrors();
   }
 
   @override
   void setUp() {
     _listener = new GatheringErrorListener();
-    SourceFactory factory = new SourceFactory([new FileUriResolver()]);
-    AnalysisContextImpl context = new AnalysisContextImpl();
-    context.sourceFactory = factory;
+    InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     Source librarySource =
         new FileBasedSource(FileUtilities2.createFile("/lib.dart"));
     _library = new Library(context, _listener, librarySource);
     LibraryElementImpl element = new LibraryElementImpl.forNode(
         context, AstFactory.libraryIdentifier2(["lib"]));
     element.definingCompilationUnit =
         new CompilationUnitElementImpl("lib.dart");
     _library.libraryElement = element;
     _typeProvider = new TestTypeProvider();
     _visitor =
@@ skipping 462 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;
   }
 }