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

sdk/lib/_internal/compiler/implementation/elements/modelx.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 elements.modelx;
 
 import 'elements.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
@@ skipping 328 matching lines @@
   get node => unsupported();
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
   get patch => null;
   get origin => this;
   get defaultImplementation => unsupported();
   get nestedClosures => unsupported();
 
   bool get isRedirectingFactory => unsupported();
+  bool get mightBePassedToFunctionApply => unsupported();
+  set mightBePassedToFunctionApply(bool value) => unsupported();
 
   setPatch(patch) => unsupported();
   computeSignature(compiler) => unsupported();
   requiredParameterCount(compiler) => unsupported();
   optionalParameterCount(compiler) => unsupported();
   parameterCount(compiler) => unsupported();
 
   // TODO(kasperl): These seem unnecessary.
   set patch(value) => unsupported();
   set origin(value) => unsupported();
@@ skipping 1133 matching lines @@
   /**
    * A function declaration that should be parsed instead of the current one.
    * The patch should be parsed as if it was in the current scope. Its
    * signature must match this function's signature.
    */
   FunctionElement patch = null;
   FunctionElement origin = null;
 
   final bool _hasNoBody;
 
+  bool mightBePassedToFunctionApply = false;
+
   /**
    * If this is a redirecting factory, [defaultImplementation] will be
    * changed by the resolver to point to the redirection target.
    * Otherwise, [:identical(defaultImplementation, this):].
    */
   // TODO(ahe): Rename this field to redirectionTarget.
   FunctionElement defaultImplementation;
 
   FunctionElementX(String name,
                    ElementKind kind,
                    Modifiers modifiers,
                    Element enclosing,
                    bool hasNoBody)
       : this.tooMuchOverloading(name, null, kind, modifiers, enclosing, null,
                                 hasNoBody);
 
   FunctionElementX.fromNode(String name,
                             FunctionExpression node,
                             ElementKind kind,
                             Modifiers modifiers,
                             Element enclosing)
       : this.tooMuchOverloading(name, node, kind, modifiers, enclosing, null,
                                 false);
 
-  FunctionElementX.from(String name,
-                        FunctionElement other,
-                        Element enclosing)
-      : this.tooMuchOverloading(name, other.node, other.kind,
-                                other.modifiers, enclosing,
-                                other.functionSignature,
-                                false);
-
   FunctionElementX.tooMuchOverloading(String name,
                                       FunctionExpression this.cachedNode,
                                       ElementKind kind,
                                       this.modifiers,
                                       Element enclosing,
                                       this.functionSignatureCache,
                                       bool hasNoBody)
       : super(name, kind, enclosing),
         _hasNoBody = hasNoBody {
     assert(modifiers != null);
@@ skipping 113 matching lines @@
 
   bool get isAbstract {
     return !modifiers.isExternal() &&
            (isFunction() || isAccessor()) &&
            _hasNoBody;
   }
 
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
 }
 
+class SynthesizedCallMethodElementX extends FunctionElementX {
+  final FunctionElement expression;
+
+  SynthesizedCallMethodElementX(String name,
+                                FunctionElement other,
+                                Element enclosing)
+      : expression = other,
+        super.tooMuchOverloading(name, other.node, other.kind,
+                                 other.modifiers, enclosing,
+                                 other.functionSignature,
+                                 false);
+
+  bool get mightBePassedToFunctionApply =>
+      expression.mightBePassedToFunctionApply;
+  void set mightBePassedToFunctionApply(_) =>
+      throw new UnsupportedError("Cannot set mightBePassedToFunctionApply for "
+                                 "synthezised call method");
+}
+
 class DeferredLoaderGetterElementX extends FunctionElementX {
 
   final PrefixElement prefix;
 
   DeferredLoaderGetterElementX(PrefixElement prefix)
       : this.prefix = prefix,
         super("loadLibrary",
               ElementKind.FUNCTION,
               Modifiers.EMPTY,
               prefix, true);
@@ skipping 941 matching lines @@
 
   ParameterMetadataAnnotation(Metadata this.metadata);
 
   Node parseNode(DiagnosticListener listener) => metadata.expression;
 
   Token get beginToken => metadata.getBeginToken();
 
   Token get endToken => metadata.getEndToken();
 }