Merge pull request #1085 from scala-steward/update/scalafmt-core-3.5.1

Update scalafmt-core to 3.5.1

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 3.4.3
+version = 3.5.1
 runner.dialect = scala212
 
 project.git = true

internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala

@@ -69,8 +69,8 @@ trait CompilingSpecification extends AbstractBridgeProviderTestkit {
     val (_, testCallback) = compileSrcs(srcs)
     val binaryDependencies = testCallback.binaryDependencies
     ExtractedClassDependencies.fromPairs(
-      binaryDependencies.collect { case (_, bin, src, DependencyByMemberRef)        => src -> bin },
-      binaryDependencies.collect { case (_, bin, src, DependencyByInheritance)      => src -> bin },
+      binaryDependencies.collect { case (_, bin, src, DependencyByMemberRef) => src -> bin },
+      binaryDependencies.collect { case (_, bin, src, DependencyByInheritance) => src -> bin },
       binaryDependencies.collect { case (_, bin, src, LocalDependencyByInheritance) => src -> bin },
     )
   }
@@ -99,7 +99,10 @@ trait CompilingSpecification extends AbstractBridgeProviderTestkit {
     if (assertDefaultScope) for {
       (className, used) <- analysisCallback.usedNamesAndScopes
       analysisCallback.TestUsedName(name, scopes) <- used
-    } assert(scopes.size() == 1 && scopes.contains(UseScope.Default), s"$className uses $name in $scopes")
+    } assert(
+      scopes.size() == 1 && scopes.contains(UseScope.Default),
+      s"$className uses $name in $scopes"
+    )
 
     val classesInActualSrc = analysisCallback.classNames(tempSrcFile).map(_._1)
     classesInActualSrc.map(className => className -> analysisCallback.usedNames(className)).toMap

internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/ExtractUsedNamesPerformanceSpecification.scala

@@ -49,14 +49,15 @@ class ExtractUsedNamesPerformanceSpecification
 
   it should "be executed in reasonable time" in {
     var zipfs: Option[FileSystem] = None
-    val src = try {
-      val fileUri = getClass.getResource(TestResource).toURI
-      zipfs = initFileSystem(fileUri)
-      new String(Files.readAllBytes(Paths.get(fileUri)))
-    } finally zipfs.foreach { fs =>
-      try fs.close()
-      catch { case _: Throwable => /*ignore*/ }
-    }
+    val src =
+      try {
+        val fileUri = getClass.getResource(TestResource).toURI
+        zipfs = initFileSystem(fileUri)
+        new String(Files.readAllBytes(Paths.get(fileUri)))
+      } finally zipfs.foreach { fs =>
+          try fs.close()
+          catch { case _: Throwable => /*ignore*/ }
+        }
     import org.scalatest.time.SpanSugar._
     val usedNames = failAfter(30 seconds) {
       extractUsedNamesFromSrc(src)
@@ -80,7 +81,7 @@ class ExtractUsedNamesPerformanceSpecification
     assert(diffAndSort(usedNames("acme.DepFn1")) === diffAndSort(expectedNamesForDepFn1))
     assert(diffAndSort(usedNames("acme.HList")) === diffAndSort(expectedNamesForHList))
     // Todo
-    //assert(
+    // assert(
     //  diffAndSort(usedNames("acme.TuplerInstances")) === diffAndSort(
     //    expectedNamesForTuplerInstances))
     // assert(diffAndSort(usedNames("acme.$colon$colon")) === diffAndSort(`expectedNamesFor::`))
@@ -105,7 +106,9 @@ class ExtractUsedNamesPerformanceSpecification
       usedNames("TuplerInstances") -- scalaDiff === expectedNamesForTuplerInstances -- scalaDiff
     )
     assert(
-      usedNames("TuplerInstances.<refinement>") -- scalaDiff === expectedNamesForTuplerInstancesRefinement -- scalaDiff
+      usedNames(
+        "TuplerInstances.<refinement>"
+      ) -- scalaDiff === expectedNamesForTuplerInstancesRefinement -- scalaDiff
     )
   }
 

internal/zinc-scripted/src/test/scala/sbt/inc/ScriptedMain.scala

@@ -53,8 +53,8 @@ object ScriptedMain {
           case Some(tests) if tests.isEmpty          => fail(s"No tests in ${directoryPath}")
           case Some(_) if target == "*"              => Some(ScriptedTest(directory, target))
           case Some(tests) if tests.contains(target) => Some(ScriptedTest(directory, target))
-          case Some(_)                               => fail(s"Missing test directory ${directoryPath / target}")
-          case None                                  => fail(s"Missing parent directory ${directoryPath}")
+          case Some(_) => fail(s"Missing test directory ${directoryPath / target}")
+          case None    => fail(s"Missing parent directory ${directoryPath}")
         }
       case _ => fail("Expected only one '/' in the target scripted test(s).")
     }

internal/zinc-scripted/src/test/scala/sbt/internal/inc/BatchScriptRunner.scala

@@ -43,7 +43,7 @@ private[sbt] class BatchScriptRunner extends ScriptRunner {
     val state = states(handler).asInstanceOf[handler.State]
     Try(handler(st.command, st.arguments, state)) match {
       case Success(s) if st.successExpected => states(handler) = s
-      case Success(_)                       => throw new PreciseScriptedError(st, "Expecting error at", null)
+      case Success(_) => throw new PreciseScriptedError(st, "Expecting error at", null)
       case Failure(t: TestFailed) if st.successExpected =>
         throw new PreciseScriptedError(st, s"${t.getMessage} produced by", null)
       case Failure(err) if st.successExpected =>
@@ -58,8 +58,13 @@ private[sbt] object BatchScriptRunner {
 
   // Should be used instead of sbt.internal.scripted.TestException that doesn't show failed command
   final class PreciseScriptedError(st: Statement, msg: String, e: Throwable)
-      extends RuntimeException({
-        val args = if (st.arguments.nonEmpty) st.arguments.mkString(" ", " ", "") else ""
-        s"${st.linePrefix}$msg: '${st.command}$args'"
-      }, e, false, false)
+      extends RuntimeException(
+        {
+          val args = if (st.arguments.nonEmpty) st.arguments.mkString(" ", " ", "") else ""
+          s"${st.linePrefix}$msg: '${st.command}$args'"
+        },
+        e,
+        false,
+        false
+      )
 }

internal/zinc-scripted/src/test/scala/sbt/internal/inc/IncHandler.scala

@@ -165,7 +165,7 @@ class IncHandler(directory: Path, cacheDir: Path, scriptedLog: ManagedLogger, co
     val (project, commandToRun) = splitCommands match {
       case sub :: cmd :: Nil => buildStructure(sub) -> cmd
       case cmd :: Nil        => buildStructure(RootIdentifier) -> cmd
-      case _                 => sys.error(s"The command is either empty or has more than one `/`: $command")
+      case _ => sys.error(s"The command is either empty or has more than one `/`: $command")
     }
     val runner = (ii: IncState) => commands(commandToRun)(project, arguments, ii)
     Some(onIncState(state, project)(runner))
@@ -213,7 +213,7 @@ class IncHandler(directory: Path, cacheDir: Path, scriptedLog: ManagedLogger, co
   // and `checkRecompilations` work.
   lazy val commands: Map[String, IncCommand] = Map(
     noArgs("compile") { case (p, i) => p.compile(i).map(_ => ()) },
-    noArgs("clean") { case (p, _)   => p.clean() },
+    noArgs("clean") { case (p, _) => p.clean() },
     onArgs("checkIterations") {
       case (p, x :: Nil, i) => p.checkNumberOfCompilerIterations(i, x.toInt)
     },
@@ -238,9 +238,9 @@ class IncHandler(directory: Path, cacheDir: Path, scriptedLog: ManagedLogger, co
     onArgs("checkNameExistsInClass") {
       case (p, cls :: name :: Nil, i) => p.checkNameExistsInClass(i, dropRightColon(cls), name)
     },
-    noArgs("checkSame") { case (p, i)   => p.checkSame(i) },
+    noArgs("checkSame") { case (p, i) => p.checkSame(i) },
     onArgs("run") { case (p, params, i) => p.run(i, params) },
-    noArgs("package") { case (p, i)     => p.packageBin(i) },
+    noArgs("package") { case (p, i) => p.packageBin(i) },
     onArgs("checkWarnings") {
       case (p, count :: Nil, _) => p.checkMessages(count.toInt, Severity.Warn)
     },
@@ -573,7 +573,8 @@ case class ProjectStructure(
               } else {
                 triggerDeps(dep)._1.map(_ => dep.output)
               }
-            } else triggerDeps(dep)._1.map(_ => dep.output)
+            }
+          else triggerDeps(dep)._1.map(_ => dep.output)
         }
         val futureScalaAnalysis = earlyDeps.map { internalCp =>
           blocking {
@@ -773,7 +774,7 @@ case class ProjectStructure(
       .of()
       .withPipelining(defaultPipelining)
       .withApiDebug(true)
-    //.withRelationsDebug(true)
+    // .withRelationsDebug(true)
     val incOptions = {
       val opts = IncOptionsUtil.fromStringMap(base, map, scriptedLog)
       if (opts.recompileAllFraction() != IncOptions.defaultRecompileAllFraction()) opts

internal/zinc-scripted/src/test/scala/sbt/internal/inc/ScriptedTests.scala

@@ -139,27 +139,28 @@ final class ScriptedTests(
     runner.initStates(states, seqHandlers)
 
     try groupedTests.map {
-      case ((group, name), originalDir) =>
-        val label = s"$group/$name"
-        val loggerName = s"scripted-$group-$name.log"
-        val logFile = createScriptedLogFile(loggerName)
-        val logger = rebindLogger(batchLogger, logFile)
-        if (bufferLog) batchLogger.buffer.record()
-
-        batchLogger.log.info(s"Running $label")
-        // Copy test's contents
-        IO.copyDirectory(originalDir, batchTmpDir.toFile)
-
-        // Reset the state of `IncHandler` between every scripted run
-        runner.cleanUpHandlers(seqHandlers, states)
-        runner.initStates(states, seqHandlers)
-
-        // Run the test and delete files (except global that holds local scala jars)
-        val runTest = () => commonRunTest(label, batchTmpDir, handlers, runner, states, logger)
-        val result = runOrHandleDisabled(label, batchTmpDir, runTest, logger)
-        IO.delete(batchTmpDir.toFile.*("*" -- "global").get)
-        result
-    } finally runner.cleanUpHandlers(seqHandlers, states)
+        case ((group, name), originalDir) =>
+          val label = s"$group/$name"
+          val loggerName = s"scripted-$group-$name.log"
+          val logFile = createScriptedLogFile(loggerName)
+          val logger = rebindLogger(batchLogger, logFile)
+          if (bufferLog) batchLogger.buffer.record()
+
+          batchLogger.log.info(s"Running $label")
+          // Copy test's contents
+          IO.copyDirectory(originalDir, batchTmpDir.toFile)
+
+          // Reset the state of `IncHandler` between every scripted run
+          runner.cleanUpHandlers(seqHandlers, states)
+          runner.initStates(states, seqHandlers)
+
+          // Run the test and delete files (except global that holds local scala jars)
+          val runTest = () => commonRunTest(label, batchTmpDir, handlers, runner, states, logger)
+          val result = runOrHandleDisabled(label, batchTmpDir, runTest, logger)
+          IO.delete(batchTmpDir.toFile.*("*" -- "global").get)
+          result
+      }
+    finally runner.cleanUpHandlers(seqHandlers, states)
   }
 
   private def runOrHandleDisabled(

zinc/src/test/resources/sbt/inc/Ext1.scala

@@ -14,7 +14,4 @@ package test.pkg
 object Ext1 {
   val x = 2
 }
-class Ext1 {
-
-}
-
+class Ext1 {}

zinc/src/test/resources/sources/NoopMacroUsed.scala

@@ -14,4 +14,4 @@ import scala.language.experimental.macros
 
 class NoopMacroUsed {
   def noop(arg: Int): Int = macro NoopMacro.noop
-}
+}

zinc/src/test/resources/sources/a/AA.scala

@@ -13,4 +13,4 @@ package a
 
 import jar2.Jar2
 
-class AA(jar2: Jar2)
+class AA(jar2: Jar2)

zinc/src/test/resources/sources/b/B.scala

@@ -11,4 +11,4 @@
 
 package b
 
-class B
+class B

zinc/src/test/resources/sources/b/c/C.scala

@@ -13,4 +13,4 @@ package b.c
 
 import classesDep1.ClassesDep1
 
-class C(myDep: ClassesDep1)
+class C(myDep: ClassesDep1)

zinc/src/test/resources/sources/naha/ClientWithImplicitNotUsed.scala

@@ -13,4 +13,4 @@ package naha
 
 object ClientWithImplicitNotUsed {
   Seq(NormalDependecy.implicitMember, NormalDependecy.standardMember, WithImplicits.standardMember)
-}
+}

zinc/src/test/resources/sources/naha/ClientWithImplicitUsed.scala

@@ -18,4 +18,4 @@ object ClientWithImplicitUsed {
 
   import WithImplicits._
   vals.map(add)
-}
+}

zinc/src/test/resources/sources/naha/ClientWithoutImplicit.scala

@@ -13,4 +13,4 @@ package naha
 
 object ClientWithoutImplicit {
   Seq(NormalDependecy.standardMember, WithImplicits.standardMember)
-}
+}

zinc/src/test/resources/sources/naha/NormalDependecy.scala

@@ -14,4 +14,4 @@ package naha
 object NormalDependecy {
   def implicitMember = "implicitMemberValue"
   def standardMember = "standardMemberValue"
-}
+}

zinc/src/test/resources/sources/naha/Other2.scala

@@ -16,4 +16,4 @@ object Other2 {
   def standardMember = "standardMemberValue"
 
   val otherSealed: OtherSealed = OtherSealed2
-}
+}