[autofix.ci] apply automated fixes

autofix-ci[bot] · web-flow · commit 5a70426208d5 · 2025-03-17T06:57:50.000Z
diff --git a/core/codesig/src/mill/codesig/ReachabilityAnalysis.scala b/core/codesig/src/mill/codesig/ReachabilityAnalysis.scala
@@ -2,7 +2,7 @@ package mill.codesig
 
 import mill.codesig.JvmModel.*
 import mill.internal.{SpanningForest, Tarjans}
-import ujson.{Arr, Obj}
+import ujson.Obj
 import upickle.default.{Writer, writer}
 
 import scala.collection.immutable.SortedMap
@@ -266,24 +266,6 @@ object CallGraphAnalysis {
       }
   }
 
-  private def invalidClassNameSet(
-    spanningForest: SpanningForest.Node,
-    indexToClassName: Array[String]
-  ): Set[String] = {
-    val queue = mutable.ArrayBuffer.empty[(Int, SpanningForest.Node)]
-    val result = mutable.Set.empty[String]
-
-    queue.appendAll(spanningForest.values)
-
-    while (queue.nonEmpty) {
-      val (index, node) = queue.remove(0)
-      result += indexToClassName(index)
-      queue.appendAll(node.values)
-    }
-
-    result.toSet
-  }
-
   /**
    * Represents the three types of nodes in our call graph. These are kept heterogeneous
    * because flattening them out into a homogenous graph of MethodDef -> MethodDef edges
diff --git a/core/define/src/mill/define/Task.scala b/core/define/src/mill/define/Task.scala
@@ -121,16 +121,18 @@ object Task extends TaskBase {
   inline def Command[T](inline t: Result[T])(implicit
       inline w: W[T],
       inline ctx: mill.define.Ctx
-  ): Command[T] = ${ TaskMacros.commandImpl[T]('t)('w, 'ctx, exclusive = '{ false }, persistent = '{ false }) }
-
+  ): Command[T] =
+    ${ TaskMacros.commandImpl[T]('t)('w, 'ctx, exclusive = '{ false }, persistent = '{ false }) }
 
   /**
    * This version allow [[Command]] to be persistent
    */
   inline def Command[T](inline persistent: Boolean)(inline t: Result[T])(implicit
       inline w: W[T],
       inline ctx: mill.define.Ctx
-  ): Command[T] = ${ TaskMacros.commandImpl[T]('t)('w, 'ctx, exclusive = '{ false }, persistent = '{ persistent }) }
+  ): Command[T] = ${
+    TaskMacros.commandImpl[T]('t)('w, 'ctx, exclusive = '{ false }, persistent = '{ persistent })
+  }
 
   /**
    * @param exclusive Exclusive commands run serially at the end of an evaluation,
@@ -553,7 +555,15 @@ private object TaskMacros {
     appImpl[Command, T](
       (in, ev) =>
         '{
-          new Command[T]($in, $ev, $ctx, $w, ${ taskIsPrivate() }, exclusive = $exclusive, persistent = $persistent)
+          new Command[T](
+            $in,
+            $ev,
+            $ctx,
+            $w,
+            ${ taskIsPrivate() },
+            exclusive = $exclusive,
+            persistent = $persistent
+          )
         },
       t
     )
diff --git a/runner/src/mill/runner/MillBuildRootModule.scala b/runner/src/mill/runner/MillBuildRootModule.scala
@@ -141,7 +141,10 @@ abstract class MillBuildRootModule()(implicit
   }
 
   @internal
-  override protected def callGraphAnalysisIgnoreCalls(callSiteOpt: Option[MethodDef], calledSig: MethodSig): Boolean = {
+  override protected def callGraphAnalysisIgnoreCalls(
+      callSiteOpt: Option[MethodDef],
+      calledSig: MethodSig
+  ): Boolean = {
     // We ignore Commands for the same reason as we ignore Targets, and also because
     // their implementations get gathered up all the via the `Discover` macro, but this
     // is primarily for use as external entrypoints and shouldn't really be counted as
@@ -159,7 +162,7 @@ abstract class MillBuildRootModule()(implicit
       calledSig.name == "millDiscover$lzyINIT1" ||
         calledSig.name == "millDiscover" ||
         callSiteOpt.exists(_.sig.name == "millDiscover")
-    
+
     super.callGraphAnalysisIgnoreCalls(callSiteOpt, calledSig) || isCommand || isMillDiscover
   }
 
diff --git a/scalalib/src/mill/scalalib/JavaModule.scala b/scalalib/src/mill/scalalib/JavaModule.scala
@@ -21,6 +21,7 @@ import mill.util.Jvm
 import os.Path
 import scala.util.Try
 import scala.collection.mutable
+
 /**
  * Core configuration required to compile a single Java compilation target
  */
@@ -95,116 +96,122 @@ trait JavaModule
         }
     }
 
-    def testQuick(args: String*): Command[(String, Seq[TestResult])] = Task.Command(persistent = true) {
-      val quicktestFailedClassesLog = Task.dest / "quickTestFailedClasses.log"
-      val (analysisFolder, previousAnalysisFolderOpt) = callGraphAnalysis()
-      val testClasses = testForkGrouping()
-      val quickTestClassLists = previousAnalysisFolderOpt.fold {
-        // no previous analysis folder, all classes need to be tested
-        testClasses
-      } { _ =>
-        // get spanning invalidation tree content
-        val spanningInvalidationTreeObj = Try {
-          upickle.default.read[ujson.Obj](os.read.stream(analysisFolder / "spanningInvalidationTree.json"))
-        }.getOrElse(ujson.Obj())
-
-        // we cannot parse the json back to its concrete type, we only know that all of them are
-        // encoded with class name as prefix.
-        // so we can do a prefix checking to get the affected class.
-        // naive implementation won't work well as it has loop through all `testClasses` and check prefix
-        // for all of them, so we employ a prefix trie to speed up the prefix checking.
-
-        val jsonValueQueue = mutable.ArrayDeque[(String, ujson.Value)]()
-        val prefixTrie = new PrefixTrie[String]()
-        jsonValueQueue.appendAll(spanningInvalidationTreeObj.value)
-        while (jsonValueQueue.nonEmpty) {
-          val (nodeStr, value) = jsonValueQueue.removeHead()
-          val parts = nodeStr
-            .stripPrefix("def ")
-            .stripPrefix("call ")
-            .stripPrefix("external ")
-            .split("[\\.\\$\\!]")
-            .map(_.trim())
-            .toSeq
-          prefixTrie.insert(parts)
-          value match {
-            case ujson.Obj(fieldMap) => jsonValueQueue.appendAll(fieldMap)
-            case _ => ()
+    def testQuick(args: String*): Command[(String, Seq[TestResult])] =
+      Task.Command(persistent = true) {
+        val quicktestFailedClassesLog = Task.dest / "quickTestFailedClasses.log"
+        val (analysisFolder, previousAnalysisFolderOpt) = callGraphAnalysis()
+        val testClasses = testForkGrouping()
+        val quickTestClassLists = previousAnalysisFolderOpt.fold {
+          // no previous analysis folder, all classes need to be tested
+          testClasses
+        } { _ =>
+          // get spanning invalidation tree content
+          val spanningInvalidationTreeObj = Try {
+            upickle.default.read[ujson.Obj](
+              os.read.stream(analysisFolder / "spanningInvalidationTree.json")
+            )
+          }.getOrElse(ujson.Obj())
+
+          // we cannot parse the json back to its concrete type, we only know that all of them are
+          // encoded with class name as prefix.
+          // so we can do a prefix checking to get the affected class.
+          // naive implementation won't work well as it has loop through all `testClasses` and check prefix
+          // for all of them, so we employ a prefix trie to speed up the prefix checking.
+
+          val jsonValueQueue = mutable.ArrayDeque[(String, ujson.Value)]()
+          val prefixTrie = new PrefixTrie[String]()
+          jsonValueQueue.appendAll(spanningInvalidationTreeObj.value)
+          while (jsonValueQueue.nonEmpty) {
+            val (nodeStr, value) = jsonValueQueue.removeHead()
+            val parts = nodeStr
+              .stripPrefix("def ")
+              .stripPrefix("call ")
+              .stripPrefix("external ")
+              .split("[\\.\\$\\!]")
+              .map(_.trim())
+              .toSeq
+            prefixTrie.insert(parts)
+            value match {
+              case ujson.Obj(fieldMap) => jsonValueQueue.appendAll(fieldMap)
+              case _ => ()
+            }
           }
+
+          val failedTestClasses =
+            if (!os.exists(quicktestFailedClassesLog)) {
+              Set.empty[String]
+            } else {
+              Try {
+                upickle.default.read[Seq[String]](os.read.stream(quicktestFailedClassesLog))
+              }.getOrElse(Seq.empty[String]).toSet
+            }
+
+          val result = testClasses.map(_.filter { testClassName =>
+            failedTestClasses.contains(testClassName) || {
+              val parts = testClassName
+                .split("\\.")
+                .map(_.trim())
+                .toSeq
+              prefixTrie.contains(parts)
+            }
+          }).filter(_.nonEmpty)
+          // help gc
+          prefixTrie.clear()
+          result
         }
 
-        val failedTestClasses =
-          if (!os.exists(quicktestFailedClassesLog)) {
-            Set.empty[String]
-          } else {
-            Try {
-              upickle.default.read[Seq[String]](os.read.stream(quicktestFailedClassesLog))
-            }.getOrElse(Seq.empty[String]).toSet
-          }
+        // Clean up the directory for test runners
+        os.walk(Task.dest).foreach { subPath => os.remove.all(subPath) }
+
+        val quickTestReportXml = testReportXml()
+
+        val testModuleUtil = new TestModuleUtil(
+          testUseArgsFile(),
+          forkArgs(),
+          Seq.empty,
+          zincWorker().scalalibClasspath(),
+          resources(),
+          testFramework(),
+          runClasspath(),
+          testClasspath(),
+          args.toSeq,
+          quickTestClassLists,
+          zincWorker().testrunnerEntrypointClasspath(),
+          forkEnv(),
+          testSandboxWorkingDir(),
+          forkWorkingDir(),
+          quickTestReportXml,
+          zincWorker().javaHome().map(_.path),
+          testParallelism()
+        )
 
-        val result = testClasses.map(_.filter { testClassName =>
-          failedTestClasses.contains(testClassName) || {
-            val parts = testClassName
-              .split("\\.")
-              .map(_.trim())
-              .toSeq
-            prefixTrie.contains(parts)
-          }
-        }).filter(_.nonEmpty)
-        // help gc
-        prefixTrie.clear()  
-        result
-      }
+        val results = testModuleUtil.runTests()
+
+        val badTestClasses = results match {
+          case Result.Failure(_) =>
+            // Consider all quick testing classes as failed
+            quickTestClassLists.flatten
+          case Result.Success((_, results)) =>
+            // Get all test classes that failed
+            results
+              .filter(testResult => Set("Error", "Failure").contains(testResult.status))
+              .map(_.fullyQualifiedName)
+        }
 
-      // Clean up the directory for test runners
-      os.walk(Task.dest).foreach { subPath => os.remove.all(subPath) }
-
-      val quickTestReportXml = testReportXml()
-
-      val testModuleUtil = new TestModuleUtil(
-        testUseArgsFile(),
-        forkArgs(),
-        Seq.empty,
-        zincWorker().scalalibClasspath(),
-        resources(),
-        testFramework(),
-        runClasspath(),
-        testClasspath(),
-        args.toSeq,
-        quickTestClassLists,
-        zincWorker().testrunnerEntrypointClasspath(),
-        forkEnv(),
-        testSandboxWorkingDir(),
-        forkWorkingDir(),
-        quickTestReportXml,
-        zincWorker().javaHome().map(_.path),
-        testParallelism()
-      )
+        os.write.over(
+          quicktestFailedClassesLog,
+          upickle.default.write[Seq[String]](badTestClasses.distinct)
+        )
 
-      val results = testModuleUtil.runTests()
-
-      val badTestClasses = results match {
-        case Result.Failure(_) =>
-          // Consider all quick testing classes as failed
-          quickTestClassLists.flatten
-        case Result.Success((_, results)) =>
-          // Get all test classes that failed
-          results
-            .filter(testResult => Set("Error", "Failure").contains(testResult.status))
-            .map(_.fullyQualifiedName)
-      }
-      
-      os.write.over(quicktestFailedClassesLog, upickle.default.write[Seq[String]](badTestClasses.distinct))
-      
-      results match {
-        case Result.Failure(errMsg) => Result.Failure(errMsg)
-        case Result.Success((doneMsg, results)) =>
-          try TestModule.handleResults(doneMsg, results, Task.ctx(), quickTestReportXml)
-          catch {
-            case e: Throwable => Result.Failure("Test reporting failed: " + e)
-          }
+        results match {
+          case Result.Failure(errMsg) => Result.Failure(errMsg)
+          case Result.Success((doneMsg, results)) =>
+            try TestModule.handleResults(doneMsg, results, Task.ctx(), quickTestReportXml)
+            catch {
+              case e: Throwable => Result.Failure("Test reporting failed: " + e)
+            }
+        }
       }
-    }
   }
 
   def defaultCommandName(): String = "run"
@@ -1496,8 +1503,8 @@ trait JavaModule
 
   @internal
   protected def callGraphAnalysisIgnoreCalls(
-    callSiteOpt: Option[mill.codesig.JvmModel.MethodDef],
-    calledSig: mill.codesig.JvmModel.MethodSig
+      callSiteOpt: Option[mill.codesig.JvmModel.MethodDef],
+      calledSig: mill.codesig.JvmModel.MethodSig
   ): Boolean = {
     // We can ignore all calls to methods that look like Targets when traversing
     // the call graph. We can do this because we assume `def` Targets are pure,
@@ -1534,10 +1541,10 @@ trait JavaModule
           isSimpleTarget(callSiteSig.desc) && calledSig.name.contains("$anonfun")
         )
       }
-    
+
     isSimpleTarget(calledSig.desc) && !isForwarderCallsiteOrLambda
   }
-  
+
   // Return the directory containing the current call graph analysis results, and previous one too if it exists
   def callGraphAnalysis: T[(Path, Option[Path])] = Task(persistent = true) {
     os.remove.all(Task.dest / "previous")
@@ -1548,7 +1555,8 @@ trait JavaModule
       .compute(
         classFiles = os.walk(compile().classes.path).filter(_.ext == "class"),
         upstreamClasspath = compileClasspath().toSeq.map(_.path),
-        ignoreCall = (callSiteOpt, calledSig) => callGraphAnalysisIgnoreCalls(callSiteOpt, calledSig),
+        ignoreCall =
+          (callSiteOpt, calledSig) => callGraphAnalysisIgnoreCalls(callSiteOpt, calledSig),
         logger = new mill.codesig.Logger(
           Task.dest / "current",
           Option.when(debugEnabled)(Task.dest / "current")
@@ -1560,7 +1568,7 @@ trait JavaModule
             )
           )
       )
-    
+
     (Task.dest / "current", Option.when(os.exists(Task.dest / "previous"))(Task.dest / "previous"))
   }
 }
diff --git a/scalalib/src/mill/scalalib/PrefixTrie.scala b/scalalib/src/mill/scalalib/PrefixTrie.scala
