[KAPT] KT-65006 fix issues when using Kapt+Serialization

This MR fixes two independent issues causing build failures when using Kapt in combination with the Kotlin serialization plugin (and, very likely, with other plugins as well):
Kapt applied compiler plugins twice, causing errors similar to the one described in KT-65006
Kapt failed to generate @Metadata annotations for plugin-generated companion objects because the corresponding SLC missed containingFile needed for generation of method and class signatures

Merge-request: KT-MR-13970
Merged-by: Pavel Mikhailovskii <Pavel.Mikhailovskii@jetbrains.com>

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightClassForClassLike.kt

@@ -17,6 +17,7 @@ import org.jetbrains.annotations.NonNls
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.sourcePsiSafe
@@ -164,15 +165,26 @@ abstract class SymbolLightClassForClassLike<SType : KtClassOrObjectSymbol> prote
     override fun getSupers(): Array<PsiClass> = PsiClassImplUtil.getSupers(this)
     override fun getSuperTypes(): Array<PsiClassType> = PsiClassImplUtil.getSuperTypes(this)
 
-    override fun getContainingClass(): PsiClass? {
+    private val _containingClass: PsiClass? by lazyPub {
         val containingBody = classOrObjectDeclaration?.parent
-        return when (val parent = containingBody?.parent) {
+        when (val parent = containingBody?.parent) {
             is KtClassOrObject -> parent.toLightClass()
             is KtScript -> parent.toLightClass()
+            null -> withClassOrObjectSymbol { s ->
+                (s.getContainingSymbol() as? KtNamedClassOrObjectSymbol)?.let { createLightClassNoCache(it, ktModule, manager) }
+            }
             else -> null
         }
     }
 
+    override fun getContainingClass(): PsiClass? = _containingClass
+
+    private val _containingFile: PsiFile? by lazyPub {
+        super.getContainingFile() ?: containingClass?.containingFile
+    }
+
+    override fun getContainingFile(): PsiFile? = _containingFile
+
     abstract override fun getParent(): PsiElement?
     override fun getScope(): PsiElement? = parent
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kapt3IT.kt

@@ -1331,4 +1331,16 @@ open class Kapt3IT : Kapt3BaseIT() {
             }
         }
     }
+
+    @DisplayName("KT-65006 Kapt works with the serialization plugin")
+    @GradleTest
+    fun testSerializationPlugin(gradleVersion: GradleVersion) {
+        project("serialization".withPrefix, gradleVersion) {
+            build(":kaptGenerateStubsKotlin") {
+                assertFileInProjectContains("build/tmp/kapt3/stubs/main/foo/Data.java",
+                    "public static final class Companion",
+                    "public static final class \$serializer implements kotlinx.serialization.internal.GeneratedSerializer<foo.Data>")
+            }
+        }
+    }
 }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kapt2/indirectDependencies/build.gradle

@@ -1,5 +1,3 @@
-import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile
-
 plugins {
     id "java"
     id "org.jetbrains.kotlin.jvm"
@@ -21,7 +19,3 @@ dependencies {
     implementation "org.jetbrains.kotlin:annotation-processor-example:$kotlin_version"
     baseAnnos "org.jetbrains.kotlin:annotation-processor-example:$kotlin_version"
 }
-
-tasks.named("compileKotlin", KotlinJvmCompile) {
-    compilerOptions.allWarningsAsErrors = false // compilation with LV=2.0 prints warning about kapt fallback
-}

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kapt2/serialization/build.gradle

@@ -0,0 +1,17 @@
+plugins {
+    id "org.jetbrains.kotlin.jvm"
+    id "org.jetbrains.kotlin.kapt"
+    id "org.jetbrains.kotlin.plugin.serialization"
+}
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+}
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.2"
+    implementation "org.jetbrains.kotlin:annotation-processor-example:$kotlin_version"
+    kapt "org.jetbrains.kotlin:annotation-processor-example:$kotlin_version"
+}

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kapt2/serialization/src/main/java/foo/Data.kt

@@ -0,0 +1,6 @@
+package foo
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+class Data(val x: Int)

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/kapt2/simple/build.gradle

@@ -1,5 +1,3 @@
-import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile
-
 plugins {
     id "java"
     id "org.jetbrains.kotlin.jvm"
@@ -17,7 +15,3 @@ dependencies {
     kapt "org.jetbrains.kotlin:annotation-processor-example:$kotlin_version"
     testImplementation 'junit:junit:4.13.2'
 }
-
-tasks.named("compileKotlin", KotlinJvmCompile) {
-    compilerOptions.allWarningsAsErrors = false // compilation with LV=2.0 prints warning about kapt fallback
-}

plugins/kapt4/src/org/jetbrains/kotlin/kapt4/Kapt4AnalysisHandlerExtension.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.kapt4
 
-import com.intellij.openapi.extensions.ExtensionPoint
 import com.intellij.openapi.util.Disposer
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiJavaFile
@@ -78,23 +77,27 @@ private class Kapt4AnalysisHandlerExtension : FirAnalysisHandlerExtension() {
                     buildKtModuleProviderByCompilerConfiguration(updatedConfiguration)
 
                     registerProjectService(KtLifetimeTokenProvider::class.java, KtAlwaysAccessibleLifetimeTokenProvider())
-                    registerProjectService(KtCompilerPluginsProvider::class.java, StandaloneCompilerPluginsProvider())
+                    registerProjectService(KtCompilerPluginsProvider::class.java, object : KtCompilerPluginsProvider() {
+                        private val extensionStorage = CompilerPluginRegistrar.ExtensionStorage().apply {
+                            for (registrar in updatedConfiguration.getList(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS)) {
+                                with(registrar) { registerExtensions(updatedConfiguration) }
+                            }
+                        }
+
+                        override fun <T : Any> getRegisteredExtensions(
+                            module: KtSourceModule,
+                            extensionType: ProjectExtensionDescriptor<T>,
+                        ): List<T> {
+                            @Suppress("UNCHECKED_CAST")
+                            return (extensionStorage.registeredExtensions[extensionType] as? List<T>) ?: emptyList()
+                        }
+
+                        override fun isPluginOfTypeRegistered(module: KtSourceModule, pluginType: CompilerPluginType): Boolean = false
+                    })
                 }
 
             val (module, files) = standaloneAnalysisAPISession.modulesWithFiles.entries.single()
 
-            val extensionStorage = CompilerPluginRegistrar.ExtensionStorage()
-            for (registrar in configuration.getList(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS)) {
-                with(registrar) { extensionStorage.registerExtensions(configuration) }
-            }
-            for ((extensionPoint, extensions) in extensionStorage.registeredExtensions) {
-                for (extension in extensions) {
-                    @Suppress("TestOnlyProblems")
-                    module.project.extensionArea.getExtensionPointIfRegistered<Any>(extensionPoint.extensionPointName.name)
-                        ?.registerExtension(extension, module.project)
-                }
-            }
-
             optionsBuilder.apply {
                 projectBaseDir = projectBaseDir ?: module.project.basePath?.let(::File)
                 val contentRoots = configuration[CLIConfigurationKeys.CONTENT_ROOTS] ?: emptyList()

plugins/kapt4/src/org/jetbrains/kotlin/kapt4/StandaloneCompilerPluginsProvider.kt

@@ -1,27 +0,0 @@
-/*
- * Copyright 2010-2023 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.kapt4
-
-import org.jetbrains.kotlin.analysis.project.structure.KtCompilerPluginsProvider
-import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
-import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
-import org.jetbrains.kotlin.extensions.internal.InternalNonStableExtensionPoints
-import org.jetbrains.kotlin.resolve.extensions.AssignResolutionAltererExtension
-
-internal class StandaloneCompilerPluginsProvider : KtCompilerPluginsProvider() {
-    override fun <T : Any> getRegisteredExtensions(module: KtSourceModule, extensionType: ProjectExtensionDescriptor<T>): List<T> {
-        return extensionType.getInstances(module.project)
-    }
-
-    @OptIn(InternalNonStableExtensionPoints::class)
-    override fun isPluginOfTypeRegistered(module: KtSourceModule, pluginType: CompilerPluginType): Boolean {
-        val extension = when (pluginType) {
-            CompilerPluginType.ASSIGNMENT -> AssignResolutionAltererExtension
-            else -> return false
-        }
-        return extension.getInstances(module.project).isNotEmpty()
-    }
-}