Remove the old 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/context/context.dart';
 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 17 matching lines @@
 main() {
   initializeTestEnvironment();
   runReflectiveTests(AnalysisDeltaTest);
   runReflectiveTests(ChangeSetTest);
   runReflectiveTests(EnclosedScopeTest);
   runReflectiveTests(LibraryImportScopeTest);
   runReflectiveTests(LibraryScopeTest);
   runReflectiveTests(ScopeTest);
   runReflectiveTests(ElementResolverTest);
   runReflectiveTests(InheritanceManagerTest);
-  if (!AnalysisEngine.instance.useTaskModel) {
-    runReflectiveTests(LibraryElementBuilderTest);
-  }
-  if (!AnalysisEngine.instance.useTaskModel) {
-    runReflectiveTests(LibraryResolver2Test);
-  }
-  if (!AnalysisEngine.instance.useTaskModel) {
-    runReflectiveTests(LibraryResolverTest);
-  }
   runReflectiveTests(LibraryTest);
   runReflectiveTests(StaticTypeAnalyzerTest);
   runReflectiveTests(StaticTypeAnalyzer2Test);
   runReflectiveTests(SubtypeManagerTest);
   runReflectiveTests(TypeOverrideManagerTest);
   runReflectiveTests(TypeProviderImplTest);
   runReflectiveTests(TypeResolverVisitorTest);
   runReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
   runReflectiveTests(ErrorResolverTest);
   runReflectiveTests(HintCodeTest);
@@ skipping 16 matching lines @@
 
   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 context that was created.
    */
   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. Return the context that was created.
    */
   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
@@ skipping 282 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.
+ * 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;
     bool needsRecompute = currentOptions.analyzeFunctionBodiesPredicate !=
             options.analyzeFunctionBodiesPredicate ||
         currentOptions.generateImplicitErrors !=
             options.generateImplicitErrors ||
         currentOptions.generateSdkErrors != options.generateSdkErrors ||
@@ skipping 5611 matching lines @@
         new CompilationUnitElementImpl("test.dart");
     definingCompilationUnit.librarySource =
         definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
     return new InheritanceManager(_definingLibrary);
   }
 }
 
 @reflectiveTest
