Downgrade to Kotlin 2.1.10

compiler-plugin/build.gradle.kts

@@ -66,7 +66,6 @@ dependencies {
     testRuntimeOnly("org.junit.platform:junit-platform-suite:$junitPlatformVersion")
     testImplementation("org.jetbrains.kotlin:kotlin-compiler:$kotlinBaseVersion")
     testImplementation("org.jetbrains.kotlin:kotlin-compiler-internal-test-framework:$kotlinBaseVersion")
-    testImplementation("org.jetbrains.kotlin:analysis-api-test-framework:$kotlinBaseVersion")
     testImplementation(project(":test-utils"))
 
     libsForTesting(kotlin("stdlib", kotlinBaseVersion))

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

@@ -46,16 +46,13 @@ 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
@@ -167,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.
@@ -534,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/main/kotlin/com/google/devtools/ksp/processing/impl/ResolverImpl.kt

@@ -56,10 +56,10 @@ import com.intellij.psi.*
 import com.intellij.psi.impl.source.PsiClassReferenceType
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
+import org.jetbrains.kotlin.codegen.ClassBuilderMode
+import org.jetbrains.kotlin.codegen.OwnerKind
 import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
-import org.jetbrains.kotlin.config.ApiVersion
-import org.jetbrains.kotlin.config.LanguageVersion
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
@@ -147,8 +147,9 @@ class ResolverImpl(
 
     private val moduleIdentifier = module.name.getNonSpecialIdentifier()
     private val typeMapper = KotlinTypeMapper(
+        BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES,
         moduleIdentifier,
-        LanguageVersionSettingsImpl(LanguageVersion.KOTLIN_1_9, ApiVersion.KOTLIN_1_9),
+        KotlinTypeMapper.LANGUAGE_VERSION_SETTINGS_DEFAULT, // TODO use proper LanguageVersionSettings
         true
     )
     private val qualifiedExpressionResolver = QualifiedExpressionResolver(LanguageVersionSettingsImpl.DEFAULT)
@@ -892,13 +893,17 @@ class ResolverImpl(
 
     @KspExperimental
     override fun getJvmName(accessor: KSPropertyAccessor): String? {
-        return resolvePropertyAccessorDeclaration(accessor)?.let(typeMapper::mapFunctionName)
+        return resolvePropertyAccessorDeclaration(accessor)?.let {
+            typeMapper.mapFunctionName(it, OwnerKind.IMPLEMENTATION)
+        }
     }
 
     @KspExperimental
     override fun getJvmName(declaration: KSFunctionDeclaration): String? {
         // function names might be mangled if they receive inline class parameters or they are internal
-        return (resolveFunctionDeclaration(declaration) as? FunctionDescriptor)?.let(typeMapper::mapFunctionName)
+        return (resolveFunctionDeclaration(declaration) as? FunctionDescriptor)?.let {
+            typeMapper.mapFunctionName(it, OwnerKind.IMPLEMENTATION)
+        }
     }
 
     @KspExperimental

compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/kotlin/KSAnnotationImpl.kt

@@ -103,7 +103,6 @@ class KSAnnotationImpl private constructor(val ktAnnotationEntry: KtAnnotationEn
             CONSTRUCTOR_PARAMETER -> AnnotationUseSiteTarget.PARAM
             SETTER_PARAMETER -> AnnotationUseSiteTarget.SETPARAM
             PROPERTY_DELEGATE_FIELD -> AnnotationUseSiteTarget.DELEGATE
-            ALL -> null
         }
     }
 

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

@@ -22,9 +22,6 @@ import com.intellij.openapi.Disposable
 import com.intellij.openapi.project.Project
 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 +58,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
     }
 }
@@ -124,11 +121,9 @@ abstract class AbstractKSPTest(frontend: FrontendKind<*>) : DisposableTest() {
         useAdditionalService<TemporaryDirectoryManager>(::TemporaryDirectoryManagerImpl)
         useAdditionalService<ApplicationDisposableProvider> { ExecutionListenerBasedDisposableProvider() }
         useAdditionalService<KotlinStandardLibrariesPathProvider> { StandardLibrariesPathProviderForKotlinProject }
-        useAdditionalService<TargetPlatformProvider>(::TargetPlatformProviderForAnalysisApiTests)
 
         useDirectives(*AbstractKotlinCompilerTest.defaultDirectiveContainers.toTypedArray())
         useDirectives(JvmEnvironmentConfigurationDirectives)
-        useDirectives(TargetPlatformDirectives)
 
         defaultDirectives {
             +JvmEnvironmentConfigurationDirectives.FULL_JDK
@@ -168,7 +163,7 @@ abstract class AbstractKSPTest(frontend: FrontendKind<*>) : DisposableTest() {
     open fun compileModule(module: TestModule, testServices: TestServices) {
         val javaFiles = module.writeJavaFiles()
         val compilerConfiguration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module)
-        val dependencies = module.allDependencies.map { outDirForModule(it.dependencyModule.name) }
+        val dependencies = module.allDependencies.map { outDirForModule(it.moduleName) }
         compilerConfiguration.addJvmClasspathRoots(dependencies)
         compilerConfiguration.addJavaSourceRoot(module.javaDir)
 
@@ -190,7 +185,7 @@ abstract class AbstractKSPTest(frontend: FrontendKind<*>) : DisposableTest() {
             "-classpath", classpath,
             "-d", module.outDir.path
         )
-        compileJavaFiles(javaFiles, options)
+        compileJavaFiles(javaFiles, options, assertions = JUnit5Assertions)
     }
 
     fun runTest(@TestDataFile path: String) {
@@ -201,8 +196,8 @@ abstract class AbstractKSPTest(frontend: FrontendKind<*>) : DisposableTest() {
             path,
             testConfiguration.directives,
         )
-        val dependencyProvider = ArtifactsProvider(testServices, moduleStructure.modules)
-        testServices.registerArtifactsProvider(dependencyProvider)
+        val dependencyProvider = DependencyProviderImpl(testServices, moduleStructure.modules)
+        testServices.registerDependencyProvider(dependencyProvider)
         testServices.register(TestModuleStructure::class, moduleStructure)
 
         val mainModule = moduleStructure.modules.last()

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-745
+kotlinBaseVersion=2.1.10
 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.0.20
-buildKspVersion=2.0.20-1.0.25
+buildKspVersion=2.0.20-1.0.25