Propagate types of final/const top-level variables and fields.

pkg/analyzer/test/src/task/dart_test.dart

 // Copyright (c) 2015, 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 test.src.task.dart_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 26 matching lines @@
   runReflectiveTests(BuildEnumMemberElementsTaskTest);
   runReflectiveTests(BuildExportNamespaceTaskTest);
   runReflectiveTests(BuildLibraryElementTaskTest);
   runReflectiveTests(BuildPublicNamespaceTaskTest);
   runReflectiveTests(BuildSourceExportClosureTaskTest);
   runReflectiveTests(BuildTypeProviderTaskTest);
   runReflectiveTests(ComputeConstantDependenciesTaskTest);
   runReflectiveTests(ComputeConstantValueTaskTest);
   runReflectiveTests(ComputeInferableStaticVariableDependenciesTaskTest);
   runReflectiveTests(ComputeLibraryCycleTaskTest);
+  runReflectiveTests(ComputePropagableVariableDependenciesTaskTest);
   runReflectiveTests(ContainingLibrariesTaskTest);
   runReflectiveTests(DartErrorsTaskTest);
   runReflectiveTests(ErrorFilterTest);
   runReflectiveTests(EvaluateUnitConstantsTaskTest);
   runReflectiveTests(GatherUsedImportedElementsTaskTest);
   runReflectiveTests(GatherUsedLocalElementsTaskTest);
   runReflectiveTests(GenerateHintsTaskTest);
   runReflectiveTests(GenerateLintsTaskTest);
   runReflectiveTests(InferInstanceMembersInUnitTaskTest);
   runReflectiveTests(InferStaticVariableTypesInUnitTaskTest);
   runReflectiveTests(InferStaticVariableTypeTaskTest);
   runReflectiveTests(LibraryErrorsReadyTaskTest);
   runReflectiveTests(LibraryUnitErrorsTaskTest);
   runReflectiveTests(ParseDartTaskTest);
   runReflectiveTests(PartiallyResolveUnitReferencesTaskTest);
+  runReflectiveTests(PropagateVariableTypesInUnitTaskTest);
+  runReflectiveTests(PropagateVariableTypeTaskTest);
   runReflectiveTests(ResolveInstanceFieldsInUnitTaskTest);
   runReflectiveTests(ResolveLibraryTypeNamesTaskTest);
   runReflectiveTests(ResolveUnitTaskTest);
   runReflectiveTests(ResolveUnitTypeNamesTaskTest);
   runReflectiveTests(ResolveVariableReferencesTaskTest);
   runReflectiveTests(ScanDartTaskTest);
   runReflectiveTests(StrongModeInferenceTest);
   runReflectiveTests(StrongModeVerifyUnitTaskTest);
   runReflectiveTests(VerifyUnitTaskTest);
 }
@@ skipping 13 matching lines @@
 isInstanceOf isBuildSourceExportClosureTask =
     new isInstanceOf<BuildSourceExportClosureTask>();
 isInstanceOf isBuildTypeProviderTask =
     new isInstanceOf<BuildTypeProviderTask>();
 isInstanceOf isComputeConstantDependenciesTask =
     new isInstanceOf<ComputeConstantDependenciesTask>();
 isInstanceOf isComputeConstantValueTask =
     new isInstanceOf<ComputeConstantValueTask>();
 isInstanceOf isComputeInferableStaticVariableDependenciesTask =
     new isInstanceOf<ComputeInferableStaticVariableDependenciesTask>();
+isInstanceOf isComputePropagableVariableDependenciesTask =
+    new isInstanceOf<ComputePropagableVariableDependenciesTask>();
 isInstanceOf isContainingLibrariesTask =
     new isInstanceOf<ContainingLibrariesTask>();
 isInstanceOf isDartErrorsTask = new isInstanceOf<DartErrorsTask>();
 isInstanceOf isEvaluateUnitConstantsTask =
     new isInstanceOf<EvaluateUnitConstantsTask>();
 isInstanceOf isGatherUsedImportedElementsTask =
     new isInstanceOf<GatherUsedImportedElementsTask>();
 isInstanceOf isGatherUsedLocalElementsTask =
     new isInstanceOf<GatherUsedLocalElementsTask>();
 isInstanceOf isGenerateHintsTask = new isInstanceOf<GenerateHintsTask>();
 isInstanceOf isGenerateLintsTask = new isInstanceOf<GenerateLintsTask>();
 isInstanceOf isInferInstanceMembersInUnitTask =
     new isInstanceOf<InferInstanceMembersInUnitTask>();
 isInstanceOf isInferStaticVariableTypesInUnitTask =
     new isInstanceOf<InferStaticVariableTypesInUnitTask>();
 isInstanceOf isInferStaticVariableTypeTask =
     new isInstanceOf<InferStaticVariableTypeTask>();
 isInstanceOf isLibraryErrorsReadyTask =
     new isInstanceOf<LibraryErrorsReadyTask>();
 isInstanceOf isLibraryUnitErrorsTask =
     new isInstanceOf<LibraryUnitErrorsTask>();
 isInstanceOf isParseDartTask = new isInstanceOf<ParseDartTask>();
 isInstanceOf isPartiallyResolveUnitReferencesTask =
     new isInstanceOf<PartiallyResolveUnitReferencesTask>();
+isInstanceOf isPropagateVariableTypesInUnitTask =
+    new isInstanceOf<PropagateVariableTypesInUnitTask>();
+isInstanceOf isPropagateVariableTypeTask =
+    new isInstanceOf<PropagateVariableTypeTask>();
 isInstanceOf isResolveLibraryTypeNamesTask =
     new isInstanceOf<ResolveLibraryTypeNamesTask>();
 isInstanceOf isResolveUnitTask = new isInstanceOf<ResolveUnitTask>();
 isInstanceOf isResolveUnitTypeNamesTask =
     new isInstanceOf<ResolveUnitTypeNamesTask>();
 isInstanceOf isResolveVariableReferencesTask =
     new isInstanceOf<ResolveVariableReferencesTask>();
 isInstanceOf isScanDartTask = new isInstanceOf<ScanDartTask>();
 isInstanceOf isStrongModeVerifyUnitTask =
     new isInstanceOf<StrongModeVerifyUnitTask>();
