[KAPT4] Create basic infrastructure for KAPT4

.space/CODEOWNERS

@@ -357,6 +357,7 @@
 /plugins/kapt3/kapt3-compiler/test/ "Kotlin Compiler Core" "Kotlin JVM"
 /plugins/kapt3/kapt3-compiler/testData/ "Kotlin Compiler Core" "Kotlin JVM"
 /plugins/kapt3/kapt3-compiler/tests-gen/ "Kotlin Compiler Core" "Kotlin JVM"
+/plugins/kapt4/ "Kotlin Compiler Core" "Kotlin JVM"
 /plugins/kotlinx-serialization/ Sergey.Shanshin Leonid.Startsev
 /plugins/lombok/ "Kotlin Compiler Core"
 /plugins/noarg/ "Kotlin Compiler Core"

build.gradle.kts

@@ -810,6 +810,8 @@ tasks {
     register("kaptTests") {
         dependsOn(":kotlin-annotation-processing:test")
         dependsOn(":kotlin-annotation-processing:testJdk11")
+        dependsOn(":kotlin-annotation-processing-compiler:test")
+        dependsOn(":kotlin-annotation-processing-compiler:testJdk11")
         dependsOn(":kotlin-annotation-processing-base:test")
         dependsOn(":kotlin-annotation-processing-cli:test")
     }

compiler/cli/cli-base/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -76,6 +76,7 @@ import org.jetbrains.kotlin.extensions.*
 import org.jetbrains.kotlin.extensions.internal.CandidateInterceptor
 import org.jetbrains.kotlin.extensions.internal.InternalNonStableExtensionPoints
 import org.jetbrains.kotlin.extensions.internal.TypeResolutionInterceptor
+import org.jetbrains.kotlin.fir.extensions.FirAnalysisHandlerExtension
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.js.translate.extensions.JsSyntheticTranslateExtension
@@ -673,6 +674,7 @@ class KotlinCoreEnvironment private constructor(
             FirExtensionRegistrarAdapter.registerExtensionPoint(project)
             TypeAttributeTranslatorExtension.registerExtensionPoint(project)
             AssignResolutionAltererExtension.registerExtensionPoint(project)
+            FirAnalysisHandlerExtension.registerExtensionPoint(project)
         }
 
         internal fun registerExtensionsFromPlugins(project: MockProject, configuration: CompilerConfiguration) {

compiler/cli/cli-common/gen/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArgumentsCopyGenerated.kt

@@ -78,6 +78,7 @@ fun copyK2JVMCompilerArguments(from: K2JVMCompilerArguments, to: K2JVMCompilerAr
     to.typeEnhancementImprovementsInStrictMode = from.typeEnhancementImprovementsInStrictMode
     to.useFastJarFileSystem = from.useFastJarFileSystem
     to.useJavac = from.useJavac
+    to.useKapt4 = from.useKapt4
     to.useOldBackend = from.useOldBackend
     to.useOldClassFilesReading = from.useOldClassFilesReading
     to.useOldInlineClassesManglingScheme = from.useOldInlineClassesManglingScheme

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt

@@ -846,6 +846,15 @@ Also sets `-jvm-target` value equal to the selected JDK version"""
             field = value
         }
 
+    @Argument(
+        value = "-Xuse-kapt4",
+        description = "Enable the experimental KAPT 4."
+    )
+    var useKapt4 = false
+        set(value) {
+            checkFrozen()
+            field = value
+        }
 
     override fun configureAnalysisFlags(collector: MessageCollector, languageVersion: LanguageVersion): MutableMap<AnalysisFlag<*>, Any> {
         val result = super.configureAnalysisFlags(collector, languageVersion)

compiler/cli/src/org/jetbrains/kotlin/cli/common/arguments.kt

@@ -56,17 +56,18 @@ fun CompilerConfiguration.setupCommonArguments(
     buildHmppModuleStructure(arguments)?.let { put(CommonConfigurationKeys.HMPP_MODULE_STRUCTURE, it) }
 }
 
-fun switchToFallbackModeIfNecessary(arguments: CommonCompilerArguments, messageCollector: MessageCollector) {
+private fun switchToFallbackModeIfNecessary(arguments: CommonCompilerArguments, messageCollector: MessageCollector) {
-    val isK2 = arguments.useK2 || (arguments.languageVersion?.startsWith('2') ?: (LanguageVersion.LATEST_STABLE >= LanguageVersion.KOTLIN_2_0))
+    fun warn(message: String) {
-    if (isK2) {
+        if (!arguments.suppressVersionWarnings) messageCollector.report(CompilerMessageSeverity.STRONG_WARNING, message)
-        val isKaptUsed = arguments.pluginOptions?.any { it.startsWith("plugin:org.jetbrains.kotlin.kapt3") } == true
+    }
-        if (isKaptUsed) {
+
-            if (!arguments.suppressVersionWarnings) {
+    if (arguments !is K2JVMCompilerArguments) return
-                messageCollector.report(
+    val isK2 =
-                    CompilerMessageSeverity.STRONG_WARNING,
+        arguments.useK2 || (arguments.languageVersion?.startsWith('2') ?: (LanguageVersion.LATEST_STABLE >= LanguageVersion.KOTLIN_2_0))
-                    "Kapt currently doesn't support language version 2.0+.\nFalling back to 1.9."
+    val isKaptUsed = arguments.pluginOptions?.any { it.startsWith("plugin:org.jetbrains.kotlin.kapt3") } == true
-                )
+    when {
-            }
+        isK2 && isKaptUsed && !arguments.useKapt4 -> {
+            warn("Kapt currently doesn't support language version 2.0+. Falling back to 1.9.")
             arguments.languageVersion = LanguageVersion.KOTLIN_1_9.versionString
             if (arguments.apiVersion?.startsWith("2") == true) {
                 arguments.apiVersion = ApiVersion.KOTLIN_1_9.versionString
@@ -74,8 +75,11 @@ fun switchToFallbackModeIfNecessary(arguments: CommonCompilerArguments, messageC
             arguments.useK2 = false
             arguments.skipMetadataVersionCheck = true
             arguments.skipPrereleaseCheck = true
-            (arguments as? K2JVMCompilerArguments)?.allowUnstableDependencies = true
+            arguments.allowUnstableDependencies = true
         }
+        isK2 && isKaptUsed && arguments.useKapt4 -> warn("Kapt 4 is still experimental. Use with caution.")
+        arguments.useKapt4 && !isK2 -> warn("-Xuse-kapt4 flag can be only used with language version 2.0+.")
+        arguments.useKapt4 && !isKaptUsed -> warn("-Xuse-kapt4 flag is present but no Kapt configuration options are provided.")
     }
 }
 

compiler/frontend.common.jvm/src/org/jetbrains/kotlin/fir/extensions/FirAnalysisHandlerExtension.kt

@@ -0,0 +1,32 @@
+/*
+ * 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.fir.extensions
+
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
+
+
+abstract class FirAnalysisHandlerExtension {
+    companion object : ProjectExtensionDescriptor<FirAnalysisHandlerExtension>(
+        "org.jetbrains.kotlin.fir.firAnalyzeCompleteHandlerExtension",
+        FirAnalysisHandlerExtension::class.java
+    )
+
+    /**
+     * Checks whether [doAnalysis] should be called
+     * @param configuration compiler configuration
+     * @return true if [doAnalysis] should be called
+     */
+    abstract fun isApplicable(configuration: CompilerConfiguration): Boolean
+
+    /**
+     * Performs code analysis
+     * @param configuration compiler configuration
+     * @return true if analysis completed successfully. There can be different causes of failure, an incorrect configuration for example.
+     * A failure means that there's no reason to continue building the project.
+     */
+    abstract fun doAnalysis(configuration: CompilerConfiguration): Boolean
+}

compiler/testData/cli/jvm/extraHelp.out

@@ -143,6 +143,7 @@ where advanced options include:
                              See KT-45671 for more details
   -Xuse-fast-jar-file-system Use fast implementation on Jar FS. This may speed up compilation time, but currently it's an experimental mode
   -Xuse-javac                Use javac for Java source and class files analysis
+  -Xuse-kapt4                Enable the experimental KAPT 4.
   -Xuse-old-backend          Use the old JVM backend
   -Xuse-old-class-files-reading Use old class files reading implementation. This may slow down the build and cause problems with Groovy interop.
                              Should be used in case of problems with the new implementation

generators/build.gradle.kts

@@ -59,8 +59,9 @@ dependencies {
     testApi(projectTests(":plugins:jvm-abi-gen"))
     testApi(projectTests(":plugins:android-extensions-compiler"))
     testApi(projectTests(":plugins:parcelize:parcelize-compiler"))
-    testApi(projectTests(":kotlin-annotation-processing"))
+    testApi(projectTests(":kotlin-annotation-processing-compiler"))
     testApi(projectTests(":kotlin-annotation-processing-cli"))
+    testApi(projectTests(":kotlin-annotation-processing"))
     testApi(projectTests(":kotlin-allopen-compiler-plugin"))
     testApi(projectTests(":kotlin-noarg-compiler-plugin"))
     testApi(projectTests(":kotlin-lombok-compiler-plugin"))

plugins/kapt3/kapt3-cli/src/KaptCli.kt

@@ -114,7 +114,12 @@ private fun transformKaptToolArgs(args: List<String>, messageCollector: MessageC
     }
 
     if (!aptModePassed) {
-        transformed.addAll(0, kaptArg(KaptCliOption.APT_MODE_OPTION, "compile"))
+        val isK2 = "-Xuse-kapt4" in transformed && ("-Xuse-k2" in transformed ||
+                transformed.any { it.startsWith("-language-version=2") } ||
+                transformed.lastIndexOf("-language-version").takeIf { it >= 0 }
+                    ?.let { transformed.getOrNull(it + 1)?.startsWith('2') } == true)
+
+        transformed.addAll(0, kaptArg(KaptCliOption.APT_MODE_OPTION, if (isK2) "stubsAndApt" else "compile"))
     }
 
     if (!isTest && !isAtLeastJava9() && !areJavacComponentsAvailable() && !toolsJarPassed) {

plugins/kapt3/kapt3-cli/testData/integration/fallback/build.txt

@@ -47,8 +47,7 @@ output/sources/generated/Test.java
 Test.kt
 
 # output
-warning: kapt currently doesn't support language version 2.0+.
+warning: kapt currently doesn't support language version 2.0+. Falling back to 1.9.
-Falling back to 1.9.
 
 # java
 -cp output/classes:output/javaClasses:output/ap.jar:%KOTLIN_STDLIB%

plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/Kapt3Plugin.kt

@@ -21,13 +21,13 @@ import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.base.kapt3.*
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
 import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.compiler.plugin.*
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CommonConfigurationKeys.USE_FIR
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
@@ -59,7 +59,7 @@ import java.io.File
 import java.io.ObjectInputStream
 import java.util.*
 
-private val KAPT_OPTIONS = CompilerConfigurationKey.create<KaptOptions.Builder>("Kapt options")
+val KAPT_OPTIONS = CompilerConfigurationKey.create<KaptOptions.Builder>("Kapt options")
 
 class Kapt3CommandLineProcessor : CommandLineProcessor {
     override val pluginId: String = ANNOTATION_PROCESSING_COMPILER_PLUGIN_ID
@@ -71,12 +71,6 @@ class Kapt3CommandLineProcessor : CommandLineProcessor {
         if (option !is KaptCliOption) {
             throw CliOptionProcessingException("Unknown option: ${option.optionName}")
         }
-        if (configuration.getBoolean(CommonConfigurationKeys.USE_FIR)) {
-            configuration[CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY]?.report(
-                CompilerMessageSeverity.ERROR,
-                "kapt currently doesn't support language version 2.0\nPlease use language version 1.9 or below"
-            )
-        }
 
         val kaptOptions = configuration[KAPT_OPTIONS]
             ?: KaptOptions.Builder().also { configuration.put(KAPT_OPTIONS, it) }
@@ -173,6 +167,7 @@ class Kapt3CommandLineProcessor : CommandLineProcessor {
 @Suppress("DEPRECATION")
 class Kapt3ComponentRegistrar : ComponentRegistrar {
     override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+        if (configuration.getBoolean(USE_FIR)) return
         doOpenInternalPackagesIfRequired()
         val contentRoots = configuration[CLIConfigurationKeys.CONTENT_ROOTS] ?: emptyList()
 

plugins/kapt4/build.gradle.kts

@@ -0,0 +1,59 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+description = "Annotation Processor for Kotlin"
+
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    compileOnly(project(":compiler:frontend.java"))
+    compileOnly(project(":compiler:plugin-api"))
+
+    implementation(project(":kotlin-annotation-processing-compiler"))
+    embedded(project(":kotlin-annotation-processing-compiler")) { isTransitive = false }
+}
+
+optInToExperimentalCompilerApi()
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" {
+        projectDefault()
+        generatedTestDir()
+    }
+}
+
+testsJar {}
+
+kaptTestTask("test", JavaLanguageVersion.of(8))
+kaptTestTask("testJdk11", JavaLanguageVersion.of(11))
+kaptTestTask("testJdk17", JavaLanguageVersion.of(17))
+
+fun Project.kaptTestTask(name: String, javaLanguageVersion: JavaLanguageVersion) {
+    val service = extensions.getByType<JavaToolchainService>()
+
+    projectTest(taskName = name, parallel = true) {
+        useJUnitPlatform {
+            excludeTags = setOf("IgnoreJDK11")
+        }
+        workingDir = rootDir
+        dependsOn(":dist")
+        javaLauncher.set(service.launcherFor { languageVersion.set(javaLanguageVersion) })
+    }
+}
+
+publish()
+runtimeJar()
+sourcesJar()
+javadocJar()
+
+
+allprojects {
+    tasks.withType(KotlinCompile::class).all {
+        kotlinOptions {
+            freeCompilerArgs += "-Xcontext-receivers"
+        }
+    }
+}

plugins/kapt4/resources/META-INF/services/org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar

@@ -0,0 +1,6 @@
+#
+# 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.
+#
+
+org.jetbrains.kotlin.kapt4.Kapt4CompilerPluginRegistrar

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

@@ -0,0 +1,38 @@
+/*
+ * 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.compiler.plugin.CompilerPluginRegistrar
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.fir.extensions.FirAnalysisHandlerExtension
+import org.jetbrains.kotlin.kapt3.KAPT_OPTIONS
+
+
+class Kapt4AnalysisHandlerExtension : FirAnalysisHandlerExtension() {
+    override fun isApplicable(configuration: CompilerConfiguration): Boolean =
+        configuration.getBoolean(CommonConfigurationKeys.USE_FIR) && configuration[KAPT_OPTIONS] != null
+
+    override fun doAnalysis(configuration: CompilerConfiguration): Boolean {
+        TODO("Not yet implemented")
+    }
+}
+
+class Kapt4CompilerPluginRegistrar : CompilerPluginRegistrar() {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
+        Companion.registerExtensions(this)
+    }
+
+    override val supportsK2: Boolean
+        get() = true
+
+
+    companion object {
+        fun registerExtensions(extensionStorage: ExtensionStorage) = with(extensionStorage) {
+            FirAnalysisHandlerExtension.registerExtension(Kapt4AnalysisHandlerExtension())
+        }
+    }
+}

prepare/compiler/build.gradle.kts

@@ -86,9 +86,10 @@ val outputJar = fileFrom(buildDir, "libs", "$compilerBaseName.jar")
 val compilerModules: Array<String> by rootProject.extra
 
 val distLibraryProjects = listOfNotNull(
-    ":kotlin-annotation-processing",
+    ":kotlin-annotation-processing-compiler",
     ":kotlin-annotation-processing-cli",
     ":kotlin-annotation-processing-runtime",
+    ":kotlin-annotation-processing",
     ":kotlin-annotations-jvm",
     ":kotlin-ant",
     ":kotlin-daemon",

repo/artifacts-tests/src/test/resources/org/jetbrains/kotlin/kotlin-annotation-processing-compiler/kotlin-annotation-processing-compiler.pom

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.jetbrains.kotlin</groupId>
+  <artifactId>kotlin-annotation-processing-compiler</artifactId>
+  <version>ArtifactsTest.version</version>
+  <name>Kotlin Annotation Processing Compiler</name>
+  <description>Annotation Processor for Kotlin</description>
+  <url>https://kotlinlang.org/</url>
+  <licenses>
+    <license>
+      <name>The Apache License, Version 2.0</name>
+      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+    </license>
+  </licenses>
+  <developers>
+    <developer>
+      <name>Kotlin Team</name>
+      <organization>JetBrains</organization>
+      <organizationUrl>https://www.jetbrains.com</organizationUrl>
+    </developer>
+  </developers>
+  <scm>
+    <connection>scm:git:https://github.com/JetBrains/kotlin.git</connection>
+    <developerConnection>scm:git:https://github.com/JetBrains/kotlin.git</developerConnection>
+    <url>https://github.com/JetBrains/kotlin</url>
+  </scm>
+</project>

repo/artifacts-tests/src/test/resources/org/jetbrains/kotlin/kotlin-annotation-processing/kotlin-annotation-processing.pom

@@ -25,4 +25,12 @@
     <developerConnection>scm:git:https://github.com/JetBrains/kotlin.git</developerConnection>
     <url>https://github.com/JetBrains/kotlin</url>
   </scm>
+  <dependencies>
+    <dependency>
+      <groupId>org.jetbrains.kotlin</groupId>
+      <artifactId>kotlin-annotation-processing-compiler</artifactId>
+      <version>ArtifactsTest.version</version>
+      <scope>runtime</scope>
+    </dependency>
+  </dependencies>
 </project>

settings.gradle

@@ -226,6 +226,7 @@ include ":kotlin-imports-dumper-compiler-plugin",
         ":kotlin-annotation-processing-base",
         ":kotlin-annotation-processing-runtime",
         ":kotlin-annotation-processing-embeddable",
+        ":kotlin-annotation-processing-compiler",
         ":kotlin-daemon-embeddable",
         ":kotlin-annotations-jvm",
         ":kotlin-scripting-common",
@@ -749,10 +750,11 @@ project(':examples:annotation-processor-example').projectDir = "$rootDir/librari
 project(':kotlin-script-util').projectDir = "$rootDir/libraries/tools/kotlin-script-util" as File
 project(':kotlin-annotation-processing-embeddable').projectDir = "$rootDir/plugins/kapt3/kotlin-annotation-processing-embeddable" as File
 project(':kotlin-daemon-embeddable').projectDir = "$rootDir/prepare/kotlin-daemon-embeddable" as File
-project(':kotlin-annotation-processing').projectDir = "$rootDir/plugins/kapt3/kapt3-compiler" as File
+project(':kotlin-annotation-processing-compiler').projectDir = "$rootDir/plugins/kapt3/kapt3-compiler" as File
 project(':kotlin-annotation-processing-cli').projectDir = "$rootDir/plugins/kapt3/kapt3-cli" as File
 project(':kotlin-annotation-processing-base').projectDir = "$rootDir/plugins/kapt3/kapt3-base" as File
 project(':kotlin-annotation-processing-runtime').projectDir = "$rootDir/plugins/kapt3/kapt3-runtime" as File
+project(':kotlin-annotation-processing').projectDir = "$rootDir/plugins/kapt4" as File
 project(':kotlin-annotations-jvm').projectDir = "$rootDir/libraries/tools/kotlin-annotations-jvm" as File
 project(':kotlin-scripting-common').projectDir = "$rootDir/libraries/scripting/common" as File
 project(':kotlin-scripting-jvm').projectDir = "$rootDir/libraries/scripting/jvm" as File