From 8e0003c1a5fffd19a92633ecd99e69606721c1f6 Mon Sep 17 00:00:00 2001 From: Michael Bogdanov Date: Sat, 4 Apr 2015 11:10:18 +0300 Subject: [PATCH] Callable Convertion --- .../org/jetbrains/kotlin/codegen/Callable.kt | 2 +- .../kotlin/codegen/CallableMethod.kt | 175 ++++++------------ 2 files changed, 57 insertions(+), 120 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/Callable.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/Callable.kt index 5e3085d39d0..b11c5ea8638 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/Callable.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/Callable.kt @@ -19,7 +19,7 @@ package org.jetbrains.kotlin.codegen; import org.jetbrains.annotations.Nullable; import org.jetbrains.org.objectweb.asm.Type; -public interface Callable { +public trait Callable { } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallableMethod.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallableMethod.kt index cc4768b900d..dbd19e2d5b9 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallableMethod.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallableMethod.kt @@ -16,142 +16,96 @@ package org.jetbrains.kotlin.codegen; +import com.sun.org.apache.bcel.internal.generic.INVOKESPECIAL +import com.sun.org.apache.bcel.internal.generic.INVOKESTATIC import kotlin.Function1; import kotlin.Unit; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; +import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import org.jetbrains.kotlin.load.java.JvmAbi; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature; -import org.jetbrains.org.objectweb.asm.Opcodes; +import org.jetbrains.org.objectweb.asm.Opcodes.*; import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter; import org.jetbrains.org.objectweb.asm.commons.Method; import org.jetbrains.org.objectweb.asm.util.Printer; import java.util.ArrayList; -import java.util.List; -import static org.jetbrains.org.objectweb.asm.Opcodes.INVOKESPECIAL; -import static org.jetbrains.org.objectweb.asm.Opcodes.INVOKESTATIC; +public class CallableMethod(private val owner: Type, private val defaultImplOwner: Type?, private val defaultImplParam: Type?, private val signature: JvmMethodSignature, private val invokeOpcode: Int, private val thisClass: Type?, private val receiverParameterType: Type?, private val generateCalleeType: Type?) : ExtendedCallable { -public class CallableMethod implements ExtendedCallable { - private final Type owner; - private final Type defaultImplOwner; - private final Type defaultImplParam; - private final JvmMethodSignature signature; - private final int invokeOpcode; - private final Type thisClass; - private final Type receiverParameterType; - private final Type generateCalleeType; - - public CallableMethod( - @NotNull Type owner, - @Nullable Type defaultImplOwner, - @Nullable Type defaultImplParam, - @NotNull JvmMethodSignature signature, - int invokeOpcode, - @Nullable Type thisClass, - @Nullable Type receiverParameterType, - @Nullable Type generateCalleeType - ) { - this.owner = owner; - this.defaultImplOwner = defaultImplOwner; - this.defaultImplParam = defaultImplParam; - this.signature = signature; - this.invokeOpcode = invokeOpcode; - this.thisClass = thisClass; - this.receiverParameterType = receiverParameterType; - this.generateCalleeType = generateCalleeType; + override fun getOwner(): Type { + return owner } - @Override - @NotNull - public Type getOwner() { - return owner; + public fun getValueParameters(): List { + return signature.getValueParameters() } - @NotNull - public List getValueParameters() { - return signature.getValueParameters(); - } - - @Override - @NotNull - public List getValueParameterTypes() { - List valueParameters = signature.getValueParameters(); - List result = new ArrayList(valueParameters.size()); - for (JvmMethodParameterSignature parameter : valueParameters) { + override fun getValueParameterTypes(): List { + val valueParameters = signature.getValueParameters() + val result = ArrayList(valueParameters.size()) + for (parameter in valueParameters) { if (parameter.getKind() == JvmMethodParameterKind.VALUE) { - result.add(parameter.getAsmType()); + result.add(parameter.getAsmType()) } } - return result; + return result } - @NotNull - public Method getAsmMethod() { - return signature.getAsmMethod(); + public fun getAsmMethod(): Method { + return signature.getAsmMethod() } - @Override - public Type[] getArgumentTypes() { - return signature.getAsmMethod().getArgumentTypes(); + override fun getArgumentTypes(): Array { + return signature.getAsmMethod().getArgumentTypes() } - @Override - @Nullable - public Type getThisType() { - return thisClass; + override fun getThisType(): Type? { + return thisClass } - @Override - @Nullable - public Type getReceiverClass() { - return receiverParameterType; + override fun getReceiverClass(): Type? { + return receiverParameterType } - private void invoke(InstructionAdapter v) { - v.visitMethodInsn(invokeOpcode, owner.getInternalName(), getAsmMethod().getName(), getAsmMethod().getDescriptor()); + private fun invoke(v: InstructionAdapter) { + v.visitMethodInsn(invokeOpcode, owner.getInternalName(), getAsmMethod().getName(), getAsmMethod().getDescriptor()) } - @Override - public void invokeWithNotNullAssertion( - @NotNull InstructionAdapter v, - @NotNull GenerationState state, - @NotNull ResolvedCall resolvedCall - ) { - invokeWithoutAssertions(v); - AsmUtil.genNotNullAssertionForMethod(v, state, resolvedCall); + + public override fun invokeWithNotNullAssertion(v: InstructionAdapter, state: GenerationState, resolvedCall: ResolvedCall<*>) { + invokeWithoutAssertions(v) + AsmUtil.genNotNullAssertionForMethod(v, state, resolvedCall) } - @Override - public void invokeWithoutAssertions(@NotNull InstructionAdapter v) { - invoke(v); + public override fun invokeWithoutAssertions(v: InstructionAdapter) { + invoke(v) } - @Override - @Nullable - public Type getGenerateCalleeType() { - return generateCalleeType; + override fun getGenerateCalleeType(): Type? { + return generateCalleeType } - private void invokeDefault(InstructionAdapter v) { + private fun invokeDefault(v: InstructionAdapter) { if (defaultImplOwner == null || defaultImplParam == null) { - throw new IllegalStateException(); + throw IllegalStateException() } - Method method = getAsmMethod(); - String desc = JetTypeMapper.getDefaultDescriptor(method, - invokeOpcode == INVOKESTATIC ? null : defaultImplParam.getDescriptor(), + val method = getAsmMethod(); + val desc = JetTypeMapper.getDefaultDescriptor(method, + if (invokeOpcode == INVOKESTATIC) null else defaultImplParam.getDescriptor(), receiverParameterType != null); + if ("".equals(method.getName())) { - v.aconst(null); - v.visitMethodInsn(INVOKESPECIAL, defaultImplOwner.getInternalName(), "", desc, false); + v.aconst(null) + v.visitMethodInsn(INVOKESPECIAL, defaultImplOwner!!.getInternalName(), "", desc, false) } else { v.visitMethodInsn(INVOKESTATIC, defaultImplOwner.getInternalName(), @@ -159,48 +113,31 @@ public class CallableMethod implements ExtendedCallable { } } - public void invokeDefaultWithNotNullAssertion( - @NotNull InstructionAdapter v, - @NotNull GenerationState state, - @NotNull ResolvedCall resolvedCall - ) { - invokeDefault(v); - AsmUtil.genNotNullAssertionForMethod(v, state, resolvedCall); + public fun invokeDefaultWithNotNullAssertion(v: InstructionAdapter, state: GenerationState, resolvedCall: ResolvedCall<*>) { + invokeDefault(v) + AsmUtil.genNotNullAssertionForMethod(v, state, resolvedCall) } - @Override - @NotNull - public Type getReturnType() { - return signature.getReturnType(); + override fun getReturnType(): Type { + return signature.getReturnType() } - @Override - public String toString() { - return Printer.OPCODES[invokeOpcode] + " " + owner.getInternalName() + "." + signature; + override fun toString(): String { + return Printer.OPCODES[invokeOpcode] + " " + owner.getInternalName() + "." + signature } - @Override - public boolean isStaticCall() { - return invokeOpcode == Opcodes.INVOKESTATIC; + override fun isStaticCall(): Boolean { + return invokeOpcode == INVOKESTATIC } - @Override - public void beforeParameterGeneration(@NotNull InstructionAdapter v, @Nullable StackValue value) { + + public override fun beforeParameterGeneration(v: InstructionAdapter, value: StackValue?) { } - @NotNull - @Override - public StackValue invokeMethodWithArguments( - @NotNull final ResolvedCall resolvedCall, @NotNull final StackValue receiver, @NotNull final Type returnType, - @NotNull final ExpressionCodegen codegen - ) { - return StackValue.functionCall(returnType, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - codegen.invokeMethodWithArguments(CallableMethod.this, resolvedCall, receiver, returnType); - return Unit.INSTANCE$; - } - }); + override fun invokeMethodWithArguments(resolvedCall: ResolvedCall<*>, receiver: StackValue, returnType: Type, codegen: ExpressionCodegen): StackValue { + return StackValue.functionCall(returnType) { + codegen.invokeMethodWithArguments(this@CallableMethod, resolvedCall, receiver, returnType) + } } }