[Gradle] Use custom classloader and ServiceLoader to load bt-api implementation

#KT-57397 Fixed

compiler/build-tools/build-tools-api/api/build-tools-api.api

@@ -1,4 +1,14 @@
-public abstract interface class org/jetbrains/kotlin/buildtools/api/CompilationFacade {
+public abstract interface class org/jetbrains/kotlin/buildtools/api/CompilationService {
+	public static final field Companion Lorg/jetbrains/kotlin/buildtools/api/CompilationService$Companion;
 	public abstract fun compile ()V
+	public static fun loadImplementation (Ljava/lang/ClassLoader;)Lorg/jetbrains/kotlin/buildtools/api/CompilationService;
+}
+
+public final class org/jetbrains/kotlin/buildtools/api/CompilationService$Companion {
+	public final fun loadImplementation (Ljava/lang/ClassLoader;)Lorg/jetbrains/kotlin/buildtools/api/CompilationService;
+}
+
+public final class org/jetbrains/kotlin/buildtools/api/SharedApiClassesClassLoader {
+	public static final fun newInstance ()Ljava/lang/ClassLoader;
 }
 

compiler/build-tools/build-tools-api/src/main/kotlin/org/jetbrains/kotlin/buildtools/api/CompilationService.kt

@@ -11,4 +11,9 @@ package org.jetbrains.kotlin.buildtools.api
  */
 interface CompilationService {
     fun compile()
+
+    companion object {
+        @JvmStatic
+        fun loadImplementation(classLoader: ClassLoader) = loadImplementation(CompilationService::class, classLoader)
+    }
 }

compiler/build-tools/build-tools-api/src/main/kotlin/org/jetbrains/kotlin/buildtools/api/SharedApiClassesClassLoader.kt

@@ -0,0 +1,44 @@
+/*
+ * 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.
+ */
+@file:JvmName("SharedApiClassesClassLoader")
+
+package org.jetbrains.kotlin.buildtools.api
+
+import java.util.*
+import kotlin.reflect.KClass
+
+/**
+ * Creates a [ClassLoader] which reuses the API classes from the ClassLoader which loaded the API.
+ * This way an API implementation can be loaded with almost fully isolated classpath, sharing only the classes from `org.jetbrains.kotlin.buildtools.api`,
+ * so a caller still able to pass API parameters in a compatible way.
+ */
+@Suppress("FunctionName")
+@JvmName("newInstance")
+fun SharedApiClassesClassLoader(): ClassLoader = SharedApiClassesClassLoaderImpl(
+    SharedApiClassesClassLoaderImpl::class.java.classLoader,
+    ClassLoader.getSystemClassLoader(),
+    SharedApiClassesClassLoaderImpl::class.java.`package`.name,
+)
+
+internal fun <T : Any> loadImplementation(cls: KClass<T>, classLoader: ClassLoader): T {
+    val implementations = ServiceLoader.load(cls.java, classLoader)
+    implementations.firstOrNull() ?: error("The classpath contains no implementation for ${cls.qualifiedName}")
+    return implementations.singleOrNull()
+        ?: error("The classpath contains more than one implementation for ${cls.qualifiedName}")
+}
+
+private class SharedApiClassesClassLoaderImpl(
+    private val parent: ClassLoader,
+    fallback: ClassLoader,
+    private val allowedPackage: String,
+) : ClassLoader(fallback) {
+    override fun loadClass(name: String, resolve: Boolean): Class<*> {
+        return if (name.startsWith(allowedPackage)) {
+            parent.loadClass(name)
+        } else {
+            super.loadClass(name, resolve)
+        }
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/compilerRunner/btapi/BuildToolsApiCompilationWork.kt

@@ -11,9 +11,13 @@ import org.gradle.api.provider.Property
 import org.gradle.workers.WorkAction
 import org.gradle.workers.WorkParameters
 import org.jetbrains.kotlin.build.report.metrics.BuildMetricsReporter
+import org.jetbrains.kotlin.buildtools.api.CompilationService
+import org.jetbrains.kotlin.buildtools.api.SharedApiClassesClassLoader
 import org.jetbrains.kotlin.compilerRunner.GradleKotlinCompilerWorkArguments
 import org.jetbrains.kotlin.gradle.internal.ClassLoadersCachingBuildService
+import org.jetbrains.kotlin.gradle.internal.ParentClassLoaderProvider
 import java.io.File
+import java.util.*
 
 internal abstract class BuildToolsApiCompilationWork : WorkAction<BuildToolsApiCompilationWork.BuildToolsApiCompilationParameters> {
     internal interface BuildToolsApiCompilationParameters : WorkParameters {
@@ -29,6 +33,17 @@ internal abstract class BuildToolsApiCompilationWork : WorkAction<BuildToolsApiC
         get() = parameters.compilerWorkArguments.get()
 
     override fun execute() {
-        println("I'm simulating compilation, the compilation classpath would be ${workArguments.compilerFullClasspath}")
+        val classLoader = parameters.classLoadersCachingService.get()
+            .getClassLoader(workArguments.compilerFullClasspath, SharedApiClassesClassLoaderProvider)
+        val compilationService = CompilationService.loadImplementation(classLoader)
+        compilationService.compile()
     }
+}
+
+private object SharedApiClassesClassLoaderProvider : ParentClassLoaderProvider {
+    override fun getClassLoader() = SharedApiClassesClassLoader()
+
+    override fun hashCode() = SharedApiClassesClassLoaderProvider::class.hashCode()
+
+    override fun equals(other: Any?) = other is SharedApiClassesClassLoaderProvider
 }