TypeProvider is only available after a resolution.

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 analyzer.test.generated.resolver_test;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 928 matching lines @@
   void test_getType_noScope() {
     TypeOverrideManager manager = new TypeOverrideManager();
     expect(manager.getType(ElementFactory.localVariableElement2("v")), isNull);
   }
 }
 
 @reflectiveTest
 class TypePropagationTest extends ResolverTestCase {
   fail_mergePropagatedTypesAtJoinPoint_1() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 f1(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     y = '';
   }
   // Propagated type is [List] here: incorrect.
   // Best we can do is [Object]?
   return y; // marker
-}''',
-        null,
-        typeProvider.dynamicType);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, typeProvider.dynamicType);
   }
 
   fail_mergePropagatedTypesAtJoinPoint_2() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 f2(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
   }
   // Propagated type is [List] here: incorrect.
   // Best we can do is [Object]?
   return y; // marker
-}''',
-        null,
-        typeProvider.dynamicType);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, typeProvider.dynamicType);
   }
 
   fail_mergePropagatedTypesAtJoinPoint_3() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 f4(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     y = 1.5;
   }
   // Propagated type is [List] here: incorrect.
   // A correct answer is the least upper bound of [int] and [double],
   // i.e. [num].
   return y; // marker
-}''',
-        null,
-        typeProvider.numType);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, typeProvider.numType);
   }
 
   fail_mergePropagatedTypesAtJoinPoint_5() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 f6(x,y) {
   var z = [];
   if (x || (z = y) < 0) {
   } else {
     z = 0;
   }
   // Propagated type is [List] here: incorrect.
   // Best we can do is [Object]?
   return z; // marker
-}''',
-        null,
-        typeProvider.dynamicType);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, typeProvider.dynamicType);
   }
 
   fail_mergePropagatedTypesAtJoinPoint_7() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
     //
     // In general [continue]s are unsafe for the purposes of
     // [isAbruptTerminationStatement].
     //
     // This is like example 6, but less tricky: the code in the branch that
     // [continue]s is in effect after the [if].
     String code = r'''
 f() {
   var x = 0;
   var c = false;
   var d = true;
   while (d) {
     if (c) {
       d = false;
     } else {
       x = '';
       c = true;
       continue;
     }
     x; // marker
   }
 }''';
+    CompilationUnit unit = await resolveSource(code);
     DartType t =
-        (await findMarkedIdentifier(code, "; // marker")).propagatedType;
+        findMarkedIdentifier(code, unit, "; // marker").propagatedType;
     expect(typeProvider.intType.isSubtypeOf(t), isTrue);
     expect(typeProvider.stringType.isSubtypeOf(t), isTrue);
   }
 
   fail_mergePropagatedTypesAtJoinPoint_8() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
     //
     // In nested loops [breaks]s are unsafe for the purposes of
     // [isAbruptTerminationStatement].
     //
@@ skipping 11 matching lines @@
         d = false;
       } else {
         x = '';
         c = true;
         break;
       }
       x; // marker
     }
   }
 }''';
+    CompilationUnit unit = await resolveSource(code);
     DartType t =
-        (await findMarkedIdentifier(code, "; // marker")).propagatedType;
+        findMarkedIdentifier(code, unit, "; // marker").propagatedType;
     expect(typeProvider.intType.isSubtypeOf(t), isTrue);
     expect(typeProvider.stringType.isSubtypeOf(t), isTrue);
   }
 
   fail_propagatedReturnType_functionExpression() async {
     // TODO(scheglov) disabled because we don't resolve function expression
     String code = r'''
 main() {
   var v = (() {return 42;})();
 }''';
-    await assertPropagatedAssignedType(
-        code, typeProvider.dynamicType, typeProvider.intType);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(
+        code, unit, typeProvider.dynamicType, typeProvider.intType);
   }
 
   test_as() async {
     Source source = addSource(r'''
 class A {
   bool get g => true;
 }
 A f(var p) {
   if ((p as A).g) {
     return p;
@@ skipping 518 matching lines @@
         '/helper.dart',
         '''
 library helper;
 int max(int x, int y) => 0;
 ''');
     String code = '''
 import 'helper.dart' as helper;
 main() {
   helper.max(10, 10); // marker
 }''';
+    CompilationUnit unit = await resolveSource(code);
     SimpleIdentifier methodName =
-        await findMarkedIdentifier(code, "(10, 10); // marker");
+        findMarkedIdentifier(code, unit, "(10, 10); // marker");
     MethodInvocation methodInvoke = methodName.parent;
     expect(methodInvoke.methodName.staticElement, isNotNull);
     expect(methodInvoke.methodName.propagatedElement, isNull);
   }
 
   test_is_conditional() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is A) ? p : null;
@@ skipping 316 matching lines @@
 class A {}
 class B extends A {}
 f() {
   var a = new A();
   var b = new B();
   b; // B
   if (a is B) {
     return a; // marker
   }
 }''';
-    DartType tB = (await findMarkedIdentifier(code, "; // B")).propagatedType;
-    await assertTypeOfMarkedExpression(code, null, tB);
+    CompilationUnit unit = await resolveSource(code);
+    DartType tB = findMarkedIdentifier(code, unit, "; // B").propagatedType;
+    assertTypeOfMarkedExpression(code, unit, null, tB);
   }
 
   test_issue20904BuggyTypePromotionAtIfJoin_6() async {
     // https://code.google.com/p/dart/issues/detail?id=20904
     //
     // The other half of the *_5() test.
     //
     // Here the is-check loses precision, so we don't use it.
     String code = r'''
 class A {}
 class B extends A {}
 f() {
   var b = new B();
   b; // B
   if (b is A) {
     return b; // marker
   }
 }''';
-    DartType tB = (await findMarkedIdentifier(code, "; // B")).propagatedType;
-    await assertTypeOfMarkedExpression(code, null, tB);
+    CompilationUnit unit = await resolveSource(code);
+    DartType tB = findMarkedIdentifier(code, unit, "; // B").propagatedType;
+    assertTypeOfMarkedExpression(code, unit, null, tB);
   }
 
   test_listLiteral_different() async {
     Source source = addSource(r'''
 f() {
   var v = [0, '1', 2];
   return v[2];
 }''');
     CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
@@ skipping 67 matching lines @@
 
   test_mergePropagatedTypes_afterIfThen_different() async {
     String code = r'''
 main() {
   var v = 0;
   if (v != null) {
     v = '';
   }
   return v;
 }''';
+    CompilationUnit unit = await resolveSource(code);
     {
-      SimpleIdentifier identifier = await findMarkedIdentifier(code, "v;");
+      SimpleIdentifier identifier = findMarkedIdentifier(code, unit, "v;");
       expect(identifier.propagatedType, null);
     }
     {
-      SimpleIdentifier identifier = await findMarkedIdentifier(code, "v = '';");
+      SimpleIdentifier identifier =
+          findMarkedIdentifier(code, unit, "v = '';");
       expect(identifier.propagatedType, typeProvider.stringType);
     }
   }
 
   test_mergePropagatedTypes_afterIfThen_same() async {
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 main() {
   var v = 1;
   if (v != null) {
     v = 2;
   }
   return v; // marker
-}''',
-        null,
-        typeProvider.intType);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, typeProvider.intType);
   }
 
   test_mergePropagatedTypes_afterIfThenElse_different() async {
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 main() {
   var v = 1;
   if (v != null) {
     v = 2;
   } else {
     v = '3';
   }
   return v; // marker
-}''',
-        null,
-        null);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, null);
   }
 
   test_mergePropagatedTypes_afterIfThenElse_same() async {
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 main() {
   var v = 1;
   if (v != null) {
     v = 2;
   } else {
     v = 3;
   }
   return v; // marker
-}''',
-        null,
-        typeProvider.intType);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, typeProvider.intType);
   }
 
   test_mergePropagatedTypesAtJoinPoint_4() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 f5(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     return y;
   }
   // Propagated type is [int] here: correct.
   return y; // marker
-}''',
-        null,
-        typeProvider.intType);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, typeProvider.intType);
   }
 
   test_mutatedOutsideScope() async {
     // https://code.google.com/p/dart/issues/detail?id=22732
     Source source = addSource(r'''
 class Base {
 }
 
 class Derived extends Base {
   get y => null;
@@ skipping 27 matching lines @@
         '''
 library helper;
 dynamic get $name => 42;
 ''');
     String code = '''
 import 'helper.dart' as helper;
 main() {
   helper.$name; // marker
 }''';
 
