From cd78514b76103bfa6d6a1bd2afa0f05816aa4330 Mon Sep 17 00:00:00 2001 From: Michael Bogdanov Date: Thu, 1 Oct 2015 12:15:05 +0300 Subject: [PATCH] Code clean, small refactorings and tests #KT-8987 Fixed --- .../kotlin/codegen/ArgumentGenerator.kt | 47 +++++++--------- .../codegen/CallBasedArgumentGenerator.java | 22 +++----- .../jetbrains/kotlin/codegen/CallGenerator.kt | 35 ++++++------ .../kotlin/codegen/ExpressionCodegen.java | 4 +- .../codegen/ImplementationBodyCodegen.java | 19 +++---- .../jetbrains/kotlin/codegen/StackValue.java | 2 +- .../kotlin/codegen/inline/InlineCodegen.java | 8 +-- .../codegen/inline/LocalVarRemapper.java | 28 ++-------- .../kotlin/codegen/inline/MethodInliner.java | 4 +- .../kotlin/codegen/inline/Parameters.kt | 53 +++++++----------- .../codegen/inline/ParametersBuilder.kt | 6 +-- .../codegen/box/argumentOrder/captured.kt | 31 +++++++++++ .../box/argumentOrder/capturedInExtension.kt | 30 +++++++++++ .../codegen/box/argumentOrder/defaults.kt | 13 +++++ .../codegen/box/argumentOrder/extension.kt | 30 +++++++++++ .../box/argumentOrder/extensionInClass.kt | 37 +++++++++++++ .../box/argumentOrder/lambdaMigration.kt | 21 ++++++++ .../argumentOrder/lambdaMigrationInClass.kt | 25 +++++++++ .../codegen/box/argumentOrder/simple.kt | 21 ++++++++ .../box/argumentOrder/simpleInClass.kt | 23 ++++++++ .../argumentOrder/argumentReorder.kt | 11 ++++ .../argumentReorderWithDefault.kt | 13 +++++ .../bytecodeText/argumentOrder/sameOrder.kt | 12 +++++ .../argumentOrder/sameOrderWithDefault.kt | 12 +++++ .../codegen/BytecodeTextTestGenerated.java | 33 ++++++++++++ .../BlackBoxCodegenTestGenerated.java | 54 +++++++++++++++++++ 26 files changed, 451 insertions(+), 143 deletions(-) create mode 100644 compiler/testData/codegen/box/argumentOrder/captured.kt create mode 100644 compiler/testData/codegen/box/argumentOrder/capturedInExtension.kt create mode 100644 compiler/testData/codegen/box/argumentOrder/defaults.kt create mode 100644 compiler/testData/codegen/box/argumentOrder/extension.kt create mode 100644 compiler/testData/codegen/box/argumentOrder/extensionInClass.kt create mode 100644 compiler/testData/codegen/box/argumentOrder/lambdaMigration.kt create mode 100644 compiler/testData/codegen/box/argumentOrder/lambdaMigrationInClass.kt create mode 100644 compiler/testData/codegen/box/argumentOrder/simple.kt create mode 100644 compiler/testData/codegen/box/argumentOrder/simpleInClass.kt create mode 100644 compiler/testData/codegen/bytecodeText/argumentOrder/argumentReorder.kt create mode 100644 compiler/testData/codegen/bytecodeText/argumentOrder/argumentReorderWithDefault.kt create mode 100644 compiler/testData/codegen/bytecodeText/argumentOrder/sameOrder.kt create mode 100644 compiler/testData/codegen/bytecodeText/argumentOrder/sameOrderWithDefault.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ArgumentGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/ArgumentGenerator.kt index a26ee863945..628b1ea04eb 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ArgumentGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ArgumentGenerator.kt @@ -16,25 +16,24 @@ package org.jetbrains.kotlin.codegen -import org.jetbrains.kotlin.resolve.calls.model.* +import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument +import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument +import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument +import org.jetbrains.kotlin.resolve.calls.model.VarargValueArgument import org.jetbrains.kotlin.utils.mapToIndex -import org.jetbrains.org.objectweb.asm.Type -import java.util.* -class ArgumentAndIndex(val arg: ResolvedValueArgument, val declIndex: Int, var type: Type? = null, var reorder: Boolean = false, var tempValue: StackValue? = null) +class ArgumentAndDeclIndex(val arg: ResolvedValueArgument, val declIndex: Int) abstract class ArgumentGenerator { /** * @return a `List` of bit masks of default arguments that should be passed as last arguments to $default method, if there were - * * any default arguments, or an empty `List` if there were none - * * + * any default arguments, or an empty `List` if there were none + * * @see kotlin.reflect.jvm.internal.KCallableImpl.callBy - * @param valueArgumentsByIndex - * * - * @param actualArgs */ - open fun generate(valueArgumentsByIndex: List, actualArgs: List, codegen: ExpressionCodegen): DefaultCallMask { + open fun generate(valueArgumentsByIndex: List, actualArgs: List): DefaultCallMask { //HACK: see tempVariable in ExpressionCodegen + assert (valueArgumentsByIndex.size() == actualArgs.size()) val actualArguments = if (actualArgs.isNotEmpty()) actualArgs else valueArgumentsByIndex assert(valueArgumentsByIndex.size() == actualArguments.size()) { @@ -43,24 +42,23 @@ abstract class ArgumentGenerator { val arg2Index = valueArgumentsByIndex.mapToIndex() - val actualArgsWithDeclIndex: ArrayList = ArrayList(actualArguments.filter { it !is DefaultValueArgument }.map { - ArgumentAndIndex(it, arg2Index[it]!!) - }) + val actualArgsWithDeclIndex = actualArguments.filter { it !is DefaultValueArgument }.map { + ArgumentAndDeclIndex(it, arg2Index[it]!!) + }.toArrayList() valueArgumentsByIndex.withIndex().forEach { if (it.value is DefaultValueArgument) { - actualArgsWithDeclIndex.add(it.index, ArgumentAndIndex(it.value, it.index)) + actualArgsWithDeclIndex.add(it.index, ArgumentAndDeclIndex(it.value, it.index)) } } val masks = DefaultCallMask(valueArgumentsByIndex.size()) - var orderChanged = false - for ((actualIndex, argumentWithDeclIndex) in actualArgsWithDeclIndex.withIndex()) { + for (argumentWithDeclIndex in actualArgsWithDeclIndex) { val argument = argumentWithDeclIndex.arg val declIndex = argumentWithDeclIndex.declIndex - argumentWithDeclIndex.type = when (argument) { + when (argument) { is ExpressionValueArgument -> { generateExpression(declIndex, argument) } @@ -75,11 +73,6 @@ abstract class ArgumentGenerator { generateOther(declIndex, argument) } } - - if (actualIndex != declIndex || orderChanged) { - orderChanged = true - argumentWithDeclIndex.reorder = true - } } reorderArgumentsIfNeeded(actualArgsWithDeclIndex) @@ -87,23 +80,23 @@ abstract class ArgumentGenerator { return masks } - protected open fun generateExpression(i: Int, argument: ExpressionValueArgument): Type { + protected open fun generateExpression(i: Int, argument: ExpressionValueArgument) { throw UnsupportedOperationException("Unsupported expression value argument #$i: $argument") } - protected open fun generateDefault(i: Int, argument: DefaultValueArgument): Type { + protected open fun generateDefault(i: Int, argument: DefaultValueArgument) { throw UnsupportedOperationException("Unsupported default value argument #$i: $argument") } - protected open fun generateVararg(i: Int, argument: VarargValueArgument): Type { + protected open fun generateVararg(i: Int, argument: VarargValueArgument) { throw UnsupportedOperationException("Unsupported vararg value argument #$i: $argument") } - protected open fun generateOther(i: Int, argument: ResolvedValueArgument): Type { + protected open fun generateOther(i: Int, argument: ResolvedValueArgument) { throw UnsupportedOperationException("Unsupported value argument #$i: $argument") } - protected open fun reorderArgumentsIfNeeded(args: ArrayList) { + protected open fun reorderArgumentsIfNeeded(args: List) { throw UnsupportedOperationException("Unsupported operation") } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.java index 34d243ddf34..a15ac23d66f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.java @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.psi.ValueArgument; import org.jetbrains.kotlin.resolve.calls.model.*; import org.jetbrains.org.objectweb.asm.Type; -import java.util.ArrayList; import java.util.List; import static org.jetbrains.kotlin.codegen.AsmUtil.pushDefaultValueOnStack; @@ -54,19 +53,17 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator { @Override public DefaultCallMask generate( @NotNull List valueArgumentsByIndex, - @NotNull List valueArgs, - @NotNull ExpressionCodegen codegen + @NotNull List valueArgs ) { boolean shouldMarkLineNumbers = this.codegen.isShouldMarkLineNumbers(); this.codegen.setShouldMarkLineNumbers(false); - DefaultCallMask masks = super.generate(valueArgumentsByIndex, valueArgs, codegen); + DefaultCallMask masks = super.generate(valueArgumentsByIndex, valueArgs); this.codegen.setShouldMarkLineNumbers(shouldMarkLineNumbers); return masks; } - @NotNull @Override - protected Type generateExpression(int i, @NotNull ExpressionValueArgument argument) { + protected void generateExpression(int i, @NotNull ExpressionValueArgument argument) { ValueParameterDescriptor parameter = valueParameters.get(i); Type type = valueParameterTypes.get(i); ValueArgument valueArgument = argument.getValueArgument(); @@ -74,31 +71,26 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator { JetExpression argumentExpression = valueArgument.getArgumentExpression(); assert argumentExpression != null : valueArgument.asElement().getText(); callGenerator.genValueAndPut(parameter, argumentExpression, type, i); - return type; } - @NotNull @Override - protected Type generateDefault(int i, @NotNull DefaultValueArgument argument) { + protected void generateDefault(int i, @NotNull DefaultValueArgument argument) { ValueParameterDescriptor parameter = valueParameters.get(i); Type type = valueParameterTypes.get(i); pushDefaultValueOnStack(type, codegen.v); callGenerator.afterParameterPut(type, null, parameter, i); - return type; } - @NotNull @Override - protected Type generateVararg(int i, @NotNull VarargValueArgument argument) { + protected void generateVararg(int i, @NotNull VarargValueArgument argument) { ValueParameterDescriptor parameter = valueParameters.get(i); Type type = valueParameterTypes.get(i); codegen.genVarargs(argument, parameter.getType()); callGenerator.afterParameterPut(type, null, parameter, i); - return type; } @Override - protected void reorderArgumentsIfNeeded(@NotNull ArrayList actualArgsWithDeclIndex) { - callGenerator.reorderArgumentsIfNeeded(actualArgsWithDeclIndex); + protected void reorderArgumentsIfNeeded(@NotNull List actualArgsWithDeclIndex) { + callGenerator.reorderArgumentsIfNeeded(actualArgsWithDeclIndex, valueParameterTypes); } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt index 91d60a607df..9f3953fe0a1 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt @@ -21,8 +21,6 @@ import org.jetbrains.kotlin.psi.JetExpression import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall import org.jetbrains.org.objectweb.asm.Type -import java.util.ArrayList - abstract class CallGenerator { internal class DefaultCallGenerator(private val codegen: ExpressionCodegen) : CallGenerator() { @@ -41,8 +39,8 @@ abstract class CallGenerator { } override fun genCallWithoutAssertions( - method: CallableMethod, codegen: ExpressionCodegen) { - method.genInvokeInstruction(codegen.v) + callableMethod: CallableMethod, codegen: ExpressionCodegen) { + callableMethod.genInvokeInstruction(codegen.v) } override fun afterParameterPut( @@ -61,7 +59,7 @@ abstract class CallGenerator { valueParameterDescriptor: ValueParameterDescriptor, argumentExpression: JetExpression, parameterType: Type, - index: Int) { + parameterIndex: Int) { val value = codegen.gen(argumentExpression) value.put(parameterType, codegen.v) } @@ -76,22 +74,23 @@ abstract class CallGenerator { value.put(value.type, codegen.v) } - override fun reorderArgumentsIfNeeded(actualArgsWithDeclIndex: ArrayList) { + override fun reorderArgumentsIfNeeded(actualArgsWithDeclIndex: List, valueParameterTypes: List) { val mark = codegen.myFrameMap.mark() - actualArgsWithDeclIndex.reversed().forEach { - if (it.reorder) { - val type = it.type!! - it.tempValue = StackValue.local(codegen.frameMap.enterTemp(type), type) - it.tempValue?.store(StackValue.onStack(type), codegen.v) - } + val reordered = actualArgsWithDeclIndex.withIndex().dropWhile { + it.value.declIndex == it.index } - actualArgsWithDeclIndex.sortedBy { it.declIndex }.forEach { - it.tempValue?.let { - it.put(it.type, codegen.v) - } + reordered.reversed().map { + val argumentAndDeclIndex = it.value + val type = valueParameterTypes.get(argumentAndDeclIndex.declIndex) + val stackValue = StackValue.local(codegen.frameMap.enterTemp(type), type) + stackValue.store(StackValue.onStack(type), codegen.v) + Pair(argumentAndDeclIndex.declIndex, stackValue) + }.sortedBy { + it.first + }.forEach { + it.second.put(valueParameterTypes.get(it.first), codegen.v) } - mark.dropTo() } } @@ -134,5 +133,5 @@ abstract class CallGenerator { abstract fun putHiddenParams() - abstract fun reorderArgumentsIfNeeded(actualArgsWithDeclIndex: ArrayList) + abstract fun reorderArgumentsIfNeeded(actualArgsWithDeclIndex: List, valueParameterTypes: List) } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 317bc03f681..b690b8f9c1d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -1486,7 +1486,7 @@ public class ExpressionCodegen extends JetVisitor implem ArgumentGenerator argumentGenerator = new CallBasedArgumentGenerator(ExpressionCodegen.this, defaultCallGenerator, valueParameters, mappedTypes); - argumentGenerator.generate(valueArguments, valueArguments, ExpressionCodegen.this); + argumentGenerator.generate(valueArguments, valueArguments); } Collection constructors = classDescriptor.getConstructors(); @@ -2455,7 +2455,7 @@ public class ExpressionCodegen extends JetVisitor implem assert valueArguments != null : "Failed to arrange value arguments by index: " + resolvedCall.getResultingDescriptor(); List masks = - argumentGenerator.generate(valueArguments, new ArrayList(resolvedCall.getValueArguments().values()), this) + argumentGenerator.generate(valueArguments, new ArrayList(resolvedCall.getValueArguments().values())) .toInts(); if (tailRecursionCodegen.isTailRecursion(resolvedCall)) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index f9363628cb9..b2171500361 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java @@ -1643,35 +1643,30 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { this.offset = firstValueParamOffset; } - @NotNull @Override - public Type generateExpression(int i, @NotNull ExpressionValueArgument argument) { - return generateSuperCallArgument(i); + public void generateExpression(int i, @NotNull ExpressionValueArgument argument) { + generateSuperCallArgument(i); } - @NotNull @Override - public Type generateDefault(int i, @NotNull DefaultValueArgument argument) { + public void generateDefault(int i, @NotNull DefaultValueArgument argument) { Type type = parameters.get(i).getAsmType(); pushDefaultValueOnStack(type, iv); - return type; } - @NotNull @Override - public Type generateVararg(int i, @NotNull VarargValueArgument argument) { - return generateSuperCallArgument(i); + public void generateVararg(int i, @NotNull VarargValueArgument argument) { + generateSuperCallArgument(i); } - private Type generateSuperCallArgument(int i) { + private void generateSuperCallArgument(int i) { Type type = parameters.get(i).getAsmType(); iv.load(offset, type); offset += type.getSize(); - return type; } @Override - protected void reorderArgumentsIfNeeded(@NotNull ArrayList args) { + protected void reorderArgumentsIfNeeded(@NotNull List args) { } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java index 548a1758c04..d2b69cb23b4 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java @@ -769,7 +769,7 @@ public abstract class StackValue { ResolvedCall call = isGetter ? resolvedGetCall : resolvedSetCall; StackValue newReceiver = StackValue.receiver(call, receiver, codegen, callable); newReceiver.put(newReceiver.type, v); - argumentGenerator.generate(valueArguments, valueArguments, codegen); + argumentGenerator.generate(valueArguments, valueArguments); } @Override diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java index 5ed5c5f86fe..4d7fd644802 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java @@ -520,8 +520,8 @@ public class InlineCodegen extends CallGenerator { } invocationParamBuilder.markValueParametesStart(); - List infos = invocationParamBuilder.listNotCaptured(); - recordParameterValueInLocalVal(infos.toArray(new ParameterInfo[infos.size()])); + List hiddenParameters = invocationParamBuilder.buildParameters().getReal(); + recordParameterValueInLocalVal(hiddenParameters.toArray(new ParameterInfo[hiddenParameters.size()])); } public void leaveTemps() { @@ -772,7 +772,9 @@ public class InlineCodegen extends CallGenerator { } @Override - public void reorderArgumentsIfNeeded(@NotNull ArrayList actualArgsWithDeclIndex) { + public void reorderArgumentsIfNeeded( + @NotNull List actualArgsWithDeclIndex, @NotNull List valueParameterTypes + ) { } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LocalVarRemapper.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LocalVarRemapper.java index b04f051377f..3207f86b014 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LocalVarRemapper.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LocalVarRemapper.java @@ -29,7 +29,6 @@ import static org.jetbrains.kotlin.codegen.inline.LocalVarRemapper.RemapStatus.* public class LocalVarRemapper { - private final int allParamsSize; private final Parameters params; private final int actualParamsSize; @@ -38,36 +37,19 @@ public class LocalVarRemapper { public LocalVarRemapper(Parameters params, int additionalShift) { this.additionalShift = additionalShift; - this.allParamsSize = params.getArgsSizeOnStack(); this.params = params; remapValues = new StackValue [params.getArgsSizeOnStack()]; - Integer [] declIndexesToActual = new Integer [params.getArgsSizeOnStack()]; - Integer [] actualDeclShifts = new Integer [params.getArgsSizeOnStack()]; - - int index = 0; - for (ParameterInfo param : params) { - declIndexesToActual[param.declarationIndex] = index; - index++; - } int realSize = 0; - for (int i = 0; i < declIndexesToActual.length; i++) { - Integer declIndexToActual = declIndexesToActual[i]; - if (declIndexToActual != null) { - actualDeclShifts[i] = realSize; - realSize += params.get(declIndexToActual).getType().getSize(); - } - } - - realSize = 0; for (ParameterInfo info : params) { + Integer shift = params.getDeclarationSlot(info); if (!info.isSkippedOrRemapped()) { - remapValues[actualDeclShifts[info.declarationIndex]] = StackValue.local(realSize, AsmTypes.OBJECT_TYPE); + remapValues[shift] = StackValue.local(realSize, AsmTypes.OBJECT_TYPE); realSize += info.getType().getSize(); } else { - remapValues[actualDeclShifts[info.declarationIndex]] = info.isRemapped() ? info.getRemapValue() : null; + remapValues[shift] = info.isRemapped() ? info.getRemapValue() : null; } } @@ -77,8 +59,8 @@ public class LocalVarRemapper { public RemapInfo doRemap(int index) { int remappedIndex; - if (index < allParamsSize) { - ParameterInfo info = params.getByByteCodeIndex(index); + if (index < params.getArgsSizeOnStack()) { + ParameterInfo info = params.getParameterByDeclarationSlot(index); StackValue remapped = remapValues[index]; if (info.isSkipped || remapped == null) { return new RemapInfo(info); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java index 8d222398fea..e2a18e7e1df 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java @@ -312,7 +312,7 @@ public class MethodInliner { Type[] types = Type.getArgumentTypes(node.desc); Type returnType = Type.getReturnType(node.desc); - ArrayList capturedTypes = parameters.getCapturedTypes(); + List capturedTypes = parameters.getCapturedTypes(); Type[] allTypes = ArrayUtil.mergeArrays(types, capturedTypes.toArray(new Type[capturedTypes.size()])); node.instructions.resetLabels(); @@ -559,7 +559,7 @@ public class MethodInliner { private LambdaInfo getLambdaIfExists(int varIndex) { if (varIndex < parameters.getArgsSizeOnStack()) { - return parameters.getByByteCodeIndex(varIndex).getLambda(); + return parameters.getParameterByDeclarationSlot(varIndex).getLambda(); } return null; } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/Parameters.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/Parameters.kt index 9bb67ddb6e9..94109614244 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/Parameters.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/Parameters.kt @@ -16,24 +16,21 @@ package org.jetbrains.kotlin.codegen.inline -import com.google.common.collect.Iterables import org.jetbrains.org.objectweb.asm.Type +import java.util.* -import java.util.ArrayList - -//All parameters with gaps class Parameters(val real: List, val captured: List) : Iterable { - private val declIndexesToActual: Array private val actualDeclShifts: Array + private val paramToDeclByteCodeIndex: HashMap = hashMapOf() - public val realArgsSizeOnStack = real.fold(0, { a, v -> a + v.type.size}) - public val capturedArgsSizeOnStack = captured.fold(0, { a, v -> a + v.type.size}) + public val realArgsSizeOnStack = real.sumBy { it.type.size } + public val capturedArgsSizeOnStack = captured.sumBy { it.type.size } public val argsSizeOnStack = realArgsSizeOnStack + capturedArgsSizeOnStack init { - declIndexesToActual = arrayOfNulls(argsSizeOnStack) + val declIndexesToActual = arrayOfNulls(argsSizeOnStack) withIndex().forEach { it -> declIndexesToActual[it.value.declarationIndex] = it.index } @@ -41,27 +38,22 @@ class Parameters(val real: List, val captured: List(argsSizeOnStack) var realSize = 0 for (i in declIndexesToActual.indices) { - val declIndexToActual = declIndexesToActual[i] - if (declIndexToActual != null) { - val byDeclarationIndex = getByDeclarationIndex(i) - actualDeclShifts[realSize] = byDeclarationIndex - realSize += byDeclarationIndex.type.size - } + val byDeclarationIndex = get(declIndexesToActual[i] ?: continue) + actualDeclShifts[realSize] = byDeclarationIndex + paramToDeclByteCodeIndex.put(byDeclarationIndex, realSize) + realSize += byDeclarationIndex.type.size } } - fun getByDeclarationIndex(index: Int): ParameterInfo { - if (index < realArgsSizeOnStack) { - return real.get(declIndexesToActual[index]!!) - } - return captured.get(declIndexesToActual[index]!! - real.size()) + fun getDeclarationSlot(info : ParameterInfo): Int { + return paramToDeclByteCodeIndex[info]!! } - fun getByByteCodeIndex(index: Int): ParameterInfo { + fun getParameterByDeclarationSlot(index: Int): ParameterInfo { return actualDeclShifts[index]!! } - fun get(index: Int): ParameterInfo { + private fun get(index: Int): ParameterInfo { if (index < real.size()) { return real.get(index) } @@ -69,26 +61,17 @@ class Parameters(val real: List, val captured: List { - return Iterables.concat(real, captured).iterator() + return (real + captured).iterator() } - val capturedTypes: ArrayList - get() { - val result = ArrayList() - for (info in captured) { - result.add(info.getType()) - } - return result + val capturedTypes: List + get() = captured.map { + it.getType() } companion object { fun shift(capturedParams: List, realSize: Int): List { - val result = ArrayList() - for (capturedParamInfo in capturedParams) { - val newInfo = capturedParamInfo.newIndex(result.size() + realSize) - result.add(newInfo) - } - return result + return capturedParams.withIndex().map { it.value.newIndex(it.index+ realSize) } } } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ParametersBuilder.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ParametersBuilder.kt index c039477f2c4..d558a990b1c 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ParametersBuilder.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ParametersBuilder.kt @@ -100,10 +100,6 @@ class ParametersBuilder private constructor(){ return info } - fun listNotCaptured(): List { - return Collections.unmodifiableList(valueAndHiddenParams) - } - fun markValueParametesStart(){ this.valueParamStart = valueAndHiddenParams.size() } @@ -118,7 +114,7 @@ class ParametersBuilder private constructor(){ } fun buildParameters(): Parameters { - return Parameters(listNotCaptured(), Parameters.shift(listCaptured(), nextValueParameterIndex)) + return Parameters(Collections.unmodifiableList(valueAndHiddenParams), Parameters.shift(listCaptured(), nextValueParameterIndex)) } companion object { diff --git a/compiler/testData/codegen/box/argumentOrder/captured.kt b/compiler/testData/codegen/box/argumentOrder/captured.kt new file mode 100644 index 00000000000..f4f35913a07 --- /dev/null +++ b/compiler/testData/codegen/box/argumentOrder/captured.kt @@ -0,0 +1,31 @@ +fun box(): String { + var invokeOrder = ""; + val expectedResult = "0_1_9" + val expectedInvokeOrder = "1_0_9" + var l = 1L + var i = 0 + val captured = 9L + + var result = test(b = {invokeOrder += "1_"; l}(), a = {invokeOrder+="0_"; i}(), c = {invokeOrder += "$captured"; "$captured"}) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 1: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + invokeOrder = ""; + result = test(b = {invokeOrder += "1_"; l}(), c = {invokeOrder += "$captured"; "$captured"}, a = {invokeOrder+="0_"; i}()) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 2: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + + invokeOrder = ""; + result = test(c = {invokeOrder += "$captured"; "$captured"}, b = {invokeOrder += "1_"; l}(), a = {invokeOrder+="0_"; i}()) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 3: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + + invokeOrder = ""; + result = test(a = {invokeOrder+="0_"; i}(), c = {invokeOrder += "$captured"; "$captured"}, b = {invokeOrder += "1_"; l}()) + if (invokeOrder != "0_1_9" || result != expectedResult) return "fail 4: $invokeOrder != 0_1_9 or $result != $expectedResult" + + return "OK" +} + +fun test(a: Int, b: Long, c: () -> String): String { + return { "${a}_${b}_${c()}"} () +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/argumentOrder/capturedInExtension.kt b/compiler/testData/codegen/box/argumentOrder/capturedInExtension.kt new file mode 100644 index 00000000000..b68ecfa0774 --- /dev/null +++ b/compiler/testData/codegen/box/argumentOrder/capturedInExtension.kt @@ -0,0 +1,30 @@ +fun box(): String { + var invokeOrder = ""; + val expectedResult = "1.0_0_1_9" + val expectedInvokeOrder = "1_0_9" + var l = 1L + var i = 0 + val captured = 9L + + var result = 1.0.test(b = {invokeOrder += "1_"; l}(), a = {invokeOrder+="0_"; i}(), c = {invokeOrder += "$captured"; "$captured"}) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 1: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + invokeOrder = ""; + result = 1.0.test(b = {invokeOrder += "1_"; l}(), c = {invokeOrder += "${captured}"; "${captured}"}, a = {invokeOrder+="0_"; i}()) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 2: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + + invokeOrder = ""; + result = 1.0.test(c = {invokeOrder += "${captured}"; "${captured}"}, b = {invokeOrder += "1_"; l}(), a = {invokeOrder+="0_"; i}()) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 3: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + invokeOrder = ""; + result = 1.0.test(a = {invokeOrder+="0_"; i}(), c = {invokeOrder += "${captured}"; "${captured}"}, b = {invokeOrder += "1_"; l}()) + if (invokeOrder != "0_1_9" || result != expectedResult) return "fail 4: $invokeOrder != 0_1_9 or $result != $expectedResult" + + return "OK" +} + +fun Double.test(a: Int, b: Long, c: () -> String): String { + return { "${this}_${a}_${b}_${c()}"} () +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/argumentOrder/defaults.kt b/compiler/testData/codegen/box/argumentOrder/defaults.kt new file mode 100644 index 00000000000..d085949ea13 --- /dev/null +++ b/compiler/testData/codegen/box/argumentOrder/defaults.kt @@ -0,0 +1,13 @@ +var invokeOrder: String = "" + +fun test(x: Double = { invokeOrder += "x"; 1.0 }(), a: String, y: Long = { invokeOrder += "y"; 1 }(), b: String): String { + return "" + x + a + b + y; +} + +fun box(): String { + val funResult = test(b = { invokeOrder += "K"; "K" }(), a = { invokeOrder += "O"; "O" }()) + + if (invokeOrder != "KOxy" || funResult != "1.0OK1") return "fail: $invokeOrder != KOxy or $funResult != 1.0OK1" + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/argumentOrder/extension.kt b/compiler/testData/codegen/box/argumentOrder/extension.kt new file mode 100644 index 00000000000..a4db0c6f574 --- /dev/null +++ b/compiler/testData/codegen/box/argumentOrder/extension.kt @@ -0,0 +1,30 @@ +fun box(): String { + var invokeOrder = ""; + val expectedResult = "1.0_0_1_L" + val expectedInvokeOrder = "1_0_L" + var l = 1L + var i = 0 + + var result = 1.0.test(b = {invokeOrder += "1_"; l}(), a = {invokeOrder+="0_"; i}(), c = {invokeOrder += "L"; "L"}) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 1: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + invokeOrder = ""; + result = 1.0.test(b = {invokeOrder += "1_"; l}(), c = {invokeOrder += "L"; "L"}, a = {invokeOrder+="0_"; i}()) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 2: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + + invokeOrder = ""; + result = 1.0.test(c = {invokeOrder += "L"; "L"}, b = {invokeOrder += "1_"; l}(), a = {invokeOrder+="0_"; i}()) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 3: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + + invokeOrder = ""; + result = 1.0.test(a = {invokeOrder+="0_"; i}(), c = {invokeOrder += "L"; "L"}, b = {invokeOrder += "1_"; l}()) + if (invokeOrder != "0_1_L" || result != expectedResult) return "fail 4: $invokeOrder != 0_1_L or $result != $expectedResult" + + return "OK" +} + +fun Double.test(a: Int, b: Long, c: () -> String): String { + return "${this}_${a}_${b}_${c()}" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/argumentOrder/extensionInClass.kt b/compiler/testData/codegen/box/argumentOrder/extensionInClass.kt new file mode 100644 index 00000000000..5839379ac0b --- /dev/null +++ b/compiler/testData/codegen/box/argumentOrder/extensionInClass.kt @@ -0,0 +1,37 @@ +fun box(): String { + return Z().test() +} + +class Z { + fun Double.test(a: Int, b: Long, c: () -> String): String { + return "${this}_${a}_${b}_${c()}" + } + + + fun test(): String { + var invokeOrder = ""; + val expectedResult = "1.0_0_1_L" + val expectedInvokeOrder = "1_0_L" + var l = 1L + var i = 0 + + var result = 1.0.test(b = { invokeOrder += "1_"; l }(), a = { invokeOrder += "0_"; i }(), c = { invokeOrder += "L"; "L" }) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 1: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + invokeOrder = ""; + result = 1.0.test(b = { invokeOrder += "1_"; l }(), c = { invokeOrder += "L"; "L" }, a = { invokeOrder += "0_"; i }()) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 2: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + + invokeOrder = ""; + result = 1.0.test(c = { invokeOrder += "L"; "L" }, b = { invokeOrder += "1_"; l }(), a = { invokeOrder += "0_"; i }()) + if (invokeOrder != expectedInvokeOrder || result != expectedResult) return "fail 3: $invokeOrder != $expectedInvokeOrder or $result != $expectedResult" + + + invokeOrder = ""; + result = 1.0.test(a = { invokeOrder += "0_"; i }(), c = { invokeOrder += "L"; "L" }, b = { invokeOrder += "1_"; l }()) + if (invokeOrder != "0_1_L" || result != expectedResult) return "fail 4: $invokeOrder != 0_1_L or $result != $expectedResult" + + return "OK" + } +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/argumentOrder/lambdaMigration.kt b/compiler/testData/codegen/box/argumentOrder/lambdaMigration.kt new file mode 100644 index 00000000000..6ef53bff6ee --- /dev/null +++ b/compiler/testData/codegen/box/argumentOrder/lambdaMigration.kt @@ -0,0 +1,21 @@ +fun box(): String { + var res = ""; + var call = test(a = {res += "K"; "K"}(), b = {res+="O"; "O"}(), c = {res += "L"; "L"}) + if (res != "KOL" || call != "KOL") return "fail 1: $res != KOL or $call != KOL" + + res = ""; + call = test(a = {res += "K"; "K"}(), c = {res += "L"; "L"}, b = {res+="O"; "O"}()) + if (res != "KOL" || call != "KOL") return "fail 2: $res != KOL or $call != KOL" + + + res = ""; + call = test(c = {res += "L"; "L"}, a = {res += "K"; "K"}(), b = {res+="O"; "O"}()) + if (res != "KOL" || call != "KOL") return "fail 3: $res != KOL or $call != KOL" + + return "OK" + +} + +fun test(a: String, b: String, c: () -> String): String { + return a + b + c(); +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/argumentOrder/lambdaMigrationInClass.kt b/compiler/testData/codegen/box/argumentOrder/lambdaMigrationInClass.kt new file mode 100644 index 00000000000..7100b035e29 --- /dev/null +++ b/compiler/testData/codegen/box/argumentOrder/lambdaMigrationInClass.kt @@ -0,0 +1,25 @@ +fun box(): String { + var res = ""; + var call = Z("Z").test(a = {res += "K"; "K"}(), b = {res+="O"; "O"}(), c = {res += "L"; "L"}) + if (res != "KOL" || call != "KOLZ") return "fail 1: $res != KOL or $call != KOLZ" + + res = ""; + call = Z("Z").test(a = {res += "K"; "K"}(), c = {res += "L"; "L"}, b = {res+="O"; "O"}()) + if (res != "KOL" || call != "KOLZ") return "fail 2: $res != KOL or $call != KOLZ" + + + res = ""; + call = Z("Z").test(c = {res += "L"; "L"}, a = {res += "K"; "K"}(), b = {res+="O"; "O"}()) + if (res != "KOL" || call != "KOLZ") return "fail 3: $res != KOL or $call != KOLZ" + + return "OK" + +} + +class Z(val p: String) { + + fun test(a: String, b: String, c: () -> String): String { + return a + b + c() + p; + } + +} diff --git a/compiler/testData/codegen/box/argumentOrder/simple.kt b/compiler/testData/codegen/box/argumentOrder/simple.kt new file mode 100644 index 00000000000..112891c4d9a --- /dev/null +++ b/compiler/testData/codegen/box/argumentOrder/simple.kt @@ -0,0 +1,21 @@ +fun box(): String { + var res = ""; + var call = test(b = {res += "K"; "K"}(), a = {res+="O"; "O"}(), c = {res += "L"; "L"}) + if (res != "KOL" || call != "OKL") return "fail 1: $res != KOL or $call != OKL" + + res = ""; + call = test(b = {res += "K"; "K"}(), c = {res += "L"; "L"}, a = {res+="O"; "O"}()) + if (res != "KOL" || call != "OKL") return "fail 2: $res != KOL or $call != OKL" + + + res = ""; + call = test(c = {res += "L"; "L"}, b = {res += "K"; "K"}(), a = {res+="O"; "O"}()) + if (res != "KOL" || call != "OKL") return "fail 3: $res != KOL or $call != OKL" + + return "OK" + +} + +fun test(a: String, b: String, c: () -> String): String { + return a + b + c(); +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/argumentOrder/simpleInClass.kt b/compiler/testData/codegen/box/argumentOrder/simpleInClass.kt new file mode 100644 index 00000000000..71bc1f7452c --- /dev/null +++ b/compiler/testData/codegen/box/argumentOrder/simpleInClass.kt @@ -0,0 +1,23 @@ +fun box(): String { + var res = ""; + var call = Z("Z").test(b = {res += "K"; "K"}(), a = {res+="O"; "O"}(), c = {res += "L"; "L"}) + if (res != "KOL" || call != "OKLZ") return "fail 1: $res != KOL or $call != OKLZ" + + res = ""; + call = Z("Z").test(b = {res += "K"; "K"}(), c = {res += "L"; "L"}, a = {res+="O"; "O"}()) + if (res != "KOL" || call != "OKLZ") return "fail 2: $res != KOL or $call != OKLZ" + + + res = ""; + call = Z("Z").test(c = {res += "L"; "L"}, b = {res += "K"; "K"}(), a = {res+="O"; "O"}()) + if (res != "KOL" || call != "OKLZ") return "fail 3: $res != KOL or $call != OKLZ" + + return "OK" + +} + +class Z(val p: String) { + fun test(a: String, b: String, c: () -> String): String { + return a + b + c() + p; + } +} \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeText/argumentOrder/argumentReorder.kt b/compiler/testData/codegen/bytecodeText/argumentOrder/argumentReorder.kt new file mode 100644 index 00000000000..ad7cc0278c7 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/argumentOrder/argumentReorder.kt @@ -0,0 +1,11 @@ +class A { + fun test(x: String?, a: String?, b: String?){} + + fun box(): String { + test(x = "x", b = "K", a = "O") + return "OK" + } +} +// Test argument reordering when call site argument order differs from declaration one +// 4 LOAD +// 2 STORE \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeText/argumentOrder/argumentReorderWithDefault.kt b/compiler/testData/codegen/bytecodeText/argumentOrder/argumentReorderWithDefault.kt new file mode 100644 index 00000000000..f372d21eca1 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/argumentOrder/argumentReorderWithDefault.kt @@ -0,0 +1,13 @@ +class A { + fun test(x: String? = "x", a: String?, b: String?, y: String? = "y") { + + } + + fun box(): String { + test(b = "K", a = "O") + return "OK" + } +} +// Test argument reordering when call site argument order differs from declaration one +// 12 LOAD +// 5 STORE \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeText/argumentOrder/sameOrder.kt b/compiler/testData/codegen/bytecodeText/argumentOrder/sameOrder.kt new file mode 100644 index 00000000000..4e3df7fab1a --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/argumentOrder/sameOrder.kt @@ -0,0 +1,12 @@ +class A { + fun test(x: String?, a: String?, b: String?) { + } + + fun box(): String { + test(x = "x", a = "O", b = "K") + return "OK" + } +} +// Test there is no argument reordering when call site argument order same as declaration one +// 2 LOAD +// 0 STORE \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeText/argumentOrder/sameOrderWithDefault.kt b/compiler/testData/codegen/bytecodeText/argumentOrder/sameOrderWithDefault.kt new file mode 100644 index 00000000000..9eb56ffefa0 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/argumentOrder/sameOrderWithDefault.kt @@ -0,0 +1,12 @@ +class A { + fun test(x: String? = "x", a: String?, b: String?, y: String? = "y") { + } + + fun box(): String { + test(a = "O", b = "K") + return "OK" + } +} +// Test there is no argument reordering when call site argument order same as declaration one +// 9 LOAD +// 2 STORE \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java index 563d45b9888..68f30251f26 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java @@ -251,6 +251,39 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { doTest(fileName); } + @TestMetadata("compiler/testData/codegen/bytecodeText/argumentOrder") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ArgumentOrder extends AbstractBytecodeTextTest { + public void testAllFilesPresentInArgumentOrder() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/bytecodeText/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("argumentReorder.kt") + public void testArgumentReorder() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeText/argumentOrder/argumentReorder.kt"); + doTest(fileName); + } + + @TestMetadata("argumentReorderWithDefault.kt") + public void testArgumentReorderWithDefault() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeText/argumentOrder/argumentReorderWithDefault.kt"); + doTest(fileName); + } + + @TestMetadata("sameOrder.kt") + public void testSameOrder() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeText/argumentOrder/sameOrder.kt"); + doTest(fileName); + } + + @TestMetadata("sameOrderWithDefault.kt") + public void testSameOrderWithDefault() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeText/argumentOrder/sameOrderWithDefault.kt"); + doTest(fileName); + } + } + @TestMetadata("compiler/testData/codegen/bytecodeText/boxingOptimization") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java index b2ec8e8ae70..8fbd1b77683 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java @@ -48,6 +48,60 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/argumentOrder/arguments.kt"); doTest(fileName); } + + @TestMetadata("captured.kt") + public void testCaptured() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/argumentOrder/captured.kt"); + doTest(fileName); + } + + @TestMetadata("capturedInExtension.kt") + public void testCapturedInExtension() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/argumentOrder/capturedInExtension.kt"); + doTest(fileName); + } + + @TestMetadata("defaults.kt") + public void testDefaults() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/argumentOrder/defaults.kt"); + doTest(fileName); + } + + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/argumentOrder/extension.kt"); + doTest(fileName); + } + + @TestMetadata("extensionInClass.kt") + public void testExtensionInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/argumentOrder/extensionInClass.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaMigration.kt") + public void testLambdaMigration() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/argumentOrder/lambdaMigration.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaMigrationInClass.kt") + public void testLambdaMigrationInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/argumentOrder/lambdaMigrationInClass.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/argumentOrder/simple.kt"); + doTest(fileName); + } + + @TestMetadata("simpleInClass.kt") + public void testSimpleInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/argumentOrder/simpleInClass.kt"); + doTest(fileName); + } } @TestMetadata("compiler/testData/codegen/box/arrays")