Add the task to resolve function bodies

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 144 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.
+ *
+ * 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`.
+ *
+ * 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);
+
+/**
  * 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 =
     new ListResultDescriptor<VariableElement>(
         'INFERABLE_STATIC_VARIABLE_DEPENDENCIES', null);
 
 /**
  * A list of the [VariableElement]s defined in a unit whose type should be
  * inferred. This includes variables defined at the library level as well as
  * static members inside classes.
  *
  * The result is only available for [LibrarySpecificUnit]s, and only when strong
  * mode is enabled.
  */
 final ListResultDescriptor<VariableElement> INFERABLE_STATIC_VARIABLES_IN_UNIT =
     new ListResultDescriptor<VariableElement>(
         'INFERABLE_STATIC_VARIABLES_IN_UNIT', null);
 
 /**
  * An inferrable static variable ([VariableElement]) whose type has been
  * inferred.
+ *
+ * The result is only available for [VariableElement]s, and only when strong
+ * mode is enabled.
  */
 final ResultDescriptor<VariableElement> INFERRED_STATIC_VARIABLE =
     new ResultDescriptor<VariableElement>('INFERRED_STATIC_VARIABLE', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
 /**
  * The partial [LibraryElement] associated with a library.
  *
  * The [LibraryElement] and its [CompilationUnitElement]s are attached to each
  * other. Directives 'library', 'part' and 'part of' are resolved.
@@ skipping 95 matching lines @@
 
 /**
  * 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 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 =
+    new ListResultDescriptor<AnalysisError>(
+        'RESOLVE_FUNCTION_BODIES_ERRORS', AnalysisError.NO_ERRORS);
+
+/**
  * The errors produced while resolving references.
  *
  * 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_REFERENCES_ERRORS =

[Paul Berry, 2015/09/02 17:10:08]

It looks like this result descriptor is not needed anymore.  Can we delete it?

[Brian Wilkerson, 2015/09/03 15:08:37]

Yes. I guess I should have said so in the CL's message, but I was planning on
doing clean-up in a separate CL.

     new ListResultDescriptor<AnalysisError>(
         'RESOLVE_REFERENCES_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.
  */
@@ skipping 2204 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>[RESOLVED_UNIT6]);
+      <ResultDescriptor>[INFER_STATIC_VARIABLE_TYPES_ERRORS, 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);

[Paul Berry, 2015/09/02 17:10:08]

Long line.  Did you forget to run the formatter?

[Brian Wilkerson, 2015/09/03 15:08:37]

It appears so, yes.

+    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>[INFERRED_STATIC_VARIABLE]);
+      buildInputs, <ResultDescriptor>[
+    INFER_STATIC_VARIABLE_ERRORS,
+    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();
     if (dependencyCycle == null) {
       //
       // Re-resolve the variable's initializer so that the inferred types of other
       // variables will be propagated.
       //
       NodeLocator locator = new NodeLocator(variable.nameOffset);
       AstNode node = locator.searchWithin(unit);
       VariableDeclaration declaration = node
           .getAncestor((AstNode ancestor) => ancestor is VariableDeclaration);
       if (declaration == null || declaration.name != node) {
         throw new AnalysisException(
             "NodeLocator failed to find a variable's declaration");
       }
-      RecordingErrorListener errorListener = new RecordingErrorListener();
       Expression initializer = declaration.initializer;
       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);
       }
@@ skipping 17 matching lines @@
       // 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 =
@@ skipping 68 matching lines @@
  * A task that merges all of the errors for a single source into a single list
  * of errors.
  */
 class LibraryUnitErrorsTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [HINTS] input.
    */
   static const String HINTS_INPUT = 'HINTS';
 
   /**
-   * The name of the [RESOLVE_REFERENCES_ERRORS] input.
+   * The name of the [INFER_STATIC_VARIABLE_TYPES_ERRORS] input.
    */
-  static const String RESOLVE_REFERENCES_ERRORS_INPUT =
-      'RESOLVE_REFERENCES_ERRORS';
+  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 [VARIABLE_REFERENCE_ERRORS] input.
    */
@@ skipping 20 matching lines @@
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     List<List<AnalysisError>> errorLists = <List<AnalysisError>>[];
     errorLists.add(getRequiredInput(HINTS_INPUT));
-    errorLists.add(getRequiredInput(RESOLVE_REFERENCES_ERRORS_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(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;
     return <String, TaskInput>{
       HINTS_INPUT: HINTS.of(unit),
-      RESOLVE_REFERENCES_ERRORS_INPUT: RESOLVE_REFERENCES_ERRORS.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),
       VARIABLE_REFERENCE_ERRORS_INPUT: VARIABLE_REFERENCE_ERRORS.of(unit),
       VERIFY_ERRORS_INPUT: VERIFY_ERRORS.of(unit)
     };
   }
 
   /**
    * Create a [LibraryUnitErrorsTask] based on the given [target] in the given
    * [context].
    */
@@ skipping 431 matching lines @@
       String name = node.name;
       names.names.add(name);
       if (dependsOn != null && bodyLevel == 0) {
         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 {
+  /**
+   * 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(
+      'ResolveFunctionBodiesInUnitTask',
+      createTask,
+      buildInputs,
+      <ResultDescriptor>[RESOLVE_FUNCTION_BODIES_ERRORS, RESOLVED_UNIT8]);
+
+  ResolveFunctionBodiesInUnitTask(
+      InternalAnalysisContext context, LibrarySpecificUnit compilationUnit)
+      : super(context, compilationUnit);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  void internalPerform() {
+    //
+    // Prepare inputs.
+    //
+    CompilationUnit unit = getRequiredInput(UNIT_INPUT);
+    TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
+    //
+    // Resolve function bodies.
+    //
+    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);
+          }
+        }
+      }
+    }
+    //
+    // 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);
+    }
+    visitor.initForIncrementalResolution();
+    functionBody.accept(visitor);
+  }
+
+  /**
+   * 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>{
+      TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
+      UNIT_INPUT: RESOLVED_UNIT7.of(unit)
+    };
+  }
+
+  /**
+   * Create a [ResolveFunctionBodiesInUnitTask] based on the given [target] in
+   * the given [context].
+   */
+  static ResolveFunctionBodiesInUnitTask createTask(
+      AnalysisContext context, AnalysisTarget target) {
+    return new ResolveFunctionBodiesInUnitTask(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';
 
   /**
@@ skipping 117 matching lines @@
    */
   static ResolveLibraryTypeNamesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveLibraryTypeNamesTask(context, target);
   }
 }
 
 /**
  * A task that builds [RESOLVED_UNIT8] for a unit.
  */
 class ResolveUnitReferencesTask extends SourceBasedAnalysisTask {

[Paul Berry, 2015/09/02 17:10:08]

I think we can delete this task too.

   /**
    * The name of the [LIBRARY_ELEMENT5] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The name of the [RESOLVED_UNIT4] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
@@ skipping 596 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }