Don't perform final fields and top-level variables type propagation.

pkg/analyzer/lib/src/task/dart.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 analyzer.src.task.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 228 matching lines @@
 /**
  * The flag specifying that [RESOLVED_UNIT12] has been been computed for this
  * compilation unit (without requiring that the AST for it still be in cache).
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<bool> CREATED_RESOLVED_UNIT12 =
     new ResultDescriptor<bool>('CREATED_RESOLVED_UNIT12', false);
 
 /**
- * The flag specifying that [RESOLVED_UNIT13] has been been computed for this
- * compilation unit (without requiring that the AST for it still be in cache).
- *
- * The result is only available for [LibrarySpecificUnit]s.
- */
-final ResultDescriptor<bool> CREATED_RESOLVED_UNIT13 =
-    new ResultDescriptor<bool>('CREATED_RESOLVED_UNIT13', false);
-
-/**
  * The flag specifying that [RESOLVED_UNIT2] has been been computed for this
  * compilation unit (without requiring that the AST for it still be in cache).
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<bool> CREATED_RESOLVED_UNIT2 =
     new ResultDescriptor<bool>('CREATED_RESOLVED_UNIT2', false);
 
 /**
  * The flag specifying that [RESOLVED_UNIT3] has been been computed for this
@@ skipping 251 matching lines @@
  *
  * The result is only available for [Source]s representing a library.
  */
 final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT6 =
     new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT6', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
 /**
  * The partial [LibraryElement] associated with a library.
  *
- * [LIBRARY_ELEMENT6] plus propagated types for propagable variables.
+ * [LIBRARY_ELEMENT6] plus [RESOLVED_UNIT7] for all library units.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT7 =
     new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT7', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
 /**
  * The partial [LibraryElement] associated with a library.
  *
@@ skipping 88 matching lines @@
 /**
  * The list of [PendingError]s for a compilation unit.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ListResultDescriptor<PendingError> PENDING_ERRORS =
     new ListResultDescriptor<PendingError>(
         'PENDING_ERRORS', const <PendingError>[]);
 
 /**
- * A list of the [VariableElement]s whose type should be known to propagate
- * the type of another variable (the target).
- *
- * The result is only available for [VariableElement]s.
- */
-final ListResultDescriptor<VariableElement> PROPAGABLE_VARIABLE_DEPENDENCIES =
-    new ListResultDescriptor<VariableElement>(
-        'PROPAGABLE_VARIABLE_DEPENDENCIES', null);
-
-/**
- * A list of the [VariableElement]s defined in a unit whose type might be
- * propagated. This includes variables defined at the library level as well as
- * static and instance members inside classes.
- *
- * The result is only available for [LibrarySpecificUnit]s.
- */
-final ListResultDescriptor<VariableElement> PROPAGABLE_VARIABLES_IN_UNIT =
-    new ListResultDescriptor<VariableElement>(
-        'PROPAGABLE_VARIABLES_IN_UNIT', null);
-
-/**
- * An propagable variable ([VariableElement]) whose type has been propagated.
- *
- * The result is only available for [VariableElement]s.
- */
-final ResultDescriptor<VariableElement> PROPAGATED_VARIABLE =
-    new ResultDescriptor<VariableElement>('PROPAGATED_VARIABLE', null,
-        cachingPolicy: ELEMENT_CACHING_POLICY);
-
-/**
  * The flag specifying that [LIBRARY_ELEMENT2] is ready for a library and its
  * import/export closure.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ResultDescriptor<bool> READY_LIBRARY_ELEMENT2 =
     new ResultDescriptor<bool>('READY_LIBRARY_ELEMENT2', false);
 
 /**
  * The flag specifying that [LIBRARY_ELEMENT6] is ready for a library and its
@@ skipping 91 matching lines @@
  * at all declaration sites have been bound to the element defined by the
  * declaration, except for the constants defined in an 'enum' declaration.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT1 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT1', null,
         cachingPolicy: AST_REUSABLE_CACHING_POLICY);
 
 /**
- * The partially resolved [CompilationUnit] associated with a compilation unit.
- *
- * In addition to what is true of a [RESOLVED_UNIT9], tasks that use this value
- * as an input can assume that the initializers of instance variables have been
- * re-resolved.
+ * The resolved [CompilationUnit] associated with a compilation unit in which
+ * the types of class members have been inferred in addition to everything that
+ * is true of a [RESOLVED_UNIT9].
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT10 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT10', null,
         cachingPolicy: AST_CACHING_POLICY);
 
 /**
- * The resolved [CompilationUnit] associated with a compilation unit in which
- * the types of class members have been inferred in addition to everything that
- * is true of a [RESOLVED_UNIT10].
+ * The resolved [CompilationUnit] associated with a compilation unit, with
+ * constants not yet resolved.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT11 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT11', null,
         cachingPolicy: AST_CACHING_POLICY);
 
 /**
  * The resolved [CompilationUnit] associated with a compilation unit, with
- * constants not yet resolved.
+ * constants resolved.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT12 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT12', null,
         cachingPolicy: AST_CACHING_POLICY);
 
 /**
- * The resolved [CompilationUnit] associated with a compilation unit, with
- * constants resolved.
- *
- * The result is only available for [LibrarySpecificUnit]s.
- */
-final ResultDescriptor<CompilationUnit> RESOLVED_UNIT13 =
-    new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT13', null,
-        cachingPolicy: AST_CACHING_POLICY);
-
-/**
  * The partially resolved [CompilationUnit] associated with a compilation unit.
  *
  * In addition to what is true of a [RESOLVED_UNIT1], tasks that use this value
  * as an input can assume that its directives have been resolved.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT2 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT2', null,
         cachingPolicy: AST_CACHING_POLICY);
@@ skipping 62 matching lines @@
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT7 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT7', null,
         cachingPolicy: AST_CACHING_POLICY);
 
 /**
  * The partially resolved [CompilationUnit] associated with a compilation unit.
  *
  * In addition to what is true of a [RESOLVED_UNIT7], tasks that use this value
- * as an input can assume that the types of final variables have been
- * propagated.
+ * as an input can assume that the types of static variables have been inferred.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT8 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT8', null,
         cachingPolicy: AST_CACHING_POLICY);
 
 /**
  * The partially resolved [CompilationUnit] associated with a compilation unit.
  *
  * In addition to what is true of a [RESOLVED_UNIT8], tasks that use this value
- * as an input can assume that the types of static variables have been inferred.
+ * as an input can assume that the initializers of instance variables have been
+ * re-resolved.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT9 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT9', null,
         cachingPolicy: AST_CACHING_POLICY);
 
 /**
  * List of all `RESOLVED_UNITx` results.
  */
 final List<ResultDescriptor<CompilationUnit>> RESOLVED_UNIT_RESULTS =
     <ResultDescriptor<CompilationUnit>>[
   RESOLVED_UNIT1,
   RESOLVED_UNIT2,
   RESOLVED_UNIT3,
   RESOLVED_UNIT4,
   RESOLVED_UNIT5,
   RESOLVED_UNIT6,
   RESOLVED_UNIT7,
   RESOLVED_UNIT8,
   RESOLVED_UNIT9,
   RESOLVED_UNIT10,
   RESOLVED_UNIT11,
   RESOLVED_UNIT12,
-  RESOLVED_UNIT13,
   RESOLVED_UNIT
 ];
 
 /**
  * The errors produced while scanning a compilation unit.
  *
  * The list will be empty if there were no errors, but will not be `null`.
  *
  * The result is only available for [Source]s representing a compilation unit.
  */
@@ skipping 1342 matching lines @@
    * Create a [ComputeLibraryCycleTask] based on the
    * given [target] in the given [context].
    */
   static ComputeLibraryCycleTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ComputeLibraryCycleTask(context, target);
   }
 }
 
 /**
- * A task that computes the [PROPAGABLE_VARIABLE_DEPENDENCIES] for a variable.
- */
-class ComputePropagableVariableDependenciesTask
-    extends InferStaticVariableTask {
-  /**
-   * The name of the [RESOLVED_UNIT7] input.
-   */
-  static const String UNIT_INPUT = 'UNIT_INPUT';
-
-  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'ComputePropagableVariableDependenciesTask',
-      createTask,
-      buildInputs,
-      <ResultDescriptor>[PROPAGABLE_VARIABLE_DEPENDENCIES]);
-
-  ComputePropagableVariableDependenciesTask(
-      InternalAnalysisContext context, VariableElement variable)
-      : super(context, variable);
-
-  @override
-  TaskDescriptor get descriptor => DESCRIPTOR;
-
-  @override
-  void internalPerform() {
-    //
-    // Prepare inputs.
-    //
-    CompilationUnit unit = getRequiredInput(UNIT_INPUT);
-    //
-    // Compute dependencies.
-    //
-    VariableDeclaration declaration = getDeclaration(unit);
-    VariableGatherer gatherer = new VariableGatherer(_isPropagable);
-    declaration.initializer.accept(gatherer);
-    //
-    // Record outputs.
-    //
-    outputs[PROPAGABLE_VARIABLE_DEPENDENCIES] = gatherer.results.toList();
-  }
-
-  /**
-   * Return `true` if the given [variable] is a variable whose type can be
-   * propagated.
-   */
-  bool _isPropagable(VariableElement variable) =>
-      variable is PropertyInducingElement &&
-      (variable.isConst || variable.isFinal) &&
-      variable.hasImplicitType &&
-      variable.initializer != null;
-
-  /**
-   * Return a map from the names of the inputs of this kind of task to the task
-   * input descriptors describing those inputs for a task with the
-   * given [target].
-   */
-  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
-    if (target is VariableElement) {
-      CompilationUnitElementImpl unit = target
-          .getAncestor((Element element) => element is CompilationUnitElement);
-      return <String, TaskInput>{
-        UNIT_INPUT: RESOLVED_UNIT7
-            .of(new LibrarySpecificUnit(unit.librarySource, unit.source))
-      };
-    }
-    throw new AnalysisException(
-        'Cannot build inputs for a ${target.runtimeType}');
-  }
-
-  /**
-   * Create a [ComputePropagableVariableDependenciesTask] based on the
-   * given [target] in the given [context].
-   */
-  static ComputePropagableVariableDependenciesTask createTask(
-      AnalysisContext context, AnalysisTarget target) {
-    return new ComputePropagableVariableDependenciesTask(context, target);
-  }
-}
-
-/**
  * A task that builds [REQUIRED_CONSTANTS] for a unit.
  */
 class ComputeRequiredConstantsTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [RESOLVED_UNIT] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
@@ skipping 604 matching lines @@
       // Ignores can be on the line or just preceding the error.
       return ignoreInfo.ignoredAt(errorCode, errorLine) ||
           ignoreInfo.ignoredAt(errorCode, errorLine - 1);
     }
 
     return errors.where((AnalysisError e) => !isIgnored(e)).toList();
   }
 }
 
 /**
- * A task that builds [RESOLVED_UNIT13] for a unit.
+ * A task that builds [RESOLVED_UNIT12] for a unit.
  */
 class EvaluateUnitConstantsTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [RESOLVED_UNIT12] input.
+   * The name of the [RESOLVED_UNIT11] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The name of the [CONSTANT_VALUE] input.
    */
   static const String CONSTANT_VALUES = 'CONSTANT_VALUES';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'EvaluateUnitConstantsTask',
       createTask,
       buildInputs,
-      <ResultDescriptor>[CREATED_RESOLVED_UNIT13, RESOLVED_UNIT13]);
+      <ResultDescriptor>[CREATED_RESOLVED_UNIT12, RESOLVED_UNIT12]);
 
   EvaluateUnitConstantsTask(AnalysisContext context, LibrarySpecificUnit target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     // No actual work needs to be performed; the task manager will ensure that
     // all constants are evaluated before this method is called.
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
-    outputs[RESOLVED_UNIT13] = unit;
-    outputs[CREATED_RESOLVED_UNIT13] = true;
+    outputs[RESOLVED_UNIT12] = unit;
+    outputs[CREATED_RESOLVED_UNIT12] = true;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       'libraryElement': LIBRARY_ELEMENT9.of(unit.library),
-      UNIT_INPUT: RESOLVED_UNIT12.of(unit),
+      UNIT_INPUT: RESOLVED_UNIT11.of(unit),
       CONSTANT_VALUES:
           COMPILATION_UNIT_CONSTANTS.of(unit).toListOf(CONSTANT_VALUE),
       'constantExpressionsDependencies':
           CONSTANT_EXPRESSIONS_DEPENDENCIES.of(unit).toListOf(CONSTANT_VALUE)
     };
   }
 
   /**
    * Create an [EvaluateUnitConstantsTask] based on the given [target] in
    * the given [context].
    */
   static EvaluateUnitConstantsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new EvaluateUnitConstantsTask(context, target);
   }
 }
 
 /**
  * A task that builds [USED_IMPORTED_ELEMENTS] for a unit.
  */
 class GatherUsedImportedElementsTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [RESOLVED_UNIT12] input.
+   * The name of the [RESOLVED_UNIT11] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'GatherUsedImportedElementsTask',
       createTask,
       buildInputs,
@@ skipping 23 matching lines @@
     outputs[USED_IMPORTED_ELEMENTS] = visitor.usedElements;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
-    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT12.of(unit)};
+    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT11.of(unit)};
   }
 
   /**
    * Create a [GatherUsedImportedElementsTask] based on the given [target] in
    * the given [context].
    */
   static GatherUsedImportedElementsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new GatherUsedImportedElementsTask(context, target);
   }
 }
 
 /**
  * A task that builds [USED_LOCAL_ELEMENTS] for a unit.
  */
 class GatherUsedLocalElementsTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [RESOLVED_UNIT12] input.
+   * The name of the [RESOLVED_UNIT11] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'GatherUsedLocalElementsTask',
       createTask,
       buildInputs,
@@ skipping 23 matching lines @@
     outputs[USED_LOCAL_ELEMENTS] = visitor.usedElements;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
-    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT12.of(unit)};
+    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT11.of(unit)};
   }
 
   /**
    * Create a [GatherUsedLocalElementsTask] based on the given [target] in
    * the given [context].
    */
   static GatherUsedLocalElementsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new GatherUsedLocalElementsTask(context, target);
   }
 }
 
 /**
  * A task that generates [HINTS] for a unit.
  */
 class GenerateHintsTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [RESOLVED_UNIT12] input.
+   * The name of the [RESOLVED_UNIT11] input.
    */
   static const String RESOLVED_UNIT_INPUT = 'RESOLVED_UNIT';
 
   /**
    * The name of a list of [USED_LOCAL_ELEMENTS] for each library unit input.
    */
   static const String USED_LOCAL_ELEMENTS_INPUT = 'USED_LOCAL_ELEMENTS';
 
   /**
    * The name of a list of [USED_IMPORTED_ELEMENTS] for each library unit input.
@@ skipping 277 matching lines @@
  * A task that ensures that all of the inferable instance members in a
  * compilation unit have had their type inferred.
  */
 class InferInstanceMembersInUnitTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
-   * The name of the input whose value is the [RESOLVED_UNIT9] for the
+   * The name of the input whose value is the [RESOLVED_UNIT8] for the
    * compilation unit.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'InferInstanceMembersInUnitTask',
       createTask,
       buildInputs,
-      <ResultDescriptor>[CREATED_RESOLVED_UNIT11, RESOLVED_UNIT11]);
+      <ResultDescriptor>[CREATED_RESOLVED_UNIT10, RESOLVED_UNIT10]);
 
   /**
    * Initialize a newly created task to build a library element for the given
    * [unit] in the given [context].
    */
   InferInstanceMembersInUnitTask(
       InternalAnalysisContext context, LibrarySpecificUnit unit)
       : super(context, unit);
 
   @override
@@ skipping 11 matching lines @@
     //
     if (context.analysisOptions.strongMode) {
       InstanceMemberInferrer inferrer = new InstanceMemberInferrer(
           typeProvider, new InheritanceManager(unit.element.library),
           typeSystem: context.typeSystem);
       inferrer.inferCompilationUnit(unit.element);
     }
     //
     // Record outputs.
     //
-    outputs[RESOLVED_UNIT11] = unit;
-    outputs[CREATED_RESOLVED_UNIT11] = true;
+    outputs[RESOLVED_UNIT10] = unit;
+    outputs[CREATED_RESOLVED_UNIT10] = true;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [libSource].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
-      UNIT_INPUT: RESOLVED_UNIT10.of(unit),
+      UNIT_INPUT: RESOLVED_UNIT9.of(unit),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
       // In strong mode, add additional dependencies to enforce inference
       // ordering.
 
       // Require that field re-resolution be complete for all units in the
       // current library cycle.
       'orderLibraryCycleTasks': LIBRARY_CYCLE_UNITS.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT10.of(
+          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT9.of(
               new LibrarySpecificUnit(
                   (unit as CompilationUnitElementImpl).librarySource,
                   unit.source))),
       // Require that full inference be complete for all dependencies of the
       // current library cycle.
       'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT11.of(
+          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT10.of(
               new LibrarySpecificUnit(
                   (unit as CompilationUnitElementImpl).librarySource,
                   unit.source)))
     };
   }
 
   /**
    * Create a [InferInstanceMembersInUnitTask] based on the given [target] in
    * the given [context].
    */
@@ skipping 83 matching lines @@
    */
   static const String ERRORS_LIST_INPUT = 'INFERRED_VARIABLES_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'InferStaticVariableTypesInUnitTask',
       createTask,
       buildInputs, <ResultDescriptor>[
-    CREATED_RESOLVED_UNIT9,
-    RESOLVED_UNIT9,
+    CREATED_RESOLVED_UNIT8,
+    RESOLVED_UNIT8,
     STATIC_VARIABLE_RESOLUTION_ERRORS_IN_UNIT
   ]);
 
   /**
    * Initialize a newly created task to build a library element for the given
    * [unit] in the given [context].
    */
   InferStaticVariableTypesInUnitTask(
       InternalAnalysisContext context, LibrarySpecificUnit unit)
       : super(context, unit);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     List<List<AnalysisError>> errorLists = getRequiredInput(ERRORS_LIST_INPUT);
     //
     // Record outputs. There is no additional work to be done at this time
     // because the work has implicitly been done by virtue of the task model
     // preparing all of the inputs.
     //
-    outputs[RESOLVED_UNIT9] = unit;
-    outputs[CREATED_RESOLVED_UNIT9] = true;
+    outputs[RESOLVED_UNIT8] = unit;
+    outputs[CREATED_RESOLVED_UNIT8] = true;
     outputs[STATIC_VARIABLE_RESOLUTION_ERRORS_IN_UNIT] =
         AnalysisError.mergeLists(errorLists);
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [libSource].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       'inferredTypes': INFERABLE_STATIC_VARIABLES_IN_UNIT
           .of(unit)
           .toListOf(INFERRED_STATIC_VARIABLE),
       ERRORS_LIST_INPUT: INFERABLE_STATIC_VARIABLES_IN_UNIT
           .of(unit)
           .toListOf(STATIC_VARIABLE_RESOLUTION_ERRORS),
-      UNIT_INPUT: RESOLVED_UNIT8.of(unit)
+      UNIT_INPUT: RESOLVED_UNIT7.of(unit)
     };
   }
 
   /**
    * Create a [InferStaticVariableTypesInUnitTask] based on the given [target]
    * in the given [context].
    */
   static InferStaticVariableTypesInUnitTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new InferStaticVariableTypesInUnitTask(context, target);
@@ skipping 107 matching lines @@
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     VariableElement variable = target;
     LibrarySpecificUnit unit =
         new LibrarySpecificUnit(variable.library.source, variable.source);
     return <String, TaskInput>{
       DEPENDENCIES_INPUT: INFERABLE_STATIC_VARIABLE_DEPENDENCIES
           .of(variable)
           .toListOf(INFERRED_STATIC_VARIABLE),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
-      UNIT_INPUT: RESOLVED_UNIT8.of(unit),
+      UNIT_INPUT: RESOLVED_UNIT7.of(unit),
       // In strong mode, add additional dependencies to enforce inference
       // ordering.
 
       // Require that full inference be complete for all dependencies of the
       // current library cycle.
       'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT11.of(
+          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT10.of(
               new LibrarySpecificUnit(
                   (unit as CompilationUnitElementImpl).librarySource,
                   unit.source)))
     };
   }
 
   /**
    * Create a [InferStaticVariableTypeTask] based on the given [target] in the
    * given [context].
    */
@@ skipping 439 matching lines @@
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'PartiallyResolveUnitReferencesTask',
       createTask,
       buildInputs, <ResultDescriptor>[
     INFERABLE_STATIC_VARIABLES_IN_UNIT,
-    PROPAGABLE_VARIABLES_IN_UNIT,
     CREATED_RESOLVED_UNIT7,
     RESOLVED_UNIT7
   ]);
 
   PartiallyResolveUnitReferencesTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
@@ skipping 14 matching lines @@
         unitElement.source, typeProvider, AnalysisErrorListener.NULL_LISTENER);
     unit.accept(visitor);
     //
     // Record outputs.
     //
     if (context.analysisOptions.strongMode) {
       outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT] = visitor.staticVariables;
     } else {
       outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT] = VariableElement.EMPTY_LIST;
     }
-    outputs[PROPAGABLE_VARIABLES_IN_UNIT] = visitor.propagableVariables;
     outputs[RESOLVED_UNIT7] = unit;
     outputs[CREATED_RESOLVED_UNIT7] = true;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       'fullyBuiltLibraryElements': READY_LIBRARY_ELEMENT6.of(unit.library),
       LIBRARY_INPUT: LIBRARY_ELEMENT6.of(unit.library),
       UNIT_INPUT: RESOLVED_UNIT6.of(unit),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
       // In strong mode, add additional dependencies to enforce inference
       // ordering.
 
       // Require that full inference be complete for all dependencies of the
       // current library cycle.
       'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT11.of(
+          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT10.of(
               new LibrarySpecificUnit(
                   (unit as CompilationUnitElementImpl).librarySource,
                   unit.source)))
     };
   }
 
   /**
    * Create a [PartiallyResolveUnitReferencesTask] based on the given [target]
    * in the given [context].
    */
   static PartiallyResolveUnitReferencesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new PartiallyResolveUnitReferencesTask(context, target);
   }
 }
 
 /**
- * An artificial task that does nothing except to force propagated types for
- * all propagable variables in the import/export closure a library.
- */
-class PropagateVariableTypesInLibraryClosureTask
-    extends SourceBasedAnalysisTask {
-  /**
-   * The name of the [LIBRARY_ELEMENT7] input.
-   */
-  static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
-
-  /**
-   * The task descriptor describing this kind of task.
-   */
-  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'PropagateVariableTypesInLibraryClosureTask',
-      createTask,
-      buildInputs,
-      <ResultDescriptor>[LIBRARY_ELEMENT8]);
-
-  PropagateVariableTypesInLibraryClosureTask(
-      InternalAnalysisContext context, AnalysisTarget target)
-      : super(context, target);
-
-  @override
-  TaskDescriptor get descriptor => DESCRIPTOR;
-
-  @override
-  void internalPerform() {
-    LibraryElement library = getRequiredInput(LIBRARY_INPUT);
-    outputs[LIBRARY_ELEMENT8] = library;
-  }
-
-  /**
-   * Return a map from the names of the inputs of this kind of task to the task
-   * input descriptors describing those inputs for a task with the
-   * given [target].
-   */
-  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
-    Source source = target;
-    return <String, TaskInput>{
-      'readyForClosure': READY_LIBRARY_ELEMENT7.of(source),
-      LIBRARY_INPUT: LIBRARY_ELEMENT7.of(source),
-    };
-  }
-
-  /**
-   * Create a [PropagateVariableTypesInLibraryClosureTask] based on the given
-   * [target] in the given [context].
-   */
-  static PropagateVariableTypesInLibraryClosureTask createTask(
-      AnalysisContext context, AnalysisTarget target) {
-    return new PropagateVariableTypesInLibraryClosureTask(context, target);
-  }
-}
-
-/**
- * An artificial task that does nothing except to force propagated types for
- * all propagable variables in the defining and part units of a library.
- */
-class PropagateVariableTypesInLibraryTask extends SourceBasedAnalysisTask {
-  /**
-   * The name of the [LIBRARY_ELEMENT6] input.
-   */
-  static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
-
-  /**
-   * The task descriptor describing this kind of task.
-   */
-  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'PropagateVariableTypesInLibraryTask',
-      createTask,
-      buildInputs,
-      <ResultDescriptor>[LIBRARY_ELEMENT7]);
-
-  PropagateVariableTypesInLibraryTask(
-      InternalAnalysisContext context, AnalysisTarget target)
-      : super(context, target);
-
-  @override
-  TaskDescriptor get descriptor => DESCRIPTOR;
-
-  @override
-  void internalPerform() {
-    LibraryElement library = getRequiredInput(LIBRARY_INPUT);
-    outputs[LIBRARY_ELEMENT7] = library;
-  }
-
-  /**
-   * Return a map from the names of the inputs of this kind of task to the task
-   * input descriptors describing those inputs for a task with the
-   * given [target].
-   */
-  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
-    Source source = target;
-    return <String, TaskInput>{
-      'propagatedVariableTypesInUnits':
-          LIBRARY_SPECIFIC_UNITS.of(source).toListOf(RESOLVED_UNIT8),
-      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(source),
-    };
-  }
-
-  /**
-   * Create a [PropagateVariableTypesInLibraryTask] based on the given [target]
-   * in the given [context].
-   */
-  static PropagateVariableTypesInLibraryTask createTask(
-      AnalysisContext context, AnalysisTarget target) {
-    return new PropagateVariableTypesInLibraryTask(context, target);
-  }
-}
-
-/**
- * A task that ensures that all of the propagable variables in a compilation
- * unit have had their type propagated.
- */
-class PropagateVariableTypesInUnitTask extends SourceBasedAnalysisTask {
-  /**
-   * The name of the input whose value is the [RESOLVED_UNIT7] for the
-   * compilation unit.
-   */
-  static const String UNIT_INPUT = 'UNIT_INPUT';
-
-  /**
-   * The task descriptor describing this kind of task.
-   */
-  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'PropagateVariableTypesInUnitTask',
-      createTask,
-      buildInputs,
-      <ResultDescriptor>[CREATED_RESOLVED_UNIT8, RESOLVED_UNIT8]);
-
-  PropagateVariableTypesInUnitTask(
-      InternalAnalysisContext context, LibrarySpecificUnit unit)
-      : super(context, unit);
-
-  @override
-  TaskDescriptor get descriptor => DESCRIPTOR;
-
-  @override
-  void internalPerform() {
-    //
-    // Prepare inputs.
-    //
-    CompilationUnit unit = getRequiredInput(UNIT_INPUT);
-    //
-    // Record outputs. There is no additional work to be done at this time
-    // because the work has implicitly been done by virtue of the task model
-    // preparing all of the inputs.
-    //
-    outputs[RESOLVED_UNIT8] = unit;
-    outputs[CREATED_RESOLVED_UNIT8] = true;
-  }
-
-  /**
-   * Return a map from the names of the inputs of this kind of task to the task
-   * input descriptors describing those inputs for a task with the given
-   * [target].
-   */
-  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
-    LibrarySpecificUnit unit = target;
-    return <String, TaskInput>{
-      'variables':
-          PROPAGABLE_VARIABLES_IN_UNIT.of(unit).toListOf(PROPAGATED_VARIABLE),
-      UNIT_INPUT: RESOLVED_UNIT7.of(unit)
-    };
-  }
-
-  /**
-   * Create a [PropagateVariableTypesInUnitTask] based on the given [target]
-   * in the given [context].
-   */
-  static PropagateVariableTypesInUnitTask createTask(
-      AnalysisContext context, AnalysisTarget target) {
-    return new PropagateVariableTypesInUnitTask(context, target);
-  }
-}
-
-/**
- * A task that computes the propagated type of an propagable variable and
- * stores it in the element model.
- */
-class PropagateVariableTypeTask extends InferStaticVariableTask {
-  /**
-   * The name of the [TYPE_PROVIDER] input.
-   */
-  static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
-
-  /**
-   * The name of the [RESOLVED_UNIT7] input.
-   */
-  static const String UNIT_INPUT = 'UNIT_INPUT';
-
-  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'PropagateVariableTypeTask',
-      createTask,
-      buildInputs,
-      <ResultDescriptor>[PROPAGATED_VARIABLE]);
-
-  PropagateVariableTypeTask(
-      InternalAnalysisContext context, VariableElement variable)
-      : super(context, variable);
-
-  @override
-  TaskDescriptor get descriptor => DESCRIPTOR;
-
-  @override
-  bool get handlesDependencyCycles => true;
-
-  @override
-  void internalPerform() {
-    //
-    // Prepare inputs.
-    //
-    PropertyInducingElementImpl variable = target;
-    TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
-    CompilationUnit unit = getRequiredInput(UNIT_INPUT);
-
-    // If we're not in a dependency cycle, and we have no type annotation,
-    // re-resolve the right hand side and do propagation.
-    if (dependencyCycle == null && variable.hasImplicitType) {
-      VariableDeclaration declaration = getDeclaration(unit);
-      //
-      // Re-resolve the variable's initializer with the propagated types of
-      // other variables.
-      //
-      Expression initializer = declaration.initializer;
-      ResolutionContext resolutionContext = ResolutionContextBuilder.contextFor(
-          initializer, AnalysisErrorListener.NULL_LISTENER);
-      ResolverVisitor visitor = new ResolverVisitor(variable.library,
-          variable.source, typeProvider, AnalysisErrorListener.NULL_LISTENER,
-          nameScope: resolutionContext.scope);
-      if (resolutionContext.enclosingClassDeclaration != null) {
-        visitor.prepareToResolveMembersInClass(
-            resolutionContext.enclosingClassDeclaration);
-      }
-      visitor.initForIncrementalResolution();
-      initializer.accept(visitor);
-      //
-      // Record the type of the variable.
-      //
-      DartType newType = initializer.bestType;
-      if (newType != null && !newType.isBottom && !newType.isDynamic) {
-        variable.propagatedType = newType;
-      }
-    }
-    //
-    // Record outputs.
-    //
-    outputs[PROPAGATED_VARIABLE] = variable;
-  }
-
-  /**
-   * Return a map from the names of the inputs of this kind of task to the task
-   * input descriptors describing those inputs for a task with the given
-   * [target].
-   */
-  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
-    VariableElement variable = target;
-    if (variable.library == null) {
-      StringBuffer buffer = new StringBuffer();
-      buffer.write(
-          'PropagateVariableTypeTask building inputs for a variable with no library. Variable name = "');
-      buffer.write(variable.name);
-      buffer.write('". Path = ');
-      (variable as ElementImpl).appendPathTo(buffer);
-      throw new AnalysisException(buffer.toString());
-    }
-    LibrarySpecificUnit unit =
-        new LibrarySpecificUnit(variable.library.source, variable.source);
-    return <String, TaskInput>{
-      'dependencies': PROPAGABLE_VARIABLE_DEPENDENCIES
-          .of(variable)
-          .toListOf(PROPAGATED_VARIABLE),
-      TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
-      UNIT_INPUT: RESOLVED_UNIT7.of(unit),
-    };
-  }
-
-  /**
-   * Create a [PropagateVariableTypeTask] based on the given [target] in the
-   * given [context].
-   */
-  static PropagateVariableTypeTask createTask(
-      AnalysisContext context, AnalysisTarget target) {
-    return new PropagateVariableTypeTask(context, target);
-  }
-}
-
-/**
  * A task that ensures that [LIBRARY_ELEMENT2] is ready for the target library
  * source and its import/export closure.
  */
 class ReadyLibraryElement2Task extends SourceBasedAnalysisTask {
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ReadyLibraryElement2Task',
       createTask,
       buildInputs,
       <ResultDescriptor>[READY_LIBRARY_ELEMENT2]);
 
