Fix for KT-13133: Incorrect InnerClasses attribute value for anonymous object copied from an inline function

#KT-13133 Fixed

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java

@@ -222,7 +222,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
         MethodInliner inliner = new MethodInliner(
                 sourceNode,
                 parameters,
-                inliningContext.subInline(inliningContext.nameGenerator.subGenerator("lambda")),
+                inliningContext.subInline(transformationInfo.getNameGenerator()),
                 remapper,
                 isSameModule,
                 "Transformer for " + transformationInfo.getOldClassName(),

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/NameGenerator.java

@@ -16,36 +16,52 @@
 
 package org.jetbrains.kotlin.codegen.inline;
 
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
 import java.util.HashMap;
 import java.util.Map;
 
 public class NameGenerator {
 
-    private final String ownerMethod;
+    private final String generatorClass;
 
     private int nextLambdaIndex = 1;
     private int nextWhenIndex = 1;
 
     private final Map<String, NameGenerator> subGenerators = new HashMap<String, NameGenerator>();
 
-    public NameGenerator(String onwerMethod) {
-        this.ownerMethod = onwerMethod;
+    public NameGenerator(String generatorClass) {
+        this.generatorClass = generatorClass;
     }
 
-    public String genLambdaClassName() {
-        return ownerMethod + "$" + nextLambdaIndex++;
+    public String getGeneratorClass() {
+        return generatorClass;
     }
 
-    public String genWhenClassNamePrefix() {
-        return ownerMethod + "$" + nextWhenIndex++;
+    private String genLambdaClassName() {
+        return generatorClass + "$" + nextLambdaIndex++;
+    }
+
+    private String genWhenClassName(@NotNull String original) {
+        return generatorClass + "$" + nextWhenIndex++ + WhenMappingTransformationInfo.TRANSFORMED_WHEN_MAPPING_MARKER + original;
     }
 
     public NameGenerator subGenerator(String inliningMethod) {
         NameGenerator generator = subGenerators.get(inliningMethod);
         if (generator == null) {
-            generator = new NameGenerator(ownerMethod+ "$" + inliningMethod);
+            generator = new NameGenerator(generatorClass + "$" + inliningMethod);
             subGenerators.put(inliningMethod, generator);
         }
         return generator;
     }
+
+    @NotNull
+    public NameGenerator subGenerator(boolean lambdaNoWhen, @Nullable String nameSuffix) {
+        String generatorClass = lambdaNoWhen ? genLambdaClassName() : genWhenClassName(nameSuffix);
+        assert !subGenerators.containsKey(generatorClass) : "Name generator for regenerated class should be unique: " + generatorClass;
+        NameGenerator generator = new NameGenerator(generatorClass);
+        subGenerators.put(generatorClass, generator);
+        return generator;
+    }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TransformationInfo.kt

@@ -22,6 +22,9 @@ interface TransformationInfo {
     val oldClassName: String
 
     val newClassName: String
+        get() = nameGenerator.generatorClass
+
+    val nameGenerator: NameGenerator
 
     fun shouldRegenerate(sameModule: Boolean): Boolean
 
@@ -32,13 +35,13 @@ interface TransformationInfo {
 
 class WhenMappingTransformationInfo(
         override val oldClassName: String,
-        val nameGenerator: NameGenerator,
+        parentNameGenerator: NameGenerator,
         val alreadyRegenerated: Boolean,
         val fieldNode: FieldInsnNode
 ) : TransformationInfo {
-    override val newClassName by lazy {
-        nameGenerator.genWhenClassNamePrefix() + TRANSFORMED_WHEN_MAPPING_MARKER +
-        oldClassName.substringAfterLast("/").substringAfterLast(TRANSFORMED_WHEN_MAPPING_MARKER)
+
+    override val nameGenerator by lazy {
+        parentNameGenerator.subGenerator(false, oldClassName.substringAfterLast("/").substringAfterLast(TRANSFORMED_WHEN_MAPPING_MARKER))
     }
 
     override fun shouldRegenerate(sameModule: Boolean): Boolean = !alreadyRegenerated && !sameModule
@@ -61,10 +64,11 @@ class AnonymousObjectTransformationInfo internal constructor(
         private val alreadyRegenerated: Boolean,
         val constructorDesc: String?,
         private val isStaticOrigin: Boolean,
-        nameGenerator: NameGenerator
+        parentNameGenerator: NameGenerator
 ) : TransformationInfo {
-    override val newClassName: String by lazy {
-        nameGenerator.genLambdaClassName()
+
+    override val nameGenerator by lazy {
+        parentNameGenerator.subGenerator(true, null)
     }
 
     lateinit var newConstructorDescriptor: String