feat(repl): add resource directives and a :resource command

Author: warcholjakub

repl/src/dotty/tools/repl/ParseResult.scala

@@ -126,6 +126,14 @@ object JarCmd extends ArgCommand[JarCmd] {
   val command: String = ":jar"
 }
 
+/** `:resource <path>` adds a resource file or directory to the classpath
+ */
+case class ResourceCmd(path: String) extends Command:
+  override def replayLine = Some(s"${ResourceCmd.command} $path")
+object ResourceCmd extends ArgCommand[ResourceCmd] {
+  val command: String = ":resource"
+}
+
 /** `:toolkit <version>` resolves a toolkit and adds it to the classpath
  */
 case class ToolkitCmd(coordinates: String) extends Command:

repl/src/dotty/tools/repl/Rendering.scala

@@ -222,18 +222,18 @@ private[repl] class Rendering(parentClassLoader: Option[ClassLoader] = None):
     if (myClassLoader != null && myClassLoader.root == ctx.settings.outputDir.value) myClassLoader
     else {
       val parent = Option(myClassLoader).getOrElse {
-        val base = parentClassLoader.getOrElse {
-          val compilerClasspath = ctx.platform.classPath(using ctx).asURLs
-          // We can't use the system classloader as a parent because it would
-          // pollute the user classpath with everything passed to the JVM
-          // `-classpath`. We can't use `null` as a parent either because on Java
-          // 9+ that's the bootstrap classloader which doesn't contain modules
-          // like `java.sql`, so we use the parent of the system classloader,
-          // which should correspond to the platform classloader on Java 9+.
-          val baseClassLoader = ClassLoader.getSystemClassLoader.getParent
-          new URLClassLoader(compilerClasspath.toArray, baseClassLoader)
-        }
-        myClasspathClassLoader = ClasspathClassLoader(base)
+        myClasspathClassLoader = parentClassLoader match
+          case Some(given_) => ClasspathClassLoader(Array.empty, given_)
+          case None =>
+            val compilerClasspath = ctx.platform.classPath(using ctx).asURLs
+            // We can't use the system classloader as a parent because it would
+            // pollute the user classpath with everything passed to the JVM
+            // `-classpath`. We can't use `null` as a parent either because on Java
+            // 9+ that's the bootstrap classloader which doesn't contain modules
+            // like `java.sql`, so we use the parent of the system classloader,
+            // which should correspond to the platform classloader on Java 9+.
+            val baseClassLoader = ClassLoader.getSystemClassLoader.getParent
+            ClasspathClassLoader(compilerClasspath.toArray, baseClassLoader)
         myClasspathClassLoader
       }
 
@@ -249,6 +249,8 @@ private[repl] class Rendering(parentClassLoader: Option[ClassLoader] = None):
     classLoader()
     urls.foreach(myClasspathClassLoader.add)
 
+  private[repl] def addResource(url: URL)(using Context): Unit = addToClasspath(Seq(url))
+
   private[repl] def truncate(str: String, maxPrintCharacters: Int)(using ctx: Context): String =
     val ncp = str.codePointCount(0, str.length) // to not cut inside code point
     if ncp <= maxPrintCharacters then str
@@ -381,5 +383,6 @@ object Rendering:
       rootCause(x.getCause)
     case _ => x
 
-private class ClasspathClassLoader(parent: ClassLoader) extends URLClassLoader(Array.empty, parent):
+private class ClasspathClassLoader(urls: Array[URL], parent: ClassLoader)
+  extends URLClassLoader(urls, parent):
   def add(url: URL): Unit = addURL(url)

repl/src/dotty/tools/repl/ReplCommands.scala

@@ -40,21 +40,22 @@ private[repl] object ReplCommands:
     CommandDefinition(companion)
 
   private val definitions = List(
-    command(Help,       "print this summary"),
-    command(Save,       "save replayable session to a file", "<path>"),
-    command(Load,       "interpret lines in a file", "<path>"),
-    command(Quit,       "exit the interpreter", aliases = List(Quit.alias)),
-    command(TypeOf,     "evaluate the type of the given expression", "<expression>"),
-    command(DocOf,      "print the documentation for the given expression", "<expression>"),
-    command(Imports,    "show import history"),
-    command(Reset,      "clear the session and start fresh with the given compiler options", "[options]"),
-    command(Replay,     "reset, then re-run the session with the given compiler options", "[options]"),
-    command(Settings,   "update compiler options, if possible", "<options>"),
-    command(Silent,     "disable/enable automatic printing of results"),
-    command(JarCmd,     "add a JAR to the classpath", "<path>"),
-    command(Dep,        "resolve a dependency and make it available in the REPL", "<group>::<artifact>:<version>"),
-    command(ToolkitCmd, "resolve a toolkit and make it available in the REPL", "<version>|default|<flavor>:<version>"),
-    command(RepoCmd,    "add repositories used to resolve dependencies", "<url>|<alias>"),
+    command(Help,        "print this summary"),
+    command(Save,        "save replayable session to a file", "<path>"),
+    command(Load,        "interpret lines in a file", "<path>"),
+    command(Quit,        "exit the interpreter", aliases = List(Quit.alias)),
+    command(TypeOf,      "evaluate the type of the given expression", "<expression>"),
+    command(DocOf,       "print the documentation for the given expression", "<expression>"),
+    command(Imports,     "show import history"),
+    command(Reset,       "clear the session and start fresh with the given compiler options", "[options]"),
+    command(Replay,      "reset, then re-run the session with the given compiler options", "[options]"),
+    command(Settings,    "update compiler options, if possible", "<options>"),
+    command(Silent,      "disable/enable automatic printing of results"),
+    command(JarCmd,      "add a JAR to the classpath", "<path>"),
+    command(Dep,         "resolve a dependency and make it available in the REPL", "<group>::<artifact>:<version>"),
+    command(ResourceCmd, "add a resource file or directory to the classpath", "<path>"),
+    command(ToolkitCmd,  "resolve a toolkit and make it available in the REPL", "<version>|default|<flavor>:<version>"),
+    command(RepoCmd,     "add repositories used to resolve dependencies", "<url>|<alias>"),
     hidden(Sh),
     hidden(KindOf),
     hidden(Require),

repl/src/dotty/tools/repl/ReplDirectives.scala

@@ -10,17 +10,17 @@ private[repl] object ReplDirectives:
     handlersByKey.get(key).fold("")(handler => s"\nUsage: ${handler.usage}")
 
   enum Warning:
-    case NoSeparateTestScope
+    case NoSeparateTestScope(what: String)
     case TestToolkitSameAsToolkit
     case ValueMissing(key: String)
     case TooManyValues(key: String)
     case MalformedValue(key: String, value: String)
     case UnsupportedDirective(key: String)
 
     override def toString: String = this match
-      case NoSeparateTestScope =>
-        """[warn] The REPL does not have a separate test scope. Dependencies that would only be
-          |available to tests are added to the current REPL session.""".stripMargin
+      case NoSeparateTestScope(what) =>
+        s"""[warn] The REPL does not have a separate test scope. $what that would only be
+           |available to tests are added to the current REPL session.""".stripMargin
       case TestToolkitSameAsToolkit =>
         """[warn] The REPL does not have a separate test scope, so `using test.toolkit` adds
           |exactly what `using toolkit` does.""".stripMargin
@@ -38,6 +38,7 @@ private[repl] object ReplDirectives:
     case Dependency(coordinate: String)
     case Jar(path: String)
     case Repository(repository: String)
+    case Resource(path: String)
 
   case class DirectiveClassification(
     directives: List[ReplDirective],
@@ -97,7 +98,7 @@ private[repl] object ReplDirectives:
       usage = "//> using test.dep <group>::<artifact>:<version> ...",
       description = "Resolve dependencies and make them available in the REPL.",
       toDirectives = coords => List(ReplDirective.Dependency(coords)),
-      warnings = List(Warning.NoSeparateTestScope)
+      warnings = List(Warning.NoSeparateTestScope("Dependencies"))
     )
 
     case Jar extends DirectiveHandler(
@@ -107,6 +108,21 @@ private[repl] object ReplDirectives:
       toDirectives = path => List(ReplDirective.Jar(path))
     )
 
+    case Resource extends DirectiveHandler(
+      keys = List("resourceDir", "resourceDirs", "resource"),
+      usage = "//> using resourceDir <path> ...",
+      description = "Add resource files or directories to the REPL classpath.",
+      toDirectives = path => List(ReplDirective.Resource(path))
+    )
+
+    case TestResource extends DirectiveHandler(
+      keys = List("test.resourceDir", "test.resourceDirs", "test.resource"),
+      usage = "//> using test.resourceDir <path> ...",
+      description = "Add resource files or directories to the REPL classpath.",
+      toDirectives = path => List(ReplDirective.Resource(path)),
+      warnings = List(Warning.NoSeparateTestScope("Resources"))
+    )
+
     case Toolkit extends DirectiveHandler(
       keys = List("toolkit"),
       usage = "//> using toolkit <version>|default|<flavor>:<version>",
@@ -115,7 +131,7 @@ private[repl] object ReplDirectives:
            |  Known flavors: scala (default, ${ScalaToolkit.defaultVersion}),
            |  typelevel (${TypelevelToolkit.defaultVersion}).""".stripMargin,
       toDirectives = toolkitDependencies,
-      warnings = List(Warning.NoSeparateTestScope),
+      warnings = List(Warning.NoSeparateTestScope("Dependencies")),
       acceptsMultipleValues = false
     )
 

repl/src/dotty/tools/repl/ReplDriver.scala

@@ -5,7 +5,7 @@ import scala.util.control.NonFatal
 
 import java.io.{File => JFile, PrintStream}
 import java.nio.charset.StandardCharsets
-import java.nio.file.Files
+import java.nio.file.{Files, Path}
 import java.util.regex.Pattern
 
 import dotc.ast.Trees.*
@@ -278,7 +278,7 @@ class ReplDriver(settings: Array[String],
           try
             System.setIn(replIn)
             scala.Console.withIn(replIn) {
-              interpret(res)
+              interpretSubmission(res)
             }
           finally
             System.setIn(savedIn)
@@ -296,6 +296,9 @@ class ReplDriver(settings: Array[String],
     interpret(ParseResult.complete(input))
   }
 
+  protected final def interpretSubmission(res: ParseResult)(using state: State): State =
+    rendering.classLoader()(using state.context).asContext(interpret(res))
+
   protected def runBody(body: => State): State = rendering.classLoader()(using rootCtx).asContext(withRedirectedOutput(body))
 
   // TODO: i5069
@@ -431,7 +434,8 @@ class ReplDriver(settings: Array[String],
       case CommandThenCode(cmd, code) =>
         val stateAfterCommand = interpretCommand(cmd)
         val recorded = cmd.replayLine.fold(stateAfterCommand)(line => stateAfterCommand.recordInput(line.strip))
-        interpret(ParseResult(code)(using recorded))(using recorded)
+        rendering.classLoader()(using recorded.context).asContext:
+          interpret(ParseResult(code)(using recorded))(using recorded)
 
       case MixedCommandsAndDirectives =>
         out.println(
@@ -749,6 +753,8 @@ class ReplDriver(settings: Array[String],
         }
         state
 
+    case ResourceCmd(path) => addResource(path)
+
     case KindOf(expr) =>
       out.println(s"""The :kind command is not currently supported.""")
       state
@@ -818,7 +824,7 @@ class ReplDriver(settings: Array[String],
         case _ => None
       singleValue.flatMap(ReplDirectives.toolkitCoordinates) match
         case Some(dependencies) =>
-          out.println(ReplDirectives.Warning.NoSeparateTestScope.toString)
+          out.println(ReplDirectives.Warning.NoSeparateTestScope("Dependencies").toString)
           resolveAndAddDeps(dependencies)
         case None =>
           out.println(
@@ -841,10 +847,35 @@ class ReplDriver(settings: Array[String],
       case Jar(path) => path
     val repositories = classified.directives.collect:
       case Repository(repository) => repository
+    val resources = classified.directives.collect:
+      case Resource(path) => path
     val stateWithRepositories = addRepositories(repositories)
     val stateWithDependencies = resolveAndAddDeps(dependencies)(using stateWithRepositories)
-    jars.foldLeft(stateWithDependencies): (currentState, path) =>
+    val stateWithJars = jars.foldLeft(stateWithDependencies): (currentState, path) =>
       interpretCommand(JarCmd(path))(using currentState)
+    resources.foldLeft(stateWithJars): (currentState, path) =>
+      addResource(path)(using currentState)
+
+  private def addResource(path: String)(using state: State): State =
+    try
+      val resource = Path.of(path)
+      if !Files.exists(resource) then
+        out.println(s"Cannot add '$path' to classpath, it does not exist.")
+      else
+        val root = if Files.isDirectory(resource) then resource else stageResourceFile(resource)
+        inContext(state.context):
+          rendering.addResource(root.toUri.toURL)
+        out.println(s"Added '$path' to classpath.")
+    catch case NonFatal(e) =>
+      out.println(s"Failed to load '$path' to classpath: ${e.getMessage}")
+    state
+
+  private def stageResourceFile(resource: Path): Path =
+    val staging = Files.createTempDirectory("repl_resource")
+    staging.toFile.deleteOnExit()
+    val staged = Files.copy(resource, staging.resolve(resource.getFileName))
+    staged.toFile.deleteOnExit()
+    staging
 
   private def addRepositories(repositoryStrings: List[String])(using state: State): State =
     repositoryStrings.foldLeft(state): (currentState, repositoryString) =>

repl/test/dotty/tools/repl/ReplDirectiveTests.scala

@@ -4,7 +4,7 @@ package repl
 import org.junit.Assert.{assertEquals, assertFalse, assertTrue}
 import org.junit.Test
 
-import ReplDirectives.ReplDirective.{Dependency, Jar, Repository}
+import ReplDirectives.ReplDirective.{Dependency, Jar, Repository, Resource}
 import ReplDirectives.Warning
 
 class ReplDirectiveTests extends ReplTest, SessionFileHelpers:
@@ -24,7 +24,7 @@ class ReplDirectiveTests extends ReplTest, SessionFileHelpers:
     aliases.foreach: alias =>
       val result = ReplDirectives.classify(s"//> using $alias ${dependencies.mkString(" ")}")
       assertEquals(dependencies.map(Dependency(_)), result.directives)
-      assertEquals(List(Warning.NoSeparateTestScope), result.warnings)
+      assertEquals(List(Warning.NoSeparateTestScope("Dependencies")), result.warnings)
     assertTrue(ReplDirectives.helpText.contains("Aliases: test.deps, test.dependency, test.dependencies"))
 
   @Test def `jar directive aliases are supported`: Unit =
@@ -35,6 +35,22 @@ class ReplDirectiveTests extends ReplTest, SessionFileHelpers:
       assertEquals(Nil, result.warnings)
     assertTrue(ReplDirectives.helpText.contains("Aliases: jars"))
 
+  @Test def `resource directive aliases are supported`: Unit =
+    val paths = List("res", "conf.json")
+    List("resourceDir", "resourceDirs", "resource").foreach: alias =>
+      val result = ReplDirectives.classify(s"//> using $alias ${paths.mkString(" ")}")
+      assertEquals(alias, paths.map(Resource(_)), result.directives)
+      assertEquals(alias, Nil, result.warnings)
+    assertTrue(ReplDirectives.helpText.contains("Aliases: resourceDirs, resource"))
+
+  @Test def `test resource directive aliases are supported with a warning`: Unit =
+    val paths = List("res", "conf.json")
+    List("test.resourceDir", "test.resourceDirs", "test.resource").foreach: alias =>
+      val result = ReplDirectives.classify(s"//> using $alias ${paths.mkString(" ")}")
+      assertEquals(alias, paths.map(Resource(_)), result.directives)
+      assertEquals(alias, List(Warning.NoSeparateTestScope("Resources")), result.warnings)
+    assertTrue(ReplDirectives.helpText.contains("Aliases: test.resourceDirs, test.resource"))
+
   @Test def `repository directive aliases are supported`: Unit =
     val repositories = List("m2Local", "https://jitpack.io")
     List("repository", "repositories").foreach: alias =>
@@ -93,6 +109,14 @@ class ReplDirectiveTests extends ReplTest, SessionFileHelpers:
         storedOutput().trim
       )
 
+  @Test def `resourceDir directive applies to the code that follows it`: Unit =
+    val dir = resourceDir("greeting.txt", "hello")
+    initially:
+      run(s"""//> using resourceDir $dir
+             |val greeting = scala.io.Source.fromResource("greeting.txt").mkString""".stripMargin)
+      val output = storedOutput()
+      assertTrue(output, output.contains("""val greeting: String = "hello""""))
+
   @Test def `test dependency directive warns about the shared REPL scope`: Unit =
     initially:
       run("//> using test.dep org.scalameta::munit:1.1.1")