-    SimpleIdentifier id = await findMarkedIdentifier(code, "; // marker");
+    CompilationUnit unit = await resolveSource(code);
+    SimpleIdentifier id = findMarkedIdentifier(code, unit, "; // marker");
     PrefixedIdentifier prefixedId = id.parent;
     expect(id.staticType, typeProvider.dynamicType);
     expect(prefixedId.staticType, typeProvider.dynamicType);
   }
 
   test_objectAccessInference_disabled_for_local_getter() async {
     String name = 'hashCode';
     String code = '''
 dynamic get $name => null;
 main() {
   $name; // marker
 }''';
 
-    SimpleIdentifier getter = await findMarkedIdentifier(code, "; // marker");
+    CompilationUnit unit = await resolveSource(code);
+    SimpleIdentifier getter = findMarkedIdentifier(code, unit, "; // marker");
     expect(getter.staticType, typeProvider.dynamicType);
   }
 
   test_objectAccessInference_enabled_for_cascades() async {
     String name = 'hashCode';
     String code = '''
 main() {
   dynamic obj;
   obj..$name..$name; // marker
 }''';
+    CompilationUnit unit = await resolveSource(code);
     PropertyAccess access =
-        (await findMarkedIdentifier(code, "; // marker")).parent;
+        findMarkedIdentifier(code, unit, "; // marker").parent;
     expect(access.staticType, typeProvider.dynamicType);
     expect(access.realTarget.staticType, typeProvider.dynamicType);
   }
 
   test_objectMethodInference_disabled_for_library_prefix() async {
     String name = 'toString';
     addNamedSource(
         '/helper.dart',
         '''
 library helper;
 dynamic $name = (int x) => x + 42');
 ''');
     String code = '''
 import 'helper.dart' as helper;
 main() {
   helper.$name(); // marker
 }''';
+    CompilationUnit unit = await resolveSource(code);
     SimpleIdentifier methodName =
-        await findMarkedIdentifier(code, "(); // marker");
+        findMarkedIdentifier(code, unit, "(); // marker");
     MethodInvocation methodInvoke = methodName.parent;
     expect(methodName.staticType, typeProvider.dynamicType);
     expect(methodInvoke.staticType, typeProvider.dynamicType);
   }
 
   test_objectMethodInference_disabled_for_local_function() async {
     String name = 'toString';
     String code = '''
 main() {
   dynamic $name = () => null;
   $name(); // marker
 }''';
-    SimpleIdentifier identifier = await findMarkedIdentifier(code, "$name = ");
+    CompilationUnit unit = await resolveSource(code);
+
+    SimpleIdentifier identifier = findMarkedIdentifier(code, unit, "$name = ");
     expect(identifier.staticType, typeProvider.dynamicType);
 
     SimpleIdentifier methodName =
-        await findMarkedIdentifier(code, "(); // marker");
+        findMarkedIdentifier(code, unit, "(); // marker");
     MethodInvocation methodInvoke = methodName.parent;
     expect(methodName.staticType, typeProvider.dynamicType);
     expect(methodInvoke.staticType, typeProvider.dynamicType);
   }
 
   test_objectMethodInference_enabled_for_cascades() async {
     String name = 'toString';
     String code = '''
 main() {
   dynamic obj;
   obj..$name()..$name(); // marker
 }''';
+    CompilationUnit unit = await resolveSource(code);
     SimpleIdentifier methodName =
-        await findMarkedIdentifier(code, "(); // marker");
+        findMarkedIdentifier(code, unit, "(); // marker");
     MethodInvocation methodInvoke = methodName.parent;
 
     expect(methodInvoke.staticType, typeProvider.dynamicType);
     expect(methodInvoke.realTarget.staticType, typeProvider.dynamicType);
   }
 
   test_objectMethodOnDynamicExpression_doubleEquals() async {
     // https://code.google.com/p/dart/issues/detail?id=20342
     //
     // This was not actually part of Issue 20342, since the spec specifies a
     // static type of [bool] for [==] comparison and the implementation
     // was already consistent with the spec there. But, it's another
     // [Object] method, so it's included here.
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 f1(x) {
   var v = (x == x);
   return v; // marker
-}''',
-        null,
-        typeProvider.boolType);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, typeProvider.boolType);
   }
 
   test_objectMethodOnDynamicExpression_hashCode() async {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 f1(x) {
   var v = x.hashCode;
   return v; // marker
-}''',
-        null,
-        typeProvider.intType);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, typeProvider.intType);
   }
 
   test_objectMethodOnDynamicExpression_runtimeType() async {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 f1(x) {
   var v = x.runtimeType;
   return v; // marker
-}''',
-        null,
-        typeProvider.typeType);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, typeProvider.typeType);
   }
 
   test_objectMethodOnDynamicExpression_toString() async {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    await assertTypeOfMarkedExpression(
-        r'''
+    var code = r'''
 f1(x) {
   var v = x.toString();
   return v; // marker
-}''',
-        null,
-        typeProvider.stringType);
+}''';
+    CompilationUnit unit = await resolveSource(code);
+    assertTypeOfMarkedExpression(code, unit, null, typeProvider.stringType);
   }
 
   test_propagatedReturnType_localFunction() async {
     String code = r'''
 main() {
   f() => 42;
   var v = f();
 }''';
-    await assertPropagatedAssignedType(
-        code, typeProvider.dynamicType, typeProvider.intType);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(
+        code, unit, typeProvider.dynamicType, typeProvider.intType);
   }
 
   test_query() async {
     Source source = addSource(r'''
 import 'dart:html';
 
 main() {
   var v1 = query('a');
   var v2 = query('A');
   var v3 = query('body:active');
@@ skipping 1259 matching lines @@
  */
 class _StaleElement extends ElementImpl {
   _StaleElement() : super("_StaleElement", -1);
 
   @override
   get kind => throw "_StaleElement's kind shouldn't be accessed";
 
   @override
   /*=T*/ accept/*<T>*/(_) => throw "_StaleElement shouldn't be visited";
 }