Fix #2678: Handle projects with only resources

frontend/src/main/scala/bloop/engine/tasks/CompileTask.scala

@@ -1,10 +1,8 @@
 package bloop.engine.tasks
 
 import java.util.Optional
-
 import scala.collection.mutable
 import scala.concurrent.Promise
-
 import bloop.CompileBackgroundTasks
 import bloop.CompileInputs
 import bloop.CompileOutPaths
@@ -37,14 +35,15 @@ import bloop.reporter.ReporterInputs
 import bloop.task.Task
 import bloop.tracing.BraveTracer
 import bloop.util.BestEffortUtils.BestEffortProducts
-
 import monix.execution.CancelableFuture
 import monix.reactive.MulticastStrategy
 import monix.reactive.Observable
 import xsbti.compile.CompileAnalysis
 import xsbti.compile.MiniSetup
 import xsbti.compile.PreviousResult
 
+import java.nio.file.Path
+
 object CompileTask {
   private implicit val logContext: DebugFilter = DebugFilter.Compilation
 
@@ -113,6 +112,25 @@ object CompileTask {
           case Left(earlyResultBundle) =>
             compileProjectTracer.terminate()
             Task.now(earlyResultBundle)
+          case Right(CopyResourcesOnly) =>
+            val denylist = Set.empty[Path] // TODO: verify if it shouldn't be computed somehow
+            val config = ParallelOps.CopyConfiguration(5, CopyMode.NoReplace, denylist, Set.empty)
+            val copyResourcesTask: Task[Unit] =
+              ParallelOps.copyResources(
+                project.runtimeResources,
+                bundle.clientClassesObserver.classesDir,
+                config,
+                logger,
+                ExecutionContext.ioScheduler
+              )
+            Task.now(
+              ResultBundle(
+                Compiler.Result.Empty,
+                None,
+                None,
+                copyResourcesTask.runAsync(ExecutionContext.ioScheduler)
+              )
+            )
           case Right(CompileSourcesAndInstance(sources, instance, _)) =>
             val readOnlyClassesDir = lastSuccessful.classesDir
             val newClassesDir = compileOut.internalNewClassesDir

frontend/src/main/scala/bloop/engine/tasks/compilation/CompileBundle.scala

@@ -101,7 +101,7 @@ final case class SuccessfulCompileBundle(
     )
   }
 
-  def prepareSourcesAndInstance: Either[ResultBundle, CompileSourcesAndInstance] = {
+  def prepareSourcesAndInstance: Either[ResultBundle, ValidSourcesAndInstances] = {
     def earlyError(msg: String): ResultBundle =
       ResultBundle(Compiler.Result.GlobalError(msg, None), None, None)
     def empty: ResultBundle = {
@@ -116,7 +116,7 @@ final case class SuccessfulCompileBundle(
     scalaInstance match {
       case Some(instance) =>
         (scalaSources, javaSources) match {
-          case (Nil, Nil) => Left(empty)
+          case (Nil, Nil) => Right(CopyResourcesOnly)
           case (Nil, _ :: _) => Right(CompileSourcesAndInstance(uniqueSources, instance, true))
           case _ => Right(CompileSourcesAndInstance(uniqueSources, instance, false))
         }
@@ -142,11 +142,15 @@ final case class SuccessfulCompileBundle(
   }
 }
 
+sealed trait ValidSourcesAndInstances
+
 case class CompileSourcesAndInstance(
     sources: List[AbsolutePath],
     instance: ScalaInstance,
     javaOnly: Boolean
-)
+) extends ValidSourcesAndInstances
+
+case object CopyResourcesOnly extends ValidSourcesAndInstances
 
 object CompileBundle {
   implicit val filter: DebugFilter.Compilation.type = bloop.logging.DebugFilter.Compilation

frontend/src/test/resources/resources-only-downstream-project/build.sbt

@@ -0,0 +1,10 @@
+Global / bloopConfigDir := baseDirectory.value / "bloop-config"
+
+ThisBuild / scalaVersion := "3.5.0"
+
+lazy val projectA = project.in(file("project-a"))
+lazy val projectAj = project.in(file("project-aj"))
+
+lazy val projectB = project
+  .in(file("project-b"))
+  .dependsOn(projectA, projectAj)

frontend/src/test/resources/resources-only-downstream-project/project-a/src/main/resources/test.txt

@@ -0,0 +1 @@
+text

frontend/src/test/resources/resources-only-downstream-project/project-aj/src/main/java/Main.java

@@ -0,0 +1,5 @@
+public class Main {
+    public static void main(String[] args) {
+        System.out.println("Hello, world!");
+    }
+}

frontend/src/test/resources/resources-only-downstream-project/project-aj/src/main/resources/test2.txt

@@ -0,0 +1 @@
+text

frontend/src/test/resources/resources-only-downstream-project/project-b/src/main/scala/Main.scala

@@ -0,0 +1,10 @@
+import scala.io.Source
+
+object Main {
+  def main(args: Array[String]): Unit = {
+    val text = Source.fromResource("test.txt").getLines().mkString
+    println(text)
+    val text2 = Source.fromResource("test2.txt").getLines().mkString
+    println(text2)
+  }
+}

frontend/src/test/resources/resources-only-downstream-project/project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.11.0

frontend/src/test/resources/resources-only-downstream-project/project/plugins.sbt

@@ -0,0 +1,8 @@
+val pluginVersion = sys.props.getOrElse(
+  "bloopVersion",
+  throw new RuntimeException("Unable to find -DbloopVersion")
+)
+
+addSbtPlugin("ch.epfl.scala" % "sbt-bloop" % pluginVersion)
+
+updateOptions := updateOptions.value.withLatestSnapshots(false)

frontend/src/test/resources/resources-test-project/build.sbt

@@ -1,5 +1,5 @@
 import Dependencies._
-bloopConfigDir in Global := baseDirectory.value / "bloop-config"
+Global / bloopConfigDir := baseDirectory.value / "bloop-config"
 
 ThisBuild / scalaVersion := "2.12.20"
 ThisBuild / version := "0.1.0-SNAPSHOT"
@@ -10,5 +10,5 @@ lazy val root = (project in file("."))
   .settings(
     name := "resources-test-project",
     libraryDependencies += munit % Test,
-    fork in Test := true
+    Test / fork := true
   )

frontend/src/test/scala/bloop/BaseCompileSpec.scala

@@ -1506,7 +1506,20 @@ abstract class BaseCompileSpec extends bloop.testing.BaseSuite {
     }
   }
 
-  test("compiler plugins are cached automatically") {
+  test("resources only downstream project resolved correctly") {
+    TestUtil.withinWorkspace { workspace =>
+      val logger = new RecordingLogger(ansiCodesSupported = false)
+      val build = loadBuildFromResources("resources-only-downstream-project", workspace, logger)
+      val projectB = build.projectFor("projectB")
+      val compiledState = build.state.compile(projectB)
+      val runState = compiledState.run(projectB)
+      println(logger.render)
+      assertExitStatus(compiledState, ExitStatus.Ok)
+      assertExitStatus(runState, ExitStatus.Ok)
+    }
+  }
+
+  ignore("compiler plugins are cached automatically") {
     TestUtil.withinWorkspace { workspace =>
       object Sources {
         // A slight modification of the original `App.scala` to trigger incremental compilation