Remove an unused non-IR IntrinsicMethod.toCallable

2019-03-28 13:43:14 +01:00
parent 31eb542476
commit 6e44b22340
4 changed files with 27 additions and 144 deletions
@@ -16,55 +16,22 @@

 package org.jetbrains.kotlin.backend.jvm.intrinsics

-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
 import org.jetbrains.kotlin.backend.jvm.codegen.BlockInfo
 import org.jetbrains.kotlin.codegen.*
-import org.jetbrains.kotlin.codegen.AsmUtil.genInvokeAppendMethod
-import org.jetbrains.kotlin.codegen.AsmUtil.genStringBuilderConstructor
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
-import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.psi.KtBinaryExpression
-import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
-import org.jetbrains.kotlin.psi.KtExpression
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
-import org.jetbrains.kotlin.resolve.jvm.AsmTypes.JAVA_STRING_TYPE
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter

 class Concat : IntrinsicMethod() {
-    fun generateImpl(
-            codegen: ExpressionCodegen,
-            v: InstructionAdapter,
-            returnType: Type,
-            element: PsiElement?,
-            arguments: List<KtExpression>,
-            receiver: StackValue
-    ): Type {
-        if (element is KtBinaryExpression && element.operationReference.getReferencedNameElementType() == KtTokens.PLUS) {
-            // LHS + RHS
-            genStringBuilderConstructor(v)
-            codegen.invokeAppend(v, element.left)
-            codegen.invokeAppend(v, element.right)
-        }
-        else {
-            // LHS?.plus(RHS)
-            receiver.put(AsmTypes.OBJECT_TYPE, v)
-            genStringBuilderConstructor(v)
-            v.swap()
-            genInvokeAppendMethod(v, returnType, null)
-            codegen.invokeAppend(v, arguments.get(0))
-        }
-
-        v.invokevirtual("java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false)
-        return JAVA_STRING_TYPE
-    }
-
-    override fun toCallable(expression: IrMemberAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction {
+    override fun toCallable(
+        expression: IrMemberAccessExpression,
+        signature: JvmMethodSignature,
+        context: JvmBackendContext
+    ): IrIntrinsicFunction {
        val argsTypes = expression.receiverAndArgs().asmTypes(context).toMutableList()
        argsTypes[0] = AsmTypes.JAVA_STRING_TYPE

@@ -75,7 +42,11 @@ class Concat : IntrinsicMethod() {
                v.invokevirtual("java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false)
            }

-            override fun invoke(v: InstructionAdapter, codegen: org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen, data: BlockInfo): StackValue {
+            override fun invoke(
+                v: InstructionAdapter,
+                codegen: org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen,
+                data: BlockInfo
+            ): StackValue {
                v.visitTypeInsn(Opcodes.NEW, "java/lang/StringBuilder")
                v.dup()

@@ -83,7 +54,12 @@ class Concat : IntrinsicMethod() {
            }


-            override fun genArg(expression: IrExpression, codegen: org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen, index: Int, data: BlockInfo) {
+            override fun genArg(
+                expression: IrExpression,
+                codegen: org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen,
+                index: Int,
+                data: BlockInfo
+            ) {
                super.genArg(expression, codegen, index, data)
                if (index == 0) {
                    codegen.mv.invokespecial("java/lang/StringBuilder", "<init>", "(Ljava/lang/String;)V", false)
@@ -91,43 +67,4 @@ class Concat : IntrinsicMethod() {
            }
        }
    }
-
-    override fun toCallable(method: CallableMethod): Callable =
-            object : IntrinsicCallable(method) {
-                override fun invokeMethodWithArguments(
-                        resolvedCall: ResolvedCall<*>,
-                        receiver: StackValue,
-                        codegen: ExpressionCodegen
-                ): StackValue {
-                    if (resolvedCall.call.callElement.parent is KtCallableReferenceExpression) {
-                        // NB we come here only in case of inlined callable reference to String::plus.
-                        // This will map arguments properly, invoking callbacks defined in Callable.
-                        return super.invokeMethodWithArguments(resolvedCall, receiver, codegen)
-                    }
-                    return StackValue.operation(returnType) {
-                        val arguments = resolvedCall.call.valueArguments.map { it.getArgumentExpression()!! }
-                        val actualType = generateImpl(
-                                codegen, it, returnType,
-                                resolvedCall.call.callElement,
-                                arguments,
-                                StackValue.receiver(resolvedCall, receiver, codegen, this)
-                        )
-                        StackValue.coerce(actualType, returnType, it)
-                    }
-                }
-
-                override fun afterReceiverGeneration(v: InstructionAdapter, frameMap: FrameMap) {
-                    v.generateNewInstanceDupAndPlaceBeforeStackTop(frameMap, AsmTypes.JAVA_STRING_TYPE, "java/lang/StringBuilder")
-                    v.invokespecial("java/lang/StringBuilder", "<init>", "(Ljava/lang/String;)V", false)
-                }
-
-                override fun invokeIntrinsic(v: InstructionAdapter) {
-                    // String::plus has type String.(Any?) -> String, thus we have no argument type information
-                    // in case of callable reference passed to a generic function, e.g.:
-                    //      charArrayOf('O', 'K').fold("", String::plus)
-                    // TODO Make String::plus generic, and invoke proper StringBuilder#append.
-                    AsmUtil.genInvokeAppendMethod(v, AsmTypes.OBJECT_TYPE, null)
-                    v.invokevirtual("java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false)
-                }
-            }
 }
@@ -6,8 +6,6 @@
 package org.jetbrains.kotlin.backend.jvm.intrinsics

 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
-import org.jetbrains.kotlin.codegen.Callable
-import org.jetbrains.kotlin.codegen.CallableMethod
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
 import org.jetbrains.kotlin.ir.types.toKotlinType
@@ -16,18 +14,11 @@ import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.Method

 abstract class IntrinsicMethod {
-
-    open fun toCallable(
+    abstract fun toCallable(
        expression: IrMemberAccessExpression,
        signature: JvmMethodSignature,
        context: JvmBackendContext
-    ): IrIntrinsicFunction {
-        TODO()
-    }
-
-    open fun toCallable(method: CallableMethod): Callable {
-        throw UnsupportedOperationException("Not implemented")
-    }
+    ): IrIntrinsicFunction

    companion object {
        fun calcReceiverType(call: IrMemberAccessExpression, context: JvmBackendContext): Type {
@@ -18,40 +18,24 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics

 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
 import org.jetbrains.kotlin.backend.jvm.codegen.BlockInfo
-import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.StackValue
 import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
-import org.jetbrains.kotlin.psi.KtPrefixExpression
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter

 class Not : IntrinsicMethod() {
-    override fun toCallable(expression: IrMemberAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction {
+    override fun toCallable(
+        expression: IrMemberAccessExpression,
+        signature: JvmMethodSignature,
+        context: JvmBackendContext
+    ): IrIntrinsicFunction {
        return object : IrIntrinsicFunction(expression, signature, context, expression.argTypes(context)) {
            override fun invoke(
                v: InstructionAdapter,
-                codegen: org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen,
+                codegen: ExpressionCodegen,
                data: BlockInfo
-            ): StackValue = StackValue.not(expression.dispatchReceiver!!.accept(codegen, data))
+            ) = StackValue.not(expression.dispatchReceiver!!.accept(codegen, data))
        }
    }
-
-    override fun toCallable(method: CallableMethod): Callable =
-            object : IntrinsicCallable(method) {
-                override fun invokeMethodWithArguments(
-                        resolvedCall: ResolvedCall<*>,
-                        receiver: StackValue,
-                        codegen: ExpressionCodegen
-                ): StackValue {
-                    val element = resolvedCall.call.callElement
-                    val stackValue =
-                            if (element is KtPrefixExpression) {
-                                codegen.gen(element.baseExpression)
-                            }
-                            else {
-                                StackValue.receiver(resolvedCall, receiver, codegen, this)
-                            }
-                    return StackValue.not(stackValue)
-                }
-            }
 }
@@ -57,33 +57,4 @@ class RangeTo : IntrinsicMethod() {
            }
        }
    }
-//
-//    override fun toCallable(method: CallableMethod): Callable {
-//        val argType = rangeTypeToPrimitiveType(method.returnType)
-//        return object : IntrinsicCallable(
-//                method.returnType,
-//                method.valueParameterTypes.map { argType },
-//                nullOr(method.dispatchReceiverType, argType),
-//                nullOr(method.extensionReceiverType, argType)
-//        ) {
-//            override fun afterReceiverGeneration(v: InstructionAdapter) {
-//                v.anew(returnType)
-//                when (argType.size) {
-//                    1 -> {
-//                        v.dupX1()
-//                        v.swap()
-//                    }
-//                    2 -> {
-//                        v.dup()
-//                        v.dup2X2()
-//                        v.pop2()
-//                    }
-//                }
-//            }
-//
-//            override fun invokeIntrinsic(v: InstructionAdapter) {
-//                v.invokespecial(returnType.internalName, "<init>", Type.getMethodDescriptor(Type.VOID_TYPE, argType, argType), false)
-//            }
-//        }
-//    }
 }