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

sdk/lib/_internal/compiler/implementation/world.dart

Index: sdk/lib/_internal/compiler/implementation/world.dart
diff --git a/sdk/lib/_internal/compiler/implementation/world.dart b/sdk/lib/_internal/compiler/implementation/world.dart
index 91a95d263d5a580e78d02fd9cb8c5db0f8a2f65a..f522cc8751c3b4d0c2384fbe4e5114874ffda3b4 100644
--- a/sdk/lib/_internal/compiler/implementation/world.dart
+++ b/sdk/lib/_internal/compiler/implementation/world.dart
@@ -29,6 +29,9 @@ class World {
 
   final Set<Element> elementsThatCannotThrow = new Set<Element>();
 
+  final Set<Element> functionsThatMightBePassedToApply =
+      new Set<FunctionElement>();
+
   Set<ClassElement> subclassesOf(ClassElement cls) {
     return _subclasses[cls.declaration];
   }
@@ -273,4 +276,21 @@ class World {
   bool getCannotThrow(Element element) {
     return elementsThatCannotThrow.contains(element);
   }
+
+  void registerMightBePassedToApply(Element element) {
+    functionsThatMightBePassedToApply.add(element);
+  }
+
+  bool getMightBePassedToApply(Element element) {
+    // We have to check whether the element we look at was created after
+    // type inference ran. This is currently only the case for the call
+    // method of function classes that were generated for function
+    // expressions. In such a case, we have to look at the original
+    // function expressions's element.
+    // TODO(herhut): Generate classes for function expressions earlier.
+    if (element is SynthesizedCallMethodElementX) {

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

What if we have:
===
var f = () => 499;
var f2 = f.call;

Function.apply(f2, [], {})
===

f2 would be a SynthesizedCallMethodElementX, and would be passed to
Function.apply.

Note: it looks like this is currently broken in dart2js.

Add test (unless there is one already).

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

f2 would be a LocalElement, as would be f1. Only the function expression () =>
499 is turned into a new class with a SynthesizedCallMethodElementX that
corresponds to the function expression.

The tracer uses the front-end view. So it will see that the function expression
flows to Function.apply (once the other bug is fixed) and will tag the function
expression accordingly. During code generation, we actually never see that
function expression but only visit the SynthesizedCallMethodElementX. At that
stage, we have to make the link back to the function expression, which is what
this code does.
Filed a bug http://dartbug.com/18238
I will add a test in the CL for the above bug.

+      return getMightBePassedToApply(element.expression);
+    }
+    return functionsThatMightBePassedToApply.contains(element);
+  }
 }