Improve strong-mode implementation and fix several failing tests

pkg/analyzer/lib/src/task/strong_mode.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.strong_mode;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 65 matching lines @@
   }
   return null;
 }
 
 /**
  * A function that returns `true` if the given [variable] passes the filter.
  */
 typedef bool VariableFilter(VariableElement element);
 
 /**
- * An object used to find static variables whose types should be inferred and
- * classes whose members should have types inferred. Clients are expected to
- * visit a [CompilationUnit].
- */
-class InferrenceFinder extends SimpleAstVisitor {
-  /**
-   * The static variables that should have types inferred for them.
-   */
-  final List<VariableElement> staticVariables = <VariableElement>[];
-
-  /**
-   * The classes defined in the unit.
-   *
-   * TODO(brianwilkerson) We don't currently remove classes whose members do not
-   * need to be processed, but we potentially could.
-   */
-  final List<ClassElement> classes = <ClassElement>[];
-
-  /**
-   * Initialize a newly created finder.
-   */
-  InferrenceFinder();
-
-  @override
-  void visitClassDeclaration(ClassDeclaration node) {
-    classes.add(node.element);
-    for (ClassMember member in node.members) {
-      member.accept(this);
-    }
-  }
-
-  @override
-  void visitClassTypeAlias(ClassTypeAlias node) {
-    classes.add(node.element);
-  }
-
-  @override
-  void visitCompilationUnit(CompilationUnit node) {
-    for (CompilationUnitMember declaration in node.declarations) {
-      declaration.accept(this);
-    }
-  }
-
-  @override
-  void visitFieldDeclaration(FieldDeclaration node) {
-    if (node.isStatic && node.fields.type == null) {
-      _addVariables(node.fields.variables);
-    }
-  }
-
-  @override
-  void visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    if (node.variables.type == null) {
-      _addVariables(node.variables.variables);
-    }
-  }
-
-  /**
-   * Add all of the [variables] with initializers to the list of variables whose
-   * type can be inferred. Technically, we only infer the types of variables
-   * that do not have a static type, but all variables with initializers
-   * potentially need to be re-resolved after inference because they might
-   * refer to fields whose type was inferred.
-   */
-  void _addVariables(NodeList<VariableDeclaration> variables) {
-    for (VariableDeclaration variable in variables) {
-      if (variable.initializer != null) {
-        VariableElement element = variable.element;
-        if (element.hasImplicitType) {
-          staticVariables.add(element);
-        }
-      }
-    }
-  }
-}
-
-/**
  * An object used to infer the type of instance fields and the return types of
  * instance methods within a single compilation unit.
  */
 class InstanceMemberInferrer {
   /**
    * The type provider used to look up types.
    */
   final TypeProvider typeProvider;
 
   /**
@@ skipping 236 matching lines @@
             (fieldElement.isFinal || overriddenGetters.isEmpty)) {
           newType = fieldElement.initializer.returnType;
         }
       }
       if (newType == null || newType.isBottom) {
         newType = typeProvider.dynamicType;
       }
       (fieldElement as FieldElementImpl).type = newType;
       setReturnType(fieldElement.getter, newType);
       if (!fieldElement.isFinal && !fieldElement.isConst) {
-         setParameterType(fieldElement.setter, newType);
+        setParameterType(fieldElement.setter, newType);
       }
     }
   }
 
   /**
    * If the given [methodElement] represents a non-synthetic instance method
    * for which no return type was provided, infer the return type of the method.
    */
   void _inferMethod(MethodElement methodElement) {
     if (methodElement.isSynthetic || methodElement.isStatic) {
@@ skipping 118 matching lines @@
         results.add(element);
       }
     }
   }
 }
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}