Resolve ordering issues.

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/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 61 matching lines @@
  */
 final ListResultDescriptor<AnalysisError> BUILD_LIBRARY_ERRORS =
     new ListResultDescriptor<AnalysisError>(
         'BUILD_LIBRARY_ERRORS', AnalysisError.NO_ERRORS);
 
 /**
  * A list of the [ConstantEvaluationTarget]s defined in a unit.  This includes
  * constants defined at top level, statically inside classes, and local to
  * functions, as well as constant constructors, annotations, and default values
  * of parameters to constant constructors.
+ *
+ * The result is only available for [LibrarySpecificUnit]s.
  */
 final ListResultDescriptor<
         ConstantEvaluationTarget> COMPILATION_UNIT_CONSTANTS =
     new ListResultDescriptor<ConstantEvaluationTarget>(
         'COMPILATION_UNIT_CONSTANTS', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
 /**
  * The element model associated with a single compilation unit.
  *
@@ skipping 13 matching lines @@
  * constructor, or a parameter element with a default value).
  */
 final ListResultDescriptor<ConstantEvaluationTarget> CONSTANT_DEPENDENCIES =
     new ListResultDescriptor<ConstantEvaluationTarget>(
         'CONSTANT_DEPENDENCIES', const <ConstantEvaluationTarget>[]);
 
 /**
  * A [ConstantEvaluationTarget] that has been successfully constant-evaluated.
  *
  * TODO(paulberry): is ELEMENT_CACHING_POLICY the correct caching policy?
+ *
+ * The result is only available for [ConstantEvaluationTarget]s.
+ *
  */
 final ResultDescriptor<ConstantEvaluationTarget> CONSTANT_VALUE =
     new ResultDescriptor<ConstantEvaluationTarget>('CONSTANT_VALUE', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
 /**
  * The sources representing the libraries that include a given source as a part.
  *
  * The result is only available for [Source]s representing a compilation unit.
  */
@@ skipping 23 matching lines @@
 /**
  * The sources representing the combined import/export closure of a library.
  * The [Source]s include only library sources, not their units.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ListResultDescriptor<Source> IMPORT_EXPORT_SOURCE_CLOSURE =
     new ListResultDescriptor<Source>('IMPORT_EXPORT_SOURCE_CLOSURE', null);
 
 /**
- * The errors produced while inferring the type of a static variable.
+ * A list of the [LibraryElement]s that make up the strongly connected
+ * component in the import/export graph in which the target resides.
  *
- * The list will be empty if there were no errors, but will not be `null`.
- *
- * The result is only available for [VariableElement]s, and only when strong
- * mode is enabled.
- */
-final ListResultDescriptor<AnalysisError> INFER_STATIC_VARIABLE_ERRORS =
-    new ListResultDescriptor<AnalysisError>(
-        'INFER_STATIC_VARIABLE_ERRORS', AnalysisError.NO_ERRORS);
-
-/**
- * The errors produced while inferring the types of all of the static variables
- * in a compilation unit.
- *
- * The list will be empty if there were no errors, but will not be `null`.
+ * Only non-empty in strongMode
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
-final ListResultDescriptor<AnalysisError> INFER_STATIC_VARIABLE_TYPES_ERRORS =
-    new ListResultDescriptor<AnalysisError>(
-        'INFER_STATIC_VARIABLE_TYPES_ERRORS', AnalysisError.NO_ERRORS);
+final ListResultDescriptor<LibraryElement> LIBRARY_CYCLE =
+    new ListResultDescriptor<LibraryElement>('LIBRARY_CYCLE', null);
+
+/**
+ * A list of the [CompilationUnitElement]s (including all parts) that make up
+ * the strongly connected component in the import/export graph in which the
+ * target resides.
+ *
+ * Only non-empty in strongMode
+ *
+ * The result is only available for [LibrarySpecificUnit]s.
+ */
+final ListResultDescriptor<CompilationUnitElement> LIBRARY_CYCLE_UNITS =
+    new ListResultDescriptor<CompilationUnitElement>(
+        'LIBRARY_CYCLE_UNITS', null);
+
+/**
+ * A list of the [CompilationUnitElement]s that comprise all of the parts and
+ * libraries in the direct import/export dependencies of the library cycle
+ * of the target, with the intra-component dependencies excluded.
+ *
+ * Only non-empty in strongMode
+ *
+ * The result is only available for [LibrarySpecificUnit]s.
+ */
+final ListResultDescriptor<CompilationUnitElement> LIBRARY_CYCLE_DEPENDENCIES =
+    new ListResultDescriptor<CompilationUnitElement>(
+        'LIBRARY_CYCLE_DEPENDENCIES', null);
 
 /**
  * A list of the [VariableElement]s whose type should be inferred that another
  * inferable static variable (the target) depends on.
  *
  * The result is only available for [VariableElement]s, and only when strong
  * mode is enabled.
  */
 final ListResultDescriptor<
         VariableElement> INFERABLE_STATIC_VARIABLE_DEPENDENCIES =
@@ skipping 118 matching lines @@
  *
  * 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.
  */
 final ListResultDescriptor<AnalysisError> PARSE_ERRORS =
     new ListResultDescriptor<AnalysisError>(
         'PARSE_ERRORS', AnalysisError.NO_ERRORS);
 
 /**
- * The errors produced while resolving references outside of function bodies.
- *
- * The list will be empty if there were no errors, but will not be `null`.
- *
- * The result is only available for [LibrarySpecificUnit]s.
- */
-final ListResultDescriptor<AnalysisError> PARTIALLY_RESOLVE_REFERENCES_ERRORS =
-    new ListResultDescriptor<AnalysisError>(
-        'PARTIALLY_RESOLVE_REFERENCES_ERRORS', AnalysisError.NO_ERRORS);
-
-/**
  * The names (resolved and not) referenced by a unit.
  *
  * The result is only available for [Source]s representing a compilation unit.
  */
 final ResultDescriptor<ReferencedNames> REFERENCED_NAMES =
     new ResultDescriptor<ReferencedNames>('REFERENCED_NAMES', null);
 
 /**
- * The errors produced while resolving the function bodies within a compilation
- * unit.
+ * The errors produced while resolving a full compilation unit. 
  *
  * The list will be empty if there were no errors, but will not be `null`.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
-final ListResultDescriptor<AnalysisError> RESOLVE_FUNCTION_BODIES_ERRORS =
+final ListResultDescriptor<AnalysisError> RESOLVE_UNIT_ERRORS =
     new ListResultDescriptor<AnalysisError>(
-        'RESOLVE_FUNCTION_BODIES_ERRORS', AnalysisError.NO_ERRORS);
+        'RESOLVE_UNIT_ERRORS', AnalysisError.NO_ERRORS);
 
 /**
  * The errors produced while resolving type names.
  *
  * The list will be empty if there were no errors, but will not be `null`.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ListResultDescriptor<AnalysisError> RESOLVE_TYPE_NAMES_ERRORS =
     new ListResultDescriptor<AnalysisError>(
@@ skipping 60 matching lines @@
  * that is true of a [RESOLVED_UNIT5].
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT6 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT6', 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_UNIT7].
+ * the right hand sides of instance variables have been re-resolved in addition
+ * to everything that is true of a [RESOLVED_UNIT6].
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT7 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT7', null,
         cachingPolicy: AST_CACHING_POLICY);
 
 /**
- * The resolved [CompilationUnit] associated with a compilation unit, with
- * constants not yet 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_UNIT8].

[Brian Wilkerson, 2015/10/07 22:56:56]

nit: "8" --> "7"

  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT8 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT8', null,
         cachingPolicy: AST_CACHING_POLICY);
 
 /**
+ * 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_UNIT9 =
+    new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT9', null,
+        cachingPolicy: AST_CACHING_POLICY);
+
+/**
  * 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.
  */
 final ListResultDescriptor<AnalysisError> SCAN_ERRORS =
     new ListResultDescriptor<AnalysisError>(
         'SCAN_ERRORS', AnalysisError.NO_ERRORS);
 
@@ skipping 1031 matching lines @@
       AnalysisContext context, AnalysisTarget target) {
     return new BuildTypeProviderTask(context, target);
   }
 }
 
 /**
  * A task that computes [CONSTANT_DEPENDENCIES] for a constant.
  */
 class ComputeConstantDependenciesTask extends ConstantEvaluationAnalysisTask {
   /**
-   * The name of the [RESOLVED_UNIT8] input.
+   * The name of the [RESOLVED_UNIT9] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ComputeConstantDependenciesTask',
@@ skipping 35 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) {
     if (target is Element) {
       CompilationUnitElementImpl unit = target
           .getAncestor((Element element) => element is CompilationUnitElement);
       return <String, TaskInput>{
-        UNIT_INPUT: RESOLVED_UNIT8
+        UNIT_INPUT: RESOLVED_UNIT9
             .of(new LibrarySpecificUnit(unit.librarySource, target.source)),
         TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
       };
     } else if (target is ConstantEvaluationTarget_Annotation) {
       return <String, TaskInput>{
-        UNIT_INPUT: RESOLVED_UNIT8
+        UNIT_INPUT: RESOLVED_UNIT9
             .of(new LibrarySpecificUnit(target.librarySource, target.source)),
         TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
       };
     }
     throw new AnalysisException(
         'Cannot build inputs for a ${target.runtimeType}');
   }
 
   /**
    * Create a [ComputeConstantDependenciesTask] based on the given [target] in
@@ skipping 178 matching lines @@
    * Create a [ComputeInferableStaticVariableDependenciesTask] based on the
    * given [target] in the given [context].
    */
   static ComputeInferableStaticVariableDependenciesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ComputeInferableStaticVariableDependenciesTask(context, target);
   }
 }
 
 /**
+ * A task that computes the [LIBRARY_CYCLE] for a
+ * library element.  Also computes the [LIBRARY_CYCLE_UNITS] and the
+ * [LIBRARY_CYCLE_DEPENDENCIES].
+ */
+class ComputeLibraryCycleTask extends SourceBasedAnalysisTask {
+  /**
+   * The name of the [LIBRARY_ELEMENT2] input.
+   */
+  static const String LIBRARY_ELEMENT_INPUT = 'LIBRARY_ELEMENT_INPUT';
+
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'ComputeLibraryCycleForUnitTask',
+      createTask,
+      buildInputs, <ResultDescriptor>[
+    LIBRARY_CYCLE,
+    LIBRARY_CYCLE_UNITS,
+    LIBRARY_CYCLE_DEPENDENCIES
+  ]);
+
+  ComputeLibraryCycleTask(
+      InternalAnalysisContext context, AnalysisTarget target)
+      : super(context, target);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  void internalPerform() {
+    if (context.analysisOptions.strongMode) {
+      LibraryElementImpl library = getRequiredInput(LIBRARY_ELEMENT_INPUT);
+      List<LibraryElement> component = library.libraryCycle;
+      Set<LibraryElement> filter = new Set<LibraryElement>.from(component);
+      Set<CompilationUnitElement> deps = new Set<CompilationUnitElement>();
+      void addLibrary(l) {
+        if (!filter.contains(l)) {
+          deps.addAll(l.units);
+        }
+      }
+      for (LibraryElement l in component) {
+        l.importedLibraries.forEach(addLibrary);
+        l.exportedLibraries.forEach(addLibrary);
+      }
+
+      //
+      // Record outputs.
+      //
+      outputs[LIBRARY_CYCLE] = component;
+      outputs[LIBRARY_CYCLE_UNITS] = component.expand((l) => l.units).toList();
+      outputs[LIBRARY_CYCLE_DEPENDENCIES] = deps.toList();
+    } else {
+      outputs[LIBRARY_CYCLE] = [];
+      outputs[LIBRARY_CYCLE_UNITS] = [];
+      outputs[LIBRARY_CYCLE_DEPENDENCIES] = [];
+    }
+  }
+
+  /**
+   * 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>{
+      'resolveReachableLibraries': IMPORT_EXPORT_SOURCE_CLOSURE
+          .of(unit.library)
+          .toListOf(LIBRARY_ELEMENT2),
+      LIBRARY_ELEMENT_INPUT: LIBRARY_ELEMENT2.of(unit.library)
+    };
+  }
+
+  /**
+   * 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 base class for analysis tasks whose target is expected to be a
  * [ConstantEvaluationTarget].
  */
 abstract class ConstantEvaluationAnalysisTask extends AnalysisTask {
   /**
    * Initialize a newly created task to perform analysis within the given
    * [context] in order to produce results for the given [constant].
    */
   ConstantEvaluationAnalysisTask(
       AnalysisContext context, ConstantEvaluationTarget constant)
@@ skipping 238 matching lines @@
       AnalysisContext context, AnalysisTarget target) {
     return new DartErrorsTask(context, target);
   }
 }
 
 /**
  * A task that builds [RESOLVED_UNIT] for a unit.
  */
 class EvaluateUnitConstantsTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [RESOLVED_UNIT8] input.
+   * The name of the [RESOLVED_UNIT9] 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.
@@ 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) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       'libraryElement': LIBRARY_ELEMENT.of(unit.library),
-      UNIT_INPUT: RESOLVED_UNIT8.of(unit),
+      UNIT_INPUT: RESOLVED_UNIT9.of(unit),
       CONSTANT_VALUES:
           COMPILATION_UNIT_CONSTANTS.of(unit).toListOf(CONSTANT_VALUE)
     };
   }
 
   /**
    * Create an [EvaluateUnitConstantsTask] based on the given [target] in
    * the given [context].
    */
   static EvaluateUnitConstantsTask createTask(
@@ skipping 103 matching lines @@
     }
     return newNames;
   }
 }
 
 /**
  * A task that builds [USED_IMPORTED_ELEMENTS] for a unit.
  */
 class GatherUsedImportedElementsTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [RESOLVED_UNIT8] input.
+   * The name of the [RESOLVED_UNIT9] 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_UNIT8.of(unit)};
+    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT9.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_UNIT8] input.
+   * The name of the [RESOLVED_UNIT9] 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_UNIT8.of(unit)};
+    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT9.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_UNIT8] input.
+   * The name of the [RESOLVED_UNIT9] 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 216 matching lines @@
    */
   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>[RESOLVED_UNIT7]);
+      <ResultDescriptor>[RESOLVED_UNIT8]);
 
   /**
    * 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 10 matching lines @@
     // Infer instance members.
     //
     if (context.analysisOptions.strongMode) {
       InstanceMemberInferrer inferrer = new InstanceMemberInferrer(typeProvider,
           typeSystem: context.typeSystem);
       inferrer.inferCompilationUnit(unit.element);
     }
     //
     // Record outputs.
     //
-    outputs[RESOLVED_UNIT7] = unit;
+    outputs[RESOLVED_UNIT8] = unit;
   }
 
   /**
    * 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_UNIT6.of(unit),
-      TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
+      UNIT_INPUT: RESOLVED_UNIT7.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).toList(
+          (CompilationUnitElementImpl unit) => RESOLVED_UNIT7
+              .of(new LibrarySpecificUnit(unit.librarySource, unit.source))),
+      // Require that full inference be complete for all dependencies of the
+      // current library cycle.
+      'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit).toList(
+          (CompilationUnitElementImpl unit) => RESOLVED_UNIT8
+              .of(new LibrarySpecificUnit(unit.librarySource, unit.source)))
     };
   }
 
   /**
    * Create a [InferInstanceMembersInUnitTask] based on the given [target] in
    * the given [context].
    */
   static InferInstanceMembersInUnitTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new InferInstanceMembersInUnitTask(context, target);
   }
 }
 
 /**
+ * A task that ensures that all of the inferrable instance members in a
+ * compilation unit have had their right hand sides re-resolved
+ */
+class ResolveInstanceFieldsInUnitTask extends SourceBasedAnalysisTask {
+  /**
+   * The name of the [LIBRARY_ELEMENT5] 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_UNIT6] 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>[RESOLVED_UNIT7]);
+
+  /**
+   * 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
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  void internalPerform() {
+    //
+    // Prepare inputs.
+    //
+    LibraryElement libraryElement = getRequiredInput(LIBRARY_INPUT);
+    CompilationUnit unit = getRequiredInput(UNIT_INPUT);
+    TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
+
+    CompilationUnitElement unitElement = unit.element;
+    if (context.analysisOptions.strongMode) {
+      //
+      // Resolve references.
+      //
+      // TODO(leafp): This code only needs to re-resolve the right hand sides of
+      // instance fields.  We could do incremental resolution on each field
+      // only using the incremental resolver.  However, this caused a massive
+      // performance degredation on the large_class_declaration_test.dart test.
+      // I would hypothesize that incremental resolution of field is linear in
+      // the size of the enclosing class, and hence incrementally resolving each
+      // field was quadratic.  We may wish to revisit this if we can resolve
+      // this performance issue.
+      InheritanceManager inheritanceManager =
+          new InheritanceManager(libraryElement);
+      PartialResolverVisitor visitor = new PartialResolverVisitor(
+          libraryElement,
+          unitElement.source,
+          typeProvider,
+          AnalysisErrorListener.NULL_LISTENER,
+          inheritanceManager: inheritanceManager);
+      unit.accept(visitor);
+    }
+    //
+    // Record outputs.
+    //
+    outputs[RESOLVED_UNIT7] = unit;
+  }
+
+  /**
+   * 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_UNIT6.of(unit),
+      LIBRARY_INPUT: LIBRARY_ELEMENT5.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).toList(
+          (CompilationUnitElementImpl unit) => RESOLVED_UNIT6
+              .of(new LibrarySpecificUnit(unit.librarySource, unit.source))),
+      // Require that full inference be complete for all dependencies of the
+      // current library cycle.
+      'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit).toList(
+          (CompilationUnitElementImpl unit) => RESOLVED_UNIT8
+              .of(new LibrarySpecificUnit(unit.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);
+  }
+}
+
+/**
  * An abstract class that defines utility methods that are useful for tasks
  * operating on static variables.
  */
 abstract class InferStaticVariableTask extends ConstantEvaluationAnalysisTask {
   InferStaticVariableTask(
       InternalAnalysisContext context, VariableElement variable)
       : super(context, variable);
 
   /**
    * Return the declaration of the target within the given compilation [unit].
@@ skipping 24 matching lines @@
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The name of the input whose value is a list of the inferrable static
    * variables whose types have been computed.
    */
   static const String INFERRED_VARIABLES_INPUT = 'INFERRED_VARIABLES_INPUT';
 
   /**
-   * The name of the input whose value is a list of the errors produced while
-   * inferring types for static variables.
-   */
-  static const String INFER_STATIC_VARIABLE_ERRORS_INPUT =
-      'INFER_STATIC_VARIABLE_ERRORS';
-
-  /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'InferStaticVariableTypesInUnitTask',
       createTask,
       buildInputs,
-      <ResultDescriptor>[INFER_STATIC_VARIABLE_TYPES_ERRORS, RESOLVED_UNIT6]);
+      <ResultDescriptor>[RESOLVED_UNIT6]);
 
   /**
    * 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>> perVariableErrors =
-        getRequiredInput(INFER_STATIC_VARIABLE_ERRORS_INPUT);
-    List<AnalysisError> errors = <AnalysisError>[];
-    for (List<AnalysisError> variableErrors in perVariableErrors) {
-      errors.addAll(variableErrors);
-    }
     //
     // 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[INFER_STATIC_VARIABLE_TYPES_ERRORS] = errors;
     outputs[RESOLVED_UNIT6] = unit;
   }
 
   /**
    * 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>{
       INFERRED_VARIABLES_INPUT: INFERABLE_STATIC_VARIABLES_IN_UNIT
           .of(unit)
           .toListOf(INFERRED_STATIC_VARIABLE),
-      INFER_STATIC_VARIABLE_ERRORS_INPUT: INFERABLE_STATIC_VARIABLES_IN_UNIT
-          .of(unit)
-          .toListOf(INFER_STATIC_VARIABLE_ERRORS),
       UNIT_INPUT: RESOLVED_UNIT5.of(unit)
     };
   }
 
   /**
    * Create a [InferStaticVariableTypesInUnitTask] based on the given [target]
    * in the given [context].
    */
   static InferStaticVariableTypesInUnitTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 18 matching lines @@
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
    * The name of the [RESOLVED_UNIT5] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'InferStaticVariableTypeTask',
       createTask,
-      buildInputs, <ResultDescriptor>[
-    INFER_STATIC_VARIABLE_ERRORS,
-    INFERRED_STATIC_VARIABLE
-  ]);
+      buildInputs,
+      <ResultDescriptor>[INFERRED_STATIC_VARIABLE]);
 
   InferStaticVariableTypeTask(
       InternalAnalysisContext context, VariableElement variable)
       : super(context, variable);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   bool get handlesDependencyCycles => true;
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     // Note: DEPENDENCIES_INPUT is not needed.  It is merely a bookkeeping
     // dependency to ensure that the variables that this variable references
     // have types inferred before inferring the type of this variable.
     //
     VariableElementImpl variable = target;
 
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
-    RecordingErrorListener errorListener = new RecordingErrorListener();
-    VariableDeclaration declaration = getDeclaration(unit);
-    //
-    // Re-resolve the variable's initializer so that the inferred types of other
-    // variables will be propagated.
-    //
-    Expression initializer = declaration.initializer;
-    ResolutionEraser.erase(initializer, eraseDeclarations: false);
-    ResolutionContext resolutionContext =
-        ResolutionContextBuilder.contextFor(initializer, errorListener);
-    ResolverVisitor visitor = new ResolverVisitor(
-        variable.library, variable.source, typeProvider, errorListener,
-        nameScope: resolutionContext.scope);
-    if (resolutionContext.enclosingClassDeclaration != null) {
-      visitor.prepareToResolveMembersInClass(
-          resolutionContext.enclosingClassDeclaration);
-    }
-    visitor.initForIncrementalResolution();
-    initializer.accept(visitor);
 
     // If we're not in a dependency cycle, and we have no type annotation,
-    // do inference.
+    // re-resolve the right hand side and do inference.
     if (dependencyCycle == null && variable.hasImplicitType) {
+      VariableDeclaration declaration = getDeclaration(unit);
+      //
+      // Re-resolve the variable's initializer so that the inferred types
+      // of other variables will be propagated.
+      //
+      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.staticType;
       if (newType == null || newType.isBottom) {
         newType = typeProvider.dynamicType;
       }
       variable.type = newType;
       (variable.initializer as ExecutableElementImpl).returnType = newType;
       if (variable is PropertyInducingElementImpl) {
         setReturnType(variable.getter, newType);
         if (!variable.isFinal && !variable.isConst) {
           setParameterType(variable.setter, newType);
         }
       }
     } else {
       // TODO(brianwilkerson) For now we simply don't infer any type for
       // variables or fields involved in a cycle. We could try to be smarter
       // by re-resolving the initializer in a context in which the types of all
       // of the variables in the cycle are assumed to be `null`, but it isn't
       // clear to me that this would produce better results often enough to
       // warrant the extra effort.
     }
     //
     // Record outputs.
     //
     outputs[INFERRED_STATIC_VARIABLE] = variable;
-    outputs[INFER_STATIC_VARIABLE_ERRORS] = errorListener.errors;
   }
 
   /**
    * 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;
     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_UNIT5.of(unit)
+      UNIT_INPUT: RESOLVED_UNIT5.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).toList(
+          (CompilationUnitElementImpl unit) => RESOLVED_UNIT8
+              .of(new LibrarySpecificUnit(unit.librarySource, unit.source)))
     };
   }
 
   /**
    * Create a [InferStaticVariableTypeTask] based on the given [target] in the
    * given [context].
    */
   static InferStaticVariableTypeTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new InferStaticVariableTypeTask(context, target);
@@ skipping 66 matching lines @@
    * The name of the [HINTS] input.
    */
   static const String HINTS_INPUT = 'HINTS';
 
   /**
    * The name of the [LINTS] input.
    */
   static const String LINTS_INPUT = 'LINTS';
 
   /**
-   * The name of the [INFER_STATIC_VARIABLE_TYPES_ERRORS] input.
-   */
-  static const String INFER_STATIC_VARIABLE_TYPES_ERRORS_INPUT =
-      'INFER_STATIC_VARIABLE_TYPES_ERRORS';
-
-  /**
-   * The name of the [PARTIALLY_RESOLVE_REFERENCES_ERRORS] input.
-   */
-  static const String PARTIALLY_RESOLVE_REFERENCES_ERRORS_INPUT =
-      'PARTIALLY_RESOLVE_REFERENCES_ERRORS';
-
-  /**
-   * The name of the [RESOLVE_FUNCTION_BODIES_ERRORS] input.
-   */
-  static const String RESOLVE_FUNCTION_BODIES_ERRORS_INPUT =
-      'RESOLVE_FUNCTION_BODIES_ERRORS';
-
-  /**
    * The name of the [RESOLVE_TYPE_NAMES_ERRORS] input.
    */
   static const String RESOLVE_TYPE_NAMES_ERRORS_INPUT =
       'RESOLVE_TYPE_NAMES_ERRORS';
 
   /**
+   * The name of the [RESOLVE_UNIT_ERRORS] input.
+   */
+  static const String RESOLVE_UNIT_ERRORS_INPUT = 'RESOLVE_UNIT_ERRORS';
+
+  /**
    * The name of the [VARIABLE_REFERENCE_ERRORS] input.
    */
   static const String VARIABLE_REFERENCE_ERRORS_INPUT =
       'VARIABLE_REFERENCE_ERRORS';
 
   /**
    * The name of the [VERIFY_ERRORS] input.
    */
   static const String VERIFY_ERRORS_INPUT = 'VERIFY_ERRORS';
 
@@ skipping 15 matching lines @@
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     List<List<AnalysisError>> errorLists = <List<AnalysisError>>[];
     errorLists.add(getRequiredInput(BUILD_DIRECTIVES_ERRORS_INPUT));
     errorLists.add(getRequiredInput(BUILD_LIBRARY_ERRORS_INPUT));
     errorLists.add(getRequiredInput(HINTS_INPUT));
     errorLists.add(getRequiredInput(LINTS_INPUT));
-    errorLists.add(getRequiredInput(INFER_STATIC_VARIABLE_TYPES_ERRORS_INPUT));
-    errorLists.add(getRequiredInput(PARTIALLY_RESOLVE_REFERENCES_ERRORS_INPUT));
-    errorLists.add(getRequiredInput(RESOLVE_FUNCTION_BODIES_ERRORS_INPUT));
     errorLists.add(getRequiredInput(RESOLVE_TYPE_NAMES_ERRORS_INPUT));
+    errorLists.add(getRequiredInput(RESOLVE_UNIT_ERRORS_INPUT));
     errorLists.add(getRequiredInput(VARIABLE_REFERENCE_ERRORS_INPUT));
     errorLists.add(getRequiredInput(VERIFY_ERRORS_INPUT));
     //
     // Record outputs.
     //
     outputs[LIBRARY_UNIT_ERRORS] = 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 [unit].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
     Map<String, TaskInput> inputs = <String, TaskInput>{
       HINTS_INPUT: HINTS.of(unit),
       LINTS_INPUT: LINTS.of(unit),
-      INFER_STATIC_VARIABLE_TYPES_ERRORS_INPUT:
-          INFER_STATIC_VARIABLE_TYPES_ERRORS.of(unit),
-      PARTIALLY_RESOLVE_REFERENCES_ERRORS_INPUT:
-          PARTIALLY_RESOLVE_REFERENCES_ERRORS.of(unit),
-      RESOLVE_FUNCTION_BODIES_ERRORS_INPUT:
-          RESOLVE_FUNCTION_BODIES_ERRORS.of(unit),
       RESOLVE_TYPE_NAMES_ERRORS_INPUT: RESOLVE_TYPE_NAMES_ERRORS.of(unit),
+      RESOLVE_UNIT_ERRORS_INPUT: RESOLVE_UNIT_ERRORS.of(unit),
       VARIABLE_REFERENCE_ERRORS_INPUT: VARIABLE_REFERENCE_ERRORS.of(unit),
       VERIFY_ERRORS_INPUT: VERIFY_ERRORS.of(unit)
     };
     Source source = unit.source;
     if (unit.library == source) {
       inputs[BUILD_DIRECTIVES_ERRORS_INPUT] =
           BUILD_DIRECTIVES_ERRORS.of(source);
       inputs[BUILD_LIBRARY_ERRORS_INPUT] = BUILD_LIBRARY_ERRORS.of(source);
     } else {
       inputs[BUILD_DIRECTIVES_ERRORS_INPUT] =
@@ skipping 220 matching lines @@
    * The name of the [TYPE_PROVIDER] input.
    */
   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,
-    PARTIALLY_RESOLVE_REFERENCES_ERRORS,
-    RESOLVED_UNIT5
-  ]);
+      buildInputs,
+      <ResultDescriptor>[INFERABLE_STATIC_VARIABLES_IN_UNIT, RESOLVED_UNIT5]);
 
   PartiallyResolveUnitReferencesTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
-    RecordingErrorListener errorListener = new RecordingErrorListener();
     //
     // Prepare inputs.
     //
     LibraryElement libraryElement = getRequiredInput(LIBRARY_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     CompilationUnitElement unitElement = unit.element;
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
-    //
-    // Resolve references.
-    //
-    InheritanceManager inheritanceManager =
-        new InheritanceManager(libraryElement);
-    PartialResolverVisitor visitor = new PartialResolverVisitor(
-        libraryElement, unitElement.source, typeProvider, errorListener,
-        inheritanceManager: inheritanceManager);
-    unit.accept(visitor);
-    //
-    // Record outputs.
-    //
-    outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT] = visitor.variablesAndFields;
-    outputs[PARTIALLY_RESOLVE_REFERENCES_ERRORS] =
-        removeDuplicateErrors(errorListener.errors);
+    if (context.analysisOptions.strongMode) {
+      //
+      // Resolve references.
+      //
+      InheritanceManager inheritanceManager =
+          new InheritanceManager(libraryElement);
+      PartialResolverVisitor visitor = new PartialResolverVisitor(
+          libraryElement,
+          unitElement.source,
+          typeProvider,
+          AnalysisErrorListener.NULL_LISTENER,
+          inheritanceManager: inheritanceManager);
+      unit.accept(visitor);
+      //
+      // Record outputs.
+      //
+      outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT] = visitor.variablesAndFields;
+    } else {
+      outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT] = [];
+    }
     outputs[RESOLVED_UNIT5] = unit;
   }
 
   /**
    * 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': IMPORT_EXPORT_SOURCE_CLOSURE
           .of(unit.library)
           .toListOf(LIBRARY_ELEMENT5),
       LIBRARY_INPUT: LIBRARY_ELEMENT5.of(unit.library),
       UNIT_INPUT: RESOLVED_UNIT4.of(unit),
-      TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
+      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).toList(
+          (CompilationUnitElementImpl unit) => RESOLVED_UNIT8
+              .of(new LibrarySpecificUnit(unit.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);
@@ skipping 134 matching lines @@
         dependsOn.add(name);
       }
     }
   }
 }
 
 /**
  * A task that resolves the bodies of top-level functions, constructors, and
  * methods within a single compilation unit.
  */
-class ResolveFunctionBodiesInUnitTask extends SourceBasedAnalysisTask {
+class ResolveUnitTask extends SourceBasedAnalysisTask {
+  /**
+   * The name of the input whose value is the defining [LIBRARY_ELEMENT5].
+   */
+  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_UNIT7] input.
+   * The name of the [RESOLVED_UNIT8] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'ResolveFunctionBodiesInUnitTask',
+      'ResolveUnitTask',
       createTask,
       buildInputs,
-      <ResultDescriptor>[RESOLVE_FUNCTION_BODIES_ERRORS, RESOLVED_UNIT8]);
+      <ResultDescriptor>[RESOLVE_UNIT_ERRORS, RESOLVED_UNIT9]);
 
-  ResolveFunctionBodiesInUnitTask(
+  ResolveUnitTask(
       InternalAnalysisContext context, LibrarySpecificUnit compilationUnit)
       : super(context, compilationUnit);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
+    LibraryElement libraryElement = getRequiredInput(LIBRARY_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     //
-    // Resolve function bodies.
+    // Resolve everything
     //
     CompilationUnitElement unitElement = unit.element;
     RecordingErrorListener errorListener = new RecordingErrorListener();
-    for (CompilationUnitMember unitMember in unit.declarations) {
-      if (unitMember is FunctionDeclaration) {
-        _resolveFunctionBody(unitMember.functionExpression.body, unitElement,
-            typeProvider, errorListener);
-      } else if (unitMember is ClassDeclaration) {
-        for (ClassMember classMember in unitMember.members) {
-          if (classMember is ConstructorDeclaration) {
-            _resolveFunctionBody(
-                classMember.body, unitElement, typeProvider, errorListener);
-          } else if (classMember is MethodDeclaration) {
-            _resolveFunctionBody(
-                classMember.body, unitElement, typeProvider, errorListener);
-          }
-        }
-      }
-    }
+    ResolverVisitor visitor = new ResolverVisitor(
+        libraryElement, unitElement.source, typeProvider, errorListener);
+    unit.accept(visitor);
     //
     // Record outputs.
     //
-    outputs[RESOLVE_FUNCTION_BODIES_ERRORS] = errorListener.errors;
-    outputs[RESOLVED_UNIT8] = unit;
-  }
-
-  void _resolveFunctionBody(
-      FunctionBody functionBody,
-      CompilationUnitElement unitElement,
-      TypeProvider typeProvider,
-      RecordingErrorListener errorListener) {
-    ResolutionContext resolutionContext =
-        ResolutionContextBuilder.contextFor(functionBody, errorListener);
-    ResolverVisitor visitor = new ResolverVisitor(
-        unitElement.library, unitElement.source, typeProvider, errorListener,
-        nameScope: resolutionContext.scope);
-    if (resolutionContext.enclosingClassDeclaration != null) {
-      visitor.prepareToResolveMembersInClass(
-          resolutionContext.enclosingClassDeclaration);
-    }
-    Declaration declaration = functionBody.getAncestor((AstNode node) =>
-        node is ConstructorDeclaration ||
-            node is FunctionDeclaration ||
-            node is MethodDeclaration);
-    visitor.initForIncrementalResolution(declaration);
-    functionBody.accept(visitor);
-    if (declaration is FunctionDeclaration) {
-      // This is in the wrong place. The propagated return type is stored
-      // locally in the resolver, not in the declaration (or element). Hence,
-      // this needs to happen later.
-      declaration.accept(visitor.typeAnalyzer);
-    }
+    outputs[RESOLVE_UNIT_ERRORS] = errorListener.errors;
+    outputs[RESOLVED_UNIT9] = unit;
   }
 
   /**
    * 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_ELEMENT5.of(unit.library),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
-      UNIT_INPUT: RESOLVED_UNIT7.of(unit)
+      UNIT_INPUT: RESOLVED_UNIT8.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).toList(
+          (CompilationUnitElementImpl unit) => RESOLVED_UNIT8
+              .of(new LibrarySpecificUnit(unit.librarySource, unit.source)))
     };
   }
 
   /**
-   * Create a [ResolveFunctionBodiesInUnitTask] based on the given [target] in
+   * Create a [ResolveUnitTask] based on the given [target] in
    * the given [context].
    */
-  static ResolveFunctionBodiesInUnitTask createTask(
+  static ResolveUnitTask createTask(
       AnalysisContext context, AnalysisTarget target) {
-    return new ResolveFunctionBodiesInUnitTask(context, target);
+    return new ResolveUnitTask(context, target);
   }
 }
 
 /**
  * A task that finishes resolution by requesting [RESOLVED_UNIT_NO_CONSTANTS] for every
  * unit in the libraries closure and produces [LIBRARY_ELEMENT].
  */
 class ResolveLibraryReferencesTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [LIBRARY_ELEMENT5] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
-   * The name of the list of [RESOLVED_UNIT8] input.
+   * The name of the list of [RESOLVED_UNIT9] input.
    */
   static const String UNITS_INPUT = 'UNITS_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ResolveLibraryReferencesTask',
       createTask,
       buildInputs,
@@ skipping 28 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_ELEMENT5.of(source),
       UNITS_INPUT: UNITS.of(source).toList((Source unit) =>
-          RESOLVED_UNIT8.of(new LibrarySpecificUnit(source, unit))),
+          RESOLVED_UNIT9.of(new LibrarySpecificUnit(source, unit))),
       'resolvedUnits': IMPORT_EXPORT_SOURCE_CLOSURE
           .of(source)
           .toMapOf(UNITS)
           .toFlattenList((Source library, Source unit) =>
-              RESOLVED_UNIT8.of(new LibrarySpecificUnit(library, unit))),
+              RESOLVED_UNIT9.of(new LibrarySpecificUnit(library, unit))),
     };
   }
 
   /**
    * Create a [ResolveLibraryReferencesTask] based on the given [target] in
    * the given [context].
    */
   static ResolveLibraryReferencesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveLibraryReferencesTask(context, target);
@@ skipping 585 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }