[autofix.ci] apply automated fixes

Author: autofix-ci[bot]

runner/daemon/src/mill/daemon/Watching.scala

@@ -95,70 +95,77 @@ object Watching {
             if (alreadyStale) {
               enterKeyPressed = false
             } else {
-              enterKeyPressed = watchAndWait(streams, streams.in, watchables, watchArgs, watchViaNotify)
+              enterKeyPressed =
+                watchAndWait(streams, streams.in, watchables, watchArgs, watchViaNotify)
             }
           }
           throw new IllegalStateException("unreachable")
         }
 
         if (watchArgs.useNotify) {
-          Using.resource(os.write.outputStream(watchArgs.serverDir / "fsNotifyWatchLog")) { watchLog =>
-            def writeToWatchLog(s: String): Unit = {
-              try {
-                watchLog.write(s.getBytes(java.nio.charset.StandardCharsets.UTF_8))
-                watchLog.write('\n')
-              } catch {
-                case _: ClosedChannelException => /* do nothing, the file is already closed */
+          Using.resource(os.write.outputStream(watchArgs.serverDir / "fsNotifyWatchLog")) {
+            watchLog =>
+              def writeToWatchLog(s: String): Unit = {
+                try {
+                  watchLog.write(s.getBytes(java.nio.charset.StandardCharsets.UTF_8))
+                  watchLog.write('\n')
+                } catch {
+                  case _: ClosedChannelException => /* do nothing, the file is already closed */
+                }
               }
-            }
 
-            val watchedFiles = evaluateOnce()
-            writeToWatchLog(s"[watched-paths:unfiltered] ${watchedFiles.watchedPathsSet.toSeq.sorted.mkString("\n")}")
-            writeToWatchLog(s"[watched-paths:filtered] ${watchedFiles.filterPaths.toSeq.sorted.mkString("\n")}")
-
-            // Start the watch before entering the evaluation loop to make sure no events fall through.
-            @volatile var pathChangesDetected = false
-            Using.resource(os.watch.watch(
-              // Just watch the root folder
-              Seq(workspaceRoot),
-              filter = path => {
-                val shouldBeWatched =
-                  watchedFiles.filterPaths.contains(path) || watchedFiles.watchedPathsSet.exists(watchedPath =>
-                    path.startsWith(watchedPath)
+              val watchedFiles = evaluateOnce()
+              writeToWatchLog(
+                s"[watched-paths:unfiltered] ${watchedFiles.watchedPathsSet.toSeq.sorted.mkString("\n")}"
+              )
+              writeToWatchLog(
+                s"[watched-paths:filtered] ${watchedFiles.filterPaths.toSeq.sorted.mkString("\n")}"
+              )
+
+              // Start the watch before entering the evaluation loop to make sure no events fall through.
+              @volatile var pathChangesDetected = false
+              Using.resource(os.watch.watch(
+                // Just watch the root folder
+                Seq(workspaceRoot),
+                filter = path => {
+                  val shouldBeWatched =
+                    watchedFiles.filterPaths.contains(path) || watchedFiles.watchedPathsSet.exists(
+                      watchedPath =>
+                        path.startsWith(watchedPath)
+                    )
+                  writeToWatchLog(s"[filter] (shouldBeWatched=$shouldBeWatched) $path")
+                  shouldBeWatched
+                },
+                onEvent = changedPaths => {
+                  // Make sure that the changed paths are actually the ones in our watch list and not some adjacent files in the
+                  // same folder
+                  val hasWatchedPath =
+                    changedPaths.exists(p =>
+                      watchedFiles.watchedPathsSet.exists(watchedPath => p.startsWith(watchedPath))
+                    )
+                  writeToWatchLog(
+                    s"[changed-paths] (hasWatchedPath=$hasWatchedPath) ${changedPaths.mkString("\n")}"
                   )
-                writeToWatchLog(s"[filter] (shouldBeWatched=$shouldBeWatched) $path")
-                shouldBeWatched
-              },
-              onEvent = changedPaths => {
-                // Make sure that the changed paths are actually the ones in our watch list and not some adjacent files in the
-                // same folder
-                val hasWatchedPath =
-                  changedPaths.exists(p =>
-                    watchedFiles.watchedPathsSet.exists(watchedPath => p.startsWith(watchedPath))
-                  )
-                writeToWatchLog(
-                  s"[changed-paths] (hasWatchedPath=$hasWatchedPath) ${changedPaths.mkString("\n")}"
-                )
-                if (hasWatchedPath) {
-                  pathChangesDetected = true
-                }
-              },
-              logger = (eventType, data) =>
-                writeToWatchLog(s"[watch:event] $eventType: ${pprint.apply(data).plainText}")
-            )) { _ =>
-              loop(Some(WatchViaNotifyArgs(notifiablesChanged = () => pathChangesDetected)))
-            }
+                  if (hasWatchedPath) {
+                    pathChangesDetected = true
+                  }
+                },
+                logger = (eventType, data) =>
+                  writeToWatchLog(s"[watch:event] $eventType: ${pprint.apply(data).plainText}")
+              )) { _ =>
+                loop(Some(WatchViaNotifyArgs(notifiablesChanged = () => pathChangesDetected)))
+              }
           }
         } else loop(watchViaNotify = None)
     }
   }
 
   private case class WatchedFiles(
-    watched: Seq[Watchable],
-    watchedPollables: Seq[Watchable.Pollable],
-    watchedPathsSeq: Seq[Watchable.Path],
-    watchedPathsSet: Set[os.Path],
-    filterPaths: Set[os.Path]
+      watched: Seq[Watchable],
+      watchedPollables: Seq[Watchable.Pollable],
+      watchedPathsSeq: Seq[Watchable.Path],
+      watchedPathsSet: Set[os.Path],
+      filterPaths: Set[os.Path]
   ) {
     def watchedValueCount: Int = watched.size - watchedPathsSeq.size
 
@@ -198,8 +205,11 @@ object Watching {
       }
 
       apply(
-        watched = watched, watchedPollables = watchedPollables, watchedPathsSeq = watchedPathsSeq,
-        watchedPathsSet = watchedPathsSet, filterPaths = filterPaths
+        watched = watched,
+        watchedPollables = watchedPollables,
+        watchedPathsSeq = watchedPathsSeq,
+        watchedPathsSet = watchedPathsSet,
+        filterPaths = filterPaths
       )
     }
   }
@@ -229,7 +239,8 @@ object Watching {
 
     watchViaNotifyArgs match {
       case Some(notifyArgs) => doWatch(notifyArgs.notifiablesChanged)
-      case None => doWatch(notifiablesChanged = () => watchedPathsSeq.exists(p => !validateAnyWatchable(p)))
+      case None =>
+        doWatch(notifiablesChanged = () => watchedPathsSeq.exists(p => !validateAnyWatchable(p)))
     }
   }