bugfix: Also copy resources on noop

backend/src/main/scala/bloop/BloopClassFileManager.scala

@@ -201,34 +201,6 @@ final class BloopClassFileManager(
 
   }
 
-  private def copyResources(
-      resources: List[AbsolutePath],
-      copyTo: AbsolutePath,
-      config: ParallelOps.CopyConfiguration
-  ): Task[Unit] = {
-    val (singleFiles, classpathEntries) =
-      resources.partition(path => path.exists && path.isFile)
-
-    val singleFilesToCopy =
-      for (file <- singleFiles)
-        yield file.underlying -> copyTo.underlying.resolve(file.underlying.toFile().getName())
-
-    val classpathEntriesCopy =
-      for (entry <- classpathEntries) yield {
-        ParallelOps
-          .copyDirectories(config)(
-            entry.underlying,
-            copyTo.underlying,
-            inputs.ioScheduler,
-            enableCancellation = false,
-            inputs.logger,
-            singleFilesToCopy
-          )
-      }
-
-    Task.gatherUnordered(classpathEntriesCopy).map(_ => ())
-  }
-
   def complete(success: Boolean): Unit = {
 
     val deleteAfterCompilation = Task { BloopPaths.delete(AbsolutePath(backupDir)) }
@@ -262,11 +234,18 @@ final class BloopClassFileManager(
               }
               .flatMap(_ => deleteAfterCompilation)
 
+            val copyResources = ParallelOps.copyResources(
+              inputs.resources,
+              clientExternalClassesDir,
+              config,
+              inputs.logger,
+              inputs.ioScheduler
+            )
             Task
               .gatherUnordered(
                 List(
                   copyClassFiles,
-                  copyResources(inputs.resources, clientExternalClassesDir, config)
+                  copyResources
                 )
               )
               .map(_ => ())

backend/src/main/scala/bloop/Compiler.scala

@@ -804,6 +804,14 @@ object Compiler {
         val denyDir = Set(readOnlyClassesDir.resolve("META-INF/best-effort"))
         val config =
           ParallelOps.CopyConfiguration(5, CopyMode.ReplaceIfMetadataMismatch, denyList, denyDir)
+
+        val copyResources = ParallelOps.copyResources(
+          compileInputs.resources,
+          clientClassesDir,
+          config,
+          compileInputs.logger,
+          compileInputs.ioScheduler
+        )
         val lastCopy = ParallelOps.copyDirectories(config)(
           readOnlyClassesDir,
           clientClassesDir.underlying,
@@ -812,7 +820,7 @@ object Compiler {
           compileInputs.logger
         )
 
-        lastCopy.map { _ =>
+        Task.gatherUnordered(List(copyResources, lastCopy)).map { _ =>
           clientLogger.debug(
             s"Finished copying classes from $readOnlyClassesDir to $clientClassesDir"
           )

backend/src/main/scala/bloop/io/ParallelOps.scala

@@ -52,6 +52,39 @@ object ParallelOps {
 
   private[this] val takenByOtherCopyProcess = new ConcurrentHashMap[Path, Promise[Unit]]()
 
+  /**
+   * Copies the resources in `resources` to the directory `copyTo` ,
+   */
+  def copyResources(
+      resources: List[AbsolutePath],
+      copyTo: AbsolutePath,
+      config: ParallelOps.CopyConfiguration,
+      logger: Logger,
+      scheduler: Scheduler
+  ): Task[Unit] = {
+    val (singleFiles, classpathEntries) =
+      resources.partition(path => path.exists && path.isFile)
+
+    val singleFilesToCopy =
+      for (file <- singleFiles)
+        yield file.underlying -> copyTo.underlying.resolve(file.underlying.toFile().getName())
+
+    val classpathEntriesCopy =
+      for (entry <- classpathEntries) yield {
+        ParallelOps
+          .copyDirectories(config)(
+            entry.underlying,
+            copyTo.underlying,
+            scheduler,
+            enableCancellation = false,
+            logger,
+            singleFilesToCopy
+          )
+      }
+
+    Task.gatherUnordered(classpathEntriesCopy).map(_ => ())
+  }
+
   /**
    * Copies files from [[origin]] to [[target]] with the provided copy
    * configuration in parallel on the scheduler [[scheduler]].

frontend/src/test/scala/bloop/RunSpec.scala

@@ -505,6 +505,13 @@ class RunSpec extends BloopHelpers {
       val state = loadState(workspace, projects, logger)
       val runState = state.run(`A`)
       assertEquals(ExitStatus.Ok, runState.status)
+
+      // Remove to make sure we copy on noop
+      state.getClientExternalDir(A).resolve("resource.txt").toFile.delete()
+
+      val state2 = loadState(workspace, projects, logger)
+      val runState2 = state2.run(`A`)
+      assertEquals(ExitStatus.Ok, runState2.status)
     }
   }