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

sdk/lib/_internal/compiler/implementation/ssa/builder.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;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 2501 matching lines @@
             new HType.inferredTypeForElement(element, compiler);
         push(instruction);
       } else {
         if (element.isGetter()) {
           Selector selector = elements.getSelector(send);
           if (tryInlineMethod(
                 element, selector, const Link<Node>(), null, send)) {
             return;
           }
         }
-        // TODO(5346): Try to avoid the need for calling [declaration] before
-        // creating an [HStatic].
-        HInstruction instruction = new HStatic(element.declaration);
         if (element.isGetter()) {
-          add(instruction);
-          instruction = buildInvokeStatic(<HInstruction>[instruction]);
-          push(instruction);
+          push(buildInvokeStatic(element, <HInstruction>[]));
         } else {
+          // TODO(5346): Try to avoid the need for calling [declaration] before
+          // creating an [HStatic].
+          HInstruction instruction = new HStatic(element.declaration);
           instruction.instructionType =
               new HType.inferredTypeForElement(element, compiler);
           push(instruction);
         }
       }
     } else if (Elements.isInstanceSend(send, elements)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceGetterWithCompiledReceiver(
           send, elements.getSelector(send), receiver);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
@@ skipping 36 matching lines @@
                                  Element element,
                                  HInstruction value,
                                  {Node location}) {
     assert(send == null || !Elements.isInstanceSend(send, elements));
     if (location == null) {
       assert(send != null);
       location = send;
     }
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.isSetter()) {
-        HStatic target = new HStatic(element);
-        add(target);
-        var instruction = buildInvokeStatic(
-            <HInstruction>[target, value], HType.UNKNOWN);
+        var instruction = buildInvokeStatic(element,
+            <HInstruction>[value], HType.UNKNOWN);
         addWithPosition(instruction, location);
       } else {
         value = potentiallyCheckType(value, element.computeType(compiler));
         addWithPosition(new HStaticStore(element, value), location);
       }
       stack.add(value);
     } else if (Elements.isErroneousElement(element)) {
       // An erroneous element indicates an unresolved static setter.
       generateThrowNoSuchMethod(
           location,
@@ skipping 16 matching lines @@
   }
 
   HInstruction invokeInterceptor(Set<ClassElement> intercepted,
                                  HInstruction receiver) {
     HInterceptor interceptor = new HInterceptor(intercepted, receiver);
     add(interceptor);
     return interceptor;
   }
 
   void pushInvokeHelper0(Element helper, HType type) {
-    HInstruction reference = new HStatic(helper);
-    add(reference);
-    List<HInstruction> inputs = <HInstruction>[reference];
-    push(buildInvokeStatic(inputs, type));
+    List<HInstruction> inputs = <HInstruction>[];
+    push(buildInvokeStatic(helper, inputs, type));
   }
 
   void pushInvokeHelper1(Element helper, HInstruction a0, HType type) {
-    HInstruction reference = new HStatic(helper);
-    add(reference);
-    List<HInstruction> inputs = <HInstruction>[reference, a0];
-    push(buildInvokeStatic(inputs, type));
+    List<HInstruction> inputs = <HInstruction>[a0];
+    push(buildInvokeStatic(helper, inputs, type));
   }
 
   void pushInvokeHelper2(Element helper,
                          HInstruction a0,
                          HInstruction a1,
                          HType type) {
-    HInstruction reference = new HStatic(helper);
-    add(reference);
-    List<HInstruction> inputs = <HInstruction>[reference, a0, a1];
-    push(buildInvokeStatic(inputs, type));
+    List<HInstruction> inputs = <HInstruction>[a0, a1];
+    push(buildInvokeStatic(helper, inputs, type));
   }
 
   void pushInvokeHelper3(Element helper,
                          HInstruction a0,
                          HInstruction a1,
                          HInstruction a2,
                          HType type) {
-    HInstruction reference = new HStatic(helper);
-    add(reference);
-    List<HInstruction> inputs = <HInstruction>[reference, a0, a1, a2];
-    push(buildInvokeStatic(inputs, type));
+    List<HInstruction> inputs = <HInstruction>[a0, a1, a2];
+    push(buildInvokeStatic(helper, inputs, type));
   }
 
   void pushInvokeHelper4(Element helper,
                          HInstruction a0,
                          HInstruction a1,
                          HInstruction a2,
                          HInstruction a3,
                          HType type) {
-    HInstruction reference = new HStatic(helper);
-    add(reference);
-    List<HInstruction> inputs = <HInstruction>[reference, a0, a1, a2, a3];
-    push(buildInvokeStatic(inputs, type));
+    List<HInstruction> inputs = <HInstruction>[a0, a1, a2, a3];
+    push(buildInvokeStatic(helper, inputs, type));
   }
 
   void pushInvokeHelper5(Element helper,
                          HInstruction a0,
                          HInstruction a1,
                          HInstruction a2,
                          HInstruction a3,
                          HInstruction a4,
                          HType type) {
-    HInstruction reference = new HStatic(helper);
-    add(reference);
-    List<HInstruction> inputs = <HInstruction>[reference, a0, a1, a2, a3, a4];
-    push(buildInvokeStatic(inputs, type));
+    List<HInstruction> inputs = <HInstruction>[a0, a1, a2, a3, a4];
+    push(buildInvokeStatic(helper, inputs, type));
   }
 
   HForeign createForeign(String code,
                          HType type,
                          List<HInstruction> inputs) {
     return new HForeign(js.js.parseForeignJS(code), type, inputs);
   }
 
   HInstruction getRuntimeTypeInfo(HInstruction target) {
     pushInvokeHelper1(backend.getGetRuntimeTypeInfo(), target, HType.UNKNOWN);
@@ skipping 78 matching lines @@
       } else {
         generateRuntimeError(node, '$type is malformed: $reasons');
       }
       return;
     }
 
     HInstruction instruction;
     if (type.kind == TypeKind.TYPE_VARIABLE) {
       HInstruction runtimeType = addTypeVariableReference(type);
       Element helper = backend.getGetObjectIsSubtype();
-      HInstruction helperCall = new HStatic(helper);
-      add(helperCall);
-      List<HInstruction> inputs = <HInstruction>[helperCall, expression,
-                                                 runtimeType];
-      HInstruction call = buildInvokeStatic(inputs, HType.BOOLEAN);
+      List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
+      HInstruction call = buildInvokeStatic(helper, inputs, HType.BOOLEAN);
       add(call);
       instruction = new HIs(type, <HInstruction>[expression, call],
                             HIs.VARIABLE_CHECK);
     } else if (RuntimeTypes.hasTypeArguments(type)) {
       Element element = type.element;
       Element helper = backend.getCheckSubtype();
-      HInstruction helperCall = new HStatic(helper);
-      add(helperCall);
       HInstruction representations =
         buildTypeArgumentRepresentations(type);
       add(representations);
       String operator =
           backend.namer.operatorIs(backend.getImplementationClass(element));
       HInstruction isFieldName = addConstantString(node, operator);
       // TODO(karlklose): use [:null:] for [asField] if [element] does not
       // have a subclass.
       HInstruction asFieldName =
           addConstantString(node, backend.namer.substitutionName(element));
-      List<HInstruction> inputs = <HInstruction>[helperCall,
-                                                 expression,
+      List<HInstruction> inputs = <HInstruction>[expression,
                                                  isFieldName,
                                                  representations,
                                                  asFieldName];
-      HInstruction call = buildInvokeStatic(inputs, HType.BOOLEAN);
+      HInstruction call = buildInvokeStatic(helper, inputs, HType.BOOLEAN);
       add(call);
       instruction = new HIs(type, <HInstruction>[expression, call],
                             HIs.COMPOUND_CHECK);
     } else {
       instruction = new HIs(type, <HInstruction>[expression], HIs.RAW_CHECK);
     }
     if (isNot) {
       add(instruction);
       instruction = new HNot(instruction);
     }
@@ skipping 174 matching lines @@
       Selector selector = new Selector.callClosure(0);
       push(new HInvokeClosure(selector, <HInstruction>[pop()]));
     } else {
       // Call a helper method from the isolate library.
       Element element = compiler.isolateHelperLibrary.find(
           const SourceString('_callInIsolate'));
       if (element == null) {
         compiler.cancel(
             'Isolate library and compiler mismatch', node: node);
       }
-      HStatic target = new HStatic(element);
-      add(target);
-      List<HInstruction> inputs = <HInstruction>[target];
+      List<HInstruction> inputs = <HInstruction>[];
       addGenericSendArgumentsToList(link, inputs);
-      push(buildInvokeStatic(inputs, HType.UNKNOWN));
+      push(buildInvokeStatic(element, inputs, HType.UNKNOWN));
     }
   }
 
   FunctionSignature handleForeignRawFunctionRef(Send node, String name) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
       compiler.cancel('"$name" requires exactly one argument',
                       node: node.argumentsNode);
     }
     Node closure = node.arguments.head;
     Element element = elements[closure];
@@ skipping 278 matching lines @@
                               HInstruction newObject) {
     if (!backend.needsRti(element) || element.typeVariables.isEmpty) {
       return;
     }
 
     HInstruction typeInfo = new HLiteralList(rtiInputs);
     add(typeInfo);
 
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = backend.getSetRuntimeTypeInfo();
-    HInstruction typeInfoSetter = new HStatic(typeInfoSetterElement);
-    add(typeInfoSetter);
-    add(buildInvokeStatic(
-        <HInstruction>[typeInfoSetter, newObject, typeInfo], HType.UNKNOWN));
+    add(buildInvokeStatic(typeInfoSetterElement,
+        <HInstruction>[newObject, typeInfo], HType.UNKNOWN));
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [type] must not be malformed in checked mode.
    */
   visitNewSend(Send node, InterfaceType type) {
     assert(invariant(node,
                      !compiler.enableTypeAssertions || !type.isMalformed,
@@ skipping 33 matching lines @@
 
     if (isSymbolConstructor) {
       constructor = compiler.symbolValidatedConstructor;
       assert(invariant(node, constructor != null,
                        message: 'Constructor Symbol.validated is missing'));
       selector = compiler.symbolValidatedConstructorSelector;
       assert(invariant(node, selector != null,
                        message: 'Constructor Symbol.validated is missing'));
     }
 
-    // TODO(5346): Try to avoid the need for calling [declaration] before
-    // creating an [HStatic].
-    HInstruction target = new HStatic(constructor.declaration);
-    add(target);
     var inputs = <HInstruction>[];
-    inputs.add(target);
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [addStaticSendArgumentsToList].
     bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                   constructor.implementation,
                                                   inputs);
     if (!succeeded) {
       generateWrongArgumentCountError(node, constructor, node.arguments);
       return;
     }
 
@@ skipping 13 matching lines @@
       while (!typeVariable.isEmpty) {
         inputs.add(graph.addConstantNull(constantSystem));
         typeVariable = typeVariable.tail;
       }
     }
 
     if (constructor.isFactoryConstructor() && !type.typeArguments.isEmpty) {
       compiler.enqueuer.codegen.registerFactoryWithTypeArguments(elements);
     }
     HType elementType = computeType(constructor);
-    HInstruction newInstance = buildInvokeStatic(inputs, elementType);
+    HInstruction newInstance =
+        buildInvokeStatic(constructor, inputs, elementType);
     pushWithPosition(newInstance, node);
 
     // The List constructor forwards to a Dart static method that does
     // not know about the type argument. Therefore we special case
     // this constructor to have the setRuntimeTypeInfo called where
     // the 'new' is done.
     if (isListConstructor && backend.needsRti(compiler.listClass)) {
       handleListConstructor(type, node, newInstance);
     }
   }
@@ skipping 18 matching lines @@
     }
     compiler.ensure(!element.isGenerativeConstructor());
     if (element.isFunction()) {
       bool isIdenticalFunction = element == compiler.identicalFunction;
 
       if (!isIdenticalFunction
           && tryInlineMethod(element, selector, node.arguments, null, node)) {
         return;
       }
 
-      HInstruction target = new HStatic(element);
-      add(target);
-      var inputs = <HInstruction>[target];
+      var inputs = <HInstruction>[];
       // TODO(5347): Try to avoid the need for calling [implementation] before
       // calling [addStaticSendArgumentsToList].
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element.implementation,
                                                     inputs);
       if (!succeeded) {
         generateWrongArgumentCountError(node, element, node.arguments);
         return;
       }
 
       if (isIdenticalFunction) {
-        pushWithPosition(new HIdentity(inputs[1], inputs[2]), node);
+        pushWithPosition(new HIdentity(inputs[0], inputs[1]), node);
         return;
       }
 
-      HInvokeStatic instruction = buildInvokeStatic(inputs, HType.UNKNOWN);
+      HInvokeStatic instruction =
+          buildInvokeStatic(element, inputs, HType.UNKNOWN);
       HType returnType =
           new HType.inferredReturnTypeForElement(element, compiler);
       if (returnType.isUnknown()) {
         // TODO(ngeoffray): Only do this if knowing the return type is
         // useful.
         returnType =
             builder.backend.optimisticReturnTypesWithRecompilationOnTypeChange(
                 currentElement, element);
       }
       if (returnType != null) instruction.instructionType = returnType;
@@ skipping 254 matching lines @@
       pushWithPosition(
           new HInvokeDynamicSetter(selector, null, inputs, !hasSetter),
           location);
     } else {
       pushWithPosition(
           new HInvokeDynamicMethod(selector, inputs, isIntercepted),
           location);
     }
   }
 
-  HInstruction buildInvokeStatic(List<HInstruction> inputs,
+  HInstruction buildInvokeStatic(Element element,
+                                 List<HInstruction> inputs,
                                  [HType type = null]) {
-    HStatic staticInstruction = inputs[0];
-    Element element = staticInstruction.element;
     if (type == null) {
       type = new HType.inferredReturnTypeForElement(element, compiler);
     }
-    HInstruction instruction = new HInvokeStatic(inputs, type);
+    // TODO(5346): Try to avoid the need for calling [declaration] before
+    // creating an [HInvokeStatic].
+    HInstruction instruction =
+        new HInvokeStatic(element.declaration, inputs, type);
     instruction.sideEffects = compiler.world.getSideEffectsOfElement(element);
     return instruction;
   }
 
   HInstruction buildInvokeSuper(Selector selector,
                                 Element element,
                                 List<HInstruction> arguments) {
     HInstruction receiver = localsHandler.readThis();
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
-    HInstruction target = new HStatic(element.declaration);
-    add(target);
-    List<HInstruction> inputs = <HInstruction>[target];
+    List<HInstruction> inputs = <HInstruction>[];
     Set<ClassElement> interceptedClasses =
         backend.getInterceptedClassesOn(selector.name);
     if (interceptedClasses != null) {
       inputs.add(invokeInterceptor(interceptedClasses, receiver));
     }
     inputs.add(receiver);
     inputs.addAll(arguments);
     HInstruction instruction = new HInvokeSuper(
+        element,
         currentNonClosureClass,
         inputs,
         isSetter: selector.isSetter() || selector.isIndexSet());
     instruction.instructionType =
         new HType.inferredReturnTypeForElement(element, compiler);
     instruction.sideEffects = compiler.world.getSideEffectsOfElement(element);
     return instruction;
   }
 
   void handleComplexOperatorSend(SendSet node,
@@ skipping 1517 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }