Add --python to repl command

Author: alexarchambault

modules/build/src/main/scala/scala/build/ReplArtifacts.scala

@@ -44,10 +44,12 @@ object ReplArtifacts {
     extraSourceJars: Seq[os.Path],
     logger: Logger,
     cache: FileCache[Task],
-    directories: Directories
+    directories: Directories,
+    addScalapy: Option[String]
   ): Either[BuildException, ReplArtifacts] = either {
     val localRepoOpt = LocalRepo.localRepo(directories.localRepoDir)
-    val allDeps      = dependencies ++ Seq(dep"com.lihaoyi:::ammonite:$ammoniteVersion")
+    val scalapyDeps  = addScalapy.map(ver => dep"me.shadaj::scalapy-core::$ver").toSeq
+    val allDeps = dependencies ++ Seq(dep"com.lihaoyi:::ammonite:$ammoniteVersion") ++ scalapyDeps
     val replArtifacts = Artifacts.artifacts(
       Positioned.none(allDeps),
       localRepoOpt.toSeq,
@@ -79,13 +81,15 @@ object ReplArtifacts {
     extraClassPath: Seq[os.Path],
     logger: Logger,
     cache: FileCache[Task],
-    repositories: Seq[String]
+    repositories: Seq[String],
+    addScalapy: Option[String]
   ): Either[BuildException, ReplArtifacts] = either {
     val isScala2 = scalaParams.scalaVersion.startsWith("2.")
     val replDep =
       if (isScala2) dep"org.scala-lang:scala-compiler:${scalaParams.scalaVersion}"
       else dep"org.scala-lang::scala3-compiler:${scalaParams.scalaVersion}"
-    val allDeps = dependencies ++ Seq(replDep)
+    val scalapyDeps = addScalapy.map(ver => dep"me.shadaj::scalapy-core::$ver").toSeq
+    val allDeps     = dependencies ++ Seq(replDep) ++ scalapyDeps
     val replArtifacts =
       Artifacts.artifacts(
         Positioned.none(allDeps),

modules/cli-options/src/main/scala/scala/cli/commands/SharedReplOptions.scala

@@ -11,6 +11,8 @@ final case class SharedReplOptions(
     watch: SharedWatchOptions = SharedWatchOptions(),
   @Recurse
     compileCross: CrossOptions = CrossOptions(),
+  @Recurse
+    sharedPython: SharedPythonOptions = SharedPythonOptions(),
 
   @Group("Repl")
   @HelpMessage("[restricted] Use Ammonite (instead of the default Scala REPL)")

modules/cli/src/main/scala/scala/cli/commands/Repl.scala

@@ -1,16 +1,18 @@
 package scala.cli.commands
 
+import ai.kien.python.Python
 import caseapp._
 import coursier.cache.FileCache
 import coursier.error.{FetchError, ResolutionError}
+import dependency._
 
 import scala.build.EitherCps.{either, value}
 import scala.build._
 import scala.build.errors.{BuildException, CantDownloadAmmoniteError, FetchingDependenciesError}
-import scala.build.internal.Runner
+import scala.build.internal.{Constants, Runner}
 import scala.build.options.{BuildOptions, JavaOpt, Scope}
 import scala.cli.CurrentParams
-import scala.cli.commands.Run.maybePrintSimpleScalacOutput
+import scala.cli.commands.Run.{maybePrintSimpleScalacOutput, orPythonDetectionError}
 import scala.cli.commands.publish.ConfigUtil._
 import scala.cli.commands.util.CommonOps._
 import scala.cli.commands.util.SharedOptionsUtil._
@@ -55,7 +57,9 @@ object Repl extends ScalaCommand[ReplOptions] {
           useAmmoniteOpt = ammonite,
           ammoniteVersionOpt = ammoniteVersionOpt,
           ammoniteArgs = ammoniteArg
-        )
+        ),
+        python = sharedPython.python,
+        pythonSetup = sharedPython.pythonSetup
       ),
       internalDependencies = baseOptions.internalDependencies.copy(
         addRunnerDependencyOpt = baseOptions.internalDependencies.addRunnerDependencyOpt
@@ -70,7 +74,8 @@ object Repl extends ScalaCommand[ReplOptions] {
       Inputs.empty(Os.pwd, options.shared.markdown.enableMarkdown)
     }
     val logger = options.shared.logger
-    val inputs = options.shared.inputs(args.all, defaultInputs = () => Some(default)).orExit(logger)
+    val inputs =
+      options.shared.inputs(args.remaining, defaultInputs = () => Some(default)).orExit(logger)
     val programArgs = args.unparsed
     CurrentParams.workspaceOpt = Some(inputs.workspace)
 
@@ -98,7 +103,8 @@ object Repl extends ScalaCommand[ReplOptions] {
       buildOptions: BuildOptions,
       artifacts: Artifacts,
       classDir: Option[os.Path],
-      allowExit: Boolean
+      allowExit: Boolean,
+      buildOpt: Option[Build.Successful]
     ): Unit = {
       val res = runRepl(
         buildOptions,
@@ -108,7 +114,8 @@ object Repl extends ScalaCommand[ReplOptions] {
         directories,
         logger,
         allowExit = allowExit,
-        options.sharedRepl.replDryRun
+        options.sharedRepl.replDryRun,
+        buildOpt
       )
       res match {
         case Left(ex) =>
@@ -125,7 +132,8 @@ object Repl extends ScalaCommand[ReplOptions] {
         build.options,
         build.artifacts,
         build.outputOpt,
-        allowExit
+        allowExit,
+        Some(build)
       )
 
     val cross    = options.sharedRepl.compileCross.cross.getOrElse(false)
@@ -141,7 +149,8 @@ object Repl extends ScalaCommand[ReplOptions] {
         initialBuildOptions,
         artifacts,
         None,
-        allowExit = !options.sharedRepl.watch.watchMode
+        allowExit = !options.sharedRepl.watch.watchMode,
+        buildOpt = None
       )
       if (options.sharedRepl.watch.watchMode) {
         // nothing to watch, just wait for Ctrl+C
@@ -194,6 +203,15 @@ object Repl extends ScalaCommand[ReplOptions] {
     }
   }
 
+  private def maybeAdaptForWindows(args: Seq[String]): Seq[String] =
+    if (Properties.isWin)
+      args.map { a =>
+        if (a.contains(" ")) "\"" + a.replace("\"", "\\\"") + "\""
+        else a
+      }
+    else
+      args
+
   private def runRepl(
     options: BuildOptions,
     programArgs: Seq[String],
@@ -202,44 +220,57 @@ object Repl extends ScalaCommand[ReplOptions] {
     directories: scala.build.Directories,
     logger: Logger,
     allowExit: Boolean,
-    dryRun: Boolean
+    dryRun: Boolean,
+    buildOpt: Option[Build.Successful]
   ): Either[BuildException, Unit] = either {
 
+    val setupPython = options.notForBloopOptions.python.getOrElse(false)
+
     val cache             = options.internal.cache.getOrElse(FileCache())
     val shouldUseAmmonite = options.notForBloopOptions.replOptions.useAmmonite
-    val replArtifacts = value {
-      val scalaParams = artifacts.scalaOpt
-        .getOrElse {
-          sys.error("Expected Scala artifacts to be fetched")
+
+    val scalaParams = artifacts.scalaOpt
+      .getOrElse {
+        sys.error("Expected Scala artifacts to be fetched")
+      }
+      .params
+
+    val scalapyJavaOpts =
+      if (setupPython) {
+        val props = value {
+          val python       = Python()
+          val propsOrError = python.scalapyProperties
+          logger.debug(s"Python Java properties: $propsOrError")
+          propsOrError.orPythonDetectionError
+        }
+        props.toVector.sorted.map {
+          case (k, v) => s"-D$k=$v"
         }
-        .params
-      val maybeReplArtifacts =
-        if (shouldUseAmmonite)
-          ReplArtifacts.ammonite(
-            scalaParams,
-            options.notForBloopOptions.replOptions.ammoniteVersion,
-            artifacts.userDependencies,
-            artifacts.extraClassPath,
-            artifacts.extraSourceJars,
-            logger,
-            cache,
-            directories
-          )
-        else
-          ReplArtifacts.default(
-            scalaParams,
-            artifacts.userDependencies,
-            artifacts.extraClassPath,
-            logger,
-            cache,
-            options.finalRepositories
-          )
-      maybeReplArtifacts match {
-        case Left(FetchingDependenciesError(e: ResolutionError.CantDownloadModule, positions))
-            if shouldUseAmmonite && e.module.name.value == s"ammonite_${scalaParams.scalaVersion}" =>
-          Left(CantDownloadAmmoniteError(e.version, scalaParams.scalaVersion, e, positions))
-        case either @ _ => either
       }
+      else
+        Nil
+
+    def additionalArgs = {
+      val pythonArgs =
+        if (setupPython && scalaParams.scalaVersion.startsWith("2.13."))
+          Seq("-Yimports:java.lang,scala,scala.Predef,me.shadaj.scalapy")
+        else
+          Nil
+      pythonArgs ++ options.scalaOptions.scalacOptions.toSeq.map(_.value.value)
+    }
+
+    def ammoniteAdditionalArgs() = {
+      val pythonPredef =
+        if (setupPython)
+          """import me.shadaj.scalapy.py
+            |import me.shadaj.scalapy.py.PyQuote
+            |""".stripMargin
+        else
+          ""
+      val predefArgs =
+        if (pythonPredef.isEmpty) Nil
+        else Seq("--predef-code", pythonPredef)
+      predefArgs ++ options.notForBloopOptions.replOptions.ammoniteArgs
     }
 
     // TODO Warn if some entries of artifacts.classPath were evicted in replArtifacts.replClassPath
@@ -264,31 +295,93 @@ object Repl extends ScalaCommand[ReplOptions] {
           " These will not be accessible from the REPL."
       )
 
-    val additionalArgs =
-      if (shouldUseAmmonite)
-        options.notForBloopOptions.replOptions.ammoniteArgs
-      else
-        options.scalaOptions.scalacOptions.toSeq.map(_.value.value)
+    def actualBuild: Build.Successful =
+      buildOpt.getOrElse {
+        val ws      = os.temp.dir()
+        val inputs  = Inputs.empty(ws, enableMarkdown = false)
+        val sources = Sources(Nil, Nil, None, Nil, options)
+        val scope   = Scope.Main
+        Build.Successful(
+          inputs = inputs,
+          options = options,
+          scalaParams = Some(scalaParams),
+          scope = scope,
+          sources = Sources(Nil, Nil, None, Nil, options),
+          artifacts = artifacts,
+          project = value(Build.buildProject(inputs, sources, Nil, options, None, scope, logger)),
+          output = classDir.getOrElse(ws),
+          diagnostics = None,
+          generatedSources = Nil,
+          isPartial = false
+        )
+      }
 
-    val replArgs = additionalArgs ++ programArgs
+    def maybeRunRepl(
+      replArtifacts: ReplArtifacts,
+      replArgs: Seq[String],
+      extraEnv: Map[String, String] = Map.empty,
+      extraProps: Map[String, String] = Map.empty
+    ): Unit =
+      if (dryRun)
+        logger.message("Dry run, not running REPL.")
+      else {
+        val retCode = Runner.runJvm(
+          options.javaHome().value.javaCommand,
+          scalapyJavaOpts ++
+            replArtifacts.replJavaOpts ++
+            options.javaOptions.javaOpts.toSeq.map(_.value.value) ++
+            extraProps.toVector.sorted.map { case (k, v) => s"-D$k=$v" },
+          classDir.toSeq ++ replArtifacts.replClassPath,
+          replArtifacts.replMainClass,
+          maybeAdaptForWindows(replArgs),
+          logger,
+          allowExecve = allowExit,
+          extraEnv = extraEnv
+        ).waitFor()
+        if (retCode != 0)
+          value(Left(new ReplError(retCode)))
+      }
 
-    if (dryRun)
-      logger.message("Dry run, not running REPL.")
-    else
-      Runner.runJvm(
-        options.javaHome().value.javaCommand,
-        replArtifacts.replJavaOpts ++ options.javaOptions.javaOpts.toSeq.map(_.value.value),
-        classDir.toSeq ++ replArtifacts.replClassPath,
-        replArtifacts.replMainClass,
-        if (Properties.isWin)
-          replArgs.map { a =>
-            if (a.contains(" ")) "\"" + a.replace("\"", "\\\"") + "\""
-            else a
-          }
-        else
-          replArgs,
+    def defaultArtifacts(): Either[BuildException, ReplArtifacts] =
+      ReplArtifacts.default(
+        scalaParams,
+        artifacts.userDependencies,
+        artifacts.extraClassPath,
+        logger,
+        cache,
+        options.finalRepositories,
+        addScalapy = if (setupPython) Some(Constants.scalaPyVersion) else None
+      )
+    def ammoniteArtifacts(): Either[BuildException, ReplArtifacts] =
+      ReplArtifacts.ammonite(
+        scalaParams,
+        options.notForBloopOptions.replOptions.ammoniteVersion,
+        artifacts.userDependencies,
+        artifacts.extraClassPath,
+        artifacts.extraSourceJars,
         logger,
-        allowExecve = allowExit
-      ).waitFor()
+        cache,
+        directories,
+        addScalapy = if (setupPython) Some(Constants.scalaPyVersion) else None
+      ).left.map {
+        case FetchingDependenciesError(e: ResolutionError.CantDownloadModule, positions)
+            if shouldUseAmmonite && e.module.name.value == s"ammonite_${scalaParams.scalaVersion}" =>
+          CantDownloadAmmoniteError(e.version, scalaParams.scalaVersion, e, positions)
+        case other => other
+      }
+
+    if (shouldUseAmmonite) {
+      val replArtifacts = value(ammoniteArtifacts())
+      val replArgs      = ammoniteAdditionalArgs() ++ programArgs
+      maybeRunRepl(replArtifacts, replArgs)
+    }
+    else {
+      val replArtifacts = value(defaultArtifacts())
+      val replArgs      = additionalArgs ++ programArgs
+      maybeRunRepl(replArtifacts, replArgs)
+    }
   }
+
+  final class ReplError(retCode: Int)
+      extends BuildException(s"Failed to run REPL (exit code: $retCode)")
 }

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

@@ -9,7 +9,11 @@ abstract class ReplTestDefinitions(val scalaVersionOpt: Option[String])
 
   private lazy val extraOptions = scalaVersionArgs ++ TestUtil.extraOptions
 
-  protected def versionNumberString: String = actualScalaVersion
+  protected def versionNumberString: String =
+    if (actualScalaVersion.startsWith("2.")) actualScalaVersion
+    // Scala 3 gives the 2.13 version it depends on for its standard library.
+    // Assuming it's the same Scala 3 version as the integration tests here.
+    else Properties.versionNumberString
 
   test("default dry run") {
     TestInputs.empty.fromRoot { root =>
@@ -42,4 +46,35 @@ abstract class ReplTestDefinitions(val scalaVersionOpt: Option[String])
       ammoniteTest()
     }
 
+  test("ammonite scalapy") {
+    TestInputs.empty.fromRoot { root =>
+      val ammArgs = Seq(
+        "-c",
+        """println("Hello" + " from Scala " + scala.util.Properties.versionNumberString)
+          |// py.Dynamic.global.print("Hello from", "ScalaPy") // doesn't work
+          |println(py"'Hello from '" + py"'ScalaPy'")
+          |""".stripMargin
+      )
+        .map {
+          if (Properties.isWin)
+            a => if (a.contains(" ")) "\"" + a.replace("\"", "\\\"") + "\"" else a
+          else
+            identity
+        }
+        .flatMap(arg => Seq("--ammonite-arg", arg))
+      val res = os.proc(
+        TestUtil.cli,
+        "repl",
+        "-v",
+        "-v",
+        extraOptions,
+        "--ammonite",
+        "--python",
+        ammArgs
+      ).call(cwd = root)
+      val lines = res.out.trim().linesIterator.toVector
+      expect(lines == Seq(s"Hello from Scala $versionNumberString", "Hello from ScalaPy"))
+    }
+  }
+
 }