Improve strong-mode implementation and fix several failing tests

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 54 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 library.
  */
 final ListResultDescriptor<AnalysisError> BUILD_LIBRARY_ERRORS =
     new ListResultDescriptor<AnalysisError>(
         'BUILD_LIBRARY_ERRORS', AnalysisError.NO_ERRORS);
 
 /**
- * A list of the [ClassElement]s representing the classes defined in a
- * compilation unit.
- *
- * The result is only available for [LibrarySpecificUnit]s, and only when strong
- * mode is enabled.
- */
-final ListResultDescriptor<ClassElement> CLASSES_IN_UNIT =
-    new ListResultDescriptor<ClassElement>('CLASSES_IN_UNIT', null);
-
-/**
  * 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.
  */
 final ListResultDescriptor<
         ConstantEvaluationTarget> COMPILATION_UNIT_CONSTANTS =
     new ListResultDescriptor<ConstantEvaluationTarget>(
         'COMPILATION_UNIT_CONSTANTS', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
@@ skipping 2601 matching lines @@
       //
       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");
       }
       Expression initializer = declaration.initializer;
+      initializer.accept(new ResolutionEraser());
       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();
@@ skipping 418 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>[
-    CLASSES_IN_UNIT,
     INFERABLE_STATIC_VARIABLES_IN_UNIT,
     PARTIALLY_RESOLVE_REFERENCES_ERRORS,
     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);
-    // TODO(brianwilkerson) Improve performance by not resolving anything inside
-    // function bodies. Function bodies will be resolved later so this is wasted
-    // effort.
-    AstVisitor visitor = new ResolverVisitor(
+    PartialResolverVisitor visitor = new PartialResolverVisitor(
         libraryElement, unitElement.source, typeProvider, errorListener,
         inheritanceManager: inheritanceManager);
     unit.accept(visitor);
     //
-    // Prepare targets for inference.
-    //
-    List<VariableElement> staticVariables = <VariableElement>[];
-    List<ClassElement> classes = <ClassElement>[];
-    if (context.analysisOptions.strongMode) {
-      InferrenceFinder inferrenceFinder = new InferrenceFinder();
-      unit.accept(inferrenceFinder);
-      staticVariables = inferrenceFinder.staticVariables;
-      classes = inferrenceFinder.classes;
-    }
-    //
     // Record outputs.
     //
-    outputs[CLASSES_IN_UNIT] = classes;
-    outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT] = staticVariables;
+    outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT] = visitor.staticVariables;
     outputs[PARTIALLY_RESOLVE_REFERENCES_ERRORS] =
         removeDuplicateErrors(errorListener.errors);
     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].
    */
@@ skipping 226 matching lines @@
       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();
+    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.

[Paul Berry, 2015/09/08 16:13:30]

I'm having trouble understanding this comment.  Would it be possible to rephrase
it as a "TODO" indicating what needs to be changed?

[Brian Wilkerson, 2015/09/08 17:10:33]

Actually, it looks like the consensus is to remove propagation of return types
for top-level function declarations, which will make this comment obsolete. I'll
remove the comment in the next CL (when I remove static return type
propagation).

+      declaration.accept(visitor.typeAnalyzer);
+    }
   }
 
   /**
    * 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>{
@@ skipping 671 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }