From fee6d4f282edf9ca4afc21f32515fd10d7548b9e Mon Sep 17 00:00:00 2001 From: Michael Bogdanov Date: Wed, 23 Dec 2015 14:47:05 +0300 Subject: [PATCH] Type parameters mapping #KT-10429 Fixed --- .../kotlin/codegen/ExpressionCodegen.java | 4 +- .../kotlin/codegen/FunctionCodegen.java | 4 +- .../inline/AnonymousObjectTransformer.java | 2 +- .../kotlin/codegen/inline/AsmTypeRemapper.kt | 24 ++--- .../codegen/inline/InliningContext.java | 4 +- .../kotlin/codegen/inline/MethodInliner.java | 2 +- .../codegen/inline/ReifiedTypeInliner.kt | 4 + .../codegen/inline/RootInliningContext.java | 2 +- .../kotlin/codegen/inline/TypeRemapper.kt | 97 ++++++++++--------- .../signature/sameFormalParameterName.1.kt | 19 ++++ .../signature/sameFormalParameterName.2.kt | 19 ++++ .../sameReifiedFormalParameterName.1.kt | 19 ++++ .../sameReifiedFormalParameterName.2.kt | 19 ++++ .../signature/typeParametersSubstitution.1.kt | 26 +++++ .../signature/typeParametersSubstitution.2.kt | 24 +++++ .../typeParametersSubstitution2.1.kt | 25 +++++ .../typeParametersSubstitution2.2.kt | 25 +++++ .../BlackBoxInlineCodegenTestGenerated.java | 33 +++++++ ...otlinAgainstInlineKotlinTestGenerated.java | 33 +++++++ 19 files changed, 312 insertions(+), 73 deletions(-) create mode 100644 compiler/testData/codegen/boxInline/signature/sameFormalParameterName.1.kt create mode 100644 compiler/testData/codegen/boxInline/signature/sameFormalParameterName.2.kt create mode 100644 compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.1.kt create mode 100644 compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.2.kt create mode 100644 compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.1.kt create mode 100644 compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.2.kt create mode 100644 compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.1.kt create mode 100644 compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.2.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index e87dfa99392..c2273428b63 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -2429,7 +2429,7 @@ public class ExpressionCodegen extends KtVisitor impleme } @NotNull - protected CallGenerator getOrCreateCallGenerator( + private CallGenerator getOrCreateCallGenerator( @NotNull CallableDescriptor descriptor, @Nullable KtElement callElement, @Nullable TypeParameterMappings typeParameterMappings @@ -2448,7 +2448,7 @@ public class ExpressionCodegen extends KtVisitor impleme } @NotNull - public CallGenerator getOrCreateCallGenerator(@NotNull FunctionDescriptor descriptor, @Nullable KtNamedFunction function) { + protected CallGenerator getOrCreateCallGeneratorForDefaultImplBody(@NotNull FunctionDescriptor descriptor, @Nullable KtNamedFunction function) { return getOrCreateCallGenerator(descriptor, function, null); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java index 369bc2715ab..4642b9fe531 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java @@ -21,7 +21,6 @@ import com.intellij.psi.PsiElement; import com.intellij.util.ArrayUtil; import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; -import kotlin.Unit; import kotlin.jvm.functions.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -29,7 +28,6 @@ import org.jetbrains.kotlin.backend.common.bridges.Bridge; import org.jetbrains.kotlin.backend.common.bridges.ImplKt; import org.jetbrains.kotlin.codegen.annotation.AnnotatedWithOnlyTargetedAnnotations; import org.jetbrains.kotlin.codegen.context.*; -import org.jetbrains.kotlin.codegen.intrinsics.TypeIntrinsics; import org.jetbrains.kotlin.codegen.optimization.OptimizationMethodVisitor; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; @@ -699,7 +697,7 @@ public class FunctionCodegen { ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, signature.getReturnType(), methodContext, state, parentCodegen); - CallGenerator generator = codegen.getOrCreateCallGenerator(functionDescriptor, function); + CallGenerator generator = codegen.getOrCreateCallGeneratorForDefaultImplBody(functionDescriptor, function); loadExplicitArgumentsOnStack(OBJECT_TYPE, isStatic, signature, generator); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java index 395dc9597c5..64546d01cf3 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java @@ -347,7 +347,7 @@ public class AnonymousObjectTransformer { return new RemappingClassBuilder( classBuilder, - new AsmTypeRemapper(inliningContext.typeRemapper, inliningContext.getRoot().typeParameterMappings, transformationResult) + new AsmTypeRemapper(inliningContext.typeRemapper, inliningContext.getRoot().typeParameterMappings == null, transformationResult) ); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AsmTypeRemapper.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AsmTypeRemapper.kt index 2b454812a3f..6afda8e0d13 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AsmTypeRemapper.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AsmTypeRemapper.kt @@ -21,24 +21,22 @@ import org.jetbrains.org.objectweb.asm.commons.RemappingSignatureAdapter import org.jetbrains.org.objectweb.asm.signature.SignatureReader import org.jetbrains.org.objectweb.asm.signature.SignatureVisitor -class AsmTypeRemapper(val typeRemapper: TypeRemapper, val mappings: TypeParameterMappings?, val result: InlineResult) : Remapper() { +class AsmTypeRemapper(val typeRemapper: TypeRemapper, val isDefaultGeneration: Boolean, val result: InlineResult) : Remapper() { override fun map(type: String): String { return typeRemapper.map(type) } - override fun createRemappingSignatureAdapter(v: SignatureVisitor?): SignatureVisitor { - if (mappings == null) { - //don't remap default generation + if (isDefaultGeneration) { return super.createRemappingSignatureAdapter(v); } return object : RemappingSignatureAdapter(v, this) { override fun visitTypeVariable(name: String) { - val mapping = getMappingByName(name) ?: - return super.visitTypeVariable(name) + /*TODO try to erase absent type variable*/ + val mapping = typeRemapper.mapTypeParameter(name) ?: return super.visitTypeVariable(name) if (mapping.newName != null) { if (mapping.isReified) { @@ -51,19 +49,9 @@ class AsmTypeRemapper(val typeRemapper: TypeRemapper, val mappings: TypeParamete } override fun visitFormalTypeParameter(name: String) { - val mapping: TypeParameterMapping = getMappingByName(name) ?: - return super.visitFormalTypeParameter(name) - if (mapping.newName != null ) { - if (mapping.isReified) { - result.reifiedTypeParametersUsages.addUsedReifiedParameter(mapping.newName) - } - super.visitFormalTypeParameter(mapping.newName) - } + typeRemapper.registerTypeParameter(name) + super.visitFormalTypeParameter(name) } - - private fun getMappingByName(name: String): TypeParameterMapping? = mappings[name] } } - - } \ No newline at end of file diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java index 5143e43196d..8c28c9bd07a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java @@ -82,7 +82,7 @@ public class InliningContext { @NotNull AnonymousObjectGeneration anonymousObjectGeneration ) { return new RegeneratedClassContext(this, expressionMap, state, generator, - new TypeRemapper(typeRemapper, newTypeMappings), + TypeRemapper.createFrom(typeRemapper, newTypeMappings), reifedTypeInliner, isInliningLambda, anonymousObjectGeneration); } @@ -97,7 +97,7 @@ public class InliningContext { boolean isRegeneration ) { return new InliningContext(this, expressionMap, state, generator, - new TypeRemapper(typeRemapper, additionalTypeMappings), reifedTypeInliner, isInliningLambda, isRegeneration); + TypeRemapper.createFrom(typeRemapper, additionalTypeMappings), reifedTypeInliner, isInliningLambda, isRegeneration); } public boolean isRoot() { 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 c5e137dd082..81b608b6e9f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java @@ -158,7 +158,7 @@ public class MethodInliner { resultNode.access, resultNode.desc, resultNode, - new AsmTypeRemapper(remapper, inliningContext.getRoot().typeParameterMappings, result) + new AsmTypeRemapper(remapper, inliningContext.getRoot().typeParameterMappings == null, result) ); final int markerShift = InlineCodegenUtil.calcMarkerShift(parameters, node); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt index 707170c716b..4fabc7701ca 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt @@ -232,6 +232,10 @@ class TypeParameterMappings() { } fun hasReifiedParameters() = mappingsByName.values.any { it.isReified } + + internal inline fun forEach(l: (TypeParameterMapping) -> Unit) { + mappingsByName.values.forEach(l) + } } class TypeParameterMapping( diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java index 62eccaee7f2..6f6341a56a8 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java @@ -40,7 +40,7 @@ public class RootInliningContext extends InliningContext { @NotNull ReifiedTypeInliner inliner, @Nullable TypeParameterMappings typeParameterMappings ) { - super(null, map, state, nameGenerator, TypeRemapper.createEmpty(), inliner, false, false); + super(null, map, state, nameGenerator, TypeRemapper.createRoot(typeParameterMappings), inliner, false, false); this.callElement = callElement; this.startContext = startContext; this.classNameToInline = classNameToInline; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TypeRemapper.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TypeRemapper.kt index 4a7e0de3005..f4e3b766166 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TypeRemapper.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TypeRemapper.kt @@ -14,69 +14,76 @@ * limitations under the License. */ -package org.jetbrains.kotlin.codegen.inline; +package org.jetbrains.kotlin.codegen.inline -import org.jetbrains.annotations.NotNull; +import java.util.HashMap -import java.util.HashMap; -import java.util.Map; +class TypeParameter(val oldName: String, val newName: String?, val isReified: Boolean, val signature: String?) -public class TypeRemapper { - //typeMapping field could be changed outside through method processing - private final Map typeMapping; +//typeMapping data could be changed outside through method processing +class TypeRemapper private constructor(private val typeMapping: MutableMap, val parent: TypeRemapper?) { - private Map additionalMappings; + private var additionalMappings: MutableMap = hashMapOf() - //typeMapping field could be changed outside through method processing - private TypeRemapper(@NotNull Map typeMapping) { - this.typeMapping = typeMapping; + + private val typeParametersMapping: MutableMap = hashMapOf() + + fun addMapping(type: String, newType: String) { + typeMapping.put(type, newType) } - public TypeRemapper(@NotNull TypeRemapper remapper, @NotNull Map newTypeMappings) { - this(createNewAndMerge(remapper, newTypeMappings)); + fun hasNoAdditionalMapping(type: String): Boolean { + return typeMapping.containsKey(type) } - public static TypeRemapper createEmpty() { - return new TypeRemapper(new HashMap()); + fun map(type: String): String { + return typeMapping[type] ?: additionalMappings?.get(type) ?: type } - public static TypeRemapper createFrom(Map mappings) { - return new TypeRemapper(mappings); + fun addAdditionalMappings(oldName: String, newName: String) { + additionalMappings!!.put(oldName, newName) } - @NotNull - private static Map createNewAndMerge(@NotNull TypeRemapper remapper, @NotNull Map additionalTypeMappings) { - Map map = new HashMap(remapper.typeMapping); - map.putAll(additionalTypeMappings); - return map; - } - - public void addMapping(String type, String newType) { - typeMapping.put(type, newType); - } - - public boolean hasNoAdditionalMapping(String type) { - return typeMapping.containsKey(type); - } - - public String map(String type) { - String newType = typeMapping.get(type); - if (newType != null) { - return newType; + fun registerTypeParameter(name: String) { + assert(typeParametersMapping[name] == null) { + "Type parameter already registered $name" } + typeParametersMapping[name] = TypeParameter(name, name, false, null) + } - if (additionalMappings != null) { - newType = additionalMappings.get(type); - if (newType != null) { - return newType; + fun registerTypeParameter(mapping: TypeParameterMapping) { + typeParametersMapping[mapping.name] = TypeParameter(mapping.name, mapping.newName, mapping.isReified, mapping.signature) + } + + fun mapTypeParameter(name: String): TypeParameter? { + return typeParametersMapping[name] ?: parent?.mapTypeParameter(name) + } + + companion object { + + @JvmStatic + fun createRoot(formalTypeParameters: TypeParameterMappings?): TypeRemapper { + val typeRemapper = TypeRemapper(HashMap(), null) + formalTypeParameters?.forEach { + typeRemapper.registerTypeParameter(it) } + return typeRemapper } - return type; - } + @JvmStatic + fun createFrom(mappings: MutableMap): TypeRemapper { + return TypeRemapper(mappings, null) + } - public void addAdditionalMappings(String oldName, String newName) { - if (additionalMappings == null) additionalMappings = new HashMap(); - additionalMappings.put(oldName, newName); + @JvmStatic + fun createFrom(remapper: TypeRemapper, mappings: MutableMap): TypeRemapper { + return TypeRemapper(createNewAndMerge(remapper, mappings), remapper) + } + + private fun createNewAndMerge(remapper: TypeRemapper, additionalTypeMappings: Map): MutableMap { + val map = HashMap(remapper.typeMapping) + map += additionalTypeMappings + return map + } } } diff --git a/compiler/testData/codegen/boxInline/signature/sameFormalParameterName.1.kt b/compiler/testData/codegen/boxInline/signature/sameFormalParameterName.1.kt new file mode 100644 index 00000000000..69588d01d08 --- /dev/null +++ b/compiler/testData/codegen/boxInline/signature/sameFormalParameterName.1.kt @@ -0,0 +1,19 @@ +// NO_CHECK_LAMBDA_INLINING +// FULL_JDK + +import test.* +import java.util.* + + +fun box(): String { + val result = Test().callInline() + val method = result.javaClass.getMethod("aTest", Any::class.java) + val genericReturnType = method.genericReturnType + if (genericReturnType.toString() != "test.B") return "fail 1: ${genericReturnType}" + + val genericParameterTypes = method.genericParameterTypes + if (genericParameterTypes.size != 1) return "fail 2: ${genericParameterTypes.size}" + if (genericParameterTypes[0].toString() != "T") return "fail 3: ${genericParameterTypes[0]}" + + return "OK" +} diff --git a/compiler/testData/codegen/boxInline/signature/sameFormalParameterName.2.kt b/compiler/testData/codegen/boxInline/signature/sameFormalParameterName.2.kt new file mode 100644 index 00000000000..45b884a5b14 --- /dev/null +++ b/compiler/testData/codegen/boxInline/signature/sameFormalParameterName.2.kt @@ -0,0 +1,19 @@ +package test + +class B + +interface A { + fun aTest(p: T): B +} + +open class Test { + + inline fun test(crossinline z: () -> Int) = object : A { + override fun aTest(p: T): B { + z() + return B() + } + } + + fun callInline() = test { 1 } +} \ No newline at end of file diff --git a/compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.1.kt b/compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.1.kt new file mode 100644 index 00000000000..69588d01d08 --- /dev/null +++ b/compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.1.kt @@ -0,0 +1,19 @@ +// NO_CHECK_LAMBDA_INLINING +// FULL_JDK + +import test.* +import java.util.* + + +fun box(): String { + val result = Test().callInline() + val method = result.javaClass.getMethod("aTest", Any::class.java) + val genericReturnType = method.genericReturnType + if (genericReturnType.toString() != "test.B") return "fail 1: ${genericReturnType}" + + val genericParameterTypes = method.genericParameterTypes + if (genericParameterTypes.size != 1) return "fail 2: ${genericParameterTypes.size}" + if (genericParameterTypes[0].toString() != "T") return "fail 3: ${genericParameterTypes[0]}" + + return "OK" +} diff --git a/compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.2.kt b/compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.2.kt new file mode 100644 index 00000000000..d01b5136065 --- /dev/null +++ b/compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.2.kt @@ -0,0 +1,19 @@ +package test + +class B + +interface A { + fun aTest(p: T): B +} + +open class Test { + + inline fun test(crossinline z: () -> Int) = object : A { + override fun aTest(p: T): B { + z() + return B() + } + } + + fun callInline() = test { 1 } +} \ No newline at end of file diff --git a/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.1.kt b/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.1.kt new file mode 100644 index 00000000000..86edd16b453 --- /dev/null +++ b/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.1.kt @@ -0,0 +1,26 @@ +//NO_CHECK_LAMBDA_INLINING + +import test.* +import java.util.* + +fun box(): String { + + val comparable = CustomerService().comparator() + val method = comparable.javaClass.getMethod("compare", Any::class.java, Any::class.java) + val genericParameterTypes = method.genericParameterTypes + if (genericParameterTypes.size != 2) return "fail 1: ${genericParameterTypes.size}" + if (genericParameterTypes[0].toString() != "T") return "fail 2: ${genericParameterTypes[0]}" + if (genericParameterTypes[1].toString() != "T") return "fail 3: ${genericParameterTypes[1]}" + + + val comparable2 = CustomerService().callInline() + val method2 = comparable2.javaClass.getMethod("compare", Any::class.java, Any::class.java) + val genericParameterTypes2 = method2.genericParameterTypes + if (genericParameterTypes2.size != 2) return "fail 4: ${genericParameterTypes2.size}" + var name = (genericParameterTypes2[0] as Class<*>).name + if (name != "java.lang.String") return "fail 5: ${name}" + name = (genericParameterTypes2[1] as Class<*>).name + if (name != "java.lang.String") return "fail 6: ${name}" + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.2.kt b/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.2.kt new file mode 100644 index 00000000000..27c89623903 --- /dev/null +++ b/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.2.kt @@ -0,0 +1,24 @@ +package test + +import java.util.* + +open class CustomerService { + + fun comparator() = object : Comparator { + override fun compare(o1: T, o2: T): Int { + throw UnsupportedOperationException() + } + } + + inline fun comparator(crossinline z: () -> Int) = object : Comparator { + + override fun compare(o1: T, o2: T): Int { + return z() + } + + } + + fun callInline() = comparator { 1 } + +} + diff --git a/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.1.kt b/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.1.kt new file mode 100644 index 00000000000..892a8220625 --- /dev/null +++ b/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.1.kt @@ -0,0 +1,25 @@ +//NO_CHECK_LAMBDA_INLINING +import test.* + +fun box(): String { + + val comparable = CustomerService().comparator() + val method = comparable.javaClass.getMethod("compare", Any::class.java, Any::class.java) + val genericParameterTypes = method.genericParameterTypes + if (genericParameterTypes.size != 2) return "fail 1: ${genericParameterTypes.size}" + if (genericParameterTypes[0].toString() != "T") return "fail 2: ${genericParameterTypes[0]}" + if (genericParameterTypes[1].toString() != "T") return "fail 3: ${genericParameterTypes[1]}" + + + val comparable2 = CustomerService().callInline() + val method2 = comparable2.javaClass.getMethod("compare", Any::class.java, Any::class.java) + val genericParameterTypes2 = method2.genericParameterTypes + if (genericParameterTypes2.size != 2) return "fail 1: ${genericParameterTypes2.size}" + + var name = (genericParameterTypes2[0] as Class<*>).name + if (name != "java.lang.String") return "fail 5: ${name}" + name = (genericParameterTypes2[1] as Class<*>).name + if (name != "java.lang.String") return "fail 6: ${name}" + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.2.kt b/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.2.kt new file mode 100644 index 00000000000..11eae8769b9 --- /dev/null +++ b/compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.2.kt @@ -0,0 +1,25 @@ +package test + +interface MComparator { + fun compare(o1: T, o2: T): Int +} + +open class CustomerService { + + fun comparator() = object : MComparator { + override fun compare(o1: T, o2: T): Int { + throw UnsupportedOperationException() + } + } + + inline fun comparator(crossinline z: () -> Int) = object : MComparator { + + override fun compare(o1: T, o2: T): Int { + return z() + } + } + + fun callInline() = comparator { 1 } + +} + diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxInlineCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxInlineCodegenTestGenerated.java index ab6c09d11e9..75476e8a128 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxInlineCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxInlineCodegenTestGenerated.java @@ -1382,6 +1382,39 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } } + @TestMetadata("compiler/testData/codegen/boxInline/signature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Signature extends AbstractBlackBoxInlineCodegenTest { + public void testAllFilesPresentInSignature() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.1.kt$"), true); + } + + @TestMetadata("sameFormalParameterName.1.kt") + public void testSameFormalParameterName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/signature/sameFormalParameterName.1.kt"); + doTestMultiFileWithInlineCheck(fileName); + } + + @TestMetadata("sameReifiedFormalParameterName.1.kt") + public void testSameReifiedFormalParameterName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.1.kt"); + doTestMultiFileWithInlineCheck(fileName); + } + + @TestMetadata("typeParametersSubstitution.1.kt") + public void testTypeParametersSubstitution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.1.kt"); + doTestMultiFileWithInlineCheck(fileName); + } + + @TestMetadata("typeParametersSubstitution2.1.kt") + public void testTypeParametersSubstitution2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.1.kt"); + doTestMultiFileWithInlineCheck(fileName); + } + } + @TestMetadata("compiler/testData/codegen/boxInline/simple") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstInlineKotlinTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstInlineKotlinTestGenerated.java index 4757c323ae9..11e1338ef50 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstInlineKotlinTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstInlineKotlinTestGenerated.java @@ -1382,6 +1382,39 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } } + @TestMetadata("compiler/testData/codegen/boxInline/signature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Signature extends AbstractCompileKotlinAgainstInlineKotlinTest { + public void testAllFilesPresentInSignature() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.1.kt$"), true); + } + + @TestMetadata("sameFormalParameterName.1.kt") + public void testSameFormalParameterName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/signature/sameFormalParameterName.1.kt"); + doBoxTestWithInlineCheck(fileName); + } + + @TestMetadata("sameReifiedFormalParameterName.1.kt") + public void testSameReifiedFormalParameterName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.1.kt"); + doBoxTestWithInlineCheck(fileName); + } + + @TestMetadata("typeParametersSubstitution.1.kt") + public void testTypeParametersSubstitution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.1.kt"); + doBoxTestWithInlineCheck(fileName); + } + + @TestMetadata("typeParametersSubstitution2.1.kt") + public void testTypeParametersSubstitution2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.1.kt"); + doBoxTestWithInlineCheck(fileName); + } + } + @TestMetadata("compiler/testData/codegen/boxInline/simple") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)