Downgrade to Kotlin 2.1.20

Author: mkmuir0

compiler-plugin/src/main/kotlin/com/google/devtools/ksp/KotlinSymbolProcessingExtension.kt

@@ -46,21 +46,17 @@ import com.google.devtools.ksp.symbol.Visibility
 import com.google.devtools.ksp.symbol.impl.java.KSFileJavaImpl
 import com.google.devtools.ksp.symbol.impl.kotlin.KSFileImpl
 import com.intellij.openapi.Disposable
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.application.runWriteAction
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiJavaFile
 import com.intellij.psi.PsiManager
 import com.intellij.psi.impl.file.impl.JavaFileManager
-import com.intellij.util.ui.EDT
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCliJavaFileManagerImpl
 import org.jetbrains.kotlin.config.JvmAnalysisFlags
-import org.jetbrains.kotlin.config.JvmDefaultMode
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.context.ProjectContext
@@ -168,10 +164,8 @@ abstract class AbstractKotlinSymbolProcessingExtension(
         logger.logging("round $rounds of processing")
         val psiManager = PsiManager.getInstance(project)
         if (initialized) {
-            maybeRunInWriteAction {
-                psiManager.dropPsiCaches()
-                psiManager.dropResolveCaches()
-            }
+            psiManager.dropPsiCaches()
+            psiManager.dropResolveCaches()
             invalidateKotlinCliJavaFileManagerCache(project)
         } else {
             // In case of broken builds.
@@ -512,9 +506,7 @@ fun findTargetInfos(languageVersionSettings: LanguageVersionSettings, module: Mo
             is JdkPlatform -> JvmPlatformInfoImpl(
                 platformName = platform.platformName,
                 jvmTarget = platform.targetVersion.toString(),
-                jvmDefaultMode =
-                (languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode) ?: JvmDefaultMode.ENABLE)
-                    .description
+                jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode).description
             )
             is JsPlatform -> JsPlatformInfoImpl(
                 platformName = platform.platformName
@@ -537,20 +529,3 @@ private fun invalidateKotlinCliJavaFileManagerCache(project: Project): Boolean {
     (privateCacheField.get(javaFileManager) as? MutableMap<*, *>)?.clear() ?: return false
     return true
 }
-
-private fun <R> maybeRunInWriteAction(f: () -> R) {
-    synchronized(EDT::class.java) {
-        if (!EDT.isCurrentThreadEdt()) {
-            val edt = EDT::class.java.getDeclaredField("myEventDispatchThread")
-            edt.isAccessible = true
-            edt.set(null, Thread.currentThread())
-        }
-        if (ApplicationManager.getApplication() != null) {
-            runWriteAction {
-                f()
-            }
-        } else {
-            f()
-        }
-    }
-}

compiler-plugin/src/test/kotlin/com/google/devtools/ksp/test/AbstractKSPTest.kt

@@ -24,7 +24,6 @@ import com.intellij.openapi.util.Disposer
 import com.intellij.testFramework.TestDataFile
 import org.jetbrains.kotlin.analysis.test.framework.services.TargetPlatformDirectives
 import org.jetbrains.kotlin.analysis.test.framework.services.TargetPlatformProviderForAnalysisApiTests
-import org.jetbrains.kotlin.cli.common.disposeRootInWriteAction
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoot
@@ -61,13 +60,13 @@ abstract class DisposableTest {
     protected val disposable: Disposable get() = _disposable!!
 
     @BeforeEach
-    fun initDisposable(testInfo: TestInfo) {
+    private fun initDisposable(testInfo: TestInfo) {
         _disposable = Disposer.newDisposable("disposable for ${testInfo.displayName}")
     }
 
     @AfterEach
-    fun disposeDisposable() {
-        _disposable?.let { disposeRootInWriteAction(it) }
+    private fun disposeDisposable() {
+        _disposable?.let { Disposer.dispose(it) }
         _disposable = null
     }
 }

gradle-plugin/src/main/kotlin/com/google/devtools/ksp/gradle/KotlinFactories.kt

@@ -215,6 +215,7 @@ abstract class KspTaskJvm @Inject constructor(
             sources,
             javaSources,
             commonSourceSet,
+            classpathSnapshotProperties.classpath,
             classpathStructure,
         )
 

gradle-plugin/src/main/kotlin/com/google/devtools/ksp/gradle/KspAATask.kt

@@ -38,7 +38,6 @@ import org.gradle.work.NormalizeLineEndings
 import org.gradle.workers.WorkAction
 import org.gradle.workers.WorkParameters
 import org.gradle.workers.WorkerExecutor
-import org.jetbrains.kotlin.gradle.dsl.JvmDefaultMode
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompilerOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
@@ -283,20 +282,11 @@ abstract class KspAATask @Inject constructor(
                             cfg.jdkVersion.value(it.toInt())
                         }
 
-                        val oldJvmDefaultMode = compilerOptions.freeCompilerArgs
+                        val jvmDefaultMode = compilerOptions.freeCompilerArgs
                             .map { args -> args.filter { it.startsWith("-Xjvm-default=") } }
-                            .map { it.lastOrNull()?.substringAfter("=") ?: "undefined" }
-
-                        cfg.jvmDefaultMode.value(
-                            project.provider {
-                                when (oldJvmDefaultMode.get()) {
-                                    "all" -> "no-compatibility"
-                                    "all-compatibility" -> "enable"
-                                    "disable" -> "disable"
-                                    else -> compilerOptions.jvmDefault.getOrElse(JvmDefaultMode.ENABLE).compilerArgument
-                                }
-                            }
-                        )
+                            .map { it.lastOrNull()?.substringAfter("=") ?: "disable" }
+
+                        cfg.jvmDefaultMode.value(jvmDefaultMode)
 
                         cfg.jvmTarget.value(compilerOptions.jvmTarget.map { it.target })
 

gradle-plugin/src/main/kotlin/com/google/devtools/ksp/gradle/KspSubplugin.kt

@@ -481,6 +481,11 @@ class KspGradleSubplugin @Inject internal constructor(private val registry: Tool
                             configureAsAbstractKotlinCompileTool(kspTask as AbstractKotlinCompileTool<*>)
                             configurePluginOptions(kspTask)
                             configureLanguageVersion(kspTask)
+                            if (kspTask.classpathSnapshotProperties.useClasspathSnapshot.get() == false) {
+                                kspTask.compilerOptions.moduleName.convention(
+                                    kotlinCompileTask.compilerOptions.moduleName.map { "$it-ksp" }
+                                )
+                            }
 
                             kspTask.destination.value(kspOutputDir)
 

gradle.properties

@@ -1,9 +1,9 @@
 # Copied from kotlinc
 org.gradle.jvmargs=-Duser.country=US -Dkotlin.daemon.jvm.options=-Xmx4096m -Dfile.encoding=UTF-8
 
-kotlinBaseVersion=2.2.0-dev-15683
+kotlinBaseVersion=2.1.20
 agpBaseVersion=8.10.0-alpha03
-intellijVersion=241.19416.19
+intellijVersion=233.13135.128
 junitVersion=4.13.1
 junit5Version=5.8.2
 junitPlatformVersion=1.8.2
@@ -25,4 +25,4 @@ kotlin.jvm.target.validation.mode=warning
 
 # Build or runtime dependencies of this project
 buildKotlinVersion=2.1.20
-buildKspVersion=2.1.20-1.0.32
+buildKspVersion=2.1.20-1.0.32

integration-tests/src/test/kotlin/com/google/devtools/ksp/test/PlaygroundIT.kt

@@ -310,7 +310,7 @@ class PlaygroundIT(val useKSP2: Boolean) {
         val gradleRunner = GradleRunner.create().withProjectDir(project.root)
         gradleRunner.buildAndCheck("clean", "build") { result ->
             Assert.assertTrue(result.output.contains("platform: JVM"))
-            Assert.assertTrue(result.output.contains("jvm default mode: no-compatibility"))
+            Assert.assertTrue(result.output.contains("jvm default mode: all"))
         }
         project.restore(buildFile.path)
     }