Moved BSP-specific module API out of public trait MainModule (#5496)

Fix #5492

Same motivation as for #5214: We
use a dedicated `trait` (`BspMainModuleApi`) to hold internal BSP tasks.
This is, to free the binary compatibly Module API from these internal tasks.

Pull request: #5496

Author: lefou

core/api/daemon/src/mill/api/daemon/internal/MainModuleApi.scala

@@ -1,8 +1,12 @@
 package mill.api.daemon.internal
 
+import mill.api.daemon.internal.bsp.BspMainModuleApi
+
 trait MainModuleApi extends ModuleApi {
-  private[mill] def bspClean(
-      evaluator: EvaluatorApi,
-      tasks: String*
-  ): TaskApi[Seq[java.nio.file.Path]]
+
+  /**
+   * Internal access to some BSP helper tasks
+   */
+  private[mill] def bspMainModule: () => BspMainModuleApi
+
 }

core/api/daemon/src/mill/api/daemon/internal/bsp/BspMainModuleApi.scala

@@ -0,0 +1,12 @@
+package mill.api.daemon.internal.bsp
+
+import mill.api.daemon.internal.{EvaluatorApi, ModuleApi, TaskApi}
+
+trait BspMainModuleApi extends ModuleApi {
+
+  private[mill] def bspClean(
+      evaluator: EvaluatorApi,
+      tasks: String*
+  ): TaskApi[Seq[java.nio.file.Path]]
+
+}

libs/util/src/mill/util/MainModule.scala

@@ -2,13 +2,14 @@ package mill.util
 
 import mill.{util, *}
 import mill.api.*
-import mill.api.daemon.internal.{EvaluatorApi, MainModuleApi, TaskApi}
+import mill.api.daemon.internal.MainModuleApi
 import mill.api.*
-import mill.api.internal.{RootModule0, RootModule}
+import mill.api.internal.{RootModule, RootModule0}
 import mill.api.SelectMode.Separated
 import mill.api.daemon.Watchable
 import mill.moduledefs.Scaladoc
 import mill.api.BuildCtx
+import mill.api.daemon.internal.bsp.BspMainModuleApi
 
 import java.util.concurrent.LinkedBlockingQueue
 import scala.collection.mutable
@@ -24,7 +25,14 @@ abstract class MainRootModule()(implicit
  * [[mill.api.Module]] containing all the default tasks that Mill provides: [[resolve]],
  * [[show]], [[inspect]], [[plan]], etc.
  */
-trait MainModule extends RootModule0 with MainModuleApi {
+trait MainModule extends RootModule0, MainModuleApi {
+
+  private lazy val bspExt = {
+    import bsp.BspMainModule.given
+    ModuleRef(this.internalBspMainModule)
+  }
+
+  private[mill] def bspMainModule: () => BspMainModuleApi = () => bspExt()
 
   /**
    * Show the mill version.
@@ -139,13 +147,6 @@ trait MainModule extends RootModule0 with MainModuleApi {
       }
     }
 
-  private[mill] def bspClean(
-      evaluator: EvaluatorApi,
-      tasks: String*
-  ): TaskApi[Seq[java.nio.file.Path]] = Task.Anon {
-    cleanTask(evaluator.asInstanceOf[Evaluator], tasks*)().map(_.path.toNIO)
-  }
-
   /**
    * Deletes the given targets from the out directory. Providing no targets
    * will clean everything.

libs/util/src/mill/util/bsp/BspMainModule.scala

@@ -0,0 +1,39 @@
+package mill.util.bsp
+
+import mill.api.JsonFormatters.given
+import mill.api.daemon.internal.bsp.BspMainModuleApi
+import mill.api.daemon.internal.{EvaluatorApi, TaskApi, internal}
+import mill.api.{Discover, Evaluator, ExternalModule, ModuleCtx}
+import mill.util.MainModule
+import mill.Task
+
+import java.nio.file.Path
+
+@internal
+private[mill] object BspMainModule extends ExternalModule {
+
+  // Requirement of ExternalModule's
+  override protected def millDiscover: Discover = Discover[this.type]
+
+  // Hack-ish way to have some BSP state in the module context
+  @internal
+  implicit class EmbeddableBspMainModule(mainModule: MainModule)
+      extends mill.api.Module {
+    // We act in the context of the module
+    override def moduleCtx: ModuleCtx = mainModule.moduleCtx
+
+    // We keep all BSP-related tasks/state in this sub-module
+    @internal
+    object internalBspMainModule extends mill.api.Module with BspMainModuleApi {
+
+      private[mill] def bspClean(
+          evaluator: EvaluatorApi,
+          tasks: String*
+      ): TaskApi[Seq[java.nio.file.Path]] = Task.Anon {
+        mainModule.cleanTask(evaluator.asInstanceOf[Evaluator], tasks*)().map(_.path.toNIO)
+      }
+
+    }
+  }
+
+}

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

@@ -706,7 +706,7 @@ private class MillBuildServer(
             val mainModule = ev.rootModule.asInstanceOf[mill.api.daemon.internal.MainModuleApi]
             val compileTaskName = (module.moduleSegments ++ Label("compile")).render
             logger.debug(s"about to clean: ${compileTaskName}")
-            val cleanTask = mainModule.bspClean(ev, Seq(compileTaskName)*)
+            val cleanTask = mainModule.bspMainModule().bspClean(ev, Seq(compileTaskName)*)
             val cleanResult = evaluate(
               ev,
               s"Cleaning cache of ${module.bspDisplayName}",