-class LibraryElementBuilderTest {
-  /**
-   * The analysis context used to analyze sources.
-   */
-  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;
-  }
-
-  void setUp() {
-    _context = AnalysisContextFactory.contextWithCore();
-  }
-
-  void tearDown() {
-    _context = null;
-  }
-
-  void test_accessorsAcrossFiles() {
-    Source librarySource = addSource(
-        "/lib.dart",
-        r'''
-library lib;
-part 'first.dart';
-part 'second.dart';''');
-    addSource(
-        "/first.dart",
-        r'''
-part of lib;
-int get V => 0;''');
-    addSource(
-        "/second.dart",
-        r'''
-part of lib;
-void set V(int v) {}''');
-    LibraryElement element = _buildLibrary(librarySource);
-    expect(element, isNotNull);
-    List<CompilationUnitElement> sourcedUnits = element.parts;
-    expect(sourcedUnits, hasLength(2));
-    List<PropertyAccessorElement> firstAccessors = sourcedUnits[0].accessors;
-    expect(firstAccessors, hasLength(1));
-    List<PropertyAccessorElement> secondAccessors = sourcedUnits[1].accessors;
-    expect(secondAccessors, hasLength(1));
-    expect(secondAccessors[0].variable, same(firstAccessors[0].variable));
-  }
-
-  void test_empty() {
-    Source librarySource = addSource("/lib.dart", "library lib;");
-    LibraryElement element = _buildLibrary(librarySource);
-    expect(element, isNotNull);
-    expect(element.name, "lib");
-    expect(element.entryPoint, isNull);
-    expect(element.importedLibraries, hasLength(0));
-    expect(element.imports, hasLength(0));
-    expect(element.library, same(element));
-    expect(element.prefixes, hasLength(0));
-    expect(element.parts, hasLength(0));
-    CompilationUnitElement unit = element.definingCompilationUnit;
-    expect(unit, isNotNull);
-    expect(unit.name, "lib.dart");
-    expect(unit.library, element);
-    expect(unit.accessors, hasLength(0));
-    expect(unit.functions, hasLength(0));
-    expect(unit.functionTypeAliases, hasLength(0));
-    expect(unit.types, hasLength(0));
-    expect(unit.topLevelVariables, hasLength(0));
-  }
-
-  void test_libraryElement_docRange() {
-    String code = r'''
-/// My dart doc.
-library lib;
-
-class A {}''';
-    Source librarySource = addSource("/lib.dart", code);
-    LibraryElement element = _buildLibrary(librarySource);
-    expect(element, isNotNull);
-    SourceRange docRange = element.docRange;
-    expect(docRange, isNotNull);
-    expect(docRange.offset, code.indexOf('/// My dart doc.'));
-    expect(docRange.length, '/// My dart doc.'.length);
-  }
-
-  void test_missingLibraryDirectiveWithPart() {
-    addSource("/a.dart", "part of lib;");
-    Source librarySource = addSource("/lib.dart", "part 'a.dart';");
-    LibraryElement element = _buildLibrary(
-        librarySource, [ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART]);
-    expect(element, isNotNull);
-  }
-
-  void test_missingPartOfDirective() {
-    addSource("/a.dart", "class A {}");
-    Source librarySource = addSource(
-        "/lib.dart",
-        r'''
-library lib;
-
-part 'a.dart';''');
-    LibraryElement element =
-        _buildLibrary(librarySource, [CompileTimeErrorCode.PART_OF_NON_PART]);
-    expect(element, isNotNull);
-  }
-
-  void test_multipleFiles() {
-    Source librarySource = addSource(
-        "/lib.dart",
-        r'''
-library lib;
-part 'first.dart';
-part 'second.dart';
-
-class A {}''');
-    addSource(
-        "/first.dart",
-        r'''
-part of lib;
-class B {}''');
-    addSource(
-        "/second.dart",
-        r'''
-part of lib;
-class C {}''');
-    LibraryElement element = _buildLibrary(librarySource);
-    expect(element, isNotNull);
-    List<CompilationUnitElement> sourcedUnits = element.parts;
-    expect(sourcedUnits, hasLength(2));
-    _assertTypes(element.definingCompilationUnit, ["A"]);
-    if (sourcedUnits[0].name == "first.dart") {
-      _assertTypes(sourcedUnits[0], ["B"]);
-      _assertTypes(sourcedUnits[1], ["C"]);
-    } else {
-      _assertTypes(sourcedUnits[0], ["C"]);
-      _assertTypes(sourcedUnits[1], ["B"]);
-    }
-  }
-
-  void test_singleFile() {
-    Source librarySource = addSource(
-        "/lib.dart",
-        r'''
-/// My dart doc.
-library lib;
-
-class A {}''');
-    LibraryElement element = _buildLibrary(librarySource);
-    expect(element, isNotNull);
-    _assertTypes(element.definingCompilationUnit, ["A"]);
-  }
-
-  /**
-   * Ensure that there are elements representing all of the types in the given array of type names.
-   *
-   * @param unit the compilation unit containing the types
-   * @param typeNames the names of the types that should be found
-   */
-  void _assertTypes(CompilationUnitElement unit, List<String> typeNames) {
-    expect(unit, isNotNull);
-    List<ClassElement> types = unit.types;
-    expect(types, hasLength(typeNames.length));
-    for (ClassElement type in types) {
-      expect(type, isNotNull);
-      String actualTypeName = type.displayName;
-      bool wasExpected = false;
-      for (String expectedTypeName in typeNames) {
-        if (expectedTypeName == actualTypeName) {
-          wasExpected = true;
-        }
-      }
-      if (!wasExpected) {
-        fail("Found unexpected type $actualTypeName");
-      }
-    }
-  }
-
-  /**
-   * Build the element model for the library whose defining compilation unit has the given source.
-   *
-   * @param librarySource the source of the defining compilation unit for the library
-   * @param expectedErrorCodes the errors that are expected to be found while building the element
-   *          model
-   * @return the element model that was built for the library
-   * @throws Exception if the element model could not be built
-   */
-  LibraryElement _buildLibrary(Source librarySource,
-      [List<ErrorCode> expectedErrorCodes = ErrorCode.EMPTY_LIST]) {
-    LibraryResolver resolver = new LibraryResolver(_context);
-    LibraryElementBuilder builder = new LibraryElementBuilder(
-        resolver.analysisContext, resolver.errorListener);
-    Library library = resolver.createLibrary(librarySource);
-    LibraryElement element = builder.buildLibrary(library);
-    GatheringErrorListener listener = new GatheringErrorListener();
-    listener.addAll2(resolver.errorListener);
-    listener.assertErrorsWithCodes(expectedErrorCodes);
-    return element;
-  }
-}
-
-@reflectiveTest
 class LibraryImportScopeTest extends ResolverTestCase {
   void test_conflictingImports() {
     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);
@@ skipping 160 matching lines @@
     errorListener.assertNoErrors();
     expect(prefixedElement, same(prefixedType));
     Element nonPrefixedElement =
         scope.lookup(AstFactory.identifier3(typeName), importingLibrary);
     errorListener.assertNoErrors();
     expect(nonPrefixedElement, same(nonPrefixedType));
   }
 }
 
 @reflectiveTest
-class LibraryResolver2Test extends ResolverTestCase {
-  LibraryResolver2 _resolver;
-
-  Source _coreLibrarySource;
-
-  Source _asyncLibrarySource;
-
-  @override
-  void setUp() {
-    super.setUp();
-    _resolver = new LibraryResolver2(analysisContext2);
-    _coreLibrarySource =
-        analysisContext2.sourceFactory.forUri(DartSdk.DART_CORE);
-    _asyncLibrarySource =
-        analysisContext2.sourceFactory.forUri(DartSdk.DART_ASYNC);
-  }
-
-  void test_imports_relative() {
-    Source sourceA = addSource(r'''
-library libA;
-import 'libB.dart';
-class A {}''');
-    Source sourceB = addNamedSource(
-        "/libB.dart",
-        r'''
-library libB;
-import 'test.dart
-class B {}''');
-    List<ResolvableLibrary> cycle = new List<ResolvableLibrary>();
-    ResolvableLibrary coreLib = _createResolvableLibrary(_coreLibrarySource);
-    coreLib.libraryElement = analysisContext2
-        .computeLibraryElement(_coreLibrarySource) as LibraryElementImpl;
-    ResolvableLibrary asyncLib = _createResolvableLibrary(_asyncLibrarySource);
-    asyncLib.libraryElement = analysisContext2
-        .computeLibraryElement(_asyncLibrarySource) as LibraryElementImpl;
-    ResolvableLibrary libA = _createResolvableLibrary(sourceA);
-    ResolvableLibrary libB = _createResolvableLibrary(sourceB);
-    libA.importedLibraries = <ResolvableLibrary>[coreLib, asyncLib, libB];
-    libB.importedLibraries = <ResolvableLibrary>[coreLib, asyncLib, libA];
-    cycle.add(libA);
-    cycle.add(libB);
-    LibraryElement library = _resolver.resolveLibrary(sourceA, cycle);
-    List<LibraryElement> importedLibraries = library.importedLibraries;
-    assertNamedElements(importedLibraries, ["dart.core", "libB"]);
-  }
-
-  ResolvableLibrary _createResolvableLibrary(Source source) {
-    CompilationUnit unit = analysisContext2.parseCompilationUnit(source);
-    ResolvableLibrary resolvableLibrary = new ResolvableLibrary(source);
-    resolvableLibrary.resolvableCompilationUnits = <ResolvableCompilationUnit>[
-      new ResolvableCompilationUnit(source, unit)
-    ];
-    return resolvableLibrary;
-  }
-}
-
-@reflectiveTest
-class LibraryResolverTest extends ResolverTestCase {
-  LibraryResolver _resolver;
-
-  @override
-  void setUp() {
-    super.setUp();
-    _resolver = new LibraryResolver(analysisContext2);
-  }
-
-  void test_imports_dart_html() {
-    Source source = addSource(r'''
-library libA;
-import 'dart:html';
-class A {}''');
-    LibraryElement library = _resolver.resolveLibrary(source, true);
-    List<LibraryElement> importedLibraries = library.importedLibraries;
-    assertNamedElements(importedLibraries, ["dart.core", "dart.dom.html"]);
-  }
-
-  void test_imports_none() {
-    Source source = addSource(r'''
-library libA;
-class A {}''');
-    LibraryElement library = _resolver.resolveLibrary(source, true);
-    List<LibraryElement> importedLibraries = library.importedLibraries;
-    assertNamedElements(importedLibraries, ["dart.core"]);
-  }
-
-  void test_imports_relative() {
-    addNamedSource("/libB.dart", "library libB;");
-    Source source = addSource(r'''
-library libA;
-import 'libB.dart';
-class A {}''');
-    LibraryElement library = _resolver.resolveLibrary(source, true);
-    List<LibraryElement> importedLibraries = library.importedLibraries;
-    assertNamedElements(importedLibraries, ["dart.core", "libB"]);
-  }
-}
-
-@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 = AnalysisContextFactory.contextWithCore();
     String importedTypeName = "A";
@@ skipping 164 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.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;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
@@ skipping 6342 matching lines @@
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
     expect(declaration.initializer.staticType.name, 'String');
     expect(declaration.initializer.propagatedType, isNull);
   }
 
   void test_genericFunction() {
-    if (!AnalysisEngine.instance.useTaskModel) {
-      return;
-    }
     _resolveTestUnit(r'/*=T*/ f/*<T>*/(/*=T*/ x) => null;');
     SimpleIdentifier f = _findIdentifier('f');
     FunctionElementImpl e = f.staticElement;
     expect(e.typeParameters.toString(), '[T]');
     expect(e.type.typeParameters.toString(), '[T]');
     expect(e.type.typeParameters[0].type, e.type.typeArguments[0]);
     expect(e.type.toString(), '(T) → T');
 
     // Substitute for T
     DartType t = e.typeParameters[0].type;
     FunctionType ft = e.type.substitute2([typeProvider.stringType], [t]);
     expect(ft.toString(), '(String) → String');
   }
 
   void test_genericMethod() {
-    if (!AnalysisEngine.instance.useTaskModel) {
-      return;
-    }
     _resolveTestUnit(r'''
 class C<E> {
   List/*<T>*/ f/*<T>*/(E e) => null;
 }
 main() {
   C<String> cOfString;
 }
 ''');
     SimpleIdentifier f = _findIdentifier('f');
     MethodElementImpl e = f.staticElement;
     expect(e.typeParameters.toString(), '[T]');
     expect(e.type.typeParameters.toString(), '[T, E]');
     expect(e.type.typeArguments.toString(), '[T, E]');
     expect(e.type.toString(), '(E) → List<T>');
 
     SimpleIdentifier c = _findIdentifier('cOfString');
     FunctionType ft = (c.staticType as InterfaceType).getMethod('f').type;
     expect(ft.toString(), '(String) → List<T>');
     DartType t = e.typeParameters[0].type;
     ft = ft.substitute2([typeProvider.intType], [t]);
     expect(ft.toString(), '(String) → List<int>');
   }
 
   void test_genericMethod_functionTypedParameter() {
-    if (!AnalysisEngine.instance.useTaskModel) {
-      return;
-    }
     _resolveTestUnit(r'''
 class C<E> {
   List/*<T>*/ f/*<T>*/(/*=T*/ f(E e)) => null;
 }
 main() {
   C<String> cOfString;
 }
 ''');
     SimpleIdentifier f = _findIdentifier('f');
     MethodElementImpl e = f.staticElement;
@@ skipping 273 matching lines @@
   v = 3;
   v; // marker
 }''';
     _assertPropagatedAssignedType(
         code, typeProvider.dynamicType, typeProvider.intType);
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_localVariableInference_transitive_field_inferred_lexical() {
-    if (!AnalysisEngine.instance.useTaskModel) {
-      return;
-    }
     String code = r'''
 class A {
   final x = 3;
   f() {
     var v = x;
     return v; // marker
   }
 }
 main() {
 }
 ''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
   void test_localVariableInference_transitive_field_inferred_reversed() {
-    if (!AnalysisEngine.instance.useTaskModel) {
-      return;
-    }
     String code = r'''
 class A {
   f() {
     var v = x;
     return v; // marker
   }
   final x = 3;
 }
 main() {
 }
@@ skipping 50 matching lines @@
 main() {
   var x = 3;
   var v = x;
   v; // marker
 }''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
   void test_localVariableInference_transitive_toplevel_inferred_lexical() {
-    if (!AnalysisEngine.instance.useTaskModel) {
-      return;
-    }
     String code = r'''
 final x = 3;
 main() {
   var v = x;
   v; // marker
 }
 ''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
   void test_localVariableInference_transitive_toplevel_inferred_reversed() {
-    if (!AnalysisEngine.instance.useTaskModel) {
-      return;
-    }
     String code = r'''
 main() {
   var v = x;
   v; // marker
 }
 final x = 3;
 ''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
@@ skipping 189 matching lines @@
   }
 
   void test_getType_noScope() {
     TypeOverrideManager manager = new TypeOverrideManager();
     expect(manager.getType(ElementFactory.localVariableElement2("v")), isNull);
   }
 }
 
 @reflectiveTest
 class TypePropagationTest extends ResolverTestCase {
-  void test_invocation_target_prefixed() {
-    addNamedSource(
-        '/helper.dart',
-        '''
-library helper;
-int max(int x, int y) => 0;
-''');
-    String code = '''
-import 'helper.dart' as helper;
-main() {
-  helper.max(10, 10); // marker
-}''';
-    SimpleIdentifier methodName =
-        _findMarkedIdentifier(code, "(10, 10); // marker");
-    MethodInvocation methodInvoke = methodName.parent;
-    expect(methodInvoke.methodName.staticElement, isNotNull);
-    expect(methodInvoke.methodName.propagatedElement, isNull);
-  }
-
   void fail_mergePropagatedTypesAtJoinPoint_1() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     _assertTypeOfMarkedExpression(
         r'''
 f1(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     y = '';
@@ skipping 265 matching lines @@
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     SimpleIdentifier identifier = EngineTestCase.findNode(
         unit, code, "context", (node) => node is SimpleIdentifier);
     expect(identifier.propagatedType.name, "CanvasRenderingContext2D");
   }
 
   void test_finalPropertyInducingVariable_classMember_instance() {
-    // TODO(scheglov) remove after switching to the task model
-    if (!AnalysisEngine.instance.useTaskModel) return;
     addNamedSource(
         "/lib.dart",
         r'''
 class A {
   final v = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 f(A a) {
   return a.v; // marker
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_finalPropertyInducingVariable_classMember_instance_inherited() {
-    // TODO(scheglov) remove after switching to the task model
-    if (!AnalysisEngine.instance.useTaskModel) return;
     addNamedSource(
         "/lib.dart",
         r'''
 class A {
   final v = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 class B extends A {
   m() {
     return v; // marker
   }
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_finalPropertyInducingVariable_classMember_instance_propagatedTarget() {
-    // TODO(scheglov) remove after switching to the task model
-    if (!AnalysisEngine.instance.useTaskModel) return;
     addNamedSource(
         "/lib.dart",
         r'''
 class A {
   final v = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 f(p) {
   if (p is A) {
     return p.v; // marker
   }
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_finalPropertyInducingVariable_classMember_instance_unprefixed() {
-    // TODO(scheglov) remove after switching to the task model
-    if (!AnalysisEngine.instance.useTaskModel) return;
     String code = r'''
 class A {
   final v = 0;
   m() {
     v; // marker
   }
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_finalPropertyInducingVariable_classMember_static() {
-    // TODO(scheglov) remove after switching to the task model
-    if (!AnalysisEngine.instance.useTaskModel) return;
     addNamedSource(
         "/lib.dart",
         r'''
 class A {
   static final V = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 f() {
   return A.V; // marker
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_finalPropertyInducingVariable_topLevelVariable_prefixed() {
-    // TODO(scheglov) remove after switching to the task model
-    if (!AnalysisEngine.instance.useTaskModel) return;
     addNamedSource("/lib.dart", "final V = 0;");
     String code = r'''
 import 'lib.dart' as p;
 f() {
   var v2 = p.V; // marker prefixed
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_finalPropertyInducingVariable_topLevelVariable_simple() {
-    // TODO(scheglov) remove after switching to the task model
-    if (!AnalysisEngine.instance.useTaskModel) return;
     addNamedSource("/lib.dart", "final V = 0;");
     String code = r'''
 import 'lib.dart';
 f() {
   return V; // marker simple
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
@@ skipping 409 matching lines @@
       expect(identifier.propagatedType, same(null));
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "v; // marker", (node) => node is SimpleIdentifier);
       expect(identifier.staticType, same(typeProvider.intType));
       expect(identifier.propagatedType, same(null));
     }
   }
 
+  void test_invocation_target_prefixed() {
+    addNamedSource(
+        '/helper.dart',
+        '''
+library helper;
+int max(int x, int y) => 0;
+''');
+    String code = '''
+import 'helper.dart' as helper;
+main() {
+  helper.max(10, 10); // marker
+}''';
+    SimpleIdentifier methodName =
+        _findMarkedIdentifier(code, "(10, 10); // marker");
+    MethodInvocation methodInvoke = methodName.parent;
+    expect(methodInvoke.methodName.staticElement, isNotNull);
+    expect(methodInvoke.methodName.propagatedElement, isNull);
+  }
+
   void test_is_conditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is A) ? p : null;
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
@@ skipping 1573 matching lines @@
 
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }