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

sdk/lib/_internal/compiler/implementation/ssa/codegen.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 ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 509 matching lines @@
     } else if (sequenceElements.length == 1) {
       return sequenceElements[0];
     } else {
       return new js.Sequence(sequenceElements);
     }
   }
 
   /**
     * Only visits the arguments starting at inputs[HInvoke.ARGUMENTS_OFFSET].
     */
-  List<js.Expression> visitArguments(List<HInstruction> inputs) {
-    assert(inputs.length >= HInvoke.ARGUMENTS_OFFSET);
+  List<js.Expression> visitArguments(List<HInstruction> inputs,
+                                     {int start: HInvoke.ARGUMENTS_OFFSET}) {
+    assert(inputs.length >= start);
     List<js.Expression> result = <js.Expression>[];
-    for (int i = HInvoke.ARGUMENTS_OFFSET; i < inputs.length; i++) {
+    for (int i = start; i < inputs.length; i++) {
       use(inputs[i]);
       result.add(pop());
     }
     return result;
   }
 
   bool isVariableDeclared(String variableName) {
     return declaredLocals.contains(variableName) ||
         collectedVariableDeclarations.contains(variableName);
   }
@@ skipping 1061 matching lines @@
                         visitArguments(node.inputs)),
          node);
     world.registerDynamicInvocation(call.name, call);
   }
 
   visitInvokeStatic(HInvokeStatic node) {
     if (node.typeCode() == HInstruction.INVOKE_STATIC_TYPECODE) {
       // Register this invocation to collect the types used at all call sites.
       backend.registerStaticInvocation(node);
     }
-    use(node.target);
-    push(new js.Call(pop(), visitArguments(node.inputs)), node);
+    Element element = node.element;
+    world.registerStaticUse(element);
+    ClassElement cls = element.getEnclosingClass();
+    if (element.isGenerativeConstructor()
+        || (element.isFactoryConstructor() && cls == compiler.listClass)) {
+      world.registerInstantiatedClass(cls, work.resolutionTree);
+    }
+    push(new js.VariableUse(backend.namer.isolateAccess(node.element)));
+    push(new js.Call(pop(), visitArguments(node.inputs, start: 0)), node);
   }
 
   visitInvokeSuper(HInvokeSuper node) {
     Element superMethod = node.element;
+    world.registerStaticUse(superMethod);
     Element superClass = superMethod.getEnclosingClass();
     if (superMethod.kind == ElementKind.FIELD) {
       String fieldName = node.caller.isShadowedByField(superMethod)
           ? backend.namer.shadowedFieldName(superMethod)
           : backend.namer.instanceFieldName(superMethod);
-      use(node.inputs[1]);
+      use(node.inputs[0]);
       js.PropertyAccess access =
           new js.PropertyAccess.field(pop(), fieldName);
       if (node.isSetter) {
         use(node.value);
         push(new js.Assignment(access, pop()), node);
       } else {
         push(access, node);
       }
     } else {
       String methodName = backend.namer.getName(superMethod);
       String className = backend.namer.isolateAccess(superClass);
       js.VariableUse classReference = new js.VariableUse(className);
       js.PropertyAccess prototype =
           new js.PropertyAccess.field(classReference, "prototype");
       js.PropertyAccess method =
           new js.PropertyAccess.field(prototype, methodName);
-      push(jsPropertyCall(method, "call", visitArguments(node.inputs)), node);
+      push(jsPropertyCall(
+          method, "call", visitArguments(node.inputs, start: 0)), node);
     }
     world.registerStaticUse(superMethod);
   }
 
   visitFieldGet(HFieldGet node) {
     use(node.receiver);
     Element element = node.element;
     if (element == backend.jsIndexableLength) {
       // We're accessing a native JavaScript property called 'length'
       // on a JS String or a JS array. Therefore, the name of that
@@ skipping 327 matching lines @@
     js.Call value = new js.Call(jsHelper, [pop()]);
     attachLocation(value, argument);
     push(value, node);
   }
 
   void visitSwitch(HSwitch node) {
     // Switches are handled using [visitSwitchInfo].
   }
 
   void visitStatic(HStatic node) {
-    // Check whether this static is used for anything else than as a target in
-    // a static call.
-    node.usedBy.forEach((HInstruction instr) {
-      if (instr is !HInvokeStatic) {
-        backend.registerNonCallStaticUse(node);
-        if (node.element.isFunction()) {
-          world.registerInstantiatedClass(
-              compiler.functionClass, work.resolutionTree);
-        }
-      } else if (instr.target != node) {
-        backend.registerNonCallStaticUse(node);
-      }
-    });
     Element element = node.element;
+    if (element.isFunction()) {
+      backend.registerNonCallStaticUse(node);
+      world.registerInstantiatedClass(
+          compiler.functionClass, work.resolutionTree);
+      push(new js.VariableUse(
+          backend.namer.isolateStaticClosureAccess(node.element)));
+    } else {
+      push(new js.VariableUse(backend.namer.isolateAccess(node.element)));
+    }
     world.registerStaticUse(element);
-    ClassElement cls = element.getEnclosingClass();
-    if (element.isGenerativeConstructor()
-        || (element.isFactoryConstructor() && cls == compiler.listClass)) {
-      world.registerInstantiatedClass(cls, work.resolutionTree);
-    }
-    push(new js.VariableUse(backend.namer.isolateAccess(node.element)));
   }
 
   void visitLazyStatic(HLazyStatic node) {
     Element element = node.element;
     world.registerStaticUse(element);
     String lazyGetter = backend.namer.isolateLazyInitializerAccess(element);
     js.VariableUse target = new js.VariableUse(lazyGetter);
     js.Call call = new js.Call(target, <js.Expression>[]);
     push(call, node);
   }
@@ skipping 153 matching lines @@
   void checkNull(HInstruction input) {
     use(input);
     push(new js.Binary('==', pop(), new js.LiteralNull()));
   }
 
   void checkNonNull(HInstruction input) {
     use(input);
     push(new js.Binary('!=', pop(), new js.LiteralNull()));
   }
 
-  void checkFunction(HInstruction input,
-                     DartType type,
-                     { bool negative: false}) {
-    String relation = negative ? '!==' : '===';
-    checkTypeOf(input, relation, 'function');
-    js.Expression functionTest = pop();
-    checkObject(input, relation);
-    js.Expression objectTest = pop();
-    checkType(input, type, negative: negative);
-    String combiner = negative ? '||' : '&&';
-    push(new js.Binary(negative ? '&&' : '||',
-                       functionTest,
-                       new js.Binary(combiner, objectTest, pop())));
-  }
-
   void checkType(HInstruction input, DartType type, {bool negative: false}) {
     assert(invariant(input, !type.isMalformed,
                      message: 'Attempt to check malformed type $type'));
     world.registerIsCheck(type, work.resolutionTree);
     Element element = type.element;
     use(input);
 
     // Hack in interceptor.  Ideally the interceptor would occur at the
     // instruction level to allow optimizations, and checks would be broken into
     // several smaller tests.
@@ skipping 121 matching lines @@
         attachLocationToLast(node);
       } else if (element == compiler.doubleClass) {
         checkDouble(input, relation);
         attachLocationToLast(node);
       } else if (element == compiler.numClass) {
         checkNum(input, relation);
         attachLocationToLast(node);
       } else if (element == compiler.boolClass) {
         checkBool(input, relation);
         attachLocationToLast(node);
-      } else if (element == compiler.functionClass) {
-        checkFunction(input, type, negative: negative);
-        attachLocationToLast(node);
       } else if (element == compiler.intClass) {
         // The is check in the code tells us that it might not be an
         // int. So we do a typeof first to avoid possible
         // deoptimizations on the JS engine due to the Math.floor check.
         checkNum(input, relation);
         js.Expression numTest = pop();
         checkBigInt(input, relation);
         push(new js.Binary(negative ? '||' : '&&', numTest, pop()), node);
       } else if (Elements.isNumberOrStringSupertype(element, compiler)) {
         handleNumberOrStringSupertypeCheck(input, type, negative: negative);
@@ skipping 127 matching lines @@
           pushStatement(new js.Throw(call));
         }
         currentContainer = oldContainer;
         body = unwrapStatement(body);
         pushStatement(new js.If.noElse(test, body), node);
         return;
       }
 
       assert(node.isCheckedModeCheck || node.isCastTypeCheck);
       DartType type = node.typeExpression;
+      if (type.kind == TypeKind.FUNCTION) {
+        // TODO(5022): We currently generate $isFunction checks for
+        // function types.
+        world.registerIsCheck(
+            compiler.functionClass.computeType(compiler), work.resolutionTree);
+      }
       world.registerIsCheck(type, work.resolutionTree);
 
       // TODO(kasperl): For now, we ignore type checks against type
       // variables. This is clearly wrong.
       if (type.kind == TypeKind.TYPE_VARIABLE) {
         use(node.checkedInput);
         return;
       }
 
       FunctionElement helperElement;
@@ skipping 473 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }