[KGP] Experimental: support incremental changes in inlined local classes

In scenarios where a local class declaration is inlined, Kotlin IC might
fail to detect the change in inline function, and skip recompiling some
of its call sites.

To fix that, we implement a brute force approach. INSTANCE usages in
inline methods are extracted from the JVM bytecode. Then inline function
"state" hashes are calculated as a multi-hash of function's own hash and
used local classes' hashes.

This behavior is disabled by default, because it is in testing.

Gradle option
kotlin.internal.classpathSnapshot.parseInlinedLocalClasses=true

would enable the new logic.

^KT-62555 Fixed
^KT-75529

Author: mazhukinevgeniy

build-common/src/org/jetbrains/kotlin/incremental/KotlinClassInfo.kt

@@ -106,19 +106,34 @@ class KotlinClassInfo(
     }
 
     companion object {
-
+        /**
+         * Compatibility note: used by JPS plugin
+         *
+         * Note #2: this form of KotlinClassInfo is also used by all IC Runners for populating in-module cache
+         */
         fun createFrom(kotlinClass: LocalFileKotlinClass): KotlinClassInfo {
             return createFrom(kotlinClass.classId, kotlinClass.classHeader, kotlinClass.fileContents)
         }
 
         fun createFrom(classId: ClassId, classHeader: KotlinClassHeader, classContents: ByteArray): KotlinClassInfo {
+            return createFrom(
+                classId,
+                classHeader,
+                extraInfo = ExtraClassInfoGenerator().getExtraInfo(classHeader, classContents),
+            )
+        }
+
+        /**
+         * Allows callers to customize [ExtraInfo] computation.
+         */
+        fun createFrom(classId: ClassId, classHeader: KotlinClassHeader, extraInfo: ExtraInfo): KotlinClassInfo {
             return KotlinClassInfo(
                 classId,
                 classHeader.kind,
                 classHeader.data ?: classHeader.incompatibleData ?: emptyArray(),
                 classHeader.strings ?: emptyArray(),
                 classHeader.multifileClassName,
-                extraInfo = ExtraClassInfoGenerator.getExtraInfo(classHeader, classContents)
+                extraInfo = extraInfo
             )
         }
     }

build-common/src/org/jetbrains/kotlin/incremental/impl/ClassNodeSnapshotter.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.incremental.impl
 
-import org.jetbrains.kotlin.incremental.md5
 import org.jetbrains.org.objectweb.asm.ClassWriter
 import org.jetbrains.org.objectweb.asm.tree.ClassNode
 import org.jetbrains.org.objectweb.asm.tree.FieldNode
@@ -60,6 +59,10 @@ object ClassNodeSnapshotter {
         classNode.methods.sortWith(compareBy({ it.name }, { it.desc }))
     }
 
+    /**
+     * Internally snapshotter uses emptyClass() a lot, so if you want to change its name, you need to update
+     * the tests with golden class snapshots - all abi hashes would shift.
+     */
     private fun emptyClass() = ClassNode().also {
         // A name is required
         it.name = "SomeClass"

build-common/src/org/jetbrains/kotlin/incremental/impl/ExtraClassInfoGenerator.kt

@@ -10,13 +10,7 @@ import org.jetbrains.kotlin.incremental.KotlinClassInfo.ExtraInfo
 import org.jetbrains.kotlin.incremental.impl.ClassNodeSnapshotter.snapshotClassExcludingMembers
 import org.jetbrains.kotlin.incremental.impl.ClassNodeSnapshotter.snapshotMethod
 import org.jetbrains.kotlin.incremental.impl.ClassNodeSnapshotter.sortClassMembers
-import org.jetbrains.kotlin.incremental.storage.DelegateDataExternalizer
-import org.jetbrains.kotlin.incremental.storage.DoubleExternalizer
-import org.jetbrains.kotlin.incremental.storage.FloatExternalizer
-import org.jetbrains.kotlin.incremental.storage.IntExternalizer
-import org.jetbrains.kotlin.incremental.storage.LongExternalizer
-import org.jetbrains.kotlin.incremental.storage.StringExternalizer
-import org.jetbrains.kotlin.incremental.storage.toByteArray
+import org.jetbrains.kotlin.incremental.storage.*
 import org.jetbrains.kotlin.inline.InlineFunctionOrAccessor
 import org.jetbrains.kotlin.inline.inlineFunctionsAndAccessors
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
@@ -25,7 +19,16 @@ import org.jetbrains.org.objectweb.asm.ClassReader
 import org.jetbrains.org.objectweb.asm.ClassVisitor
 import org.jetbrains.org.objectweb.asm.tree.ClassNode
 
-internal object ExtraClassInfoGenerator {
+
+open class ExtraClassInfoGenerator() {
+    protected open fun makeClassVisitor(classNode: ClassNode): ClassVisitor {
+        return classNode
+    }
+
+    protected open fun calculateInlineMethodHash(methodSignature: JvmMemberSignature.Method, ownMethodHash: Long): Long {
+        return ownMethodHash
+    }
+
     fun getExtraInfo(classHeader: KotlinClassHeader, classContents: ByteArray): ExtraInfo {
         val inlineFunctionsAndAccessors: Map<JvmMemberSignature.Method, InlineFunctionOrAccessor> =
             inlineFunctionsAndAccessors(classHeader, excludePrivateMembers = true).associateBy { it.jvmMethodSignature }
@@ -41,7 +44,7 @@ internal object ExtraClassInfoGenerator {
         //        + Do not filter out method bodies
         val classReader = ClassReader(classContents)
         val selectiveClassVisitor = SelectiveClassVisitor(
-            classNode,
+            cv = makeClassVisitor(classNode),
             shouldVisitField = { _: JvmMemberSignature.Field, isPrivate: Boolean, isConstant: Boolean ->
                 !isPrivate && isConstant
             },
@@ -86,7 +89,8 @@ internal object ExtraClassInfoGenerator {
             //     class metadata (also in the source file), but not in the bytecode. However, we can safely ignore those
             //     inline functions/accessors because they are not declared in the bytecode and therefore can't be referenced.
             val methodSignature = JvmMemberSignature.Method(name = methodNode.name, desc = methodNode.desc)
-            inlineFunctionsAndAccessors[methodSignature]!! to snapshotMethod(methodNode, classNode.version)
+            var methodHash = snapshotMethod(methodNode, classNode.version)
+            inlineFunctionsAndAccessors[methodSignature]!! to calculateInlineMethodHash(methodSignature, methodHash)
         }
 
         return ExtraInfo(classSnapshotExcludingMembers, constantSnapshots, inlineFunctionOrAccessorSnapshots)

build-common/src/org/jetbrains/kotlin/incremental/impl/InstanceOwnerRecordingClassVisitor.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2010-2025 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.incremental.impl
+
+import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMemberSignature
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName
+import org.jetbrains.org.objectweb.asm.ClassVisitor
+import org.jetbrains.org.objectweb.asm.MethodVisitor
+import org.jetbrains.org.objectweb.asm.Opcodes
+
+/**
+ * Used to detect the usage of lambdas in bytecode
+ *
+ * It doesn't look perfectly universal, but it passes tests
+ */
+class InstanceOwnerRecordingClassVisitor(
+    delegateClassVisitor: ClassVisitor?,
+    private val methodToUsedClassesMap: MutableMap<JvmMemberSignature.Method, MutableSet<JvmClassName>>? = null,
+    private val allUsedClassesSet: MutableSet<JvmClassName>? = null,
+) : ClassVisitor(Opcodes.ASM9, delegateClassVisitor) {
+    override fun visitMethod(
+        access: Int,
+        name: String?,
+        descriptor: String?,
+        signature: String?,
+        exceptions: Array<out String?>?
+    ): MethodVisitor? {
+        val methodSignature = name?.let { descriptor?.let { JvmMemberSignature.Method(name, descriptor) } } ?: return null
+
+        return object : MethodVisitor(Opcodes.ASM9, super.visitMethod(access, name, descriptor, signature, exceptions)) {
+            override fun visitFieldInsn(opcode: Int, owner: String?, name: String?, descriptor: String?) {
+                if (owner != null && opcode == Opcodes.GETSTATIC && name == "INSTANCE") {
+                    val jvmClassName = JvmClassName.byInternalName(owner)
+                    methodToUsedClassesMap?.getOrPut(methodSignature) { mutableSetOf() }?.add(jvmClassName)
+                    allUsedClassesSet?.add(jvmClassName)
+                }
+                super.visitFieldInsn(opcode, owner, name, descriptor)
+            }
+        }
+    }
+}

compiler/build-tools/kotlin-build-tools-api-tests/src/main/kotlin/compilation/model/JvmModule.kt

@@ -75,7 +75,7 @@ class JvmModule(
         val snapshot = BaseTest.compilationService.calculateClasspathSnapshot(
             dependency.location.toFile(),
             snapshotConfig.granularity,
-            //snapshotConfig.useInlineLambdaSnapshotting, //TODO(KT-62555)
+            snapshotConfig.useInlineLambdaSnapshotting,
         )
         val hash = snapshot.classSnapshots.values
             .filterIsInstance<AccessibleClassSnapshot>()

compiler/build-tools/kotlin-build-tools-api-tests/src/main/kotlin/compilation/model/SnapshotConfig.kt

@@ -12,5 +12,5 @@ import org.jetbrains.kotlin.buildtools.api.jvm.ClassSnapshotGranularity
  */
 data class SnapshotConfig(
     val granularity: ClassSnapshotGranularity,
-    val useInlineLambdaSnapshotting: Boolean, // TODO(KT-62555) - now has no effect
+    val useInlineLambdaSnapshotting: Boolean,
 )

compiler/build-tools/kotlin-build-tools-api-tests/src/testCrossModuleIncrementalChanges/kotlin/AnonymousInheritorTest.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2025 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.buildtools.api.tests.compilation
+
+import org.jetbrains.kotlin.buildtools.api.CompilerExecutionStrategyConfiguration
+import org.jetbrains.kotlin.buildtools.api.jvm.ClassSnapshotGranularity
+import org.jetbrains.kotlin.buildtools.api.tests.compilation.model.DefaultStrategyAgnosticCompilationTest
+import org.jetbrains.kotlin.buildtools.api.tests.compilation.model.SnapshotConfig
+import org.jetbrains.kotlin.buildtools.api.tests.compilation.scenario.scenario
+import org.jetbrains.kotlin.buildtools.api.tests.compilation.util.compile
+import org.jetbrains.kotlin.buildtools.api.tests.compilation.util.execute
+import org.jetbrains.kotlin.test.TestMetadata
+import org.junit.jupiter.api.DisplayName
+
+/**
+ * Test scenarios where type dependency is obscured by an intermediate anonymous type
+ */
+class AnonymousInheritorTest : BaseCompilationTest() {
+
+    @DefaultStrategyAgnosticCompilationTest
+    @DisplayName("Recompilation of call site affected by an anonymous object - no-inline version")
+    @TestMetadata("ic-scenarios/inline-local-class/inline-anonymous-object-evil/lib")
+    fun testAnonymousObjectBaseTypeChangeWithOverloads(strategyConfig: CompilerExecutionStrategyConfiguration) {
+        scenario(strategyConfig) {
+            val lib = module("ic-scenarios/inline-local-class/inline-anonymous-object-evil/lib")
+            val app = module(
+                "ic-scenarios/inline-local-class/inline-anonymous-object-evil/app",
+                dependencies = listOf(lib),
+                snapshotConfig = SnapshotConfig(ClassSnapshotGranularity.CLASS_MEMBER_LEVEL, true),
+            )
+
+            lib.changeFile("callable.kt") { it.replace("inline fun", "fun") }
+
+            lib.compile()
+            app.compile()
+
+            app.execute(mainClass = "CallSiteKt", exactOutput = INITIAL_OUTPUT)
+
+            lib.replaceFileWithVersion("SomeClass.kt", "withOverload")
+
+            lib.compile(expectedDirtySet = setOf("SomeClass.kt", "callable.kt"))
+            app.compile(expectedDirtySet = setOf())
+            app.execute(mainClass = "CallSiteKt", exactOutput = WITH_NEW_LAMBDA_BODY)
+        }
+    }
+
+    private companion object {
+        const val INITIAL_OUTPUT = "42"
+        const val WITH_NEW_LAMBDA_BODY = "45"
+    }
+}

compiler/build-tools/kotlin-build-tools-api-tests/src/testCrossModuleIncrementalChanges/kotlin/InlinedLambdaChangeTest.kt

@@ -18,7 +18,6 @@ import org.junit.jupiter.api.DisplayName
 
 // When adding or changing tests, make sure that test sources don't have unintended changes in whitespace, copyright notices and similar things:
 // debug info is sensitive to changes in line numbers, and it's part of default inline function abiHash
-@Disabled("KT-62555")
 class InlinedLambdaChangeTest : BaseCompilationTest() {
     @DefaultStrategyAgnosticCompilationTest
     @DisplayName("When inlined lambda's body changes, its call site is recompiled")
@@ -253,7 +252,7 @@ class InlinedLambdaChangeTest : BaseCompilationTest() {
     }
 
     @DefaultStrategyAgnosticCompilationTest
-    @DisplayName("Recompilation of call site affected by a anonymous object - basic")
+    @DisplayName("Recompilation of call site affected by an anonymous object - basic")
     @TestMetadata("ic-scenarios/inline-local-class/inline-anonymous-object/lib")
     fun testAnonymousObjectBaseTypeChange(strategyConfig: CompilerExecutionStrategyConfiguration) {
         scenario(strategyConfig) {
@@ -274,9 +273,9 @@ class InlinedLambdaChangeTest : BaseCompilationTest() {
         }
     }
 
-    @Disabled("broken! other snapshotting strategies might work better here")
+    @Disabled("should be fixed if we start snapshotting bytecode")
     @DefaultStrategyAgnosticCompilationTest
-    @DisplayName("Recompilation of call site affected by a anonymous object - slightly evil")
+    @DisplayName("Recompilation of call site affected by an anonymous object - slightly evil")
     @TestMetadata("ic-scenarios/inline-local-class/inline-anonymous-object-evil/lib")
     fun testAnonymousObjectBaseTypeChangeWithOverloads(strategyConfig: CompilerExecutionStrategyConfiguration) {
         scenario(strategyConfig) {

compiler/build-tools/kotlin-build-tools-api/api/kotlin-build-tools-api.api

@@ -10,6 +10,7 @@ public final class org/jetbrains/kotlin/buildtools/api/CompilationResult : java/
 public abstract interface class org/jetbrains/kotlin/buildtools/api/CompilationService {
 	public static final field Companion Lorg/jetbrains/kotlin/buildtools/api/CompilationService$Companion;
 	public abstract fun calculateClasspathSnapshot (Ljava/io/File;Lorg/jetbrains/kotlin/buildtools/api/jvm/ClassSnapshotGranularity;)Lorg/jetbrains/kotlin/buildtools/api/jvm/ClasspathEntrySnapshot;
+	public abstract fun calculateClasspathSnapshot (Ljava/io/File;Lorg/jetbrains/kotlin/buildtools/api/jvm/ClassSnapshotGranularity;Z)Lorg/jetbrains/kotlin/buildtools/api/jvm/ClasspathEntrySnapshot;
 	public abstract fun compileJvm (Lorg/jetbrains/kotlin/buildtools/api/ProjectId;Lorg/jetbrains/kotlin/buildtools/api/CompilerExecutionStrategyConfiguration;Lorg/jetbrains/kotlin/buildtools/api/jvm/JvmCompilationConfiguration;Ljava/util/List;Ljava/util/List;)Lorg/jetbrains/kotlin/buildtools/api/CompilationResult;
 	public abstract fun finishProjectCompilation (Lorg/jetbrains/kotlin/buildtools/api/ProjectId;)V
 	public abstract fun getCompilerVersion ()Ljava/lang/String;

compiler/build-tools/kotlin-build-tools-api/src/main/kotlin/org/jetbrains/kotlin/buildtools/api/CompilationService.kt

@@ -32,8 +32,28 @@ public interface CompilationService {
      *
      * @param classpathEntry path to existent classpath entry
      * @param granularity determines granularity of tracking.
+     * @param parseInlinedLocalClasses enables an experimental snapshotting mode for inline methods and accessors
      */
-    public fun calculateClasspathSnapshot(classpathEntry: File, granularity: ClassSnapshotGranularity): ClasspathEntrySnapshot
+    public fun calculateClasspathSnapshot(
+        classpathEntry: File,
+        granularity: ClassSnapshotGranularity,
+        parseInlinedLocalClasses: Boolean
+    ): ClasspathEntrySnapshot
+
+    /**
+     * Calculates JVM classpath snapshot for [classpathEntry] used for detecting changes in incremental compilation with specified [granularity].
+     *
+     * The [ClassSnapshotGranularity.CLASS_LEVEL] granularity should be preferred for rarely changing dependencies as more lightweight in terms of the resulting snapshot size.
+     *
+     * @param classpathEntry path to existent classpath entry
+     * @param granularity determines granularity of tracking.
+     *
+     * This version of [calculateClasspathSnapshot] would not do any extra work to snapshot local classes used inside inline functions.
+     */
+    public fun calculateClasspathSnapshot(
+        classpathEntry: File,
+        granularity: ClassSnapshotGranularity
+    ): ClasspathEntrySnapshot
 
     /**
      * Provides a default [CompilerExecutionStrategyConfiguration] allowing to use it as is or customizing for specific requirements.
@@ -95,4 +115,4 @@ public interface CompilationService {
         public fun loadImplementation(classLoader: ClassLoader): CompilationService =
             loadImplementation(CompilationService::class, classLoader)
     }
-}
+}