Merged branch idea251.release into idea251.x

Author: builduser

scala/compile-server/src/org/jetbrains/jps/incremental/scala/remote/Main.scala

@@ -12,7 +12,6 @@ import org.jetbrains.plugins.scala.compiler.data.{Arguments, ComputeStampsArgume
 import org.jetbrains.plugins.scala.server.CompileServerToken
 
 import java.io.{IOException, PrintStream}
-import java.lang.reflect.Method
 import java.net.URLClassLoader
 import java.nio.charset.StandardCharsets
 import java.nio.file.{Files, Path}
@@ -226,23 +225,69 @@ object Main {
     server.compileDocument(arguments, client)
   }
 
-  private val expressionCompilerCache: Cache[Seq[Path], (AnyRef, Method)] = new Cache(3)
+  private val classLoaderCache: Cache[Seq[Path], ClassLoader] = new Cache(3)
 
   private def evaluateExpressionLogic(args: ExpressionEvaluationArguments, client: Client): Unit = {
-    val ExpressionEvaluationArguments(outDir, classpath, scalacOptions, source, line, expression, localVariableNames, packageName) = args
-
-    val (instance, method) = expressionCompilerCache.getOrUpdate(classpath) { () =>
-      val classLoader = new URLClassLoader(classpath.map(_.toUri.toURL).toArray, this.getClass.getClassLoader)
-      val bridgeClass = Class.forName("dotty.tools.dotc.ExpressionCompilerBridge", true, classLoader)
-      val instance = bridgeClass.getDeclaredConstructor().newInstance().asInstanceOf[AnyRef]
-      val method = bridgeClass.getMethods.find(_.getName == "run").get
-      (instance, method)
+    val ExpressionEvaluationArguments(useBuiltInExpressionCompiler, outDir, classpath, scalacOptions, source, line, expression, localVariableNames, packageName) = args
+
+    val classLoader = classLoaderCache.getOrUpdate(classpath) { () =>
+      new URLClassLoader(classpath.map(_.toUri.toURL).toArray, this.getClass.getClassLoader)
     }
 
+    val bridgeClassName =
+      if (useBuiltInExpressionCompiler) "dotty.tools.debug.ExpressionCompilerBridge"
+      else "dotty.tools.dotc.ExpressionCompilerBridge"
+
+    val bridgeClass = Class.forName(bridgeClassName, true, classLoader)
+    val bridgeInstance = bridgeClass.getDeclaredConstructor().newInstance().asInstanceOf[AnyRef]
+    val runMethod = bridgeClass.getMethods.find(_.getName == "run").get
+
     val consumer: java.util.function.Consumer[String] = client.error(_)
+    val expressionClassName = "CompiledExpression"
+    val classpathString = classpath.mkString(java.io.File.pathSeparator)
+    val scalacOptionsArray = scalacOptions.toArray
+    val localVariableNamesJavaSet = localVariableNames.asJava
+
+    if (useBuiltInExpressionCompiler) {
+      val config = assembleExpressionCompilerConfig(classLoader, packageName, expressionClassName, line, expression, localVariableNamesJavaSet, consumer)
+      runMethod.invoke(bridgeInstance, outDir, classpathString, scalacOptionsArray, source, config)
+    } else {
+      runMethod.invoke(bridgeInstance, outDir, expressionClassName, classpathString, scalacOptionsArray, source, line,
+        expression, localVariableNamesJavaSet, packageName, consumer, true)
+    }
+  }
+
+  private def assembleExpressionCompilerConfig(
+    classLoader: ClassLoader,
+    packageName: String,
+    outputClassName: String,
+    breakpointLine: Int,
+    expression: String,
+    localVariables: java.util.Set[String],
+    errorReporter: java.util.function.Consumer[String]
+  ): AnyRef = {
+    val configClass = Class.forName("dotty.tools.debug.ExpressionCompilerConfig", true, classLoader)
+    var configInstance = configClass.getDeclaredConstructor().newInstance().asInstanceOf[AnyRef]
+
+    val withPackageNameMethod = configClass.getDeclaredMethod("withPackageName", classOf[String])
+    configInstance = withPackageNameMethod.invoke(configInstance, packageName)
+
+    val withOutputClassNameMethod = configClass.getDeclaredMethod("withOutputClassName", classOf[String])
+    configInstance = withOutputClassNameMethod.invoke(configInstance, outputClassName)
+
+    val withBreakpointLineMethod = configClass.getDeclaredMethod("withBreakpointLine", classOf[Int])
+    configInstance = withBreakpointLineMethod.invoke(configInstance, breakpointLine)
+
+    val withExpressionMethod = configClass.getDeclaredMethod("withExpression", classOf[String])
+    configInstance = withExpressionMethod.invoke(configInstance, expression)
+
+    val withLocalVariablesMethod = configClass.getDeclaredMethod("withLocalVariables", classOf[java.util.Set[String]])
+    configInstance = withLocalVariablesMethod.invoke(configInstance, localVariables)
+
+    val withErrorReporterMethod = configClass.getDeclaredMethod("withErrorReporter", classOf[java.util.function.Consumer[String]])
+    configInstance = withErrorReporterMethod.invoke(configInstance, errorReporter)
 
-    method.invoke(instance, outDir, "CompiledExpression", classpath.mkString(java.io.File.pathSeparator), scalacOptions.toArray, source, line,
-      expression, localVariableNames.asJava, packageName, consumer, false)
+    configInstance
   }
 
   private def getMetricsLogic(client: Client): Unit = {

scala/compiler-shared/src/org/jetbrains/plugins/scala/compiler/data/ExpressionEvaluationArguments.scala

@@ -5,6 +5,7 @@ import org.jetbrains.jps.incremental.scala.Extractor
 import java.nio.file.Path
 
 case class ExpressionEvaluationArguments(
+  useBuiltInExpressionCompiler: Boolean,
   outDir: Path,
   classpath: Seq[Path],
   scalacOptions: Seq[String],
@@ -18,6 +19,7 @@ case class ExpressionEvaluationArguments(
 
   def asStrings: Seq[String] =
     Seq(
+      useBuiltInExpressionCompiler.toString,
       pathToString(outDir),
       pathsToString(classpath),
       sequenceToString(scalacOptions),
@@ -34,6 +36,7 @@ object ExpressionEvaluationArguments {
 
   def parse(strings: Seq[String]): Option[ExpressionEvaluationArguments] = strings match {
     case Seq(
+      s2b(useBuiltInExpressionCompiler),
       StringToPath(outDir),
       StringToPaths(classpath),
       StringToSequence(scalacOptions),
@@ -43,10 +46,12 @@ object ExpressionEvaluationArguments {
       stringToSet(localVariableNames),
       packageName
     ) =>
-      Some(ExpressionEvaluationArguments(outDir, classpath, scalacOptions, source, line, expression, localVariableNames, packageName))
+      Some(ExpressionEvaluationArguments(useBuiltInExpressionCompiler, outDir, classpath, scalacOptions, source, line, expression, localVariableNames, packageName))
     case _ => None
   }
 
+  private val s2b: Extractor[String, Boolean] = _.toBoolean
+
   private val stringToSet: Extractor[String, Set[String]] = StringToSequence.andThen(_.toSet)(_)
 
   private val s2i: Extractor[String, Int] = _.toInt

scala/debugger/src/org/jetbrains/plugins/scala/debugger/evaluation/ExpressionCompilerResolverListener.scala

@@ -6,7 +6,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Key
 import org.jetbrains.plugins.scala.DependencyManagerBase.RichStr
 import org.jetbrains.plugins.scala.debugger.DebuggerBundle
-import org.jetbrains.plugins.scala.project.{ModuleExt, ProjectExt}
+import org.jetbrains.plugins.scala.project.{ModuleExt, ProjectExt, ScalaLanguageLevel}
 import org.jetbrains.plugins.scala.{DependencyManagerBase, ScalaVersion}
 
 import java.nio.file.Path
@@ -29,13 +29,13 @@ private final class ExpressionCompilerResolverListener(project: Project) extends
             .flatMap(_.scalaMinorVersion)
             .filter(_.isScala3)
             .flatMap { v =>
-              resolveExpressionCompilerJar(v, indicator) match {
-                case Some(jar) => Some(v -> jar)
-                case None => None
-              }
+              if (v.languageLevel >= ScalaLanguageLevel.Scala_3_7)
+                Some(v -> ExpressionCompilerType.BuiltIn)
+              else
+                resolveExpressionCompilerJar(v, indicator).map(jar => v -> ExpressionCompilerType.ResolvedJar(jar))
             }.toMap
         } catch {
-          case NonFatal(_) => Map.empty[ScalaVersion, Path]
+          case NonFatal(_) => Map.empty[ScalaVersion, ExpressionCompilerType]
         }
 
         project.putUserData(ExpressionCompilers, expressionCompilers)
@@ -53,7 +53,23 @@ private final class ExpressionCompilerResolverListener(project: Project) extends
 }
 
 private object ExpressionCompilerResolverListener {
-  final val ExpressionCompilers: Key[Map[ScalaVersion, Path]] = Key.create("scala_debugger_expression_compilers")
+
+  sealed trait ExpressionCompilerType
+  object ExpressionCompilerType {
+    /**
+     * Scala 3.7 ships the debugger expression compiler as part of the scala3-compiler.jar. We do not need to manually
+     * resolve a separate expression compiler jar.
+     */
+    case object BuiltIn extends ExpressionCompilerType
+
+    /**
+     * Scala 3.0 to Scala 3.6 use a separate jar which hosts the debugger expression compiler which needs to be
+     * manually resolved.
+     */
+    case class ResolvedJar(path: Path) extends ExpressionCompilerType
+  }
+
+  final val ExpressionCompilers: Key[Map[ScalaVersion, ExpressionCompilerType]] = Key.create("scala_debugger_expression_compilers")
 
   final val ScalaExpressionCompilerVersion = "4.2.4"
 }

scala/debugger/src/org/jetbrains/plugins/scala/debugger/evaluation/evaluator/ExpressionCompilerEvaluator.scala

@@ -48,14 +48,18 @@ private[evaluation] final class ExpressionCompilerEvaluator(codeFragment: PsiEle
         throw EvaluationException(DebuggerBundle.message("could.not.determine.scala.version", module.getName))
     }
 
-    val expressionCompilerJar = {
+    val expressionCompilerType = {
       import ExpressionCompilerResolverListener.{ExpressionCompilers, ScalaExpressionCompilerVersion}
-      context.getProject.getUserData(ExpressionCompilers).get(scalaVersion) match {
-        case Some(jar) => jar
-        case None =>
-          throw EvaluationException(DebuggerBundle.message("could.not.resolve.scala.expression.compiler", ScalaExpressionCompilerVersion, scalaVersion.minor))
-      }
+      context.getProject.getUserData(ExpressionCompilers)
+        .getOrElse(scalaVersion, throw EvaluationException(DebuggerBundle.message("could.not.resolve.scala.expression.compiler", ScalaExpressionCompilerVersion, scalaVersion.minor)))
+    }
+
+    import ExpressionCompilerResolverListener.ExpressionCompilerType
+    val expressionCompilerJar = expressionCompilerType match {
+      case ExpressionCompilerType.BuiltIn => Seq.empty
+      case ExpressionCompilerType.ResolvedJar(path) => Seq(path)
     }
+    val useBuiltInExpressionCompiler = expressionCompilerType == ExpressionCompilerType.BuiltIn
 
     try {
       def stripJarPathSuffix(path: String): String =
@@ -64,7 +68,7 @@ private[evaluation] final class ExpressionCompilerEvaluator(codeFragment: PsiEle
       val enumerator = OrderEnumerator.orderEntries(module).compileOnly().recursively()
       val classpath =
         module.scalaCompilerClasspath ++
-          enumerator.getClassesRoots.map(_.getCanonicalPath).map(stripJarPathSuffix).map(Path.of(_)) :+
+          enumerator.getClassesRoots.map(_.getCanonicalPath).map(stripJarPathSuffix).map(Path.of(_)) ++
           expressionCompilerJar
       val scalacOptions = module.scalaCompilerSettings.getOptionsAsStrings(module.hasScala3)
       val source = Path.of(position.getFile.getVirtualFile.getCanonicalPath)
@@ -81,7 +85,7 @@ private[evaluation] final class ExpressionCompilerEvaluator(codeFragment: PsiEle
       val thisObject = stackFrame.thisObject()
 
       val packageName = inReadAction(ScalaPositionManager.findPackageName(position.getElementAt)).getOrElse("")
-      val arguments = ExpressionEvaluationArguments(outDir, classpath, scalacOptions, source, line, expression, localVariableNames.toSet, packageName)
+      val arguments = ExpressionEvaluationArguments(useBuiltInExpressionCompiler, outDir, classpath, scalacOptions, source, line, expression, localVariableNames.toSet, packageName)
 
       val errors = Seq.newBuilder[NlsString]
       val client = new DummyClient() {