Support new CompilerPluginRegistrar in 1.8.0 and K2 plugins

Author: tschuchortdev

core/src/main/kotlin/com/tschuchort/compiletesting/AbstractKotlinCompilation.kt

@@ -11,15 +11,15 @@ import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
 import org.jetbrains.kotlin.cli.js.K2JSCompiler
 import org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.util.ServiceLoaderLite
 import java.io.File
 import java.io.OutputStream
 import java.io.PrintStream
-import java.lang.reflect.InvocationTargetException
-import java.lang.reflect.ReflectPermission
 import java.net.URI
 import java.nio.file.Files
 import java.nio.file.Paths
@@ -29,6 +29,7 @@ import java.nio.file.Paths
  * functionality. Should not be used outside of this library as it is an
  * implementation detail.
  */
+@ExperimentalCompilerApi
 abstract class AbstractKotlinCompilation<A : CommonCompilerArguments> internal constructor() {
     /** Working directory for the compilation */
     var workingDir: File by default {
@@ -49,10 +50,29 @@ abstract class AbstractKotlinCompilation<A : CommonCompilerArguments> internal c
      */
     var pluginClasspaths: List<File> = emptyList()
 
+
+    @Suppress("DEPRECATION")
+    @Deprecated(
+        "Renamed to componentRegistrars due to introduction of CompilerPluginRegistrar",
+        ReplaceWith("componentRegistrars"),
+        DeprecationLevel.ERROR
+    )
+    var compilerPlugins: List<ComponentRegistrar> = emptyList()
+
+
+
+    /**
+     * Legacy compiler plugins that should be added to the compilation.
+     * This option will be removed in the future; you should migrate to [CompilerPluginRegistrar].
+     */
+    @Suppress("DEPRECATION")
+    @Deprecated("Deprecated in Kotlin compiler. Migrate to compilerPluginRegistrars instead")
+    var componentRegistrars: List<ComponentRegistrar> = emptyList()
+
     /**
      * Compiler plugins that should be added to the compilation
      */
-    var compilerPlugins: List<ComponentRegistrar> = emptyList()
+    var compilerPluginRegistrars: List<CompilerPluginRegistrar> = emptyList()
 
     /**
      * Commandline processors for compiler plugins that should be added to the compilation
@@ -115,6 +135,9 @@ abstract class AbstractKotlinCompilation<A : CommonCompilerArguments> internal c
         HostEnvironment.kotlinStdLibCommonJar
     }
 
+    /** Enable support for the new K2 compiler. */
+    var supportsK2 = false
+
     // Directory for input source files
     protected val sourcesDir get() = workingDir.resolve("sources")
 
@@ -188,11 +211,14 @@ abstract class AbstractKotlinCompilation<A : CommonCompilerArguments> internal c
          * To avoid that the annotation processors are executed twice,
          * the list is set to empty
          */
-        MainComponentRegistrar.threadLocalParameters.set(
-            MainComponentRegistrar.ThreadLocalParameters(
+        @Suppress("DEPRECATION")
+        MainComponentAndPluginRegistrar.threadLocalParameters.set(
+            MainComponentAndPluginRegistrar.ThreadLocalParameters(
                 listOf(),
                 KaptOptions.Builder(),
-                compilerPlugins
+                componentRegistrars,
+                compilerPluginRegistrars,
+                supportsK2
             )
         )
 
@@ -207,14 +233,15 @@ abstract class AbstractKotlinCompilation<A : CommonCompilerArguments> internal c
                 } else {
                     emptyList()
                 }
+            @Suppress("DEPRECATION")
             args.pluginClasspaths = (args.pluginClasspaths ?: emptyArray()) +
                     /** The resources path contains the MainComponentRegistrar and MainCommandLineProcessor which will
                      be found by the Kotlin compiler's service loader. We add it only when the user has actually given
                      us ComponentRegistrar instances to be loaded by the MainComponentRegistrar because the experimental
                      K2 compiler doesn't support plugins yet. This way, users of K2 can prevent MainComponentRegistrar
-                     from being loaded and crashing K2 by setting both [compilerPlugins] and [commandLineProcessors] to
-                     the emptyList. */
-                    if (compilerPlugins.isNotEmpty() || commandLineProcessors.isNotEmpty())
+                     from being loaded and crashing K2 by setting both [componentRegistrars] and [commandLineProcessors]
+                     and [compilerPluginRegistrars] to the emptyList. */
+                    if (componentRegistrars.union(compilerPluginRegistrars).union(commandLineProcessors).isNotEmpty())
                         arrayOf(getResourcesPath())
                     else emptyArray()
         }
@@ -229,7 +256,7 @@ abstract class AbstractKotlinCompilation<A : CommonCompilerArguments> internal c
     }
 
     protected fun getResourcesPath(): String {
-        val resourceName = "META-INF/services/org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar"
+        val resourceName = "META-INF/services/org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar"
         return this::class.java.classLoader.getResources(resourceName)
             .asSequence()
             .mapNotNull { url ->
@@ -241,9 +268,9 @@ abstract class AbstractKotlinCompilation<A : CommonCompilerArguments> internal c
                 }.toAbsolutePath()
             }
             .find { resourcesPath ->
-                ServiceLoaderLite.findImplementations(ComponentRegistrar::class.java, listOf(resourcesPath.toFile()))
-                    .any { implementation -> implementation == MainComponentRegistrar::class.java.name }
-            }?.toString() ?: throw AssertionError("Could not get path to ComponentRegistrar service from META-INF")
+                ServiceLoaderLite.findImplementations(CompilerPluginRegistrar::class.java, listOf(resourcesPath.toFile()))
+                    .any { implementation -> implementation == MainComponentAndPluginRegistrar::class.java.name }
+            }?.toString() ?: throw AssertionError("Could not get path to CompilerPluginRegistrar service from META-INF")
     }
 
     /** Searches compiler log for known errors that are hard to debug for the user */
