Merge branch '1.11.x' into wip/merge-1.11.x

internal/util-core/src/main/scala/sbt/internal/util/Util.scala

@@ -13,7 +13,7 @@ import java.util.Locale
 
 import scala.collection.concurrent.TrieMap
 import scala.reflect.Selectable.reflectiveSelectable
-import scala.util.control.NonFatal
+import scala.util.Properties
 
 object Util:
   def makeList[T](size: Int, value: T): List[T] = List.fill(size)(value)
@@ -96,17 +96,7 @@ object Util:
   def reduceIntents[A1, A2](intents: PartialFunction[A1, A2]*): PartialFunction[A1, A2] =
     intents.toList.reduceLeft(_ orElse _)
 
-  lazy val majorJavaVersion: Int =
+  lazy val isJava19Plus: Boolean = Properties.isJavaAtLeast("19")
-    try {
-      val javaVersion = sys.props.get("java.version").getOrElse("1.0")
-      if (javaVersion.startsWith("1.")) {
-        javaVersion.split("\\.")(1).toInt
-      } else {
-        javaVersion.split("\\.")(0).toInt
-      }
-    } catch {
-      case NonFatal(_) => 0
-    }
 
   private type GetId = {
     def getId: Long
@@ -121,13 +111,10 @@ object Util:
    * https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Thread.html#threadId()
    */
   def threadId: Long =
-    if (majorJavaVersion < 19) {
+    if !isJava19Plus then
-      (Thread.currentThread(): AnyRef) match {
+      (Thread.currentThread(): AnyRef) match
         case g: GetId @unchecked => g.getId
-      }
+    else
-    } else {
+      (Thread.currentThread(): AnyRef) match
-      (Thread.currentThread(): AnyRef) match {
         case g: ThreadId @unchecked => g.threadId
-      }
-    }
 end Util

run/src/main/scala/sbt/Run.scala

@@ -20,7 +20,7 @@ import sbt.util.Logger
 
 import scala.sys.process.Process
 import scala.util.control.NonFatal
-import scala.util.{ Failure, Success, Try }
+import scala.util.{ Failure, Properties, Success, Try }
 
 sealed trait ScalaRun:
   def run(mainClass: String, classpath: Seq[NioPath], options: Seq[String], log: Logger): Try[Unit]
@@ -93,7 +93,7 @@ class Run(private[sbt] val newLoader: Seq[NioPath] => ClassLoader, trapExit: Boo
     def execute(): Unit =
       try {
         log.debug("  Classpath:\n\t" + classpath.mkString("\n\t"))
-        val main = getMainMethod(mainClass, loader)
+        val main = detectMainMethod(mainClass, loader)
         invokeMain(loader, main, options)
       } catch {
         case e: java.lang.reflect.InvocationTargetException =>
@@ -141,14 +141,22 @@ class Run(private[sbt] val newLoader: Seq[NioPath] => ClassLoader, trapExit: Boo
   }
   private def invokeMain(
       loader: ClassLoader,
-      main: Method,
+      main: DetectedMain,
       options: Seq[String]
   ): Unit = {
     val currentThread = Thread.currentThread
     val oldLoader = Thread.currentThread.getContextClassLoader
     currentThread.setContextClassLoader(loader)
     try {
-      main.invoke(null, options.toArray[String]); ()
+      if (main.isStatic) {
+        if (main.parameterCount > 0) main.method.invoke(null, options.toArray[String])
+        else main.method.invoke(null)
+      } else {
+        val ref = main.mainClass.getDeclaredConstructor().newInstance().asInstanceOf[AnyRef]
+        if (main.parameterCount > 0) main.method.invoke(ref, options.toArray[String])
+        else main.method.invoke(ref)
+      }
+      ()
     } catch {
       case t: Throwable =>
         t.getCause match {
@@ -164,19 +172,40 @@ class Run(private[sbt] val newLoader: Seq[NioPath] => ClassLoader, trapExit: Boo
       currentThread.setContextClassLoader(oldLoader)
     }
   }
-  def getMainMethod(mainClassName: String, loader: ClassLoader) = {
+  def getMainMethod(mainClassName: String, loader: ClassLoader): Method =
+    detectMainMethod(mainClassName, loader).method
+
+  private def detectMainMethod(mainClassName: String, loader: ClassLoader) = {
     val mainClass = Class.forName(mainClassName, true, loader)
-    val method = mainClass.getMethod("main", classOf[Array[String]])
+    if (Run.isJava25Plus) {
-    // jvm allows the actual main class to be non-public and to run a method in the non-public class,
+      val method =
-    //  we need to make it accessible
+        try {
-    method.setAccessible(true)
+          mainClass.getMethod("main", classOf[Array[String]])
-    val modifiers = method.getModifiers
+        } catch {
-    if (!isPublic(modifiers))
+          case _: NoSuchMethodException => mainClass.getMethod("main")
-      throw new NoSuchMethodException(mainClassName + ".main is not public")
+        }
-    if (!isStatic(modifiers))
+      method.setAccessible(true)
-      throw new NoSuchMethodException(mainClassName + ".main is not static")
+      val modifiers = method.getModifiers
-    method
+      DetectedMain(mainClass, method, isStatic(modifiers), method.getParameterCount())
+    } else {
+      val method = mainClass.getMethod("main", classOf[Array[String]])
+      // jvm allows the actual main class to be non-public and to run a method in the non-public class,
+      //  we need to make it accessible
+      method.setAccessible(true)
+      val modifiers = method.getModifiers
+      if (!isPublic(modifiers))
+        throw new NoSuchMethodException(mainClassName + ".main is not public")
+      if (!isStatic(modifiers))
+        throw new NoSuchMethodException(mainClassName + ".main is not static")
+      DetectedMain(mainClass, method, isStatic = true, method.getParameterCount())
+    }
   }
+  private case class DetectedMain(
+      mainClass: Class[?],
+      method: Method,
+      isStatic: Boolean,
+      parameterCount: Int
+  )
 }
 
 /** This module is an interface to starting the scala interpreter or runner. */
@@ -207,4 +236,6 @@ object Run:
           s"""nonzero exit code returned from $label: $exitCode""".stripMargin
         )
       )
+
+  private[sbt] lazy val isJava25Plus: Boolean = Properties.isJavaAtLeast("25")
 end Run

sbt-app/src/sbt-test/run/jep-512/A.scala

@@ -0,0 +1,7 @@
+package example
+
+class A {
+  def main(): Unit = {
+    println("hi")
+  }
+}

sbt-app/src/sbt-test/run/jep-512/build.sbt

@@ -0,0 +1,11 @@
+// 2.12.x uses Zinc's compiler bridge
+ThisBuild / scalaVersion := "2.12.20"
+
+@transient
+lazy val check = taskKey[Unit]("")
+
+check := {
+  if (scala.util.Properties.isJavaAtLeast("25"))
+    (Compile / run).toTask(" ").value
+  else ()
+}

sbt-app/src/sbt-test/run/jep-512/test

@@ -0,0 +1,2 @@
+# > run
+> check