update scala3-sbt-bridge from 3.0.0-M2 to 3.0.0, fix LinkageError #SCL-18861 fixed

In Scala 3.0.0-RC1 in sbt-bridge they moved to new compiler interface `xsbti.CompilerInterface2`.

Before Scala 3.0.0-RC1 `xsbt.CompilerClassLoader` was used. It resolved `xsbti.*` classes (e.g. xsbti.AnalysisCallback) to the classes from the CompileServer classloader (more specifically, they were taken from `zincRepackaged` aka `incremental-compiler.jar`).
`compiler-interface.jar` is also included into Scala 3 compiler classpath. But it was simply ignored, because the classes were already loaded by the parent classloader.

After Scala 3.0.0-RC1 `sbt.internal.inc.classpath.DualLoader` is used.
(see sbt.internal.inc.AnalyzingCompiler.compile, see also sbt.internal.inc.AnalyzingCompiler.createDualLoader)
`parentA` loader represents the compiler classloader.
Scala3 compiler uses `xsbti.*` classes directly so it so it's loader needs to resolve the those classes. And they should be resolved to the same classes used in the Compile Server.

Before this commit, the classes were resolved to the `compiler-interface` jar file in the compile classpath itself.
This caused the LinkageError.
To avoid those we delegate all `xsbti.*` classes loading to the SCS classlader.

Closely related links:
- [`[sbt-bridge] Upgrade to CompilerInterface2`](scala/scala3@5185d4d)
- [`[sbt-dotty] Use sbt loader as parent of scala instance loader #10541`](scala/scala3#10541)

Author: unkarjedy

project/dependencies.scala

@@ -112,7 +112,7 @@ object Dependencies {
   val compilerBridgeSources_2_10 = "org.scala-sbt" % "compiler-bridge_2.10" % zincVersion classifier "sources"
   val compilerBridgeSources_2_11 = "org.scala-sbt" % "compiler-bridge_2.11" % zincVersion classifier "sources"
   val compilerBridgeSources_2_13 = "org.scala-sbt" % "compiler-bridge_2.13" % zincVersion classifier "sources"
-  val scala3SbtBridge = "org.scala-lang" % "scala3-sbt-bridge" % "3.0.0-M2"
+  val scala3SbtBridge = "org.scala-lang" % "scala3-sbt-bridge" % "3.0.0"
 
   // "provided" danger: we statically depend on a single version, but need to support all the version
   // some part of our code is now statically dependent on lib classes, another part uses reflections for other versions

scala/compiler-jps/src/org/jetbrains/jps/incremental/scala/local/CompilerFactoryImpl.scala

@@ -80,7 +80,22 @@ object CompilerFactoryImpl {
   private def createScalaInstance(jars: CompilerJars) = {
     def createClassLoader(paths: Seq[File]) = {
       val urls = Path.toURLs(paths)
-      val newClassloader = new URLClassLoader(urls, ClasspathUtil.rootLoader)
+
+      // NOTE: it's required for only for Scala3 compilation, cause they moved to `xsbti.CompilerInterface2`
+      // We need to use same compile-interface classes in the Scala3 compiler and Scala Compile Server
+      // (see commit message for the details  SCL-18861)
+      val isXbtiClass = (className: String) => className.startsWith("xsbti.")
+      val isNotXbtiClass = (className: String) => !isXbtiClass(className)
+      val delegatingToCompilerInterfaceLoader = new classpath.DualLoader(
+        classOf[xsbti.AnalysisCallback].getClassLoader, // any class from compiler-interface
+        isXbtiClass,
+        _ => false,
+        ClasspathUtil.rootLoader,
+        isNotXbtiClass,
+        _ => true
+      )
+
+      val newClassloader = new URLClassLoader(urls, delegatingToCompilerInterfaceLoader)
 
       classLoadersMap += paths -> newClassloader