@@ -298,7 +325,6 @@ abstract class AbstractKotlinCompilation<A : CommonCompilerArguments> internal c
 
 internal fun convertKotlinExitCode(code: ExitCode) = when(code) {
     ExitCode.OK -> KotlinCompilation.ExitCode.OK
-    ExitCode.OOM_ERROR,
     ExitCode.INTERNAL_ERROR -> KotlinCompilation.ExitCode.INTERNAL_ERROR
     ExitCode.COMPILATION_ERROR -> KotlinCompilation.ExitCode.COMPILATION_ERROR
     ExitCode.SCRIPT_EXECUTION_ERROR -> KotlinCompilation.ExitCode.SCRIPT_EXECUTION_ERROR

core/src/main/kotlin/com/tschuchort/compiletesting/KaptComponentRegistrar.kt

@@ -43,12 +43,14 @@ import org.jetbrains.kotlin.kapt3.base.LoadedProcessors
 import org.jetbrains.kotlin.kapt3.base.incremental.IncrementalProcessor
 import org.jetbrains.kotlin.kapt3.base.util.KaptLogger
 import org.jetbrains.kotlin.kapt3.util.MessageCollectorBackedKaptLogger
+import org.jetbrains.kotlin.kapt3.util.doOpenInternalPackagesIfRequired
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.resolve.jvm.extensions.PartialAnalysisHandlerExtension
 import java.io.File
 
+@Suppress("DEPRECATION")
 internal class KaptComponentRegistrar(
     private val processors: List<IncrementalProcessor>,
     private val kaptOptions: KaptOptions.Builder
@@ -58,6 +60,8 @@ internal class KaptComponentRegistrar(
         if (processors.isEmpty())
             return
 
+        doOpenInternalPackagesIfRequired()
+
         val contentRoots = configuration[CLIConfigurationKeys.CONTENT_ROOTS] ?: emptyList()
 
         val optionsBuilder = kaptOptions.apply {

core/src/main/kotlin/com/tschuchort/compiletesting/KotlinCompilation.kt

@@ -91,21 +91,9 @@ class KotlinCompilation : AbstractKotlinCompilation<K2JVMCompilerArguments>() {
 	/** Don't generate not-null assertions on parameters of methods accessible from Java */
 	var noParamAssertions: Boolean = false
 
-	/** Generate nullability assertions for non-null Java expressions */
-	@Deprecated("Removed in latest Kotlin version")
-	var strictJavaNullabilityAssertions: Boolean? = null
-
 	/** Disable optimizations */
 	var noOptimize: Boolean = false
 
-	/**
-	 * Normalize constructor calls (disable: don't normalize; enable: normalize),
-	 * default is 'disable' in language version 1.2 and below, 'enable' since language version 1.3
-	 *
-	 * {disable|enable}
-	 */
-	@Deprecated("Removed in latest Kotlin version")
-	var constructorCallNormalizationMode: String? = null
 
 	/** Assert calls behaviour {always-enable|always-disable|jvm|legacy} */
 	var assertionsMode: String? = JVMAssertionsMode.DEFAULT.description
@@ -119,9 +107,6 @@ class KotlinCompilation : AbstractKotlinCompilation<K2JVMCompilerArguments>() {
 	/** Use type table in metadata serialization */
 	var useTypeTable: Boolean = false
 
-	/** Allow Kotlin runtime libraries of incompatible versions in the classpath */
-	@Deprecated("Removed in latest Kotlin version")
-	var skipRuntimeVersionCheck: Boolean? = null
 
 	/** Path to JSON file to dump Java to Kotlin declaration mappings */
 	var declarationsOutputPath: File? = null
@@ -144,9 +129,6 @@ class KotlinCompilation : AbstractKotlinCompilation<K2JVMCompilerArguments>() {
 	 */
 	var supportCompatqualCheckerFrameworkAnnotations: String? = null
 
-	/** Do not throw NPE on explicit 'equals' call for null receiver of platform boxed primitive type */
-	@Deprecated("Removed in latest Kotlin version")
-	var noExceptionOnExplicitEqualsForBoxedNull: Boolean? = null
 
 	/** Allow to use '@JvmDefault' annotation for JVM default method support.
 	 * {disable|enable|compatibility}
@@ -330,17 +312,8 @@ class KotlinCompilation : AbstractKotlinCompilation<K2JVMCompilerArguments>() {
 		args.noParamAssertions = noParamAssertions
 		args.noReceiverAssertions = noReceiverAssertions
 
-		// TODO: Remove after kotlin 1.6.30
-		if(strictJavaNullabilityAssertions != null)
-			args.trySetDeprecatedOption("strictJavaNullabilityAssertions", strictJavaNullabilityAssertions)
-
 		args.noOptimize = noOptimize
 
-		// TODO: Remove after kotlin 1.6.30
-		if(constructorCallNormalizationMode != null)
-			args.trySetDeprecatedOption("constructorCallNormalizationMode", constructorCallNormalizationMode)
-
-
 		if(assertionsMode != null)
 			args.assertionsMode = assertionsMode
 
@@ -370,14 +343,6 @@ class KotlinCompilation : AbstractKotlinCompilation<K2JVMCompilerArguments>() {
 		if(scriptResolverEnvironment.isNotEmpty())
 			args.scriptResolverEnvironment = scriptResolverEnvironment.map { (key, value) -> "$key=\"$value\"" }.toTypedArray()
 
-		// TODO: Remove after kotlin 1.6.30
-		if(noExceptionOnExplicitEqualsForBoxedNull != null)
-			args.trySetDeprecatedOption("noExceptionOnExplicitEqualsForBoxedNull", noExceptionOnExplicitEqualsForBoxedNull)
-
-		// TODO: Remove after kotlin 1.6.30
-		if(skipRuntimeVersionCheck != null)
-			args.trySetDeprecatedOption("skipRuntimeVersionCheck", skipRuntimeVersionCheck)
-
         args.javaPackagePrefix = javaPackagePrefix
         args.suppressMissingBuiltinsError = suppressMissingBuiltinsError
 	}
@@ -418,11 +383,14 @@ class KotlinCompilation : AbstractKotlinCompilation<K2JVMCompilerArguments>() {
 		 *  any parameters that change between compilations
 		 *
 		 */
-		MainComponentRegistrar.threadLocalParameters.set(
-				MainComponentRegistrar.ThreadLocalParameters(
+		@Suppress("DEPRECATION")
+		MainComponentAndPluginRegistrar.threadLocalParameters.set(
+				MainComponentAndPluginRegistrar.ThreadLocalParameters(
 					annotationProcessors.map { IncrementalProcessor(it, DeclaredProcType.NON_INCREMENTAL, kaptLogger) },
 					kaptOptions,
-					compilerPlugins
+					componentRegistrars,
+					compilerPluginRegistrars,
+					supportsK2
 				)
 		)
 
@@ -653,7 +621,7 @@ class KotlinCompilation : AbstractKotlinCompilation<K2JVMCompilerArguments>() {
 					return makeResult(exitCode)
 				}
 			} finally {
-				MainComponentRegistrar.threadLocalParameters.remove()
+				MainComponentAndPluginRegistrar.threadLocalParameters.remove()
 			}
 
 			// step 3: compile Kotlin files

core/src/main/kotlin/com/tschuchort/compiletesting/KotlinJsCompilation.kt

@@ -19,7 +19,7 @@ class KotlinJsCompilation : AbstractKotlinCompilation<K2JSCompilerArguments>() {
   var irProduceKlibFile: Boolean = false
 
   /** Generates JS file using IR backend. Also disables pre-IR backend */
-  var irProduceJs: Boolean = false
+  var irProduceJs: Boolean = true
 
   /** Perform experimental dead code elimination */
   var irDce: Boolean = false
@@ -28,7 +28,7 @@ class KotlinJsCompilation : AbstractKotlinCompilation<K2JSCompilerArguments>() {
   var irDcePrintReachabilityInfo: Boolean = false
 
   /** Disables pre-IR backend */
-  var irOnly: Boolean = false
+  var irOnly: Boolean = true
 
   /** Specify a compilation module name for IR backend */
   var irModuleName: String? = null

core/src/main/kotlin/com/tschuchort/compiletesting/MainComponentAndPluginRegistrar.kt

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.tschuchort.compiletesting
+
+import com.google.auto.service.AutoService
+import org.jetbrains.kotlin.base.kapt3.KaptOptions
+import org.jetbrains.kotlin.com.intellij.mock.MockProject
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
+import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.kapt3.base.incremental.IncrementalProcessor
+
+@Suppress("DEPRECATION")
+@AutoService(ComponentRegistrar::class, CompilerPluginRegistrar::class)
+internal class MainComponentAndPluginRegistrar : ComponentRegistrar, CompilerPluginRegistrar() {
+
+    override val supportsK2: Boolean
+        get() = safeGetThreadLocalParameters(logCallerName = "supportsK2")?.supportsK2 ?: false
+
+    // Handle unset parameters gracefully because this plugin may be accidentally called by other tools that
+    // discover it on the classpath (for example the kotlin jupyter kernel).
+    private fun safeGetThreadLocalParameters(logCallerName: String): ThreadLocalParameters? {
+        val params = threadLocalParameters.get()
+        if (params == null) {
+            System.err.println("WARNING: ${MainComponentAndPluginRegistrar::class.simpleName}::$logCallerName accessed before thread local parameters have been set.")
+        }
+
+        return params
+    }
+
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
+        val parameters = safeGetThreadLocalParameters(logCallerName = "registerExtensions") ?: return
+
+        parameters.compilerPluginRegistrars.forEach { pluginRegistrar ->
+            with(pluginRegistrar) {
+                registerExtensions(configuration)
+            }
+        }
+    }
+
+    // Legacy plugins
+    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+        val parameters = safeGetThreadLocalParameters(logCallerName = "registerProjectComponents") ?: return
+
+        /*
+         * The order of registering plugins here matters. If the kapt plugin is registered first, then
+         * it will be executed first and any changes made to the AST by later plugins won't apply to the
+         * generated stub files and thus won't be visible to any annotation processors. So we decided
+         * to register third-party plugins before kapt and hope that it works, although we don't
+         * know for sure if that is the correct way.
+         */
+        parameters.componentRegistrars.forEach { componentRegistrar ->
+            componentRegistrar.registerProjectComponents(project, configuration)
+        }
+
+        KaptComponentRegistrar(parameters.processors, parameters.kaptOptions)
+            .registerProjectComponents(project, configuration)
+    }
+
+
+    companion object {
+        /** This compiler plugin is instantiated by K2JVMCompiler using
+         *  a service locator. So we can't just pass parameters to it easily.
+         *  Instead, we need to use a thread-local global variable to pass
+         *  any parameters that change between compilations
+         */
+        val threadLocalParameters: ThreadLocal<ThreadLocalParameters> = ThreadLocal()
+    }
+
+    data class ThreadLocalParameters(
+        val processors: List<IncrementalProcessor>,
+        val kaptOptions: KaptOptions.Builder,
+        @Deprecated("Remove once ComponentRegistrar is deprecated with error")
+        val componentRegistrars: List<ComponentRegistrar>,
+        val compilerPluginRegistrars: List<CompilerPluginRegistrar>,
+        val supportsK2: Boolean
+    )
+}