KT-65684: KAPT: (Re)enable fallback to K1 KAPT and make it default

[KAPT] KT-65684 Set languageVersion=1.9 in KaptToolIntegrationTestGenerated

[KAPT] KT-65684 Re-enable a few now-passing tests in Kapt4IT

[KAPT] KT-65684 Fix the logic setting -Xuse-kapt4 flag in Kapt4IT.forceKapt4()

The change is needed to make sure that all the tests have the flag set,
 otherwise some of them would silently switch to the fallback node.
Also disables a few now failing tests.

[KAPT] KT-65684 Revert "KT-64385 Enable K2 KAPT by default"

This reverts commit 7e9d6e60


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

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

@@ -77,6 +77,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

@@ -836,6 +836,16 @@ This option is deprecated and will be deleted in future versions."""
             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)
         result[JvmAnalysisFlags.strictMetadataVersionSemantics] = strictMetadataVersionSemantics

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.cli.common
 import com.intellij.ide.highlighter.JavaFileType
 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.CommonToolArguments
+import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.ManualLanguageFeatureSetting
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
@@ -47,6 +48,7 @@ fun CompilerConfiguration.setupCommonArguments(
         }
     }
 
+    switchToFallbackModeIfNecessary(arguments, messageCollector)
     setupLanguageVersionSettings(arguments)
 
     val usesK2 = arguments.useK2 || languageVersionSettings.languageVersion.usesK2
@@ -55,6 +57,34 @@ fun CompilerConfiguration.setupCommonArguments(
     buildHmppModuleStructure(arguments)?.let { put(CommonConfigurationKeys.HMPP_MODULE_STRUCTURE, it) }
 }
 
+private fun switchToFallbackModeIfNecessary(arguments: CommonCompilerArguments, messageCollector: MessageCollector) {
+    fun warn(message: String) {
+        if (!arguments.suppressVersionWarnings) messageCollector.report(CompilerMessageSeverity.STRONG_WARNING, message)
+    }
+
+    if (arguments !is K2JVMCompilerArguments) return
+    val isK2 =
+        arguments.useK2 || (arguments.languageVersion?.startsWith('2') ?: (LanguageVersion.LATEST_STABLE >= LanguageVersion.KOTLIN_2_0))
+    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
+            }
+            arguments.useK2 = false
+            arguments.skipMetadataVersionCheck = true
+            arguments.skipPrereleaseCheck = true
+            arguments.allowUnstableDependencies = true
+        }
+        arguments.useKapt4 -> warn(
+            if (isK2) "K2 kapt is an experimental feature. Use with caution."
+            else "-Xuse-kapt4 flag can be only used with language version 2.0+."
+        )
+    }
+}
+
 fun CompilerConfiguration.setupLanguageVersionSettings(arguments: CommonCompilerArguments) {
     languageVersionSettings = arguments.toLanguageVersionSettings(getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY))
 }

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 the fast implementation of Jar FS. This may speed up compilation time, but it is experimental.
   -Xuse-javac                Use javac for Java source and class file analysis.
+  -Xuse-kapt4                Enable the experimental KAPT 4.
   -Xuse-old-backend          Use the old JVM backend.
   -Xuse-old-class-files-reading Use the old implementation for reading class files. This may slow down the compilation and cause problems with Groovy interop.
                              This can be used in the event of problems with the new implementation.

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

@@ -12,9 +12,9 @@ import org.jetbrains.kotlin.gradle.testbase.*
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.DisplayName
 
-@DisplayName("Kapt3 caching inside Gradle daemon")
+@DisplayName("Kapt caching inside Gradle daemon")
 @DaemonsGradlePluginTests
-open class Kapt3AndGradleDaemon : KGPDaemonsBaseTest() {
+class Kapt3AndGradleDaemon : KGPDaemonsBaseTest() {
 
     override val defaultBuildOptions: BuildOptions = super.defaultBuildOptions
         .copy(
@@ -22,7 +22,7 @@ open class Kapt3AndGradleDaemon : KGPDaemonsBaseTest() {
                 verbose = true,
                 includeCompileClasspath = false
             )
-        ).copyEnsuringK1()
+        )
 
     @DisplayName("Javac should be loaded only once")
     @GradleTest
@@ -51,7 +51,7 @@ open class Kapt3AndGradleDaemon : KGPDaemonsBaseTest() {
     // which is not compatible with classloaders caching.
     @GradleTestVersions(maxVersion = TestVersions.Gradle.G_7_6)
     @GradleTest
-    open fun testAnnotationProcessorClassIsLoadedOnce(gradleVersion: GradleVersion) {
+    fun testAnnotationProcessorClassIsLoadedOnce(gradleVersion: GradleVersion) {
         project(
             "javacIsLoadedOnce".withPrefix,
             gradleVersion,

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

@@ -147,10 +147,18 @@ open class Kapt3ClassLoadersCacheIT : Kapt3IT() {
     override fun useGeneratedKotlinSource(gradleVersion: GradleVersion) {
     }
 
+    @Disabled("classloaders cache is leaking file descriptors that prevents cleaning test project")
+    override fun useGeneratedKotlinSourceK2(gradleVersion: GradleVersion) {
+    }
+
     @Disabled("classloaders cache is leaking file descriptors that prevents cleaning test project")
     override fun testMultipleProcessingPasses(gradleVersion: GradleVersion) {
     }
 
+    @Disabled("classloaders cache is leaking file descriptors that prevents cleaning test project")
+    override fun useK2KaptProperty(gradleVersion: GradleVersion) {
+    }
+
     override fun testAnnotationProcessorAsFqName(gradleVersion: GradleVersion) {
         project("annotationProcessorAsFqName".withPrefix, gradleVersion) {
             //classloaders caching is not compatible with includeCompileClasspath
@@ -384,13 +392,13 @@ open class Kapt3IT : Kapt3BaseIT() {
 
     @DisplayName("Kapt is working with incremental compilation")
     @GradleTest
-    open fun testSimpleWithIC(gradleVersion: GradleVersion) {
+    fun testSimpleWithIC(gradleVersion: GradleVersion) {
         doTestSimpleWithIC(gradleVersion)
     }
 
     @DisplayName("Kapt is working with incremental compilation, when kotlin.incremental.useClasspathSnapshot=true")
     @GradleTest
-    open fun testSimpleWithIC_withClasspathSnapshot(gradleVersion: GradleVersion) {
+    fun testSimpleWithIC_withClasspathSnapshot(gradleVersion: GradleVersion) {
         doTestSimpleWithIC(gradleVersion, useClasspathSnapshot = true)
     }
 
@@ -997,7 +1005,7 @@ open class Kapt3IT : Kapt3BaseIT() {
 
     @DisplayName("Kapt with MPP/Jvm")
     @GradleTest
-    open fun testMPPKaptPresence(gradleVersion: GradleVersion) {
+    fun testMPPKaptPresence(gradleVersion: GradleVersion) {
         project(
             "mpp-kapt-presence".withPrefix,
             gradleVersion,
@@ -1268,6 +1276,99 @@ open class Kapt3IT : Kapt3BaseIT() {
         }
     }
 
+    @DisplayName("Kapt runs in fallback mode with useK2 = true")
+    @GradleTest
+    open fun fallBackModeWithUseK2(gradleVersion: GradleVersion) {
+        project("simple".withPrefix, gradleVersion) {
+            buildGradle.appendText(
+                """
+                |tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
+                |    compilerOptions {
+                |        freeCompilerArgs.addAll([
+                |            "-Xuse-fir-ic",
+                |            "-Xuse-fir-lt"
+                |        ])
+                |    }
+                |    kotlinOptions {
+                |      useK2 = true
+                |    }
+                |}
+                |
+                |compileKotlin.kotlinOptions.allWarningsAsErrors = false
+                """.trimMargin()
+            )
+            build("build") {
+                assertKaptSuccessful()
+                assertTasksExecuted(":kaptGenerateStubsKotlin", ":kaptKotlin", ":compileKotlin")
+                assertOutputContains("Falling back to 1.9.")
+            }
+        }
+    }
+
+    @DisplayName("Kapt runs in fallback mode with languageVersion = 2.0")
+    @GradleTest
+    open fun fallBackModeWithLanguageVersion2_0(gradleVersion: GradleVersion) {
+        project("simple".withPrefix, gradleVersion) {
+            buildGradle.appendText(
+                """
+                |tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
+                |    compilerOptions {
+                |        freeCompilerArgs.addAll([
+                |            "-Xuse-fir-ic",
+                |            "-Xuse-fir-lt"
+                |        ])
+                |    }
+                |    kotlinOptions {
+                |      languageVersion = "2.0"
+                |    }
+                |}
+                |
+                |compileKotlin.kotlinOptions.allWarningsAsErrors = false
+                """.trimMargin()
+            )
+            build("build") {
+                assertKaptSuccessful()
+                assertTasksExecuted(":kaptGenerateStubsKotlin", ":kaptKotlin", ":compileKotlin")
+                assertOutputContains("Falling back to 1.9.")
+            }
+        }
+    }
+
+    @DisplayName("K2 Kapt can be enabled via Gradle property kapt.use.k2")
+    @GradleTest
+    open fun useK2KaptProperty(gradleVersion: GradleVersion) {
+        project("simple".withPrefix, gradleVersion) {
+            buildGradle.appendText(
+                """
+                |tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
+                |    compilerOptions {
+                |        freeCompilerArgs.addAll([
+                |            "-Xuse-fir-ic",
+                |            "-Xuse-fir-lt"
+                |        ])
+                |    }
+                |    kotlinOptions {
+                |        languageVersion = "2.0"
+                |    }
+                |}
+                |
+                |compileKotlin.kotlinOptions.allWarningsAsErrors = false
+                """.trimMargin()
+            )
+            build("-Pkapt.use.k2=true", "build") {
+                assertKaptSuccessful()
+                assertTasksExecuted(":kaptGenerateStubsKotlin", ":kaptKotlin", ":compileKotlin")
+                assertOutputDoesNotContain("Falling back to 1.9.")
+                assertOutputContains("K2 kapt is an experimental feature. Use with caution.")
+            }
+            build("-Pkapt.use.k2=true", "cleanCompileKotlin", "compileKotlin") {
+                assertTasksExecuted(":compileKotlin")
+                // The warning should not be displayed for the compile task.
+                assertOutputDoesNotContain("K2 kapt is an experimental feature. Use with caution.")
+            }
+        }
+    }
+
     @DisplayName("Kapt-generated Kotlin sources can be used in Kotlin")
     @GradleTest
     open fun useGeneratedKotlinSource(gradleVersion: GradleVersion) {
@@ -1279,6 +1380,35 @@ open class Kapt3IT : Kapt3BaseIT() {
         }
     }
 
+    @DisplayName("Kapt-generated Kotlin sources can be used in Kotlin with languageVersion = 2.0")
+    @GradleTest
+    open fun useGeneratedKotlinSourceK2(gradleVersion: GradleVersion) {
+        project("useGeneratedKotlinSource".withPrefix, gradleVersion) {
+            buildGradle.appendText(
+                """
+                |tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
+                |    compilerOptions {
+                |        freeCompilerArgs.addAll([
+                |            "-Xuse-fir-ic",
+                |            "-Xuse-fir-lt"
+                |        ])
+                |    }
+                |    kotlinOptions {
+                |      languageVersion = "2.0"
+                |    }
+                |}
+                |
+                |compileKotlin.kotlinOptions.allWarningsAsErrors = false
+                """.trimMargin()
+            )
+            build("build") {
+                assertKaptSuccessful()
+                assertTasksExecuted(":kaptGenerateStubsKotlin", ":kaptKotlin", ":compileKotlin")
+                assertOutputContains("Falling back to 1.9.")
+            }
+        }
+    }
+
     @DisplayName("KT-58745: compiler plugin options should be passed to KaptGenerateStubs task")
     @GradleTest
     fun kaptGenerateStubsConfiguredWithCompilerPluginOptions(gradleVersion: GradleVersion) {

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

@@ -1,21 +0,0 @@
-/*
- * Copyright 2010-2024 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.gradle
-
-import org.gradle.util.GradleVersion
-import org.jetbrains.kotlin.gradle.testbase.BuildOptions
-import org.jetbrains.kotlin.gradle.testbase.DaemonsGradlePluginTests
-import org.junit.jupiter.api.Disabled
-import org.junit.jupiter.api.DisplayName
-
-@DisplayName("Kapt4 caching inside Gradle daemon")
-@DaemonsGradlePluginTests
-class Kapt4AndGradleDaemon : Kapt3AndGradleDaemon() {
-    override val defaultBuildOptions: BuildOptions = super.defaultBuildOptions.copyEnsuringK2()
-
-    @Disabled("KT-63102 Incremental compilation doesn't work in 2.0")
-    override fun testAnnotationProcessorClassIsLoadedOnce(gradleVersion: GradleVersion) {}
-}

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

@@ -10,24 +10,29 @@ import org.jetbrains.kotlin.gradle.testbase.*
 import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.DisplayName
 import kotlin.io.path.appendText
-
+import kotlin.io.path.name
+import kotlin.io.path.walk
 
 @DisplayName("Kapt 4 base checks")
 class Kapt4IT : Kapt3IT() {
     override val defaultBuildOptions = super.defaultBuildOptions.copyEnsuringK2()
 
-    @DisplayName("Kapt doesn't run in fallback mode with languageVersion = 2.0")
+    override fun TestProject.customizeProject() {
-    @GradleTest
+        forceKapt4()
-    fun noFallBackModeWithLanguageVersion2_0(gradleVersion: GradleVersion) {
-        project("simple".withPrefix, gradleVersion) {
-            build("build") {
-                assertKaptSuccessful()
-                assertTasksExecuted(":kaptGenerateStubsKotlin", ":kaptKotlin", ":compileKotlin")
-                assertOutputDoesNotContain("Falling back to 1.9.")
-            }
-        }
     }
 
+    @Disabled("Doesn't make sense in Kapt 4")
+    override fun useGeneratedKotlinSourceK2(gradleVersion: GradleVersion) {}
+
+    @Disabled("Doesn't make sense in Kapt 4")
+    override fun fallBackModeWithUseK2(gradleVersion: GradleVersion) {}
+
+    @Disabled("Doesn't make sense in Kapt 4")
+    override fun fallBackModeWithLanguageVersion2_0(gradleVersion: GradleVersion) {}
+
+    @Disabled("Doesn't make sense in Kapt 4")
+    override fun useK2KaptProperty(gradleVersion: GradleVersion) {}
+
     @DisplayName("KT-61879: K2 KAPT works with proguarded compiler jars and enum class")
     @GradleTest
     fun testEnumClass(gradleVersion: GradleVersion) {
@@ -45,15 +50,52 @@ class Kapt4IT : Kapt3IT() {
 class Kapt4ClassLoadersCacheIT : Kapt3ClassLoadersCacheIT() {
     override val defaultBuildOptions = super.defaultBuildOptions.copyEnsuringK2()
 
+    override fun TestProject.customizeProject() {
+        forceKapt4()
+    }
+
     @Disabled("Enable when KT-61845 is fixed")
     override fun testKt18799(gradleVersion: GradleVersion) {}
 
-    @Disabled("KT-63102 Incremental compilation doesn't work in 2.0")
+    @Disabled("Doesn't make sense in Kapt 4")
-    override fun testSimpleWithIC(gradleVersion: GradleVersion) {}
+    override fun useGeneratedKotlinSourceK2(gradleVersion: GradleVersion) {}
 
-    @Disabled("KT-63102 Incremental compilation doesn't work in 2.0")
+    @Disabled("Doesn't make sense in Kapt 4")
-    override fun testSimpleWithIC_withClasspathSnapshot(gradleVersion: GradleVersion) {}
+    override fun fallBackModeWithUseK2(gradleVersion: GradleVersion) {}
 
-    @Disabled("KT-63102 Incremental compilation doesn't work in 2.0")
+    @Disabled("Doesn't make sense in Kapt 4")
-    override fun testChangeClasspathICRebuild(gradleVersion: GradleVersion) {}
+    override fun fallBackModeWithLanguageVersion2_0(gradleVersion: GradleVersion) {}
+}
+
+fun TestProject.forceKapt4() {
+    projectPath.walk().forEach {
+        when (it.fileName.name) {
+            "build.gradle" -> it.appendText(
+                """
+                
+                try {
+                    Class.forName('org.jetbrains.kotlin.gradle.tasks.KotlinCompile')
+                    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
+                       compilerOptions.freeCompilerArgs.addAll(['-Xuse-kapt4', '-Xsuppress-version-warnings'])
+                    }
+                } catch(ClassNotFoundException ignore) {
+                }
+                
+                """.trimIndent()
+            )
+            "build.gradle.kts" -> it.appendText(
+                """
+                
+                try {
+                    Class.forName("org.jetbrains.kotlin.gradle.tasks.KotlinCompile")
+                    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile::class.java).configureEach {
+                       compilerOptions.freeCompilerArgs.addAll(listOf("-Xuse-kapt4", "-Xsuppress-version-warnings"))
+                    }
+                } catch(ignore: ClassNotFoundException) {
+                }
+                
+                """.trimIndent()
+            )
+        }
+    }
 }

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

@@ -3,7 +3,6 @@ package org.jetbrains.kotlin.gradle
 import org.gradle.api.logging.LogLevel
 import org.gradle.testkit.runner.BuildResult
 import org.gradle.util.GradleVersion
-import  org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 import org.jetbrains.kotlin.gradle.testbase.*
 import org.junit.jupiter.api.DisplayName
 import java.io.File
@@ -30,7 +29,7 @@ open class KaptIncrementalIT : KGPBaseTest() {
     override val defaultBuildOptions = super.defaultBuildOptions.copy(
         incremental = true,
         kaptOptions = BuildOptions.KaptOptions(incrementalKapt = true)
-    ).copyEnsuringK1()
+    )
 
     protected open fun KGPBaseTest.kaptProject(
         gradleVersion: GradleVersion,
@@ -187,10 +186,8 @@ open class KaptIncrementalIT : KGPBaseTest() {
             build("assemble") {
                 assertKapt3FullyExecuted()
 
-                if (isIncrementalStubGenerationSupported) {
+                assertFileInProjectExists("$kapt3IncDataPath/bar/B.class")
-                    assertFileInProjectExists("$kapt3IncDataPath/bar/B.class")
+                assertFileInProjectExists("$kapt3IncDataPath/bar/UseBKt.class")
-                    assertFileInProjectExists("$kapt3IncDataPath/bar/UseBKt.class")
-                }
                 assertFileInProjectExists("$kapt3StubsPath/bar/B.java")
                 assertFileInProjectExists("$kapt3StubsPath/bar/B.kapt_metadata")
                 assertFileInProjectExists("$kapt3StubsPath/bar/UseBKt.java")
@@ -285,13 +282,11 @@ open class KaptIncrementalIT : KGPBaseTest() {
                 assertKapt3FullyExecuted()
 
                 val useBKt = javaSourcesDir().resolve("bar/useB.kt")
-                if (isIncrementalStubGenerationSupported) {
+                assertCompiledKotlinSources(
-                    assertCompiledKotlinSources(
+                    listOf(projectPath.relativize(bKt), projectPath.relativize(useBKt)),
-                        listOf(projectPath.relativize(bKt), projectPath.relativize(useBKt)),
+                    getOutputForTask(":kaptGenerateStubsKotlin"),
-                        getOutputForTask(":kaptGenerateStubsKotlin"),
+                    errorMessageSuffix = " in task 'kaptGenerateStubsKotlin'"
-                        errorMessageSuffix = " in task 'kaptGenerateStubsKotlin'"
+                )
-                    )
-                }
 
                 // java removal is detected
                 assertCompiledKotlinSources(
@@ -348,20 +343,17 @@ open class KaptIncrementalIT : KGPBaseTest() {
         buildResult: BuildResult,
         sources: List<Path>
     ) {
-        if (isIncrementalStubGenerationSupported) {
+        assertCompiledKotlinSources(
-            assertCompiledKotlinSources(
+            sources,
-                sources,
+            buildResult.getOutputForTask(":kaptGenerateStubsKotlin"),
-                buildResult.getOutputForTask(":kaptGenerateStubsKotlin"),
+            errorMessageSuffix = " in task 'kaptGenerateStubsKotlin"
-                errorMessageSuffix = " in task 'kaptGenerateStubsKotlin"
+        )
-            )
 
-
+        assertCompiledKotlinSources(
-            assertCompiledKotlinSources(
+            sources,
-                sources,
+            buildResult.getOutputForTask(":compileKotlin"),
-                buildResult.getOutputForTask(":compileKotlin"),
+            errorMessageSuffix = " in task 'compileKotlin'"
-                errorMessageSuffix = " in task 'compileKotlin'"
+        )
-            )
-        }
     }
 
     private fun BuildResult.assertKapt3FullyExecuted() {
@@ -398,17 +390,7 @@ open class KaptIncrementalIT : KGPBaseTest() {
     val TestProject.kaptGeneratedToPath get() = projectPath.resolve("build/generated/source/kapt")
 }
 
-@DisplayName("K2 Kapt incremental compilation")
-@OtherGradlePluginTests
-class K2KaptIncrementalIT: KaptIncrementalIT() {
-    override val defaultBuildOptions = super.defaultBuildOptions.copyEnsuringK2()
-}
-
 @DisplayName("Kapt incremental compilation with disabled precise compilation outputs backup")
 class KaptIncrementalWithoutPreciseBackupIT : KaptIncrementalIT() {
     override val defaultBuildOptions = super.defaultBuildOptions.copy(usePreciseOutputsBackup = false, keepIncrementalCompilationCachesInMemory = false)
-}
+}
-
-// KT-63102 Incremental compilation doesn't work in 2.0
-val TestProject.isIncrementalStubGenerationSupported: Boolean
-    get() = buildOptions.languageVersion?.startsWith("1") ?: (KotlinVersion.DEFAULT < KotlinVersion.KOTLIN_2_0)

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

@@ -20,7 +20,7 @@ import kotlin.io.path.writeText
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
-@DisplayName("K1 Kapt incremental tests with aggregating apt")
+@DisplayName("Kapt incremental tests with aggregating apt")
 open class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
 
     override val defaultBuildOptions = super.defaultBuildOptions.copy(
@@ -390,16 +390,8 @@ open class KaptIncrementalWithAggregatingApt : KaptIncrementalIT() {
     }
 }
 
-@DisplayName("K2 Kapt incremental tests with aggregating apt")
-class K2KaptIncrementalWithAggregatingApt: KaptIncrementalWithAggregatingApt() {
-    override val defaultBuildOptions = super.defaultBuildOptions.copyEnsuringK2()
-}
 
-@DisplayName("K1 Kapt incremental tests with aggregating apt with disabled precise compilation outputs backup")
+@DisplayName("Kapt incremental tests with aggregating apt with disabled precise compilation outputs backup")
-open class KaptIncrementalWithAggregatingAptAndWithoutPreciseBackup : KaptIncrementalWithAggregatingApt() {
+class KaptIncrementalWithAggregatingAptAndWithoutPreciseBackup : KaptIncrementalWithAggregatingApt() {
     override val defaultBuildOptions = super.defaultBuildOptions.copy(usePreciseOutputsBackup = false, keepIncrementalCompilationCachesInMemory = false)
-}
-
-class K2KaptIncrementalWithAggregatingAptAndWithoutPreciseBackup: KaptIncrementalWithAggregatingAptAndWithoutPreciseBackup() {
-    override val defaultBuildOptions = super.defaultBuildOptions.copyEnsuringK2()
 }

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

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.gradle.incapt.IncrementalBinaryIsolatingProcessor
 import org.jetbrains.kotlin.gradle.incapt.IncrementalProcessor
 import org.jetbrains.kotlin.gradle.incapt.IncrementalProcessorReferencingClasspath
 import org.jetbrains.kotlin.gradle.testbase.*
-import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.condition.DisabledOnOs
 import org.junit.jupiter.api.condition.OS
@@ -24,7 +23,7 @@ import java.util.zip.ZipOutputStream
 import kotlin.io.path.*
 import kotlin.test.assertEquals
 
-@DisplayName("K1 Kapt incremental tests with isolating apt")
+@DisplayName("Kapt incremental tests with isolating apt")
 open class KaptIncrementalWithIsolatingApt : KaptIncrementalIT() {
 
     override val defaultBuildOptions = super.defaultBuildOptions.copy(
@@ -34,7 +33,7 @@ open class KaptIncrementalWithIsolatingApt : KaptIncrementalIT() {
             incrementalKapt = true,
             includeCompileClasspath = false
         )
-    ).copyEnsuringK1()
+    )
 
     override fun KGPBaseTest.kaptProject(
         gradleVersion: GradleVersion,
@@ -319,16 +318,14 @@ open class KaptIncrementalWithIsolatingApt : KaptIncrementalIT() {
                 }
 
             build(":mylibrary:assembleDebug") {
-                if (isIncrementalStubGenerationSupported) {
+                assertEquals(
-                    assertEquals(
+                    listOf(
-                        listOf(
+                        "baseLibrary/build/tmp/kapt3/stubs/debug/error/NonExistentClass.java",
-                            "baseLibrary/build/tmp/kapt3/stubs/debug/error/NonExistentClass.java",
+                        "mylibrary/src/main/java/com/example/lib/ExampleParcel.java",
-                            "mylibrary/src/main/java/com/example/lib/ExampleParcel.java",
+                        "baseLibrary/src/main/java/com/example/lib2/basemodule/BaseClassParcel.java",
-                            "baseLibrary/src/main/java/com/example/lib2/basemodule/BaseClassParcel.java",
+                    ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
-                        ).map { projectPath.resolve(it).toRealPath().toString() }.toSet(),
+                    getProcessedSources(output)
-                        getProcessedSources(output)
+                )
-                    )
-                }
             }
         }
     }
@@ -440,21 +437,11 @@ open class KaptIncrementalWithIsolatingApt : KaptIncrementalIT() {
     }
 }
 
-@DisplayName("K2 Kapt incremental tests with isolating apt")
+@DisplayName("Kapt incremental tests with isolating apt with disabled precise compilation outputs backup")
-class K2KaptIncrementalWithIsolatingApt : KaptIncrementalWithIsolatingApt() {
+class KaptIncrementalWithIsolatingAptAndWithoutPreciseBackup : KaptIncrementalWithIsolatingApt() {
-    override val defaultBuildOptions = super.defaultBuildOptions.copyEnsuringK2()
-}
-
-@DisplayName("K1 Kapt incremental tests with isolating apt with disabled precise compilation outputs backup")
-open class KaptIncrementalWithIsolatingAptAndWithoutPreciseBackup : KaptIncrementalWithIsolatingApt() {
     override val defaultBuildOptions = super.defaultBuildOptions.copy(usePreciseOutputsBackup = false, keepIncrementalCompilationCachesInMemory = false)
 }
 
-@DisplayName("K2 Kapt incremental tests with isolating apt with disabled precise compilation outputs backup")
-class K2KaptIncrementalWithIsolatingAptAndWithoutPreciseBackup : KaptIncrementalWithIsolatingAptAndWithoutPreciseBackup() {
-    override val defaultBuildOptions = super.defaultBuildOptions.copyEnsuringK2()
-}
-
 private const val patternApt = "Processing java sources with annotation processors:"
 fun getProcessedSources(output: String): Set<String> {
     return output.lines().filter { it.contains(patternApt) }.flatMapTo(HashSet()) { logging ->

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

@@ -5,9 +5,15 @@
 
 package org.jetbrains.kotlin.gradle.android
 
+import org.jetbrains.kotlin.gradle.forceKapt4
+import org.jetbrains.kotlin.gradle.testbase.TestProject
 import org.junit.jupiter.api.DisplayName
 
 @DisplayName("android with kapt4 tests")
 class Kapt4AndroidIT : Kapt3AndroidIT() {
     override val defaultBuildOptions = super.defaultBuildOptions.copyEnsuringK2()
+
+    override fun TestProject.customizeProject() {
+        forceKapt4()
+    }
 }

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

@@ -14,7 +14,7 @@ import kotlin.io.path.deleteRecursively
 import kotlin.io.path.writeText
 
 @DisplayName("JVM API validation")
-open class KotlinJvmApiTest : KGPBaseTest() {
+class KotlinJvmApiTest : KGPBaseTest() {
     @DisplayName("Kotlin compilation can be set up using APIs")
     @JvmGradlePluginTests
     @GradleTest
@@ -51,7 +51,11 @@ open class KotlinJvmApiTest : KGPBaseTest() {
                         """.trimIndent()
             }
 
-            build("foo")
+            val expectedOutput = projectPath.resolve("build/fooOutput/Foo.class")
+
+            build("foo") {
+                assertFileExists(expectedOutput)
+            }
         }
     }
 
@@ -143,6 +147,7 @@ open class KotlinJvmApiTest : KGPBaseTest() {
                         """.trimIndent()
             }
 
+            val expectedOutputClass = projectPath.resolve("build/fooOutput/Foo.class")
             val expectedOutputStubs = listOf(
                 projectPath.resolve("build/fooOutputStubs/Foo.java"),
                 projectPath.resolve("build/fooOutputStubs/Foo.kapt_metadata"),
@@ -150,6 +155,7 @@ open class KotlinJvmApiTest : KGPBaseTest() {
             )
 
             build("foo") {
+                assertFileExists(expectedOutputClass)
                 expectedOutputStubs.forEach { assertFileExists(it) }
             }
         }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/Kapt3KotlinGradleSubplugin.kt

@@ -25,6 +25,7 @@ import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
 import org.jetbrains.kotlin.gradle.internal.Kapt3GradleSubplugin.Companion.isInfoAsWarnings
 import org.jetbrains.kotlin.gradle.internal.Kapt3GradleSubplugin.Companion.isKaptKeepKdocCommentsInStubs
 import org.jetbrains.kotlin.gradle.internal.Kapt3GradleSubplugin.Companion.isKaptVerbose
+import org.jetbrains.kotlin.gradle.internal.Kapt3GradleSubplugin.Companion.isUseK2
 import org.jetbrains.kotlin.gradle.model.builder.KaptModelBuilder
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJvmAndroidCompilation
@@ -122,6 +123,10 @@ class Kapt3GradleSubplugin @Inject internal constructor(private val registry: To
             return getBooleanOptionValue(BooleanOption.KAPT_KEEP_KDOC_COMMENTS_IN_STUBS)
         }
 
+        fun Project.isUseK2(): Boolean {
+            return getBooleanOptionValue(BooleanOption.KAPT_USE_K2)
+        }
+
         fun Project.classLoadersCacheSize(): Int = findPropertySafe(CLASSLOADERS_CACHE_SIZE)?.toString()?.toInt() ?: 0
 
         fun Project.disableClassloaderCacheForProcessors(): Set<String> {
@@ -213,6 +218,7 @@ class Kapt3GradleSubplugin @Inject internal constructor(private val registry: To
             KAPT_INFO_AS_WARNINGS("kapt.info.as.warnings", false),
             KAPT_INCLUDE_COMPILE_CLASSPATH("kapt.include.compile.classpath", true),
             KAPT_KEEP_KDOC_COMMENTS_IN_STUBS("kapt.keep.kdoc.comments.in.stubs", true),
+            KAPT_USE_K2("kapt.use.k2", false),
         }
     }
 
@@ -532,6 +538,7 @@ internal fun buildKaptSubpluginOptions(
     pluginOptions += SubpluginOption("keepKdocCommentsInStubs", "${project.isKaptKeepKdocCommentsInStubs()}")
     pluginOptions += SubpluginOption("showProcessorTimings", "${kaptExtension.showProcessorStats}")
     pluginOptions += SubpluginOption("detectMemoryLeaks", kaptExtension.detectMemoryLeaks)
+    pluginOptions += SubpluginOption("useK2", "${project.isUseK2()}")
     pluginOptions += SubpluginOption("infoAsWarnings", "${project.isInfoAsWarnings()}")
     pluginOptions += FilesSubpluginOption("stubs", kaptStubsDir)
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/KaptGenerateStubsTask.kt

@@ -29,7 +29,6 @@ import org.gradle.workers.WorkerExecutor
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompilerOptionsDefault
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompilerOptionsHelper
-import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilerArgumentsProducer.CreateCompilerArgumentsContext
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilerArgumentsProducer.CreateCompilerArgumentsContext.Companion.create
 import org.jetbrains.kotlin.gradle.report.BuildReportMode
@@ -67,6 +66,9 @@ abstract class KaptGenerateStubsTask @Inject constructor(
     @get:Input
     abstract val verbose: Property<Boolean>
 
+    @get:Input
+    abstract val useK2Kapt: Property<Boolean>
+
     /**
      * Changes in this additional sources will trigger stubs regeneration,
      * but the sources themselves will not be used to find kapt annotations and generate stubs.
@@ -127,6 +129,10 @@ abstract class KaptGenerateStubsTask @Inject constructor(
 
             args.verbose = verbose.get()
             args.destinationAsFile = destinationDirectory.get().asFile
+
+            if (useK2Kapt.get()) {
+                args.freeArgs += "-Xuse-kapt4"
+            }
         }
 
         pluginClasspath { args ->
@@ -148,5 +154,5 @@ abstract class KaptGenerateStubsTask @Inject constructor(
     }
 
     override fun isIncrementalCompilationEnabled(): Boolean =
-        super.isIncrementalCompilationEnabled() && compilerOptions.languageVersion.getOrElse(KotlinVersion.DEFAULT) < KotlinVersion.KOTLIN_2_0
+        super.isIncrementalCompilationEnabled() && !useK2Kapt.get() && ("-Xuse-kapt4" !in compilerOptions.freeCompilerArgs.get())
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/tasks/configuration/KaptGenerateStubsConfig.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinTopLevelExtension
 import org.jetbrains.kotlin.gradle.internal.*
 import org.jetbrains.kotlin.gradle.internal.Kapt3GradleSubplugin.Companion.KAPT_SUBPLUGIN_ID
 import org.jetbrains.kotlin.gradle.internal.Kapt3GradleSubplugin.Companion.isIncludeCompileClasspath
+import org.jetbrains.kotlin.gradle.internal.Kapt3GradleSubplugin.Companion.isUseK2
 import org.jetbrains.kotlin.gradle.plugin.KaptExtension
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationInfo
@@ -49,6 +50,7 @@ internal class KaptGenerateStubsConfig : BaseKotlinCompileConfig<KaptGenerateStu
         configureTask { task ->
             task.verbose.set(KaptTask.queryKaptVerboseProperty(project))
             task.pluginOptions.add(buildOptions(kaptExtension, task))
+            task.useK2Kapt.value(project.isUseK2()).finalizeValueOnRead()
 
             if (!isIncludeCompileClasspath(kaptExtension)) {
                 task.onlyIf {

libraries/tools/kotlin-maven-plugin-test/src/it/java8/test-dagger-maven-example/pom.xml

@@ -11,7 +11,7 @@
 
     <properties>
         <junit.version>4.13.1</junit.version>
-        <dagger.version>2.50</dagger.version>
+        <dagger.version>2.9</dagger.version>
         <main.class>coffee.CoffeeApp</main.class>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>

libraries/tools/kotlin-maven-plugin-test/src/it/java8/test-enable-extensions-kapt-allopen/pom.xml

@@ -11,7 +11,7 @@
 
     <properties>
         <junit.version>4.13.1</junit.version>
-        <dagger.version>2.50</dagger.version>
+        <dagger.version>2.9</dagger.version>
         <main.class>coffee.CoffeeApp</main.class>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>

libraries/tools/kotlin-maven-plugin-test/src/it/java8/test-kapt-allopen/pom.xml

@@ -11,7 +11,7 @@
 
     <properties>
         <junit.version>4.13.1</junit.version>
-        <dagger.version>2.50</dagger.version>
+        <dagger.version>2.9</dagger.version>
         <main.class>coffee.CoffeeApp</main.class>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>

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

@@ -107,6 +107,7 @@ private fun transformKaptToolArgs(args: List<String>, messageCollector: MessageC
             }
             KaptCliOption.APT_MODE_OPTION -> aptModePassed = true
             KaptCliOption.VERBOSE_MODE_OPTION -> kaptVerboseModePassed = true
+            KaptCliOption.USE_K2 -> transformed.add("-Xuse-kapt4")
             else -> {}
         }
 
@@ -114,7 +115,7 @@ private fun transformKaptToolArgs(args: List<String>, messageCollector: MessageC
     }
 
     if (!aptModePassed) {
-        val isK2 = ("-Xuse-k2" in transformed ||
+        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)

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

@@ -214,6 +214,13 @@ enum class KaptCliOption(
         "Keep KDoc comments in stubs"
     ),
 
+    USE_K2(
+        "useK2",
+        "true | false",
+        "Use K2",
+        cliToolOption = CliToolOption("-Kapt-use-k2", FLAG)
+    ),
+
     DETECT_MEMORY_LEAKS_OPTION("detectMemoryLeaks", "true | false", "Detect memory leaks in annotation processors"),
     INCLUDE_COMPILE_CLASSPATH(
         "includeCompileClasspath",

plugins/kapt3/kapt3-cli/testData/integration-kapt4/argfile/kaptArgs.txt

@@ -1,4 +1,5 @@
 -language-version 2.0
+-Xuse-kapt4
 -Kapt-mode=stubsAndApt
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes

plugins/kapt3/kapt3-cli/testData/integration-kapt4/compileModeUnsupported/build.txt

@@ -1,6 +1,7 @@
 # kapt
 -language-version 2.0
 -Xsuppress-version-warnings
+-Xuse-kapt4
 -Kapt-mode=compile
 ../simple/Test.kt
 

plugins/kapt3/kapt3-cli/testData/integration-kapt4/correctErrorTypesOn/build.txt

@@ -12,6 +12,7 @@ ap/Processor.kt
 
 # kapt
 -language-version 2.0
+-Xuse-kapt4
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes
 -Kapt-sources=output/sources

plugins/kapt3/kapt3-cli/testData/integration-kapt4/defaultPackage/build.txt

@@ -17,6 +17,7 @@ ap/Processor.kt
 
 # kapt
 -language-version 2.0
+-Xuse-kapt4
 -Kapt-mode=stubsAndApt
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes

plugins/kapt3/kapt3-cli/testData/integration-kapt4/kaptUseK2Flag/build.txt

@@ -1,6 +1,7 @@
 # kapt
 -language-version 2.0
 -Xsuppress-version-warnings
+-Kapt-use-k2=true
 -Kapt-mode=compile
 ../simple/Test.kt
 

plugins/kapt3/kapt3-cli/testData/integration-kapt4/kotlinFileGeneration/build.txt

@@ -17,6 +17,7 @@ output/ap/META-INF/services/javax.annotation.processing.Processor
 
 # kapt
 -language-version 2.0
+-Xuse-kapt4
 -Kapt-mode=stubsAndApt
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes

plugins/kapt3/kapt3-cli/testData/integration-kapt4/kotlinFileGenerationDefaultOutput/build.txt

@@ -20,6 +20,7 @@ ap/Processor.kt
 
 # kapt
 -language-version 2.0
+-Xuse-kapt4
 -Kapt-mode=stubsAndApt
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes
@@ -33,6 +34,7 @@ Test.kt
 
 # kotlinc
 -language-version 2.0
+-Xuse-kapt4
 -d output/classes
 -cp output/classes:output/ap:%KOTLIN_STDLIB%
 Test.kt

plugins/kapt3/kapt3-cli/testData/integration-kapt4/kt33800/build.txt

@@ -21,6 +21,7 @@ output/ap/META-INF/services/javax.annotation.processing.Processor
 
 # kapt
 -language-version 2.0
+-Xuse-kapt4
 -Kapt-mode=stubsAndApt
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes

plugins/kapt3/kapt3-cli/testData/integration-kapt4/multipass/build.txt

@@ -13,6 +13,7 @@ ap/processors.kt
 
 # kapt
 -language-version 2.0
+-Xuse-kapt4
 -Kapt-mode=stubsAndApt
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes

plugins/kapt3/kapt3-cli/testData/integration-kapt4/separateStubAptCompilation/build.txt

@@ -21,6 +21,7 @@ ap/Processor.kt
 
 # kapt
 -language-version 2.0
+-Xuse-kapt4
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes
 -Kapt-sources=output/sources
@@ -32,6 +33,7 @@ Test.kt
 
 # kapt
 -language-version 2.0
+-Xuse-kapt4
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes
 -Kapt-sources=output/sources

plugins/kapt3/kapt3-cli/testData/integration-kapt4/simple/build.txt

@@ -17,6 +17,7 @@ output/ap/META-INF/services/javax.annotation.processing.Processor
 
 # kapt
 -language-version 2.0
+-Xuse-kapt4
 -Kapt-mode=stubsAndApt
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes

plugins/kapt3/kapt3-cli/testData/integration-kapt4/withoutService/build.txt

@@ -21,6 +21,7 @@ ap/Processor.kt
 
 # kapt
 -language-version 2.0
+-Xuse-kapt4
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes
 -Kapt-sources=output/sources

plugins/kapt3/kapt3-cli/testData/integration/argfile/kaptArgs.txt

@@ -1,4 +1,3 @@
--language-version 1.9
 -Kapt-stubs=output/stubs
 -Kapt-classes=output/classes
 -Kapt-sources=output/sources

plugins/kapt3/kapt3-cli/testData/integration/fallback/Test.kt

@@ -0,0 +1,19 @@
+package test
+
+import apt.Anno
+import generated.Test as TestGenerated
+
+@Anno
+class Test {
+    @field:Anno
+    val property: String = ""
+
+    @Anno
+    fun function() {
+
+    }
+}
+
+fun main() {
+    println("Generated class: " + TestGenerated::class.java.name)
+}

plugins/kapt3/kapt3-cli/testData/integration/fallback/ap/META-INF/services/javax.annotation.processing.Processor

@@ -0,0 +1 @@
+apt.SampleApt

plugins/kapt3/kapt3-cli/testData/integration/fallback/ap/Processor.kt

@@ -0,0 +1,34 @@
+package apt
+
+import javax.annotation.processing.*
+import javax.lang.model.SourceVersion
+import javax.lang.model.element.TypeElement
+import javax.tools.Diagnostic.Kind.*
+import javax.tools.StandardLocation
+
+annotation class Anno
+
+class SampleApt : AbstractProcessor() {
+    override fun process(annotations: Set<TypeElement>, roundEnv: RoundEnvironment): Boolean {
+        val writeKotlinFiles = processingEnv.options["kapt.test.writeKotlinFiles"] == "true"
+
+        for (element in roundEnv.getElementsAnnotatedWith(Anno::class.java)) {
+            val generatedSimpleName = element.simpleName.toString().capitalize()
+
+            val file = when (writeKotlinFiles) {
+                true -> processingEnv.filer.createResource(StandardLocation.SOURCE_OUTPUT, "generated", "$generatedSimpleName.kt")
+                false -> processingEnv.filer.createSourceFile("generated.$generatedSimpleName")
+            }
+
+            file.openWriter().use {
+                it.write("package generated;\npublic class $generatedSimpleName {}")
+            }
+        }
+
+        return true
+    }
+
+    override fun getSupportedOptions() = setOf("kapt.test.writeKotlinFiles")
+    override fun getSupportedSourceVersion() = SourceVersion.RELEASE_8
+    override fun getSupportedAnnotationTypes() = setOf("apt.Anno")
+}

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

@@ -0,0 +1,69 @@
+# mkdir
+output/stubs
+output/classes
+output/javaClasses
+output/sources
+output/stubsAlt
+output/classesAlt
+output/javaClassesAlt
+output/sourcesAlt
+
+# kotlinc
+-language-version 2.0
+-cp %KOTLIN_STDLIB%
+-d output/ap.jar
+ap/Processor.kt
+
+# copy
+ap/META-INF/services/javax.annotation.processing.Processor
+output/ap/META-INF/services/javax.annotation.processing.Processor
+
+# kapt
+-Xuse-k2
+-Kapt-stubs=output/stubs
+-Kapt-classes=output/classes
+-Kapt-sources=output/sources
+-Kapt-classpath=output/ap
+-d output/classes
+-cp output/ap.jar:%KOTLIN_STDLIB%
+Test.kt
+
+# javac
+-cp output/ap.jar
+-d output/javaClasses
+-proc:none
+output/sources/generated/Function.java
+output/sources/generated/Property.java
+output/sources/generated/Test.java
+
+# kapt
+-language-version 2.0
+-Kapt-stubs=output/stubsAlt
+-Kapt-classes=output/classesAlt
+-Kapt-sources=output/sourcesAlt
+-Kapt-classpath=output/ap
+-d output/classesAlt
+-cp output/ap.jar:%KOTLIN_STDLIB%
+Test.kt
+
+# output
+warning: kapt currently doesn't support language version 2.0+. Falling back to 1.9.
+
+# java
+-cp output/classes:output/javaClasses:output/ap.jar:%KOTLIN_STDLIB%
+test.TestKt
+
+# javac
+-cp output/ap.jar
+-d output/javaClassesAlt
+-proc:none
+output/sourcesAlt/generated/Function.java
+output/sourcesAlt/generated/Property.java
+output/sourcesAlt/generated/Test.java
+
+# java
+-cp output/classes:output/javaClassesAlt:output/ap.jar:%KOTLIN_STDLIB%
+test.TestKt
+
+# after
+Generated class: generated.Test

plugins/kapt3/kapt3-cli/tests-gen/org/jetbrains/kotlin/kapt/cli/test/KaptToolIntegrationTestGenerated.java

@@ -48,6 +48,12 @@ public class KaptToolIntegrationTestGenerated extends AbstractKaptToolIntegratio
         runTest("plugins/kapt3/kapt3-cli/testData/integration/defaultPackage/");
     }
 
+    @Test
+    @TestMetadata("fallback")
+    public void testFallback() throws Exception {
+        runTest("plugins/kapt3/kapt3-cli/testData/integration/fallback/");
+    }
+
     @Test
     @TestMetadata("kotlinFileGeneration")
     public void testKotlinFileGeneration() throws Exception {

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

@@ -123,6 +123,7 @@ class Kapt3CommandLineProcessor : CommandLineProcessor {
             STRICT_MODE_OPTION -> setFlag(KaptFlag.STRICT, value)
             STRIP_METADATA_OPTION -> setFlag(KaptFlag.STRIP_METADATA, value)
             KEEP_KDOC_COMMENTS_IN_STUBS -> setFlag(KaptFlag.KEEP_KDOC_COMMENTS_IN_STUBS, value)
+            USE_K2 -> {}
 
             SHOW_PROCESSOR_STATS -> setFlag(KaptFlag.SHOW_PROCESSOR_STATS, value)
             DUMP_PROCESSOR_STATS -> processorsStatsReportFile = File(value)