@@ skipping 1139 matching lines @@
 
   void _checkCircularities(
       String variableName, List<String> otherVariables, String content) {
     // Evaluating the first constant should produce an error.
     CompilationUnit unit = _resolveUnit(content);
     _expectCircularityError(_evaluateConstant(unit, variableName));
     // And all the other constants involved in the strongly connected component
     // should be set to the same error state.
     for (String otherVariableName in otherVariables) {
       PropertyInducingElement otherVariableElement =
-          _findVariable(unit, otherVariableName);
+          getTopLevelVariableElement(unit, otherVariableName);
       _expectCircularityError((otherVariableElement
           as TopLevelVariableElementImpl).evaluationResult);
     }
   }
 
   EvaluationResultImpl _computeTopLevelVariableConstValue(
       String variableName, String content) {
     return _evaluateConstant(_resolveUnit(content), variableName);
   }
 
   EvaluationResultImpl _evaluateConstant(
       CompilationUnit unit, String variableName) {
     // Find the element for the given constant.
-    PropertyInducingElement variableElement = _findVariable(unit, variableName);
+    PropertyInducingElement variableElement =
+        getTopLevelVariableElement(unit, variableName);
     // Now compute the value of the constant.
     computeResult(variableElement, CONSTANT_VALUE,
         matcher: isComputeConstantValueTask);
     expect(outputs[CONSTANT_VALUE], same(variableElement));
     EvaluationResultImpl evaluationResult =
         (variableElement as TopLevelVariableElementImpl).evaluationResult;
     return evaluationResult;
   }
 
   void _expectCircularityError(EvaluationResultImpl evaluationResult) {
     expect(evaluationResult, isNotNull);
     expect(evaluationResult.value, isNull);
     expect(evaluationResult.errors, hasLength(1));
     expect(evaluationResult.errors[0].errorCode,
         CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT);
   }
 
-  PropertyInducingElement _findVariable(
-      CompilationUnit unit, String variableName) {
-    // Find the element for the given constant.
-    return unit.element.topLevelVariables.firstWhere(
-        (TopLevelVariableElement variable) => variable.name == variableName);
-  }
-
   CompilationUnit _resolveSource(Source source) {
     LibrarySpecificUnit librarySpecificUnit =
         new LibrarySpecificUnit(source, source);
     computeResult(librarySpecificUnit, RESOLVED_UNIT1);
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     return unit;
   }
 
   CompilationUnit _resolveUnit(String content) =>
       _resolveSource(newSource('/test.dart', content));
@@ skipping 427 matching lines @@
     expect(dep2, hasLength(1)); // dart:core
     expect(dep3, hasLength(1)); // dart:core
     expect(dep4, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
     expect(dep5, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
     expect(dep6, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
     expect(dep7, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
   }
 }
 
 @reflectiveTest
+class ComputePropagableVariableDependenciesTaskTest
+    extends _AbstractDartTaskTest {
+  test_perform_instanceField() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+class A {
+  final a = a1 + a2 + a3 + a4 + B.b1 + B.b2 + B.b3 + B.b4;
+  static const a1 = 1;
+  final a2 = 2;
+  final a3;
+  var   a4 = 4;
+}
+class B {
+  static const b1 = 1;
+  static final b2 = 2;
+  static final b3;
+  static var   b4 = 4;
+}
+''');
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, RESOLVED_UNIT5);
+    CompilationUnit unit = outputs[RESOLVED_UNIT5];
+    FieldElement elementA = getFieldInClassElement(unit, 'A', 'a');
+    // compute
+    computeResult(elementA, PROPAGABLE_VARIABLE_DEPENDENCIES,
+        matcher: isComputePropagableVariableDependenciesTask);
+    // verify
+    expect(outputs, hasLength(1));
+    List<VariableElement> dependencies =
+        outputs[PROPAGABLE_VARIABLE_DEPENDENCIES];
+    expect(
+        dependencies,
+        unorderedEquals([
+          getFieldInClassElement(unit, 'A', 'a1'),
+          getFieldInClassElement(unit, 'A', 'a2'),
+          getFieldInClassElement(unit, 'B', 'b1'),
+          getFieldInClassElement(unit, 'B', 'b2')
+        ]));
+  }
+
+  test_perform_topLevel() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+const a = d1 + d2 + d3 + d4;
+const d1 = 1;
+final d2 = 2;
+final d3;
+var   d4 = 4;
+''');
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, RESOLVED_UNIT5);
+    CompilationUnit unit = outputs[RESOLVED_UNIT5];
+    TopLevelVariableElement elementA = getTopLevelVariableElement(unit, 'a');
+    // compute
+    computeResult(elementA, PROPAGABLE_VARIABLE_DEPENDENCIES,
+        matcher: isComputePropagableVariableDependenciesTask);
+    // verify
+    expect(outputs, hasLength(1));
+    List<VariableElement> dependencies =
+        outputs[PROPAGABLE_VARIABLE_DEPENDENCIES];
+    expect(
+        dependencies,
+        unorderedEquals([
+          getTopLevelVariableElement(unit, 'd1'),
+          getTopLevelVariableElement(unit, 'd2')
+        ]));
+  }
+}
+
+@reflectiveTest
 class ContainingLibrariesTaskTest extends _AbstractDartTaskTest {
   test_perform_definingCompilationUnit() {
     AnalysisTarget library = newSource('/test.dart', 'library test;');
     computeResult(library, INCLUDED_PARTS);
     computeResult(library, CONTAINING_LIBRARIES,
         matcher: isContainingLibrariesTask);
     expect(outputs, hasLength(1));
     List<Source> containingLibraries = outputs[CONTAINING_LIBRARIES];
     expect(containingLibraries, unorderedEquals([library]));
   }
@@ skipping 50 matching lines @@
     computeResult(part, DART_ERRORS, matcher: isDartErrorsTask);
     expect(outputs, hasLength(1));
     List<AnalysisError> errors = outputs[DART_ERRORS];
     // This should contain only the errors in the part file, not the ones in the
     // library.
     expect(errors, hasLength(1));
   }
 }
 
 @reflectiveTest
+class ErrorFilterTest extends _AbstractDartTaskTest {
+  @override
+  setUp() {
+    super.setUp();
+    context.setConfigurationData(CONFIGURED_ERROR_FILTERS, [
+      (AnalysisError error) => error.errorCode.name == 'INVALID_ASSIGNMENT'
+    ]);
+  }
+
+  test_error_filters() {
+    AnalysisTarget library = newSource(
+        '/test.dart',
+        '''
+main() {
+  int x = ""; // INVALID_ASSIGNMENT (suppressed)
+  // UNUSED_LOCAL_VARIABLE
+}''');
+    computeResult(library, DART_ERRORS, matcher: isDartErrorsTask);
+    expect(outputs, hasLength(1));
+    List<AnalysisError> errors = outputs[DART_ERRORS];
+    expect(errors, hasLength(1));
+    expect(errors.first.errorCode, HintCode.UNUSED_LOCAL_VARIABLE);
+  }
+}
+
+@reflectiveTest
 class EvaluateUnitConstantsTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source source = newSource(
         '/test.dart',
         '''
 class C {
   const C();
 }
 
 @x
 f() {}
 
 const x = const C();
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
-    computeResult(target, RESOLVED_UNIT10,
+    computeResult(target, RESOLVED_UNIT11,
         matcher: isEvaluateUnitConstantsTask);
-    CompilationUnit unit = outputs[RESOLVED_UNIT10];
+    CompilationUnit unit = outputs[RESOLVED_UNIT11];
     CompilationUnitElement unitElement = unit.element;
     expect(
         (unitElement.types[0].constructors[0] as ConstructorElementImpl)
             .isCycleFree,
         isTrue);
     expect(
         (unitElement.functions[0].metadata[0] as ElementAnnotationImpl)
             .evaluationResult,
         isNotNull);
     expect(
@@ skipping 372 matching lines @@
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[HintCode.UNUSED_ELEMENT, HintCode.UNUSED_ELEMENT]);
   }
 }
 
 @reflectiveTest
-class ErrorFilterTest extends _AbstractDartTaskTest {
-  @override
-  setUp() {
-    super.setUp();
-    context.setConfigurationData(CONFIGURED_ERROR_FILTERS, [
-      (AnalysisError error) => error.errorCode.name == 'INVALID_ASSIGNMENT'
-    ]);
-  }
-
-  test_error_filters() {
-    AnalysisTarget library = newSource('/test.dart', '''
-main() {
-  int x = ""; // INVALID_ASSIGNMENT (suppressed)
-  // UNUSED_LOCAL_VARIABLE
-}''');
-    computeResult(library, DART_ERRORS, matcher: isDartErrorsTask);
-    expect(outputs, hasLength(1));
-    List<AnalysisError> errors = outputs[DART_ERRORS];
-    expect(errors, hasLength(1));
-    expect(errors.first.errorCode, HintCode.UNUSED_LOCAL_VARIABLE);
-  }
-}
-
-@reflectiveTest
 class GenerateLintsTaskTest extends _AbstractDartTaskTest {
   void enableLints() {
     AnalysisOptionsImpl options = context.analysisOptions;
     options.lint = true;
     context.analysisOptions = options;
   }
 
   @override
   void setUp() {
     super.setUp();
@@ skipping 52 matching lines @@
   Y m(Z x) {}
 }
 class B extends A {
   var f;
   m(x) {}
 }
 class X {}
 class Y {}
 class Z {}
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8,
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT9,
         matcher: isInferInstanceMembersInUnitTask);
-    CompilationUnit unit = outputs[RESOLVED_UNIT8];
+    CompilationUnit unit = outputs[RESOLVED_UNIT9];
     VariableDeclaration field = getFieldInClass(unit, 'B', 'f');
     MethodDeclaration method = getMethodInClass(unit, 'B', 'm');
     DartType typeX = getClass(unit, 'X').element.type;
     DartType typeY = getClass(unit, 'Y').element.type;
     DartType typeZ = getClass(unit, 'Z').element.type;
 
     expect(field.element.type, typeX);
     expect(method.element.returnType, typeY);
     expect(method.element.parameters[0].type, typeZ);
   }
@@ skipping 11 matching lines @@
         '/second.dart',
         '''
 import 'first.dart';
 
 const b = a;
 class M {
    String c = a;
 }
 ''');
     computeResult(
-        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT8,
+        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT9,
         matcher: isInferInstanceMembersInUnitTask);
-    CompilationUnit firstUnit = outputs[RESOLVED_UNIT8];
+    CompilationUnit firstUnit = outputs[RESOLVED_UNIT9];
     computeResult(
-        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT8);
-    CompilationUnit secondUnit = outputs[RESOLVED_UNIT8];
+        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT9);
+    CompilationUnit secondUnit = outputs[RESOLVED_UNIT9];
 
     VariableDeclaration variableA = getTopLevelVariable(firstUnit, 'a');
     VariableDeclaration variableB = getTopLevelVariable(secondUnit, 'b');
     VariableDeclaration variableC = getFieldInClass(secondUnit, 'M', 'c');
     InterfaceType stringType = context.typeProvider.stringType;
 
     expect(variableA.element.type, stringType);
     expect(variableB.element.type, stringType);
     expect(variableB.initializer.staticType, stringType);
     expect(variableC.element.type, stringType);
     expect(variableC.initializer.staticType, stringType);
   }
 
   void test_perform_reresolution() {
     enableStrongMode();
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 const topLevel = '';
 class C {
   String field = topLevel;
 }
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
-    CompilationUnit unit = outputs[RESOLVED_UNIT8];
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT9);
+    CompilationUnit unit = outputs[RESOLVED_UNIT9];
     VariableDeclaration topLevelDecl = getTopLevelVariable(unit, 'topLevel');
     VariableDeclaration fieldDecl = getFieldInClass(unit, 'C', 'field');
     VariableElement topLevel = topLevelDecl.name.staticElement;
     VariableElement field = fieldDecl.name.staticElement;
 
     InterfaceType stringType = context.typeProvider.stringType;
     expect(topLevel.type, stringType);
     expect(field.type, stringType);
     expect(fieldDecl.initializer.staticType, stringType);
   }
 }
 
 @reflectiveTest
 class InferStaticVariableTypesInUnitTaskTest extends _AbstractDartTaskTest {
   void test_perform_const_field() {
     enableStrongMode();
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 class M {
   static const X = "";
 }
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT6,
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT7,
         matcher: isInferStaticVariableTypesInUnitTask);
-    CompilationUnit unit = outputs[RESOLVED_UNIT6];
+    CompilationUnit unit = outputs[RESOLVED_UNIT7];
     VariableDeclaration declaration = getFieldInClass(unit, 'M', 'X');
     InterfaceType stringType = context.typeProvider.stringType;
     expect(declaration.element.type, stringType);
   }
 
   void test_perform_nestedDeclarations() {
     enableStrongMode();
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 var f = (int x) {
   int squared(int value) => value * value;
   var xSquared = squared(x);
   return xSquared;
 };
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT6,
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT7,
         matcher: isInferStaticVariableTypesInUnitTask);
   }
 
   void test_perform_recursive() {
     enableStrongMode();
     AnalysisTarget firstSource = newSource(
         '/first.dart',
         '''
 import 'second.dart';
 
 var a = new M();
 var c = b;
 ''');
     AnalysisTarget secondSource = newSource(
         '/second.dart',
         '''
 import 'first.dart';
 
 var b = a;
 class M {}
 ''');
     computeResult(
-        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT6,
+        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT7,
         matcher: isInferStaticVariableTypesInUnitTask);
-    CompilationUnit firstUnit = outputs[RESOLVED_UNIT6];
+    CompilationUnit firstUnit = outputs[RESOLVED_UNIT7];
     computeResult(
-        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT6);
-    CompilationUnit secondUnit = outputs[RESOLVED_UNIT6];
+        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT7);
+    CompilationUnit secondUnit = outputs[RESOLVED_UNIT7];
 
     VariableDeclaration variableA = getTopLevelVariable(firstUnit, 'a');
     VariableDeclaration variableB = getTopLevelVariable(secondUnit, 'b');
     VariableDeclaration variableC = getTopLevelVariable(firstUnit, 'c');
     ClassDeclaration classM = getClass(secondUnit, 'M');
     DartType typeM = classM.element.type;
 
     expect(variableA.element.type, typeM);
     expect(variableB.element.type, typeM);
     expect(variableB.initializer.staticType, typeM);
     expect(variableC.element.type, typeM);
     expect(variableC.initializer.staticType, typeM);
   }
 
   void test_perform_simple() {
     enableStrongMode();
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 var X = 1;
 
 var Y = () {
   return 1 + X;
 };
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT6,
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT7,
         matcher: isInferStaticVariableTypesInUnitTask);
-    CompilationUnit unit = outputs[RESOLVED_UNIT6];
+    CompilationUnit unit = outputs[RESOLVED_UNIT7];
     TopLevelVariableDeclaration declaration = unit.declarations[1];
     FunctionExpression function =
         declaration.variables.variables[0].initializer;
     BlockFunctionBody body = function.body;
     ReturnStatement statement = body.block.statements[0];
     Expression expression = statement.expression;
     InterfaceType intType = context.typeProvider.intType;
     expect(expression.staticType, intType);
   }
 }
@@ skipping 321 matching lines @@
   static void _assertHasCore(List<Source> sources, int lenght) {
     expect(sources, hasLength(lenght));
     expect(sources, contains(predicate((Source s) {
       return s.fullName.endsWith('core.dart');
     })));
   }
 }
 
 @reflectiveTest
 class PartiallyResolveUnitReferencesTaskTest extends _AbstractDartTaskTest {
-  test_perform() {
+  test_perform_propagable() {
     enableStrongMode();
     Source source = newSource(
         '/test.dart',
         '''
-int a = b;
-int b = c;
-var d = 0;
-class A {}
+const t1 = 1;
+final t2 = 2;
+var   t3 = 3;
+final t4;
 class C {
-  static final f = '';
-  var g = 0;
+  static const fs1 = 1;
+  static final fs2 = 2;
+  static var   fs3 = 3;
+  static final fs4;
+  const fi1 = 1;
+  final fi2 = 2;
+  var   fi3 = 3;
+  final fi4;
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
-    computeResult(target, RESOLVED_UNIT5,
+    computeResult(target, PROPAGABLE_VARIABLES_IN_UNIT,
         matcher: isPartiallyResolveUnitReferencesTask);
-    // Test the outputs
-    expect(outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT], hasLength(4));
-    CompilationUnit unit = outputs[RESOLVED_UNIT5];
-    expect(unit, same(outputs[RESOLVED_UNIT5]));
-    // Test the state of the AST
-    TopLevelVariableDeclaration a = unit.declarations[0];
-    VariableDeclaration variableA = a.variables.variables[0];
-    SimpleIdentifier initializer = variableA.initializer;
-    expect(initializer.staticElement, isNotNull);
+    // PROPAGABLE_VARIABLES_IN_UNIT
+    List<VariableElement> variables = outputs[PROPAGABLE_VARIABLES_IN_UNIT];
+    expect(variables.map((v) => v.displayName),
+        unorderedEquals(['t1', 't2', 'fs1', 'fs2', 'fi1', 'fi2']));
   }
 
-  test_perform_importExport() {
+  test_perform_strong_importExport() {
     newSource(
         '/a.dart',
         '''
 library a;
 class A<T> {
   T m() {}
 }
 ''');
     newSource(
         '/b.dart',
@@ skipping 20 matching lines @@
     FunctionDeclaration mainFunction = unit.declarations[0];
     expect(mainFunction.element, isNotNull);
     BlockFunctionBody body = mainFunction.functionExpression.body;
     List<Statement> statements = body.block.statements;
     ExpressionStatement statement = statements[0];
     MethodInvocation invocation = statement.expression;
     MethodElement methodElement = invocation.methodName.staticElement;
     expect(methodElement, isNull);
   }
 
-  test_perform_notResolved() {
+  test_perform_strong_inferable() {
     enableStrongMode();
     Source source = newSource(
         '/test.dart',
+        '''
+int a = b;
+int b = c;
+var d = 0;
+class A {}
+class C {
+  static final f = '';
+  var g = 0;
+}
+''');
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, RESOLVED_UNIT5,
+        matcher: isPartiallyResolveUnitReferencesTask);
+    CompilationUnit unit = outputs[RESOLVED_UNIT5];
+    // INFERABLE_STATIC_VARIABLES_IN_UNIT
+    {
+      List<VariableElement> variables =
+          outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT];
+      expect(variables, hasLength(4));
+      expect(variables.map((v) => v.displayName),
+          unorderedEquals(['a', 'b', 'd', 'f']));
+    }
+    // Test the state of the AST
+    TopLevelVariableDeclaration a = unit.declarations[0];
+    VariableDeclaration variableA = a.variables.variables[0];
+    SimpleIdentifier initializer = variableA.initializer;
+    expect(initializer.staticElement, isNotNull);
+  }
+
+  test_perform_strong_notResolved() {
+    enableStrongMode();
+    Source source = newSource(
+        '/test.dart',
         '''
 int A;
 f1() {
   A;
 }
 var f2 = () {
   A;
   void f3() {
     A;
   }
@@ skipping 43 matching lines @@
 
     ConstructorDeclaration constructor = members[0];
     expectReference(constructor.body, false);
 
     MethodDeclaration method = members[1];
     expectReference(method.body, false);
   }
 }
 
 @reflectiveTest
+class PropagateVariableTypesInUnitTaskTest extends _AbstractDartTaskTest {
+  void test_perform_cycle() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+final piFirst = true;
+final pi = piFirst ? 3.14 : tau / 2;
+final tau = piFirst ? pi * 2 : 6.28;
+''');
+    // compute
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT6,
+        matcher: isPropagateVariableTypesInUnitTask);
+    CompilationUnit unit = outputs[RESOLVED_UNIT6];
+    // verify
+    TopLevelVariableElement piFirst =
+        getTopLevelVariableElement(unit, 'piFirst');
+    TopLevelVariableElement pi = getTopLevelVariableElement(unit, 'pi');
+    TopLevelVariableElement tau = getTopLevelVariableElement(unit, 'tau');
+    expect(piFirst.propagatedType, context.typeProvider.boolType);
+    expect(pi.propagatedType, isNull);
+    expect(tau.propagatedType, isNull);
+  }
+
+  void test_perform_topLevel() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+final a = b + c.length;
+final b = 1;
+final c = '2';
+final d = a / 2.0;
+''');
+    // compute
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT6,
+        matcher: isPropagateVariableTypesInUnitTask);
+    CompilationUnit unit = outputs[RESOLVED_UNIT6];
+    // verify
+    InterfaceType intType = context.typeProvider.intType;
+    InterfaceType numType = context.typeProvider.numType;
+    InterfaceType stringType = context.typeProvider.stringType;
+    expect(getTopLevelVariableElement(unit, 'a').propagatedType, intType);
+    expect(getTopLevelVariableElement(unit, 'b').propagatedType, intType);
+    expect(getTopLevelVariableElement(unit, 'c').propagatedType, stringType);
+    expect(getTopLevelVariableElement(unit, 'd').propagatedType, numType);
+  }
+}
+
+@reflectiveTest
+class PropagateVariableTypeTaskTest extends _AbstractDartTaskTest {
+  void test_perform_cycle() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+final piFirst = true;
+final pi = piFirst ? 3.14 : tau / 2;
+final tau = piFirst ? pi * 2 : 6.28;
+''');
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT5);
+    CompilationUnit unit = outputs[RESOLVED_UNIT5];
+    TopLevelVariableElement piFirst =
+        getTopLevelVariableElement(unit, 'piFirst');
+    TopLevelVariableElement pi = getTopLevelVariableElement(unit, 'pi');
+    TopLevelVariableElement tau = getTopLevelVariableElement(unit, 'tau');
+    // compute
+    computeResult(piFirst, PROPAGATED_VARIABLE,
+        matcher: isPropagateVariableTypeTask);
+    expect(piFirst.propagatedType, context.typeProvider.boolType);
+    expect(pi.propagatedType, isNull);
+    expect(tau.propagatedType, isNull);
+  }
+
+  void test_perform_null() {
+    enableStrongMode();
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+var a = null;
+''');
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT5);
+    CompilationUnit unit = outputs[RESOLVED_UNIT5];
+    TopLevelVariableElement a = getTopLevelVariableElement(unit, 'a');
+    // compute
+    computeResult(a, PROPAGATED_VARIABLE, matcher: isPropagateVariableTypeTask);
+    expect(a.propagatedType, isNull);
+  }
+
+  void test_perform_topLevel() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+final a = b + c.length;
+final b = 1;
+final c = '2';
+''');
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT5);
+    CompilationUnit unit = outputs[RESOLVED_UNIT5];
+    TopLevelVariableElement elementA = getTopLevelVariableElement(unit, 'a');
+    TopLevelVariableElement elementB = getTopLevelVariableElement(unit, 'b');
+    TopLevelVariableElement elementC = getTopLevelVariableElement(unit, 'c');
+    // compute
+    computeResult(elementA, PROPAGATED_VARIABLE,
+        matcher: isPropagateVariableTypeTask);
+    InterfaceType intType = context.typeProvider.intType;
+    InterfaceType stringType = context.typeProvider.stringType;
+    expect(elementA.propagatedType, intType);
+    expect(elementB.propagatedType, intType);
+    expect(elementC.propagatedType, stringType);
+  }
+}
+
+@reflectiveTest
 class ResolveInstanceFieldsInUnitTaskTest extends _AbstractDartTaskTest {
   @override
   void setUp() {
     super.setUp();
     enableStrongMode();
   }
 
   // Test inference of instance fields across units
   void test_perform_inference_cross_unit_instance() {
     List<Source> sources = newSources({
@@ skipping 14 matching lines @@
           test1() {
             int x = 0;
             x = new A().a2;
           }
     '''
     });
     InterfaceType intType = context.typeProvider.intType;
     DartType dynamicType = context.typeProvider.dynamicType;
 
     computeResult(
-        new LibrarySpecificUnit(sources[1], sources[1]), RESOLVED_UNIT7);
-    CompilationUnit unit1 = outputs[RESOLVED_UNIT7];
+        new LibrarySpecificUnit(sources[1], sources[1]), RESOLVED_UNIT8);
+    CompilationUnit unit1 = outputs[RESOLVED_UNIT8];
 
     // B.b2 shoud be resolved on the rhs, but not yet inferred.
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "B", "b2"), dynamicType, intType);
 
     computeResult(
-        new LibrarySpecificUnit(sources[0], sources[0]), RESOLVED_UNIT7);
-    CompilationUnit unit0 = outputs[RESOLVED_UNIT7];
+        new LibrarySpecificUnit(sources[0], sources[0]), RESOLVED_UNIT8);
+    CompilationUnit unit0 = outputs[RESOLVED_UNIT8];
 
     // B.b2 should now be fully resolved and inferred.
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "B", "b2"), intType, intType);
 
     // A.a2 should now be resolved on the rhs, but not yet inferred.
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a2"), dynamicType, intType);
 
     computeResult(
-        new LibrarySpecificUnit(sources[2], sources[2]), RESOLVED_UNIT7);
+        new LibrarySpecificUnit(sources[2], sources[2]), RESOLVED_UNIT8);
 
     // A.a2 should now be fully resolved and inferred.
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a2"), intType, intType);
 
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "B", "b2"), intType, intType);
   }
 
   // Test inference of instance fields across units
@@ skipping 16 matching lines @@
 
           test1() {
             int x = 0;
             x = new A().a2;
           }
     '''
     });
     DartType dynamicType = context.typeProvider.dynamicType;
 
     computeResult(
-        new LibrarySpecificUnit(sources[0], sources[0]), RESOLVED_UNIT7);
-    CompilationUnit unit0 = outputs[RESOLVED_UNIT7];
+        new LibrarySpecificUnit(sources[0], sources[0]), RESOLVED_UNIT8);
+    CompilationUnit unit0 = outputs[RESOLVED_UNIT8];
 
     // A.a2 should now be resolved on the rhs, but not yet inferred.
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a2"), dynamicType, dynamicType);
 
     computeResult(
-        new LibrarySpecificUnit(sources[2], sources[2]), RESOLVED_UNIT7);
+        new LibrarySpecificUnit(sources[2], sources[2]), RESOLVED_UNIT8);
 
     // A.a2 should now be fully resolved and inferred.
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a2"), dynamicType, dynamicType);
   }
 
   // Test inference of instance fields across units with cycles
   void test_perform_inference_cross_unit_static_instance() {
     List<Source> sources = newSources({
       '/a.dart': '''
@@ skipping 17 matching lines @@
             // inference in A now works.
             x = A.a1;
             x = new A().a2;
           }
     '''
     });
     InterfaceType intType = context.typeProvider.intType;
     DartType dynamicType = context.typeProvider.dynamicType;
 
     computeResult(
-        new LibrarySpecificUnit(sources[1], sources[1]), RESOLVED_UNIT7);
-    CompilationUnit unit1 = outputs[RESOLVED_UNIT7];
+        new LibrarySpecificUnit(sources[1], sources[1]), RESOLVED_UNIT8);
+    CompilationUnit unit1 = outputs[RESOLVED_UNIT8];
 
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "B", "b1"), intType, intType);
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "B", "b2"), dynamicType, intType);
 
     computeResult(
-        new LibrarySpecificUnit(sources[0], sources[0]), RESOLVED_UNIT7);
-    CompilationUnit unit0 = outputs[RESOLVED_UNIT7];
+        new LibrarySpecificUnit(sources[0], sources[0]), RESOLVED_UNIT8);
+    CompilationUnit unit0 = outputs[RESOLVED_UNIT8];
 
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a1"), intType, intType);
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a2"), dynamicType, intType);
 
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "B", "b1"), intType, intType);
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "B", "b2"), intType, intType);
 
     computeResult(
-        new LibrarySpecificUnit(sources[2], sources[2]), RESOLVED_UNIT7);
+        new LibrarySpecificUnit(sources[2], sources[2]), RESOLVED_UNIT8);
 
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a1"), intType, intType);
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a2"), intType, intType);
 
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "B", "b1"), intType, intType);
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "B", "b2"), intType, intType);
@@ skipping 18 matching lines @@
           test1() {
             int x = 0;
             x = new A().a2;
           }
     '''
     });
     InterfaceType intType = context.typeProvider.intType;
     DartType dynamicType = context.typeProvider.dynamicType;
 
     computeResult(
-        new LibrarySpecificUnit(sources[0], sources[0]), RESOLVED_UNIT7);
-    CompilationUnit unit0 = outputs[RESOLVED_UNIT7];
+        new LibrarySpecificUnit(sources[0], sources[0]), RESOLVED_UNIT8);
+    CompilationUnit unit0 = outputs[RESOLVED_UNIT8];
 
     // A.a2 should now be resolved on the rhs, but not yet inferred.
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a2"), dynamicType, dynamicType);
 
     // B.b2 shoud be resolved on the rhs, but not yet inferred.
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "B", "b2"), dynamicType, intType);
 
     computeResult(
-        new LibrarySpecificUnit(sources[1], sources[1]), RESOLVED_UNIT7);
+        new LibrarySpecificUnit(sources[1], sources[1]), RESOLVED_UNIT8);
 
     // A.a2 should now be fully resolved and inferred.
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a2"), dynamicType, dynamicType);
 
     // B.b2 should now be fully resolved and inferred.
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "B", "b2"), intType, intType);
   }
 }
@@ skipping 68 matching lines @@
 void f() {
   var c = new C();
   c.m();
 }
 class C {
   void m() {
     f();
   }
 }
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT9,
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT10,
         matcher: isResolveUnitTask);
-    CompilationUnit unit = outputs[RESOLVED_UNIT9];
+    CompilationUnit unit = outputs[RESOLVED_UNIT10];
 
     FunctionDeclaration f = unit.declarations[0];
     _assertResolved(f.functionExpression.body);
 
     MethodDeclaration m = (unit.declarations[1] as ClassDeclaration).members[0];
     _assertResolved(m.body);
 
     expect(outputs[RESOLVE_UNIT_ERRORS], hasLength(0));
   }
 
@@ skipping 233 matching lines @@
   // Check that even within a static variable cycle, inferred
   // types get propagated to the members of the cycle.
   void test_perform_cycle() {
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 var piFirst = true;
 var pi = piFirst ? 3.14 : tau / 2;
 var tau = piFirst ? pi * 2 : 6.28;
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT9);
-    CompilationUnit unit = outputs[RESOLVED_UNIT9];
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT10);
+    CompilationUnit unit = outputs[RESOLVED_UNIT10];
     VariableElement piFirst =
         getTopLevelVariable(unit, 'piFirst').name.staticElement;
     VariableElement pi = getTopLevelVariable(unit, 'pi').name.staticElement;
     VariableElement tau = getTopLevelVariable(unit, 'tau').name.staticElement;
     Expression piFirstUse = (getTopLevelVariable(unit, 'tau').initializer
         as ConditionalExpression).condition;
 
     expect(piFirstUse.staticType, context.typeProvider.boolType);
     expect(piFirst.type, context.typeProvider.boolType);
     expect(pi.type.isDynamic, isTrue);
@@ skipping 17 matching lines @@
 
           test1() {
             int t = 3;
             t = x;
             t = y;
             t = A.x;
             t = B.y;
           }
 ''');
     computeResult(
-        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT9);
-    CompilationUnit unit1 = outputs[RESOLVED_UNIT9];
+        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT10);
+    CompilationUnit unit1 = outputs[RESOLVED_UNIT10];
     computeResult(
-        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT9);
-    CompilationUnit unit2 = outputs[RESOLVED_UNIT9];
+        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT10);
+    CompilationUnit unit2 = outputs[RESOLVED_UNIT10];
 
     InterfaceType intType = context.typeProvider.intType;
 
     assertVariableDeclarationTypes(
         getTopLevelVariable(unit1, "x"), intType, intType);
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "A", "x"), intType, intType);
 
     assertVariableDeclarationTypes(
         getTopLevelVariable(unit2, "y"), intType, intType);
@@ skipping 26 matching lines @@
       '/main.dart': '''
           import "a.dart";
 
           test1() {
             int x = 0;
             x = new A().a2;
           }
     '''
     });
     List<dynamic> units =
-        computeLibraryResults(sources, RESOLVED_UNIT9).toList();
+        computeLibraryResults(sources, RESOLVED_UNIT10).toList();
     CompilationUnit unit0 = units[0];
     CompilationUnit unit1 = units[1];
     CompilationUnit unit2 = units[2];
 
     InterfaceType intType = context.typeProvider.intType;
 
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a2"), intType, intType);
 
     assertVariableDeclarationTypes(
@@ skipping 26 matching lines @@
       ''',
       '/c.dart': '''
           import 'b.dart';
             var bar = new B();
             void foo() {
               String x = bar.f.z;
             }
     '''
     });
     List<dynamic> units =
-        computeLibraryResults(sources, RESOLVED_UNIT9).toList();
+        computeLibraryResults(sources, RESOLVED_UNIT10).toList();
     CompilationUnit unit0 = units[0];
     CompilationUnit unit2 = units[2];
 
     InterfaceType intType = context.typeProvider.intType;
     InterfaceType stringType = context.typeProvider.stringType;
 
     assertVariableDeclarationStatementTypes(
         getStatementsInTopLevelFunction(unit0, "foo")[0], stringType, intType);
     assertVariableDeclarationStatementTypes(
         getStatementsInTopLevelFunction(unit2, "foo")[0], stringType, intType);
@@ skipping 16 matching lines @@
           class B { static var y = A.x; }
 
           test1() {
             x = /*severe:StaticTypeError*/"hi";
             y = /*severe:StaticTypeError*/"hi";
             A.x = /*severe:StaticTypeError*/"hi";
             B.y = /*severe:StaticTypeError*/"hi";
           }
 ''');
     computeResult(
-        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT9);
-    CompilationUnit unit1 = outputs[RESOLVED_UNIT9];
+        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT10);
+    CompilationUnit unit1 = outputs[RESOLVED_UNIT10];
     computeResult(
-        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT9);
-    CompilationUnit unit2 = outputs[RESOLVED_UNIT9];
+        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT10);
+    CompilationUnit unit2 = outputs[RESOLVED_UNIT10];
 
     InterfaceType intType = context.typeProvider.intType;
     InterfaceType stringType = context.typeProvider.stringType;
 
     assertVariableDeclarationTypes(
         getTopLevelVariable(unit1, "x"), intType, intType);
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "A", "x"), intType, intType);
 
     assertVariableDeclarationTypes(
@@ skipping 29 matching lines @@
 
           test1() {
             int x = 0;
             // inference in A now works.
             x = A.a1;
             x = new A().a2;
           }
     '''
     });
     List<dynamic> units =
-        computeLibraryResults(sources, RESOLVED_UNIT9).toList();
+        computeLibraryResults(sources, RESOLVED_UNIT10).toList();
     CompilationUnit unit0 = units[0];
     CompilationUnit unit1 = units[1];
     CompilationUnit unit2 = units[2];
 
     InterfaceType intType = context.typeProvider.intType;
 
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a1"), intType, intType);
     assertVariableDeclarationTypes(
         getFieldInClass(unit0, "A", "a2"), intType, intType);
@@ skipping 15 matching lines @@
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
       test() {
         int x = 3;
         x = "hi";
         var y = 3;
         y = "hi";
       }
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT9);
-    CompilationUnit unit = outputs[RESOLVED_UNIT9];
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT10);
+    CompilationUnit unit = outputs[RESOLVED_UNIT10];
 
     InterfaceType intType = context.typeProvider.intType;
     InterfaceType stringType = context.typeProvider.stringType;
 
     List<Statement> statements = getStatementsInTopLevelFunction(unit, "test");
 
     assertVariableDeclarationStatementTypes(statements[0], intType, intType);
     assertAssignmentStatementTypes(statements[1], intType, stringType);
     assertVariableDeclarationStatementTypes(statements[2], intType, intType);
     assertAssignmentStatementTypes(statements[3], intType, stringType);
@@ skipping 16 matching lines @@
           b = 4;
           var c = z;
           c = "hi";
           c = 4;
         }
 
         int y; // field def after use
         final z = 42; // should infer `int`
       }
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT9);
-    CompilationUnit unit = outputs[RESOLVED_UNIT9];
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT10);
+    CompilationUnit unit = outputs[RESOLVED_UNIT10];
 
     InterfaceType intType = context.typeProvider.intType;
     InterfaceType stringType = context.typeProvider.stringType;
 
     List<Statement> statements = getStatementsInMethod(unit, "A", "test1");
 
     assertVariableDeclarationStatementTypes(statements[0], intType, intType);
     assertAssignmentStatementTypes(statements[1], intType, stringType);
     assertAssignmentStatementTypes(statements[2], intType, intType);
 
@@ skipping 26 matching lines @@
         b = /*severe:StaticTypeError*/"hi";
         b = 4;
         var c = z;
         c = /*severe:StaticTypeError*/"hi";
         c = 4;
       }
 
       int y = 0; // field def after use
       final z = 42; // should infer `int`
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT9);
-    CompilationUnit unit = outputs[RESOLVED_UNIT9];
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT10);
+    CompilationUnit unit = outputs[RESOLVED_UNIT10];
 
     InterfaceType intType = context.typeProvider.intType;
     InterfaceType stringType = context.typeProvider.stringType;
 
     List<Statement> statements = getStatementsInTopLevelFunction(unit, "test1");
 
     assertVariableDeclarationStatementTypes(statements[0], intType, intType);
     assertAssignmentStatementTypes(statements[1], intType, stringType);
     assertAssignmentStatementTypes(statements[2], intType, intType);
 
@@ skipping 30 matching lines @@
 
       test() {
         x = "hi";
         y = /*severe:StaticTypeError*/"hi";
         A.x = "hi";
         A.y = /*severe:StaticTypeError*/"hi";
         new A().x2 = "hi";
         new A().y2 = /*severe:StaticTypeError*/"hi";
       }
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT9);
-    CompilationUnit unit = outputs[RESOLVED_UNIT9];
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT10);
+    CompilationUnit unit = outputs[RESOLVED_UNIT10];
 
     InterfaceType intType = context.typeProvider.intType;
     InterfaceType stringType = context.typeProvider.stringType;
     DartType bottomType = context.typeProvider.bottomType;
     DartType dynamicType = context.typeProvider.dynamicType;
 
     assertVariableDeclarationTypes(
         getTopLevelVariable(unit, "x"), dynamicType, bottomType);
     assertVariableDeclarationTypes(
         getTopLevelVariable(unit, "y"), intType, intType);
@@ skipping 19 matching lines @@
   // Test inference between fields and method bodies
   void test_perform_local_explicit_disabled() {
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
       test() {
         int x = 3;
         x = "hi";
       }
 ''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT9);
-    CompilationUnit unit = outputs[RESOLVED_UNIT9];
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT10);
+    CompilationUnit unit = outputs[RESOLVED_UNIT10];
 
     InterfaceType intType = context.typeProvider.intType;
     InterfaceType stringType = context.typeProvider.stringType;
 
     List<Statement> statements = getStatementsInTopLevelFunction(unit, "test");
     VariableDeclaration decl =
         (statements[0] as VariableDeclarationStatement).variables.variables[0];
     expect(decl.element.type, intType);
     expect(decl.initializer.staticType, intType);
 
@@ skipping 253 matching lines @@
             return field;
           }
         }
       }
     }
     fail('No field named $fieldName in $className');
     return null;
   }
 
   /**
+   * Return the element of the field with the given [fieldName] in the class
+   * with the given [className] in the given compilation [unit].
+   */
+  FieldElement getFieldInClassElement(
+      CompilationUnit unit, String className, String fieldName) {
+    return getFieldInClass(unit, className, fieldName)?.name?.staticElement;
+  }
+
+  /**
    * Return the declaration of the method with the given [methodName] in the
    * class with the given [className] in the given compilation [unit].
    */
   MethodDeclaration getMethodInClass(
       CompilationUnit unit, String className, String methodName) {
     ClassDeclaration unitMember = getClass(unit, className);
     NodeList<ClassMember> classMembers = unitMember.members;
     for (ClassMember classMember in classMembers) {
       if (classMember is MethodDeclaration) {
         if (classMember.name.name == methodName) {
@@ skipping 50 matching lines @@
         for (VariableDeclaration variable in variables) {
           if (variable.name.name == variableName) {
             return variable;
           }
         }
       }
     }
     return null;
   }
 
+  /**
+   * Return the top-level variable element with the given [name].
+   */
+  TopLevelVariableElement getTopLevelVariableElement(
+      CompilationUnit unit, String name) {
+    return getTopLevelVariable(unit, name)?.name?.staticElement;
+  }
+
   void setUp() {
     super.setUp();
     emptySource = newSource('/test.dart');
   }
 
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result];
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }