Exclude folders bsp

bsp/src/mill/bsp/BspContext.scala

@@ -61,10 +61,11 @@ private[mill] class BspContext(
 
       override def rawOutputStream: PrintStream = systemStreams.out
     }
-
-    BspWorker(os.pwd, home, log).flatMap { worker =>
+    val workspace = os.pwd
+    BspWorker(workspace, home, log).flatMap { worker =>
       os.makeDir.all(home / Constants.bspDir)
       worker.startBspServer(
+        workspace,
         streams,
         logStream.getOrElse(streams.err),
         home / Constants.bspDir,

bsp/src/mill/bsp/BspWorker.scala

@@ -8,6 +8,7 @@ import java.net.URL
 
 private trait BspWorker {
   def startBspServer(
+      topLevelBuildRoot: os.Path,
       streams: SystemStreams,
       logStream: PrintStream,
       logDir: os.Path,

bsp/worker/src/mill/bsp/worker/BspWorkerImpl.scala

@@ -15,6 +15,7 @@ import scala.concurrent.{Await, CancellationException, Promise}
 private class BspWorkerImpl() extends BspWorker {
 
   override def startBspServer(
+      topLevelBuildRoot: os.Path,
       streams: SystemStreams,
       logStream: PrintStream,
       logDir: os.Path,
@@ -23,6 +24,7 @@ private class BspWorkerImpl() extends BspWorker {
 
     val millServer =
       new MillBuildServer(
+        topLevelProjectRoot = topLevelBuildRoot,
         bspVersion = Constants.bspProtocolVersion,
         serverVersion = BuildInfo.millVersion,
         serverName = Constants.serverName,

bsp/worker/src/mill/bsp/worker/MillBuildServer.scala

@@ -1,87 +1,31 @@
 package mill.bsp.worker
 
-import ch.epfl.scala.bsp4j.{
-  BuildClient,
-  BuildServer,
-  BuildServerCapabilities,
-  BuildTarget,
-  BuildTargetCapabilities,
-  BuildTargetIdentifier,
-  CleanCacheParams,
-  CleanCacheResult,
-  CompileParams,
-  CompileProvider,
-  CompileResult,
-  DebugProvider,
-  DebugSessionAddress,
-  DebugSessionParams,
-  DependencyModule,
-  DependencyModulesItem,
-  DependencyModulesParams,
-  DependencyModulesResult,
-  DependencySourcesItem,
-  DependencySourcesParams,
-  DependencySourcesResult,
-  InitializeBuildParams,
-  InitializeBuildResult,
-  InverseSourcesParams,
-  InverseSourcesResult,
-  LogMessageParams,
-  MessageType,
-  OutputPathItem,
-  OutputPathItemKind,
-  OutputPathsItem,
-  OutputPathsParams,
-  OutputPathsResult,
-  ReadParams,
-  ResourcesItem,
-  ResourcesParams,
-  ResourcesResult,
-  RunParams,
-  RunProvider,
-  RunResult,
-  SourceItem,
-  SourceItemKind,
-  SourcesItem,
-  SourcesParams,
-  SourcesResult,
-  StatusCode,
-  TaskFinishDataKind,
-  TaskFinishParams,
-  TaskId,
-  TaskStartDataKind,
-  TaskStartParams,
-  TestParams,
-  TestProvider,
-  TestResult,
-  TestTask,
-  WorkspaceBuildTargetsResult
-}
 import ch.epfl.scala.bsp4j
+import ch.epfl.scala.bsp4j._
 import com.google.gson.JsonObject
 import mill.T
 import mill.api.{DummyTestReporter, Result, Strict}
+import mill.bsp.BspServerResult
+import mill.bsp.worker.Utils.{makeBuildTarget, outputPaths, sanitizeUri}
 import mill.define.Segment.Label
 import mill.define.{Args, Discover, ExternalModule, Task}
 import mill.eval.Evaluator
+import mill.eval.Evaluator.TaskResult
 import mill.main.MainModule
-import mill.scalalib.{JavaModule, SemanticDbJavaModule, TestModule}
-import mill.scalalib.bsp.{BspModule, JvmBuildTarget, ScalaBuildTarget}
 import mill.runner.MillBuildRootModule
+import mill.scalalib.bsp.{BspModule, JvmBuildTarget, ScalaBuildTarget}
+import mill.scalalib.{JavaModule, SemanticDbJavaModule, TestModule}
 
 import java.io.PrintStream
 import java.util.concurrent.CompletableFuture
 import scala.concurrent.Promise
 import scala.jdk.CollectionConverters._
 import scala.reflect.ClassTag
-import scala.util.{Failure, Success, Try}
-import Utils.sanitizeUri
-import mill.bsp.BspServerResult
-import mill.eval.Evaluator.TaskResult
-
 import scala.util.chaining.scalaUtilChainingOps
 import scala.util.control.NonFatal
+import scala.util.{Failure, Success, Try}
 private class MillBuildServer(
+    topLevelProjectRoot: os.Path,
     bspVersion: String,
     serverVersion: String,
     serverName: String,
@@ -110,7 +54,7 @@ private class MillBuildServer(
     if (statePromise.isCompleted) statePromise = Promise[State]() // replace the promise
     evaluatorsOpt.foreach { evaluators =>
       statePromise.success(
-        new State(evaluators, debug)
+        new State(topLevelProjectRoot, evaluators, debug)
       )
     }
   }
@@ -246,30 +190,13 @@ private class MillBuildServer(
       }
 
       val bt = m.bspBuildTarget
-      val buildTarget = new BuildTarget(
-        id,
-        bt.tags.asJava,
-        bt.languageIds.asJava,
-        depsIds.asJava,
-        new BuildTargetCapabilities().tap { it =>
-          it.setCanCompile(bt.canCompile)
-          it.setCanTest(bt.canTest)
-          it.setCanRun(bt.canRun)
-          it.setCanDebug(bt.canDebug)
-        }
-      )
-
-      bt.displayName.foreach(buildTarget.setDisplayName)
-      bt.baseDirectory.foreach(p => buildTarget.setBaseDirectory(sanitizeUri(p)))
+      makeBuildTarget(id, depsIds, bt, data)
 
-      for ((dataKind, data) <- data) {
-        buildTarget.setDataKind(dataKind)
-        buildTarget.setData(data)
-      }
-
-      buildTarget
-
-    }(new WorkspaceBuildTargetsResult(_))
+    } { case (targets, state) =>
+      new WorkspaceBuildTargetsResult(
+        (targets.asScala ++ state.syntheticRootBspBuildTarget.map(_.target)).asJava
+      )
+    }
 
   override def workspaceReload(): CompletableFuture[Object] =
     completableNoState("workspaceReload", false) {
@@ -316,8 +243,10 @@ private class MillBuildServer(
       }
     ) {
       case (ev, state, id, module, items) => new SourcesItem(id, items.asJava)
-    } {
-      new SourcesResult(_)
+    } { case (sourceItems, state) =>
+      new SourcesResult(
+        (sourceItems.asScala.toSeq ++ state.syntheticRootBspBuildTarget.map(_.synthSources)).asJava
+      )
     }
 
   }
@@ -387,8 +316,8 @@ private class MillBuildServer(
 
         val cp = (resolveDepsSources ++ unmanagedClasspath).map(sanitizeUri).toSeq ++ buildSources
         new DependencySourcesItem(id, cp.asJava)
-    } {
-      new DependencySourcesResult(_)
+    } { x =>
+      new DependencySourcesResult(x._1)
     }
 
   /**
@@ -426,8 +355,8 @@ private class MillBuildServer(
           new DependencyModule(s"unmanaged-${dep.path.last}", "")
         }
         new DependencyModulesItem(id, (deps ++ unmanged).iterator.toSeq.asJava)
-    } {
-      new DependencyModulesResult(_)
+    } { x =>
+      new DependencyModulesResult(x._1)
     }
 
   override def buildTargetResources(p: ResourcesParams): CompletableFuture[ResourcesResult] =
@@ -443,14 +372,17 @@ private class MillBuildServer(
         val resourcesUrls = resources.map(_.path).filter(os.exists).map(sanitizeUri)
         new ResourcesItem(id, resourcesUrls.asJava)
 
-    } {
-      new ResourcesResult(_)
+    } { x =>
+      new ResourcesResult(x._1)
     }
 
   // TODO: if the client wants to give compilation arguments and the module
   // already has some from the build file, what to do?
   override def buildTargetCompile(p: CompileParams): CompletableFuture[CompileResult] =
     completable(s"buildTargetCompile ${p}") { state =>
+      p.setTargets(p.getTargets.asScala.filterNot(
+        state.syntheticRootBspBuildTarget.map(_.id).contains
+      ).toList.asJava)
       val params = TaskParameters.fromCompileParams(p)
       val taskId = params.hashCode()
       val compileTasksEvs = params.getTargets.distinct.map(state.bspModulesById).map {
@@ -483,29 +415,33 @@ private class MillBuildServer(
   override def buildTargetOutputPaths(params: OutputPathsParams)
       : CompletableFuture[OutputPathsResult] =
     completable(s"buildTargetOutputPaths ${params}") { state =>
+      val synthOutpaths = for {
+        synthTarget <- state.syntheticRootBspBuildTarget
+        if params.getTargets.contains(synthTarget.id)
+        baseDir <- synthTarget.bt.baseDirectory
+      } yield new OutputPathsItem(synthTarget.id, outputPaths(baseDir / "out", baseDir, topLevelProjectRoot).asJava)
+
       val items = for {
         target <- params.getTargets.asScala
         (module, ev) <- state.bspModulesById.get(target)
       } yield {
-        val items =
-          if (module.millOuterCtx.external) List(
-            new OutputPathItem(
-              // Spec says, a directory must end with a forward slash
-              sanitizeUri(ev.externalOutPath) + "/",
-              OutputPathItemKind.DIRECTORY
-            )
-          )
-          else List(
-            new OutputPathItem(
-              // Spec says, a directory must end with a forward slash
-              sanitizeUri(ev.outPath) + "/",
-              OutputPathItemKind.DIRECTORY
-            )
-          )
+        val items = {
+          module match {
+            case external if external.millOuterCtx.external =>
+              outputPaths(
+                ev.externalOutPath,
+                module.bspBuildTarget.baseDirectory.get,
+                topLevelProjectRoot
+              )
+            case _ =>
+              outputPaths(ev.outPath, module.bspBuildTarget.baseDirectory.get, topLevelProjectRoot)
+          }
+        }
+
         new OutputPathsItem(target, items.asJava)
       }
 
-      new OutputPathsResult(items.asJava)
+      new OutputPathsResult((items ++ synthOutpaths).asJava)
     }
 
   override def buildTargetRun(runParams: RunParams): CompletableFuture[RunResult] =
@@ -536,6 +472,9 @@ private class MillBuildServer(
 
   override def buildTargetTest(testParams: TestParams): CompletableFuture[TestResult] =
     completable(s"buildTargetTest ${testParams}") { state =>
+      testParams.setTargets(testParams.getTargets.asScala.toSeq.filterNot(
+        state.syntheticRootBspBuildTarget.map(_.id).contains
+      ).toList.asJava)
       val millBuildTargetIds = state
         .rootModules
         .map { case m: BspModule => state.bspIdByModule(m) }
@@ -627,6 +566,9 @@ private class MillBuildServer(
   override def buildTargetCleanCache(cleanCacheParams: CleanCacheParams)
       : CompletableFuture[CleanCacheResult] =
     completable(s"buildTargetCleanCache ${cleanCacheParams}") { state =>
+      cleanCacheParams.setTargets(cleanCacheParams.getTargets.asScala.toSeq.filterNot(
+        state.syntheticRootBspBuildTarget.map(_.id).contains
+      ).toList.asJava)
       val (msg, cleaned) =
         cleanCacheParams.getTargets.asScala.foldLeft((
           "",
@@ -675,6 +617,9 @@ private class MillBuildServer(
   override def debugSessionStart(debugParams: DebugSessionParams)
       : CompletableFuture[DebugSessionAddress] =
     completable(s"debugSessionStart ${debugParams}") { state =>
+      debugParams.setTargets(debugParams.getTargets.asScala.toSeq.filterNot(
+        state.syntheticRootBspBuildTarget.map(_.id).contains
+      ).toList.asJava)
       throw new NotImplementedError("debugSessionStart endpoint is not implemented")
     }
 
@@ -686,11 +631,13 @@ private class MillBuildServer(
       hint: String,
       targetIds: State => Seq[BuildTargetIdentifier],
       tasks: PartialFunction[BspModule, Task[W]]
-  )(f: (Evaluator, State, BuildTargetIdentifier, BspModule, W) => T)(agg: java.util.List[T] => V)
-      : CompletableFuture[V] = {
+  )(f: (Evaluator, State, BuildTargetIdentifier, BspModule, W) => T)(agg: ((
+      java.util.List[T],
+      State
+  )) => V): CompletableFuture[V] = {
     val prefix = hint.split(" ").head
     completable(hint) { state: State =>
-      val ids = targetIds(state)
+      val ids = targetIds(state).filterNot(state.syntheticRootBspBuildTarget.map(_.id).contains)
       val tasksSeq = ids.flatMap { id =>
         val (m, ev) = state.bspModulesById(id)
         tasks.lift.apply(m).map(ts => (ts, (ev, id)))
@@ -729,7 +676,7 @@ private class MillBuildServer(
             }
         }
 
-      agg(evaluated.flatten.toSeq.asJava)
+      agg((evaluated.flatten.toSeq.asJava, state))
     }
   }
 

bsp/worker/src/mill/bsp/worker/MillJavaBuildServer.scala

@@ -41,7 +41,7 @@ private trait MillJavaBuildServer extends JavaBuildServer { this: MillBuildServe
           classpath.iterator.toSeq.asJava,
           sanitizeUri(classesPath.resolve(pathResolver))
         )
-    } {
-      new JavacOptionsResult(_)
+    } { x =>
+      new JavacOptionsResult(x._1)
     }
 }

bsp/worker/src/mill/bsp/worker/MillJvmBuildServer.scala

@@ -83,8 +83,8 @@ private trait MillJvmBuildServer extends JvmBuildServer { this: MillBuildServer
         val classes = mainClass.toList ++ zincWorker.discoverMainClasses(compile)
         item.setMainClasses(classes.map(new JvmMainClass(_, Nil.asJava)).asJava)
         item
-    } {
-      agg
+    } { x =>
+      agg(x._1)
     }
   }
 
@@ -106,7 +106,7 @@ private trait MillJvmBuildServer extends JvmBuildServer { this: MillBuildServer
             .map(_.resolve(pathResolver))
             .map(sanitizeUri).toSeq.asJava
         )
-    } {
-      new JvmCompileClasspathResult(_)
+    } { x =>
+      new JvmCompileClasspathResult(x._1)
     }
 }