Merge pull request #1602 from eed3si9n/bport/jdk25-main

[1.x] Support JDK 25 JEP-512/JEP-445 Main class

Author: eed3si9n

.github/workflows/ci.yml

@@ -12,27 +12,35 @@ jobs:
         include:
           - os: ubuntu-latest
             java: 8
+            distribution: zulu
             jobtype: 1
           - os: ubuntu-latest
             java: 11
+            distribution: temurin
             jobtype: 1
           - os: ubuntu-latest
             java: 21
+            distribution: zulu
             jobtype: 1
           - os: windows-latest
             java: 8
+            distribution: zulu
             jobtype: 2
           - os: ubuntu-latest
             java: 21
+            distribution: temurin
             jobtype: 3
           - os: ubuntu-latest
             java: 21
+            distribution: temurin
             jobtype: 4
           - os: ubuntu-latest
             java: 21
+            distribution: temurin
             jobtype: 5
           - os: ubuntu-latest
             java: 21
+            distribution: temurin
             jobtype: 6
     runs-on: ${{ matrix.os }}
     steps:

build.sbt

@@ -46,7 +46,7 @@ ThisBuild / version := {
   nightlyVersion match {
     case Some(v) => v
     case _ =>
-      if ((ThisBuild / isSnapshot).value) "1.10.6-SNAPSHOT"
+      if ((ThisBuild / isSnapshot).value) "1.11.0-SNAPSHOT"
       else old
   }
 }

internal/compiler-bridge/src/main/scala/xsbt/ExtractAPI.scala

@@ -80,6 +80,18 @@ class ExtractAPI[GlobalType <: Global](
   private[this] val allNonLocalClassSymbols = perRunCaches.newSet[Symbol]()
   private[this] val allNonLocalClassesInSrc = perRunCaches.newSet[xsbti.api.ClassLike]()
   private[this] val _mainClasses = perRunCaches.newSet[String]()
+  private[this] val javaVersion: Int =
+    try {
+      val version = sys.props("java.specification.version").split("\\.").toList.map(_.toInt)
+      version match {
+        case 1 :: minor :: _ => minor
+        case major :: _      => major
+        case _               => 0
+      }
+    } catch {
+      case _: Throwable => 0
+    }
+  private[this] def isJava25Plus: Boolean = javaVersion >= 25
 
   /**
    * Implements a work-around for https://github.com/sbt/sbt/issues/823
@@ -775,7 +787,13 @@ class ExtractAPI[GlobalType <: Global](
     allNonLocalClassesInSrc += classWithMembers
     allNonLocalClassSymbols += sym
 
-    if (sym.isStatic && defType == DefinitionType.Module && definitions.hasJavaMainMethod(sym)) {
+    if (isJava25Plus) {
+      if (hasJava25MainMethod(sym)) {
+        _mainClasses += name
+      }
+    } else if (
+      sym.isStatic && defType == DefinitionType.Module && definitions.hasJavaMainMethod(sym)
+    ) {
       _mainClasses += name
     }
 
@@ -790,6 +808,18 @@ class ExtractAPI[GlobalType <: Global](
     classDef
   }
 
+  private[this] def hasJava25MainMethod(sym: Symbol): Boolean =
+    !sym.isAbstract && sym.tpe.member(nme.main).alternatives.exists(isJava25MainMethod)
+
+  private[this] def isJava25MainMethod(sym: Symbol): Boolean =
+    (sym.name == nme.main) && (sym.info match {
+      case MethodType(Nil, restpe) => restpe.typeSymbol == definitions.UnitClass
+      case MethodType(p :: Nil, restpe) =>
+        definitions.isArrayOfSymbol(p.tpe, definitions.StringClass) && restpe
+          .typeSymbol == definitions.UnitClass
+      case _ => false
+    })
+
   // TODO: could we restrict ourselves to classes, ignoring the term symbol for modules,
   // since everything we need to track about a module is in the module's class (`moduleSym.moduleClass`)?
   private[this] def isClass(s: Symbol) = s.isClass || s.isModule

internal/compiler-bridge/src/main/scala_2.10/xsbt/Compat.scala

@@ -110,6 +110,8 @@ abstract class Compat {
 
     // unexpandedName replaces originalName in 2.11
     @inline final def unexpandedName: Name = sym.originalName
+
+    @inline final def isAbstract: Boolean = false
   }
 
   val DummyValue = 0

internal/zinc-scripted/src/test/scala/sbt/internal/inc/IncHandler.scala

@@ -241,7 +241,8 @@ class IncHandler(directory: Path, cacheDir: Path, scriptedLog: ManagedLogger, co
       case (p, src :: products, i) => p.checkClasses(i, dropRightColon(src), products)
     },
     onArgs("checkMainClasses") {
-      case (p, src :: products, i) => p.checkMainClasses(i, dropRightColon(src), products)
+      case (p, javaV :: src :: products, i) =>
+        p.checkMainClasses(i, javaV, dropRightColon(src), products)
     },
     onArgs("checkProducts") {
       case (p, src :: products, i) => p.checkProducts(i, dropRightColon(src), products)
@@ -455,16 +456,23 @@ case class ProjectStructure(
       ()
     }
 
-  def checkMainClasses(i: IncState, src: String, expected: List[String]): Future[Unit] =
+  def checkMainClasses(
+      i: IncState,
+      javaV: String,
+      src: String,
+      expected: List[String]
+  ): Future[Unit] =
     compile(i).map { analysis =>
+      val is25Plus = scala.util.Properties.isJavaAtLeast("25")
       def mainClasses(src: String): Set[String] =
         analysis.infos.get(converter.toVirtualFile(baseDirectory / src)).getMainClasses.toSet
       def assertClasses(expected: Set[String], actual: Set[String]) = {
         val msg = s"Expected $expected classes, got $actual\n\n" + analysis.infos.allInfos
         assert(expected == actual, msg)
       }
 
-      assertClasses(expected.toSet, mainClasses(src))
+      if (is25Plus == (javaV == "25")) assertClasses(expected.toSet, mainClasses(src))
+      else ()
       ()
     }
 

zinc/src/sbt-test/apiinfo/main-discovery/src/main/scala/Hello.scala

@@ -1,13 +1,36 @@
 package runscala
 
 object MainScala {
-	def main(args: Array[String]) {}
+  def main(args: Array[String]): Unit = ()
 
   object StaticInner {
-	  def main(args: Array[String]) {}
+    def main(args: Array[String]): Unit = ()
   }
 }
 
-class NoMainScala {
-	def main(args: Array[String]) {}
+class NoStatic {
+  def main(args: Array[String]): Unit = ()
+}
+
+class NoArgs {
+  def main(): Unit = ()
+}
+
+class Protected {
+  protected def main(): Unit = ()
+}
+
+trait Tr {
+  def main(): Unit = ()
+}
+
+abstract class Abs {
+  def main(): Unit = ()
+}
+
+class InheritTrait extends Tr
+abstract class AbsInheritAbs extends Abs
+
+class NonVoid {
+  def main(): Int = 1
 }

zinc/src/sbt-test/apiinfo/main-discovery/test

@@ -1,4 +1,11 @@
 > compile
-> checkMainClasses src/main/java/runjava/MainJava.java: runjava.MainJava runjava.MainJava.StaticInner
-> checkMainClasses src/main/java/runjava/oMainJava.java:
-> checkMainClasses src/main/scala/Hello.scala: runscala.MainScala runscala.MainScala.StaticInner
+
+# before Java 25
+> checkMainClasses 24 src/main/java/runjava/MainJava.java: runjava.MainJava runjava.MainJava.StaticInner
+> checkMainClasses 24 src/main/java/runjava/oMainJava.java:
+> checkMainClasses 24 src/main/scala/Hello.scala: runscala.MainScala runscala.MainScala.StaticInner
+
+# starting Java 25
+> checkMainClasses 25 src/main/java/runjava/MainJava.java: runjava.MainJava runjava.MainJava.StaticInner
+> checkMainClasses 25 src/main/java/runjava/oMainJava.java:
+> checkMainClasses 25 src/main/scala/Hello.scala: runscala.MainScala runscala.MainScala.StaticInner runscala.NoStatic runscala.NoArgs runscala.Protected runscala.InheritTrait