azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Convert TailRecursionCodegen.java to Kotlin

Browse Source
This commit is contained in:
Mikhael Bogdanov
2019-06-13 12:49:47 +02:00
parent 2eda7cb4b0
commit 077092d619
1 changed files with 81 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/kotlin/codegen/TailRecursionCodegen.kt
+81 -104
View File
@@ -14,145 +14,122 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.codegen; package org.jetbrains.kotlin.codegen
import com.google.common.collect.Lists; import com.google.common.collect.Lists
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.cfg.TailRecursionKind
import org.jetbrains.kotlin.cfg.TailRecursionKind; import org.jetbrains.kotlin.codegen.context.MethodContext
import org.jetbrains.kotlin.codegen.context.MethodContext; import org.jetbrains.kotlin.codegen.coroutines.*
import org.jetbrains.kotlin.codegen.coroutines.CoroutineCodegenUtilKt; import org.jetbrains.kotlin.codegen.state.GenerationState
import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.descriptors.CallableDescriptor
import org.jetbrains.kotlin.descriptors.CallableDescriptor; import org.jetbrains.kotlin.descriptors.FunctionDescriptor
import org.jetbrains.kotlin.descriptors.FunctionDescriptor; import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor; import org.jetbrains.kotlin.psi.KtExpression
import org.jetbrains.kotlin.psi.KtExpression; import org.jetbrains.kotlin.psi.KtSimpleNameExpression
import org.jetbrains.kotlin.psi.KtSimpleNameExpression; import org.jetbrains.kotlin.psi.ValueArgument
import org.jetbrains.kotlin.psi.ValueArgument; import org.jetbrains.kotlin.resolve.calls.callUtil.*
import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt; import org.jetbrains.kotlin.resolve.calls.model.*
import org.jetbrains.kotlin.resolve.calls.model.*; import org.jetbrains.org.objectweb.asm.Type
import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
import java.util.List; import org.jetbrains.kotlin.resolve.BindingContext.TAIL_RECURSION_CALL
import static org.jetbrains.kotlin.resolve.BindingContext.TAIL_RECURSION_CALL; class TailRecursionCodegen(
private val context: MethodContext,
private val codegen: ExpressionCodegen,
private val v: InstructionAdapter,
private val state: GenerationState
) {
public class TailRecursionCodegen { fun isTailRecursion(resolvedCall: ResolvedCall<*>): Boolean {
val status = state.bindingContext.get(TAIL_RECURSION_CALL, resolvedCall.call)
@NotNull return status != null && status.isDoGenerateTailRecursion
private final MethodContext context;
@NotNull
private final ExpressionCodegen codegen;
@NotNull
private final InstructionAdapter v;
@NotNull
private final GenerationState state;
public TailRecursionCodegen(
@NotNull MethodContext context,
@NotNull ExpressionCodegen codegen,
@NotNull InstructionAdapter v,
@NotNull GenerationState state
) {
this.context = context;
this.codegen = codegen;
this.v = v;
this.state = state;
} }
public boolean isTailRecursion(@NotNull ResolvedCall<?> resolvedCall) { fun generateTailRecursion(resolvedCall: ResolvedCall<*>) {
TailRecursionKind status = state.getBindingContext().get(TAIL_RECURSION_CALL, resolvedCall.getCall()); val fd = resolvedCall.resultingDescriptor.unwrapInitialDescriptorForSuspendFunction().let {
return status != null && status.isDoGenerateTailRecursion(); it as? FunctionDescriptor
} ?: error("Resolved call doesn't refer to the function descriptor: $it")
}
val callable = codegen.resolveToCallable(fd, false, resolvedCall) as CallableMethod
public void generateTailRecursion(ResolvedCall<?> resolvedCall) { val arguments = resolvedCall.valueArgumentsByIndex ?: throw IllegalStateException("Failed to arrange value arguments by index: $fd")
CallableDescriptor fd = CoroutineCodegenUtilKt.unwrapInitialDescriptorForSuspendFunction(resolvedCall.getResultingDescriptor());
assert fd instanceof FunctionDescriptor : "Resolved call doesn't refer to the function descriptor: " + fd;
CallableMethod callable = (CallableMethod) codegen.resolveToCallable((FunctionDescriptor) fd, false, resolvedCall);
List<ResolvedValueArgument> arguments = resolvedCall.getValueArgumentsByIndex(); if (fd.isSuspend) {
if (arguments == null) { AsmUtil.pop(v, callable.getValueParameters()[callable.getValueParameters().size - 1].asmType)
throw new IllegalStateException("Failed to arrange value arguments by index: " + fd);
} }
if (((FunctionDescriptor) fd).isSuspend()) { assignParameterValues(fd, callable, arguments)
AsmUtil.pop(v, callable.getValueParameters().get(callable.getValueParameters().size() - 1).getAsmType()); if (callable.extensionReceiverType != null) {
} if (resolvedCall.extensionReceiver != fd.extensionReceiverParameter!!.value) {
val expression = context.getReceiverExpression(codegen.typeMapper)
assignParameterValues(fd, callable, arguments); expression.store(StackValue.onStack(callable.extensionReceiverType), v, true)
if (callable.getExtensionReceiverType() != null) { } else {
if (resolvedCall.getExtensionReceiver() != fd.getExtensionReceiverParameter().getValue()) { AsmUtil.pop(v, callable.extensionReceiverType)
StackValue expression = context.getReceiverExpression(codegen.typeMapper);
expression.store(StackValue.onStack(callable.getExtensionReceiverType()), v, true);
}
else {
AsmUtil.pop(v, callable.getExtensionReceiverType());
} }
} }
if (callable.getDispatchReceiverType() != null) { if (callable.dispatchReceiverType != null) {
AsmUtil.pop(v, callable.getDispatchReceiverType()); AsmUtil.pop(v, callable.dispatchReceiverType)
} }
v.goTo(context.getMethodStartLabel()); v.goTo(context.methodStartLabel)
} }
private void assignParameterValues( private fun assignParameterValues(
CallableDescriptor fd, fd: CallableDescriptor,
CallableMethod callableMethod, callableMethod: CallableMethod,
List<ResolvedValueArgument> valueArguments valueArguments: List<ResolvedValueArgument>
) { ) {
List<Type> types = callableMethod.getValueParameterTypes(); val types = callableMethod.valueParameterTypes
for (ValueParameterDescriptor parameterDescriptor : Lists.reverse(fd.getValueParameters())) { loop@ for (parameterDescriptor in fd.valueParameters.asReversed()) {
ResolvedValueArgument arg = valueArguments.get(parameterDescriptor.getIndex()); val arg = valueArguments[parameterDescriptor.index]
Type type = types.get(parameterDescriptor.getIndex()); val type = types[parameterDescriptor.index]
if (arg instanceof ExpressionValueArgument) { when (arg) {
ExpressionValueArgument ev = (ExpressionValueArgument) arg; is ExpressionValueArgument -> {
ValueArgument argument = ev.getValueArgument(); val argumentExpression = arg.valueArgument?.getArgumentExpression()
KtExpression argumentExpression = argument == null ? null : argument.getArgumentExpression();
if (argumentExpression instanceof KtSimpleNameExpression) { if (argumentExpression is KtSimpleNameExpression) {
ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(argumentExpression, state.getBindingContext()); val resolvedCall = argumentExpression.getResolvedCall(state.bindingContext)
if (resolvedCall != null && resolvedCall.getResultingDescriptor().equals(parameterDescriptor.getOriginal())) { if (resolvedCall?.resultingDescriptor == parameterDescriptor.original) {
// do nothing: we shouldn't store argument to itself again // do nothing: we shouldn't store argument to itself again
AsmUtil.pop(v, type); AsmUtil.pop(v, type)
continue; continue@loop
}
} }
//assign the parameter below
} }
//assign the parameter below is DefaultValueArgument -> {
} AsmUtil.pop(v, type)
else if (arg instanceof DefaultValueArgument) { DefaultParameterValueLoader.DEFAULT.genValue(parameterDescriptor, codegen).put(type, v)
AsmUtil.pop(v, type); }
DefaultParameterValueLoader.DEFAULT.genValue(parameterDescriptor, codegen).put(type, v); is VarargValueArgument -> {
} // assign the parameter below
else if (arg instanceof VarargValueArgument) { }
// assign the parameter below else -> throw UnsupportedOperationException("Unknown argument type: $arg in $fd")
}
else {
throw new UnsupportedOperationException("Unknown argument type: " + arg + " in " + fd);
} }
store(parameterDescriptor, type); store(parameterDescriptor, type)
} }
} }
private void store(ValueParameterDescriptor parameterDescriptor, Type type) { private fun store(parameterDescriptor: ValueParameterDescriptor, type: Type) {
int index = getParameterVariableIndex(parameterDescriptor); val index = getParameterVariableIndex(parameterDescriptor)
v.store(index, type); v.store(index, type)
} }
private int getParameterVariableIndex(ValueParameterDescriptor parameterDescriptor) { private fun getParameterVariableIndex(parameterDescriptor: ValueParameterDescriptor): Int {
int index = codegen.lookupLocalIndex(parameterDescriptor); var index = codegen.lookupLocalIndex(parameterDescriptor)
if (index == -1) { if (index == -1) {
// in the case of a generic function recursively calling itself, the parameters on the call site are substituted // in the case of a generic function recursively calling itself, the parameters on the call site are substituted
index = codegen.lookupLocalIndex(parameterDescriptor.getOriginal()); index = codegen.lookupLocalIndex(parameterDescriptor.original)
} }
if (index == -1) { if (index == -1) {
throw new IllegalStateException("Failed to obtain parameter index: " + parameterDescriptor); throw IllegalStateException("Failed to obtain parameter index: $parameterDescriptor")
} }
return index; return index
} }
} }