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

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

 // Copyright (c) 2012, 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 dart2js;
 
 class World {
   final Compiler compiler;
   final FunctionSet allFunctions;
   final Set<Element> functionsCalledInLoop = new Set<Element>();
@@ skipping 11 matching lines @@
       new Map<ClassElement, Set<ClassElement>>();
   final Map<ClassElement, Set<ClassElement>> _subtypes =
       new Map<ClassElement, Set<ClassElement>>();
   final Map<ClassElement, Set<ClassElement>> _supertypes =
       new Map<ClassElement, Set<ClassElement>>();
 
   final Set<Element> sideEffectsFreeElements = new Set<Element>();
 
   final Set<Element> elementsThatCannotThrow = new Set<Element>();
 
+  final Set<Element> functionsThatMightBePassedToApply =
+      new Set<FunctionElement>();
+
   Set<ClassElement> subclassesOf(ClassElement cls) {
     return _subclasses[cls.declaration];
   }
 
   Set<ClassElement> subtypesOf(ClassElement cls) {
     return _subtypes[cls.declaration];
   }
 
   Set<ClassElement> supertypesOf(ClassElement cls) {
     return _supertypes[cls.declaration];
@@ skipping 224 matching lines @@
     return sideEffects;
   }
 
   void registerCannotThrow(Element element) {
     elementsThatCannotThrow.add(element);
   }
 
   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);
+  }
 }