@@ skipping 69 matching lines @@
   static ReadyLibraryElement5Task createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ReadyLibraryElement5Task(context, target);
   }
 }
 
 /**
  * A task that ensures that [LIBRARY_ELEMENT7] is ready for the target library
  * source and its import/export closure.
  */
-class ReadyLibraryElement6Task extends SourceBasedAnalysisTask {
+class ReadyLibraryElement7Task extends SourceBasedAnalysisTask {
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'ReadyLibraryElement6Task',
+      'ReadyLibraryElement7Task',
       createTask,
       buildInputs,
       <ResultDescriptor>[READY_LIBRARY_ELEMENT7]);
 
-  ReadyLibraryElement6Task(
+  ReadyLibraryElement7Task(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   bool get handlesDependencyCycles => true;
 
   @override
   void internalPerform() {
     outputs[READY_LIBRARY_ELEMENT7] = true;
   }
 
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     Source source = target;
     return <String, TaskInput>{
       'thisLibraryElementReady': LIBRARY_ELEMENT7.of(source),
       'directlyImportedLibrariesReady':
           IMPORTED_LIBRARIES.of(source).toListOf(READY_LIBRARY_ELEMENT7),
       'directlyExportedLibrariesReady':
           EXPORTED_LIBRARIES.of(source).toListOf(READY_LIBRARY_ELEMENT7),
     };
   }
 
-  static ReadyLibraryElement6Task createTask(
+  static ReadyLibraryElement7Task createTask(
       AnalysisContext context, AnalysisTarget target) {
-    return new ReadyLibraryElement6Task(context, target);
+    return new ReadyLibraryElement7Task(context, target);
   }
 }
 
 /**
  * A task that ensures that [RESOLVED_UNIT] is ready for every unit of the
  * target library source and its import/export closure.
  */
 class ReadyResolvedUnitTask extends SourceBasedAnalysisTask {
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ReadyResolvedUnitTask',
@@ skipping 468 matching lines @@
       CompilationUnitElementImpl unit = target
           .getAncestor((Element element) => element is CompilationUnitElement);
       librarySource = unit.librarySource;
     } else if (target is ElementAnnotationImpl) {
       librarySource = target.librarySource;
     } else {
       throw new AnalysisException(
           'Cannot build inputs for a ${target.runtimeType}');
     }
     return <String, TaskInput>{
-      'createdResolvedUnit': CREATED_RESOLVED_UNIT12
+      'createdResolvedUnit': CREATED_RESOLVED_UNIT11
           .of(new LibrarySpecificUnit(librarySource, target.source))
     };
   }
 
   /**
    * Create a [ResolveConstantExpressionTask] based on the given [target] in
    * the given [context].
    */
   static ResolveConstantExpressionTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 69 matching lines @@
    * Create a [ResolveDirectiveElementsTask] based on the given [target] in
    * the given [context].
    */
   static ResolveDirectiveElementsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveDirectiveElementsTask(context, target);
   }
 }
 
 /**
+ * An artificial task that does nothing except to force [LIBRARY_ELEMENT7] for
+ * the target library and its import/export closure.
+ */
+class ResolvedUnit7InLibraryClosureTask extends SourceBasedAnalysisTask {
+  /**
+   * The name of the [LIBRARY_ELEMENT7] input.
+   */
+  static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
+
+  /**
+   * The task descriptor describing this kind of task.
+   */
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'ResolvedUnit7InLibraryClosureTask',
+      createTask,
+      buildInputs,
+      <ResultDescriptor>[LIBRARY_ELEMENT8]);
+
+  ResolvedUnit7InLibraryClosureTask(
+      InternalAnalysisContext context, AnalysisTarget target)
+      : super(context, target);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  void internalPerform() {
+    LibraryElement library = getRequiredInput(LIBRARY_INPUT);
+    outputs[LIBRARY_ELEMENT8] = library;
+  }
+
+  /**
+   * Return a map from the names of the inputs of this kind of task to the task
+   * input descriptors describing those inputs for a task with the
+   * given [target].
+   */
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
+    return <String, TaskInput>{
+      'readyForClosure': READY_LIBRARY_ELEMENT7.of(source),
+      LIBRARY_INPUT: LIBRARY_ELEMENT7.of(source),
+    };
+  }
+
+  /**
+   * Create a [ResolvedUnit7InLibraryClosureTask] based on the given
+   * [target] in the given [context].
+   */
+  static ResolvedUnit7InLibraryClosureTask createTask(
+      AnalysisContext context, AnalysisTarget target) {
+    return new ResolvedUnit7InLibraryClosureTask(context, target);
+  }
+}
+
+/**
+ * An artificial task that does nothing except to force [LIBRARY_ELEMENT6] and
+ * [RESOLVED_UNIT7] in the defining and part units of a library.
+ */
+class ResolvedUnit7InLibraryTask extends SourceBasedAnalysisTask {
+  /**
+   * The name of the [LIBRARY_ELEMENT6] input.
+   */
+  static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
+
+  /**
+   * The task descriptor describing this kind of task.
+   */
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'ResolvedUnit7InLibraryTask',
+      createTask,
+      buildInputs,
+      <ResultDescriptor>[LIBRARY_ELEMENT7]);
+
+  ResolvedUnit7InLibraryTask(
+      InternalAnalysisContext context, AnalysisTarget target)
+      : super(context, target);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  void internalPerform() {
+    LibraryElement library = getRequiredInput(LIBRARY_INPUT);
+    outputs[LIBRARY_ELEMENT7] = library;
+  }
+
+  /**
+   * Return a map from the names of the inputs of this kind of task to the task
+   * input descriptors describing those inputs for a task with the
+   * given [target].
+   */
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
+    return <String, TaskInput>{
+      'resolvedUnits':
+          LIBRARY_SPECIFIC_UNITS.of(source).toListOf(RESOLVED_UNIT7),
+      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(source),
+    };
+  }
+
+  /**
+   * Create a [ResolvedUnit7InLibraryTask] based on the given [target]
+   * in the given [context].
+   */
+  static ResolvedUnit7InLibraryTask createTask(
+      AnalysisContext context, AnalysisTarget target) {
+    return new ResolvedUnit7InLibraryTask(context, target);
+  }
+}
+
+/**
  * A task that ensures that all of the inferable instance members in a
  * compilation unit have had their right hand sides re-resolved
  */
 class ResolveInstanceFieldsInUnitTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [LIBRARY_ELEMENT6] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
-   * The name of the input whose value is the [RESOLVED_UNIT9] for the
+   * The name of the input whose value is the [RESOLVED_UNIT8] for the
    * compilation unit.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ResolveInstanceFieldsInUnitTask',
       createTask,
       buildInputs,
-      <ResultDescriptor>[CREATED_RESOLVED_UNIT10, RESOLVED_UNIT10]);
+      <ResultDescriptor>[CREATED_RESOLVED_UNIT9, RESOLVED_UNIT9]);
 
   /**
    * Initialize a newly created task to build a library element for the given
    * [unit] in the given [context].
    */
   ResolveInstanceFieldsInUnitTask(
       InternalAnalysisContext context, LibrarySpecificUnit unit)
       : super(context, unit);
 
   @override
@@ skipping 16 matching lines @@
       InstanceFieldResolverVisitor visitor = new InstanceFieldResolverVisitor(
           libraryElement,
           unitElement.source,
           typeProvider,
           AnalysisErrorListener.NULL_LISTENER);
       visitor.resolveCompilationUnit(unit);
     }
     //
     // Record outputs.
     //
-    outputs[RESOLVED_UNIT10] = unit;
-    outputs[CREATED_RESOLVED_UNIT10] = true;
+    outputs[RESOLVED_UNIT9] = unit;
+    outputs[CREATED_RESOLVED_UNIT9] = true;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [libSource].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
-      UNIT_INPUT: RESOLVED_UNIT9.of(unit),
+      UNIT_INPUT: RESOLVED_UNIT8.of(unit),
       LIBRARY_INPUT: LIBRARY_ELEMENT6.of(unit.library),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
       // In strong mode, add additional dependencies to enforce inference
       // ordering.
 
       // Require that static variable inference  be complete for all units in
       // the current library cycle.
       'orderLibraryCycleTasks': LIBRARY_CYCLE_UNITS.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT9.of(
+          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT8.of(
               new LibrarySpecificUnit(
                   (unit as CompilationUnitElementImpl).librarySource,
                   unit.source))),
       // Require that full inference be complete for all dependencies of the
       // current library cycle.
       'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT11.of(
+          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT10.of(
               new LibrarySpecificUnit(
                   (unit as CompilationUnitElementImpl).librarySource,
                   unit.source)))
     };
   }
 
   /**
    * Create a [ResolveInstanceFieldsInUnitTask] based on the given [target] in
    * the given [context].
    */
   static ResolveInstanceFieldsInUnitTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveInstanceFieldsInUnitTask(context, target);
   }
 }
 
 /**
- * A task that finishes resolution by requesting [RESOLVED_UNIT12] for every
+ * A task that finishes resolution by requesting [RESOLVED_UNIT11] for every
  * unit in the libraries closure and produces [LIBRARY_ELEMENT9].
  */
 class ResolveLibraryReferencesTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [LIBRARY_ELEMENT8] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
@@ skipping 20 matching lines @@
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     Source source = target;
     return <String, TaskInput>{
       LIBRARY_INPUT: LIBRARY_ELEMENT8.of(source),
       'resolvedUnits':
-          LIBRARY_SPECIFIC_UNITS.of(source).toListOf(RESOLVED_UNIT12),
+          LIBRARY_SPECIFIC_UNITS.of(source).toListOf(RESOLVED_UNIT11),
     };
   }
 
   /**
    * Create a [ResolveLibraryReferencesTask] based on the given [target] in
    * the given [context].
    */
   static ResolveLibraryReferencesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveLibraryReferencesTask(context, target);
   }
 }
 
 /**
- * A task that finishes resolution by requesting [RESOLVED_UNIT13] for every
+ * A task that finishes resolution by requesting [RESOLVED_UNIT12] for every
  * unit in the libraries closure and produces [LIBRARY_ELEMENT].
  */
 class ResolveLibraryTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [LIBRARY_ELEMENT9] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
-   * The name of the list of [RESOLVED_UNIT13] input.
+   * The name of the list of [RESOLVED_UNIT12] input.
    */
   static const String UNITS_INPUT = 'UNITS_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ResolveLibraryTask',
       createTask,
       buildInputs,
@@ skipping 279 matching lines @@
    * The name of the input whose value is the defining [LIBRARY_ELEMENT8].
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
-   * The name of the [RESOLVED_UNIT11] input.
+   * The name of the [RESOLVED_UNIT10] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ResolveUnitTask', createTask, buildInputs, <ResultDescriptor>[
     CONSTANT_EXPRESSIONS_DEPENDENCIES,
     RESOLVE_UNIT_ERRORS,
-    CREATED_RESOLVED_UNIT12,
-    RESOLVED_UNIT12
+    CREATED_RESOLVED_UNIT11,
+    RESOLVED_UNIT11
   ]);
 
   ResolveUnitTask(
       InternalAnalysisContext context, LibrarySpecificUnit compilationUnit)
       : super(context, compilationUnit);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
@@ skipping 25 matching lines @@
     }
     //
     // Record outputs.
     //
     // TODO(brianwilkerson) This task modifies the element model (by copying the
     // AST's for constructor initializers into it) but does not produce an
     // updated version of the element model.
     //
     outputs[CONSTANT_EXPRESSIONS_DEPENDENCIES] = constExprDependencies;
     outputs[RESOLVE_UNIT_ERRORS] = getTargetSourceErrors(errorListener, target);
-    outputs[RESOLVED_UNIT12] = unit;
-    outputs[CREATED_RESOLVED_UNIT12] = true;
+    outputs[RESOLVED_UNIT11] = unit;
+    outputs[CREATED_RESOLVED_UNIT11] = true;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       LIBRARY_INPUT: LIBRARY_ELEMENT8.of(unit.library),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
-      UNIT_INPUT: RESOLVED_UNIT11.of(unit),
+      UNIT_INPUT: RESOLVED_UNIT10.of(unit),
       // In strong mode, add additional dependencies to enforce inference
       // ordering.
 
       // Require that inference be complete for all units in the
       // current library cycle.
       'orderLibraryCycleTasks': LIBRARY_CYCLE_UNITS.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT11.of(
+          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT10.of(
               new LibrarySpecificUnit(
                   (unit as CompilationUnitElementImpl).librarySource,
                   unit.source)))
     };
   }
 
   /**
    * Create a [ResolveUnitTask] based on the given [target] in
    * the given [context].
    */
@@ skipping 334 matching lines @@
     return TaskSuitability.NONE;
   }
 }
 
 /**
  * A task that builds [STRONG_MODE_ERRORS] for a unit.  Also builds
  * [RESOLVED_UNIT] for a unit.
  */
 class StrongModeVerifyUnitTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [RESOLVED_UNIT13] input.
+   * The name of the [RESOLVED_UNIT12] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
@@ skipping 40 matching lines @@
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
-      UNIT_INPUT: RESOLVED_UNIT13.of(unit),
+      UNIT_INPUT: RESOLVED_UNIT12.of(unit),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
     };
   }
 
   /**
    * Create a [StrongModeVerifyUnitTask] based on the given [target] in
    * the given [context].
    */
   static StrongModeVerifyUnitTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 306 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }