Re-apply: Implement tracing for function expressions and statements, and infer types of parameters …

sdk/lib/_internal/compiler/implementation/inferrer/inferrer_visitor.dart

 // Copyright (c) 2013, 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 inferrer_visitor;
 
 import '../dart2jslib.dart' hide Selector, TypedSelector;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../tree/tree.dart';
@@ skipping 31 matching lines @@
   bool isNull(T type);
   Selector newTypedSelector(T receiver, Selector selector);
 
   T allocateList(T type,
                  Node node,
                  Element enclosing,
                  [T elementType, int length]);
 
   T allocateMap(T keyType, T valueType, T type);
 
+  T allocateClosure(Node node, Element element);
+
   /**
    * Returns the least upper bound between [firstType] and
    * [secondType].
    */
   T computeLUB(T firstType, T secondType);
 
   /**
    * Returns the intersection between [T] and [annotation].
    * [isNullable] indicates whether the annotation implies a null
    * type.
@@ skipping 202 matching lines @@
   }
 
   void forEach(void f(T type)) {
     positional.forEach(f);
     named.values.forEach(f);
   }
 
   bool every(bool f(T type)) {
     return positional.every(f) && named.values.every(f);
   }
+
+  bool contains(T type) {
+    return positional.contains(type) || named.containsValue(type);
+  }
 }
 
 abstract class MinimalInferrerEngine<T> {
   /**
    * Returns the type of [element].
    */
   T typeOfElement(Element element);
 
   /**
    * Records that [node] sets non-final field [element] to be of type
@@ skipping 443 matching lines @@
     if (_superType != null) return _superType;
     return _superType = types.nonNullExact(
         outermostElement.getEnclosingClass().superclass);
   }
 
   T visitIdentifier(Identifier node) {
     if (node.isThis()) {
       return thisType;
     } else if (node.isSuper()) {
       return superType;
+    } else {
+      Element element = elements[node];
+      if (Elements.isLocal(element)) {
+        return locals.use(element);
+      }
     }
   }
 
   void potentiallyAddIsCheck(Send node) {
     if (!accumulateIsChecks) return;
     if (!Elements.isLocal(elements[node.receiver])) return;
     isChecks.add(node);
   }
 
   void potentiallyAddNullCheck(Send node, Node receiver) {
@@ skipping 407 matching lines @@
     return type;
   }
 
   T visitCascade(Cascade node) {
     // Ignore the result of the cascade send and return the type of the cascade
     // receiver.
     visit(node.expression);
     return cascadeReceiverStack.removeLast();
   }
 }