Remove private[mill] annotations from non-public submodule

core/eval/src/mill/eval/EvaluatorImpl.scala

@@ -21,21 +21,21 @@ import mill.resolve.Resolve
  * As well as [[evaluate]] which does all of these phases one after another
  */
 
-final class EvaluatorImpl private[mill] (
-    private[mill] val allowPositionalCommandArgs: Boolean,
-    private[mill] val selectiveExecution: Boolean = false,
-    private val execution: Execution
+final class EvaluatorImpl(
+    val allowPositionalCommandArgs: Boolean,
+    val selectiveExecution: Boolean = false,
+    val execution: Execution
 ) extends Evaluator {
 
-  private[mill] def workspace = execution.workspace
-  private[mill] def baseLogger = execution.baseLogger
-  private[mill] def outPath = execution.outPath
-  private[mill] def codeSignatures = execution.codeSignatures
-  private[mill] def rootModule = execution.rootModule.asInstanceOf[RootModule0]
-  private[mill] def workerCache = execution.workerCache
-  private[mill] def env = execution.env
-  private[mill] def effectiveThreadCount = execution.effectiveThreadCount
-  override private[mill] def offline: Boolean = execution.offline
+  def workspace = execution.workspace
+  def baseLogger = execution.baseLogger
+  def outPath = execution.outPath
+  def codeSignatures = execution.codeSignatures
+  def rootModule = execution.rootModule.asInstanceOf[RootModule0]
+  def workerCache = execution.workerCache
+  def env = execution.env
+  def effectiveThreadCount = execution.effectiveThreadCount
+  override def offline: Boolean = execution.offline
 
   def withBaseLogger(newBaseLogger: Logger): Evaluator = new EvaluatorImpl(
     allowPositionalCommandArgs,

core/eval/src/mill/eval/SelectiveExecutionImpl.scala

@@ -9,7 +9,7 @@ import mill.exec.{CodeSigUtils, Execution, PlanImpl}
 import mill.internal.SpanningForest
 import mill.internal.SpanningForest.breadthFirst
 
-private[mill] class SelectiveExecutionImpl(evaluator: Evaluator)
+class SelectiveExecutionImpl(evaluator: Evaluator)
     extends mill.api.SelectiveExecution {
 
   def computeHashCodeSignatures(

core/exec/src/mill/exec/CodeSigUtils.scala

@@ -6,7 +6,7 @@ import mill.api.{Task, Segment}
 import scala.reflect.NameTransformer.encode
 import java.lang.reflect.Method
 
-private[mill] object CodeSigUtils {
+object CodeSigUtils {
   def precomputeMethodNamesPerClass(transitiveNamed: Seq[Task.Named[?]])
       : (Map[Class[?], IndexedSeq[Class[?]]], Map[Class[?], Map[String, Method]]) = {
 

core/exec/src/mill/exec/Execution.scala

@@ -13,7 +13,7 @@ import scala.concurrent.*
 /**
  * Core logic of evaluating tasks, without any user-facing helper methods
  */
-private[mill] case class Execution(
+case class Execution(
     baseLogger: Logger,
     profileLogger: JsonArrayLogger.Profile,
     workspace: os.Path,
@@ -95,7 +95,7 @@ private[mill] case class Execution(
     }
   }
 
-  private def execute0(
+  def execute0(
       goals: Seq[Task[?]],
       logger: Logger,
       reporter: Int => Option[
@@ -332,7 +332,7 @@ private[mill] case class Execution(
   }
 }
 
-private[mill] object Execution {
+object Execution {
 
   /**
    * Format a failed count as a string to be used in status messages.

core/exec/src/mill/exec/ExecutionLogs.scala

@@ -7,7 +7,7 @@ import mill.internal.SpanningForest
 import java.util.concurrent.ConcurrentHashMap
 import scala.jdk.CollectionConverters.EnumerationHasAsScala
 
-private object ExecutionLogs {
+object ExecutionLogs {
   def logDependencyTree(
       interGroupDeps: Map[Task[?], Seq[Task[?]]],
       indexToTerminal: Array[Task[?]],

core/exec/src/mill/exec/GroupExecution.scala

@@ -265,7 +265,7 @@ trait GroupExecution {
     }
   }
 
-  private def executeGroup(
+  def executeGroup(
       group: Seq[Task[?]],
       results: Map[Task[?], ExecResult[(Val, Int)]],
       inputsHash: Int,
@@ -376,7 +376,7 @@ trait GroupExecution {
   // classloader/class is the same or different doesn't matter.
   def workerCacheHash(inputHash: Int): Int = inputHash + classLoaderIdentityHash
 
-  private def handleTaskResult(
+  def handleTaskResult(
       v: Val,
       hashCode: Int,
       metaPath: os.Path,
@@ -436,7 +436,7 @@ trait GroupExecution {
         (multiLogger, Some(fileLogger))
     }
 
-  private def loadCachedJson(
+  def loadCachedJson(
       logger: Logger,
       inputsHash: Int,
       labelled: Task.Named[?],
@@ -471,7 +471,7 @@ trait GroupExecution {
   def getValueHash(v: Val, task: Task[?], inputsHash: Int): Int = {
     if (task.isInstanceOf[Task.Worker[?]]) inputsHash else v.##
   }
-  private def loadUpToDateWorker(
+  def loadUpToDateWorker(
       logger: Logger,
       inputsHash: Int,
       labelled: Task.Named[?],

core/exec/src/mill/exec/PlanImpl.scala

@@ -4,7 +4,7 @@ import mill.api.{Plan, Task}
 import mill.api.MultiBiMap
 import mill.api.TopoSorted
 
-private[mill] object PlanImpl {
+object PlanImpl {
   def plan(goals: Seq[Task[?]]): Plan = {
     val transitive = PlanImpl.transitiveTasks(goals.toIndexedSeq)
     val goalSet = goals.toSet

core/internal/src/mill/internal/AnsiNav.scala

@@ -3,7 +3,7 @@ package mill.internal
 import java.io.Writer
 
 // Reference https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797
-private[mill] class AnsiNav(output: Writer) {
+class AnsiNav(output: Writer) {
   def control(n: Int, c: Char): Unit = output.write(AnsiNav.control(n, c))
 
   /**
@@ -45,7 +45,7 @@ private[mill] class AnsiNav(output: Writer) {
   def clearLine(n: Int): Unit = output.write(AnsiNav.clearLine(n))
 }
 
-private[mill] object AnsiNav {
+object AnsiNav {
   def control(n: Int, c: Char): String = "\u001b[" + n + c
   def up(n: Int): String = if (n != 0) control(n, 'A') else ""
   def down(n: Int): String = if (n != 0) control(n, 'B') else ""

core/internal/src/mill/internal/Colors.scala

@@ -1,7 +1,7 @@
 package mill.internal
 
-private[mill] case class Colors(info: fansi.Attrs, warn: fansi.Attrs, error: fansi.Attrs)
-private[mill] object Colors {
+case class Colors(info: fansi.Attrs, warn: fansi.Attrs, error: fansi.Attrs)
+object Colors {
   object Default extends Colors(fansi.Color.Blue, fansi.Color.Yellow, fansi.Color.Red)
   object BlackWhite extends Colors(fansi.Attrs.Empty, fansi.Attrs.Empty, fansi.Attrs.Empty)
 }

core/internal/src/mill/internal/FileLogger.scala

@@ -5,7 +5,7 @@ import mill.api.BuildCtx
 import java.io.{OutputStream, PrintStream}
 import java.nio.file.{Files, StandardOpenOption}
 
-private[mill] class FileLogger(
+class FileLogger(
     file: os.Path,
     append: Boolean = false
 ) extends Logger with AutoCloseable {

core/internal/src/mill/internal/JsonArrayLogger.scala

@@ -4,7 +4,7 @@ import java.io.{BufferedOutputStream, PrintStream}
 import java.nio.file.{Files, StandardOpenOption}
 import java.util.concurrent.ArrayBlockingQueue
 
-private[mill] class JsonArrayLogger[T: upickle.Writer](outPath: os.Path, indent: Int) {
+class JsonArrayLogger[T: upickle.Writer](outPath: os.Path, indent: Int) {
   private var used = false
 
   @volatile var closed = false
@@ -67,9 +67,9 @@ private[mill] class JsonArrayLogger[T: upickle.Writer](outPath: os.Path, indent:
   }
 }
 
-private[mill] object JsonArrayLogger {
+object JsonArrayLogger {
 
-  private[mill] class Profile(outPath: os.Path)
+  class Profile(outPath: os.Path)
       extends JsonArrayLogger[Profile.Timing](outPath, indent = 2) {
     def log(
         terminal: String,
@@ -110,7 +110,7 @@ private[mill] object JsonArrayLogger {
     }
   }
 
-  private[mill] class ChromeProfile(outPath: os.Path)
+  class ChromeProfile(outPath: os.Path)
       extends JsonArrayLogger[ChromeProfile.TraceEvent](outPath, indent = -1) {
 
     def logBegin(

core/internal/src/mill/internal/LinePrefixOutputStream.scala

@@ -10,7 +10,7 @@ import java.io.{ByteArrayOutputStream, FilterOutputStream, OutputStream}
  * @param linePrefix The function to provide the prefix.
  * @param out The underlying output stream.
  */
-private[mill] class LinePrefixOutputStream(
+class LinePrefixOutputStream(
     linePrefix: String,
     out: OutputStream,
     reportPrefix: () => Unit

core/internal/src/mill/internal/MultiLogger.scala

@@ -4,7 +4,7 @@ import mill.api.{Logger, SystemStreams}
 
 import java.io.{InputStream, PrintStream}
 
-private[mill] class MultiLogger(
+class MultiLogger(
     val logger1: Logger,
     val logger2: Logger,
     val inStream0: InputStream
@@ -16,7 +16,7 @@ private[mill] class MultiLogger(
     inStream0
   )
 
-  private[mill] override lazy val unprefixedStreams: SystemStreams = new SystemStreams(
+  override lazy val unprefixedStreams: SystemStreams = new SystemStreams(
     new MultiStream(logger1.unprefixedStreams.out, logger2.unprefixedStreams.out),
     new MultiStream(logger1.unprefixedStreams.err, logger2.unprefixedStreams.err),
     inStream0
@@ -46,7 +46,7 @@ private[mill] class MultiLogger(
       logger2.prompt.setPromptDetail(key, s)
     }
 
-    private[mill] override def setPromptLine(
+    override def setPromptLine(
         key: Seq[String],
         keySuffix: String,
         message: String
@@ -55,31 +55,31 @@ private[mill] class MultiLogger(
       logger2.prompt.setPromptLine(key, keySuffix, message)
     }
 
-    private[mill] override def reportKey(key: Seq[String]): Unit = {
+    override def reportKey(key: Seq[String]): Unit = {
       logger1.prompt.reportKey(key)
       logger2.prompt.reportKey(key)
     }
 
-    private[mill] override def clearPromptStatuses(): Unit = {
+    override def clearPromptStatuses(): Unit = {
       logger1.prompt.clearPromptStatuses()
       logger2.prompt.clearPromptStatuses()
     }
 
-    private[mill] override def removePromptLine(key: Seq[String], message: String): Unit = {
+    override def removePromptLine(key: Seq[String], message: String): Unit = {
       logger1.prompt.removePromptLine(key, message)
       logger2.prompt.removePromptLine(key, message)
     }
 
-    private[mill] override def setPromptHeaderPrefix(s: String): Unit = {
+    override def setPromptHeaderPrefix(s: String): Unit = {
       logger1.prompt.setPromptHeaderPrefix(s)
       logger2.prompt.setPromptHeaderPrefix(s)
     }
 
-    private[mill] override def withPromptPaused[T](t: => T): T = {
+    override def withPromptPaused[T](t: => T): T = {
       logger1.prompt.withPromptPaused(logger2.prompt.withPromptPaused(t))
     }
 
-    private[mill] override def withPromptUnpaused[T](t: => T): T = {
+    override def withPromptUnpaused[T](t: => T): T = {
       logger1.prompt.withPromptUnpaused(logger2.prompt.withPromptUnpaused(t))
     }
 
@@ -95,22 +95,22 @@ private[mill] class MultiLogger(
       logger1.prompt.errorColor(logger2.prompt.errorColor(s))
     override def colored: Boolean = logger1.prompt.colored || logger2.prompt.colored
 
-    override private[mill] def beginChromeProfileEntry(text: String): Unit = {
+    override def beginChromeProfileEntry(text: String): Unit = {
       logger1.prompt.beginChromeProfileEntry(text)
       logger2.prompt.beginChromeProfileEntry(text)
     }
 
-    override private[mill] def endChromeProfileEntry(): Unit = {
+    override def endChromeProfileEntry(): Unit = {
       logger1.prompt.endChromeProfileEntry()
       logger2.prompt.endChromeProfileEntry()
     }
 
-    override private[mill] def logBeginChromeProfileEntry(message: String, nanoTime: Long) = {
+    override def logBeginChromeProfileEntry(message: String, nanoTime: Long) = {
       logger1.prompt.logBeginChromeProfileEntry(message, nanoTime)
       logger2.prompt.logBeginChromeProfileEntry(message, nanoTime)
     }
 
-    override private[mill] def logEndChromeProfileEntry(nanoTime: Long) = {
+    override def logEndChromeProfileEntry(nanoTime: Long) = {
       logger1.prompt.logEndChromeProfileEntry(nanoTime)
       logger2.prompt.logEndChromeProfileEntry(nanoTime)
     }
@@ -120,11 +120,11 @@ private[mill] class MultiLogger(
     logger2.debug(s)
   }
 
-  private[mill] override def logKey = logger1.logKey ++ logger2.logKey
+  override def logKey = logger1.logKey ++ logger2.logKey
 
-  private[mill] override def message = logger1.message ++ logger2.message
+  override def message = logger1.message ++ logger2.message
 
-  private[mill] override def keySuffix = logger1.keySuffix ++ logger2.keySuffix
+  override def keySuffix = logger1.keySuffix ++ logger2.keySuffix
 
   override def withOutStream(outStream: PrintStream): Logger = {
     new MultiLogger(

core/internal/src/mill/internal/MultiStream.scala

@@ -1,6 +1,6 @@
 package mill.internal
 import java.io.{OutputStream, PrintStream}
-private[mill] class MultiStream(stream1: OutputStream, stream2: OutputStream)
+class MultiStream(stream1: OutputStream, stream2: OutputStream)
     extends PrintStream(new OutputStream {
       def write(b: Int): Unit = {
         stream1.write(b)

core/internal/src/mill/internal/PipeStreams.scala

@@ -9,7 +9,7 @@ import java.io.{IOException, InputStream, OutputStream}
  * somewhat cleaned up as a single object rather than two loose objects you have
  * to connect together.
  */
-private[mill] class PipeStreams(val bufferSize: Int = 1024) { pipe =>
+class PipeStreams(val bufferSize: Int = 1024) { pipe =>
 
   private var closedByWriter = false
   @volatile private var closedByReader = false

core/internal/src/mill/internal/PrefixLogger.scala

@@ -18,7 +18,7 @@ import java.io.PrintStream
  *
  * [$parentKeys-$key0] $message
  */
-private[mill] class PrefixLogger(
+class PrefixLogger(
     val logger0: Logger,
     key0: Seq[String],
     override val keySuffix: String = "",
@@ -28,7 +28,7 @@ private[mill] class PrefixLogger(
     // above the output of every command that gets run so we can see who the output belongs to
     noPrefix: Boolean = false
 ) extends Logger {
-  private[mill] override val logKey = logger0.logKey ++ key0
+  override val logKey = logger0.logKey ++ key0
 
   assert(key0.forall(_.nonEmpty))
   val linePrefix: String =
@@ -50,7 +50,7 @@ private[mill] class PrefixLogger(
     logger0.streams.in
   )
 
-  private[mill] override val unprefixedStreams = new SystemStreams(
+  override val unprefixedStreams = new SystemStreams(
     logger0.unprefixedStreams.out,
     logger0.unprefixedStreams.err,
     logger0.unprefixedStreams.in