Make static tear-off closures a class, like instance tear-off closures.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
@@ skipping 61 matching lines @@
       : types = new List<HType>(length),
         namedArguments = null;
   HTypeList.withNamedArguments(int length, this.namedArguments)
       : types = new List<HType>(length);
   const HTypeList.withAllUnknown()
       : types = null,
         namedArguments = null;
 
   factory HTypeList.fromStaticInvocation(HInvokeStatic node) {
     bool allUnknown = true;
-    for (int i = 1; i < node.inputs.length; i++) {
+    for (int i = 0; i < node.inputs.length; i++) {
       if (node.inputs[i].instructionType != HType.UNKNOWN) {
         allUnknown = false;
         break;
       }
     }
     if (allUnknown) return HTypeList.ALL_UNKNOWN;
 
-    HTypeList result = new HTypeList(node.inputs.length - 1);
+    HTypeList result = new HTypeList(node.inputs.length);
     for (int i = 0; i < result.types.length; i++) {
-      result.types[i] = node.inputs[i + 1].instructionType;
+      result.types[i] = node.inputs[i].instructionType;
       assert(!result.types[i].isConflicting());
     }
     return result;
   }
 
   factory HTypeList.fromDynamicInvocation(HInvokeDynamic node,
                                           Selector selector) {
     HTypeList result;
     int argumentsCount = node.inputs.length - 1;
     int startInvokeIndex = HInvoke.ARGUMENTS_OFFSET;
@@ skipping 537 matching lines @@
    */
   final Map<FunctionElement, bool> canBeInlined =
       new Map<FunctionElement, bool>();
 
   ClassElement jsInterceptorClass;
   ClassElement jsStringClass;
   ClassElement jsArrayClass;
   ClassElement jsNumberClass;
   ClassElement jsIntClass;
   ClassElement jsDoubleClass;
-  ClassElement jsFunctionClass;
   ClassElement jsNullClass;
   ClassElement jsBoolClass;
 
   ClassElement jsIndexableClass;
   ClassElement jsMutableIndexableClass;
 
   ClassElement jsMutableArrayClass;
   ClassElement jsFixedArrayClass;
   ClassElement jsExtendableArrayClass;
 
@@ skipping 251 matching lines @@
       jsInterceptorClass =
           compiler.findInterceptor(const SourceString('Interceptor')),
       jsStringClass = compiler.findInterceptor(const SourceString('JSString')),
       jsArrayClass = compiler.findInterceptor(const SourceString('JSArray')),
       // The int class must be before the double class, because the
       // emitter relies on this list for the order of type checks.
       jsIntClass = compiler.findInterceptor(const SourceString('JSInt')),
       jsDoubleClass = compiler.findInterceptor(const SourceString('JSDouble')),
       jsNumberClass = compiler.findInterceptor(const SourceString('JSNumber')),
       jsNullClass = compiler.findInterceptor(const SourceString('JSNull')),
-      jsFunctionClass =
-          compiler.findInterceptor(const SourceString('JSFunction')),
       jsBoolClass = compiler.findInterceptor(const SourceString('JSBool')),
       jsMutableArrayClass =
           compiler.findInterceptor(const SourceString('JSMutableArray')),
       jsFixedArrayClass =
           compiler.findInterceptor(const SourceString('JSFixedArray')),
       jsExtendableArrayClass =
           compiler.findInterceptor(const SourceString('JSExtendableArray'))];
 
     jsIndexableClass =
         compiler.findInterceptor(const SourceString('JSIndexable'));
@@ skipping 181 matching lines @@
                || cls == jsExtendableArrayClass) {
       addInterceptors(jsArrayClass, enqueuer, elements);
       enqueuer.registerInstantiatedClass(jsFixedArrayClass, elements);
       enqueuer.registerInstantiatedClass(jsExtendableArrayClass, elements);
     } else if (cls == compiler.intClass || cls == jsIntClass) {
       addInterceptors(jsIntClass, enqueuer, elements);
       addInterceptors(jsNumberClass, enqueuer, elements);
     } else if (cls == compiler.doubleClass || cls == jsDoubleClass) {
       addInterceptors(jsDoubleClass, enqueuer, elements);
       addInterceptors(jsNumberClass, enqueuer, elements);
-    } else if (cls == compiler.functionClass || cls == jsFunctionClass) {
-      addInterceptors(jsFunctionClass, enqueuer, elements);
     } else if (cls == compiler.boolClass || cls == jsBoolClass) {
       addInterceptors(jsBoolClass, enqueuer, elements);
     } else if (cls == compiler.nullClass || cls == jsNullClass) {
       addInterceptors(jsNullClass, enqueuer, elements);
     } else if (cls == compiler.numClass || cls == jsNumberClass) {
       addInterceptors(jsIntClass, enqueuer, elements);
       addInterceptors(jsDoubleClass, enqueuer, elements);
       addInterceptors(jsNumberClass, enqueuer, elements);
     } else if (cls.isNative()) {
       addInterceptorsForNativeClassMembers(cls, enqueuer);
@@ skipping 512 matching lines @@
     } else if (element == jsNumberClass || element == compiler.numClass) {
       if (nativeCheckOnly) return null;
       return typeCast
           ? const SourceString("numTypeCast")
           : const SourceString('numTypeCheck');
     } else if (element == jsBoolClass || element == compiler.boolClass) {
       if (nativeCheckOnly) return null;
       return typeCast
           ? const SourceString("boolTypeCast")
           : const SourceString('boolTypeCheck');
-    } else if (element == jsFunctionClass ||
-               element == compiler.functionClass) {
-      if (nativeCheckOnly) return null;
-      return typeCast
-          ? const SourceString("functionTypeCast")
-          : const SourceString('functionTypeCheck');
     } else if (element == jsIntClass || element == compiler.intClass) {
       if (nativeCheckOnly) return null;
       return typeCast ?
           const SourceString("intTypeCast") :
           const SourceString('intTypeCheck');
     } else if (Elements.isNumberOrStringSupertype(element, compiler)) {
       if (nativeCheck) {
         return typeCast
             ? const SourceString("numberOrStringSuperNativeTypeCast")
             : const SourceString('numberOrStringSuperNativeTypeCheck');
@@ skipping 163 matching lines @@
   ClassElement get intImplementation => jsIntClass;
   ClassElement get doubleImplementation => jsDoubleClass;
   ClassElement get numImplementation => jsNumberClass;
   ClassElement get stringImplementation => jsStringClass;
   ClassElement get listImplementation => jsArrayClass;
   ClassElement get constListImplementation => jsArrayClass;
   ClassElement get fixedListImplementation => jsFixedArrayClass;
   ClassElement get growableListImplementation => jsExtendableArrayClass;
   ClassElement get mapImplementation => mapLiteralClass;
   ClassElement get constMapImplementation => constMapLiteralClass;
-  ClassElement get functionImplementation => jsFunctionClass;
   ClassElement get typeImplementation => typeLiteralClass;
   ClassElement get boolImplementation => jsBoolClass;
   ClassElement get nullImplementation => jsNullClass;
 }