Add support for passing Java code by stdin (#956)

* Enable passing Java code through stdin

* Parse the virtual file name automatically when Java code is passed through stdin

* Add integration tests for running Java from stdin

* Extract Java parsing to a Scala 3 module

* fixup (fix Scala 3 / Scala 2.13 modules compat)

* fixup (fmt)

* fixup Extract Java parsing to a Scala 3 module (fmt)

* move import

Co-authored-by: Alexandre Archambault <[email protected]>
Co-authored-by: Alexandre Archambault <[email protected]>

Author: Gedochao

build.sc

@@ -69,6 +69,7 @@ object `cli-options`  extends CliOptions
 object `build-macros` extends Cross[BuildMacros](Scala.mainVersions: _*)
 object options        extends Cross[Options](Scala.mainVersions: _*)
 object scalaparse     extends ScalaParse
+object javaparse      extends JavaParse
 object directives     extends Cross[Directives](Scala.mainVersions: _*)
 object core           extends Cross[Core](Scala.mainVersions: _*)
 object `build-module` extends Cross[Build](Scala.mainVersions: _*)
@@ -493,6 +494,34 @@ trait ScalaParse extends SbtModule with ScalaCliPublishModule with ScalaCliCompi
   def scalaVersion = Scala.scala213
 }
 
+trait JavaParse extends SbtModule with ScalaCliPublishModule with ScalaCliCompile {
+  def ivyDeps = super.ivyDeps() ++ Agg(Deps.scala3Compiler(scalaVersion()))
+
+  // pin scala3-library suffix, so that 2.13 modules can have us as moduleDep fine
+  def mandatoryIvyDeps = T {
+    super.mandatoryIvyDeps().map { dep =>
+      val isScala3Lib =
+        dep.dep.module.organization.value == "org.scala-lang" &&
+        dep.dep.module.name.value == "scala3-library" &&
+        (dep.cross match {
+          case _: CrossVersion.Binary => true
+          case _                      => false
+        })
+      if (isScala3Lib)
+        dep.copy(
+          dep = dep.dep.withModule(
+            dep.dep.module.withName(
+              coursier.ModuleName(dep.dep.module.name.value + "_3")
+            )
+          ),
+          cross = CrossVersion.empty(dep.cross.platformed)
+        )
+      else dep
+    }
+  }
+  def scalaVersion = Scala.scala3
+}
+
 trait Scala3Runtime extends SbtModule with ScalaCliPublishModule with ScalaCliCompile {
   def ivyDeps      = super.ivyDeps()
   def scalaVersion = Scala.scala3
@@ -528,6 +557,7 @@ class Build(val crossScalaVersion: String) extends BuildLikeModule {
   def moduleDeps = Seq(
     `options`(),
     scalaparse,
+    javaparse,
     `directives`(),
     `scala-cli-bsp`,
     `test-runner`(),

modules/build/src/main/scala/scala/build/Inputs.scala

@@ -185,6 +185,10 @@ object Inputs {
       ScopePath(Left(source), subPath)
   }
 
+  sealed abstract class VirtualSourceFile extends Virtual {
+    def isStdin: Boolean = source == "<stdin>"
+  }
+
   sealed trait SingleFile extends OnDisk with SingleElement
   sealed trait SourceFile extends SingleFile {
     def subPath: os.SubPath
@@ -210,9 +214,9 @@ object Inputs {
   final case class VirtualScript(content: Array[Byte], source: String, wrapperPath: os.SubPath)
       extends Virtual with AnyScalaFile with AnyScript
   final case class VirtualScalaFile(content: Array[Byte], source: String)
-      extends Virtual with AnyScalaFile { def isStdin: Boolean = source == "<stdin>" }
+      extends VirtualSourceFile with AnyScalaFile
   final case class VirtualJavaFile(content: Array[Byte], source: String)
-      extends Virtual with Compiled
+      extends VirtualSourceFile with Compiled
   final case class VirtualData(content: Array[Byte], source: String)
       extends Virtual
 
@@ -336,6 +340,8 @@ object Inputs {
       val isStdin = (arg == "-.scala" || arg == "_" || arg == "_.scala") &&
         stdinOpt0.nonEmpty
       if (isStdin) Right(Seq(VirtualScalaFile(stdinOpt0.get, "<stdin>")))
+      else if ((arg == "-.java" || arg == "_.java") && stdinOpt0.nonEmpty)
+        Right(Seq(VirtualJavaFile(stdinOpt0.get, "<stdin>")))
       else if ((arg == "-" || arg == "-.sc" || arg == "_.sc") && stdinOpt0.nonEmpty)
         Right(Seq(VirtualScript(stdinOpt0.get, "stdin", os.sub / "stdin.sc")))
       else if (arg.endsWith(".zip") && os.exists(os.Path(arg, cwd))) {

modules/build/src/main/scala/scala/build/preprocessing/JavaPreprocessor.scala

@@ -6,6 +6,7 @@ import java.nio.charset.StandardCharsets
 
 import scala.build.EitherCps.{either, value}
 import scala.build.errors.BuildException
+import scala.build.internal.JavaParser
 import scala.build.options.BuildRequirements
 import scala.build.preprocessing.ExtractedDirectives.from
 import scala.build.preprocessing.ScalaPreprocessor._
@@ -44,17 +45,25 @@ case object JavaPreprocessor extends Preprocessor {
           ))
         })
       case v: Inputs.VirtualJavaFile =>
+        val relPath =
+          if (v.isStdin) {
+            val fileName = JavaParser.parseRootPublicClassName(v.content).map(
+              _ + ".java"
+            ).getOrElse("stdin.java")
+            os.sub / fileName
+          }
+          else v.subPath
         val content = new String(v.content, StandardCharsets.UTF_8)
         val s = PreprocessedSource.InMemory(
-          Left(v.source),
-          v.subPath,
-          content,
-          0,
-          None,
-          None,
-          Nil,
-          None,
-          v.scopePath
+          originalPath = Left(v.source),
+          relPath = relPath,
+          code = content,
+          ignoreLen = 0,
+          options = None,
+          requirements = None,
+          scopedRequirements = Nil,
+          mainClassOpt = None,
+          scopePath = v.scopePath
         )
         Some(Right(Seq(s)))
 

modules/integration/src/test/scala/scala/cli/integration/RunTestDefinitions.scala

@@ -729,6 +729,46 @@ abstract class RunTestDefinitions(val scalaVersionOpt: Option[String])
         expect(output == expectedOutput)
       }
     }
+    test("Java code accepted as piped input") {
+      val expectedOutput = "Hello"
+      val pipedInput =
+        s"""public class Main {
+           |    public static void main(String[] args) {
+           |        System.out.println("$expectedOutput");
+           |    }
+           |}
+           |""".stripMargin
+      emptyInputs.fromRoot { root =>
+        val output = os.proc(TestUtil.cli, "_.java", extraOptions)
+          .call(cwd = root, stdin = pipedInput)
+          .out.text().trim
+        expect(output == expectedOutput)
+      }
+    }
+    test("Java code with multiple classes accepted as piped input") {
+      val expectedOutput = "Hello"
+      val pipedInput =
+        s"""class OtherClass {
+           |    public String message;
+           |    public OtherClass(String message) {
+           |      this.message = message;
+           |    }
+           |}
+           |
+           |public class Main {
+           |    public static void main(String[] args) {
+           |        OtherClass obj = new OtherClass("$expectedOutput");
+           |        System.out.println(obj.message);
+           |    }
+           |}
+           |""".stripMargin
+      emptyInputs.fromRoot { root =>
+        val output = os.proc(TestUtil.cli, "_.java", extraOptions)
+          .call(cwd = root, stdin = pipedInput)
+          .out.text().trim
+        expect(output == expectedOutput)
+      }
+    }
   }
 
   def fd(): Unit = {

modules/javaparse/src/main/scala/scala/build/internal/JavaParser.scala

@@ -0,0 +1,39 @@
+package scala.build.internal
+
+import dotty.tools.dotc.ast.{Trees, untpd}
+import dotty.tools.dotc.core.Contexts.{Context, ContextBase}
+import dotty.tools.dotc.parsing.JavaParsers.OutlineJavaParser
+import dotty.tools.dotc.util.SourceFile
+import dotty.tools.io.VirtualFile
+import dotty.tools.dotc.ast.untpd.{ModuleDef, PackageDef, Tree, TypeDef}
+import dotty.tools.dotc.core.Symbols.ClassSymbol
+import dotty.tools.dotc.core.{SymbolLoaders, Flags}
+import dotty.tools.dotc.ast.untpd.Modifiers
+import scala.io.Codec
+
+object JavaParser {
+  private def parseOutline(byteContent: Array[Byte]): untpd.Tree = {
+    given Context = ContextBase().initialCtx.fresh
+    val virtualFile   = VirtualFile("placeholder.java", byteContent)
+    val sourceFile    = SourceFile(virtualFile, Codec.UTF8)
+    val outlineParser = OutlineJavaParser(sourceFile)
+    outlineParser.parse()
+  }
+
+  extension(mdef: untpd.DefTree) {
+    def nonPackagePrivate: Boolean = mdef.mods.privateWithin.toTermName.toString != "<empty>"
+    def isPrivate: Boolean         = mdef.mods.flags.is(Flags.Private)
+    def isProtected: Boolean       = mdef.mods.flags.is(Flags.Protected)
+  }
+
+  def parseRootPublicClassName(byteContent: Array[Byte]): Option[String] =
+    Option(parseOutline(byteContent))
+      .flatMap {
+        case pd: Trees.PackageDef[_] => Some(pd.stats)
+        case _                       => None
+      }
+      .flatMap(_.collectFirst {
+        case mdef: ModuleDef if mdef.nonPackagePrivate && !mdef.isPrivate && !mdef.isProtected =>
+          mdef.name.toString
+      })
+}

project/deps.sc

@@ -101,7 +101,7 @@ object Deps {
   def organizeImports            = ivy"com.github.liancheng::organize-imports:0.5.0"
   def osLib                      = ivy"com.lihaoyi::os-lib:0.8.1"
   def pprint                     = ivy"com.lihaoyi::pprint:0.7.3"
-  def scala3Compiler(sv: String) = ivy"org.scala-lang::scala3-compiler:$sv"
+  def scala3Compiler(sv: String) = ivy"org.scala-lang:scala3-compiler_3:$sv"
   def scalaAsync         = ivy"org.scala-lang.modules::scala-async:1.0.1".exclude("*" -> "*")
   def scalac(sv: String) = ivy"org.scala-lang:scala-compiler:$sv"
   def scalafmtCli        = ivy"org.scalameta:scalafmt-cli_2.13:3.5.2"

project/settings.sc

@@ -941,7 +941,7 @@ trait ScalaCliCrossSbtModule extends CrossSbtModule {
     val sv         = scalaVersion()
     val isScala213 = sv.startsWith("2.13.")
     val extraOptions =
-      if (isScala213) Seq("-Xsource:3")
+      if (isScala213) Seq("-Xsource:3", "-Ytasty-reader")
       else Nil
     super.scalacOptions() ++ extraOptions
   }