From ff676c050fbbdb1d37f592ab9a778ea94cd0d652 Mon Sep 17 00:00:00 2001 From: Mikhael Bogdanov Date: Wed, 26 Jul 2017 13:32:46 +0200 Subject: [PATCH] Properly generate inner classes when compiling source for inline KT-19175: Compiler generates different bytecode when classes are compiled separately or together #KT-19175 Fixed --- .../kotlin/codegen/ClassBodyCodegen.java | 2 +- .../kotlin/codegen/InnerClassConsumer.kt | 28 +++++++ .../codegen/InterfaceImplBodyCodegen.kt | 9 +-- .../kotlin/codegen/MemberCodegen.java | 21 +++-- .../kotlin/codegen/inline/InlineCodegen.kt | 4 +- .../kotlin/codegen/inline/LambdaInfo.kt | 4 +- .../codegen/inline/SourceCompilerForInline.kt | 41 ++++++++-- .../codegen/inline/inlineCodegenUtils.kt | 7 +- .../boxInline/smap/anonymous/kt19175.kt | 79 +++++++++++++++++++ .../writeFlags/inline/lostInnerClass.kt | 14 ++++ .../writeFlags/inline/lostInnerClass2.kt | 20 +++++ .../writeFlags/inline/lostInnerClass3.kt | 20 +++++ .../codegen/flags/AbstractWriteFlagsTest.java | 2 +- .../IrBlackBoxInlineCodegenTestGenerated.java | 6 ++ ...otlinAgainstInlineKotlinTestGenerated.java | 6 ++ .../BlackBoxInlineCodegenTestGenerated.java | 6 ++ ...otlinAgainstInlineKotlinTestGenerated.java | 6 ++ .../flags/WriteFlagsTestGenerated.java | 27 +++++++ ...perimentalIncrementalJpsTestGenerated.java | 6 ++ .../Introspector.kt | 10 +++ .../IntrospectorImpl.kt.new | 12 +++ .../Model.java | 4 + .../ModelModifier.java | 3 + .../build.log | 7 ++ 24 files changed, 312 insertions(+), 32 deletions(-) create mode 100644 compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt create mode 100644 compiler/testData/writeFlags/inline/lostInnerClass.kt create mode 100644 compiler/testData/writeFlags/inline/lostInnerClass2.kt create mode 100644 compiler/testData/writeFlags/inline/lostInnerClass3.kt create mode 100644 jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/Introspector.kt create mode 100644 jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/IntrospectorImpl.kt.new create mode 100644 jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/Model.java create mode 100644 jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/ModelModifier.java create mode 100644 jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/build.log diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java index ae68ab5a051..6bc205e7852 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java @@ -192,6 +192,6 @@ public abstract class ClassBodyCodegen extends MemberCodegen codegen = this; codegen != null; codegen = codegen.getParentCodegen()) { - ClassDescriptor outerClass = codegen.classForInnerClassRecord(); - if (outerClass != null) { - innerClasses.add(outerClass); - } - } + addParentsToInnerClassesIfNeeded(innerClasses); } for (ClassDescriptor innerClass : innerClasses) { @@ -357,6 +350,18 @@ public abstract class MemberCodegen innerClasses) { + ClassDescriptor outerClass = classForInnerClassRecord(); + if (outerClass != null) { + innerClasses.add(outerClass); + } + + MemberCodegen parentCodegen = getParentCodegen(); + if (parentCodegen != null) { + parentCodegen.addParentsToInnerClassesIfNeeded(innerClasses); + } + } + // It's necessary for proper recovering of classId by plain string JVM descriptor when loading annotations // See FileBasedKotlinClass.convertAnnotationVisitor @Override diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt index f54bbd90b15..853c993797e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt @@ -460,7 +460,7 @@ abstract class InlineCodegen( if (isBuiltInArrayIntrinsic(callableDescriptor)) { val classId = classId val bytes = state.inlineCache.classBytes.getOrPut(classId) { bytecode } - return getMethodNode(bytes, asmMethod.name, asmMethod.descriptor, classId.asString()) + return getMethodNode(bytes, asmMethod.name, asmMethod.descriptor, AsmUtil.asmTypeByClassId(classId)) } assert(callableDescriptor is DeserializedCallableMemberDescriptor) { "Not a deserialized function or proper: " + callableDescriptor } @@ -474,7 +474,7 @@ abstract class InlineCodegen( throw IllegalStateException("Couldn't find declaration file for " + containerId) } - val methodNode = getMethodNode(bytes, asmMethod.name, asmMethod.descriptor, containerId.asString()) ?: return null + val methodNode = getMethodNode(bytes, asmMethod.name, asmMethod.descriptor, AsmUtil.asmTypeByClassId(containerId)) ?: return null // KLUDGE: Inline suspend function built with compiler version less than 1.1.4/1.2-M1 did not contain proper // before/after suspension point marks, so we detect those functions here and insert the corresponding marks diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.kt index df03e072e84..0995b1a3d38 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.kt @@ -135,7 +135,7 @@ class DefaultLambda( classReader.b, "", descriptor, - lambdaClassType.internalName)?.node + lambdaClassType)?.node assert(constructor != null || capturedArgs.isEmpty()) { "Can't find non-default constructor $descriptor for default lambda $lambdaClassType" @@ -164,7 +164,7 @@ class DefaultLambda( classReader.b, invokeMethod.name, invokeMethod.descriptor, - lambdaClassType.internalName)!! + lambdaClassType)!! if (needReification) { //nested classes could also require reification diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt index 12ad453be6d..5c199791971 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature +import org.jetbrains.kotlin.utils.addIfNotNull import org.jetbrains.org.objectweb.asm.Label import org.jetbrains.org.objectweb.asm.MethodVisitor import org.jetbrains.org.objectweb.asm.Opcodes @@ -94,6 +95,8 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid private var context by Delegates.notNull>() + private var additionalInnerClasses = mutableListOf() + override val lookupLocation = KotlinLookupLocation(callElement) @@ -164,7 +167,9 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid if (isLambda) codegen.parentCodegen.className else - state.typeMapper.mapImplementationOwner(descriptor).internalName + state.typeMapper.mapImplementationOwner(descriptor).internalName, + if (isLambda) emptyList() else additionalInnerClasses, + isLambda ) val strategy = when (expression) { @@ -222,7 +227,9 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid internal val delegate: MemberCodegen<*>, declaration: KtElement, codegenContext: FieldOwnerContext<*>, - private val className: String + private val className: String, + private val parentAsInnerClasses: List, + private val isInlineLambdaCodegen: Boolean ) : MemberCodegen(delegate as MemberCodegen, declaration, codegenContext) { override fun generateDeclaration() { @@ -246,6 +253,14 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid return className } + override fun addParentsToInnerClassesIfNeeded(innerClasses: MutableCollection) { + if (isInlineLambdaCodegen) { + super.addParentsToInnerClassesIfNeeded(innerClasses) + } + else { + innerClasses.addAll(parentAsInnerClasses) + } + } } override fun doCreateMethodNodeFromSource( @@ -278,7 +293,9 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid val implementationOwner = state.typeMapper.mapImplementationOwner(callableDescriptor) val parentCodegen = FakeMemberCodegen( codegen.parentCodegen, inliningFunction!!, methodContext.parentContext as FieldOwnerContext<*>, - implementationOwner.internalName + implementationOwner.internalName, + additionalInnerClasses, + false ) if (element !is KtNamedFunction) { throw IllegalStateException("Property accessors with default parameters not supported " + callableDescriptor) @@ -389,22 +406,25 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid } override fun initializeInlineFunctionContext(functionDescriptor: FunctionDescriptor) { - context = getContext(functionDescriptor, state, DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor)?.containingFile as? KtFile) + context = getContext(functionDescriptor, functionDescriptor, state, DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor)?.containingFile as? KtFile, additionalInnerClasses) } companion object { fun getContext( - descriptor: DeclarationDescriptor, state: GenerationState, sourceFile: KtFile? + descriptor: DeclarationDescriptor, innerDescriptor: DeclarationDescriptor, state: GenerationState, sourceFile: KtFile?, additionalInners: MutableList ): CodegenContext<*> { if (descriptor is PackageFragmentDescriptor) { + //no inners return PackageContext(descriptor, state.rootContext, null, sourceFile) } val container = descriptor.containingDeclaration ?: error("No container for descriptor: " + descriptor) val parent = getContext( container, + descriptor, state, - sourceFile + sourceFile, + additionalInners ) return when (descriptor) { @@ -417,7 +437,14 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid ) } is ClassDescriptor -> { - val kind = if (DescriptorUtils.isInterface(descriptor)) OwnerKind.DEFAULT_IMPLS else OwnerKind.IMPLEMENTATION + val kind = + if (DescriptorUtils.isInterface(descriptor) && innerDescriptor !is ClassDescriptor) + OwnerKind.DEFAULT_IMPLS + else OwnerKind.IMPLEMENTATION + + additionalInners.addIfNotNull( + InnerClassConsumer.classForInnerClassRecord(descriptor, kind == OwnerKind.DEFAULT_IMPLS) + ) parent.intoClass(descriptor, kind, state) } is FunctionDescriptor -> { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineCodegenUtils.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineCodegenUtils.kt index 6e9e3664973..c343e1bc414 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineCodegenUtils.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineCodegenUtils.kt @@ -89,12 +89,13 @@ private const val INLINE_MARKER_FINALLY_START = "finallyStart" private const val INLINE_MARKER_FINALLY_END = "finallyEnd" private const val INLINE_MARKER_BEFORE_SUSPEND_ID = 0 private const val INLINE_MARKER_AFTER_SUSPEND_ID = 1 +private val INTRINSIC_ARRAY_CONSTRUCTOR_TYPE = AsmUtil.asmTypeByClassId(classId) internal fun getMethodNode( classData: ByteArray, methodName: String, methodDescriptor: String, - classInternalName: String + classType: Type ): SMAPAndMethodNode? { val cr = ClassReader(classData) var node: MethodNode? = null @@ -136,12 +137,12 @@ internal fun getMethodNode( return null } - if (classId.asString() == classInternalName) { + if (INTRINSIC_ARRAY_CONSTRUCTOR_TYPE == classType) { // Don't load source map for intrinsic array constructors debugInfo[0] = null } - val smap = SMAPParser.parseOrCreateDefault(debugInfo[1], debugInfo[0], classInternalName, lines[0], lines[1]) + val smap = SMAPParser.parseOrCreateDefault(debugInfo[1], debugInfo[0], classType.internalName, lines[0], lines[1]) return SMAPAndMethodNode(node!!, smap) } diff --git a/compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt b/compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt new file mode 100644 index 00000000000..2622e875a44 --- /dev/null +++ b/compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt @@ -0,0 +1,79 @@ +// FILE: 1.kt +package test + +abstract class Introspector { + abstract inner class SchemaRetriever(val transaction: String) { + inline fun inSchema(crossinline modifier: (String) -> Unit) = + { modifier.invoke(transaction) }() + } +} + +// FILE: 2.kt +import test.* + +var result = "fail" + +class IntrospectorImpl() : Introspector() { + inner class SchemaRetriever(transaction: String) : Introspector.SchemaRetriever(transaction) { + internal fun retrieve() { + inSchema { schema -> result = schema } + } + } +} + +fun box(): String { + IntrospectorImpl().SchemaRetriever("OK").retrieve() + + return result +} + + +// FILE: 1.smap + +SMAP +1.kt +Kotlin +*S Kotlin +*F ++ 1 1.kt +test/Introspector$SchemaRetriever$inSchema$1 +*L +1#1,11:1 +*E + +// FILE: 2.smap + +SMAP +2.kt +Kotlin +*S Kotlin +*F ++ 1 2.kt +IntrospectorImpl$SchemaRetriever ++ 2 1.kt +test/Introspector$SchemaRetriever +*L +1#1,21:1 +7#2:22 +*E +*S KotlinDebug +*F ++ 1 2.kt +IntrospectorImpl$SchemaRetriever +*L +9#1:22 +*E + +SMAP +1.kt +Kotlin +*S Kotlin +*F ++ 1 1.kt +test/Introspector$SchemaRetriever$inSchema$1 ++ 2 2.kt +IntrospectorImpl$SchemaRetriever +*L +1#1,11:1 +9#2:12 +*E \ No newline at end of file diff --git a/compiler/testData/writeFlags/inline/lostInnerClass.kt b/compiler/testData/writeFlags/inline/lostInnerClass.kt new file mode 100644 index 00000000000..addf27a7ef3 --- /dev/null +++ b/compiler/testData/writeFlags/inline/lostInnerClass.kt @@ -0,0 +1,14 @@ +class Introspector { + inner class SchemaRetriever(val transaction: String) { + inline fun inSchema(crossinline modifier: (String) -> Unit) = + { modifier(transaction) }() + + internal fun retrieve() { + inSchema { schema -> "OK" } + } + } +} + +// TESTED_OBJECT_KIND: innerClass +// TESTED_OBJECTS: Introspector$SchemaRetriever$inSchema$1, SchemaRetriever +// FLAGS: ACC_FINAL, ACC_PUBLIC \ No newline at end of file diff --git a/compiler/testData/writeFlags/inline/lostInnerClass2.kt b/compiler/testData/writeFlags/inline/lostInnerClass2.kt new file mode 100644 index 00000000000..886ad9e7fd4 --- /dev/null +++ b/compiler/testData/writeFlags/inline/lostInnerClass2.kt @@ -0,0 +1,20 @@ +interface Introspector { + + class SchemaRetriever(val transaction: String) { + inline fun inSchema(crossinline modifier: (String) -> Unit) = + { modifier(transaction) }() + + internal fun retrieve() { + inSchema { schema -> "OK" } + } + } + +} + +// TESTED_OBJECT_KIND: innerClass +// TESTED_OBJECTS: Introspector$SchemaRetriever$inSchema$1, SchemaRetriever +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_STATIC + +// TESTED_OBJECT_KIND: innerClass +// TESTED_OBJECTS: Introspector$SchemaRetriever$inSchema$1, DefaultImpls +// ABSENT: true \ No newline at end of file diff --git a/compiler/testData/writeFlags/inline/lostInnerClass3.kt b/compiler/testData/writeFlags/inline/lostInnerClass3.kt new file mode 100644 index 00000000000..d3909a59c2d --- /dev/null +++ b/compiler/testData/writeFlags/inline/lostInnerClass3.kt @@ -0,0 +1,20 @@ +interface Introspector { + fun test() { + class SchemaRetriever(val transaction: String) { + inline fun inSchema(crossinline modifier: (String) -> Unit) = + { modifier(transaction) }() + + internal fun retrieve() { + inSchema { schema -> "OK" } + } + } + } +} + +// TESTED_OBJECT_KIND: innerClass +// TESTED_OBJECTS: Introspector$test$SchemaRetriever, SchemaRetriever +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_STATIC + +// TESTED_OBJECT_KIND: innerClass +// TESTED_OBJECTS: Introspector$test$SchemaRetriever, DefaultImpls +// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_STATIC \ No newline at end of file diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java index 70bf74a43e4..30c23f13606 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java +++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java @@ -261,7 +261,7 @@ public abstract class AbstractWriteFlagsTest extends CodegenTestCase { @Override public void visitInnerClass(@NotNull String innerClassInternalName, String outerClassInternalName, String name, int access) { - if (name.equals(innerClassName)) { + if (innerClassName.equals(name)) { this.access = access; isExists = true; } diff --git a/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java b/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java index 819946d8385..f3042a2ba2a 100644 --- a/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java +++ b/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java @@ -2755,6 +2755,12 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } + @TestMetadata("kt19175.kt") + public void testKt19175() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt"); + doTest(fileName); + } + @TestMetadata("lambda.kt") public void testLambda() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/smap/anonymous/lambda.kt"); diff --git a/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java b/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java index 330636a05b3..c16a2266a2d 100644 --- a/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java +++ b/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java @@ -2755,6 +2755,12 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } + @TestMetadata("kt19175.kt") + public void testKt19175() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt"); + doTest(fileName); + } + @TestMetadata("lambda.kt") public void testLambda() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/smap/anonymous/lambda.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java index 2285c508c9f..f04ef4b57d0 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java @@ -2755,6 +2755,12 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } + @TestMetadata("kt19175.kt") + public void testKt19175() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt"); + doTest(fileName); + } + @TestMetadata("lambda.kt") public void testLambda() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/smap/anonymous/lambda.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java index 2f945c929af..d3b88ed88a7 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java @@ -2755,6 +2755,12 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } + @TestMetadata("kt19175.kt") + public void testKt19175() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt"); + doTest(fileName); + } + @TestMetadata("lambda.kt") public void testLambda() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/smap/anonymous/lambda.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java index 55d9fcb7af0..d594273b59c 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java @@ -609,6 +609,33 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } } + @TestMetadata("compiler/testData/writeFlags/inline") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inline extends AbstractWriteFlagsTest { + public void testAllFilesPresentInInline() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/inline"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("lostInnerClass.kt") + public void testLostInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeFlags/inline/lostInnerClass.kt"); + doTest(fileName); + } + + @TestMetadata("lostInnerClass2.kt") + public void testLostInnerClass2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeFlags/inline/lostInnerClass2.kt"); + doTest(fileName); + } + + @TestMetadata("lostInnerClass3.kt") + public void testLostInnerClass3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeFlags/inline/lostInnerClass3.kt"); + doTest(fileName); + } + } + @TestMetadata("compiler/testData/writeFlags/innerClass") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/ExperimentalIncrementalJpsTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/ExperimentalIncrementalJpsTestGenerated.java index f349f6d69bc..748c87e713a 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/ExperimentalIncrementalJpsTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/ExperimentalIncrementalJpsTestGenerated.java @@ -1466,6 +1466,12 @@ public class ExperimentalIncrementalJpsTestGenerated extends AbstractExperimenta doTest(fileName); } + @TestMetadata("innerClassNotGeneratedWhenRebuilding") + public void testInnerClassNotGeneratedWhenRebuilding() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/"); + doTest(fileName); + } + @TestMetadata("jvmNameChanged") public void testJvmNameChanged() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/classHierarchyAffected/jvmNameChanged/"); diff --git a/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/Introspector.kt b/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/Introspector.kt new file mode 100644 index 00000000000..c46629ef944 --- /dev/null +++ b/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/Introspector.kt @@ -0,0 +1,10 @@ +abstract class Introspector(protected val model: Model) { + protected abstract inner class Retriever(protected val transaction: Any) { + protected var model: Model = this@Introspector.model + } + + protected abstract inner class SchemaRetriever(transaction: Any): Retriever(transaction) { + protected inline fun inSchema(crossinline modifier: (Any) -> Unit) = + model.modify { schema -> modifier.invoke(schema) } + } +} diff --git a/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/IntrospectorImpl.kt.new b/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/IntrospectorImpl.kt.new new file mode 100644 index 00000000000..75ae9d6cf2d --- /dev/null +++ b/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/IntrospectorImpl.kt.new @@ -0,0 +1,12 @@ +class IntrospectorImpl(model: ModuleImpl) : Introspector(model) { + private inner class SchemaRetriever(transaction: Any) : Introspector.SchemaRetriever(transaction) { + internal fun retrieve() { + inSchema { schema -> println(schema) } + } + } +} + +class ModuleImpl : Model { + override fun modify(modifier: ModelModifier) {} +} + diff --git a/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/Model.java b/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/Model.java new file mode 100644 index 00000000000..82f6d6476f6 --- /dev/null +++ b/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/Model.java @@ -0,0 +1,4 @@ +public interface Model { + void modify(ModelModifier modifier); +} + diff --git a/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/ModelModifier.java b/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/ModelModifier.java new file mode 100644 index 00000000000..fb19636744f --- /dev/null +++ b/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/ModelModifier.java @@ -0,0 +1,3 @@ +public interface ModelModifier { + void perform(Object element); +} diff --git a/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/build.log b/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/build.log new file mode 100644 index 00000000000..632a8a2344b --- /dev/null +++ b/jps-plugin/testData/incremental/classHierarchyAffected/innerClassNotGeneratedWhenRebuilding/build.log @@ -0,0 +1,7 @@ +================ Step #1 ================= + +Compiling files: + src/IntrospectorImpl.kt +End of files +Exit code: OK +------------------------------------------ \ No newline at end of file