Use closure tracer to identify closures that are not passed to Function.apply

sdk/lib/_internal/compiler/implementation/inferrer/closure_tracer.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.
 
 part of type_graph_inferrer;
 
-class ClosureTracerVisitor extends TracerVisitor {
-  final FunctionElement tracedElement;
+class ClosureTracerVisitor extends TracerVisitor<ApplyableTypeInformation> {
+  final Iterable<FunctionElement> tracedElements;
 
-  ClosureTracerVisitor(this.tracedElement, tracedType, inferrer)
+  ClosureTracerVisitor(this.tracedElements, tracedType, inferrer)
       : super(tracedType, inferrer);
 
   void run() {
-    tracedElement.functionSignature.forEachParameter((Element parameter) {
-      ElementTypeInformation info = inferrer.types.getInferredTypeOf(parameter);
-      info.abandonInferencing = false;
+    tracedElements.forEach((FunctionElement e) {

[floitsch, 2014/04/14 15:39:37]

minor nit: I prefer 
for (FunctionElement e in tracedElements) {
  ...
}

Couldn't you then break out once the inference needs to is abandoned?

[herhut, 2014/04/15 10:50:39]

Parameters of closurized functions are abandoned during normal inference as we
do not know the context they are used in. This code resumes type inference for
them, as the tracer will compute just that context. For some parameters, e.g.,
those of native functions, we cannot infer types anyway but trust annotations.
Those are marked as non-resumable and thus will remain abandoned.

Even if all parameters of all traced functions do not take part in inference,
tracing is still beneficial to find out whether the closure flows to
Function.apply.

+      e.functionSignature.forEachParameter((Element parameter) {
+        ElementTypeInformation info =
+            inferrer.types.getInferredTypeOf(parameter);
+        info.abandonInferencing = info.abandonInferencing &&
+                                  !info.mightResume;
+      });
     });
     analyze();
-    tracedElement.functionSignature.forEachParameter((Element parameter) {
-      ElementTypeInformation info = inferrer.types.getInferredTypeOf(parameter);
-      if (continueAnalyzing) {
-        info.disableHandleSpecialCases = true;
-      } else {
-        info.giveUp(inferrer);
-      }
+    tracedElements.forEach((FunctionElement e) {

[floitsch, 2014/04/14 15:39:37]

ditto.

[herhut, 2014/04/15 10:50:39]

Done.

+      e.functionSignature.forEachParameter((Element parameter) {
+        ElementTypeInformation info =
+            inferrer.types.getInferredTypeOf(parameter);
+        if (continueAnalyzing) {
+          info.disableHandleSpecialCases = true;
+        } else {
+          info.giveUp(inferrer);
+        }
+      });
     });
   }
 
-  visitMapTypeInformation(MapTypeInformation info) {
-    bailout('Stored in a map');
+  void tagAsFunctionApplyTarget([String reason]) {
+    tracedType.mightBePassedToFunctionApply = true;
+    if (_VERBOSE) {
+      print("Closure $tracedType might be passed to apply: $reason");
+    }
   }
 
   void analyzeCall(CallSiteTypeInformation info) {
     Selector selector = info.selector;
-    if (!selector.signatureApplies(tracedElement, compiler)) return;
-    inferrer.updateParameterAssignments(
-        info, tracedElement, info.arguments, selector, remove: false,
-        addToQueue: false);
+    tracedElements.forEach((FunctionElement e) {

[floitsch, 2014/04/14 15:39:37]

s/e/functionElement/

[herhut, 2014/04/15 10:50:39]

Done.

+      if (!selector.signatureApplies(e, compiler)) return;
+      inferrer.updateParameterAssignments(
+          info, e, info.arguments, selector, remove: false,
+          addToQueue: false);
+    });
   }
 
   visitClosureCallSiteTypeInformation(ClosureCallSiteTypeInformation info) {
     super.visitClosureCallSiteTypeInformation(info);
     if (info.closure == currentUser) {
       analyzeCall(info);
     } else {
       bailout('Passed to a closure');
     }
   }
 
   visitStaticCallSiteTypeInformation(StaticCallSiteTypeInformation info) {
     super.visitStaticCallSiteTypeInformation(info);
     Element called = info.calledElement;
     if (called.isForeign(compiler)) {
       String name = called.name;
       if (name == 'JS' || name == 'DART_CLOSURE_TO_JS') {
         bailout('Used in JS ${info.call}');
       }
     }
     if (called.isGetter()
         && info.selector != null
         && info.selector.isCall()
         && inferrer.types.getInferredTypeOf(called) == currentUser) {
       // This node can be a closure call as well. For example, `foo()`
       // where `foo` is a getter.
       analyzeCall(info);
     }
+    if (checkIfFunctionApply(called) && info.arguments.contains(currentUser)) {
+      tagAsFunctionApplyTarget("static call");
+    }
   }
 
   bool checkIfCurrentUser(element) {
     return inferrer.types.getInferredTypeOf(element) == currentUser;
   }
 
+  bool checkIfFunctionApply(element) {
+    return compiler.functionApplyMethod == element;
+  }
+
   visitDynamicCallSiteTypeInformation(DynamicCallSiteTypeInformation info) {
     super.visitDynamicCallSiteTypeInformation(info);
     if (info.selector.isCall()) {
-      if (info.arguments.contains(currentUser)
-          && !info.targets.every((element) => element.isFunction())) {
-        bailout('Passed to a closure');
+      if (info.arguments.contains(currentUser)) {
+        if (!info.targets.every((element) => element.isFunction())) {
+          bailout('Passed to a closure');
+        }
+        if (info.targets.any(checkIfFunctionApply)) {
+          tagAsFunctionApplyTarget("dynamic call");
+        }
       } else if (info.targets.any((element) => checkIfCurrentUser(element))) {
         analyzeCall(info);
       }
     }
   }
 }
 
 class StaticTearOffClosureTracerVisitor extends ClosureTracerVisitor {
   StaticTearOffClosureTracerVisitor(tracedElement, tracedType, inferrer)
-      : super(tracedElement, tracedType, inferrer);
+      : super([tracedElement], tracedType, inferrer);
 
   visitStaticCallSiteTypeInformation(StaticCallSiteTypeInformation info) {
     super.visitStaticCallSiteTypeInformation(info);
-    if (info.calledElement == tracedElement
+    if (info.calledElement == tracedElements.first
         && info.selector != null
         && info.selector.isGetter()) {
       addNewEscapeInformation(info);
     }
   }
 }