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 1511 matching lines @@
                                 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);
+}
+
 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();
 }