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

J2K CallBasedArgumentGenerator: convert and prettify

Browse Source
This commit is contained in:
Alexander Udalov
2018-11-08 17:04:16 +01:00
parent b66755b2d6
commit 7766f0a89d
1 changed files with 41 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.kt
+41 -76
View File
@@ -3,101 +3,66 @@
* that can be found in the license/LICENSE.txt file. * that can be found in the license/LICENSE.txt file.
*/ */
package org.jetbrains.kotlin.codegen; package org.jetbrains.kotlin.codegen
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
import org.jetbrains.kotlin.descriptors.CallableDescriptor; import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument
import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor; import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument
import org.jetbrains.kotlin.psi.KtExpression; import org.jetbrains.kotlin.resolve.calls.model.VarargValueArgument
import org.jetbrains.kotlin.psi.ValueArgument; import org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE
import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument; import org.jetbrains.kotlin.types.upperIfFlexible
import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument; import org.jetbrains.org.objectweb.asm.Type
import org.jetbrains.kotlin.resolve.calls.model.VarargValueArgument;
import org.jetbrains.kotlin.types.FlexibleTypesKt;
import org.jetbrains.org.objectweb.asm.Type;
import java.util.List; class CallBasedArgumentGenerator(
private val codegen: ExpressionCodegen,
import static org.jetbrains.kotlin.codegen.StackValue.createDefaultValue; private val callGenerator: CallGenerator,
import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE; private val valueParameters: List<ValueParameterDescriptor>,
private val valueParameterTypes: List<Type>
public class CallBasedArgumentGenerator extends ArgumentGenerator { ) : ArgumentGenerator() {
private final ExpressionCodegen codegen; private val isVarargInvoke: Boolean =
private final CallGenerator callGenerator; JvmCodegenUtil.isDeclarationOfBigArityFunctionInvoke(valueParameters.firstOrNull()?.containingDeclaration)
private final List<ValueParameterDescriptor> valueParameters;
private final List<Type> valueParameterTypes;
private final boolean isVarargInvoke;
public CallBasedArgumentGenerator(
@NotNull ExpressionCodegen codegen,
@NotNull CallGenerator callGenerator,
@NotNull List<ValueParameterDescriptor> valueParameters,
@NotNull List<Type> valueParameterTypes
) {
this.codegen = codegen;
this.callGenerator = callGenerator;
this.valueParameters = valueParameters;
this.valueParameterTypes = valueParameterTypes;
CallableDescriptor container = valueParameters.isEmpty() ? null : valueParameters.get(0).getContainingDeclaration();
this.isVarargInvoke = JvmCodegenUtil.isDeclarationOfBigArityFunctionInvoke(container);
init {
if (!isVarargInvoke) { if (!isVarargInvoke) {
assert valueParameters.size() == valueParameterTypes.size() : assert(valueParameters.size == valueParameterTypes.size) {
"Value parameters and their types mismatch in sizes: " + valueParameters.size() + " != " + valueParameterTypes.size(); "Value parameters and their types mismatch in sizes: ${valueParameters.size} != ${valueParameterTypes.size}"
}
} }
} }
@Override override fun generateExpression(i: Int, argument: ExpressionValueArgument) {
protected void generateExpression(int i, @NotNull ExpressionValueArgument argument) { val parameter = valueParameters[i]
ValueParameterDescriptor parameter = valueParameters.get(i); val valueArgument = argument.valueArgument!!
ValueArgument valueArgument = argument.getValueArgument(); val argumentExpression = valueArgument.getArgumentExpression() ?: error(valueArgument.asElement().text)
assert valueArgument != null; callGenerator.genValueAndPut(parameter, argumentExpression, if (isVarargInvoke) OBJECT_TYPE else valueParameterTypes[i], i)
KtExpression argumentExpression = valueArgument.getArgumentExpression();
assert argumentExpression != null : valueArgument.asElement().getText();
callGenerator.genValueAndPut(parameter, argumentExpression, isVarargInvoke ? OBJECT_TYPE : valueParameterTypes.get(i), i);
} }
@Override override fun generateDefault(i: Int, argument: DefaultValueArgument) {
protected void generateDefault(int i, @NotNull DefaultValueArgument argument) {
callGenerator.putValueIfNeeded( callGenerator.putValueIfNeeded(
getJvmKotlinType(valueParameterTypes, valueParameters, i), getJvmKotlinType(i),
createDefaultValue(valueParameterTypes.get(i)), StackValue.createDefaultValue(valueParameterTypes[i]),
ValueKind.DEFAULT_PARAMETER, ValueKind.DEFAULT_PARAMETER,
i i
); )
} }
@Override override fun generateVararg(i: Int, argument: VarargValueArgument) {
protected void generateVararg(int i, @NotNull VarargValueArgument argument) {
ValueParameterDescriptor parameter = valueParameters.get(i);
// Upper bound for type of vararg parameter should always have a form of 'Array<out T>', // Upper bound for type of vararg parameter should always have a form of 'Array<out T>',
// while its lower bound may be Nothing-typed after approximation // while its lower bound may be Nothing-typed after approximation
StackValue lazyVararg = codegen.genVarargs(argument, FlexibleTypesKt.upperIfFlexible(parameter.getType())); val lazyVararg = codegen.genVarargs(argument, valueParameters[i].type.upperIfFlexible())
callGenerator.putValueIfNeeded(getJvmKotlinType(valueParameterTypes, valueParameters, i), lazyVararg, ValueKind.GENERAL_VARARG, i); callGenerator.putValueIfNeeded(getJvmKotlinType(i), lazyVararg, ValueKind.GENERAL_VARARG, i)
} }
@Override override fun generateDefaultJava(i: Int, argument: DefaultValueArgument) {
protected void generateDefaultJava(int i, @NotNull DefaultValueArgument argument) { val argumentValue = valueParameters[i].findJavaDefaultArgumentValue(valueParameterTypes[i], codegen.typeMapper)
StackValue argumentValue = StackValueKt.findJavaDefaultArgumentValue(
valueParameters.get(i),
valueParameterTypes.get(i),
codegen.typeMapper
);
callGenerator.putValueIfNeeded(getJvmKotlinType(valueParameterTypes, valueParameters, i), argumentValue); callGenerator.putValueIfNeeded(getJvmKotlinType(i), argumentValue)
} }
@Override override fun reorderArgumentsIfNeeded(args: List<ArgumentAndDeclIndex>) {
protected void reorderArgumentsIfNeeded(@NotNull List<ArgumentAndDeclIndex> actualArgsWithDeclIndex) { callGenerator.reorderArgumentsIfNeeded(args, valueParameterTypes)
callGenerator.reorderArgumentsIfNeeded(actualArgsWithDeclIndex, valueParameterTypes);
} }
@NotNull private fun getJvmKotlinType(i: Int): JvmKotlinType =
private static JvmKotlinType getJvmKotlinType( JvmKotlinType(valueParameterTypes[i], valueParameters[i].original.type)
@NotNull List<Type> valueParameterTypes,
@NotNull List<ValueParameterDescriptor> valueParameters, int i
) {
return new JvmKotlinType(valueParameterTypes.get(i), valueParameters.get(i).getOriginal().getType());
}
} }