From f9688c1464bf2b8f9f39e02fef5820c2f19c1fc8 Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Thu, 10 Sep 2026 13:52:19 -0400
Subject: [PATCH] Apply Scalafmt format (Scala 3 syntax)

---
 build.sbt                                     |  64 +-
 .../main/scala/sbt/internal/DslEntry.scala    |  43 +-
 .../src/main/scala/sbt/internal/Eval.scala    |  17 +-
 .../sbt/internal/EvaluateConfigurations.scala |  82 +--
 .../scala/sbt/internal/LoadedSbtFile.scala    |  22 +-
 .../scala/sbt/internal/parser/SbtParser.scala |  32 +-
 .../sbt/internal/parser/SbtRefactorings.scala |  22 +-
 .../internal/parser/CheckIfParsedSpec.scala   |  12 +-
 .../internal/parser/CommentedXmlSpec.scala    |   4 +-
 .../sbt/internal/parser/EmbeddedXmlSpec.scala |  10 +-
 .../sbt/internal/parser/NewFormatSpec.scala   |   4 +-
 .../internal/parser/SbtParserErrorSpec.scala  |   4 +-
 .../internal/parser/SessionSettingsSpec.scala |   4 +-
 .../parser/SplitExpressionsBehavior.scala     |  13 +-
 .../sbt/internal/util/appmacro/Cont.scala     |  14 +-
 .../internal/util/appmacro/ContextUtil.scala  |   3 +
 .../sbt/internal/util/appmacro/Convert.scala  |   1 +
 .../scala/sbt/internal/util/LineReader.scala  | 105 +--
 .../internal/util/complete/Completions.scala  |  52 +-
 .../internal/util/complete/EditDistance.scala |  28 +-
 .../util/complete/ExampleSource.scala         |  13 +-
 .../sbt/internal/util/complete/History.scala  |  24 +-
 .../util/complete/HistoryCommands.scala       |  17 +-
 .../util/complete/JLineCompletion.scala       |  97 +--
 .../sbt/internal/util/complete/Parser.scala   | 350 ++++-----
 .../sbt/internal/util/complete/Parsers.scala  |  56 +-
 .../internal/util/complete/ProcessError.scala |  22 +-
 .../internal/util/complete/SizeParser.scala   |  19 +-
 .../util/complete/TokenCompletions.scala      |  34 +-
 .../internal/util/complete/TypeString.scala   |  40 +-
 .../internal/util/complete/UpperBound.scala   |  13 +-
 .../src/test/scala/DefaultParsersSpec.scala   |   7 +-
 .../src/test/scala/ParserTest.scala           |  42 +-
 .../scala/sbt/complete/FileExamplesTest.scala |  15 +-
 .../sbt/complete/FixedSetExamplesTest.scala   |  12 +-
 .../sbt/complete/ParserWithExamplesTest.scala |  35 +-
 .../sbt/internal/util/ErrorHandling.scala     |  30 +-
 .../scala/sbt/internal/util/ExitHook.scala    |  14 +-
 .../sbt/internal/util/RunningProcesses.scala  |   3 +-
 .../internal/util/hashing/FarmHash64.scala    |   3 +
 .../hashing/StreamingXXHash64VarHandle.scala  |   2 +
 .../sbt/internal/util/hashing/XXHash64.scala  |   2 +
 .../util/appmacro/StringTypeTag.scala         |   5 +-
 .../main/scala/sbt/internal/util/Util.scala   |  26 +-
 .../scala/sbt/internal/util/BasicLogger.scala |   3 +-
 .../sbt/internal/util/BufferedLogger.scala    | 101 ++-
 .../sbt/internal/util/ConsoleAppender.scala   | 133 ++--
 .../scala/sbt/internal/util/ConsoleOut.scala  |  67 +-
 .../scala/sbt/internal/util/EscHelpers.scala  |  85 +--
 .../sbt/internal/util/FilterLogger.scala      |  27 +-
 .../scala/sbt/internal/util/FullLogger.scala  |  24 +-
 .../sbt/internal/util/GlobalLogging.scala     |  17 +-
 .../main/scala/sbt/internal/util/JLine3.scala | 147 ++--
 .../sbt/internal/util/LoggerWriter.scala      |  19 +-
 .../sbt/internal/util/MainAppender.scala      |  22 +-
 .../sbt/internal/util/ManagedLogger.scala     |  20 +-
 .../scala/sbt/internal/util/MultiLogger.scala |  20 +-
 .../scala/sbt/internal/util/ObjectEvent.scala |   6 +-
 .../sbt/internal/util/ProgressState.scala     | 118 ++-
 .../main/scala/sbt/internal/util/Prompt.scala |  17 +-
 .../scala/sbt/internal/util/StackTrace.scala  |  36 +-
 .../scala/sbt/internal/util/Terminal.scala    | 439 +++++------
 .../internal/util/WindowsInputStream.scala    |  76 +-
 .../internal/util/codec/JValueFormats.scala   |  26 +-
 .../internal/util/codec/PositionFormats.scala |  20 +-
 .../internal/util/codec/ProblemFormats.scala  |  20 +-
 .../internal/util/codec/SeverityFormats.scala |  22 +-
 .../util/codec/SuccessEventShowLines.scala    |   7 +-
 .../util/codec/ThrowableShowLines.scala       |  14 +-
 .../main/scala/sbt/util/AbstractLogger.scala  |  10 +-
 .../main/scala/sbt/util/InterfaceUtil.scala   |  88 +--
 .../src/main/scala/sbt/util/Level.scala       |   6 +-
 .../src/main/scala/sbt/util/LogEvent.scala    |   6 +-
 .../src/main/scala/sbt/util/LogExchange.scala |  16 +-
 .../src/main/scala/sbt/util/Logger.scala      |  26 +-
 .../main/scala/sbt/util/LoggerContext.scala   |  64 +-
 .../src/main/scala/sbt/util/ShowLines.scala   |  10 +-
 .../util-logging/src/test/scala/Escapes.scala |  54 +-
 .../src/test/scala/LogWriterTest.scala        |  71 +-
 .../src/test/scala/ProblemTest.scala          |  63 +-
 .../src/test/scala/TestLogger.scala           |   6 +-
 .../sbt/internal/util/CleanStringSpec.scala   |   4 +-
 .../sbt/internal/util/TerminalColorSpec.scala |   7 +-
 .../scala/sbt/internal/util/logic/Logic.scala | 118 ++-
 .../src/test/scala/sbt/logic/Test.scala       |  34 +-
 .../internal/util/SourcePositionMacro.scala   |   9 +-
 .../scala/sbt/internal/util/Positions.scala   |  12 +-
 .../internal/util/SourcePositionSpec.scala    |   3 +-
 .../scala/sbt/internal/util/Relation.scala    |  36 +-
 .../src/test/scala/RelationTest.scala         |  12 +-
 .../internal/scripted/CommentHandler.scala    |   3 +-
 .../sbt/internal/scripted/FileCommands.scala  |  49 +-
 .../internal/scripted/FilteredLoader.scala    |  11 +-
 .../internal/scripted/HandlersProvider.scala  |   3 +-
 .../sbt/internal/scripted/ScriptRunner.scala  |  45 +-
 .../sbt/internal/scripted/ScriptedTests.scala | 124 ++--
 .../internal/scripted/StatementHandler.scala  |   9 +-
 .../internal/scripted/TestScriptParser.scala  |  35 +-
 launcher-package/build.sbt                    | 131 ++--
 .../src/test/scala/BspConfigTest.scala        |   7 +-
 .../src/test/scala/ExtendedRunnerTest.scala   |  39 +-
 .../src/test/scala/IntegrationTestPaths.scala |  15 +-
 .../src/test/scala/LauncherTestHelper.scala   |   3 +-
 .../src/test/scala/RunnerScriptTest.scala     |  14 +-
 .../src/test/scala/ShellScriptUtil.scala      |  80 +-
 .../CompatibilityWarning.scala                |  24 +-
 .../librarymanagement/InternalDefaults.scala  |   3 +-
 .../librarymanagement/IvyConfigurations.scala |  11 +-
 .../internal/librarymanagement/IvySbt.scala   |   3 +-
 .../internal/librarymanagement/JsonUtil.scala |  40 +-
 .../librarymanagement/LMSysProp.scala         |  20 +-
 .../librarymanagement/SemSelOperator.scala    |   9 +-
 .../SemanticSelectorExtra.scala               | 102 ++-
 .../librarymanagement/StringUtilities.scala   |   5 +-
 .../UpdateClassifiersUtil.scala               |  23 +-
 .../UpdateReportInterner.scala                |  13 +-
 .../UpdateReportPersistence.scala             |   2 +
 .../librarymanagement/VersionRange.scala      | 137 ++--
 .../librarymanagement/VersionSchemes.scala    |  10 +-
 .../librarymanagement/WeakPools.scala         |  34 +-
 .../cross/CrossVersionUtil.scala              |  44 +-
 .../formats/GlobalLockFormat.scala            |  10 +-
 .../formats/LoggerFormat.scala                |   4 +-
 .../formats/LogicalClockFormats.scala         |   4 +-
 .../formats/NodeSeqFormat.scala               |   4 +-
 .../sbt/librarymanagement/ArtifactExtra.scala |  37 +-
 .../sbt/librarymanagement/ConfigRef.scala     |  22 +-
 .../librarymanagement/ConfigRefFormats.scala  |  16 +-
 .../sbt/librarymanagement/Configuration.scala |  10 +-
 .../ConfigurationExtra.scala                  |  21 +-
 .../ConfigurationFormats.scala                |  16 +-
 .../librarymanagement/ConflictWarning.scala   |  36 +-
 .../sbt/librarymanagement/Credentials.scala   |  11 +-
 .../sbt/librarymanagement/CrossVersion.scala  | 306 +++-----
 .../librarymanagement/CrossVersionExtra.scala |  42 +-
 .../DependencyBuilders.scala                  |  40 +-
 .../librarymanagement/DependencyFilter.scala  |  23 +-
 .../DependencyResolution.scala                |  32 +-
 .../sbt/librarymanagement/EvictionError.scala |  60 +-
 .../librarymanagement/EvictionWarning.scala   | 155 ++--
 .../scala/sbt/librarymanagement/Extra.scala   |  16 +-
 .../scala/sbt/librarymanagement/Http.scala    |   3 +-
 .../LibraryManagementInterface.scala          |  12 +-
 .../LibraryManagementSyntax.scala             |   7 +-
 .../sbt/librarymanagement/LogicalClock.scala  |  12 +-
 .../MakePomConfigurationExtra.scala           |   3 +-
 .../MemoizedFileFormats.scala                 |  22 +-
 .../sbt/librarymanagement/ModuleIDExtra.scala |  52 +-
 .../sbt/librarymanagement/Publisher.scala     |   7 +-
 .../sbt/librarymanagement/ResolverExtra.scala | 150 ++--
 .../librarymanagement/RichUpdateReport.scala  |  26 +-
 .../librarymanagement/ScalaArtifacts.scala    |  51 +-
 .../sbt/librarymanagement/TrackLevel.scala    |  20 +-
 .../librarymanagement/UnresolvedWarning.scala |  25 +-
 .../librarymanagement/UpdateReportExtra.scala |  60 +-
 .../sbt/librarymanagement/VersionNumber.scala |  65 +-
 lm-core/src/test/scala/ConfigMacroSpec.scala  |  16 +-
 .../tests/CrossVersionCompatTest.scala        |  34 +-
 .../UpdateReportCacheCodecSpec.scala          |   1 +
 .../UpdateReportFormatSpec.scala              |   1 +
 .../UpdateReportInternerSpec.scala            |   1 +
 .../UpdateReportPersistenceBenchmark.scala    |   5 +-
 .../UpdateReportPersistenceSpec.scala         |   2 +
 .../librarymanagement/WeakInternerSpec.scala  |   1 +
 .../sbt/librarymanagement/ArtifactTest.scala  |   4 +-
 .../librarymanagement/ConfigMacroTest.scala   |   3 +-
 .../librarymanagement/CrossVersionTest.scala  |   4 +-
 .../MemoizedFileFormatsSpec.scala             |   1 +
 .../sbt/librarymanagement/ModuleIdTest.scala  |   4 +-
 .../sbt/librarymanagement/ResolverTest.scala  |   4 +-
 .../SemanticSelectorSpec.scala                |   4 +-
 .../librarymanagement/VersionNumberSpec.scala |  15 +-
 .../librarymanagement/VersionRangeSpec.scala  |   4 +-
 .../credentials/DirectCredentials.scala       |   3 +-
 .../definitions/Authentication.scala          |   3 +-
 .../CoursierDependencyResolution.scala        | 127 ++--
 .../src/main/scala/lmcoursier/FromSbt.scala   |  53 +-
 .../src/main/scala/lmcoursier/Inputs.scala    |  65 +-
 .../src/main/scala/lmcoursier/IvyXml.scala    |  26 +-
 .../lmcoursier/definitions/CacheLogger.scala  |   7 +-
 .../lmcoursier/definitions/CachePolicy.scala  |   4 +-
 .../lmcoursier/definitions/FromCoursier.scala |   6 +-
 .../definitions/Reconciliation.scala          |   6 +-
 .../lmcoursier/definitions/ToCoursier.scala   |  16 +-
 .../lmcoursier/internal/ArtifactsRun.scala    |  36 +-
 .../lmcoursier/internal/BuildClock.scala      |  11 +-
 .../internal/CacheUrlConversion.scala         |  34 +-
 .../internal/CoursierModuleDescriptor.scala   |   3 +-
 .../internal/InterProjectRepository.scala     |   7 +-
 .../main/scala/lmcoursier/internal/Lock.scala |   5 +-
 .../scala/lmcoursier/internal/LockFile.scala  |  22 +-
 .../internal/LockFileConstants.scala          |   3 +-
 .../lmcoursier/internal/LockFileFormats.scala |  66 +-
 .../internal/LockedArtifactsRun.scala         |  32 +-
 .../internal/ResolutionParams.scala           |  29 +-
 .../lmcoursier/internal/ResolutionRun.scala   | 110 ++-
 .../internal/ResolutionSerializer.scala       |  25 +-
 .../scala/lmcoursier/internal/Resolvers.scala |  63 +-
 .../lmcoursier/internal/SbtBootJars.scala     |   3 +-
 .../internal/SbtCoursierCache.scala           |  13 +-
 .../lmcoursier/internal/SbtUpdateReport.scala |  73 +-
 .../TemporaryInMemoryRepository.scala         |  83 +--
 .../lmcoursier/internal/UpdateParams.scala    |  16 +-
 .../scala/lmcoursier/internal/UpdateRun.scala |  11 +-
 .../scala/lmcoursier/syntax/package.scala     |  40 +-
 .../CoursierDependencyResolutionTests.scala   |  23 +-
 .../scala/lmcoursier/EvictionErrorSpec.scala  |   7 +-
 .../lmcoursier/EvictionWarningSpec.scala      |   4 +-
 .../lmcoursier/FromSbtPlatformSpec.scala      |   4 +-
 .../test/scala/lmcoursier/InclExclSpec.scala  |  16 +-
 .../test/scala/lmcoursier/IvyXmlTests.scala   |   5 +-
 .../test/scala/lmcoursier/LockFileSpec.scala  |   4 +-
 .../scala/lmcoursier/ResolutionSpec.scala     |  17 +-
 .../src/test/scala/lmcoursier/TestKit.scala   |   1 +
 .../internal/ResolutionRunSpec.scala          |   1 +
 main-actions/src/main/scala/sbt/Console.scala |  33 +-
 .../src/main/scala/sbt/DotGraph.scala         |  17 +-
 .../src/main/scala/sbt/ForkTests.scala        |   6 +-
 main-actions/src/main/scala/sbt/Pkg.scala     |  46 +-
 .../src/main/scala/sbt/RawCompileLike.scala   |  37 +-
 main-actions/src/main/scala/sbt/Sync.scala    |  59 +-
 .../src/main/scala/sbt/TestResultLogger.scala |  43 +-
 main-actions/src/main/scala/sbt/Tests.scala   | 120 ++-
 .../scala/sbt/internal/WorkerExchange.scala   |  17 +-
 .../PackageDeploymentValidationError.scala    |  18 +-
 .../main/scala/sbt/internal/sona/Sona.scala   |  92 +--
 .../src/test/scala/sbt/CacheIvyTest.scala     |  46 +-
 .../sbt/internal/sona/SonaClientTest.scala    |   8 +-
 .../main/scala/sbt/BasicCommandStrings.scala  |  13 +-
 .../src/main/scala/sbt/BasicCommands.scala    | 151 ++--
 .../src/main/scala/sbt/BasicKeys.scala        |   4 +-
 main-command/src/main/scala/sbt/Command.scala |  62 +-
 .../src/main/scala/sbt/CommandUtil.scala      |  47 +-
 .../main/scala/sbt/ExceptionCategory.scala    |  14 +-
 .../src/main/scala/sbt/Highlight.scala        |  18 +-
 .../src/main/scala/sbt/MainControl.scala      |  12 +-
 main-command/src/main/scala/sbt/State.scala   | 109 ++-
 main-command/src/main/scala/sbt/Watched.scala |  10 +-
 .../sbt/internal/BootServerSocketProbe.scala  |   1 +
 .../scala/sbt/internal/CommandChannel.scala   |  29 +-
 .../scala/sbt/internal/ConsoleChannel.scala   |   6 +-
 .../scala/sbt/internal/LabeledFunctions.scala |  34 +-
 .../internal/classpath/ClassLoaderCache.scala | 111 +--
 .../scala/sbt/internal/client/BspClient.scala |  42 +-
 .../sbt/internal/client/NetworkClient.scala   | 694 ++++++++----------
 .../scala/sbt/internal/server/Server.scala    |  89 +--
 .../sbt/internal/server/ServerHandler.scala   |  15 +-
 .../main/scala/sbt/internal/ui/UITask.scala   |  69 +-
 .../scala/sbt/internal/ui/UserThread.scala    |  46 +-
 main-command/src/main/scala/xsbt/IPC.scala    |  34 +-
 .../sbt/internal/BootServerSocketSpec.scala   |   6 +-
 .../internal/client/ClientConnectSpec.scala   |   1 +
 .../NetworkClientSilentDisconnectTest.scala   |   4 +-
 .../client/NetworkClientSysPropsTest.scala    |   1 +
 .../internal/server/ServerAcceptSpec.scala    |   1 +
 .../sbt/internal/server/ServerTokenSpec.scala |   1 +
 main-settings/src/main/scala/sbt/Append.scala |  23 +-
 .../src/main/scala/sbt/ConfigKey.scala        |   3 +-
 main-settings/src/main/scala/sbt/Def.scala    |  65 +-
 .../src/main/scala/sbt/DelegateIndex.scala    |  18 +-
 .../src/main/scala/sbt/InputTask.scala        |   3 +-
 .../src/main/scala/sbt/KeyRanks.scala         |   4 +-
 .../src/main/scala/sbt/Plugins.scala          | 133 ++--
 .../src/main/scala/sbt/Previous.scala         |  56 +-
 .../src/main/scala/sbt/Project.scala          |  44 +-
 .../src/main/scala/sbt/PromiseWrap.scala      |   6 +-
 .../src/main/scala/sbt/Reference.scala        |  28 +-
 main-settings/src/main/scala/sbt/Remove.scala |  22 +-
 main-settings/src/main/scala/sbt/Scope.scala  |  98 +--
 .../src/main/scala/sbt/ScopeMask.scala        |  18 +-
 .../src/main/scala/sbt/Structure.scala        |  45 +-
 .../src/main/scala/sbt/dsl/LinterLevel.scala  |   6 +-
 .../main/scala/sbt/std/InputTaskMacro.scala   |  10 +-
 .../src/main/scala/sbt/std/Instances.scala    |   1 +
 .../src/main/scala/sbt/std/TaskMacro.scala    |  14 +-
 .../src/test/scala/sbt/AppendSpec.scala       |   3 +-
 .../scala/sbt/BuildSettingsInstances.scala    |   1 +
 .../src/test/scala/sbt/SlashSyntaxTest.scala  |   4 +-
 .../src/test/scala/sbt/TupleSyntaxTest.scala  |   3 +-
 .../src/test/scala/sbt/std/TaskPosSpec.scala  |  42 +-
 .../src/test/scala/sbt/std/UsageTest.scala    |   6 +-
 .../main/scala/sbt/BackgroundJobService.scala |  25 +-
 main/src/main/scala/sbt/BuildPaths.scala      |  26 +-
 .../sbt/ClassLoaderLayeringStrategy.scala     |   4 +-
 .../main/scala/sbt/CommandLineUIService.scala |  20 +-
 main/src/main/scala/sbt/Cross.scala           | 160 ++--
 main/src/main/scala/sbt/Defaults.scala        | 626 +++++++---------
 main/src/main/scala/sbt/EvaluateTask.scala    | 178 ++---
 .../src/main/scala/sbt/ExecuteProgress2.scala |  13 +-
 main/src/main/scala/sbt/Extracted.scala       |  16 +-
 .../main/scala/sbt/InteractionService.scala   |   3 +-
 main/src/main/scala/sbt/Main.scala            | 424 +++++------
 main/src/main/scala/sbt/MainLoop.scala        |  69 +-
 main/src/main/scala/sbt/OptionSyntax.scala    |  18 +-
 main/src/main/scala/sbt/Opts.scala            |  35 +-
 main/src/main/scala/sbt/PluginCross.scala     |  28 +-
 main/src/main/scala/sbt/ProjectExtra.scala    |  63 +-
 main/src/main/scala/sbt/ProjectMatrix.scala   | 117 ++-
 main/src/main/scala/sbt/RemoteCache.scala     |   3 +-
 .../scala/sbt/RepositoryUpdateStrategy.scala  |   4 +-
 main/src/main/scala/sbt/Resolvers.scala       | 161 ++--
 main/src/main/scala/sbt/RichURI.scala         |  27 +-
 main/src/main/scala/sbt/ScopeFilter.scala     |  84 +--
 main/src/main/scala/sbt/ScopedKeyData.scala   |   3 +-
 main/src/main/scala/sbt/ScriptedPlugin.scala  |  41 +-
 main/src/main/scala/sbt/ScriptedRun.scala     |  90 +--
 main/src/main/scala/sbt/SessionVar.scala      |  23 +-
 main/src/main/scala/sbt/Tags.scala            |  31 +-
 .../main/scala/sbt/TemplateCommandUtil.scala  | 125 ++--
 main/src/main/scala/sbt/Terminal.scala        |  10 +-
 main/src/main/scala/sbt/UpperStateOps.scala   |  21 +-
 main/src/main/scala/sbt/VersionScheme.scala   |   3 +-
 main/src/main/scala/sbt/VirtualAxis.scala     |  50 +-
 .../coursierint/CoursierArtifactsTasks.scala  |  51 +-
 .../sbt/coursierint/CoursierInputsTasks.scala |  26 +-
 .../CoursierRepositoriesTasks.scala           |  31 +-
 .../scala/sbt/coursierint/LMCoursier.scala    |  39 +-
 .../sbt/coursierint/ResolutionProgress.scala  |  45 +-
 .../main/scala/sbt/internal/APIMappings.scala |   4 +-
 .../AbstractTaskExecuteProgress.scala         |  58 +-
 main/src/main/scala/sbt/internal/Act.scala    | 137 ++--
 .../main/scala/sbt/internal/AddSettings.scala |  16 +-
 .../main/scala/sbt/internal/Aggregation.scala |  47 +-
 .../scala/sbt/internal/AnalysisUtil.scala     |   4 +-
 .../main/scala/sbt/internal/BuildDef.scala    |  17 +-
 .../sbt/internal/BuildDependencies.scala      |   9 +-
 .../main/scala/sbt/internal/BuildLoader.scala |  63 +-
 .../scala/sbt/internal/BuildStructure.scala   |  69 +-
 .../main/scala/sbt/internal/BuildUtil.scala   |  41 +-
 .../sbt/internal/ClassLoaderWarmup.scala      |  22 +-
 .../scala/sbt/internal/ClassLoaders.scala     |  46 +-
 .../scala/sbt/internal/ClasspathImpl.scala    |  52 +-
 main/src/main/scala/sbt/internal/Clean.scala  |  34 +-
 .../scala/sbt/internal/CommandExchange.scala  | 289 +++-----
 .../scala/sbt/internal/CommandStrings.scala   |   9 +-
 .../sbt/internal/CompileDebugLogger.scala     |  13 +-
 .../main/scala/sbt/internal/Compiler.scala    |  15 +-
 .../scala/sbt/internal/ConsoleProject.scala   |   7 +-
 .../main/scala/sbt/internal/Continuous.scala  | 486 +++++-------
 .../main/scala/sbt/internal/CrossJava.scala   | 207 +++---
 .../DefaultBackgroundJobService.scala         | 207 ++----
 .../sbt/internal/DefaultRunProfiler.scala     |   4 +-
 .../scala/sbt/internal/DynamicInput.scala     |  21 +-
 .../sbt/internal/FastTrackCommands.scala      |  18 +-
 .../scala/sbt/internal/FileChangesMacro.scala |   1 +
 .../main/scala/sbt/internal/GCMonitor.scala   |  20 +-
 main/src/main/scala/sbt/internal/GCUtil.scala |  15 +-
 .../scala/sbt/internal/GlobalPlugin.scala     |  17 +-
 .../sbt/internal/GroupedAutoPlugins.scala     |   9 +-
 .../sbt/internal/InMemoryCacheStore.scala     |  68 +-
 .../scala/sbt/internal/IncrementalTest.scala  |   2 +
 .../src/main/scala/sbt/internal/Inspect.scala |  35 +-
 .../main/scala/sbt/internal/InstallSbtn.scala | 106 ++-
 .../sbt/internal/InternalDependencies.scala   |   9 +-
 .../main/scala/sbt/internal/IvyConsole.scala  |  15 +-
 .../scala/sbt/internal/JarClassPath.scala     |  19 +-
 .../main/scala/sbt/internal/KeyIndex.scala    | 107 ++-
 .../sbt/internal/LayeredClassLoaders.scala    |  76 +-
 .../sbt/internal/LibraryManagement.scala      | 138 ++--
 .../main/scala/sbt/internal/LintUnused.scala  |  42 +-
 main/src/main/scala/sbt/internal/Load.scala   | 271 +++----
 .../main/scala/sbt/internal/LogManager.scala  |  53 +-
 main/src/main/scala/sbt/internal/Output.scala |  25 +-
 .../scala/sbt/internal/PluginDiscovery.scala  |  41 +-
 .../scala/sbt/internal/PluginManagement.scala |  15 +-
 .../scala/sbt/internal/PluginsDebug.scala     | 140 ++--
 .../scala/sbt/internal/PomGenerator.scala     |   4 +-
 .../main/scala/sbt/internal/PrettyPrint.scala |   6 +-
 .../sbt/internal/ProjectNavigation.scala      |  38 +-
 .../scala/sbt/internal/RelayAppender.scala    |   6 +-
 .../src/main/scala/sbt/internal/Resolve.scala |  21 +-
 .../scala/sbt/internal/RetrieveUnit.scala     |  25 +-
 .../src/main/scala/sbt/internal/RunUtil.scala |  23 +-
 main/src/main/scala/sbt/internal/Script.scala |  34 +-
 .../scala/sbt/internal/SessionSettings.scala  |  52 +-
 .../sbt/internal/SettingCompletions.scala     | 118 ++-
 .../scala/sbt/internal/SettingGraph.scala     |  54 +-
 .../scala/sbt/internal/ShutdownHooks.scala    |  21 +-
 .../src/main/scala/sbt/internal/SysProp.scala |  76 +-
 .../main/scala/sbt/internal/TaskName.scala    |   3 +-
 .../scala/sbt/internal/TaskProgress.scala     | 116 ++-
 .../scala/sbt/internal/TaskSequential.scala   |  10 +-
 .../main/scala/sbt/internal/TaskTimings.scala |  28 +-
 .../scala/sbt/internal/TaskTraceEvent.scala   |  33 +-
 .../main/scala/sbt/internal/TestCommand.scala |   3 +
 .../scala/sbt/internal/VcsUriFragment.scala   |  13 +-
 .../sbt/internal/VirtualFileValueCache.scala  |  33 +-
 .../WatchTransitiveDependencies.scala         |  62 +-
 .../internal/graph/GraphTransformations.scala |  26 +-
 .../graph/backend/SbtUpdateReport.scala       |  23 +-
 .../main/scala/sbt/internal/graph/model.scala |  10 +-
 .../scala/sbt/internal/graph/package.scala    |   3 +-
 .../internal/graph/rendering/AsciiTree.scala  |   7 +-
 .../sbt/internal/graph/rendering/DOT.scala    |  17 +-
 .../internal/graph/rendering/DagreHTML.scala  |  10 +-
 .../internal/graph/rendering/FlatList.scala   |   3 +-
 .../internal/graph/rendering/GraphML.scala    |   1 +
 .../graph/rendering/LicenseInfo.scala         |   7 +-
 .../internal/graph/rendering/Statistics.scala |  20 +-
 .../internal/graph/rendering/TreeView.scala   |  34 +-
 .../DependencyLockManager.scala               |   2 +
 .../librarymanagement/GenericPublisher.scala  |  30 +-
 .../librarymanagement/Publishing.scala        |  28 +-
 .../internal/server/BspCompileProgress.scala  |  17 +-
 .../sbt/internal/server/BspCompileTask.scala  |  22 +-
 .../server/BuildServerEvalReporter.scala      |  18 +-
 .../internal/server/BuildServerProtocol.scala | 201 ++---
 .../internal/server/BuildServerReporter.scala |  70 +-
 .../internal/server/CoalescingFlusher.scala   |   4 +-
 .../sbt/internal/server/Definition.scala      | 100 +--
 .../server/LanguageServerProtocol.scala       |  19 +-
 .../sbt/internal/server/NetworkChannel.scala  | 451 +++++-------
 .../sbt/internal/server/SettingQuery.scala    |  30 +-
 .../sbt/internal/server/VirtualTerminal.scala |  75 +-
 .../scala/sbt/nio/CheckBuildSources.scala     |  78 +-
 main/src/main/scala/sbt/nio/FileChanges.scala |   6 +-
 main/src/main/scala/sbt/nio/FileStamp.scala   | 127 ++--
 main/src/main/scala/sbt/nio/Keys.scala        |   4 +-
 main/src/main/scala/sbt/nio/Settings.scala    |  88 +--
 main/src/main/scala/sbt/nio/Watch.scala       | 205 ++----
 .../main/scala/sbt/plugins/CorePlugin.scala   |   3 +-
 .../sbt/plugins/DependencyTreePlugin.scala    |   4 +-
 .../sbt/plugins/DependencyTreeSettings.scala  |  17 +-
 .../sbt/plugins/Giter8TemplatePlugin.scala    |   3 +-
 .../main/scala/sbt/plugins/IvyPlugin.scala    |   4 +-
 .../sbt/plugins/JUnitXmlReportPlugin.scala    |   7 +-
 .../main/scala/sbt/plugins/JvmPlugin.scala    |   4 +-
 .../scala/sbt/plugins/SemanticdbPlugin.scala  |  25 +-
 main/src/test/scala/ClasspathsTest.scala      |  10 +-
 main/src/test/scala/Delegates.scala           |  22 +-
 main/src/test/scala/ParseKeySpec.scala        |  69 +-
 main/src/test/scala/ParserSpec.scala          |   8 +-
 main/src/test/scala/PluginCommandTest.scala   |  28 +-
 main/src/test/scala/ProjectMacro.scala        |  16 +-
 main/src/test/scala/ProjectSpec.scala         |   7 +-
 .../test/scala/ScopeFilterOrderingSpec.scala  |   4 +-
 main/src/test/scala/SelectedFilterTest.scala  |   4 +-
 main/src/test/scala/TagsTest.scala            |  13 +-
 .../scala/sbt/TemplateCommandUtilTest.scala   |   5 +-
 .../coursierint/ResolutionProgressSpec.scala  |   3 +-
 .../scala/sbt/internal/AggregationSpec.scala  |   4 +-
 .../scala/sbt/internal/ClassStamperTest.scala |   5 +
 .../sbt/internal/CompileDebugLoggerSpec.scala |  12 +-
 .../scala/sbt/internal/CrossJavaTest.scala    |  28 +-
 .../scala/sbt/internal/GCMonitorTest.scala    |  12 +-
 .../sbt/internal/InMemoryCacheStoreTest.scala |   1 +
 .../scala/sbt/internal/InstallSbtnSpec.scala  |  19 +-
 .../test/scala/sbt/internal/OutputSpec.scala  |   3 +-
 .../test/scala/sbt/internal/ScriptTest.scala  |  20 +-
 .../scala/sbt/internal/StressGCMonitor.scala  |   9 +-
 .../scala/sbt/internal/TaskProgressSpec.scala |   4 +-
 .../test/scala/sbt/internal/TestBuild.scala   | 161 ++--
 .../graph/backend/SbtUpdateReportTest.scala   |   4 +-
 .../graph/rendering/TreeViewTest.scala        |   4 +-
 .../server/CoalescingFlusherSpec.scala        |  17 +-
 .../test/scala/testpkg/CompletionSpec.scala   |   8 +-
 project/DatatypeConfig.scala                  |  88 +--
 project/Dependencies.scala                    |  13 +-
 project/Docs.scala                            |   3 +-
 project/HouseRulesPlugin.scala                |  18 +-
 project/Mima.scala                            |  11 +-
 project/NightlyPlugin.scala                   |   9 +-
 project/PackageSignerPlugin.scala             |  13 +-
 project/PublishBinPlugin.scala                |  14 +-
 project/SbtLauncherPlugin.scala               |  25 +-
 project/Scripted.scala                        |  70 +-
 project/Transform.scala                       |   7 +-
 project/Utils.scala                           |  48 +-
 .../internal/bsp/BuildServerConnection.scala  |  18 +-
 .../sbt/internal/bsp/BuildServerTasks.scala   |   3 +-
 .../sbt/internal/bsp/BuildTargetName.scala    |   9 +-
 .../sbt/internal/bsp/BuildTargetTag.scala     |   6 +-
 .../sbt/internal/bsp/DiagnosticSeverity.scala |   4 +-
 .../sbt/internal/bsp/OutputPathItemKind.scala |   3 +-
 .../sbt/internal/bsp/ScalaPlatform.scala      |   3 +-
 .../sbt/internal/bsp/SourceItemKind.scala     |   3 +-
 .../scala/sbt/internal/bsp/StatusCode.scala   |   3 +-
 .../langserver/DiagnosticSeverity.scala       |   4 +-
 .../sbt/internal/langserver/MessageType.scala |   9 +-
 .../JsonRpcNotificationMessageFormats.scala   |  16 +-
 .../codec/JsonRpcRequestMessageFormats.scala  |  25 +-
 .../codec/JsonRpcResponseErrorFormats.scala   |  16 +-
 .../codec/JsonRpcResponseMessageFormats.scala |  37 +-
 .../scala/sbt/internal/util/JoinThread.scala  |  23 +-
 .../scala/sbt/protocol/ClientSocket.scala     |  18 +-
 .../scala/sbt/protocol/JsonRpcReader.scala    |  42 +-
 .../scala/sbt/protocol/JsonRpcWriter.scala    |  11 +-
 .../scala/sbt/protocol/Serialization.scala    | 102 +--
 .../scala/sbt/protocol/ServerSession.scala    |  32 +-
 .../sbt/protocol/ServerSessionImpl.scala      | 108 ++-
 .../bsp/BuildServerConnectionSpec.scala       |   1 +
 .../sbt/protocol/ClientSocketDuplexTest.scala |   1 +
 .../sbt/protocol/ServerSessionImplSpec.scala  |   4 +-
 run/src/main/scala/sbt/Fork.scala             |  70 +-
 run/src/main/scala/sbt/OutputStrategy.scala   |  67 +-
 run/src/main/scala/sbt/Run.scala              | 117 ++-
 run/src/main/scala/sbt/SelectMainClass.scala  |  30 +-
 run/src/main/scala/sbt/TrapExit.scala         |  12 +-
 run/src/test/scala/sbt/ForkTest.scala         |  35 +-
 run/src/test/scala/sbt/TestLogger.scala       |   6 +-
 sbt-app/src/main/scala/package.scala          |   3 +-
 sbt-app/src/main/scala/sbt/AllSyntax.scala    |   6 +-
 sbt-app/src/main/scala/sbt/Import.scala       |   8 +-
 .../test/scala/sbt/RunFromSourceMain.scala    |  58 +-
 .../scala/sbt/RunFromSourceMainSpec.scala     |   3 +-
 .../sbt/internal/GrpcActionCacheStore.scala   |   7 +
 .../scala/sbt/plugins/RemoteCachePlugin.scala |   1 +
 sbtw/src/main/scala/sbtw/ArgParser.scala      |   2 +
 sbtw/src/main/scala/sbtw/ConfigLoader.scala   |  10 +-
 sbtw/src/main/scala/sbtw/Main.scala           |   7 +-
 sbtw/src/main/scala/sbtw/Runner.scala         |  10 +-
 .../sbt/scriptedtest/BatchScriptRunner.scala  |  42 +-
 .../sbt/scriptedtest/RemoteSbtCreator.scala   |  30 +-
 .../scala/sbt/scriptedtest/SbtHandler.scala   |  38 +-
 .../sbt/scriptedtest/ScriptedTests.scala      | 256 +++----
 .../scala/testpkg/AbstractServerTest.scala    |  57 +-
 .../test/scala/testpkg/BuildServerTest.scala  |  58 +-
 .../scala/testpkg/ChannelCursorTest.scala     |  13 +-
 .../scala/testpkg/ClientBootTimeoutTest.scala |  22 +-
 .../testpkg/ClientSubscriptionTest.scala      |   6 +-
 .../src/test/scala/testpkg/ClientTest.scala   |  49 +-
 .../src/test/scala/testpkg/EventsTest.scala   |   4 +-
 .../testpkg/ExecRequiresInitializeTest.scala  |  28 +-
 .../scala/testpkg/FailedLoadPromptTest.scala  |  25 +-
 .../test/scala/testpkg/HandshakeTest.scala    |   3 +-
 .../scala/testpkg/PortfileReloadTest.scala    |   3 +-
 .../src/test/scala/testpkg/PortfileTest.scala |   3 +-
 .../testpkg/QueuedNotificationTest.scala      |   4 +-
 .../src/test/scala/testpkg/RebootTest.scala   |   3 +-
 .../src/test/scala/testpkg/ResponseTest.scala |  10 +-
 .../scala/testpkg/ServerCompletionsTest.scala |   4 +-
 .../scala/testpkg/ServerSysPropsTest.scala    |  63 +-
 .../scala/testpkg/TerminalMapsDrainTest.scala |  13 +-
 .../TerminalPropertiesFreezeTest.scala        |   7 +-
 .../src/main/scala/sbt/std/Streams.scala      |  52 +-
 .../src/main/scala/sbt/std/TaskExtra.scala    |  67 +-
 .../src/main/scala/sbt/std/Transform.scala    |   9 +-
 tasks-standard/src/test/scala/Execute.scala   |   4 +-
 tasks-standard/src/test/scala/TaskGen.scala   |  15 +-
 .../src/test/scala/TaskRunnerCircular.scala   |  33 +-
 .../src/test/scala/TaskRunnerFork.scala       |   7 +-
 .../src/test/scala/TaskSerial.scala           |  24 +-
 tasks-standard/src/test/scala/Test.scala      |   5 +-
 .../src/test/scala/TestRunnerCall.scala       |  25 +-
 .../src/test/scala/TestRunnerSort.scala       |  23 +-
 .../src/test/scala/checkResult.scala          |  13 +-
 .../main/scala/sbt/CompletionService.scala    |  45 +-
 .../scala/sbt/ConcurrentRestrictions.scala    | 106 ++-
 tasks/src/main/scala/sbt/Execute.scala        | 154 ++--
 .../src/main/scala/sbt/ExecuteProgress.scala  |  38 +-
 tasks/src/main/scala/sbt/Incomplete.scala     |  25 +-
 tasks/src/main/scala/sbt/Result.scala         |   9 +-
 .../scala/sbt/JUnitXmlTestsListener.scala     | 152 ++--
 .../src/main/scala/sbt/TestFramework.scala    | 137 ++--
 .../main/scala/sbt/TestReportListener.scala   |  38 +-
 .../sbt/internal/testing/StatusFormats.scala  |  23 +-
 .../sbt/internal/testing/TestLogger.scala     |  31 +-
 .../src/test/scala/sbt/TestRunnerSpec.scala   |  37 +-
 .../util/codec/ByteBufferFormats.scala        |   4 +-
 .../codec/HashedVirtualFileRefFormats.scala   |  10 +-
 .../src/main/scala/sbt/util/ActionCache.scala |   7 +
 .../scala/sbt/util/ActionCacheStore.scala     |   8 +-
 .../scala/sbt/util/BasicCacheImplicits.scala  |   7 +-
 .../src/main/scala/sbt/util/Cache.scala       |  19 +-
 .../src/main/scala/sbt/util/CacheStore.scala  |  28 +-
 .../src/main/scala/sbt/util/Digest.scala      |   4 +
 .../main/scala/sbt/util/DigestHasher.scala    |   1 +
 .../src/main/scala/sbt/util/FileInfo.scala    | 132 ++--
 .../src/main/scala/sbt/util/Input.scala       |  60 +-
 .../src/main/scala/sbt/util/Output.scala      |  21 +-
 .../main/scala/sbt/util/SeparatedCache.scala  |  24 +-
 .../main/scala/sbt/util/StampedFormat.scala   |  21 +-
 .../test/scala/sbt/util/ActionCacheTest.scala |  55 +-
 .../scala/sbt/util/GzipCacheStoreSpec.scala   |   1 +
 .../scala/sbt/internal/util/Attributes.scala  |  12 +-
 .../main/scala/sbt/internal/util/Dag.scala    |  80 +-
 .../main/scala/sbt/internal/util/IDSet.scala  |  23 +-
 .../main/scala/sbt/internal/util/INode.scala  |  34 +-
 .../main/scala/sbt/internal/util/PMap.scala   |  32 +-
 .../main/scala/sbt/internal/util/Par.scala    |   3 +-
 .../scala/sbt/internal/util/Settings.scala    | 137 ++--
 .../main/scala/sbt/internal/util/Signal.scala |  64 +-
 .../sbt/internal/util/TupleMapExtension.scala |   2 +
 .../scala/sbt/internal/util/WrappedMap.scala  |   3 +-
 .../main/scala/sbt/util/OptJsonWriter.scala   |  12 +-
 .../src/test/scala/DagSpecification.scala     |  33 +-
 .../src/test/scala/SettingsExample.scala      |  17 +-
 .../main/scala/sbt/util/ChangeReport.scala    |  26 +-
 .../main/scala/sbt/util/FileFunction.scala    |  16 +-
 .../src/main/scala/sbt/util/Tracked.scala     |  94 +--
 .../main/scala/sbt/internal/inc/Errors.scala  |   9 +-
 .../scala/sbt/internal/inc/IfMissing.scala    |   6 +-
 .../sbt/internal/inc/ResourceLoader.scala     |  25 +-
 .../internal/inc/ZincComponentCompiler.scala  |  78 +-
 .../internal/inc/ZincComponentManager.scala   |  60 +-
 .../scala/sbt/internal/inc/ZincLmUtil.scala   |  27 +-
 .../inc/BridgeProviderSpecification.scala     |  15 +-
 .../inc/ZincComponentCompilerSpec.scala       |   4 +-
 598 files changed, 9294 insertions(+), 13894 deletions(-)

diff --git a/build.sbt b/build.sbt
index 76f2ff288..89ec6842f 100644
--- a/build.sbt
+++ b/build.sbt
@@ -82,13 +82,13 @@ def commonSettings: Seq[Setting[?]] = Def.settings(
   Global / concurrentRestrictions += Utils.testExclusiveRestriction,
   // On Windows, limit to one task at a time to avoid OverlappingFileLockException when
   // multiple tasks (e.g. scalafix plugin and sbt Coursier) write to the same cache.
-  Global / concurrentRestrictions ++= (if (scala.util.Properties.isWin) Seq(Tags.limitAll(1))
+  Global / concurrentRestrictions ++= (if scala.util.Properties.isWin then Seq(Tags.limitAll(1))
                                        else Nil),
   Test / testOptions += Tests.Argument(TestFrameworks.ScalaCheck, "-w", "1"),
   Test / testOptions += Tests.Argument(TestFrameworks.ScalaCheck, "-verbosity", "2"),
   compile / javacOptions ++= Seq("-Xlint", "-Xlint:-serial"),
   Compile / doc / scalacOptions ++= {
-    if (Dependencies.sbtIoPath.isEmpty && Dependencies.sbtZincPath.isEmpty) {
+    if Dependencies.sbtIoPath.isEmpty && Dependencies.sbtZincPath.isEmpty then
       import scala.sys.process.*
       val devnull = ProcessLogger(_ => ())
       val tagOrSha =
@@ -98,9 +98,7 @@ def commonSettings: Seq[Setting[?]] = Def.settings(
         "-revision",
         tagOrSha
       )
-    } else {
-      Nil
-    }
+    else Nil
   },
   Compile / javafmtOnCompile := scalafmtOnCompile.value,
   Test / javafmtOnCompile := (Test / scalafmtOnCompile).value,
@@ -132,8 +130,8 @@ val sbt20Plus =
 val mimaSettings = mimaSettingsSince(sbt20Plus)
 def mimaSettingsSince(versions: Seq[String]): Seq[Def.Setting[?]] = Def.settings(
   mimaPreviousArtifacts := {
-    val crossVersion = if (crossPaths.value) CrossVersion.binary else CrossVersion.disabled
-    if (sbtPlugin.value) {
+    val crossVersion = if crossPaths.value then CrossVersion.binary else CrossVersion.disabled
+    if sbtPlugin.value then
       versions
         .map(v =>
           Defaults.sbtPluginExtra(
@@ -143,9 +141,7 @@ def mimaSettingsSince(versions: Seq[String]): Seq[Def.Setting[?]] = Def.settings
           )
         )
         .toSet
-    } else {
-      versions.map(v => (organization.value % moduleName.value % v).cross(crossVersion)).toSet
-    }
+    else versions.map(v => (organization.value % moduleName.value % v).cross(crossVersion)).toSet
   },
   mimaBinaryIssueFilters ++= Seq(
   ),
@@ -183,8 +179,7 @@ lazy val sbtRoot: Project = (project in file("."))
         |  /____/_.___/\__/
         |Welcome to the build for sbt.
         |""".stripMargin +
-        (if (version != "17")
-           s"""!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        (if version != "17" then s"""!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                |  Java version is $version. We recommend java 17.
                |!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""".stripMargin
          else "")
@@ -204,16 +199,14 @@ lazy val sbtRoot: Project = (project in file("."))
     installNativeThinClient := {
       // nativeInstallDirectory can be set globally or in a gitignored local file
       val dir = nativeInstallDirectory.?.value
-      val target = Def.spaceDelimited("").parsed.headOption match {
+      val target = Def.spaceDelimited("").parsed.headOption match
         case Some(p) => file(p).toPath
         case _       =>
-          dir match {
+          dir match
             case Some(d) => d / "sbtn"
             case _       =>
               val msg = "Expected input parameter <path>: installNativeExecutable /usr/local/bin"
               throw new IllegalStateException(msg)
-          }
-      }
       val base = baseDirectory.value.toPath
       val exec = fileConverter.value.toPath((sbtClientProj / nativeImage).value)
       streams.value.log.info(s"installing thin client ${base.relativize(exec)} to ${target}")
@@ -351,7 +344,7 @@ lazy val utilLogging = project
     Compile / generateContrabands / contrabandFormatsForType := { tpe =>
       val old = (Compile / generateContrabands / contrabandFormatsForType).value
       val name = tpe.removeTypeParameters.name
-      if (name == "Throwable") Nil
+      if name == "Throwable" then Nil
       else old(tpe)
     },
     Test / fork := true,
@@ -905,9 +898,9 @@ lazy val serverTestProj = (project in file("server-test"))
           .map(_.toFile.getAbsolutePath)
           .mkString(java.io.File.pathSeparator)
       val cp =
-        if (scala.util.Properties.isWin) rawClasspath.replace("\\", "\\\\")
+        if scala.util.Properties.isWin then rawClasspath.replace("\\", "\\\\")
         else rawClasspath
-      val content = {
+      val content =
         s"""|
             |package testpkg
             |
@@ -917,7 +910,6 @@ lazy val serverTestProj = (project in file("server-test"))
             |  val scalaVersion = "${scalaVersion.value}"
             |}
           """.stripMargin
-      }
       val file =
         (Test / target).value / "generated" / "src" / "test" / "scala" / "testpkg" / "TestProperties.scala"
       IO.write(file, content)
@@ -956,17 +948,14 @@ lazy val sbtClientProj = (project in file("client"))
     nativeImageJvm := "graalvm-java23",
     nativeImageOutput := {
       val outputDir = (target.value / "bin").toPath
-      if (!Files.exists(outputDir)) {
-        Files.createDirectories(outputDir)
-      }
+      if !Files.exists(outputDir) then Files.createDirectories(outputDir)
       fileConverter.value.toVirtualFile(outputDir.resolve("sbtn"))
     },
     nativeImageCommand := {
       val orig = nativeImageCommand.value
-      sys.env.get("ARCHS") match {
+      sys.env.get("ARCHS") match
         case Some(a) => Seq("arch", s"-$a") ++ orig
         case None    => orig
-      }
     },
     nativeImageOptions ++= Seq(
       "--no-fallback",
@@ -983,16 +972,16 @@ lazy val sbtClientProj = (project in file("client"))
     ),
     buildThinClient := {
       val isFish = Def.spaceDelimited("").parsed.headOption.fold(false)(_ == "--fish")
-      val ext = if (isWin) ".bat" else if (isFish) ".fish" else ".sh"
-      val output = target.value.toPath / "bin" / s"${if (isFish) "fish-" else ""}client$ext"
+      val ext = if isWin then ".bat" else if isFish then ".fish" else ".sh"
+      val output = target.value.toPath / "bin" / s"${if isFish then "fish-" else ""}client$ext"
       java.nio.file.Files.createDirectories(output.getParent)
       val cp = (Compile / fullClasspathAsJars).value.map(_.data)
       val args =
-        if (isWin) "%*" else if (isFish) s"$$argv" else s"$$*"
+        if isWin then "%*" else if isFish then s"$$argv" else s"$$*"
       java.nio.file.Files.write(
         output,
         s"""
-        |${if (isWin) "@echo off" else s"#!/usr/bin/env ${if (isFish) "fish" else "sh"}"}
+        |${if isWin then "@echo off" else s"#!/usr/bin/env ${if isFish then "fish" else "sh"}"}
         |
         |java -cp ${cp.mkString(java.io.File.pathSeparator)} sbt.client.Client --jna $args
         """.stripMargin.linesIterator.toSeq.tail.mkString("\n").getBytes
@@ -1058,11 +1047,10 @@ lazy val upperModules = (project in (file("internal") / "upper"))
     Utils.noPublish
   )
 
-lazy val sbtIgnoredProblems = {
+lazy val sbtIgnoredProblems =
   import com.typesafe.tools.mima.core.*
   Vector(
   )
-}
 
 def scriptedTask(launch: Boolean): Def.Initialize[InputTask[Unit]] = Def.inputTask {
   val _ = publishLocalBinAll.value
@@ -1075,7 +1063,7 @@ def scriptedTask(launch: Boolean): Def.Initialize[InputTask[Unit]] = Def.inputTa
     scriptedBufferLog.value,
     Def.setting(Scripted.scriptedParser(scriptedSource.value)).parsed,
     scriptedPrescripted.value,
-    scriptedLaunchOpts.value ++ (if (launch) Some(launchJar) else None),
+    scriptedLaunchOpts.value ++ (if launch then Some(launchJar) else None),
     scalaVersion.value,
     version.value,
     (scriptedSbtProj / Test / fullClasspathAsJars).value
@@ -1171,10 +1159,9 @@ def otherRootSettings =
       "-server",
       s"-Dsbt.build.root=${(ThisBuild / baseDirectory).value.getAbsolutePath}"
     ) :::
-      (sys.props.get("sbt.ivy.home") match {
+      (sys.props.get("sbt.ivy.home") match
         case Some(home) => List(s"-Dsbt.ivy.home=$home")
-        case _          => Nil
-      }),
+        case _          => Nil),
     publishLocalBinAll := {
       val _ = (Compile / publishLocalBin).all(scriptedProjects).value
     },
@@ -1185,10 +1172,9 @@ def otherRootSettings =
         "-Xms512M",
         "-server"
       ) :::
-        (sys.props.get("sbt.ivy.home") match {
+        (sys.props.get("sbt.ivy.home") match
           case Some(home) => List(s"-Dsbt.ivy.home=$home")
-          case _          => Nil
-        }),
+          case _          => Nil),
       scripted := scriptedTask(true).evaluated,
       scriptedUnpublished := scriptedTask(true).evaluated,
       scriptedSource := (sbtProj / sourceDirectory).value / "repo-override-test"
@@ -1248,7 +1234,7 @@ ThisBuild / pomIncludeRepository := (_ => false) // drop repos other than Maven
 ThisBuild / publishTo := {
   val centralSnapshots = "https://central.sonatype.com/repository/maven-snapshots/"
   val v = (ThisBuild / version).value
-  if (v.endsWith("SNAPSHOT")) Some("central-snapshots" at centralSnapshots)
+  if v.endsWith("SNAPSHOT") then Some("central-snapshots" at centralSnapshots)
   else localStaging.value
 }
 ThisBuild / publishMavenStyle := true
diff --git a/buildfile/src/main/scala/sbt/internal/DslEntry.scala b/buildfile/src/main/scala/sbt/internal/DslEntry.scala
index 77852d72d..72a29d134 100644
--- a/buildfile/src/main/scala/sbt/internal/DslEntry.scala
+++ b/buildfile/src/main/scala/sbt/internal/DslEntry.scala
@@ -16,72 +16,59 @@ import sbt.librarymanagement.Configuration
 import Def.*
 
 /** This represents a `Setting` expression configured by the sbt DSL. */
-sealed trait DslEntry {
+sealed trait DslEntry:
 
   /** Called by the parser.  Sets the position where this entry was defined in the build.sbt file. */
   def withPos(pos: RangePosition): DslEntry
-}
-object DslEntry {
+object DslEntry:
   implicit def fromSettingsDef(inc: SettingsDefinition): DslEntry =
     DslSetting(inc)
   implicit def fromSettingsDef(inc: Seq[Setting[?]]): DslEntry =
     DslSetting(inc)
 
   /** Represents a DSL entry which adds settings to the current project. */
-  sealed trait ProjectSettings extends DslEntry {
+  sealed trait ProjectSettings extends DslEntry:
     def toSettings: Seq[Setting[?]]
-  }
-  object ProjectSettings {
+  object ProjectSettings:
     def unapply(e: DslEntry): Option[Seq[Setting[?]]] =
-      e match {
+      e match
         case e: ProjectSettings => Some(e.toSettings)
         case _                  => None
-      }
-  }
 
   /** Represents a DSL entry which manipulates the current project. */
-  sealed trait ProjectManipulation extends DslEntry {
+  sealed trait ProjectManipulation extends DslEntry:
     def toFunction: Project => Project
     // TODO - Should we store this?
     final def withPos(pos: RangePosition): DslEntry = this
-  }
-  object ProjectManipulation {
+  object ProjectManipulation:
     def unapply(e: DslEntry): Option[Project => Project] =
-      e match {
+      e match
         case e: ProjectManipulation => Some(e.toFunction)
         case _                      => None
-      }
-  }
 
   /** this represents an actually Setting[_] or Seq[Setting[_]] configured by the sbt DSL. */
-  case class DslSetting(settings: SettingsDefinition) extends ProjectSettings {
+  case class DslSetting(settings: SettingsDefinition) extends ProjectSettings:
     def toSettings = settings.settings
     final def withPos(pos: RangePosition): DslEntry =
       DslSetting(settings.settings.map(_.withPos(pos)))
-  }
 
   /** this represents an `enablePlugins()` in the sbt DSL */
-  case class DslEnablePlugins(plugins: Seq[AutoPlugin]) extends ProjectManipulation {
+  case class DslEnablePlugins(plugins: Seq[AutoPlugin]) extends ProjectManipulation:
     override val toFunction: Project => Project = _.enablePlugins(plugins*)
-  }
 
   /** this represents an `disablePlugins()` in the sbt DSL */
-  case class DslDisablePlugins(plugins: Seq[AutoPlugin]) extends ProjectManipulation {
+  case class DslDisablePlugins(plugins: Seq[AutoPlugin]) extends ProjectManipulation:
     override val toFunction: Project => Project = _.disablePlugins(plugins*)
-  }
 
   /** Represents registering an internal dependency for the current project */
-  case class DslDependsOn(cs: Seq[ClasspathDep[ProjectReference]]) extends ProjectManipulation {
+  case class DslDependsOn(cs: Seq[ClasspathDep[ProjectReference]]) extends ProjectManipulation:
     override val toFunction: Project => Project = _.dependsOn(cs*)
-  }
 
   /** Represents registering a set of configurations with the current project. */
-  case class DslConfigs(cs: Seq[Configuration]) extends ProjectManipulation {
+  case class DslConfigs(cs: Seq[Configuration]) extends ProjectManipulation:
     override val toFunction: Project => Project = _.configs(cs*)
-  }
 
   /** this represents an `aggregateProjects()` in the sbt DSL */
-  case class DslAggregate(refs: Seq[ProjectReference]) extends ProjectManipulation {
+  case class DslAggregate(refs: Seq[ProjectReference]) extends ProjectManipulation:
     override val toFunction: Project => Project = _.aggregate(refs*)
-  }
-}
+end DslEntry
diff --git a/buildfile/src/main/scala/sbt/internal/Eval.scala b/buildfile/src/main/scala/sbt/internal/Eval.scala
index 9a793430d..14efe3119 100644
--- a/buildfile/src/main/scala/sbt/internal/Eval.scala
+++ b/buildfile/src/main/scala/sbt/internal/Eval.scala
@@ -255,6 +255,7 @@ class Eval(
       generated = generatedFiles,
       enclosingModule = moduleName,
     )
+  end evalCommon
 
   // location of the cached type or definition information
   private def cacheFile(base: Path, moduleName: String): Path =
@@ -271,12 +272,12 @@ class Eval(
     val source = ev.makeSource(moduleName)
     run.compileSources(source :: Nil)
     val unit = run.units.head
-    val traverser = new tpd.TreeTraverser {
-      override def traverse(tree: tpd.Tree)(using Context): Unit = {
-        tree match {
+    val traverser = new tpd.TreeTraverser:
+      override def traverse(tree: tpd.Tree)(using Context): Unit =
+        tree match
           case x: tpd.TypeDef
               if x.name.mangledString == s"${moduleName}${NameTransformer.MODULE_SUFFIX_STRING}" =>
-            x.rhs match {
+            x.rhs match
               case template: tpd.Template =>
                 template.body.foreach {
                   case defdef: tpd.DefDef if defdef.name.mangledString == WrapValName =>
@@ -314,13 +315,9 @@ class Eval(
                   case _ =>
                 }
               case _ =>
-            }
           case _: tpd.PackageDef =>
             traverseChildren(tree)
           case _ =>
-        }
-      }
-    }
     traverser.traverse(unit.tpdTree)
     checkError("an error in expression")
     val extra: A = ev.extract(run, unit)
@@ -329,6 +326,7 @@ class Eval(
     }
     val loader = (parent: ClassLoader) => AbstractFileClassLoader(outputDir, parent)
     (extra, loader)
+  end compileAndLoad
 
   private final class EvalIntermediate[A](
       val extra: A,
@@ -534,11 +532,10 @@ final class EvalDefinitions(
     val enclosingModule: String,
     val valNames: Seq[String]
 ):
-  def values(parent: ClassLoader): Seq[Any] = {
+  def values(parent: ClassLoader): Seq[Any] =
     val module = Eval.getModule(enclosingModule, loader(parent))
     for n <- valNames
     yield module.getClass.getMethod(n).invoke(module)
-  }
 end EvalDefinitions
 
 final class EvalException(msg: String) extends RuntimeException(msg)
diff --git a/buildfile/src/main/scala/sbt/internal/EvaluateConfigurations.scala b/buildfile/src/main/scala/sbt/internal/EvaluateConfigurations.scala
index 6fa7cebea..1e829c4f5 100644
--- a/buildfile/src/main/scala/sbt/internal/EvaluateConfigurations.scala
+++ b/buildfile/src/main/scala/sbt/internal/EvaluateConfigurations.scala
@@ -33,7 +33,7 @@ import dotty.tools.dotc.ast.untpd.{ Annotated, ValOrDefDef, Tree }
  *  2. Compiling scala code into local .class files
  *  3. Evaluating the expressions and obtaining in-memory objects of the results (Setting[_] instances, or val references).
  */
-private[sbt] object EvaluateConfigurations {
+private[sbt] object EvaluateConfigurations:
 
   type LazyClassLoaded[A] = ClassLoader => A
 
@@ -61,7 +61,7 @@ private[sbt] object EvaluateConfigurations {
       eval: Eval,
       srcs: Seq[VirtualFile],
       imports: Seq[String],
-  ): LazyClassLoaded[LoadedSbtFile] = {
+  ): LazyClassLoaded[LoadedSbtFile] =
     val loadFiles = srcs.sortBy(_.name) map { src =>
       evaluateSbtFile(eval, src, IO.readStream(src.input()).linesIterator.toList, imports, 0)
     }
@@ -69,7 +69,6 @@ private[sbt] object EvaluateConfigurations {
       loadFiles.foldLeft(LoadedSbtFile.empty) { (loaded, load) =>
         loaded.merge(load(loader))
       }
-  }
 
   /**
    * Reads a given .sbt file and evaluates it into a sequence of setting values.
@@ -95,7 +94,7 @@ private[sbt] object EvaluateConfigurations {
       builtinImports: Seq[String],
       offset: Int,
       options: Seq[String]
-  ): ParsedFile = {
+  ): ParsedFile =
     def loseTree(l: (String, Tree, LineRange)): (String, LineRange) = (l._1, l._3)
     val (importStatements, settingsAndDefinitions) = splitExpressions(file, lines, options)
     val allImports = builtinImports.map(s => (s, -1)) ++ addOffset(offset, importStatements)
@@ -103,7 +102,6 @@ private[sbt] object EvaluateConfigurations {
       addOffsetToRange(offset, settingsAndDefinitions)
     )
     new ParsedFile(allImports, definitions.map(loseTree), settings.map(loseTree))
-  }
 
   /**
    * Evaluates a  parsed sbt configuration file.
@@ -121,10 +119,9 @@ private[sbt] object EvaluateConfigurations {
       lines: Seq[String],
       imports: Seq[String],
       offset: Int
-  ): LazyClassLoaded[Seq[Setting[?]]] = {
+  ): LazyClassLoaded[Seq[Setting[?]]] =
     val l = evaluateSbtFile(eval, file, lines, imports, offset)
     loader => l(loader).settings
-  }
 
   /**
    * Evaluates a parsed sbt configuration file.
@@ -142,7 +139,7 @@ private[sbt] object EvaluateConfigurations {
       lines: Seq[String],
       imports: Seq[String],
       offset: Int
-  ): LazyClassLoaded[LoadedSbtFile] = {
+  ): LazyClassLoaded[LoadedSbtFile] =
     // TODO - Store the file on the LoadedSbtFile (or the parent dir) so we can accurately do
     //        detection for which project manipulations should be applied.
     val name = file match
@@ -150,13 +147,12 @@ private[sbt] object EvaluateConfigurations {
       case file                => file.id
     val parsed = parseConfiguration(file, lines, imports, offset, eval.nonCpOptions)
     val (importDefs, definitions) =
-      if (parsed.definitions.isEmpty) (Nil, DefinedSbtValues.empty)
-      else {
+      if parsed.definitions.isEmpty then (Nil, DefinedSbtValues.empty)
+      else
         val definitions =
           evaluateDefinitions(eval, name, parsed.imports, parsed.definitions, Some(file))
         val imp = BuildUtilLite.importAllRoot(definitions.enclosingModule :: Nil)
         (imp, DefinedSbtValues(definitions))
-      }
     val allImports = importDefs.map(s => (s, -1)) ++ parsed.imports
     val dslEntries = parsed.settings map { (dslExpression, range) =>
       evaluateDslEntry(eval, name, allImports, dslExpression, range)
@@ -167,13 +163,12 @@ private[sbt] object EvaluateConfigurations {
 
     // Tracks all the files we generated from evaluating the sbt file.
     val allGeneratedFiles: Seq[Path] = (definitions.generated ++ dslEntries.flatMap(_.generated))
-    loader => {
-      val projects = {
+    loader =>
+      val projects =
         val compositeProjects = definitions
           .values(loader)
           .collect { case p: CompositeProject => p }
         CompositeProject.expand(compositeProjects)
-      }
       val loadedDslEntries = dslEntries.map(_.result.apply(loader))
       val settings = loadedDslEntries.collect { case DslEntry.ProjectSettings(s) => s }.flatten
       val manipulations = loadedDslEntries.collect { case DslEntry.ProjectManipulation(f) => f }
@@ -186,8 +181,7 @@ private[sbt] object EvaluateConfigurations {
         definitions,
         allGeneratedFiles
       )
-    }
-  }
+  end evaluateSbtFile
 
   private def addOffset(offset: Int, lines: Seq[(String, Int)]): Seq[(String, Int)] =
     lines.map { (s, i) => (s, i + offset) }
@@ -201,11 +195,10 @@ private[sbt] object EvaluateConfigurations {
   /**
    * The name of the class we cast DSL "setting" (vs. definition) lines to.
    */
-  val SettingsDefinitionName = {
+  val SettingsDefinitionName =
     val _ =
       classOf[DslEntry] // this line exists to try to provide a compile-time error when the following line needs to be changed
     "sbt.internal.DslEntry"
-  }
 
   /**
    * This actually compiles a scala expression which represents a sbt.internals.DslEntry.
@@ -225,11 +218,11 @@ private[sbt] object EvaluateConfigurations {
       imports: Seq[(String, Int)],
       expression: String,
       range: LineRange
-  ): TrackedEvalResult[DslEntry] = {
+  ): TrackedEvalResult[DslEntry] =
     // TODO - Should we try to namespace these between.sbt files?  IF they hash to the same value, they may actually be
     // exactly the same setting, so perhaps we don't care?
     val result =
-      try {
+      try
         eval.eval(
           expression,
           imports = new EvalImports(imports.map(_._1)), // name
@@ -237,18 +230,16 @@ private[sbt] object EvaluateConfigurations {
           tpeName = Some(SettingsDefinitionName),
           line = range.start
         )
-      } catch {
+      catch
         case e: EvalException => throw new MessageOnlyException(e.getMessage)
-      }
     // TODO - keep track of configuration classes defined.
     TrackedEvalResult(
       result.generated,
-      loader => {
+      loader =>
         val pos = RangePosition(name, range.shift(1))
         result.getValue(loader).asInstanceOf[DslEntry].withPos(pos)
-      }
     )
-  }
+  end evaluateDslEntry
 
   /**
    * This actually compiles a scala expression which represents a Seq[Setting[_]], although the
@@ -308,13 +299,11 @@ private[sbt] object EvaluateConfigurations {
     lines partition { case (_, tree, _) => isDefinition(tree) }
 
   @tailrec
-  private def isDefinition(tree: Tree): Boolean = {
-    tree match {
+  private def isDefinition(tree: Tree): Boolean =
+    tree match
       case Annotated(arg, annot) => isDefinition(arg)
       case _: ValOrDefDef        => true
       case _                     => false
-    }
-  }
 
   private def extractedValTypes: Seq[String] =
     Seq(
@@ -330,7 +319,7 @@ private[sbt] object EvaluateConfigurations {
       imports: Seq[(String, Int)],
       definitions: Seq[(String, LineRange)],
       file: Option[VirtualFileRef],
-  ): EvalDefinitions = {
+  ): EvalDefinitions =
     val convertedRanges = definitions.map { (s, r) => (s, r.start to r.end) }
     eval.evalDefinitions(
       convertedRanges,
@@ -339,13 +328,12 @@ private[sbt] object EvaluateConfigurations {
       // file,
       extractedValTypes
     )
-  }
-}
+end EvaluateConfigurations
 
 object BuildUtilLite:
   /** Import just the names. */
   def importNames(names: Seq[String]): Seq[String] =
-    if (names.isEmpty) Nil else names.mkString("import ", ", ", "") :: Nil
+    if names.isEmpty then Nil else names.mkString("import ", ", ", "") :: Nil
 
   /** Prepend `_root_` and import just the names. */
   def importNamesRoot(names: Seq[String]): Seq[String] = importNames(names map rootedName)
@@ -353,26 +341,24 @@ object BuildUtilLite:
   /** Wildcard import `.{*, given}` for all values. */
   def importAll(values: Seq[String]): Seq[String] = importNames(values map { _ + ".{*, given}" })
   def importAllRoot(values: Seq[String]): Seq[String] = importAll(values map rootedName)
-  def rootedName(s: String): String = if (s contains '.') "_root_." + s else s
+  def rootedName(s: String): String = if s contains '.' then "_root_." + s else s
 end BuildUtilLite
 
-object Index {
-  def allKeys(settings: Seq[Setting[?]]): Set[ScopedKey[?]] = {
+object Index:
+  def allKeys(settings: Seq[Setting[?]]): Set[ScopedKey[?]] =
     val result = new java.util.HashSet[ScopedKey[?]]
     settings.foreach { s =>
-      if (!s.key.key.isLocal && result.add(s.key)) {
-        s.dependencies.foreach(k => if (!k.key.isLocal) result.add(s.key))
-      }
+      if !s.key.key.isLocal && result.add(s.key) then
+        s.dependencies.foreach(k => if !k.key.isLocal then result.add(s.key))
     }
     result.asScala.toSet
-  }
 
   def stringToKeyMap(settings: Set[AttributeKey[?]]): Map[String, AttributeKey[?]] =
     stringToKeyMap0(settings)(_.label)
 
   private def stringToKeyMap0(
       settings: Set[AttributeKey[?]]
-  )(label: AttributeKey[?] => String): Map[String, AttributeKey[?]] = {
+  )(label: AttributeKey[?] => String): Map[String, AttributeKey[?]] =
     val multiMap = settings.groupBy(label)
     val duplicates = multiMap.iterator
       .collect { case (k, xs) if xs.size > 1 => (k, xs.map(_.tag)) }
@@ -384,11 +370,10 @@ object Index {
         .map { (k, tps) => s"'$k' (${tps.mkString(", ")})" }
         .mkString(",")
       sys.error(s"Some keys were defined with the same name but different types: $duplicateStr")
-  }
 
   private type TriggerMap = collection.mutable.HashMap[TaskId[?], Seq[TaskId[?]]]
 
-  def triggers(ss: Settings): Triggers = {
+  def triggers(ss: Settings): Triggers =
     val runBefore = new TriggerMap
     val triggeredBy = new TriggerMap
     ss.values.collect { case base: Task[?] =>
@@ -400,7 +385,10 @@ object Index {
       update(triggeredBy, Def.triggeredBy)
     }
     val onComplete = (GlobalScope / Def.onComplete).get(ss).getOrElse(() => ())
-    new Triggers(runBefore, triggeredBy, map => { onComplete(); map })
-  }
-
-}
+    new Triggers(
+      runBefore,
+      triggeredBy,
+      map =>
+        onComplete(); map
+    )
+end Index
diff --git a/buildfile/src/main/scala/sbt/internal/LoadedSbtFile.scala b/buildfile/src/main/scala/sbt/internal/LoadedSbtFile.scala
index b0a0997d0..bba19a4af 100644
--- a/buildfile/src/main/scala/sbt/internal/LoadedSbtFile.scala
+++ b/buildfile/src/main/scala/sbt/internal/LoadedSbtFile.scala
@@ -26,7 +26,7 @@ private[sbt] final case class LoadedSbtFile(
     // rather than what we have now...
     definitions: DefinedSbtValues,
     generatedFiles: Seq[Path]
-) {
+):
   // We still use merge for now.  We track originating sbt file in an alternative manner.
   def merge(o: LoadedSbtFile): LoadedSbtFile =
     new LoadedSbtFile(
@@ -40,13 +40,13 @@ private[sbt] final case class LoadedSbtFile(
 
   def clearProjects =
     new LoadedSbtFile(settings, Nil, importedDefs, manipulations, definitions, generatedFiles)
-}
+end LoadedSbtFile
 
 /**
  * Represents the `val`/`lazy val` definitions defined within a build.sbt file
  * which we can reference in other settings.
  */
-private[sbt] final class DefinedSbtValues(val sbtFiles: Seq[EvalDefinitions]) {
+private[sbt] final class DefinedSbtValues(val sbtFiles: Seq[EvalDefinitions]):
 
   def values(parent: ClassLoader): Seq[Any] =
     sbtFiles flatMap (_.values(parent))
@@ -56,15 +56,14 @@ private[sbt] final class DefinedSbtValues(val sbtFiles: Seq[EvalDefinitions]) {
       e.loader(cl)
     }
 
-  def imports: Seq[String] = {
+  def imports: Seq[String] =
     // TODO - Sanity check duplicates and such, so users get a nice warning rather
     // than explosion.
-    for {
+    for
       file <- sbtFiles
       m = file.enclosingModule
       v <- file.valNames.map(NameTransformer.decode)
-    } yield s"import ${m}.`${v}`"
-  }
+    yield s"import ${m}.`${v}`"
   def generated: Seq[Path] =
     sbtFiles.flatMap(_.generated)
 
@@ -79,8 +78,8 @@ private[sbt] final class DefinedSbtValues(val sbtFiles: Seq[EvalDefinitions]) {
    */
   def zip(other: DefinedSbtValues): DefinedSbtValues =
     new DefinedSbtValues(sbtFiles ++ other.sbtFiles)
-}
-private[sbt] object DefinedSbtValues {
+end DefinedSbtValues
+private[sbt] object DefinedSbtValues:
 
   /** Construct a DefinedSbtValues object directly from the underlying representation. */
   def apply(eval: EvalDefinitions): DefinedSbtValues =
@@ -89,10 +88,7 @@ private[sbt] object DefinedSbtValues {
   /** Construct an empty value object. */
   def empty = new DefinedSbtValues(Nil)
 
-}
-
-private[sbt] object LoadedSbtFile {
+private[sbt] object LoadedSbtFile:
 
   /** Represents an empty .sbt file: no Projects, imports, or settings. */
   def empty = new LoadedSbtFile(Nil, Nil, Nil, Nil, DefinedSbtValues.empty, Nil)
-}
diff --git a/buildfile/src/main/scala/sbt/internal/parser/SbtParser.scala b/buildfile/src/main/scala/sbt/internal/parser/SbtParser.scala
index 63fe498b0..1ed4e721b 100644
--- a/buildfile/src/main/scala/sbt/internal/parser/SbtParser.scala
+++ b/buildfile/src/main/scala/sbt/internal/parser/SbtParser.scala
@@ -76,7 +76,7 @@ private[sbt] object SbtParser:
    * when we know for a fact that the user-provided snippet doesn't
    * parse.
    */
-  private[sbt] class UniqueParserReporter extends Reporter {
+  private[sbt] class UniqueParserReporter extends Reporter:
 
     private val reporters = new ConcurrentHashMap[String, StoreReporter]()
 
@@ -91,47 +91,43 @@ private[sbt] object SbtParser:
       val reporter = getReporter(sourcePath)
       reporter.report(dia)
 
-    override def hasErrors: Boolean = {
+    override def hasErrors: Boolean =
       var result = false
-      reporters.forEachValue(100, r => if (r.hasErrors) result = true)
+      reporters.forEachValue(100, r => if r.hasErrors then result = true)
       result
-    }
 
     def createReporter(uniqueFileName: String): StoreReporter =
       val r = new StoreReporter(null)
       reporters.put(uniqueFileName, r)
       r
 
-    def getOrCreateReporter(uniqueFileName: String): StoreReporter = {
+    def getOrCreateReporter(uniqueFileName: String): StoreReporter =
       val r = reporters.get(uniqueFileName)
-      if (r == null) createReporter(uniqueFileName)
+      if r == null then createReporter(uniqueFileName)
       else r
-    }
 
-    private def getReporter(fileName: String) = {
+    private def getReporter(fileName: String) =
       val reporter = reporters.get(fileName)
-      if (reporter == null) {
+      if reporter == null then
         scalacGlobalInitReporter.getOrElse(
           sys.error(s"sbt forgot to initialize `scalacGlobalInitReporter`.")
         )
-      } else reporter
-    }
+      else reporter
 
     def throwParserErrorsIfAny(reporter: StoreReporter, fileName: String)(using
         context: Context
     ): Unit =
-      if reporter.hasErrors then {
+      if reporter.hasErrors then
         val seq = reporter.pendingMessages.map { info =>
           s"""[$fileName]:${info.pos.line}: ${info.msg}"""
         }
         val errorMessage = seq.mkString(System.lineSeparator)
         val error: String =
-          if (errorMessage.contains(XML_ERROR))
-            s"$errorMessage\n${SbtParser.XmlErrorMessage}"
+          if errorMessage.contains(XML_ERROR) then s"$errorMessage\n${SbtParser.XmlErrorMessage}"
           else errorMessage
         throw new MessageOnlyException(error)
-      } else ()
-  }
+      else ()
+  end UniqueParserReporter
 
   private[sbt] var scalacGlobalInitReporter: Option[ConsoleReporter] = None
 
@@ -251,7 +247,7 @@ private[sbt] case class SbtParser(
   private def splitExpressions(
       path: VirtualFileRef,
       lines: Seq[String]
-  ): (Seq[(String, Int)], Seq[(String, LineRange)], Seq[(String, Tree)]) = {
+  ): (Seq[(String, Int)], Seq[(String, LineRange)], Seq[(String, Tree)]) =
     // import sbt.internal.parser.MissingBracketHandler.findMissingText
     val code = lines.toIndexedSeq.mkString(END_OF_LINE)
     val wrapCode = s"""object SyntheticModule {
@@ -301,7 +297,7 @@ private[sbt] case class SbtParser(
         (stmt, tree)
       }
     )
-  }
+  end splitExpressions
 
   private def importsToLineRanges(
       sourceFile: SourceFile,
diff --git a/buildfile/src/main/scala/sbt/internal/parser/SbtRefactorings.scala b/buildfile/src/main/scala/sbt/internal/parser/SbtRefactorings.scala
index 36d67a9cd..69c166e84 100644
--- a/buildfile/src/main/scala/sbt/internal/parser/SbtRefactorings.scala
+++ b/buildfile/src/main/scala/sbt/internal/parser/SbtRefactorings.scala
@@ -34,7 +34,7 @@ private[sbt] object SbtRefactorings:
   def applySessionSettings(
       lines: Seq[String],
       commands: Seq[SessionSetting]
-  ): Seq[String] = {
+  ): Seq[String] =
     val split = SbtParser(FAKE_FILE, lines)
     given ctx: Context = SbtParser.defaultGlobalForParser.compileCtx
     val recordedCommands = recordCommands(commands, split)
@@ -42,24 +42,21 @@ private[sbt] object SbtRefactorings:
 
     val newContent = replaceFromBottomToTop(lines.mkString(END_OF_LINE), sortedRecordedCommands)
     newContent.linesIterator.toList
-  }
 
   private def replaceFromBottomToTop(
       modifiedContent: String,
       sortedRecordedCommands: Seq[(Int, String, String)]
-  ) = {
+  ) =
     sortedRecordedCommands.foldLeft(modifiedContent) { case (acc, (from, old, replacement)) =>
       val before = acc.substring(0, from)
       val after = acc.substring(from + old.length, acc.length)
       val afterLast = emptyStringForEmptyString(after)
       before + replacement + afterLast
     }
-  }
 
-  private def emptyStringForEmptyString(text: String) = {
+  private def emptyStringForEmptyString(text: String) =
     val trimmed = text.trim
-    if (trimmed.isEmpty) trimmed else text
-  }
+    if trimmed.isEmpty then trimmed else text
 
   private def recordCommands(commands: Seq[SessionSetting], split: SbtParser)(using Context) =
     commands.flatMap { case (_, command) =>
@@ -72,25 +69,22 @@ private[sbt] object SbtRefactorings:
   ) =
     split.settingsTrees.foldLeft(Seq.empty[(Int, String, String)]) { case (acc, (st, tree)) =>
       val treeName = extractSettingName(tree)
-      if (name == treeName) {
+      if name == treeName then
         val replacement =
-          if (acc.isEmpty) command.mkString(END_OF_LINE)
+          if acc.isEmpty then command.mkString(END_OF_LINE)
           else emptyString
         val pos = tree.sourcePos.start - SbtParser.WRAPPER_POSITION_OFFSET
         (pos, st, replacement) +: acc
-      } else {
-        acc
-      }
+      else acc
     }
 
-  private def toTreeStringMap(command: Seq[String]) = {
+  private def toTreeStringMap(command: Seq[String]) =
     val split = SbtParser(FAKE_FILE, command)
     val trees = split.settingsTrees
     val seq = trees.map { (statement, tree) =>
       (extractSettingName(tree), statement)
     }
     seq.toMap
-  }
 
   @tailrec
   private def extractSettingName(tree: untpd.Tree): String = tree match
diff --git a/buildfile/src/test/scala/sbt/internal/parser/CheckIfParsedSpec.scala b/buildfile/src/test/scala/sbt/internal/parser/CheckIfParsedSpec.scala
index 65c6c2605..aacf497f9 100644
--- a/buildfile/src/test/scala/sbt/internal/parser/CheckIfParsedSpec.scala
+++ b/buildfile/src/test/scala/sbt/internal/parser/CheckIfParsedSpec.scala
@@ -11,7 +11,7 @@ package parser
 
 abstract class CheckIfParsedSpec(
     val splitter: SplitExpressions.SplitExpression = EvaluateConfigurations.splitExpressions
-) extends AbstractSpec {
+) extends AbstractSpec:
 
   test(s"${this.getClass.getName} should parse sbt file") {
     files foreach { (content, description, nonEmptyImports, nonEmptyStatements) =>
@@ -34,13 +34,9 @@ abstract class CheckIfParsedSpec(
 
   private def shouldContains(b: Boolean): String =
     s"""Should ${
-        if (b) {
-          "contain"
-        } else {
-          "not contain"
-        }
+        if b then "contain"
+        else "not contain"
       }"""
 
   protected def files: Seq[(String, String, Boolean, Boolean)]
-
-}
+end CheckIfParsedSpec
diff --git a/buildfile/src/test/scala/sbt/internal/parser/CommentedXmlSpec.scala b/buildfile/src/test/scala/sbt/internal/parser/CommentedXmlSpec.scala
index 5e13f6f45..2c921e150 100644
--- a/buildfile/src/test/scala/sbt/internal/parser/CommentedXmlSpec.scala
+++ b/buildfile/src/test/scala/sbt/internal/parser/CommentedXmlSpec.scala
@@ -8,7 +8,7 @@
 
 package sbt.internal.parser
 
-object CommentedXmlSpec extends CheckIfParsedSpec {
+object CommentedXmlSpec extends CheckIfParsedSpec:
 
   override protected val files = Seq(
     (
@@ -95,4 +95,4 @@ object CommentedXmlSpec extends CheckIfParsedSpec {
       false
     )
   )
-}
+end CommentedXmlSpec
diff --git a/buildfile/src/test/scala/sbt/internal/parser/EmbeddedXmlSpec.scala b/buildfile/src/test/scala/sbt/internal/parser/EmbeddedXmlSpec.scala
index b3f2a043b..d06826d3a 100644
--- a/buildfile/src/test/scala/sbt/internal/parser/EmbeddedXmlSpec.scala
+++ b/buildfile/src/test/scala/sbt/internal/parser/EmbeddedXmlSpec.scala
@@ -10,7 +10,7 @@ package sbt.internal.parser
 
 import sbt.internal.util.MessageOnlyException
 
-object EmbeddedXmlSpec extends CheckIfParsedSpec {
+object EmbeddedXmlSpec extends CheckIfParsedSpec:
 
   test("File with xml content  should Handle last xml part") {
     val errorLine = """<version>4.0<version>"""
@@ -35,17 +35,16 @@ object EmbeddedXmlSpec extends CheckIfParsedSpec {
                        |
                        |""".stripMargin
 
-    try {
+    try
       splitter(buildSbt)
       sys.error("expected MessageOnlyException")
-    } catch {
+    catch
       case exception: MessageOnlyException =>
         val index = buildSbt.linesIterator.indexWhere(line => line.contains(errorLine)) + 1
         val numberRegex = """(\d+)""".r
         val message = exception.getMessage
         val list = numberRegex.findAllIn(message).toList
         assert(list.contains(index.toString))
-    }
   }
 
   protected val files = Seq(
@@ -169,5 +168,4 @@ object EmbeddedXmlSpec extends CheckIfParsedSpec {
       true
     )
   )
-
-}
+end EmbeddedXmlSpec
diff --git a/buildfile/src/test/scala/sbt/internal/parser/NewFormatSpec.scala b/buildfile/src/test/scala/sbt/internal/parser/NewFormatSpec.scala
index 659734bb5..c5f187dd8 100644
--- a/buildfile/src/test/scala/sbt/internal/parser/NewFormatSpec.scala
+++ b/buildfile/src/test/scala/sbt/internal/parser/NewFormatSpec.scala
@@ -15,7 +15,7 @@ import java.io.File
 import scala.io.Source
 import sbt.internal.inc.PlainVirtualFileConverter
 
-object NewFormatSpec extends AbstractSpec {
+object NewFormatSpec extends AbstractSpec:
   val converter = PlainVirtualFileConverter.converter
   given splitter: SplitExpressions.SplitExpression = EvaluateConfigurations.splitExpressions
 
@@ -36,4 +36,4 @@ object NewFormatSpec extends AbstractSpec {
       )
     }
   }
-}
+end NewFormatSpec
diff --git a/buildfile/src/test/scala/sbt/internal/parser/SbtParserErrorSpec.scala b/buildfile/src/test/scala/sbt/internal/parser/SbtParserErrorSpec.scala
index e8cc39b05..7f03d3596 100644
--- a/buildfile/src/test/scala/sbt/internal/parser/SbtParserErrorSpec.scala
+++ b/buildfile/src/test/scala/sbt/internal/parser/SbtParserErrorSpec.scala
@@ -17,7 +17,7 @@ import java.nio.file.Files
 import java.nio.file.Paths
 import verify.sourcecode.SourceLocation
 
-object SbtParserErrorSpec extends AbstractSpec {
+object SbtParserErrorSpec extends AbstractSpec:
 
   val converter = PlainVirtualFileConverter.converter
 
@@ -59,4 +59,4 @@ object SbtParserErrorSpec extends AbstractSpec {
       callback
       throw new AssertionError(s"$pos: expected a MessageOnlyException to be thrown")
     catch case ex: MessageOnlyException => ex.getMessage
-}
+end SbtParserErrorSpec
diff --git a/buildfile/src/test/scala/sbt/internal/parser/SessionSettingsSpec.scala b/buildfile/src/test/scala/sbt/internal/parser/SessionSettingsSpec.scala
index b1a0b2953..2394b5356 100644
--- a/buildfile/src/test/scala/sbt/internal/parser/SessionSettingsSpec.scala
+++ b/buildfile/src/test/scala/sbt/internal/parser/SessionSettingsSpec.scala
@@ -17,7 +17,7 @@ import java.nio.file.Path
 import java.nio.file.Paths
 import scala.jdk.CollectionConverters.*
 
-abstract class AbstractSessionSettingsSpec(folder: String) extends AbstractSpec {
+abstract class AbstractSessionSettingsSpec(folder: String) extends AbstractSpec:
   private val rootDir = Paths.get(getClass.getResource("/" + folder).toURI)
   println(s"Reading files from: $rootDir")
   private val converter = PlainVirtualFileConverter.converter
@@ -62,7 +62,7 @@ abstract class AbstractSessionSettingsSpec(folder: String) extends AbstractSpec
 
   private def readLines(file: Path): Seq[String] =
     Files.readAllLines(file).asScala.toList
-}
+end AbstractSessionSettingsSpec
 
 object SessionSettingsSpec extends AbstractSessionSettingsSpec("session-settings")
 
diff --git a/buildfile/src/test/scala/sbt/internal/parser/SplitExpressionsBehavior.scala b/buildfile/src/test/scala/sbt/internal/parser/SplitExpressionsBehavior.scala
index d3260f998..a5ba9fd76 100644
--- a/buildfile/src/test/scala/sbt/internal/parser/SplitExpressionsBehavior.scala
+++ b/buildfile/src/test/scala/sbt/internal/parser/SplitExpressionsBehavior.scala
@@ -14,15 +14,15 @@ import sbt.internal.util.LineRange
 import xsbti.VirtualFileRef
 import dotty.tools.dotc.ast.untpd.Tree
 
-trait SplitExpression {
+trait SplitExpression:
   extension (splitter: SplitExpressions.SplitExpression)
     def apply(s: String): (Seq[(String, Int)], Seq[(String, Tree, LineRange)]) =
       splitter(VirtualFileRef.of("noFile"), s.split('\n').toSeq)
-}
 
-trait SplitExpressionsBehavior extends SplitExpression { this: verify.BasicTestSuite =>
+trait SplitExpressionsBehavior extends SplitExpression:
+  this: verify.BasicTestSuite =>
 
-  def newExpressionsSplitter(splitter: SplitExpressions.SplitExpression) = {
+  def newExpressionsSplitter(splitter: SplitExpressions.SplitExpression) =
 
     test("parse a two settings without intervening blank line") {
       val (imports, settings) = splitter(
@@ -64,6 +64,5 @@ trait SplitExpressionsBehavior extends SplitExpression { this: verify.BasicTestS
       assert(imports.size == 1)
       assert(settingsAndDefs.size == 1)
     }
-  }
-
-}
+  end newExpressionsSplitter
+end SplitExpressionsBehavior
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/Cont.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/Cont.scala
index 8393c6d91..abbd305c2 100644
--- a/core-macros/src/main/scala/sbt/internal/util/appmacro/Cont.scala
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/Cont.scala
@@ -236,7 +236,7 @@ trait Cont:
               val lambda = Lambda(
                 owner = Symbol.spliceOwner,
                 tpe = tpe,
-                rhsFn = (sym, params) => {
+                rhsFn = (sym, params) =>
                   val param = params.head.asInstanceOf[Term]
                   // Called when transforming the tree to add an input.
                   //  For `qual` of type F[A], and a `selection` qual.value,
@@ -261,7 +261,6 @@ trait Cont:
                       ).asTerm
                         .changeOwner(sym)
                     case None => modifiedBody.asTerm
-                }
               ).asExprOf[a => A1]
               val expr = input.term.asExprOf[F[a]]
               typed[F[A1]](
@@ -274,6 +273,7 @@ trait Cont:
             genMap0[Effect[A]](inner(body).asExprOf[Effect[A]])
           case Right(_) =>
             flatten(genMap0[F[Effect[A]]](inner(body).asExprOf[F[Effect[A]]]))
+      end genMap
 
       def genMapN(body: Term, inputs: List[Input]): Expr[F[Effect[A]]] =
         def genMapN0[A1: Type](body: Expr[A1]): Expr[F[A1]] =
@@ -285,7 +285,7 @@ trait Cont:
               val lambda = Lambda(
                 owner = Symbol.spliceOwner,
                 tpe = lambdaTpe,
-                rhsFn = (sym, params) => {
+                rhsFn = (sym, params) =>
                   val p0 = params.head.asInstanceOf[Term]
                   // Called when transforming the tree to add an input.
                   //  For `qual` of type F[A], and a `selection` qual.value,
@@ -342,9 +342,10 @@ trait Cont:
                           body = modifiedBody,
                           input = unitExpr,
                         ).asTerm.changeOwner(sym)
+                      end if
                     case None =>
                       modifiedBody.asTerm
-                }
+                  end match
               )
               val tupleMapRepr = TypeRepr
                 .of[Tuple.Map]
@@ -358,11 +359,14 @@ trait Cont:
                       ${ lambda.asExprOf[inputTypeTpe & Tuple => A1] }
                     )
                   }
+          end match
+        end genMapN0
         eitherTree match
           case Left(_) =>
             genMapN0[Effect[A]](inner(body).asExprOf[Effect[A]])
           case Right(_) =>
             flatten(genMapN0[F[Effect[A]]](inner(body).asExprOf[F[Effect[A]]]))
+      end genMapN
 
       // call `ActionCache.cache`
       def callActionCache[A1: Type, A2: Type](
@@ -512,6 +516,8 @@ trait Cont:
         if hasPrintTreeMacroSetting then Console.err.println(Printer.TreeStructure.show(r.asTerm))
         else Console.err.println(r.show)
       r
+    end contImpl
+  end extension
 end Cont
 
 private[sbt] object Cont:
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/ContextUtil.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/ContextUtil.scala
index 2d1414553..f8459aac6 100644
--- a/core-macros/src/main/scala/sbt/internal/util/appmacro/ContextUtil.scala
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/ContextUtil.scala
@@ -116,6 +116,8 @@ trait ContextUtil[C <: Quotes & scala.Singleton](val valStart: Int):
         case Inlined(_, _, tree) => extractTags(tree)
         case Apply(_, List(arg)) => extractTags(arg)
         case _                   => extractTags0(tree)
+    end extractTags
+  end Input
 
   def cacheLevels(tree: Term): Seq[CacheLevelTag] =
     tree.underlying match
@@ -202,6 +204,7 @@ trait ContextUtil[C <: Quotes & scala.Singleton](val valStart: Int):
     end scanner
     scanner.traverseTree(tree)(Symbol.spliceOwner)
     result.toSet
+  end collectNowarnQuals
 
   def collectDefs(tree: Term, isWrapper: (String, TypeRepr, Term) => Boolean): Set[Symbol] =
     val defs = mutable.HashSet[Symbol]()
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/Convert.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/Convert.scala
index f4b359371..8abd0a706 100644
--- a/core-macros/src/main/scala/sbt/internal/util/appmacro/Convert.scala
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/Convert.scala
@@ -70,6 +70,7 @@ trait Convert[C <: Quotes & Singleton] extends ContextUtil[C]:
             super.transformTerm(tree)(owner)
     end appTransformer
     appTransformer.transformTerm(tree)(owner)
+  end transformWrappers
 
   object Converted:
     def success(tree: Term) = Converted.Success(tree, Types.idFun)
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/LineReader.scala b/internal/util-complete/src/main/scala/sbt/internal/util/LineReader.scala
index 9c821ec20..adb2e9856 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/LineReader.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/LineReader.scala
@@ -32,18 +32,17 @@ import java.net.MalformedURLException
 
 import org.jline.builtins.InputRC
 
-trait LineReader extends AutoCloseable {
+trait LineReader extends AutoCloseable:
   def readLine(prompt: String, mask: Option[Char] = None): Option[String]
   override def close(): Unit = {}
-}
 
-object LineReader {
+object LineReader:
   val HandleCONT =
     !java.lang.Boolean.getBoolean("sbt.disable.cont") && Signals.supported(Signals.CONT)
   val MaxHistorySize = 500
 
-  private def completer(parser: Parser[?]): Completer = new Completer {
-    def complete(lr: JLineReader, pl: ParsedLine, candidates: JList[Candidate]): Unit = {
+  private def completer(parser: Parser[?]): Completer = new Completer:
+    def complete(lr: JLineReader, pl: ParsedLine, candidates: JList[Candidate]): Unit =
       Parser.completions(parser, pl.line(), 10).get.foreach { c =>
         /*
          * For commands like `~` that delegate parsing to another parser, the `~` may be
@@ -61,39 +60,32 @@ object LineReader {
          * the prefix, so that `testOnly com<Tab>` might expand to something like:
          * `testOnly testOnly\ com.foo.FooSpec` instead of `testOnly com.foo.FooSpec`.
          */
-        if (c.append.nonEmpty) {
-          val cand = pl.line() match {
+        if c.append.nonEmpty then
+          val cand = pl.line() match
             case line if line.endsWith(" ") => c.append
             case line                       => line.split(" ").last + c.append
-          }
           // https://github.com/jline/jline3/blob/9a4971868e4bdd29a36e454de01f54d3cd6071e0/reader/src/main/java/org/jline/reader/Candidate.java#L123-L131
           // "If the candidate is complete and is selected, a space separator will be added."
           val complete = false
           candidates.add(new Candidate(cand, cand, null, null, null, null, complete))
-        }
       }
-    }
-  }
-  private def inputrcFileUrl(): Option[URL] = {
+  private def inputrcFileUrl(): Option[URL] =
     // keep jline2 compatibility
     // https://github.com/jline/jline2/blob/12b98d94589e3bd6a6/src/main/java/jline/console/ConsoleReader.java#L291-L306
     sys.props
       .get("jline.inputrc")
       .flatMap { path =>
-        try {
-          Some(url(path))
-        } catch {
+        try Some(url(path))
+        catch
           case _: MalformedURLException =>
             Some(file(path).toURI.toURL)
-        }
       }
       .orElse {
         sys.props.get("user.home").map { home =>
           val f = file(home) / ".inputrc"
-          (if (f.isFile) f else file("/etc/inputrc")).toURI.toURL
+          (if f.isFile then f else file("/etc/inputrc")).toURI.toURL
         }
       }
-  }
   // cache on memory.
   private lazy val inputrcFileContents: Option[Array[Byte]] =
     inputrcFileUrl().map(in => sbt.io.IO.readBytes(in.openStream()))
@@ -101,11 +93,11 @@ object LineReader {
       historyPath: Option[File],
       parser: Parser[?],
       terminal: Terminal,
-  ): LineReader = {
+  ): LineReader =
     // We may want to consider in-sourcing LineReader.java from jline. We don't otherwise
     // directly need jline3 for sbt.
-    new LineReader {
-      override def readLine(prompt: String, mask: Option[Char]): Option[String] = {
+    new LineReader:
+      override def readLine(prompt: String, mask: Option[Char]): Option[String] =
         val term = JLine3(terminal)
         val reader = LineReaderBuilder
           .builder()
@@ -113,69 +105,62 @@ object LineReader {
           .completer(completer(parser))
           .option(JLineReader.Option.CASE_INSENSITIVE, true)
           .build()
-        try {
+        try
           inputrcFileContents.foreach { bytes =>
             InputRC.configure(
               reader,
               new ByteArrayInputStream(bytes)
             )
           }
-        } catch {
+        catch
           case NonFatal(_) =>
           // ignore
-        }
         historyPath.foreach(f => reader.setVariable(JLineReader.HISTORY_FILE, f))
-        val signalRegistration = terminal match {
+        val signalRegistration = terminal match
           case _: Terminal.ConsoleTerminal => Some(Signals.register(() => terminal.write(-1)))
           case _                           => None
-        }
         try
           terminal.withRawInput {
             Option(mask.map(reader.readLine(prompt, _)).getOrElse(reader.readLine(prompt)))
           }
-        catch {
+        catch
           case e: EndOfFileException =>
-            if (terminal == Terminal.console && !Terminal.hasConsole) None
+            if terminal == Terminal.console && !Terminal.hasConsole then None
             else Some("exit")
           case _: IOError | _: ClosedException => Some("exit")
           case _: UserInterruptException | _: ClosedByInterruptException |
               _: UncheckedIOException =>
             throw new InterruptedException
-        } finally {
+        finally
           signalRegistration.foreach(_.remove())
           terminal.prompt.reset()
           term.close()
-        }
-      }
-    }
-  }
+      end readLine
 
   def createJLine2Reader(
       historyPath: Option[File],
       terminal: Terminal,
       prompt: Prompt = Prompt.Running,
-  ): ConsoleReader = {
+  ): ConsoleReader =
     val cr = Terminal.createReader(terminal, prompt)
     cr.setExpandEvents(false) // https://issues.scala-lang.org/browse/SI-7650
     cr.setBellEnabled(false)
-    val h = historyPath match {
+    val h = historyPath match
       case None       => new MemoryHistory
       case Some(file) => new FileHistory(file): MemoryHistory
-    }
     h.setMaxSize(MaxHistorySize)
     cr.setHistory(h)
     cr.setHistoryEnabled(true)
     cr
-  }
   def simple(terminal: Terminal): LineReader = new SimpleReader(None, HandleCONT, terminal)
   def simple(
       historyPath: Option[File],
       handleCONT: Boolean = HandleCONT,
       injectThreadSleep: Boolean = false
   ): LineReader = new SimpleReader(historyPath, handleCONT, injectThreadSleep)
-}
+end LineReader
 
-abstract class JLine extends LineReader {
+abstract class JLine extends LineReader:
   protected def handleCONT: Boolean
   protected def reader: ConsoleReader
 
@@ -188,79 +173,67 @@ abstract class JLine extends LineReader {
     }
 
   private def readLineWithHistory(prompt: String, mask: Option[Char]): Option[String] =
-    reader.getHistory match {
+    reader.getHistory match
       case fh: FileHistory =>
         try readLineDirect(prompt, mask)
         finally fh.flush()
       case _ => readLineDirect(prompt, mask)
-    }
 
   private def readLineDirect(prompt: String, mask: Option[Char]): Option[String] =
-    if (handleCONT)
+    if handleCONT then
       Signals.withHandler(() => resume(), signal = Signals.CONT)(() =>
         readLineDirectRaw(prompt, mask)
       )
-    else
-      readLineDirectRaw(prompt, mask)
+    else readLineDirectRaw(prompt, mask)
 
-  private def readLineDirectRaw(prompt: String, mask: Option[Char]): Option[String] = {
+  private def readLineDirectRaw(prompt: String, mask: Option[Char]): Option[String] =
     val newprompt = handleMultilinePrompt(prompt)
-    mask match {
+    mask match
       case Some(m) => Option(reader.readLine(newprompt, m))
       case None    => Option(reader.readLine(newprompt))
-    }
-  }
 
-  private def handleMultilinePrompt(prompt: String): String = {
+  private def handleMultilinePrompt(prompt: String): String =
     val lines0 = """\r?\n""".r.split(prompt)
-    lines0.length match {
+    lines0.length match
       case 0 | 1 => handleProgress(prompt)
       case _     =>
         val lines = lines0.toList map handleProgress
         // Workaround for regression jline/jline2#205
         reader.getOutput.write(lines.init.mkString("\n") + "\n")
         lines.last
-    }
-  }
 
-  private def handleProgress(prompt: String): String = {
+  private def handleProgress(prompt: String): String =
     import ConsoleAppender.*
-    if (showProgress) s"$DeleteLine" + prompt
+    if showProgress then s"$DeleteLine" + prompt
     else prompt
-  }
 
-  private def resume(): Unit = {
+  private def resume(): Unit =
     Terminal.reset()
     reader.drawLine()
     reader.flush()
-  }
-}
+end JLine
 
 final class FullReader(
     historyPath: Option[File],
     complete: Parser[?],
     val handleCONT: Boolean,
     terminal: Terminal
-) extends JLine {
-  protected val reader: ConsoleReader = {
+) extends JLine:
+  protected val reader: ConsoleReader =
     val cr = LineReader.createJLine2Reader(historyPath, terminal)
     sbt.internal.util.complete.JLineCompletion.installCustomCompletor(cr, complete)
     cr
-  }
-}
 
 class SimpleReader private[sbt] (
     historyPath: Option[File],
     val handleCONT: Boolean,
     terminal: Terminal
-) extends JLine {
+) extends JLine:
   def this(historyPath: Option[File], handleCONT: Boolean, injectThreadSleep: Boolean) =
     this(historyPath, handleCONT, Terminal.console)
   protected lazy val reader: ConsoleReader =
     LineReader.createJLine2Reader(historyPath, terminal)
-}
 
-object SimpleReader extends SimpleReader(None, LineReader.HandleCONT, false) {
+object SimpleReader extends SimpleReader(None, LineReader.HandleCONT, false):
   def apply(terminal: Terminal): SimpleReader =
     new SimpleReader(None, LineReader.HandleCONT, terminal)
-}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/Completions.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Completions.scala
index 99f6ed088..31c71b448 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/Completions.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Completions.scala
@@ -13,7 +13,7 @@ package complete
  * Represents a set of completions. It exists instead of implicitly defined operations on top of
  * Set[Completion] for laziness.
  */
-sealed trait Completions {
+sealed trait Completions:
   def get: Set[Completion]
 
   final infix def x(o: Completions): Completions = flatMap(_ x o)
@@ -30,17 +30,15 @@ sealed trait Completions {
   final def map(f: Completion => Completion): Completions = Completions(get map f)
 
   override final def hashCode = get.hashCode
-  override final def equals(o: Any) = o match {
-    case c: Completions => get == c.get; case _ => false
-  }
-}
+  override final def equals(o: Any) = o match
+    case c: Completions => get == c.get;
+    case _              => false
 
-object Completions {
+object Completions:
 
   /** Returns a lazy Completions instance using the provided Completion Set. */
-  def apply(cs: => Set[Completion]): Completions = new Completions {
+  def apply(cs: => Set[Completion]): Completions = new Completions:
     lazy val get = cs
-  }
 
   /** Returns a strict Completions instance using the provided Completion Set. */
   def strict(cs: Set[Completion]): Completions = apply(cs)
@@ -59,8 +57,7 @@ object Completions {
 
   /** Returns a strict Completions instance containing only the provided Completion. */
   def single(c: Completion): Completions = strict(Set.empty + c)
-
-}
+end Completions
 
 /**
  * Represents a completion. The abstract members `display` and `append` are best explained with an
@@ -74,7 +71,7 @@ object Completions {
  * input if a completion is selected 2) the full token being completed, which is useful for
  * presenting a user with choices to select
  */
-sealed trait Completion {
+sealed trait Completion:
 
   /**
    * The proposed suffix to append to the existing input to complete the last token in the input.
@@ -95,58 +92,51 @@ sealed trait Completion {
     else Completions.strict(Set.empty + this)
 
   override final lazy val hashCode = Completion.hashCode(this)
-  override final def equals(o: Any) = o match {
-    case c: Completion => Completion.equal(this, c); case _ => false
-  }
-}
+  override final def equals(o: Any) = o match
+    case c: Completion => Completion.equal(this, c);
+    case _             => false
+end Completion
 
-final class DisplayOnly(val display: String) extends Completion {
+final class DisplayOnly(val display: String) extends Completion:
   def isEmpty = display.isEmpty
   def append = ""
   override def toString = "{" + display + "}"
-}
 
-final class Token(val display: String, val append: String) extends Completion {
+final class Token(val display: String, val append: String) extends Completion:
   def isEmpty = display.isEmpty && append.isEmpty
   override final def toString = "[" + display + "]++" + append
-}
 
-final class Suggestion(val append: String) extends Completion {
+final class Suggestion(val append: String) extends Completion:
   def isEmpty = append.isEmpty
   def display = append
   override def toString = append
-}
 
-object Completion {
+object Completion:
   def concat(a: Completion, b: Completion): Completion =
-    (a, b) match {
+    (a, b) match
       case (as: Suggestion, bs: Suggestion)    => suggestion(as.append + bs.append)
       case (at: Token, _) if at.append.isEmpty => b
       case _ if a.isEmpty                      => b
       case _                                   => a
-    }
 
   def evaluatesRight(a: Completion): Boolean =
-    a match {
+    a match
       case _: Suggestion                  => true
       case at: Token if at.append.isEmpty => true
       case _                              => a.isEmpty
-    }
 
   def equal(a: Completion, b: Completion): Boolean =
-    (a, b) match {
+    (a, b) match
       case (as: Suggestion, bs: Suggestion)   => as.append == bs.append
       case (ad: DisplayOnly, bd: DisplayOnly) => ad.display == bd.display
       case (at: Token, bt: Token)             => at.display == bt.display && at.append == bt.append
       case _                                  => false
-    }
 
   def hashCode(a: Completion): Int =
-    a match {
+    a match
       case as: Suggestion  => (0, as.append).hashCode
       case ad: DisplayOnly => (1, ad.display).hashCode
       case at: Token       => (2, at.display, at.append).hashCode
-    }
 
   val empty: Completion = suggestion("")
   def single(c: Char): Completion = suggestion(c.toString)
@@ -160,4 +150,4 @@ object Completion {
   def tokenDisplay(append: String, display: String): Completion = new Token(display, append)
 
   def suggestion(value: String): Completion = new Suggestion(value)
-}
+end Completion
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/EditDistance.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/EditDistance.scala
index ea3a130c2..3e46a8615 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/EditDistance.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/EditDistance.scala
@@ -12,7 +12,7 @@ package complete
 import java.lang.Character.toLowerCase as lower
 
 /** @author Paul Phillips */
-object EditDistance {
+object EditDistance:
 
   /**
    * Translated from the java version at
@@ -29,23 +29,21 @@ object EditDistance {
       matchCost: Int = 0,
       caseCost: Int = 1,
       transpositions: Boolean = false
-  ): Int = {
+  ): Int =
     val _ = transposeCost
     val n = s.length
     val m = t.length
-    if (n == 0) {
-      m
-    } else if (m == 0) {
-      n
-    } else {
+    if n == 0 then m
+    else if m == 0 then n
+    else
       val d = Array.ofDim[Int](n + 1, m + 1)
       0 to n foreach (x => d(x)(0) = x)
       0 to m foreach (x => d(0)(x) = x)
 
-      for (i <- 1 to n; s_i = s(i - 1); j <- 1 to m) {
+      for i <- 1 to n; s_i = s(i - 1); j <- 1 to m do
         val t_j = t(j - 1)
         val cost =
-          if (s_i == t_j) matchCost else if (lower(s_i) == lower(t_j)) caseCost else subCost
+          if s_i == t_j then matchCost else if lower(s_i) == lower(t_j) then caseCost else subCost
 
         val c1 = d(i - 1)(j) + deleteCost
         val c2 = d(i)(j - 1) + insertCost
@@ -53,13 +51,11 @@ object EditDistance {
 
         d(i)(j) = c1 min c2 min c3
 
-        if (transpositions) {
-          if (i > 1 && j > 1 && s(i - 1) == t(j - 2) && s(i - 2) == t(j - 1))
+        if transpositions then
+          if i > 1 && j > 1 && s(i - 1) == t(j - 2) && s(i - 2) == t(j - 1) then
             d(i)(j) = d(i)(j) min (d(i - 2)(j - 2) + cost)
-        }
-      }
 
       d(n)(m)
-    }
-  }
-}
+    end if
+  end levenshtein
+end EditDistance
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/ExampleSource.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/ExampleSource.scala
index bf247b52b..a9239d2a0 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/ExampleSource.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/ExampleSource.scala
@@ -17,7 +17,7 @@ import sbt.io.IO
  * source is the [[sbt.internal.util.complete.FileExamples]] class, which provides a list of
  * suggested files to the user as they press the TAB key in the console.
  */
-trait ExampleSource {
+trait ExampleSource:
 
   /**
    * @return
@@ -35,14 +35,12 @@ trait ExampleSource {
    */
   def withAddedPrefix(addedPrefix: String): ExampleSource
 
-}
-
 /**
  * A convenience example source that wraps any collection of strings into a source of examples.
  * @param examples
  *   the examples that will be displayed to the user when they press the TAB key.
  */
-sealed case class FixedSetExamples(examples: Iterable[String]) extends ExampleSource {
+sealed case class FixedSetExamples(examples: Iterable[String]) extends ExampleSource:
   override def withAddedPrefix(addedPrefix: String): ExampleSource =
     FixedSetExamples(examplesWithRemovedPrefix(addedPrefix))
 
@@ -51,7 +49,6 @@ sealed case class FixedSetExamples(examples: Iterable[String]) extends ExampleSo
   private def examplesWithRemovedPrefix(prefix: String) = examples.collect {
     case example if example.startsWith(prefix) => example.substring(prefix.length)
   }
-}
 
 /**
  * Provides path completion examples based on files in the base directory.
@@ -60,13 +57,13 @@ sealed case class FixedSetExamples(examples: Iterable[String]) extends ExampleSo
  * @param prefix
  *   the part of the path already written by the user.
  */
-class FileExamples(base: File, prefix: String = "") extends ExampleSource {
+class FileExamples(base: File, prefix: String = "") extends ExampleSource:
   override def apply(): LazyList[String] = files(base).map(_.substring(prefix.length))
 
   override def withAddedPrefix(addedPrefix: String): FileExamples =
     new FileExamples(base, prefix + addedPrefix)
 
-  protected def files(directory: File): LazyList[String] = {
+  protected def files(directory: File): LazyList[String] =
     val childPaths = LazyList(IO.listFiles(directory)*)
     val prefixedDirectChildPaths = childPaths
       .map(IO.relativize(base, _).get)
@@ -76,8 +73,6 @@ class FileExamples(base: File, prefix: String = "") extends ExampleSource {
       .map(IO.relativize(base, _).get)
       .filter(dirStartsWithPrefix)
     prefixedDirectChildPaths ++ dirsToRecurseInto.flatMap(dir => files(new File(base, dir)))
-  }
 
   private def dirStartsWithPrefix(relativizedPath: String): Boolean =
     relativizedPath.startsWith(prefix) || prefix.startsWith(relativizedPath)
-}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/History.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/History.scala
index 3285cdb67..e4de4fd74 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/History.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/History.scala
@@ -12,7 +12,7 @@ package complete
 import History.number
 import java.io.File
 
-final class History private (val lines: IndexedSeq[String], val path: Option[File]) {
+final class History private (val lines: IndexedSeq[String], val path: Option[File]):
   private def reversed = lines.reverse
 
   def all: Seq[String] = lines
@@ -20,28 +20,23 @@ final class History private (val lines: IndexedSeq[String], val path: Option[Fil
   def !! : Option[String] = !-(1)
 
   def apply(i: Int): Option[String] =
-    if (0 <= i && i < size) Some(lines(i))
-    else {
-      sys.error("Invalid history index: " + i)
-    }
+    if 0 <= i && i < size then Some(lines(i))
+    else sys.error("Invalid history index: " + i)
 
   def !(i: Int): Option[String] = apply(i)
 
   def !(s: String): Option[String] =
-    number(s) match {
-      case Some(n) => if (n < 0) !-(-n) else apply(n)
+    number(s) match
+      case Some(n) => if n < 0 then !-(-n) else apply(n)
       case None    => nonEmpty(s) { reversed.find(_.startsWith(s)) }
-    }
 
   def !-(n: Int): Option[String] = apply(size - n - 1)
 
   def !?(s: String): Option[String] = nonEmpty(s) { reversed.drop(1).find(_.contains(s)) }
 
   private def nonEmpty[T](s: String)(act: => Option[T]): Option[T] =
-    if (s.isEmpty)
-      sys.error("No action specified to history command")
-    else
-      act
+    if s.isEmpty then sys.error("No action specified to history command")
+    else act
 
   def list(historySize: Int, show: Int): Seq[String] =
     lines.toList
@@ -49,13 +44,12 @@ final class History private (val lines: IndexedSeq[String], val path: Option[Fil
       .zipWithIndex
       .map { (line, number) => "   " + number + "  " + line }
       .takeRight(show max 1)
-}
+end History
 
-object History {
+object History:
   def apply(lines: Seq[String], path: Option[File], error: String => Unit): History =
     new History(lines.toIndexedSeq, path)
   def apply(lines: Seq[String], path: Option[File]): History =
     new History(lines.toIndexedSeq, path)
 
   def number(s: String): Option[Int] = s.toIntOption
-}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/HistoryCommands.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/HistoryCommands.scala
index f446eb35e..0e9a216f1 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/HistoryCommands.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/HistoryCommands.scala
@@ -12,7 +12,7 @@ package complete
 import sbt.io.IO
 import Util.*
 
-object HistoryCommands {
+object HistoryCommands:
   val Start = "!"
   // second characters
   val Contains = "?"
@@ -59,20 +59,22 @@ object HistoryCommands {
   lazy val last = Last ^^^ { execute(_.!!) }
 
   lazy val list = ListCommands ~> (num ?? Int.MaxValue) map { show => (h: History) =>
-    { printHistory(h, MaxLines, show); nil[String].some }
+    printHistory(h, MaxLines, show); nil[String].some
   }
 
   lazy val execStr = flag('?') ~ token(any.+.string, "<string>") map { (contains, str) =>
-    execute(h => if (contains) h !? str else h ! str)
+    execute(h => if contains then h !? str else h ! str)
   }
 
   lazy val execInt = flag('-') ~ num map { (neg, value) =>
-    execute(h => if (neg) h !- value else h ! value)
+    execute(h => if neg then h !- value else h ! value)
   }
 
-  lazy val help = success((h: History) => { printHelp(); nil[String].some })
+  lazy val help = success((h: History) =>
+    printHelp(); nil[String].some
+  )
 
-  def execute(f: History => Option[String]): History => Option[List[String]] = (h: History) => {
+  def execute(f: History => Option[String]): History => Option[List[String]] = (h: History) =>
     val command = f(h).filterNot(_.startsWith(Start))
     val lines = h.lines.toArray
     command.foreach(lines(lines.length - 1) = _)
@@ -80,8 +82,7 @@ object HistoryCommands {
       IO.writeLines(h, lines.toSeq)
     }
     command.toList.some
-  }
 
   val actionParser: Parser[complete.History => Option[List[String]]] =
     Start ~> (help | last | execInt | list | execStr) // execStr must come last
-}
+end HistoryCommands
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/JLineCompletion.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/JLineCompletion.scala
index a784104f9..d743b69d5 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/JLineCompletion.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/JLineCompletion.scala
@@ -14,7 +14,7 @@ import jline.console.completer.{ Completer, CompletionHandler }
 import scala.annotation.tailrec
 import scala.jdk.CollectionConverters.*
 
-object JLineCompletion {
+object JLineCompletion:
   def installCustomCompletor(reader: ConsoleReader, parser: Parser[?]): Unit =
     installCustomCompletor(reader)(parserAsCompletor(parser))
 
@@ -26,14 +26,13 @@ object JLineCompletion {
   def installCustomCompletor(
       complete: (ConsoleReader, Int) => Boolean,
       reader: ConsoleReader
-  ): Unit = {
+  ): Unit =
     reader.removeCompleter(DummyCompletor)
     reader.addCompleter(DummyCompletor)
     reader.setCompletionHandler(new CustomHandler(complete))
-  }
 
   private final class CustomHandler(completeImpl: (ConsoleReader, Int) => Boolean)
-      extends CompletionHandler {
+      extends CompletionHandler:
     private var previous: Option[(String, Int)] = None
     private var level: Int = 1
 
@@ -41,144 +40,120 @@ object JLineCompletion {
         reader: ConsoleReader,
         candidates: java.util.List[CharSequence],
         position: Int
-    ) = {
+    ) =
       val current = Some(bufferSnapshot(reader))
-      level = if (current == previous) level + 1 else 1
+      level = if current == previous then level + 1 else 1
       previous = current
       try completeImpl(reader, level)
-      catch {
+      catch
         case e: Exception =>
           reader.print("\nException occurred while determining completions.")
           e.printStackTrace()
           false
-      }
-    }
-  }
 
   // always provides dummy completions so that the custom completion handler gets called
   //   (ConsoleReader doesn't call the handler if there aren't any completions)
   //   the custom handler will then throw away the candidates and call the custom function
-  private object DummyCompletor extends Completer {
+  private object DummyCompletor extends Completer:
     override def complete(
         buffer: String,
         cursor: Int,
         candidates: java.util.List[CharSequence]
-    ): Int = {
+    ): Int =
       candidates.add("dummy")
       0
-    }
-  }
 
   def parserAsCompletor(p: Parser[?]): (String, Int) => (Seq[String], Seq[String]) =
     (str, level) => convertCompletions(Parser.completions(p, str, level))
 
-  def convertCompletions(c: Completions): (Seq[String], Seq[String]) = {
+  def convertCompletions(c: Completions): (Seq[String], Seq[String]) =
     val cs = c.get
-    if (cs.isEmpty)
-      (Nil, "{invalid input}" :: Nil)
-    else
-      convertCompletions(cs)
-  }
+    if cs.isEmpty then (Nil, "{invalid input}" :: Nil)
+    else convertCompletions(cs)
 
-  def convertCompletions(cs: Set[Completion]): (Seq[String], Seq[String]) = {
+  def convertCompletions(cs: Set[Completion]): (Seq[String], Seq[String]) =
     val (insert, display) =
       cs.foldLeft((Set.empty[String], Set.empty[String])) { case (t @ (insert, display), comp) =>
-        if (comp.isEmpty) t
+        if comp.isEmpty then t
         else (appendNonEmpty(insert, comp.append), appendNonEmpty(display, comp.display))
       }
     (insert.toSeq, display.toSeq.sorted)
-  }
 
-  def appendNonEmpty(set: Set[String], add: String) = if (add.trim.isEmpty) set else set + add
+  def appendNonEmpty(set: Set[String], add: String) = if add.trim.isEmpty then set else set + add
 
   def customCompletor(
       f: (String, Int) => (Seq[String], Seq[String])
   ): (ConsoleReader, Int) => Boolean =
-    (reader, level) => {
+    (reader, level) =>
       val success = complete(beforeCursor(reader), string => f(string, level), reader)
       reader.flush()
       success
-    }
 
-  def bufferSnapshot(reader: ConsoleReader): (String, Int) = {
+  def bufferSnapshot(reader: ConsoleReader): (String, Int) =
     val b = reader.getCursorBuffer
     (b.buffer.toString, b.cursor)
-  }
 
-  def beforeCursor(reader: ConsoleReader): String = {
+  def beforeCursor(reader: ConsoleReader): String =
     val b = reader.getCursorBuffer
     b.buffer.substring(0, b.cursor)
-  }
 
   // returns false if there was nothing to insert and nothing to display
   def complete(
       beforeCursor: String,
       completions: String => (Seq[String], Seq[String]),
       reader: ConsoleReader
-  ): Boolean = {
+  ): Boolean =
     val (insert, display) = completions(beforeCursor)
     val common = commonPrefix(insert)
-    if (common.isEmpty)
-      if (display.isEmpty)
-        ()
-      else
-        showCompletions(display, reader)
-    else
-      appendCompletion(common, reader)
+    if common.isEmpty then
+      if display.isEmpty then ()
+      else showCompletions(display, reader)
+    else appendCompletion(common, reader)
 
     !(common.isEmpty && display.isEmpty)
-  }
 
-  def appendCompletion(common: String, reader: ConsoleReader): Unit = {
+  def appendCompletion(common: String, reader: ConsoleReader): Unit =
     reader.getCursorBuffer.write(common)
     reader.redrawLine()
-  }
 
   /**
    * `display` is assumed to be the exact strings requested to be displayed. In particular,
    * duplicates should have been removed already.
    */
-  def showCompletions(display: Seq[String], reader: ConsoleReader): Unit = {
+  def showCompletions(display: Seq[String], reader: ConsoleReader): Unit =
     printCompletions(display, reader)
     reader.drawLine()
-  }
 
-  def printCompletions(cs: Seq[String], reader: ConsoleReader): Unit = {
+  def printCompletions(cs: Seq[String], reader: ConsoleReader): Unit =
     val print = shouldPrint(cs, reader)
     reader.println()
-    if (print) printLinesAndColumns(cs, reader)
-  }
+    if print then printLinesAndColumns(cs, reader)
 
-  def printLinesAndColumns(cs: Seq[String], reader: ConsoleReader): Unit = {
+  def printLinesAndColumns(cs: Seq[String], reader: ConsoleReader): Unit =
     val (lines, columns) = cs partition hasNewline
-    for (line <- lines) {
+    for line <- lines do
       reader.print(line)
-      if (line.charAt(line.length - 1) != '\n')
-        reader.println()
-    }
+      if line.charAt(line.length - 1) != '\n' then reader.println()
     reader.printColumns(columns.map(_.trim).asJava)
-  }
 
   def hasNewline(s: String): Boolean = s.indexOf('\n') >= 0
 
-  def shouldPrint(cs: Seq[String], reader: ConsoleReader): Boolean = {
+  def shouldPrint(cs: Seq[String], reader: ConsoleReader): Boolean =
     val size = cs.size
     (size <= reader.getAutoprintThreshold) ||
     confirm("Display all %d possibilities? (y or n) ".format(size), 'y', 'n', reader)
-  }
 
-  def confirm(prompt: String, trueC: Char, falseC: Char, reader: ConsoleReader): Boolean = {
+  def confirm(prompt: String, trueC: Char, falseC: Char, reader: ConsoleReader): Boolean =
     reader.println()
     reader.print(prompt)
     reader.flush()
     reader.readCharacter(trueC, falseC) == trueC
-  }
 
-  def commonPrefix(s: Seq[String]): String = if (s.isEmpty) "" else s reduceLeft commonPrefix
+  def commonPrefix(s: Seq[String]): String = if s.isEmpty then "" else s reduceLeft commonPrefix
 
-  def commonPrefix(a: String, b: String): String = {
+  def commonPrefix(a: String, b: String): String =
     val len = scala.math.min(a.length, b.length)
-    @tailrec def loop(i: Int): Int = if (i >= len) len else if (a(i) != b(i)) i else loop(i + 1)
+    @tailrec def loop(i: Int): Int =
+      if i >= len then len else if a(i) != b(i) then i else loop(i + 1)
     a.substring(0, loop(0))
-  }
-}
+end JLineCompletion
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parser.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parser.scala
index 979f1251a..f2872ce68 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parser.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parser.scala
@@ -31,7 +31,7 @@ trait Parser[+A1]:
   def valid: Boolean
 end Parser
 
-sealed trait RichParser[A] {
+sealed trait RichParser[A]:
 
   /**
    * Apply the original Parser and then apply `next` (in order). The result of both is provides as a
@@ -153,11 +153,11 @@ sealed trait RichParser[A] {
    * parser and uses its result for the overall result.
    */
   def flatMap[B](f: A => Parser[B]): Parser[B]
-}
+end RichParser
 
 /** Contains Parser implementation helper methods not typically needed for using parsers. */
 object Parser extends ParserMain:
-  sealed abstract class Result[+T] {
+  sealed abstract class Result[+T]:
     def isFailure: Boolean
     def isValid: Boolean
     def errors: Seq[String]
@@ -170,44 +170,42 @@ object Parser extends ParserMain:
     def seq[B](b: => Result[B]): Result[(T, B)] = app(b)((m, n) => (m, n))
     def app[B, C](b: => Result[B])(f: (T, B) => C): Result[C]
     def toEither: Either[() => Seq[String], T]
-  }
 
-  final case class Value[+T](value: T) extends Result[T] {
+  final case class Value[+T](value: T) extends Result[T]:
     def isFailure = false
     def isValid: Boolean = true
     def errors = Nil
 
-    def app[B, C](b: => Result[B])(f: (T, B) => C): Result[C] = b match {
+    def app[B, C](b: => Result[B])(f: (T, B) => C): Result[C] = b match
       case fail: Failure => fail
       case Value(bv)     => Value(f(value, bv))
-    }
 
-    infix def &&(b: => Result[?]): Result[T] = b match { case f: Failure => f; case _ => this }
+    infix def &&(b: => Result[?]): Result[T] = b match
+      case f: Failure => f;
+      case _          => this
     infix def or[B >: T](b: => Result[B]): Result[B] = this
     def either[B](b: => Result[B]): Result[Either[T, B]] = Value(Left(value))
     def map[B](f: T => B): Result[B] = Value(f(value))
     def flatMap[B](f: T => Result[B]): Result[B] = f(value)
-    def filter(f: T => Boolean, msg: => String): Result[T] = if (f(value)) this else mkFailure(msg)
+    def filter(f: T => Boolean, msg: => String): Result[T] =
+      if f(value) then this else mkFailure(msg)
     def toEither = Right(value)
-  }
 
   final class Failure private[sbt] (mkErrors: => Seq[String], val definitive: Boolean)
-      extends Result[Nothing] {
+      extends Result[Nothing]:
     lazy val errors: Seq[String] = mkErrors
     def isFailure = true
     def isValid = false
     def map[B](f: Nothing => B) = this
     def flatMap[B](f: Nothing => Result[B]) = this
 
-    infix def or[B](b: => Result[B]): Result[B] = b match {
+    infix def or[B](b: => Result[B]): Result[B] = b match
       case v: Value[B] => v
-      case f: Failure  => if (definitive) this else this ++ f
-    }
+      case f: Failure  => if definitive then this else this ++ f
 
-    def either[B](b: => Result[B]): Result[Either[Nothing, B]] = b match {
+    def either[B](b: => Result[B]): Result[Either[Nothing, B]] = b match
       case Value(v)   => Value(Right(v))
-      case f: Failure => if (definitive) this else this ++ f
-    }
+      case f: Failure => if definitive then this else this ++ f
 
     def filter(f: Nothing => Boolean, msg: => String) = this
     def app[B, C](b: => Result[B])(f: (Nothing, B) => C): Result[C] = this
@@ -215,7 +213,7 @@ object Parser extends ParserMain:
     def toEither = Left(() => errors)
 
     private[sbt] def ++(f: Failure) = mkFailures(errors ++ f.errors)
-  }
+  end Failure
 
   def mkFailures(errors: => Seq[String], definitive: Boolean = false): Failure =
     new Failure(errors.distinct, definitive)
@@ -224,26 +222,25 @@ object Parser extends ParserMain:
     new Failure(error :: Nil, definitive)
 
   def tuple[A, B](a: Option[A], b: Option[B]): Option[(A, B)] =
-    (a, b) match { case (Some(av), Some(bv)) => Some((av, bv)); case _ => None }
+    (a, b) match
+      case (Some(av), Some(bv)) => Some((av, bv));
+      case _                    => None
 
   def mapParser[A, B](a: Parser[A], f: A => B): Parser[B] =
     a.ifValid {
-      a.result match {
+      a.result match
         case Some(av) => success(f(av))
         case None     =>
-          a match {
+          a match
             case m: MapParser[?, ?] => m.map(f)
             case _                  => new MapParser(a, f)
-          }
-      }
     }
 
   def bindParser[A, B](a: Parser[A], f: A => Parser[B]): Parser[B] =
     a.ifValid {
-      a.result match {
+      a.result match
         case Some(av) => f(av)
         case None     => new BindParser(a, f)
-      }
     }
 
   def filterParser[T](
@@ -253,21 +250,19 @@ object Parser extends ParserMain:
       msg: String => String
   ): Parser[T] =
     a.ifValid {
-      a.result match {
+      a.result match
         case Some(av) if f(av) => success(av)
         case _                 => new Filter(a, f, seen, msg)
-      }
     }
 
   def seqParser[A, B](a: Parser[A], b: Parser[B]): Parser[(A, B)] =
     a.ifValid {
       b.ifValid {
-        (a.result, b.result) match {
+        (a.result, b.result) match
           case (Some(av), Some(bv)) => success((av, bv))
           case (Some(av), None)     => b.map(bv => (av, bv))
           case (None, Some(bv))     => a.map(av => (av, bv))
           case (None, None)         => new SeqParser(a, b)
-        }
       }
     }
 
@@ -300,7 +295,7 @@ object Parser extends ParserMain:
       min: Int,
       max: UpperBound,
       revAcc: List[T]
-  ): Parser[Seq[T]] = {
+  ): Parser[Seq[T]] =
     assume(min >= 0, "Minimum must be greater than or equal to zero (was " + min + ")")
     assume(
       max >= min,
@@ -308,39 +303,35 @@ object Parser extends ParserMain:
     )
 
     def checkRepeated(invalidButOptional: => Parser[Seq[T]]): Parser[Seq[T]] =
-      repeated match {
+      repeated match
         case _: Invalid if min == 0 => invalidButOptional
         case i: Invalid             => i
         case _                      =>
-          repeated.result match {
+          repeated.result match
             case Some(value) =>
               success(revAcc reverse_::: value :: Nil) // revAcc should be Nil here
             case None =>
-              if (max.isZero) success(revAcc.reverse)
+              if max.isZero then success(revAcc.reverse)
               else new Repeat(partial, repeated, min, max, revAcc)
-          }
-      }
 
-    partial match {
+    partial match
       case Some(part) =>
         part.ifValid {
-          part.result match {
+          part.result match
             case Some(value) => repeat(None, repeated, min, max, value :: revAcc)
             case None        => checkRepeated(part.map(lv => (lv :: revAcc).reverse))
-          }
         }
       case None => checkRepeated(success(Nil))
-    }
-  }
+  end repeat
 
   def and[T](a: Parser[T], b: Parser[?]): Parser[T] = a.ifValid(b.ifValid(new And(a, b)))
 
 end Parser
 
-trait ParserMain {
+trait ParserMain:
 
   /** Provides combinators for Parsers. */
-  implicit def richParser[A](a: Parser[A]): RichParser[A] = new RichParser[A] {
+  implicit def richParser[A](a: Parser[A]): RichParser[A] = new RichParser[A]:
     def ~[B](b: Parser[B]) = seqParser(a, b)
     def ||[B](b: Parser[B]) = choiceParser(a, b)
     def |[B >: A](b: Parser[B]) = homParser[B](a, b)
@@ -375,7 +366,6 @@ trait ParserMain {
     def filter(f: A => Boolean, msg: String => String): Parser[A] = filterParser(a, f, "", msg)
     def string(using ev: A <:< Seq[Char]): Parser[String] = map(_.mkString)
     def flatMap[B](f: A => Parser[B]) = bindParser(a, f)
-  }
 
   implicit def literalRichCharParser(c: Char): RichParser[Char] = richParser(c)
   implicit def literalRichStringParser(s: String): RichParser[String] = richParser(s)
@@ -405,21 +395,19 @@ trait ParserMain {
     invalid(msg :: Nil, definitive)
 
   /** Defines a parser that always succeeds on empty input with the result `value`. */
-  def success[T](value: T): Parser[T] = new ValidParser[T] {
+  def success[T](value: T): Parser[T] = new ValidParser[T]:
     override def result = Some(value)
     def resultEmpty = Value(value)
     def derive(c: Char) = Parser.failure("Expected end of input.")
     def completions(level: Int) = Completions.empty
     override def toString = "success(" + value + ")"
-  }
 
   /**
    * Presents a Char range as a Parser. A single Char is parsed only if it is in the given range.
    */
-  implicit def range(r: collection.immutable.NumericRange[Char]): Parser[Char] = {
+  implicit def range(r: collection.immutable.NumericRange[Char]): Parser[Char] =
     val label = r.map(_.toString).toString
     range(r, label)
-  }
 
   /**
    * Presents a Char range as a Parser. A single Char is parsed only if it is in the given range.
@@ -428,10 +416,9 @@ trait ParserMain {
     charClass(r contains _, label).examples(r.map(_.toString)*)
 
   /** Defines a Parser that parses a single character only if it is contained in `legal`. */
-  def chars(legal: String): Parser[Char] = {
+  def chars(legal: String): Parser[Char] =
     val set = legal.toSet
     charClass(set, "character in '" + legal + "'").examples(set.map(_.toString))
-  }
 
   /**
    * Defines a Parser that parses a single character only if the predicate `f` returns true for that
@@ -441,14 +428,13 @@ trait ParserMain {
     new CharacterClass(f, label)
 
   /** Presents a single Char `ch` as a Parser that only parses that exact character. */
-  implicit def literal(ch: Char): Parser[Char] = new ValidParser[Char] {
+  implicit def literal(ch: Char): Parser[Char] = new ValidParser[Char]:
     def result = None
     private lazy val fail = mkFailure("Expected '" + ch + "'")
     def resultEmpty = fail
-    def derive(c: Char) = if (c == ch) success(ch) else new Invalid(fail)
+    def derive(c: Char) = if c == ch then success(ch) else new Invalid(fail)
     def completions(level: Int) = Completions.single(Completion.suggestion(ch.toString))
     override def toString = "'" + ch + "'"
-  }
 
   /**
    * Presents a literal String `s` as a Parser that only parses that exact text and provides it as
@@ -457,7 +443,7 @@ trait ParserMain {
   implicit def literal(s: String): Parser[String] = stringLiteral(s, 0)
 
   /** See [[unapply]]. */
-  object ~ {
+  object `~`:
 
     /** Convenience for destructuring a tuple that mirrors the `~` combinator. */
     def unapply[A, B](t: (A, B)): (A, B) = t
@@ -469,8 +455,6 @@ trait ParserMain {
     @deprecated("Use unapply instead", "2.0.0")
     private[sbt] def unapplyDeprecated[A, B](t: (A, B)): Some[(A, B)] = Some(t)
 
-  }
-
   /**
    * Parses input `str` using `parser`. If successful, the result is provided wrapped in `Right`. If
    * unsuccessful, an error message is provided in `Left`.
@@ -490,7 +474,7 @@ trait ParserMain {
    * See also [[sampleParse]] and [[sampleCompletions]].
    */
   def sample(str: String, parser: Parser[?], completions: Boolean = false): Unit =
-    if (completions) sampleCompletions(str, parser) else sampleParse(str, parser)
+    if completions then sampleCompletions(str, parser) else sampleParse(str, parser)
 
   /**
    * Convenience method to use when developing a parser. `parser` is applied to the input `str` and
@@ -498,10 +482,9 @@ trait ParserMain {
    * error message is displayed.
    */
   def sampleParse(str: String, parser: Parser[?]): Unit =
-    parse(str, parser) match {
+    parse(str, parser) match
       case Left(msg) => println(msg)
       case Right(v)  => println(v)
-    }
 
   /**
    * Convenience method to use when developing a parser. `parser` is applied to the input `str` and
@@ -512,24 +495,21 @@ trait ParserMain {
     Parser.completions(parser, str, level).get foreach println
 
   // intended to be temporary pending proper error feedback
-  def result[T](p: Parser[T], s: String): Either[() => (Seq[String], Int), T] = {
+  def result[T](p: Parser[T], s: String): Either[() => (Seq[String], Int), T] =
     @tailrec
     def loop(i: Int, a: Parser[T]): Either[() => (Seq[String], Int), T] =
-      a match {
+      a match
         case Invalid(f) => Left(() => (f.errors, i))
         case _          =>
           val ci = i + 1
-          if (ci >= s.length)
+          if ci >= s.length then
             a.resultEmpty.toEither.left.map { msgs0 => () =>
               val msgs = msgs0()
-              val nonEmpty = if (msgs.isEmpty) Seq("Unexpected end of input") else msgs
+              val nonEmpty = if msgs.isEmpty then Seq("Unexpected end of input") else msgs
               (nonEmpty, ci)
             }
-          else
-            loop(ci, a.derive(s((ci))))
-      }
+          else loop(ci, a.derive(s((ci))))
     loop(-1, p)
-  }
 
   /** Applies parser `p` to input `s`. */
   def apply[T](p: Parser[T])(s: String): Parser[T] =
@@ -537,7 +517,7 @@ trait ParserMain {
 
   /** Applies parser `p` to a single character of input. */
   def derive1[T](p: Parser[T], c: Char): Parser[T] =
-    if (p.valid) p.derive(c) else p
+    if p.valid then p.derive(c) else p
 
   /**
    * Applies parser `p` to input `s` and returns the completions at verbosity `level`. The
@@ -575,27 +555,23 @@ trait ParserMain {
       maxNumberOfExamples: Int,
       removeInvalidExamples: Boolean
   ): Parser[A] =
-    if (a.valid) {
-      a.result match {
+    if a.valid then
+      a.result match
         case Some(av) => success(av)
         case None     =>
           new ParserWithExamples(a, completions, maxNumberOfExamples, removeInvalidExamples)
-      }
-    } else a
+    else a
 
   def matched(
       t: Parser[?],
       seen: Vector[Char] = Vector.empty,
       partial: Boolean = false
   ): Parser[String] =
-    t match {
-      case i: Invalid => if (partial && seen.nonEmpty) success(seen.mkString) else i
+    t match
+      case i: Invalid => if partial && seen.nonEmpty then success(seen.mkString) else i
       case _          =>
-        if (t.result.isEmpty)
-          new MatchedString(t, seen, partial)
-        else
-          success(seen.mkString)
-    }
+        if t.result.isEmpty then new MatchedString(t, seen, partial)
+        else success(seen.mkString)
 
   /**
    * Establishes delegate parser `t` as a single token of tab completion. When tab completion of
@@ -633,50 +609,44 @@ trait ParserMain {
     mkToken(t, "", complete)
 
   private[sbt] def mkToken[T](t: Parser[T], seen: String, complete: TokenCompletions): Parser[T] =
-    if (t.valid && !t.isTokenStart)
-      if (t.result.isEmpty) new TokenStart(t, seen, complete) else t
-    else
-      t
+    if t.valid && !t.isTokenStart then
+      if t.result.isEmpty then new TokenStart(t, seen, complete) else t
+    else t
 
-  def homParser[A](a: Parser[A], b: Parser[A]): Parser[A] = (a, b) match {
+  def homParser[A](a: Parser[A], b: Parser[A]): Parser[A] = (a, b) match
     case (Invalid(af), Invalid(bf)) => Invalid(af ++ bf)
     case (Invalid(_), bv)           => bv
     case (av, Invalid(_))           => av
     case (_, _)                     => new HomParser(a, b)
-  }
 
-  def not(p: Parser[?], failMessage: String): Parser[Unit] = p.result match {
+  def not(p: Parser[?], failMessage: String): Parser[Unit] = p.result match
     case None    => new Not(p, failMessage)
     case Some(_) => failure(failMessage)
-  }
 
   def oneOf[T](p: Seq[Parser[T]]): Parser[T] = p.reduceLeft(_ | _)
   def seq[T](p: Seq[Parser[T]]): Parser[Seq[T]] = seq0(p, Nil)
 
-  def seq0[T](p: Seq[Parser[T]], errors: => Seq[String]): Parser[Seq[T]] = {
+  def seq0[T](p: Seq[Parser[T]], errors: => Seq[String]): Parser[Seq[T]] =
     val (newErrors, valid) = separate(p) {
       case Invalid(f) => Left(() => f.errors): Either[() => Seq[String], Parser[T]]
       case ok         => Right(ok): Either[() => Seq[String], Parser[T]]
     }
     def combinedErrors = errors ++ newErrors.flatMap(_())
-    if (valid.isEmpty) invalid(combinedErrors) else new ParserSeq(valid, combinedErrors)
-  }
+    if valid.isEmpty then invalid(combinedErrors) else new ParserSeq(valid, combinedErrors)
 
-  def stringLiteral(s: String, start: Int): Parser[String] = {
+  def stringLiteral(s: String, start: Int): Parser[String] =
     val len = s.length
-    if (len == 0) sys.error("String literal cannot be empty")
-    else if (start >= len) success(s)
+    if len == 0 then sys.error("String literal cannot be empty")
+    else if start >= len then success(s)
     else new StringLiteral(s, start)
-  }
-}
+end ParserMain
 
-sealed trait ValidParser[T] extends Parser[T] {
+sealed trait ValidParser[T] extends Parser[T]:
   final def valid = true
   final def failure = None
   final def ifValid[S](p: => Parser[S]): Parser[S] = p
-}
 
-private final case class Invalid(fail: Failure) extends Parser[Nothing] {
+private final case class Invalid(fail: Failure) extends Parser[Nothing]:
   def failure = Some(fail)
   def result = None
   def resultEmpty = fail
@@ -685,138 +655,114 @@ private final case class Invalid(fail: Failure) extends Parser[Nothing] {
   override def toString = fail.errors.mkString("; ")
   def valid = false
   def ifValid[S](p: => Parser[S]): Parser[S] = this
-}
 
-private final case class SoftInvalid(fail: Failure) extends ValidParser[Nothing] {
+private final case class SoftInvalid(fail: Failure) extends ValidParser[Nothing]:
   def result = None
   def resultEmpty = fail
   def derive(c: Char) = Invalid(fail)
   def completions(level: Int) = Completions.nil
   override def toString = fail.errors.mkString("; ")
-}
 
-private final class TrapAndFail[A](a: Parser[A]) extends ValidParser[A] {
+private final class TrapAndFail[A](a: Parser[A]) extends ValidParser[A]:
   def result =
-    try {
-      a.result
-    } catch { case _: Exception => None }
+    try a.result
+    catch case _: Exception => None
   def resultEmpty =
-    try {
-      a.resultEmpty
-    } catch { case e: Exception => fail(e) }
+    try a.resultEmpty
+    catch case e: Exception => fail(e)
 
   def derive(c: Char) =
-    try {
-      trapAndFail(a.derive(c))
-    } catch {
-      case e: Exception => Invalid(fail(e))
-    }
+    try trapAndFail(a.derive(c))
+    catch case e: Exception => Invalid(fail(e))
 
   def completions(level: Int) =
-    try {
-      a.completions(level)
-    } catch {
-      case _: Exception => Completions.nil
-    }
+    try a.completions(level)
+    catch case _: Exception => Completions.nil
 
   override def toString = "trap(" + a + ")"
   override def isTokenStart = a.isTokenStart
   private def fail(e: Exception): Failure = mkFailure(e.toString)
-}
 
-private final class OnFailure[A](a: Parser[A], message: String) extends ValidParser[A] {
+private final class OnFailure[A](a: Parser[A], message: String) extends ValidParser[A]:
   def result = a.result
 
-  def resultEmpty = a.resultEmpty match {
-    case _: Failure => mkFailure(message); case v: Value[A] => v
-  }
+  def resultEmpty = a.resultEmpty match
+    case _: Failure  => mkFailure(message);
+    case v: Value[A] => v
 
   def derive(c: Char) = onFailure(a.derive(c), message)
   def completions(level: Int) = a.completions(level)
   override def toString = "(" + a + " !!! \"" + message + "\" )"
   override def isTokenStart = a.isTokenStart
-}
 
-private final class SeqParser[A, B](a: Parser[A], b: Parser[B]) extends ValidParser[(A, B)] {
+private final class SeqParser[A, B](a: Parser[A], b: Parser[B]) extends ValidParser[(A, B)]:
   lazy val result = tuple(a.result, b.result)
   lazy val resultEmpty = a.resultEmpty.seq(b.resultEmpty)
 
-  def derive(c: Char) = {
+  def derive(c: Char) =
     val common = a.derive(c) ~ b
-    a.resultEmpty match {
+    a.resultEmpty match
       case Value(av)  => common | b.derive(c).map(br => (av, br))
       case _: Failure => common
-    }
-  }
 
   def completions(level: Int) = a.completions(level).x(b.completions(level))
   override def toString = "(" + a + " ~ " + b + ")"
-}
 
-private final class HomParser[A](a: Parser[A], b: Parser[A]) extends ValidParser[A] {
+private final class HomParser[A](a: Parser[A], b: Parser[A]) extends ValidParser[A]:
   lazy val result = tuple(a.result, b.result) map (_._1)
   def derive(c: Char) = a.derive(c) | b.derive(c)
   lazy val resultEmpty = a.resultEmpty or b.resultEmpty
   def completions(level: Int) = a.completions(level) ++ b.completions(level)
   override def toString = "(" + a + " | " + b + ")"
-}
 
-private final class HetParser[A, B](a: Parser[A], b: Parser[B]) extends ValidParser[Either[A, B]] {
+private final class HetParser[A, B](a: Parser[A], b: Parser[B]) extends ValidParser[Either[A, B]]:
   lazy val result = tuple(a.result, b.result) map { case (a, _) => Left(a) }
   def derive(c: Char) = a.derive(c) || b.derive(c)
   lazy val resultEmpty = a.resultEmpty.either(b.resultEmpty)
   def completions(level: Int) = a.completions(level) ++ b.completions(level)
   override def toString = "(" + a + " || " + b + ")"
-}
 
 private final class ParserSeq[T](a: Seq[Parser[T]], errors: => Seq[String])
-    extends ValidParser[Seq[T]] {
+    extends ValidParser[Seq[T]]:
   assert(a.nonEmpty)
 
-  lazy val resultEmpty: Result[Seq[T]] = {
+  lazy val resultEmpty: Result[Seq[T]] =
     val res = a.map(_.resultEmpty)
     val (failures, values) = separate(res)(_.toEither)
     //    if(failures.isEmpty) Value(values) else mkFailures(failures.flatMap(_()) ++ errors)
-    if (values.nonEmpty) Value(values) else mkFailures(failures.flatMap(_()) ++ errors)
-  }
+    if values.nonEmpty then Value(values) else mkFailures(failures.flatMap(_()) ++ errors)
 
-  def result = {
+  def result =
     val success = a.flatMap(_.result)
-    if (success.length == a.length) Some(success) else None
-  }
+    if success.length == a.length then Some(success) else None
 
   def completions(level: Int) = a.map(_.completions(level)).reduceLeft(_ ++ _)
   def derive(c: Char) = seq0(a.map(_.derive(c)), errors)
 
   override def toString = "seq(" + a + ")"
-}
 
-private final class BindParser[A, B](a: Parser[A], f: A => Parser[B]) extends ValidParser[B] {
+private final class BindParser[A, B](a: Parser[A], f: A => Parser[B]) extends ValidParser[B]:
   lazy val result = a.result flatMap (av => f(av).result)
   lazy val resultEmpty = a.resultEmpty.flatMap(av => f(av).resultEmpty)
 
   def completions(level: Int) =
     a.completions(level) flatMap { c =>
-      apply(a)(c.append).resultEmpty match {
+      apply(a)(c.append).resultEmpty match
         case _: Failure => Completions.strict(Set.empty + c)
         case Value(av)  => c.x(f(av).completions(level))
-      }
     }
 
-  def derive(c: Char) = {
+  def derive(c: Char) =
     val common = a.derive(c).flatMap(f)
-    a.resultEmpty match {
+    a.resultEmpty match
       case Value(av)  => common | derive1(f(av), c)
       case _: Failure => common
-    }
-  }
 
   override def isTokenStart = a.isTokenStart
 
   override def toString = "bind(" + a + ")"
-}
 
-private final class MapParser[A, B](a: Parser[A], f: A => B) extends ValidParser[B] {
+private final class MapParser[A, B](a: Parser[A], f: A => B) extends ValidParser[B]:
   lazy val result = a.result map f
   lazy val resultEmpty = a.resultEmpty.map(f)
   def derive(c: Char) = a.derive(c).map(f)
@@ -824,10 +770,9 @@ private final class MapParser[A, B](a: Parser[A], f: A => B) extends ValidParser
   override def isTokenStart = a.isTokenStart
   override def toString = "map(" + a + ")"
   def map[C](g: B => C) = new MapParser[A, C](a, f.andThen(g))
-}
 
 private final class Filter[T](p: Parser[T], f: T => Boolean, seen: String, msg: String => String)
-    extends ValidParser[T] {
+    extends ValidParser[T]:
   def filterResult(r: Result[T]) = r.filter(f, msg(seen))
   lazy val result = p.result filter f
   lazy val resultEmpty = filterResult(p.resultEmpty)
@@ -839,59 +784,52 @@ private final class Filter[T](p: Parser[T], f: T => Boolean, seen: String, msg:
 
   override def toString = "filter(" + p + ")"
   override def isTokenStart = p.isTokenStart
-}
 
 private final class MatchedString(delegate: Parser[?], seenV: Vector[Char], partial: Boolean)
-    extends ValidParser[String] {
+    extends ValidParser[String]:
   lazy val seen = seenV.mkString
   def derive(c: Char) = matched(delegate.derive(c), seenV :+ c, partial)
   def completions(level: Int) = delegate.completions(level)
-  def result = if (delegate.result.isDefined) Some(seen) else None
+  def result = if delegate.result.isDefined then Some(seen) else None
 
-  def resultEmpty = delegate.resultEmpty match {
-    case f: Failure if !partial => f; case _ => Value(seen)
-  }
+  def resultEmpty = delegate.resultEmpty match
+    case f: Failure if !partial => f;
+    case _                      => Value(seen)
 
   override def isTokenStart = delegate.isTokenStart
   override def toString = "matched(" + partial + ", " + seen + ", " + delegate + ")"
-}
 
 private final class TokenStart[T](delegate: Parser[T], seen: String, complete: TokenCompletions)
-    extends ValidParser[T] {
+    extends ValidParser[T]:
   def derive(c: Char) = mkToken(delegate.derive(c), seen + c, complete)
 
-  def completions(level: Int) = complete match {
+  def completions(level: Int) = complete match
     case dc: TokenCompletions.Delegating =>
       dc.completions(seen, level, delegate.completions(level))
     case fc: TokenCompletions.Fixed => fc.completions(seen, level)
-  }
 
   def result = delegate.result
   def resultEmpty = delegate.resultEmpty
   override def isTokenStart = true
   override def toString = "token('" + complete + ", " + delegate + ")"
-}
 
-private final class And[T](a: Parser[T], b: Parser[?]) extends ValidParser[T] {
+private final class And[T](a: Parser[T], b: Parser[?]) extends ValidParser[T]:
   lazy val result = tuple(a.result, b.result) map { _._1 }
   def derive(c: Char) = a.derive(c) & b.derive(c)
   def completions(level: Int) = a.completions(level).filterS(s => apply(b)(s).resultEmpty.isValid)
   lazy val resultEmpty = a.resultEmpty && b.resultEmpty
   override def toString = s"(${a}) && (${b})"
-}
 
-private final class Not(delegate: Parser[?], failMessage: String) extends ValidParser[Unit] {
-  def derive(c: Char) = if (delegate.valid) not(delegate.derive(c), failMessage) else this
+private final class Not(delegate: Parser[?], failMessage: String) extends ValidParser[Unit]:
+  def derive(c: Char) = if delegate.valid then not(delegate.derive(c), failMessage) else this
   def completions(level: Int) = Completions.empty
   def result = None
 
-  lazy val resultEmpty = delegate.resultEmpty match {
+  lazy val resultEmpty = delegate.resultEmpty match
     case _: Failure  => Value(())
     case _: Value[?] => mkFailure(failMessage)
-  }
 
   override def toString = s" -(${delegate})"
-}
 
 /**
  * This class wraps an existing parser (the delegate), and replaces the delegate's completions with
@@ -919,7 +857,7 @@ private final class ParserWithExamples[T](
     exampleSource: ExampleSource,
     maxNumberOfExamples: Int,
     removeInvalidExamples: Boolean
-) extends ValidParser[T] {
+) extends ValidParser[T]:
 
   def derive(c: Char) =
     examples(
@@ -933,29 +871,24 @@ private final class ParserWithExamples[T](
 
   lazy val resultEmpty = delegate.resultEmpty
 
-  def completions(level: Int) = {
-    if (exampleSource().isEmpty) if (resultEmpty.isValid) Completions.nil else Completions.empty
-    else {
+  def completions(level: Int) =
+    if exampleSource().isEmpty then
+      if resultEmpty.isValid then Completions.nil else Completions.empty
+    else
       val examplesBasedOnTheResult = filteredExamples.take(maxNumberOfExamples).toSet
       Completions(examplesBasedOnTheResult.map(ex => Completion.suggestion(ex)))
-    }
-  }
 
   override def toString = "examples(" + delegate + ", " + exampleSource().take(2).toList + ")"
 
-  private def filteredExamples: Iterable[String] = {
-    if (removeInvalidExamples)
-      exampleSource().filter(isExampleValid)
-    else
-      exampleSource()
-  }
+  private def filteredExamples: Iterable[String] =
+    if removeInvalidExamples then exampleSource().filter(isExampleValid)
+    else exampleSource()
 
-  private def isExampleValid(example: String): Boolean = {
+  private def isExampleValid(example: String): Boolean =
     apply(delegate)(example).resultEmpty.isValid
-  }
-}
+end ParserWithExamples
 
-private final class StringLiteral(str: String, start: Int) extends ValidParser[String] {
+private final class StringLiteral(str: String, start: Int) extends ValidParser[String]:
   assert(0 <= start && start < str.length)
 
   def failMsg = "Expected '" + str + "'"
@@ -964,28 +897,25 @@ private final class StringLiteral(str: String, start: Int) extends ValidParser[S
   def result = None
 
   def derive(c: Char) =
-    if (str.charAt(start) == c) stringLiteral(str, start + 1) else new Invalid(fail)
+    if str.charAt(start) == c then stringLiteral(str, start + 1) else new Invalid(fail)
 
   def completions(level: Int) = Completions.single(Completion.suggestion(str.substring(start)))
   override def toString = "\"" + str + "\""
-}
 
-private final class CharacterClass(f: Char => Boolean, label: String) extends ValidParser[Char] {
+private final class CharacterClass(f: Char => Boolean, label: String) extends ValidParser[Char]:
   def result = None
   private def fail: Failure = mkFailure("Expected " + label)
   def resultEmpty = fail
-  def derive(c: Char) = if (f(c)) success(c) else Invalid(fail)
+  def derive(c: Char) = if f(c) then success(c) else Invalid(fail)
   def completions(level: Int) = Completions.empty
   override def toString = "class(" + label + ")"
-}
 
-private final class Optional[A](delegate: Parser[A]) extends ValidParser[Option[A]] {
+private final class Optional[A](delegate: Parser[A]) extends ValidParser[Option[A]]:
   def result = delegate.result.map(some[A])
   def resultEmpty = Value(None)
   def derive(c: Char) = delegate.derive(c).map(some[A])
   def completions(level: Int) = Completion.empty +: delegate.completions(level)
   override def toString = delegate.toString + "?"
-}
 
 private final class Repeat[T](
     partial: Option[Parser[T]],
@@ -993,56 +923,48 @@ private final class Repeat[T](
     min: Int,
     max: UpperBound,
     accumulatedReverse: List[T]
-) extends ValidParser[Seq[T]] {
+) extends ValidParser[Seq[T]]:
   assume(0 <= min, "Minimum occurrences must be non-negative")
   assume(max >= min, "Minimum occurrences must be less than the maximum occurrences")
 
   def derive(c: Char) =
-    partial match {
+    partial match
       case Some(part) =>
         val partD = repeat(Some(part.derive(c)), repeated, min, max, accumulatedReverse)
-        part.resultEmpty match {
+        part.resultEmpty match
           case Value(pv)  => partD | repeatDerive(c, pv :: accumulatedReverse)
           case _: Failure => partD
-        }
       case None => repeatDerive(c, accumulatedReverse)
-    }
 
   def repeatDerive(c: Char, accRev: List[T]): Parser[Seq[T]] =
     repeat(Some(repeated.derive(c)), repeated, scala.math.max(0, min - 1), max.decrement, accRev)
 
-  def completions(level: Int) = {
+  def completions(level: Int) =
     @tailrec
     def pow(comp: Completions, exp: Completions, n: Int): Completions =
-      if (n == 1) comp else pow(comp.x(exp), exp, n - 1)
+      if n == 1 then comp else pow(comp.x(exp), exp, n - 1)
 
     val repC = repeated.completions(level)
-    val fin = if (min == 0) Completion.empty +: repC else pow(repC, repC, min)
-    partial match {
+    val fin = if min == 0 then Completion.empty +: repC else pow(repC, repC, min)
+    partial match
       case Some(p) => p.completions(level).x(fin)
       case None    => fin
-    }
-  }
 
   def result = None
 
-  lazy val resultEmpty: Result[Seq[T]] = {
+  lazy val resultEmpty: Result[Seq[T]] =
     val partialAccumulatedOption =
-      partial match {
+      partial match
         case None                 => (Value(accumulatedReverse): Result[List[T]])
         case Some(partialPattern) =>
           partialPattern.resultEmpty.map(_ :: accumulatedReverse)
-      }
     (partialAccumulatedOption.app(repeatedParseEmpty))((x, y) => (x reverse_::: y): Seq[T])
-  }
 
-  private def repeatedParseEmpty: Result[List[T]] = {
-    if (min == 0)
-      Value(Nil)
+  private def repeatedParseEmpty: Result[List[T]] =
+    if min == 0 then Value(Nil)
     else
       // forced determinism
-      for (value <- repeated.resultEmpty) yield makeList(min, value)
-  }
+      for value <- repeated.resultEmpty yield makeList(min, value)
 
   override def toString = "repeat(" + min + "," + max + "," + partial + "," + repeated + ")"
-}
+end Repeat
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parsers.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parsers.scala
index 4efcc6e26..4c24f8ad0 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parsers.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parsers.scala
@@ -26,7 +26,7 @@ import scala.annotation.tailrec
 import sbt.internal.util.Util.nilSeq
 
 /** Provides standard implementations of commonly useful [[Parser]]s. */
-trait Parsers {
+trait Parsers:
 
   /** Matches the end of input, providing no useful result on success. */
   lazy val EOF = not(any, "Expected EOF")
@@ -116,22 +116,18 @@ trait Parsers {
     start ~ rep.* map { case x ~ xs => (x +: xs).mkString }
 
   def opOrIDSpaced(s: String): Parser[Char] =
-    if (DefaultParsers.matches(ID, s))
-      OpChar | SpaceClass
-    else if (DefaultParsers.matches(Op, s))
-      IDChar | SpaceClass
-    else
-      any
+    if DefaultParsers.matches(ID, s) then OpChar | SpaceClass
+    else if DefaultParsers.matches(Op, s) then IDChar | SpaceClass
+    else any
 
   /** Returns true if `c` an operator character. */
   def isOpChar(c: Char) = !isDelimiter(c) && isOpType(getType(c))
 
-  def isOpType(cat: Int) = cat match {
+  def isOpType(cat: Int) = cat match
     case MATH_SYMBOL | OTHER_SYMBOL | DASH_PUNCTUATION | OTHER_PUNCTUATION | MODIFIER_SYMBOL |
         CURRENCY_SYMBOL =>
       true
     case _ => false
-  }
 
   /** Returns true if `c` is a dash `-`, a letter, digit, or an underscore `_`. */
   def isIDChar(c: Char) = isScalaIDChar(c) || c == '-'
@@ -139,9 +135,9 @@ trait Parsers {
   /** Returns true if `c` is a letter, digit, or an underscore `_`. */
   def isScalaIDChar(c: Char) = c.isLetterOrDigit || c == '_'
 
-  def isDelimiter(c: Char) = c match {
-    case '`' | '\'' | '\"' | /*';' | */ ',' | '.' => true; case _ => false
-  }
+  def isDelimiter(c: Char) = c match
+    case '`' | '\'' | '\"' | /*';' | */ ',' | '.' => true;
+    case _                                        => false
 
   /** Matches a single character that is not a whitespace character. */
   lazy val NotSpaceClass = charClass(!_.isWhitespace, "non-whitespace character")
@@ -187,14 +183,14 @@ trait Parsers {
   /** Matches any character except a double quote or whitespace. */
   lazy val NotDQuoteSpaceClass =
     charClass(
-      (c: Char) => { (c != DQuoteChar) && !c.isWhitespace },
+      (c: Char) => (c != DQuoteChar) && !c.isWhitespace,
       "non-double-quote-space character"
     )
 
   /** Matches any character except a double quote or backslash. */
   lazy val NotDQuoteBackslashClass =
     charClass(
-      (c: Char) => { (c != DQuoteChar) && (c != BackslashChar) },
+      (c: Char) => (c != DQuoteChar) && (c != BackslashChar),
       "non-double-quote-backslash character"
     )
 
@@ -281,9 +277,9 @@ trait Parsers {
    * @return
    *   a parser for the brace enclosed string.
    */
-  private[sbt] def braces(open: Char, close: Char): Parser[String] = {
+  private[sbt] def braces(open: Char, close: Char): Parser[String] =
     val notDelim = charClass(c => c != open && c != close).*.string
-    def impl(): Parser[String] = {
+    def impl(): Parser[String] =
       (open ~ (notDelim ~ close).?).flatMap {
         case (l, Some((content, r))) => Parser.success(s"$l$content$r")
         case (l, None)               =>
@@ -293,9 +289,7 @@ trait Parsers {
             s"$l${nested.mkString}$suffix$r"
           }
       }
-    }
     impl()
-  }
 
   /**
    * Parses a single escape sequence into the represented Char. Escapes start with a backslash and
@@ -351,9 +345,8 @@ trait Parsers {
    */
   def mapOrFail[S, T](p: Parser[S])(f: S => T): Parser[T] =
     p flatMap { s =>
-      try {
-        success(f(s))
-      } catch { case e: Exception => failure(e.toString) }
+      try success(f(s))
+      catch case e: Exception => failure(e.toString)
     }
 
   /**
@@ -376,17 +369,15 @@ trait Parsers {
    * discarded and only the sequence of values from the parsers returned by `p` is used for the
    * result.
    */
-  def repeatDep[A](p: Seq[A] => Parser[A], sep: Parser[Any]): Parser[Seq[A]] = {
-    def loop(acc: Seq[A]): Parser[Seq[A]] = {
+  def repeatDep[A](p: Seq[A] => Parser[A], sep: Parser[Any]): Parser[Seq[A]] =
+    def loop(acc: Seq[A]): Parser[Seq[A]] =
       val next = (sep ~> p(acc)) flatMap { result =>
         loop(acc :+ result)
       }
       next ?? acc
-    }
     p(Vector()) flatMap { first =>
       loop(Seq(first))
     }
-  }
 
   /** Applies String.trim to the result of `p`. */
   def trimmed(p: Parser[String]) = p map { _.trim }
@@ -399,29 +390,24 @@ trait Parsers {
    * `ex` as tab completion examples.
    */
   def Uri(ex: Set[URI]) = basicUri.examples(ex.map(_.toString))
-}
+end Parsers
 
 /** Provides standard [[Parser]] implementations. */
 object Parsers extends Parsers
 
 /** Provides common [[Parser]] implementations and helper methods. */
-object DefaultParsers extends Parsers with ParserMain {
+object DefaultParsers extends Parsers with ParserMain:
 
   /** Applies parser `p` to input `s` and returns `true` if the parse was successful. */
   def matches(p: Parser[?], s: String): Boolean =
     apply(p)(s).resultEmpty.isValid
 
   /** Returns `true` if `s` parses successfully according to [[ID]]. */
-  def validID(s: String): Boolean = {
+  def validID(s: String): Boolean =
     // Handwritten version of `matches(ID, s)` because validID turned up in profiling.
     def isIdChar(c: Char): Boolean = Character.isLetterOrDigit(c) || (c == '-') || (c == '_')
     @tailrec def isRestIdChar(cur: Int, s: String, length: Int): Boolean =
-      if (cur < length)
-        isIdChar(s.charAt(cur)) && isRestIdChar(cur + 1, s, length)
-      else
-        true
+      if cur < length then isIdChar(s.charAt(cur)) && isRestIdChar(cur + 1, s, length)
+      else true
 
     !s.isEmpty && Character.isLetter(s.charAt(0)) && isRestIdChar(1, s, s.length)
-  }
-
-}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/ProcessError.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/ProcessError.scala
index f15a70f06..28045261a 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/ProcessError.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/ProcessError.scala
@@ -11,32 +11,26 @@ package complete
 
 import scala.annotation.tailrec
 
-object ProcessError {
-  def apply(command: String, msgs: Seq[String], index: Int): String = {
+object ProcessError:
+  def apply(command: String, msgs: Seq[String], index: Int): String =
     val (line, modIndex) = extractLine(command, index)
     val point = pointerSpace(command, modIndex)
     msgs.mkString("\n") + "\n" + line + "\n" + point + "^"
-  }
 
-  def extractLine(s: String, i: Int): (String, Int) = {
+  def extractLine(s: String, i: Int): (String, Int) =
     val notNewline = (c: Char) => c != '\n' && c != '\r'
     val left = takeRightWhile(s.substring(0, i))(notNewline)
     val right = s.substring(i).takeWhile(notNewline)
     (left + right, left.length)
-  }
 
-  def takeRightWhile(s: String)(pred: Char => Boolean): String = {
+  def takeRightWhile(s: String)(pred: Char => Boolean): String =
     @tailrec
     def loop(i: Int): String =
-      if (i < 0)
-        s
-      else if (pred(s(i)))
-        loop(i - 1)
-      else
-        s.substring(i + 1)
+      if i < 0 then s
+      else if pred(s(i)) then loop(i - 1)
+      else s.substring(i + 1)
     loop(s.length - 1)
-  }
 
   def pointerSpace(s: String, i: Int): String =
     (s take i) map { case '\t' => '\t'; case _ => ' ' } mkString ""
-}
+end ProcessError
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/SizeParser.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/SizeParser.scala
index 5f066b5ed..bf201a619 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/SizeParser.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/SizeParser.scala
@@ -10,21 +10,18 @@ package sbt.internal.util.complete
 
 import sbt.internal.util.complete.DefaultParsers.*
 
-private[sbt] object SizeParser {
+private[sbt] object SizeParser:
   def apply(s: String): Option[Long] = Parser.parse(s, value).toOption
-  private enum SizeUnit {
+  private enum SizeUnit:
     case Bytes, KiloBytes, MegaBytes, GigaBytes
-  }
   private def parseDouble(s: String): Parser[Either[Double, Long]] =
-    s.toDoubleOption match {
+    s.toDoubleOption match
       case Some(x) => Parser.success(Left(x))
       case _       => Parser.failure(s"Couldn't parse $s as double.")
-    }
   private def parseLong(s: String): Parser[Either[Double, Long]] =
-    s.toLongOption match {
+    s.toLongOption match
       case Some(x) => Parser.success(Right(x))
       case _       => Parser.failure(s"Couldn't parse $s as double.")
-    }
   private val digit = charClass(_.isDigit, "digit")
   private val numberParser: Parser[Either[Double, Long]] =
     (digit.+ ~ ('.'.examples() ~> digit.+).?).flatMap {
@@ -39,20 +36,18 @@ private[sbt] object SizeParser {
       case "k" | "K" => SizeUnit.KiloBytes
       case "m" | "M" => SizeUnit.MegaBytes
     }
-  private def multiply(left: Either[Double, Long], right: Long): Long = left match {
+  private def multiply(left: Either[Double, Long], right: Long): Long = left match
     case Left(d)  => (d * right).toLong
     case Right(l) => l * right
-  }
   private[sbt] val value: Parser[Long] =
     ((numberParser <~ SpaceClass
       .examples(" ", "b", "B", "g", "G", "k", "K", "m", "M")
       .*) ~ unitParser.?)
       .map { (number, unit) =>
-        unit match {
+        unit match
           case None | Some(SizeUnit.Bytes) => multiply(number, right = 1L)
           case Some(SizeUnit.KiloBytes)    => multiply(number, right = 1024L)
           case Some(SizeUnit.MegaBytes)    => multiply(number, right = 1024L * 1024)
           case Some(SizeUnit.GigaBytes)    => multiply(number, right = 1024L * 1024 * 1024)
-        }
       }
-}
+end SizeParser
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/TokenCompletions.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/TokenCompletions.scala
index 9c76ae411..96f80e442 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/TokenCompletions.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/TokenCompletions.scala
@@ -11,43 +11,37 @@ package complete
 
 import Completion.{ token as ctoken, tokenDisplay }
 
-sealed trait TokenCompletions {
+sealed trait TokenCompletions:
   def hideWhen(f: Int => Boolean): TokenCompletions
-}
 
-object TokenCompletions {
-  private[sbt] abstract class Delegating extends TokenCompletions { outer =>
+object TokenCompletions:
+  private[sbt] abstract class Delegating extends TokenCompletions:
+    outer =>
     def completions(seen: String, level: Int, delegate: Completions): Completions
-    final def hideWhen(hide: Int => Boolean): TokenCompletions = new Delegating {
+    final def hideWhen(hide: Int => Boolean): TokenCompletions = new Delegating:
       def completions(seen: String, level: Int, delegate: Completions): Completions =
-        if (hide(level)) Completions.nil else outer.completions(seen, level, delegate)
-    }
-  }
+        if hide(level) then Completions.nil else outer.completions(seen, level, delegate)
 
-  private[sbt] abstract class Fixed extends TokenCompletions { outer =>
+  private[sbt] abstract class Fixed extends TokenCompletions:
+    outer =>
     def completions(seen: String, level: Int): Completions
-    final def hideWhen(hide: Int => Boolean): TokenCompletions = new Fixed {
+    final def hideWhen(hide: Int => Boolean): TokenCompletions = new Fixed:
       def completions(seen: String, level: Int) =
-        if (hide(level)) Completions.nil else outer.completions(seen, level)
-    }
-  }
+        if hide(level) then Completions.nil else outer.completions(seen, level)
 
   val default: TokenCompletions = mapDelegateCompletions((seen, level, c) => ctoken(seen, c.append))
 
-  def displayOnly(msg: String): TokenCompletions = new Fixed {
+  def displayOnly(msg: String): TokenCompletions = new Fixed:
     def completions(seen: String, level: Int) = Completions.single(Completion.displayOnly(msg))
-  }
 
   def overrideDisplay(msg: String): TokenCompletions =
     mapDelegateCompletions((seen, level, c) => tokenDisplay(display = msg, append = c.append))
 
-  def fixed(f: (String, Int) => Completions): TokenCompletions = new Fixed {
+  def fixed(f: (String, Int) => Completions): TokenCompletions = new Fixed:
     def completions(seen: String, level: Int) = f(seen, level)
-  }
 
   def mapDelegateCompletions(f: (String, Int, Completion) => Completion): TokenCompletions =
-    new Delegating {
+    new Delegating:
       def completions(seen: String, level: Int, delegate: Completions) =
         Completions(delegate.get.map(c => f(seen, level, c)))
-    }
-}
+end TokenCompletions
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/TypeString.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/TypeString.scala
index fa5a961ee..5da1098c8 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/TypeString.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/TypeString.scala
@@ -17,24 +17,20 @@ import TypeString.*
  * structure of parameterized types. All other types are represented by a TypeString with an empty
  * `args`.
  */
-private[sbt] final class TypeString(val base: String, val args: List[TypeString]) {
+private[sbt] final class TypeString(val base: String, val args: List[TypeString]):
   override def toString =
-    if (base.startsWith(FunctionName))
+    if base.startsWith(FunctionName) then
       args.dropRight(1).mkString("(", ",", ")") + " => " + args.last
-    else if (base.startsWith(TupleName))
-      args.mkString("(", ",", ")")
-    else
-      cleanupTypeName(base) + (if (args.isEmpty) "" else args.mkString("[", ",", "]"))
-}
+    else if base.startsWith(TupleName) then args.mkString("(", ",", ")")
+    else cleanupTypeName(base) + (if args.isEmpty then "" else args.mkString("[", ",", "]"))
 
-private[sbt] object TypeString {
+private[sbt] object TypeString:
 
   /** Makes the string representation of a type as returned by Manifest.toString more readable. */
   def cleanup(typeString: String): String =
-    parse(typeString, typeStringParser) match {
+    parse(typeString, typeStringParser) match
       case Right(ts) => ts.toString
       case Left(_)   => typeString
-    }
 
   /**
    * Makes a fully qualified type name provided by Manifest.toString more readable. The argument
@@ -49,16 +45,13 @@ private[sbt] object TypeString {
    * conservative approximation.
    */
   def dropPrefix(base: String): String =
-    if (base.startsWith(SbtPrefix)) base.substring(SbtPrefix.length)
-    else if (base.startsWith(CollectionPrefix)) {
+    if base.startsWith(SbtPrefix) then base.substring(SbtPrefix.length)
+    else if base.startsWith(CollectionPrefix) then
       val simple = base.substring(CollectionPrefix.length)
-      if (ShortenCollection(simple)) simple else base
-    } else if (base.startsWith(ScalaPrefix))
-      base.substring(ScalaPrefix.length)
-    else if (base.startsWith(JavaPrefix))
-      base.substring(JavaPrefix.length)
-    else
-      TypeMap.getOrElse(base, base)
+      if ShortenCollection(simple) then simple else base
+    else if base.startsWith(ScalaPrefix) then base.substring(ScalaPrefix.length)
+    else if base.startsWith(JavaPrefix) then base.substring(JavaPrefix.length)
+    else TypeMap.getOrElse(base, base)
 
   final val CollectionPrefix = "scala.collection."
   final val FunctionName = "scala.Function"
@@ -80,13 +73,12 @@ private[sbt] object TypeString {
    * Manifest.toString. This is rudimentary and essentially only decomposes the string into names
    * and arguments for parameterized types.
    */
-  lazy val typeStringParser: Parser[TypeString] = {
+  lazy val typeStringParser: Parser[TypeString] =
     def isFullScalaIDChar(c: Char) = isScalaIDChar(c) || c == '.' || c == '$'
     lazy val fullScalaID =
       identifier(IDStart, charClass(isFullScalaIDChar, "Scala identifier character"))
     lazy val tpe: Parser[TypeString] =
-      for (id <- fullScalaID; args <- ('[' ~> rep1sep(tpe, ',') <~ ']').?)
-        yield new TypeString(id, args.toList.flatten)
+      for id <- fullScalaID; args <- ('[' ~> rep1sep(tpe, ',') <~ ']').?
+      yield new TypeString(id, args.toList.flatten)
     tpe
-  }
-}
+end TypeString
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/UpperBound.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/UpperBound.scala
index abf7ed8d4..9086c7951 100644
--- a/internal/util-complete/src/main/scala/sbt/internal/util/complete/UpperBound.scala
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/UpperBound.scala
@@ -9,7 +9,7 @@
 package sbt.internal.util
 package complete
 
-sealed trait UpperBound {
+sealed trait UpperBound:
 
   /** True if and only if the given value meets this bound. */
   def >=(min: Int): Boolean
@@ -30,10 +30,8 @@ sealed trait UpperBound {
   /** True if and only if this is unbounded. */
   def isInfinite: Boolean
 
-}
-
 /** Represents unbounded. */
-case object Infinite extends UpperBound {
+case object Infinite extends UpperBound:
 
   /** All finite numbers meet this bound. */
   def >=(min: Int) = true
@@ -44,13 +42,12 @@ case object Infinite extends UpperBound {
   def isInfinite = true
 
   override def toString = "Infinity"
-}
 
 /**
  * Represents a finite upper bound. The maximum allowed value is 'value', inclusive. It must
  * positive.
  */
-final case class Finite(value: Int) extends UpperBound {
+final case class Finite(value: Int) extends UpperBound:
   assume(value >= 0, "Maximum occurrences must be nonnegative.")
 
   def >=(min: Int) = value >= min
@@ -59,8 +56,6 @@ final case class Finite(value: Int) extends UpperBound {
   def decrement = Finite(scala.math.max(0, value - 1))
   def isInfinite = false
   override def toString = value.toString
-}
 
-object UpperBound {
+object UpperBound:
   implicit def intToFinite(i: Int): Finite = Finite(i)
-}
diff --git a/internal/util-complete/src/test/scala/DefaultParsersSpec.scala b/internal/util-complete/src/test/scala/DefaultParsersSpec.scala
index 47cc6eba8..a190c0bba 100644
--- a/internal/util-complete/src/test/scala/DefaultParsersSpec.scala
+++ b/internal/util-complete/src/test/scala/DefaultParsersSpec.scala
@@ -11,7 +11,7 @@ package complete
 
 import org.scalacheck.*, Gen.*, Prop.*
 
-object DefaultParsersSpec extends Properties("DefaultParsers") {
+object DefaultParsersSpec extends Properties("DefaultParsers"):
   import DefaultParsers.{ ID, isIDChar, matches, validID }
 
   property("∀ s ∈ String: validID(s) == matches(ID, s)") =
@@ -22,8 +22,7 @@ object DefaultParsersSpec extends Properties("DefaultParsers") {
 
   private val chars: Seq[Char] = Char.MinValue to Char.MaxValue
   private val genID: Gen[String] =
-    for {
+    for
       c <- oneOf(chars filter (_.isLetter))
       cs <- listOf(oneOf(chars filter isIDChar))
-    } yield (c :: cs).mkString
-}
+    yield (c :: cs).mkString
diff --git a/internal/util-complete/src/test/scala/ParserTest.scala b/internal/util-complete/src/test/scala/ParserTest.scala
index 811dc3035..14f8c9f1a 100644
--- a/internal/util-complete/src/test/scala/ParserTest.scala
+++ b/internal/util-complete/src/test/scala/ParserTest.scala
@@ -11,7 +11,7 @@ package complete
 
 import scala.annotation.tailrec
 
-object JLineTest {
+object JLineTest:
   import DefaultParsers.*
 
   val one = "blue" | "green" | "black"
@@ -27,7 +27,7 @@ object JLineTest {
   }
 
   val parsers = Map("1" -> one, "2" -> two, "3" -> three, "4" -> four, "5" -> five)
-  def main(args: Array[String]): Unit = {
+  def main(args: Array[String]): Unit =
     import jline.TerminalFactory
     import jline.console.ConsoleReader
     val reader = new ConsoleReader()
@@ -36,21 +36,18 @@ object JLineTest {
     val parser = parsers(args(0))
     JLineCompletion.installCustomCompletor(reader, parser)
     @tailrec
-    def loop(): Unit = {
+    def loop(): Unit =
       val line = reader.readLine("> ")
-      if (line ne null) {
+      if line ne null then
         println("Result: " + apply(parser)(line).resultEmpty)
         loop()
-      }
-    }
     loop()
-  }
-}
+end JLineTest
 
 import Parser.*
 import org.scalacheck.*
 
-object ParserTest extends Properties("Completing Parser") {
+object ParserTest extends Properties("Completing Parser"):
   import Parsers.*
   import DefaultParsers.matches
 
@@ -59,7 +56,8 @@ object ParserTest extends Properties("Completing Parser") {
 
   val spacePort = token(Space) ~> Port
 
-  def p[T](f: T): T = { println(f); f }
+  def p[T](f: T): T =
+    println(f); f
 
   def checkSingle(in: String, expect: Completion)(expectDisplay: Completion = expect) =
     (("token '" + in + "'") |: checkOne(in, nested, expect)) &&
@@ -68,19 +66,17 @@ object ParserTest extends Properties("Completing Parser") {
   def checkOne(in: String, parser: Parser[?], expect: Completion): Prop =
     completions(parser, in, 1) == Completions.single(expect)
 
-  def checkAll(in: String, parser: Parser[?], expect: Completions): Prop = {
+  def checkAll(in: String, parser: Parser[?], expect: Completions): Prop =
     val cs = completions(parser, in, 1)
     ("completions: " + cs) |: ("Expected: " + expect) |: (cs == expect: Prop)
-  }
 
   def checkInvalid(in: String) =
     (("token '" + in + "'") |: checkInv(in, nested)) &&
       (("display '" + in + "'") |: checkInv(in, nestedDisplay))
 
-  def checkInv(in: String, parser: Parser[?]): Prop = {
+  def checkInv(in: String, parser: Parser[?]): Prop =
     val cs = completions(parser, in, 1)
     ("completions: " + cs) |: (cs == Completions.nil: Prop)
-  }
 
   property("nested tokens a") =
     checkSingle("", Completion.token("", "a1"))(Completion.displayOnly("<a1>"))
@@ -113,21 +109,19 @@ object ParserTest extends Properties("Completing Parser") {
 
   property("repeatDep no suggestions for bad input") = checkInv(".", repeat)
   property("repeatDep suggest all") = checkAll("", repeat, completionStrings(colors))
-  property("repeatDep suggest remaining two") = {
+  property("repeatDep suggest remaining two") =
     val first = colors.toSeq.head
     checkAll(first + " ", repeat, completionStrings(colors - first))
-  }
-  property("repeatDep suggest remaining one") = {
+  property("repeatDep suggest remaining one") =
     val take = colors.toSeq.take(2)
     checkAll(take.mkString("", " ", " "), repeat, completionStrings(colors -- take))
-  }
   property("repeatDep requires at least one token") = !matches(repeat, "")
   property("repeatDep accepts one token") = matches(repeat, colors.toSeq.head)
   property("repeatDep accepts two tokens") = matches(repeat, colors.toSeq.take(2).mkString(" "))
   property("parses string that doesn't start with quotes, but includes quotes within it") =
     matches(StringBasic, "-Dsilicon:z3ConfigArgs=\"model=true model_validate=true\"")
-}
-object ParserExample {
+end ParserTest
+object ParserExample:
   val ws = charClass(_.isWhitespace, "whitespace").+
   val notws = charClass(!_.isWhitespace, "not whitespace").+
 
@@ -151,7 +145,7 @@ object ParserExample {
   println(apply(t)("test w").resultEmpty)
   println(apply(t)("test was were").resultEmpty)
 
-  def run(n: Int): Unit = {
+  def run(n: Int): Unit =
     val a = 'a'.id
     val aq = a.?
     val aqn = repeat(aq, min = n, max = n)
@@ -160,10 +154,8 @@ object ParserExample {
 
     def r = apply(ann)("a" * (n * 2)).resultEmpty
     println(r.isValid)
-  }
-  def run2(n: Int): Unit = {
+  def run2(n: Int): Unit =
     val ab = "ab".?.*
     val r = apply(ab)("a" * n).resultEmpty
     println(r)
-  }
-}
+end ParserExample
diff --git a/internal/util-complete/src/test/scala/sbt/complete/FileExamplesTest.scala b/internal/util-complete/src/test/scala/sbt/complete/FileExamplesTest.scala
index 6fe4bb625..23208a7d8 100644
--- a/internal/util-complete/src/test/scala/sbt/complete/FileExamplesTest.scala
+++ b/internal/util-complete/src/test/scala/sbt/complete/FileExamplesTest.scala
@@ -13,7 +13,7 @@ import java.io.File
 import org.scalatest.Assertion
 import sbt.io.IO
 
-class FileExamplesTest extends UnitSpec {
+class FileExamplesTest extends UnitSpec:
 
   "listing all files in an absolute base directory" should
     "produce the entire base directory's contents" in {
@@ -60,16 +60,15 @@ class FileExamplesTest extends UnitSpec {
 
   def withDirectoryStructure(withCompletionPrefix: String = "")(
       thunk: DirectoryStructure => Assertion
-  ): Assertion = {
+  ): Assertion =
     IO.withTemporaryDirectory { tempDir =>
       val ds = new DirectoryStructure(withCompletionPrefix)
       ds.createSampleDirStructure(tempDir)
       ds.fileExamples = new FileExamples(ds.baseDir, withCompletionPrefix)
       thunk(ds)
     }
-  }
 
-  final class DirectoryStructure(withCompletionPrefix: String) {
+  final class DirectoryStructure(withCompletionPrefix: String):
     var fileExamples: FileExamples = scala.compiletime.uninitialized
     var baseDir: File = scala.compiletime.uninitialized
     var childFiles: List[File] = scala.compiletime.uninitialized
@@ -86,7 +85,7 @@ class FileExamplesTest extends UnitSpec {
         .withFilter(_.startsWith(withCompletionPrefix))
         .map(_.substring(withCompletionPrefix.length))
 
-    def createSampleDirStructure(tempDir: File): Unit = {
+    def createSampleDirStructure(tempDir: File): Unit =
       childFiles = toChildFiles(tempDir, List("foo", "bar", "bazaar"))
       childDirectories = toChildFiles(tempDir, List("moo", "far"))
       nestedFiles = toChildFiles(childDirectories(1), List("farfile1", "barfile2"))
@@ -96,10 +95,8 @@ class FileExamplesTest extends UnitSpec {
       (childFiles ++ nestedFiles).foreach(_.createNewFile())
 
       baseDir = tempDir
-    }
 
     private def toChildFiles(baseDir: File, files: List[String]): List[File] =
       files.map(new File(baseDir, _))
-  }
-
-}
+  end DirectoryStructure
+end FileExamplesTest
diff --git a/internal/util-complete/src/test/scala/sbt/complete/FixedSetExamplesTest.scala b/internal/util-complete/src/test/scala/sbt/complete/FixedSetExamplesTest.scala
index 835afb593..f91e08781 100644
--- a/internal/util-complete/src/test/scala/sbt/complete/FixedSetExamplesTest.scala
+++ b/internal/util-complete/src/test/scala/sbt/complete/FixedSetExamplesTest.scala
@@ -9,25 +9,21 @@
 package sbt.internal.util
 package complete
 
-class FixedSetExamplesTest extends UnitSpec {
+class FixedSetExamplesTest extends UnitSpec:
 
   "adding a prefix" should "produce a smaller set of examples with the prefix removed" in {
-    val _ = new Examples {
+    val _ = new Examples:
       fixedSetExamples.withAddedPrefix("f")() should contain theSameElementsAs
         (List("oo", "ool", "u"))
       fixedSetExamples.withAddedPrefix("fo")() should contain theSameElementsAs (List("o", "ol"))
       fixedSetExamples.withAddedPrefix("b")() should contain theSameElementsAs (List("ar"))
-    }
   }
 
   "without a prefix" should "produce the original set" in {
-    val _ = new Examples {
+    val _ = new Examples:
       fixedSetExamples() shouldBe exampleSet
-    }
   }
 
-  trait Examples {
+  trait Examples:
     val exampleSet = List("foo", "bar", "fool", "fu")
     val fixedSetExamples = FixedSetExamples(exampleSet)
-  }
-}
diff --git a/internal/util-complete/src/test/scala/sbt/complete/ParserWithExamplesTest.scala b/internal/util-complete/src/test/scala/sbt/complete/ParserWithExamplesTest.scala
index d2b4a2aec..c1c392ee6 100644
--- a/internal/util-complete/src/test/scala/sbt/complete/ParserWithExamplesTest.scala
+++ b/internal/util-complete/src/test/scala/sbt/complete/ParserWithExamplesTest.scala
@@ -11,19 +11,18 @@ package complete
 
 import Completion.*
 
-class ParserWithExamplesTest extends UnitSpec {
+class ParserWithExamplesTest extends UnitSpec:
 
   "listing a limited number of completions" should
     "grab only the needed number of elements from the iterable source of examples" in {
-      val _ = new ParserWithLazyExamples {
+      val _ = new ParserWithLazyExamples:
         parserWithExamples.completions(0)
         examples.size shouldEqual maxNumberOfExamples
-      }
     }
 
   "listing only valid completions" should
     "use the delegate parser to remove invalid examples" in {
-      val _ = new ParserWithValidExamples {
+      val _ = new ParserWithValidExamples:
         val validCompletions = Completions(
           Set(
             suggestion("blue"),
@@ -31,32 +30,29 @@ class ParserWithExamplesTest extends UnitSpec {
           )
         )
         parserWithExamples.completions(0) shouldEqual validCompletions
-      }
     }
 
   "listing valid completions in a derived parser" should
     "produce only valid examples that start with the character of the derivation" in {
-      val _ = new ParserWithValidExamples {
+      val _ = new ParserWithValidExamples:
         val derivedCompletions = Completions(
           Set(
             suggestion("lue")
           )
         )
         parserWithExamples.derive('b').completions(0) shouldEqual derivedCompletions
-      }
     }
 
   "listing valid and invalid completions" should
     "produce the entire source of examples" in {
-      val _ = new parserWithAllExamples {
+      val _ = new parserWithAllExamples:
         val completions = Completions(examples.map(suggestion(_)).toSet)
         parserWithExamples.completions(0) shouldEqual completions
-      }
     }
 
   "listing valid and invalid completions in a derived parser" should
     "produce only examples that start with the character of the derivation" in {
-      val _ = new parserWithAllExamples {
+      val _ = new parserWithAllExamples:
         val derivedCompletions = Completions(
           Set(
             suggestion("lue"),
@@ -64,7 +60,6 @@ class ParserWithExamplesTest extends UnitSpec {
           )
         )
         parserWithExamples.derive('b').completions(0) shouldEqual derivedCompletions
-      }
     }
 
   class ParserWithLazyExamples
@@ -82,7 +77,7 @@ class ParserWithExamplesTest extends UnitSpec {
       examples: Iterable[String] = Set("blue", "yellow", "green_", "block", "red"),
       maxNumberOfExamples: Int = 25,
       removeInvalidExamples: Boolean
-  ) {
+  ):
 
     import DefaultParsers.*
 
@@ -93,26 +88,20 @@ class ParserWithExamplesTest extends UnitSpec {
       maxNumberOfExamples,
       removeInvalidExamples
     )
-  }
 
-  case class GrowableSourceOfExamples() extends Iterable[String] {
+  case class GrowableSourceOfExamples() extends Iterable[String]:
     private var numberOfIteratedElements: Int = 0
 
-    override def iterator: Iterator[String] = {
-      new Iterator[String] {
+    override def iterator: Iterator[String] =
+      new Iterator[String]:
         var currentElement = 0
 
-        override def next(): String = {
+        override def next(): String =
           currentElement += 1
           numberOfIteratedElements = Math.max(currentElement, numberOfIteratedElements)
           numberOfIteratedElements.toString
-        }
 
         override def hasNext: Boolean = true
-      }
-    }
 
     override def size: Int = numberOfIteratedElements
-  }
-
-}
+end ParserWithExamplesTest
diff --git a/internal/util-control/src/main/scala/sbt/internal/util/ErrorHandling.scala b/internal/util-control/src/main/scala/sbt/internal/util/ErrorHandling.scala
index 1c79e5365..544464181 100644
--- a/internal/util-control/src/main/scala/sbt/internal/util/ErrorHandling.scala
+++ b/internal/util-control/src/main/scala/sbt/internal/util/ErrorHandling.scala
@@ -10,19 +10,16 @@ package sbt.internal.util
 
 import java.io.IOException
 
-object ErrorHandling {
+object ErrorHandling:
   def translate[T](msg: => String)(f: => T) =
-    try {
-      f
-    } catch {
+    try f
+    catch
       case e: IOException => throw new TranslatedIOException(msg + e.toString, e)
       case e: Exception   => throw new TranslatedException(msg + e.toString, e)
-    }
 
   def wideConvert[T](f: => T): Either[Throwable, T] =
-    try {
-      Right(f)
-    } catch {
+    try Right(f)
+    catch
       case ex @ (_: Exception | _: StackOverflowError) =>
         Left(ex)
       case err: VirtualMachineError =>
@@ -33,24 +30,21 @@ object ErrorHandling {
         throw err
       case x: Throwable =>
         Left(x)
-    }
 
   def convert[T](f: => T): Either[Exception, T] =
-    try {
-      Right(f)
-    } catch { case e: Exception => Left(e) }
+    try Right(f)
+    catch case e: Exception => Left(e)
 
   def reducedToString(e: Throwable): String =
-    if (e.getClass == classOf[RuntimeException]) {
+    if e.getClass == classOf[RuntimeException] then
       val msg = e.getMessage
-      if (msg == null || msg.isEmpty) e.toString else msg
-    } else e.toString
-}
+      if msg == null || msg.isEmpty then e.toString else msg
+    else e.toString
+end ErrorHandling
 
 sealed class TranslatedException private[sbt] (msg: String, cause: Throwable)
-    extends RuntimeException(msg, cause) {
+    extends RuntimeException(msg, cause):
   override def toString = msg
-}
 
 final class TranslatedIOException private[sbt] (msg: String, cause: IOException)
     extends TranslatedException(msg, cause)
diff --git a/internal/util-control/src/main/scala/sbt/internal/util/ExitHook.scala b/internal/util-control/src/main/scala/sbt/internal/util/ExitHook.scala
index d73b60065..b7d650bdc 100644
--- a/internal/util-control/src/main/scala/sbt/internal/util/ExitHook.scala
+++ b/internal/util-control/src/main/scala/sbt/internal/util/ExitHook.scala
@@ -9,18 +9,16 @@
 package sbt.internal.util
 
 /** Defines a function to call as sbt exits. */
-trait ExitHook {
+trait ExitHook:
 
   /** Subclasses should implement this method, which is called when this hook is executed. */
   def runBeforeExiting(): Unit
 
-}
+object ExitHook:
+  def apply(f: => Unit): ExitHook = new ExitHook:
+    def runBeforeExiting() = f
 
-object ExitHook {
-  def apply(f: => Unit): ExitHook = new ExitHook { def runBeforeExiting() = f }
-}
-
-object ExitHooks {
+object ExitHooks:
 
   /**
    * Calls each registered exit hook, trapping any exceptions so that each hook is given a chance to
@@ -28,5 +26,3 @@ object ExitHooks {
    */
   def runExitHooks(exitHooks: Seq[ExitHook]): Seq[Throwable] =
     exitHooks.flatMap(hook => ErrorHandling.wideConvert(hook.runBeforeExiting()).left.toOption)
-
-}
diff --git a/internal/util-control/src/main/scala/sbt/internal/util/RunningProcesses.scala b/internal/util-control/src/main/scala/sbt/internal/util/RunningProcesses.scala
index ce325d423..f704d8fec 100644
--- a/internal/util-control/src/main/scala/sbt/internal/util/RunningProcesses.scala
+++ b/internal/util-control/src/main/scala/sbt/internal/util/RunningProcesses.scala
@@ -17,7 +17,7 @@ import scala.sys.process.Process
  * killed with the killAll method. In particular, this can be used in a signal handler to kill these
  * processes when the user inputs ctrl+c.
  */
-private[sbt] object RunningProcesses {
+private[sbt] object RunningProcesses:
   val active = ConcurrentHashMap.newKeySet[AnyRef]
   def add(process: AnyRef): Unit = active.synchronized {
     active.add(process)
@@ -35,4 +35,3 @@ private[sbt] object RunningProcesses {
     }
     active.clear()
   }
-}
diff --git a/internal/util-control/src/main/scala/sbt/internal/util/hashing/FarmHash64.scala b/internal/util-control/src/main/scala/sbt/internal/util/hashing/FarmHash64.scala
index 61d9ada40..507fdb371 100644
--- a/internal/util-control/src/main/scala/sbt/internal/util/hashing/FarmHash64.scala
+++ b/internal/util-control/src/main/scala/sbt/internal/util/hashing/FarmHash64.scala
@@ -143,6 +143,7 @@ object FarmHash64:
         off += 64
         off != fin
       do ()
+      end while
 
       off = last64.toInt
 
@@ -183,6 +184,8 @@ object FarmHash64:
       z = x
       x = t
       hashLen16(hashLen16(v1, w1, m) + shiftMix(y) * K0 + z, hashLen16(v2, w2, m) + x, m)
+    end if
+  end naHash64
 end FarmHash64
 
 object FarmNaSeedlessHash64:
diff --git a/internal/util-control/src/main/scala/sbt/internal/util/hashing/StreamingXXHash64VarHandle.scala b/internal/util-control/src/main/scala/sbt/internal/util/hashing/StreamingXXHash64VarHandle.scala
index 965dc5898..b157df4f2 100644
--- a/internal/util-control/src/main/scala/sbt/internal/util/hashing/StreamingXXHash64VarHandle.scala
+++ b/internal/util-control/src/main/scala/sbt/internal/util/hashing/StreamingXXHash64VarHandle.scala
@@ -56,6 +56,7 @@ class StreamingXXHash64VarHandle(seed: Long) extends AbstractStreamingXXHash64Sc
       h64 ^= v4
       h64 = h64 * PRIME64_1 + PRIME64_4
     else h64 = seed + PRIME64_5
+    end if
 
     h64 += totalLen
 
@@ -123,6 +124,7 @@ class StreamingXXHash64VarHandle(seed: Long) extends AbstractStreamingXXHash64Sc
         off += 32 - memSize
         memSize = 0
       else ()
+      end if
 
       {
         val limit: Int = end - 32
diff --git a/internal/util-control/src/main/scala/sbt/internal/util/hashing/XXHash64.scala b/internal/util-control/src/main/scala/sbt/internal/util/hashing/XXHash64.scala
index 02905dcc3..4adc131f3 100644
--- a/internal/util-control/src/main/scala/sbt/internal/util/hashing/XXHash64.scala
+++ b/internal/util-control/src/main/scala/sbt/internal/util/hashing/XXHash64.scala
@@ -71,6 +71,7 @@ class XXHash64[A1: Access](seed: Long) extends HashAlgo[A1]:
         off += 8
         off <= limit
       do ()
+      end while
 
       h64 = rotateLeft(v1, 1) + rotateLeft(v2, 7) + rotateLeft(v3, 12) + rotateLeft(v4, 18)
 
@@ -98,6 +99,7 @@ class XXHash64[A1: Access](seed: Long) extends HashAlgo[A1]:
       h64 ^= v4
       h64 = h64 * PRIME64_1 + PRIME64_4
     else h64 = seed + PRIME64_5
+    end if
 
     h64 += len
 
diff --git a/internal/util-core/src/main/scala-3/sbt/internal/util/appmacro/StringTypeTag.scala b/internal/util-core/src/main/scala-3/sbt/internal/util/appmacro/StringTypeTag.scala
index 11975a4c3..4d17bb8fa 100644
--- a/internal/util-core/src/main/scala-3/sbt/internal/util/appmacro/StringTypeTag.scala
+++ b/internal/util-core/src/main/scala-3/sbt/internal/util/appmacro/StringTypeTag.scala
@@ -9,10 +9,9 @@ package sbt.internal.util.appmacro
 
 final class StringTypeTag[A](val key: String):
   override def toString(): String = key
-  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match
     case x: StringTypeTag[?] => (this.key == x.key)
-    case _                   => false
-  })
+    case _                   => false)
   override def hashCode: Int = key.##
 end StringTypeTag
 
diff --git a/internal/util-core/src/main/scala/sbt/internal/util/Util.scala b/internal/util-core/src/main/scala/sbt/internal/util/Util.scala
index b109f38be..c34554db1 100644
--- a/internal/util-core/src/main/scala/sbt/internal/util/Util.scala
+++ b/internal/util-core/src/main/scala/sbt/internal/util/Util.scala
@@ -19,16 +19,14 @@ import scala.util.control.NonFatal
 object Util:
   def makeList[T](size: Int, value: T): List[T] = List.fill(size)(value)
 
-  def separate[T, A, B](ps: Seq[T])(f: T => Either[A, B]): (Seq[A], Seq[B]) = {
+  def separate[T, A, B](ps: Seq[T])(f: T => Either[A, B]): (Seq[A], Seq[B]) =
     val (a, b) = ps.foldLeft((Nil: Seq[A], Nil: Seq[B]))((xs, y) => prependEither(xs, f(y)))
     (a.reverse, b.reverse)
-  }
 
   def prependEither[A, B](acc: (Seq[A], Seq[B]), next: Either[A, B]): (Seq[A], Seq[B]) =
-    next match {
+    next match
       case Left(l)  => (l +: acc._1, acc._2)
       case Right(r) => (acc._1, r +: acc._2)
-    }
 
   def pairID[A, B] = (a: A, b: B) => (a, b)
 
@@ -37,14 +35,14 @@ object Util:
   def hasHyphen(s: String): Boolean = s.indexOf('-') >= 0
 
   def hyphenToCamel(s: String): String =
-    if (hasHyphen(s)) Hyphen.replaceAllIn(s, _.group(1).toUpperCase(Locale.ENGLISH)) else s
+    if hasHyphen(s) then Hyphen.replaceAllIn(s, _.group(1).toUpperCase(Locale.ENGLISH)) else s
 
   private lazy val Camel = """(\p{javaLowerCase})(\p{javaUpperCase})""".r
 
   def camelToHyphen(s: String): String =
     Camel.replaceAllIn(s, m => m.group(1) + "-" + m.group(2).toLowerCase(Locale.ENGLISH))
 
-  def quoteIfKeyword(s: String): String = if (ScalaKeywords.values(s)) s"`${s}`" else s
+  def quoteIfKeyword(s: String): String = if ScalaKeywords.values(s) then s"`${s}`" else s
 
   def quoteIfNotScalaId(s: String): String =
     if isValidScalaId(s) && !ScalaKeywords.values(s) then s
@@ -54,10 +52,9 @@ object Util:
     s.nonEmpty && (s.charAt(0).isLetter || s.charAt(0) == '_') &&
       s.forall(c => c.isLetterOrDigit || c == '_')
 
-  def ignoreResult[A](f: => A): Unit = {
+  def ignoreResult[A](f: => A): Unit =
     val _ = f
     ()
-  }
 
   def ignoreTry[A](f: => A): Unit = ignoreResult(Try(f))
 
@@ -67,13 +64,11 @@ object Util:
   lazy val isWindows: Boolean =
     System.getProperty("os.name").toLowerCase(Locale.ENGLISH).contains("windows")
 
-  lazy val isCygwin: Boolean = {
+  lazy val isCygwin: Boolean =
     val os = sys.env.get("OSTYPE")
-    os match {
+    os match
       case Some(x) => x.toLowerCase(Locale.ENGLISH).contains("cygwin")
       case _       => false
-    }
-  }
 
   lazy val isNonCygwinWindows: Boolean = isWindows && !isCygwin
   lazy val isCygwinWindows: Boolean = isWindows && isCygwin
@@ -88,14 +83,11 @@ object Util:
   def nilSeq[A]: Seq[A] = Seq.empty[A]
   def none[A]: Option[A] = (None: Option[A])
 
-  extension [A](value: A) {
-    def some: Option[A] = (Some(value): Option[A])
-  }
+  extension [A](value: A) def some: Option[A] = (Some(value): Option[A])
 
-  private[sbt] def withCaching[A1, A2](f: A1 => A2): A1 => A2 = {
+  private[sbt] def withCaching[A1, A2](f: A1 => A2): A1 => A2 =
     val cache = TrieMap.empty[A1, A2]
     x => cache.getOrElseUpdate(x, f(x))
-  }
 
   lazy val javaHome: Path =
     sys.env.get("JAVA_HOME") match
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/BasicLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/BasicLogger.scala
index 56c3ddbc9..2432a8d29 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/BasicLogger.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/BasicLogger.scala
@@ -11,7 +11,7 @@ package sbt.internal.util
 import sbt.util.*
 
 /** Implements the level-setting methods of Logger. */
-abstract class BasicLogger extends AbstractLogger {
+abstract class BasicLogger extends AbstractLogger:
   private var traceEnabledVar: Int = java.lang.Integer.MAX_VALUE
   private var level: Level.Value = Level.Info
   private var successEnabledVar = true
@@ -21,4 +21,3 @@ abstract class BasicLogger extends AbstractLogger {
   def setLevel(newLevel: Level.Value): Unit = synchronized { level = newLevel }
   def setTrace(level: Int): Unit = synchronized { traceEnabledVar = level }
   def getTrace: Int = synchronized { traceEnabledVar }
-}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/BufferedLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/BufferedLogger.scala
index 8ec136c62..866d010f2 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/BufferedLogger.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/BufferedLogger.scala
@@ -12,7 +12,7 @@ import sbt.util.*
 import scala.collection.mutable.ListBuffer
 import java.util.concurrent.atomic.AtomicInteger
 
-object BufferedAppender {
+object BufferedAppender:
   def generateName: String =
     "buffered-" + generateId.incrementAndGet
 
@@ -23,7 +23,6 @@ object BufferedAppender {
 
   def apply(name: String, delegate: Appender): BufferedAppender =
     new BufferedAppender(name, delegate)
-}
 
 /**
  * An appender that can buffer the logging done on it and then can flush the buffer to the delegate
@@ -31,7 +30,7 @@ object BufferedAppender {
  * the buffer to the backing appender. The logging level set at the time a message is originally
  * logged is used, not the level at the time 'play' is called.
  */
-class BufferedAppender(override val name: String, delegate: Appender) extends Appender {
+class BufferedAppender(override val name: String, delegate: Appender) extends Appender:
   override def close(): Unit = ()
   override private[sbt] def properties: ConsoleAppender.Properties = delegate.properties
   override private[sbt] def suppressedMessage: SuppressedTraceContext => Option[String] =
@@ -41,40 +40,37 @@ class BufferedAppender(override val name: String, delegate: Appender) extends Ap
     new java.util.Vector[(Level.Value, Option[String], Option[ObjectEvent[?]])]
   private var recording = false
 
-  override def appendLog(level: Level.Value, message: => String): Unit = {
-    if (recording) Util.ignoreResult(buffer.add((level, Some(message), None)))
+  override def appendLog(level: Level.Value, message: => String): Unit =
+    if recording then Util.ignoreResult(buffer.add((level, Some(message), None)))
     else delegate.appendLog(level, message)
-  }
   override private[sbt] def appendObjectEvent[T](
       level: Level.Value,
       message: => ObjectEvent[T]
-  ): Unit = {
-    if (recording) Util.ignoreResult(buffer.add(((level, None, Some(message)))))
+  ): Unit =
+    if recording then Util.ignoreResult(buffer.add(((level, None, Some(message)))))
     else delegate.appendObjectEvent(level, message)
-  }
 
   /** Enables buffering. */
   def record() = synchronized { recording = true }
-  def buffer[T](f: => T): T = {
+  def buffer[T](f: => T): T =
     record()
-    try {
+    try
       f
-    } finally {
+    finally
       stopQuietly()
-    }
-  }
-  def bufferQuietly[T](f: => T): T = {
+  def bufferQuietly[T](f: => T): T =
     record()
-    try {
+    try
       val result = f
       clearBuffer()
       result
-    } catch { case e: Throwable => stopQuietly(); throw e }
-  }
+    catch
+      case e: Throwable =>
+        stopQuietly()
+        throw e
   def stopQuietly() = synchronized {
-    try {
-      stopBuffer()
-    } catch { case _: Exception => () }
+    try stopBuffer()
+    catch case _: Exception => ()
   }
 
   /**
@@ -95,8 +91,7 @@ class BufferedAppender(override val name: String, delegate: Appender) extends Ap
 
   /** Plays buffered events and disables buffering. */
   def stopBuffer(): Unit = synchronized { play(); clearBuffer() }
-
-}
+end BufferedAppender
 
 /**
  * A logger that can buffer the logging done on it and then can flush the buffer to the delegate
@@ -106,32 +101,31 @@ class BufferedAppender(override val name: String, delegate: Appender) extends Ap
  *
  * This class assumes that it is the only client of the delegate logger.
  */
-class BufferedLogger(delegate: AbstractLogger) extends BasicLogger {
+class BufferedLogger(delegate: AbstractLogger) extends BasicLogger:
   private val buffer = new ListBuffer[LogEvent]
   private var recording = false
 
   /** Enables buffering. */
   def record() = synchronized { recording = true }
-  def buffer[T](f: => T): T = {
+  def buffer[T](f: => T): T =
     record()
-    try {
+    try
       f
-    } finally {
+    finally
       stopQuietly()
-    }
-  }
-  def bufferQuietly[T](f: => T): T = {
+  def bufferQuietly[T](f: => T): T =
     record()
-    try {
+    try
       val result = f
       clear()
       result
-    } catch { case e: Throwable => stopQuietly(); throw e }
-  }
+    catch
+      case e: Throwable =>
+        stopQuietly()
+        throw e
   def stopQuietly() = synchronized {
-    try {
-      stop()
-    } catch { case _: Exception => () }
+    try stop()
+    catch case _: Exception => ()
   }
 
   /**
@@ -148,28 +142,22 @@ class BufferedLogger(delegate: AbstractLogger) extends BasicLogger {
 
   override def setLevel(newLevel: Level.Value): Unit = synchronized {
     super.setLevel(newLevel)
-    if (recording)
-      buffer += new SetLevel(newLevel)
-    else
-      delegate.setLevel(newLevel)
+    if recording then buffer += new SetLevel(newLevel)
+    else delegate.setLevel(newLevel)
     ()
   }
 
   override def setSuccessEnabled(flag: Boolean): Unit = synchronized {
     super.setSuccessEnabled(flag)
-    if (recording)
-      buffer += new SetSuccess(flag)
-    else
-      delegate.setSuccessEnabled(flag)
+    if recording then buffer += new SetSuccess(flag)
+    else delegate.setSuccessEnabled(flag)
     ()
   }
 
   override def setTrace(level: Int): Unit = synchronized {
     super.setTrace(level)
-    if (recording)
-      buffer += new SetTrace(level)
-    else
-      delegate.setTrace(level)
+    if recording then buffer += new SetTrace(level)
+    else delegate.setTrace(level)
     ()
   }
 
@@ -182,10 +170,8 @@ class BufferedLogger(delegate: AbstractLogger) extends BasicLogger {
     doBufferable(level, new Log(level, message), _.log(level, message))
 
   def logAll(events: Seq[LogEvent]): Unit = synchronized {
-    if (recording)
-      buffer ++= events
-    else
-      delegate.logAll(events)
+    if recording then buffer ++= events
+    else delegate.logAll(events)
     ()
   }
 
@@ -204,12 +190,9 @@ class BufferedLogger(delegate: AbstractLogger) extends BasicLogger {
       appendIfBuffered: => LogEvent,
       doUnbuffered: AbstractLogger => Unit
   ): Unit = synchronized {
-    if (condition) {
-      if (recording)
-        buffer += appendIfBuffered
-      else
-        doUnbuffered(delegate)
-    }
+    if condition then
+      if recording then buffer += appendIfBuffered
+      else doUnbuffered(delegate)
     ()
   }
-}
+end BufferedLogger
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleAppender.scala b/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleAppender.scala
index 739244b99..82014291d 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleAppender.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleAppender.scala
@@ -15,7 +15,7 @@ import java.util.concurrent.atomic.{ AtomicBoolean, AtomicInteger }
 import sbt.internal.util.ConsoleAppender.*
 import sbt.util.*
 
-object ConsoleLogger {
+object ConsoleLogger:
 
   /**
    * A new `ConsoleLogger` that logs to `out`.
@@ -59,7 +59,7 @@ object ConsoleLogger {
         ConsoleAppender.noSuppressedMessage
   ): ConsoleLogger =
     new ConsoleLogger(out, ansiCodesSupported, useFormat, suppressedMessage)
-}
+end ConsoleLogger
 
 /**
  * A logger that logs to the console. On supported systems, the level labels are colored.
@@ -69,7 +69,7 @@ class ConsoleLogger private[ConsoleLogger] (
     ansiCodesSupported: Boolean,
     useFormat: Boolean,
     suppressedMessage: SuppressedTraceContext => Option[String]
-) extends BasicLogger {
+) extends BasicLogger:
 
   private[sbt] val appender: Appender =
     ConsoleAppender(generateName(), out, ansiCodesSupported, useFormat, suppressedMessage)
@@ -78,22 +78,18 @@ class ConsoleLogger private[ConsoleLogger] (
     appender.control(event, message)
 
   override def log(level: Level.Value, message: => String): Unit =
-    if (atLevel(level)) {
-      appender.appendLog(level, message)
-    }
+    if atLevel(level) then appender.appendLog(level, message)
 
   override def success(message: => String): Unit =
-    if (successEnabled) {
-      appender.success(message)
-    }
+    if successEnabled then appender.success(message)
 
   override def trace(t: => Throwable): Unit =
     appender.trace(t, getTrace)
 
   override def logAll(events: Seq[LogEvent]) = events.foreach(log)
-}
+end ConsoleLogger
 
-object ConsoleAppender {
+object ConsoleAppender:
   private[sbt] def cursorLeft(n: Int): String = s"\u001B[${n}D"
   private[sbt] def cursorUp(n: Int): String = s"\u001B[${n}A"
   private[sbt] def cursorDown(n: Int): String = s"\u001B[${n}B"
@@ -108,24 +104,21 @@ object ConsoleAppender {
   private val showProgressHolder: AtomicBoolean = new AtomicBoolean(false)
   def setShowProgress(b: Boolean): Unit = showProgressHolder.set(b)
   def showProgress: Boolean = showProgressHolder.get
-  private[sbt] trait Properties {
+  private[sbt] trait Properties:
     def isAnsiSupported: Boolean
     def isColorEnabled: Boolean
     def out: ConsoleOut
-  }
-  private[sbt] object Properties {
+  private[sbt] object Properties:
     def from(terminal: Terminal): Properties =
       from(ConsoleOut.terminalOut(terminal), terminal.isAnsiSupported, terminal.isColorEnabled)
 
     def safelyFrom(terminal: Terminal): Properties =
       from(ConsoleOut.safeTerminalOut(terminal), terminal.isAnsiSupported, terminal.isColorEnabled)
 
-    def from(o: ConsoleOut, ansi: Boolean, color: Boolean): Properties = new Properties {
+    def from(o: ConsoleOut, ansi: Boolean, color: Boolean): Properties = new Properties:
       override def isAnsiSupported: Boolean = ansi
       override def isColorEnabled: Boolean = color
       override def out = o
-    }
-  }
 
   /** Hide stack trace altogether. */
   val noSuppressedMessage = (_: SuppressedTraceContext) => None
@@ -139,11 +132,10 @@ object ConsoleAppender {
   @deprecated("Use Terminal.isAnsiSupported or Terminal.isColorEnabled", "1.4.0")
   lazy val formatEnabledInEnv: Boolean = Terminal.isAnsiSupported
 
-  private[sbt] def parseLogOption(s: String): LogOption = Terminal.parseLogOption(s) match {
+  private[sbt] def parseLogOption(s: String): LogOption = Terminal.parseLogOption(s) match
     case Some(true)  => LogOption.Always
     case Some(false) => LogOption.Never
     case _           => LogOption.Auto
-  }
 
   private val generateId: AtomicInteger = new AtomicInteger
 
@@ -223,10 +215,9 @@ object ConsoleAppender {
       name: String,
       out: ConsoleOut,
       suppressedMessage: SuppressedTraceContext => Option[String]
-  ): Appender = {
+  ): Appender =
     val ansi = Terminal.isAnsiSupported
     apply(name, out, ansi, ansi, suppressedMessage)
-  }
 
   /**
    * A new `ConsoleAppender` identified by `name`, and that writes to `out`.
@@ -253,9 +244,8 @@ object ConsoleAppender {
    * @return
    *   A new `ConsoleAppender` that writes to `out`.
    */
-  def apply(name: String, terminal: Terminal): Appender = {
+  def apply(name: String, terminal: Terminal): Appender =
     new ConsoleAppender(name, Properties.from(terminal), noSuppressedMessage)
-  }
 
   /**
    * A new `ConsoleAppender` identified by `name`, and that writes to `terminal`.
@@ -265,9 +255,8 @@ object ConsoleAppender {
    * @param terminal  The terminal to which this appender corresponds
    * @return A new `ConsoleAppender` that writes to `terminal`.
    */
-  def safe(name: String, terminal: Terminal): Appender = {
+  def safe(name: String, terminal: Terminal): Appender =
     new ConsoleAppender(name, Properties.safelyFrom(terminal), noSuppressedMessage)
-  }
 
   /**
    * A new `ConsoleAppender` identified by `name`, and that writes to `out`.
@@ -285,9 +274,8 @@ object ConsoleAppender {
       name: String,
       terminal: Terminal,
       suppressedMessage: SuppressedTraceContext => Option[String]
-  ): Appender = {
+  ): Appender =
     new ConsoleAppender(name, Properties.from(terminal), suppressedMessage)
-  }
 
   /**
    * A new `ConsoleAppender` identified by `name`, and that writes to `out`.
@@ -309,16 +297,15 @@ object ConsoleAppender {
       ansiCodesSupported: Boolean,
       useFormat: Boolean,
       suppressedMessage: SuppressedTraceContext => Option[String]
-  ): Appender = {
+  ): Appender =
     new ConsoleAppender(
       name,
       Properties.from(out, ansiCodesSupported, useFormat),
       suppressedMessage
     )
-  }
 
   private[sbt] def generateName(): String = "out-" + generateId.incrementAndGet
-}
+end ConsoleAppender
 
 // See http://stackoverflow.com/questions/24205093/how-to-create-a-custom-appender-in-log4j2
 // for custom appender using Java.
@@ -334,10 +321,9 @@ class ConsoleAppender(
     override private[sbt] val name: String,
     override private[sbt] val properties: Properties,
     override private[sbt] val suppressedMessage: SuppressedTraceContext => Option[String]
-) extends Appender {
+) extends Appender:
   override def close(): Unit = ()
-}
-trait Appender extends AutoCloseable {
+trait Appender extends AutoCloseable:
   private[sbt] def name: String
   private[sbt] def properties: Properties
   private[sbt] def suppressedMessage: SuppressedTraceContext => Option[String]
@@ -373,15 +359,11 @@ trait Appender extends AutoCloseable {
    * @param traceLevel
    *   How to shorten the stack trace.
    */
-  def trace(t: => Throwable, traceLevel: Int): Unit = {
-    if (traceLevel >= 0)
-      write(StackTrace.trimmed(t, traceLevel))
-    if (traceLevel <= 2) {
+  def trace(t: => Throwable, traceLevel: Int): Unit =
+    if traceLevel >= 0 then write(StackTrace.trimmed(t, traceLevel))
+    if traceLevel <= 2 then
       val ctx = new SuppressedTraceContext(traceLevel, ansiCodesSupported && useFormat)
-      for (msg <- suppressedMessage(ctx))
-        appendLog(NO_COLOR, "trace", NO_COLOR, msg)
-    }
-  }
+      for msg <- suppressedMessage(ctx) do appendLog(NO_COLOR, "trace", NO_COLOR, msg)
 
   /**
    * Logs a `ControlEvent` to the log.
@@ -402,9 +384,8 @@ trait Appender extends AutoCloseable {
    * @param message
    *   The message to log.
    */
-  def appendLog(level: Level.Value, message: => String): Unit = {
+  def appendLog(level: Level.Value, message: => String): Unit =
     appendLog(labelColor(level), level.toString, NO_COLOR, message)
-  }
 
   /**
    * Select the right color for the label given `level`.
@@ -415,11 +396,10 @@ trait Appender extends AutoCloseable {
    *   The color to use to color the label.
    */
   private def labelColor(level: Level.Value): String =
-    level match {
+    level match
       case Level.Error => RED
       case Level.Warn  => YELLOW
       case _           => NO_COLOR
-    }
 
   /**
    * Appends a full message to the log. Each line is prefixed with `[$label]`, written in
@@ -441,81 +421,71 @@ trait Appender extends AutoCloseable {
       messageColor: String,
       message: String
   ): Unit =
-    try {
+    try
       // according to https://github.com/sbt/sbt/issues/5608, sometimes we get a null message
-      if (message == null) ()
-      else {
+      if message == null then ()
+      else
         val len = labelColor.length + label.length + messageColor.length + reset.length * 3
         val builder: StringBuilder = new StringBuilder(len)
         message.linesIterator.foreach { line =>
           builder.ensureCapacity(len + line.length + 4)
           builder.setLength(0)
 
-          def fmted(a: String, b: String) = {
-            if (useFormat) builder.append(reset).append(a).append(b).append(reset)
+          def fmted(a: String, b: String) =
+            if useFormat then builder.append(reset).append(a).append(b).append(reset)
             else builder.append(b)
-          }
 
-          if (useFormat) builder.append(reset)
+          if useFormat then builder.append(reset)
           builder.append('[')
           fmted(labelColor, label)
           builder.append("] ")
           fmted(messageColor, line)
           write(builder.toString)
         }
-      }
-    } catch { case _: InterruptedException => }
+    catch
+      case _: InterruptedException =>
 
   // success is called by ConsoleLogger.
-  private[sbt] def success(message: => String): Unit = {
+  private[sbt] def success(message: => String): Unit =
     appendLog(SUCCESS_LABEL_COLOR, Level.SuccessLabel, SUCCESS_MESSAGE_COLOR, message)
-  }
 
-  private def write(msg: String): Unit = {
+  private def write(msg: String): Unit =
     // There is no api for removing only colors but not other ansi escape sequences
     // so we do nothing if useFormat is false but ansiCodesSupported is true which is
     // a rare use case but if ansiCodesSupported is true, color codes should work so
     // the output may have unwanted colors but it would still be legible. This should
     // only be relevant if the log message string itself contains ansi escape sequences
     // other than color codes which is very unlikely.
-    val toWrite = if ((!ansiCodesSupported || !useFormat) && msg.getBytes.contains(27.toByte)) {
+    val toWrite = if (!ansiCodesSupported || !useFormat) && msg.getBytes.contains(27.toByte) then
       val (bytes, len) =
         EscHelpers.strip(msg.getBytes, stripAnsi = !ansiCodesSupported, stripColor = !useFormat)
       new String(bytes, 0, len)
-    } else msg
+    else msg
     out.println(toWrite)
-  }
 
-  private def appendTraceEvent(te: TraceEvent): Unit = {
+  private def appendTraceEvent(te: TraceEvent): Unit =
     val traceLevel = getTrace
-    if (traceLevel >= 0) {
+    if traceLevel >= 0 then
       val throwableShowLines: ShowLines[Throwable] =
-        ShowLines[Throwable]((t: Throwable) => {
-          List(StackTrace.trimmed(t, traceLevel))
-        })
+        ShowLines[Throwable]((t: Throwable) => List(StackTrace.trimmed(t, traceLevel)))
       val codec: ShowLines[TraceEvent] =
-        ShowLines[TraceEvent]((t: TraceEvent) => {
-          throwableShowLines.showLines(t.message)
-        })
+        ShowLines[TraceEvent]((t: TraceEvent) => throwableShowLines.showLines(t.message))
       codec.showLines(te).toVector foreach { appendLog(Level.Error, _) }
-    }
-    if (traceLevel <= 2) {
+    if traceLevel <= 2 then
       suppressedMessage(
         new SuppressedTraceContext(traceLevel, ansiCodesSupported && useFormat)
       ) foreach {
         appendLog(Level.Error, _)
       }
-    }
-  }
 
-  private def appendMessageContent(level: Level.Value, o: AnyRef): Unit = {
-    def appendEvent(oe: ObjectEvent[?]): Unit = {
+  private def appendMessageContent(level: Level.Value, o: AnyRef): Unit =
+    def appendEvent(oe: ObjectEvent[?]): Unit =
       val contentType = oe.contentType
-      contentType match {
+      contentType match
         case "sbt.internal.util.TraceEvent" => appendTraceEvent(oe.message.asInstanceOf[TraceEvent])
         case "sbt.internal.util.ProgressEvent" =>
         case _                                 =>
-          LogExchange.stringCodec[AnyRef](contentType) match {
+          LogExchange.stringCodec[AnyRef](contentType) match
             case Some(codec) if contentType == "sbt.internal.util.SuccessEvent" =>
               codec.showLines(oe.message.asInstanceOf[AnyRef]).toVector foreach { success(_) }
             case Some(codec) =>
@@ -524,19 +494,14 @@ trait Appender extends AutoCloseable {
                 _
               ))
             case _ => appendLog(level, oe.message.toString)
-          }
-      }
-    }
 
-    o match {
+    o match
       case x: StringEvent    => Vector(x.message) foreach { appendLog(level, _) }
       case x: ObjectEvent[?] => appendEvent(x)
       case _                 => Vector(o.toString) foreach { appendLog(level, _) }
-    }
-  }
+  end appendMessageContent
   private[sbt] def appendObjectEvent[T](level: Level.Value, message: => ObjectEvent[T]): Unit =
     appendMessageContent(level, message)
-
-}
+end Appender
 
 final class SuppressedTraceContext(val traceLevel: Int, val useFormat: Boolean)
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleOut.scala b/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleOut.scala
index 012a38c2e..7f56dc75d 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleOut.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleOut.scala
@@ -13,27 +13,25 @@ import java.nio.channels.ClosedChannelException
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicReference
 
-sealed trait ConsoleOut {
+sealed trait ConsoleOut:
   val lockObject: AnyRef
   def print(s: String): Unit
   def println(s: String): Unit
   def println(): Unit
   def flush(): Unit
-}
 
-object ConsoleOut {
+object ConsoleOut:
   def systemOut: ConsoleOut = terminalOut
-  private[sbt] object NullConsoleOut extends ConsoleOut {
+  private[sbt] object NullConsoleOut extends ConsoleOut:
     override val lockObject: AnyRef = this
     override def print(s: String): Unit = {}
     override def println(): Unit = {}
     override def println(s: String): Unit = {}
     override def flush(): Unit = {}
-  }
   private[sbt] def globalProxy: ConsoleOut = Proxy
   private[sbt] def setGlobalProxy(out: ConsoleOut): Unit = Proxy.set(out)
   private[sbt] def getGlobalProxy: ConsoleOut = Proxy.proxy.get
-  private object Proxy extends ConsoleOut {
+  private object Proxy extends ConsoleOut:
     private[ConsoleOut] val proxy = new AtomicReference[ConsoleOut](systemOut)
     private def get: ConsoleOut = proxy.get
     def set(proxy: ConsoleOut): Unit = this.proxy.set(proxy)
@@ -43,7 +41,6 @@ object ConsoleOut {
     override def println(): Unit = get.println()
     override def flush(): Unit = get.flush()
     override def toString: String = s"ProxyConsoleOut"
-  }
 
   def overwriteContaining(s: String): (String, String) => Boolean =
     (cur, prev) => cur.contains(s) && prev.contains(s)
@@ -58,7 +55,7 @@ object ConsoleOut {
    * The ConsoleOut returned by this method assumes that the only newlines are from println calls
    * and not in the String arguments.
    */
-  def systemOutOverwrite(f: (String, String) => Boolean): ConsoleOut = new ConsoleOut {
+  def systemOutOverwrite(f: (String, String) => Boolean): ConsoleOut = new ConsoleOut:
     val lockObject: PrintStream = System.out
     private var last: Option[String] = None
     private val current = new java.lang.StringBuffer
@@ -66,7 +63,7 @@ object ConsoleOut {
     def println(s: String): Unit = synchronized { current.append(s); println() }
     def println(): Unit = synchronized {
       val s = current.toString
-      if (Terminal.isAnsiSupported && last.exists(lmsg => f(s, lmsg)))
+      if Terminal.isAnsiSupported && last.exists(lmsg => f(s, lmsg)) then
         lockObject.print(OverwriteLine)
       lockObject.println(s)
       last = Some(s)
@@ -74,82 +71,74 @@ object ConsoleOut {
     }
     def flush(): Unit = synchronized {
       val s = current.toString
-      if (Terminal.isAnsiSupported && last.exists(lmsg => f(s, lmsg)))
+      if Terminal.isAnsiSupported && last.exists(lmsg => f(s, lmsg)) then
         lockObject.print(OverwriteLine)
       lockObject.print(s)
       last = Some(s)
       current.setLength(0)
     }
     override def toString: String = s"SystemOutOverwrite@${System.identityHashCode(this)}"
-  }
 
-  def terminalOut: ConsoleOut = new ConsoleOut {
+  def terminalOut: ConsoleOut = new ConsoleOut:
     override val lockObject: AnyRef = System.out
     override def print(s: String): Unit = Terminal.get.printStream.print(s)
     override def println(s: String): Unit = Terminal.get.printStream.println(s)
     override def println(): Unit = Terminal.get.printStream.println()
     override def flush(): Unit = Terminal.get.printStream.flush()
     override def toString: String = s"TerminalOut"
-  }
 
   /**
    * Same as terminalOut but it catches and ignores the ClosedChannelException
    */
-  def safeTerminalOut(terminal: Terminal): ConsoleOut = {
+  def safeTerminalOut(terminal: Terminal): ConsoleOut =
     val out = terminalOut(terminal)
-    new ConsoleOut {
+    new ConsoleOut:
       override val lockObject: AnyRef = terminal
       override def print(s: String): Unit = catchException(out.print(s))
       override def println(s: String): Unit = catchException(out.println(s))
       override def println(): Unit = catchException(out.println())
       override def flush(): Unit = catchException(out.flush())
       override def toString: String = s"SafeTerminalOut($terminal)"
-      private def catchException(f: => Unit): Unit = {
+      private def catchException(f: => Unit): Unit =
         try f
-        catch {
-          case _: ClosedChannelException => ()
-        }
-      }
-    }
-  }
+        catch case _: ClosedChannelException => ()
 
   private val consoleOutPerTerminal = new ConcurrentHashMap[Terminal, ConsoleOut]
-  def terminalOut(terminal: Terminal): ConsoleOut = consoleOutPerTerminal.get(terminal) match {
+  def terminalOut(terminal: Terminal): ConsoleOut = consoleOutPerTerminal.get(terminal) match
     case null =>
-      val res = new ConsoleOut {
+      val res = new ConsoleOut:
         override val lockObject: AnyRef = terminal
         override def print(s: String): Unit = terminal.printStream.print(s)
         override def println(s: String): Unit = terminal.printStream.println(s)
         override def println(): Unit = terminal.printStream.println()
         override def flush(): Unit = terminal.printStream.flush()
         override def toString: String = s"TerminalOut($terminal)"
-      }
       consoleOutPerTerminal.put(terminal, res)
       res
     case c => c
-  }
-  def printStreamOut(out: PrintStream): ConsoleOut = new ConsoleOut {
+  def printStreamOut(out: PrintStream): ConsoleOut = new ConsoleOut:
     val lockObject: AnyRef = out
     def print(s: String) = out.print(s)
     def println(s: String) = out.println(s)
     def println() = out.println()
     def flush() = out.flush()
     override def toString: String = s"PrintStreamConsoleOut($out)"
-  }
-  def printWriterOut(out: PrintWriter): ConsoleOut = new ConsoleOut {
+  def printWriterOut(out: PrintWriter): ConsoleOut = new ConsoleOut:
     val lockObject: AnyRef = out
     def print(s: String) = out.print(s)
-    def println(s: String) = { out.println(s); flush() }
-    def println() = { out.println(); flush() }
-    def flush() = { out.flush() }
+    def println(s: String) =
+      out.println(s); flush()
+    def println() =
+      out.println(); flush()
+    def flush() = out.flush()
     override def toString: String = s"PrintWriterConsoleOut($out)"
-  }
-  def bufferedWriterOut(out: BufferedWriter): ConsoleOut = new ConsoleOut {
+  def bufferedWriterOut(out: BufferedWriter): ConsoleOut = new ConsoleOut:
     val lockObject: AnyRef = out
     def print(s: String) = out.write(s)
-    def println(s: String) = { out.write(s); println() }
-    def println() = { out.newLine(); flush() }
-    def flush() = { out.flush() }
+    def println(s: String) =
+      out.write(s); println()
+    def println() =
+      out.newLine(); flush()
+    def flush() = out.flush()
     override def toString: String = s"BufferedWriterConsoleOut($out)"
-  }
-}
+end ConsoleOut
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/EscHelpers.scala b/internal/util-logging/src/main/scala/sbt/internal/util/EscHelpers.scala
index 98ca4cf27..f69bdadc0 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/EscHelpers.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/EscHelpers.scala
@@ -12,7 +12,7 @@ import scala.annotation.tailrec
 import scala.collection.mutable.ArrayBuffer
 import scala.util.Try
 
-object EscHelpers {
+object EscHelpers:
 
   /** Escape character, used to introduce an escape sequence. */
   final val ESC = '\u001B'
@@ -64,43 +64,39 @@ object EscHelpers {
    *   isEscapeTerminator
    */
   def removeEscapeSequences(s: String): String =
-    if (s.isEmpty || !hasEscapeSequence(s)) s
-    else {
+    if s.isEmpty || !hasEscapeSequence(s) then s
+    else
       val sb = new java.lang.StringBuilder
       nextESC(s, 0, sb)
       sb.toString
-    }
 
   @tailrec
-  private def nextESC(s: String, start: Int, sb: java.lang.StringBuilder): Unit = {
+  private def nextESC(s: String, start: Int, sb: java.lang.StringBuilder): Unit =
     val escIndex = s.indexOf(ESC, start)
-    if (escIndex < 0) {
+    if escIndex < 0 then
       sb.append(s, start, s.length)
       ()
-    } else {
+    else
       sb.append(s, start, escIndex)
       val next: Int =
-        if (escIndex + 1 >= s.length) skipESC(s, escIndex + 1)
+        if escIndex + 1 >= s.length then skipESC(s, escIndex + 1)
         // If it's a CSI we skip past it and then look for a terminator.
-        else if (isCSI(s.charAt(escIndex + 1))) skipESC(s, escIndex + 2)
-        else if (isAnsiTwoCharacterTerminator(s.charAt(escIndex + 1))) escIndex + 2
-        else {
+        else if isCSI(s.charAt(escIndex + 1)) then skipESC(s, escIndex + 2)
+        else if isAnsiTwoCharacterTerminator(s.charAt(escIndex + 1)) then escIndex + 2
+        else
           // There could be non-ANSI character sequences we should make sure we handle here.
           skipESC(s, escIndex + 1)
-        }
       nextESC(s, next, sb)
-    }
-  }
   private val esc = 1
   private val csi = 2
-  def cursorPosition(s: String): Int = {
+  def cursorPosition(s: String): Int =
     val bytes = s.getBytes
     var i = 0
     var index = 0
     var state = 0
     val digit = new ArrayBuffer[Byte]
-    while (i < bytes.length) {
-      bytes(i) match {
+    while i < bytes.length do
+      bytes(i) match
         case 27                                                       => state = esc
         case b if (state == esc || state == csi) && b >= 48 && b < 58 =>
           state = csi
@@ -112,23 +108,22 @@ object EscHelpers {
         case b if state == csi =>
           val leftDigit = Try(new String(digit.toArray).toInt).getOrElse(0)
           state = 0
-          b.toChar match {
+          b.toChar match
             case 'D' => index = math.max(index - leftDigit, 0)
             case 'C' => index += leftDigit
             case 'K' =>
-            case 'J' => if (leftDigit == 2) index = 0
+            case 'J' => if leftDigit == 2 then index = 0
             case 'm' =>
             case ';' => state = csi
             case _   =>
-          }
           digit.clear()
         case _ =>
           index += 1
-      }
+      end match
       i += 1
-    }
+    end while
     index
-  }
+  end cursorPosition
 
   /**
    * Strips ansi escape and color codes from an input string.
@@ -143,7 +138,7 @@ object EscHelpers {
    *   a string with the escape and color codes removed depending on the input parameter along with
    *   the length of the output string (which may be smaller than the returned array)
    */
-  def strip(bytes: Array[Byte], stripAnsi: Boolean, stripColor: Boolean): (Array[Byte], Int) = {
+  def strip(bytes: Array[Byte], stripAnsi: Boolean, stripColor: Boolean): (Array[Byte], Int) =
     val res = new Array[Byte](bytes.length)
     var index = 0
     var state = 0
@@ -151,11 +146,11 @@ object EscHelpers {
     val digit = new ArrayBuffer[Byte]
     var escIndex = -1
     bytes.foreach { b =>
-      if (index < res.length) res(index) = b
+      if index < res.length then res(index) = b
       index += 1
       limit = math.max(limit, index)
-      if (state == 0) escIndex = -1
-      b match {
+      if state == 0 then escIndex = -1
+      b match
         case 27 =>
           escIndex = index - 1
           state = esc
@@ -169,20 +164,19 @@ object EscHelpers {
         case b if state == csi =>
           val leftDigit = Try(new String(digit.toArray).toInt).getOrElse(0)
           state = 0
-          b.toChar match {
+          b.toChar match
             case 'h' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'J' | 'K' =>
-              if (stripAnsi) index = math.max(escIndex, 0)
-            case 'm'                   => if (stripColor) index = escIndex
+              if stripAnsi then index = math.max(escIndex, 0)
+            case 'm'                   => if stripColor then index = escIndex
             case ';' | 's' | 'u' | '?' => state = csi
             case b                     =>
-          }
           digit.clear()
         case b if state == esc => state = 0
         case b                 =>
-      }
+      end match
     }
     (res, index)
-  }
+  end strip
 
   /**
    * Removes the ansi escape sequences from a string and makes a best attempt at calculating any
@@ -197,7 +191,7 @@ object EscHelpers {
    *   a string containing the original characters of the input stream with the ansi escape codes
    *   removed.
    */
-  def stripColorsAndMoves(s: String): String = {
+  def stripColorsAndMoves(s: String): String =
     val bytes = s.getBytes
     val res = new Array[Byte](bytes.length)
     var index = 0
@@ -216,17 +210,16 @@ object EscHelpers {
       case b if state == csi =>
         val leftDigit = Try(new String(digit.toArray).toInt).getOrElse(0)
         state = 0
-        b.toChar match {
+        b.toChar match
           case 'h'       => index = math.max(index - 1, 0)
           case 'D'       => index = math.max(index - leftDigit, 0)
           case 'C'       => index = math.min(limit, math.min(index + leftDigit, res.length - 1))
           case 'K' | 'J' =>
-            if (leftDigit > 0) (0 until index).foreach(res(_) = 32)
+            if leftDigit > 0 then (0 until index).foreach(res(_) = 32)
             else res(index) = 32
           case 'm' =>
           case ';' => state = csi
           case b   => state = csi
-        }
         digit.clear()
       case b if state == esc => state = 0
       case b                 =>
@@ -235,21 +228,15 @@ object EscHelpers {
         limit = math.max(limit, index)
     }
     new String(res, 0, limit)
-  }
+  end stripColorsAndMoves
 
   /**
    * Skips the escape sequence starting at `i-1`. `i` should be positioned at the character after
    * the ESC that starts the sequence.
    */
   @tailrec
-  private def skipESC(s: String, i: Int): Int = {
-    if (i >= s.length) {
-      i
-    } else if (isEscapeTerminator(s.charAt(i))) {
-      i + 1
-    } else {
-      skipESC(s, i + 1)
-    }
-  }
-
-}
+  private def skipESC(s: String, i: Int): Int =
+    if i >= s.length then i
+    else if isEscapeTerminator(s.charAt(i)) then i + 1
+    else skipESC(s, i + 1)
+end EscHelpers
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/FilterLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/FilterLogger.scala
index 289860c41..4ba47b6cb 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/FilterLogger.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/FilterLogger.scala
@@ -15,26 +15,17 @@ import sbt.util.*
  * means that messages are logged at the higher of the two levels set by this logger and its
  * delegate.
  */
-class FilterLogger(delegate: AbstractLogger) extends BasicLogger {
-  def trace(t: => Throwable): Unit = {
-    if (traceEnabled)
-      delegate.trace(t)
-  }
+class FilterLogger(delegate: AbstractLogger) extends BasicLogger:
+  def trace(t: => Throwable): Unit =
+    if traceEnabled then delegate.trace(t)
   override def setSuccessEnabled(flag: Boolean): Unit = delegate.setSuccessEnabled(flag)
   override def successEnabled = delegate.successEnabled
   override def setTrace(level: Int): Unit = delegate.setTrace(level)
   override def getTrace = delegate.getTrace
-  def log(level: Level.Value, message: => String): Unit = {
-    if (atLevel(level))
-      delegate.log(level, message)
-  }
-  def success(message: => String): Unit = {
-    if (successEnabled)
-      delegate.success(message)
-  }
-  def control(event: ControlEvent.Value, message: => String): Unit = {
-    if (atLevel(Level.Info))
-      delegate.control(event, message)
-  }
+  def log(level: Level.Value, message: => String): Unit =
+    if atLevel(level) then delegate.log(level, message)
+  def success(message: => String): Unit =
+    if successEnabled then delegate.success(message)
+  def control(event: ControlEvent.Value, message: => String): Unit =
+    if atLevel(Level.Info) then delegate.control(event, message)
   def logAll(events: Seq[LogEvent]): Unit = delegate.logAll(events)
-}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/FullLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/FullLogger.scala
index 7178e33a8..319adcb2a 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/FullLogger.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/FullLogger.scala
@@ -11,26 +11,18 @@ package sbt.internal.util
 import sbt.util.*
 
 /** Promotes the simple Logger interface to the full AbstractLogger interface. */
-class FullLogger(delegate: Logger) extends BasicLogger {
-  def trace(t: => Throwable): Unit = {
-    if (traceEnabled)
-      delegate.trace(t)
-  }
-  def log(level: Level.Value, message: => String): Unit = {
-    if (atLevel(level))
-      delegate.log(level, message)
-  }
+class FullLogger(delegate: Logger) extends BasicLogger:
+  def trace(t: => Throwable): Unit =
+    if traceEnabled then delegate.trace(t)
+  def log(level: Level.Value, message: => String): Unit =
+    if atLevel(level) then delegate.log(level, message)
   def success(message: => String): Unit =
-    if (successEnabled)
-      delegate.success(message)
+    if successEnabled then delegate.success(message)
   def control(event: ControlEvent.Value, message: => String): Unit =
     info(message)
   def logAll(events: Seq[LogEvent]): Unit = events.foreach(log)
-}
-object FullLogger {
+object FullLogger:
   def apply(delegate: Logger): AbstractLogger =
-    delegate match {
+    delegate match
       case d: AbstractLogger => d
       case _                 => new FullLogger(delegate)
-    }
-}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/GlobalLogging.scala b/internal/util-logging/src/main/scala/sbt/internal/util/GlobalLogging.scala
index 8f1cfebf5..691d85655 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/GlobalLogging.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/GlobalLogging.scala
@@ -41,7 +41,7 @@ final case class GlobalLogging1(
  * the previous backing file, if there is one. `newBackingFile` creates a new temporary location for
  * the next backing file.
  */
-final case class GlobalLogBacking(file: File, last: Option[File], newBackingFile: () => File) {
+final case class GlobalLogBacking(file: File, last: Option[File], newBackingFile: () => File):
 
   /** Shifts the current backing file to `last` and sets the current backing to `newFile`. */
   def shift(newFile: File) = GlobalLogBacking(newFile, Some(file), newBackingFile)
@@ -58,14 +58,11 @@ final case class GlobalLogBacking(file: File, last: Option[File], newBackingFile
    */
   def unshift = GlobalLogBacking(last getOrElse file, None, newBackingFile)
 
-}
-
-object GlobalLogBacking {
+object GlobalLogBacking:
   def apply(newBackingFile: => File): GlobalLogBacking =
     GlobalLogBacking(newBackingFile, None, () => newBackingFile)
-}
 
-object GlobalLogging {
+object GlobalLogging:
   import java.util.concurrent.atomic.AtomicInteger
 
   private def generateName: String = "GlobalLogging" + generateId.incrementAndGet
@@ -75,10 +72,9 @@ object GlobalLogging {
       newLogger: (PrintWriter, GlobalLogBacking) => GlobalLogging1,
       newBackingFile: => File,
       console: ConsoleOut
-  ): GlobalLogging1 = {
+  ): GlobalLogging1 =
     val log = ConsoleLogger(console)
     GlobalLogging1(log, console, log, GlobalLogBacking(newBackingFile), newLogger)
-  }
 
   def initial(
       newAppender: (ManagedLogger, PrintWriter, GlobalLogBacking, LoggerContext) => GlobalLogging,
@@ -92,11 +88,10 @@ object GlobalLogging {
       newBackingFile: => File,
       console: ConsoleOut,
       initialLevel: Level.Value = Level.Info
-  ): GlobalLogging = {
+  ): GlobalLogging =
     val loggerName = generateName
     val log = LoggerContext.globalContext.logger(loggerName, None, None)
     val appender = ConsoleAppender(ConsoleAppender.generateName(), console)
     LoggerContext.globalContext.addAppender(loggerName, appender -> initialLevel)
     GlobalLogging(log, console, appender, GlobalLogBacking(newBackingFile), newAppender)
-  }
-}
+end GlobalLogging
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/JLine3.scala b/internal/util-logging/src/main/scala/sbt/internal/util/JLine3.scala
index e9c9229cd..2a7a4e0f9 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/JLine3.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/JLine3.scala
@@ -24,159 +24,135 @@ import sbt.internal.util.Terminal.hasConsole
 import scala.jdk.CollectionConverters.*
 import java.util.concurrent.LinkedBlockingQueue
 
-private[sbt] object JLine3 {
+private[sbt] object JLine3:
   private[util] val initialAttributes = new AtomicReference[Attributes]
-  private[util] def system: org.jline.terminal.Terminal = {
+  private[util] def system: org.jline.terminal.Terminal =
     val term =
       org.jline.terminal.TerminalBuilder
         .builder()
         .system(hasConsole)
         .paused(true)
         .build()
-    initialAttributes.get match {
+    initialAttributes.get match
       case null => initialAttributes.set(term.getAttributes)
       case _    =>
-    }
     term
-  }
-  private[sbt] def apply(term: Terminal): JTerminal = {
-    if (System.getProperty("jline.terminal", "") == "none")
+  private[sbt] def apply(term: Terminal): JTerminal =
+    if System.getProperty("jline.terminal", "") == "none" then
       new DumbTerminal(term.inputStream, term.outputStream)
     else wrapTerminal(term)
-  }
-  private[util] def decodeInput(decoder: CharsetDecoder, inputStream: InputStream): Int = {
+  private[util] def decodeInput(decoder: CharsetDecoder, inputStream: InputStream): Int =
     val bytes = new Array[Byte](4)
     var i = 0
     var res = -2
-    while (i < 4 && res == -2) {
-      inputStream.read() match {
+    while i < 4 && res == -2 do
+      inputStream.read() match
         case -1   => res = -1
         case byte =>
           bytes(i) = byte.toByte
           i += 1
           val bb = ByteBuffer.wrap(bytes, 0, i)
-          try {
+          try
             val cb = decoder.decode(bb)
             val it = cb.codePoints().iterator
-            if (it.hasNext) res = it.next
-          } catch { case _: CharacterCodingException => }
-      }
-    }
+            if it.hasNext then res = it.next
+          catch
+            case _: CharacterCodingException =>
     res
-  }
-  private def wrapTerminal(term: Terminal): JTerminal = {
+  private def wrapTerminal(term: Terminal): JTerminal =
     new AbstractTerminal(
       term.name,
       "nocapabilities",
       Charset.forName("UTF-8"),
       SignalHandler.SIG_DFL
-    ) {
+    ):
       val closed = new AtomicBoolean(false)
       setOnClose { () =>
         doClose()
         reader.close()
-        if (closed.compareAndSet(false, true)) {
+        if closed.compareAndSet(false, true) then
           // This is necessary to shutdown the non blocking input reader
           // so that it doesn't keep blocking
-          term.inputStream match {
+          term.inputStream match
             case w: Terminal.WriteableInputStream => w.cancel()
             case _                                =>
-          }
-        }
       }
 
       // returns 'null' if the terminal was created with no provider
       override def getProvider(): TerminalProvider = null
       // returns 'null' if the terminal is not bound to a system stream.
       override def getSystemStream(): SystemStream = null
-      override val input: InputStream = new InputStream {
-        override def read: Int = {
-          val res = term.inputStream match {
+      override val input: InputStream = new InputStream:
+        override def read: Int =
+          val res = term.inputStream match
             case w: Terminal.WriteableInputStream =>
               val result = new LinkedBlockingQueue[Integer]
-              try {
+              try
                 w.read(result)
-                result.poll match {
+                result.poll match
                   case null => throw new ClosedException
                   case i    => i.toInt
-                }
-              } catch {
+              catch
                 case _: InterruptedException =>
                   w.cancel()
                   throw new ClosedException
-              }
             case _ => throw new ClosedException
-          }
-          res match {
+          res match
             case 3 /* ctrl+c */ => throw new ClosedException
             case r              => r
-          }
-        }
-      }
-      override val output: OutputStream = new OutputStream {
+      override val output: OutputStream = new OutputStream:
         override def write(b: Int): Unit = write(Array[Byte](b.toByte))
-        override def write(b: Array[Byte]): Unit = if (!closed.get) term.withPrintStream { ps =>
-          ps.write(b)
-          term.prompt match {
-            case a: Prompt.AskUser => a.write(b)
-            case _                 =>
+        override def write(b: Array[Byte]): Unit = if !closed.get then
+          term.withPrintStream { ps =>
+            ps.write(b)
+            term.prompt match
+              case a: Prompt.AskUser => a.write(b)
+              case _                 =>
           }
-        }
         override def write(b: Array[Byte], offset: Int, len: Int) =
           write(Arrays.copyOfRange(b, offset, offset + len))
         override def flush(): Unit = term.withPrintStream(_.flush())
-      }
 
-      override val reader = new NonBlockingReader {
+      override val reader = new NonBlockingReader:
         val buffer = new LinkedBlockingQueue[Integer]
         val thread = new AtomicReference[Thread]
         private def fillBuffer(): Unit = thread.synchronized {
           thread.set(Thread.currentThread)
           try buffer.put(decodeInput(encoding.newDecoder, term.inputStream))
-          catch { case _: InterruptedException => buffer.put(-3) }
+          catch case _: InterruptedException => buffer.put(-3)
         }
-        override def close(): Unit = thread.get match {
+        override def close(): Unit = thread.get match
           case null =>
           case t    => t.interrupt()
-        }
-        override def read(timeout: Long, peek: Boolean) = {
-          if (buffer.isEmpty && !peek) fillBuffer()
-          (if (peek) buffer.peek else buffer.take) match {
+        override def read(timeout: Long, peek: Boolean) =
+          if buffer.isEmpty && !peek then fillBuffer()
+          (if peek then buffer.peek else buffer.take) match
             case null => -2
-            case i    => if (i == -3) throw new InterruptedException else i
-          }
-        }
-        override def peek(timeout: Long): Int = buffer.peek() match {
+            case i    => if i == -3 then throw new InterruptedException else i
+        override def peek(timeout: Long): Int = buffer.peek() match
           case null => -1
           case i    => i.toInt
-        }
-        override def readBuffered(buf: Array[Char], off: Int, len: Int, timeout: Long): Int = {
-          if (buffer.isEmpty) fillBuffer()
-          buffer.take match {
+        override def readBuffered(buf: Array[Char], off: Int, len: Int, timeout: Long): Int =
+          if buffer.isEmpty then fillBuffer()
+          buffer.take match
             case i if i == -1 => -1
             case i            =>
               buf(0) = i.toChar
               1
-          }
-        }
-      }
       override val writer: PrintWriter = new PrintWriter(output, true)
       /*
        * For now assume that the terminal capabilities for client and server
        * are the same.
        */
-      override def getStringCapability(cap: Capability): String = {
-        term.getStringCapability(cap.toString) match {
+      override def getStringCapability(cap: Capability): String =
+        term.getStringCapability(cap.toString) match
           case null if cap == Capability.key_dc && Util.isWindows  => "\\E[3~"
           case null if cap == Capability.key_end && Util.isWindows => "\\E[4~"
           case null if cap == Capability.key_ic && Util.isWindows  => "\\E[2~"
           case c                                                   => c
-        }
-      }
-      override def getNumericCapability(cap: Capability): Integer = {
-        if (cap == Capability.max_colors && !term.isColorEnabled) 1
+      override def getNumericCapability(cap: Capability): Integer =
+        if cap == Capability.max_colors && !term.isColorEnabled then 1
         else term.getNumericCapability(cap.toString)
-      }
       override def getBooleanCapability(cap: Capability): Boolean =
         term.getBooleanCapability(cap.toString)
       def getAttributes(): Attributes = attributesFromMap(term.getAttributes)
@@ -186,19 +162,15 @@ private[sbt] object JLine3 {
       ): Unit = {} // don't allow the jline line reader to change attributes
       def setSize(size: Size): Unit = term.setSize(size.getColumns, size.getRows)
 
-      override def enterRawMode(): Attributes = {
+      override def enterRawMode(): Attributes =
         // don't actually modify the term, that is handled by LineReader
         attributesFromMap(term.getAttributes)
-      }
-    }
-  }
   // We need to set the ENABLE_PROCESS_INPUT flag for ctrl+c to be treated as a signal in windows
   // https://docs.microsoft.com/en-us/windows/console/setconsolemode
   private val ENABLE_PROCESS_INPUT = 1
-  private[util] def setEnableProcessInput(): Unit = if (Util.isWindows) {
+  private[util] def setEnableProcessInput(): Unit = if Util.isWindows then
     WindowsSupport.setConsoleMode(WindowsSupport.getConsoleMode | ENABLE_PROCESS_INPUT)
-  }
-  private[util] def enterRawMode(term: JTerminal): Unit = {
+  private[util] def enterRawMode(term: JTerminal): Unit =
     val prevAttr = initialAttributes.get
     val newAttr = new Attributes(prevAttr)
     // These flags are copied from the jline3 enterRawMode but the jline implementation
@@ -207,15 +179,13 @@ private[sbt] object JLine3 {
     newAttr.setInputFlags(EnumSet.of(InputFlag.IXON, InputFlag.ICRNL, InputFlag.INLCR), false)
     term.setAttributes(newAttr)
     setEnableProcessInput()
-  }
-  private[util] def exitRawMode(term: JTerminal): Unit = {
+  private[util] def exitRawMode(term: JTerminal): Unit =
     val initAttr = initialAttributes.get
     val newAttr = new Attributes(initAttr)
     newAttr.setLocalFlags(EnumSet.of(LocalFlag.ICANON, LocalFlag.ECHO), true)
     term.setAttributes(newAttr)
     setEnableProcessInput()
-  }
-  private[util] def toMap(jattributes: Attributes): Map[String, String] = {
+  private[util] def toMap(jattributes: Attributes): Map[String, String] =
     val result = new java.util.LinkedHashMap[String, String]
     result.put(
       "iflag",
@@ -242,7 +212,7 @@ private[sbt] object JLine3 {
         .mkString(" ")
     )
     result.asScala.toMap
-  }
+  end toMap
   private val iflagMap: Map[String, InputFlag] =
     InputFlag.values.map(f => f.name.toLowerCase -> f).toMap
   private val oflagMap: Map[String, Attributes.OutputFlag] =
@@ -253,14 +223,13 @@ private[sbt] object JLine3 {
     LocalFlag.values.map(f => f.name.toLowerCase -> f).toMap
   private val charMap: Map[String, Attributes.ControlChar] =
     Attributes.ControlChar.values().map(f => f.name.toLowerCase -> f).toMap
-  private[sbt] def setMode(term: Terminal, canonical: Boolean, echo: Boolean): Unit = {
+  private[sbt] def setMode(term: Terminal, canonical: Boolean, echo: Boolean): Unit =
     val prev = attributesFromMap(term.getAttributes)
     val newAttrs = new Attributes(prev)
     newAttrs.setLocalFlag(LocalFlag.ICANON, canonical)
     newAttrs.setLocalFlag(LocalFlag.ECHO, echo)
     term.setAttributes(toMap(newAttrs))
-  }
-  private[util] def attributesFromMap(map: Map[String, String]): Attributes = {
+  private[util] def attributesFromMap(map: Map[String, String]): Attributes =
     val attributes = new Attributes
     map.get("iflag").foreach { flags =>
       flags.split(" ").foreach(f => iflagMap.get(f).foreach(attributes.setInputFlag(_, true)))
@@ -276,16 +245,14 @@ private[sbt] object JLine3 {
     }
     map.get("cchars").foreach { chars =>
       chars.split(" ").foreach { keyValue =>
-        keyValue.split(",") match {
+        keyValue.split(",") match
           case Array(k, v) =>
             v.toIntOption.foreach(i => charMap.get(k).foreach(c => attributes.setControlChar(c, i)))
           case _ =>
-        }
       }
     }
     attributes
-  }
-  private[sbt] def isEchoEnabled(map: Map[String, String]): Boolean = {
+  end attributesFromMap
+  private[sbt] def isEchoEnabled(map: Map[String, String]): Boolean =
     attributesFromMap(map).getLocalFlag(LocalFlag.ECHO)
-  }
-}
+end JLine3
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/LoggerWriter.scala b/internal/util-logging/src/main/scala/sbt/internal/util/LoggerWriter.scala
index 85e304da9..58205d7c5 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/LoggerWriter.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/LoggerWriter.scala
@@ -20,7 +20,7 @@ class LoggerWriter(
     delegate: Logger,
     unbufferedLevel: Option[Level.Value],
     nl: String = System.getProperty("line.separator")
-) extends java.io.Writer {
+) extends java.io.Writer:
   def this(delegate: Logger, level: Level.Value) = this(delegate, Some(level))
   def this(delegate: Logger) = this(delegate, None)
 
@@ -31,16 +31,14 @@ class LoggerWriter(
 
   override def flush(): Unit =
     synchronized {
-      if (buffer.nonEmpty) {
+      if buffer.nonEmpty then
         log(buffer.toString)
         buffer.clear()
-      }
     }
 
   def flushLines(level: Level.Value): Unit =
     synchronized {
-      for (line <- lines)
-        delegate.log(level, line)
+      for line <- lines do delegate.log(level, line)
       lines.clear()
     }
 
@@ -51,18 +49,15 @@ class LoggerWriter(
     }
 
   @tailrec
-  private def process(): Unit = {
+  private def process(): Unit =
     val i = buffer.indexOf(nl)
-    if (i >= 0) {
+    if i >= 0 then
       log(buffer.substring(0, i))
       buffer.delete(0, i + nl.length)
       process()
-    }
-  }
 
-  private def log(s: String): Unit = unbufferedLevel match {
+  private def log(s: String): Unit = unbufferedLevel match
     case None =>
       lines += s; ()
     case Some(level) => delegate.log(level, s)
-  }
-}
+end LoggerWriter
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/MainAppender.scala b/internal/util-logging/src/main/scala/sbt/internal/util/MainAppender.scala
index eec04d5d4..5bf9d1d8f 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/MainAppender.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/MainAppender.scala
@@ -11,7 +11,7 @@ package sbt.internal.util
 import sbt.util.*
 import java.io.PrintWriter
 
-object MainAppender {
+object MainAppender:
   import java.util.concurrent.atomic.AtomicInteger
   private def generateGlobalBackingName: String =
     "GlobalBacking" + generateId.incrementAndGet
@@ -21,36 +21,32 @@ object MainAppender {
       log: ManagedLogger,
       config: MainAppenderConfig,
       context: LoggerContext
-  ): ManagedLogger = {
+  ): ManagedLogger =
     import config.*
     // TODO
     // backed setTrace backingTrace
     // multi: Logger
 
     context.clearAppenders(log.name)
-    consoleOpt match {
+    consoleOpt match
       case Some(a: ConsoleAppender) =>
         a.setTrace(screenTrace)
         context.addAppender(log.name, a -> screenLevel)
       case _ =>
-    }
     context.addAppender(log.name, backed -> backingLevel)
     extra.foreach(a => context.addAppender(log.name, a -> Level.Info))
     log
-  }
 
   def globalDefault(
       console: ConsoleOut
-  ): (ManagedLogger, PrintWriter, GlobalLogBacking, LoggerContext) => GlobalLogging = {
+  ): (ManagedLogger, PrintWriter, GlobalLogBacking, LoggerContext) => GlobalLogging =
     lazy val newAppender
         : (ManagedLogger, PrintWriter, GlobalLogBacking, LoggerContext) => GlobalLogging =
-      (log, writer, backing, lc) => {
+      (log, writer, backing, lc) =>
         val backed: Appender = defaultBacked(generateGlobalBackingName)(writer)
         val full = multiLogger(log, defaultMultiConfig(Option(console), backed, Nil), lc)
         GlobalLogging(full, console, backed, backing, newAppender)
-      }
     newAppender
-  }
 
   def defaultMultiConfig(
       consoleOpt: Option[ConsoleOut],
@@ -73,13 +69,12 @@ object MainAppender {
   def defaultScreen(
       console: ConsoleOut,
       suppressedMessage: SuppressedTraceContext => Option[String]
-  ): Appender = {
+  ): Appender =
     ConsoleAppender(
       ConsoleAppender.generateName(),
       console,
       suppressedMessage = suppressedMessage
     )
-  }
 
   def defaultScreen(
       name: String,
@@ -98,13 +93,12 @@ object MainAppender {
     defaultBacked(generateGlobalBackingName, useFormat)
 
   def defaultBacked(loggerName: String, useFormat: Boolean): PrintWriter => Appender =
-    to => {
+    to =>
       ConsoleAppender(
         ConsoleAppender.generateName(),
         ConsoleOut.printWriterOut(to),
         useFormat = useFormat
       )
-    }
 
   final case class MainAppenderConfig(
       consoleOpt: Option[Appender],
@@ -115,4 +109,4 @@ object MainAppender {
       screenTrace: Int,
       backingTrace: Int
   )
-}
+end MainAppender
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/ManagedLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/ManagedLogger.scala
index 6788969a2..fde04d272 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/ManagedLogger.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/ManagedLogger.scala
@@ -13,10 +13,9 @@ import sbt.util.*
 import sjsonnew.JsonFormat
 import sbt.internal.util.appmacro.StringTypeTag
 
-private[sbt] trait MiniLogger {
+private[sbt] trait MiniLogger:
   def log[T](level: Level.Value, message: ObjectEvent[T]): Unit
   def log(level: Level.Value, message: => String): Unit
-}
 
 /**
  * Delegates log events to the associated LogExchange.
@@ -28,7 +27,7 @@ class ManagedLogger(
     xlogger: MiniLogger,
     terminal: Option[Terminal],
     private[sbt] val context: LoggerContext,
-) extends Logger {
+) extends Logger:
   def this(
       name: String,
       channelName: Option[String],
@@ -42,15 +41,11 @@ class ManagedLogger(
     xlogger.log(level, message)
 
   // send special event for success since it's not a real log level
-  override def success(message: => String): Unit = {
-    if (terminal.fold(true)(_.isSuccessEnabled)) {
-      infoEvent[SuccessEvent](SuccessEvent(message))
-    }
-  }
+  override def success(message: => String): Unit =
+    if terminal.fold(true)(_.isSuccessEnabled) then infoEvent[SuccessEvent](SuccessEvent(message))
 
-  def registerStringCodec[A: ShowLines: StringTypeTag]: Unit = {
+  def registerStringCodec[A: ShowLines: StringTypeTag]: Unit =
     LogExchange.registerStringCodec[A]
-  }
 
   final def debugEvent[A: JsonFormat: StringTypeTag](event: => A): Unit =
     logEvent(Level.Debug, event)
@@ -60,10 +55,9 @@ class ManagedLogger(
     logEvent(Level.Error, event)
   def logEvent[A: JsonFormat](level: Level.Value, event: => A)(using
       tag: StringTypeTag[A]
-  ): Unit = {
+  ): Unit =
     val v: A = event
     // println("logEvent " + tag.key)
     val entry: ObjectEvent[A] = ObjectEvent(level, v, channelName, execId, tag.key)
     xlogger.log(level, entry)
-  }
-}
+end ManagedLogger
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/MultiLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/MultiLogger.scala
index 78aa73da6..6b245700f 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/MultiLogger.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/MultiLogger.scala
@@ -12,22 +12,19 @@ import sbt.util.*
 
 // note that setting the logging level on this logger has no effect on its behavior, only
 //   on the behavior of the delegates.
-class MultiLogger(delegates: List[AbstractLogger]) extends BasicLogger {
+class MultiLogger(delegates: List[AbstractLogger]) extends BasicLogger:
 
-  override def setLevel(newLevel: Level.Value): Unit = {
+  override def setLevel(newLevel: Level.Value): Unit =
     super.setLevel(newLevel)
     dispatch(new SetLevel(newLevel))
-  }
 
-  override def setTrace(level: Int): Unit = {
+  override def setTrace(level: Int): Unit =
     super.setTrace(level)
     dispatch(new SetTrace(level))
-  }
 
-  override def setSuccessEnabled(flag: Boolean): Unit = {
+  override def setSuccessEnabled(flag: Boolean): Unit =
     super.setSuccessEnabled(flag)
     dispatch(new SetSuccess(flag))
-  }
 
   def trace(t: => Throwable): Unit = dispatch(new Trace(t))
   def log(level: Level.Value, message: => String): Unit = dispatch(new Log(level, message))
@@ -37,9 +34,6 @@ class MultiLogger(delegates: List[AbstractLogger]) extends BasicLogger {
   def control(event: ControlEvent.Value, message: => String): Unit =
     delegates.foreach(_.control(event, message))
 
-  private def dispatch(event: LogEvent): Unit = {
-    for (d <- delegates) {
-      d.log(event)
-    }
-  }
-}
+  private def dispatch(event: LogEvent): Unit =
+    for d <- delegates do d.log(event)
+end MultiLogger
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/ObjectEvent.scala b/internal/util-logging/src/main/scala/sbt/internal/util/ObjectEvent.scala
index dcebd5eb6..65d6ba23c 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/ObjectEvent.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/ObjectEvent.scala
@@ -22,12 +22,11 @@ final class ObjectEvent[A](
     val execId: Option[String],
     val contentType: String,
     val json: JValue
-) extends Serializable {
+) extends Serializable:
   override def toString: String =
     s"ObjectEvent($level, $message, $channelName, $execId, $contentType, $json)"
-}
 
-object ObjectEvent {
+object ObjectEvent:
   def apply[A: JsonFormat](
       level: Level.Value,
       message: A,
@@ -43,4 +42,3 @@ object ObjectEvent {
       contentType,
       Converter.toJsonUnsafe(message)
     )
-}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/ProgressState.scala b/internal/util-logging/src/main/scala/sbt/internal/util/ProgressState.scala
index 45253491e..9c101c920 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/ProgressState.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/ProgressState.scala
@@ -29,7 +29,7 @@ private[sbt] final class ProgressState(
     val blankZone: Int,
     val currentLineBytes: AtomicReference[ArrayBuffer[Byte]],
     val maxItems: Int,
-) {
+):
   def this(blankZone: Int, maxItems: Int) = this(
     new AtomicReference(Nil),
     new AtomicInteger(0),
@@ -42,50 +42,43 @@ private[sbt] final class ProgressState(
     new String(currentLineBytes.get.toArray, "UTF-8").linesIterator.toSeq.lastOption
       .map(EscHelpers.stripColorsAndMoves)
       .filter(_.nonEmpty)
-  def reset(): Unit = {
+  def reset(): Unit =
     progressLines.set(Nil)
     padding.set(0)
     currentLineBytes.set(new ArrayBuffer[Byte])
-  }
   private val lineBuffer = new ArrayBlockingQueue[String](300)
   private[util] def getLines: Seq[String] = lineBuffer.asScala.toVector
-  private def appendLine(line: String) = while (!lineBuffer.offer(line)) { lineBuffer.poll }
-  private[util] def clearBytes(): Unit = {
+  private def appendLine(line: String) = while !lineBuffer.offer(line) do lineBuffer.poll
+  private[util] def clearBytes(): Unit =
     val pad = padding.get
-    if (currentLineBytes.get.isEmpty && pad > 0) padding.decrementAndGet()
+    if currentLineBytes.get.isEmpty && pad > 0 then padding.decrementAndGet()
     currentLineBytes.set(new ArrayBuffer[Byte])
-  }
 
   private val lineSeparatorBytes: Array[Byte] = System.lineSeparator.getBytes("UTF-8")
-  private[util] def addBytes(terminal: Terminal, bytes: Seq[Byte]): Unit = {
+  private[util] def addBytes(terminal: Terminal, bytes: Seq[Byte]): Unit =
     val previous: ArrayBuffer[Byte] = currentLineBytes.get
     val padding = this.padding.get
-    val prevLineCount = if (padding > 0) terminal.lineCount(new String(previous.toArray)) else 0
+    val prevLineCount = if padding > 0 then terminal.lineCount(new String(previous.toArray)) else 0
     previous ++= bytes
-    if (padding > 0) {
+    if padding > 0 then
       val newLineCount = terminal.lineCount(new String(previous.toArray))
       val diff = newLineCount - prevLineCount
       this.padding.set(math.max(padding - diff, 0))
-    }
     val lines = new String(previous.toArray, "UTF-8")
-    if (lines.contains(System.lineSeparator)) {
+    if lines.contains(System.lineSeparator) then
       currentLineBytes.set(new ArrayBuffer[Byte])
-      if (!lines.endsWith(System.lineSeparator)) {
+      if !lines.endsWith(System.lineSeparator) then
         val allLines = lines.split(System.lineSeparator)
         allLines.dropRight(1).foreach(appendLine)
         allLines.lastOption.foreach(currentLineBytes.get ++= _.getBytes("UTF-8"))
-      } else if (lines.contains(System.lineSeparator)) {
+      else if lines.contains(System.lineSeparator) then
         lines.split(System.lineSeparator).foreach(appendLine)
-      }
-    }
-  }
 
-  private[util] def getPrompt(terminal: Terminal): Array[Byte] = {
-    if (terminal.prompt.isInstanceOf[Prompt.AskUser]) {
-      val prefix = if (terminal.isAnsiSupported) s"$DeleteLine$CursorLeft1000" else ""
+  private[util] def getPrompt(terminal: Terminal): Array[Byte] =
+    if terminal.prompt.isInstanceOf[Prompt.AskUser] then
+      val prefix = if terminal.isAnsiSupported then s"$DeleteLine$CursorLeft1000" else ""
       prefix.getBytes ++ terminal.prompt.render().getBytes("UTF-8")
-    } else Array.empty
-  }
+    else Array.empty
   private val cleanPrompt =
     (DeleteLine + ClearScreenAfterCursor + CursorLeft1000).getBytes("UTF-8")
   private val clearScreenBytes = ClearScreenAfterCursor.getBytes("UTF-8")
@@ -94,67 +87,57 @@ private[sbt] final class ProgressState(
       bytes: Array[Byte],
       printStream: PrintStream,
       hasProgress: Boolean
-  ): Unit = {
-    if (hasProgress) {
+  ): Unit =
+    if hasProgress then
       val canClearPrompt = currentLineBytes.get.isEmpty
       addBytes(terminal, bytes.toSeq)
       val toWrite = new ArrayBuffer[Byte]
-      terminal.prompt match {
+      terminal.prompt match
         case a: Prompt.AskUser if a.render().nonEmpty && canClearPrompt => toWrite ++= cleanPrompt
         case _                                                          =>
-      }
       val endsWithNewLine = bytes.endsWith(lineSeparatorBytes)
-      if (endsWithNewLine || bytes.containsSlice(lineSeparatorBytes)) {
+      if endsWithNewLine || bytes.containsSlice(lineSeparatorBytes) then
         val parts = new String(bytes, "UTF-8").split(System.lineSeparator)
-        def appendLine(l: String, appendNewline: Boolean): Unit = {
+        def appendLine(l: String, appendNewline: Boolean): Unit =
           toWrite ++= l.getBytes("UTF-8")
-          if (!l.getBytes("UTF-8").endsWith("\r".getBytes)) toWrite ++= clearScreenBytes
-          if (appendNewline) toWrite ++= lineSeparatorBytes
-        }
+          if !l.getBytes("UTF-8").endsWith("\r".getBytes) then toWrite ++= clearScreenBytes
+          if appendNewline then toWrite ++= lineSeparatorBytes
         parts.dropRight(1).foreach(appendLine(_, true))
-        parts.lastOption match {
+        parts.lastOption match
           case Some(l) => appendLine(l, bytes.endsWith(lineSeparatorBytes))
           case None    => toWrite ++= lineSeparatorBytes
-        }
-      } else toWrite ++= bytes
+      else toWrite ++= bytes
       toWrite ++= clearScreenBytes
-      if (endsWithNewLine) {
-        if (progressLines.get.nonEmpty) {
-          val lastLine = terminal.prompt match {
+      if endsWithNewLine then
+        if progressLines.get.nonEmpty then
+          val lastLine = terminal.prompt match
             case a: Prompt.AskUser => a.render()
             case _                 => currentLine.getOrElse("")
-          }
           val lines = printProgress(terminal, lastLine)
           toWrite ++= lines.getBytes("UTF-8")
-        }
         toWrite ++= getPrompt(terminal)
-      }
       printStream.write(toWrite.toArray)
       printStream.flush()
-    } else printStream.write(bytes)
-  }
+    else printStream.write(bytes)
 
-  private[util] def printProgress(terminal: Terminal, lastLine: String): String = {
+  private[util] def printProgress(terminal: Terminal, lastLine: String): String =
     val previousLines = progressLines.get
-    if (previousLines.nonEmpty) {
+    if previousLines.nonEmpty then
       val currentLength = previousLines.foldLeft(0)(_ + terminal.lineCount(_))
       val (height, width) = terminal.getLineHeightAndWidth(lastLine)
       val offset = width > 0
       val pad = math.max(padding.get - height, 0)
-      val start = (if (offset) s"\n$CursorLeft1000" else "")
+      val start = (if offset then s"\n$CursorLeft1000" else "")
       val totalSize = currentLength + blankZone + pad
       val blank = CursorLeft1000 + s"\n$DeleteLine" * (totalSize - currentLength)
       val lines = previousLines.mkString(DeleteLine, s"\n$DeleteLine", s"\n$DeleteLine")
-      val resetCursorUp = cursorUp(totalSize + (if (offset) 1 else 0))
+      val resetCursorUp = cursorUp(totalSize + (if offset then 1 else 0))
       val resetCursor = resetCursorUp + CursorLeft1000 + lastLine
       start + blank + lines + resetCursor
-    } else {
-      ClearScreenAfterCursor
-    }
-  }
-}
+    else ClearScreenAfterCursor
+end ProgressState
 
-private[sbt] object ProgressState {
+private[sbt] object ProgressState:
   private val SERVER_IS_RUNNING = "sbt server is running "
   // the + 2 is for the quotation marks
   private val SERVER_IS_RUNNING_LENGTH = SERVER_IS_RUNNING.length + 3
@@ -168,36 +151,35 @@ private[sbt] object ProgressState {
   private[sbt] def updateProgressState(
       pe: ProgressEvent,
       terminal: Terminal
-  ): Unit = {
+  ): Unit =
     val state = terminal.progressState
     val isAskUser = terminal.prompt.isInstanceOf[Prompt.AskUser]
     val isRunning = terminal.prompt == Prompt.Running
     val isBatch = terminal.prompt == Prompt.Batch
     val isWatch = terminal.prompt == Prompt.Watch
-    if (terminal.isSupershellEnabled) {
+    if terminal.isSupershellEnabled then
       setShowProgress(true) // used by Zinc to not show "done compiling"
-      if (!pe.skipIfActive.getOrElse(false) || (!isRunning && !isBatch)) {
+      if !pe.skipIfActive.getOrElse(false) || (!isRunning && !isBatch) then
         terminal.withPrintStream { ps =>
           val commandFromThisTerminal = pe.channelName.fold(true)(_ == terminal.name)
-          val info = if (commandFromThisTerminal) {
+          val info = if commandFromThisTerminal then
             val base = pe.items.map { item =>
               val elapsed = item.elapsedMicros / 1000000L
               s"  | => ${item.name} ${elapsed}s"
             }
             val limit = state.maxItems
-            if (base.size > limit + 1)
+            if base.size > limit + 1 then
               s"  | ... (${base.size - limit} other tasks)" +: base.takeRight(limit)
             else base
-          } else {
+          else
             pe.command.toSeq.flatMap { cmd =>
               val width = terminal.getWidth
-              val sanitized = if ((cmd.length + SERVER_IS_RUNNING_LENGTH) > width) {
+              val sanitized = if (cmd.length + SERVER_IS_RUNNING_LENGTH) > width then
                 cmd.take(width - 3 - SERVER_IS_RUNNING_LENGTH) + "..."
-              } else cmd
-              val tail = if (isWatch) Nil else "enter 'cancel' to stop evaluation" :: Nil
+              else cmd
+              val tail = if isWatch then Nil else "enter 'cancel' to stop evaluation" :: Nil
               s"$SERVER_IS_RUNNING '$sanitized'" :: tail
             }
-          }
 
           val currentLength = info.foldLeft(0)(_ + terminal.lineCount(_))
           val previousLines = state.progressLines.getAndSet(info)
@@ -205,21 +187,21 @@ private[sbt] object ProgressState {
           val prevSize = prevLength + state.padding.get
 
           val lastLine =
-            if (isAskUser) terminal.prompt.render() else terminal.getLastLine.getOrElse("")
+            if isAskUser then terminal.prompt.render() else terminal.getLastLine.getOrElse("")
           state.padding.set(math.max(0, prevSize - currentLength))
           val toWrite =
             state.getPrompt(terminal) ++ state.printProgress(terminal, lastLine).getBytes("UTF-8")
           ps.write(toWrite)
           ps.flush()
         }
-      } else if (state.progressLines.get.nonEmpty) {
+      else if state.progressLines.get.nonEmpty then
         state.progressLines.set(Nil)
         terminal.withPrintStream { ps =>
           val lastLine = terminal.getLastLine.getOrElse("")
           ps.print(lastLine + ClearScreenAfterCursor)
           ps.flush()
         }
-      }
-    }
-  }
-}
+      end if
+    end if
+  end updateProgressState
+end ProgressState
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/Prompt.scala b/internal/util-logging/src/main/scala/sbt/internal/util/Prompt.scala
index ccd45801d..f2be5324a 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/Prompt.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/Prompt.scala
@@ -11,30 +11,25 @@ package sbt.internal.util
 import java.util.concurrent.LinkedBlockingQueue
 import scala.jdk.CollectionConverters.*
 
-private[sbt] sealed trait Prompt {
+private[sbt] sealed trait Prompt:
   def mkPrompt: () => String
   def render(): String
   def reset(): Unit
-}
 
-private[sbt] object Prompt {
-  private[sbt] case class AskUser(override val mkPrompt: () => String) extends Prompt {
+private[sbt] object Prompt:
+  private[sbt] case class AskUser(override val mkPrompt: () => String) extends Prompt:
     private val bytes = new LinkedBlockingQueue[Byte]
     def write(b: Array[Byte]): Unit = b.foreach(bytes.put)
-    override def render(): String = {
+    override def render(): String =
       val res = new String(bytes.asScala.toArray, "UTF-8")
-      if (res.endsWith(System.lineSeparator)) "" else res
-    }
+      if res.endsWith(System.lineSeparator) then "" else res
     override def reset(): Unit = bytes.clear()
-  }
-  private[sbt] trait NoPrompt extends Prompt {
+  private[sbt] trait NoPrompt extends Prompt:
     override val mkPrompt: () => String = () => ""
     override def render(): String = ""
     override def reset(): Unit = {}
-  }
   private[sbt] case object Running extends NoPrompt
   private[sbt] case object Batch extends NoPrompt
   private[sbt] case object Watch extends NoPrompt
   private[sbt] case object Pending extends NoPrompt
   private[sbt] case object NoPrompt extends NoPrompt
-}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/StackTrace.scala b/internal/util-logging/src/main/scala/sbt/internal/util/StackTrace.scala
index 5145718c2..eabe197db 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/StackTrace.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/StackTrace.scala
@@ -12,7 +12,7 @@ import sbt.io.IO
 import scala.collection.mutable.ListBuffer
 import java.util.{ IdentityHashMap, Collections }
 
-object StackTrace {
+object StackTrace:
   def isSbtClass(name: String) = name.startsWith("sbt.") || name.startsWith("xsbt.")
 
   /**
@@ -28,51 +28,47 @@ object StackTrace {
    *
    * See also ConsoleAppender where d <= 2 is treated specially by printing a prepared statement.
    */
-  def trimmedLines(t: Throwable, d: Int): List[String] = {
+  def trimmedLines(t: Throwable, d: Int): List[String] =
     require(d >= 0)
     val b = new ListBuffer[String]()
     val seen: java.util.Set[Throwable] =
       Collections.newSetFromMap(new IdentityHashMap[Throwable, java.lang.Boolean]())
 
-    def appendStackTrace(t: Throwable, first: Boolean): Unit = {
+    def appendStackTrace(t: Throwable, first: Boolean): Unit =
 
       val include: StackTraceElement => Boolean =
-        if (d == 0) element => !isSbtClass(element.getClassName)
-        else {
+        if d == 0 then element => !isSbtClass(element.getClassName)
+        else
           var count = d - 1
-          (_ => { count -= 1; count >= 0 })
-        }
+          (_ =>
+            count -= 1; count >= 0
+          )
 
-      def appendElement(e: StackTraceElement): Unit = {
+      def appendElement(e: StackTraceElement): Unit =
         b.append("\tat " + e)
         ()
-      }
 
-      if (!first) b.append("Caused by: " + t.toString)
+      if !first then b.append("Caused by: " + t.toString)
       else b.append(t.toString)
 
       val els = t.getStackTrace()
       var i = 0
-      while ((i < els.length) && include(els(i))) {
+      while (i < els.length) && include(els(i)) do
         appendElement(els(i))
         i += 1
-      }
-
-    }
+    end appendStackTrace
 
     appendStackTrace(t, true)
     seen.add(t)
     var c = t
-    while (c.getCause() != null && !seen.contains(c.getCause())) {
+    while c.getCause() != null && !seen.contains(c.getCause()) do
       c = c.getCause()
       seen.add(c)
       appendStackTrace(c, false)
-    }
-    if (c.getCause() != null && seen.contains(c.getCause())) {
+    if c.getCause() != null && seen.contains(c.getCause()) then
       b.append("[CIRCULAR REFERENCE: " + c.getCause().toString + "]")
-    }
     b.toList
-  }
+  end trimmedLines
 
   /**
    * Return a printable representation of the stack trace associated with t. Information about t and
@@ -87,4 +83,4 @@ object StackTrace {
    */
   def trimmed(t: Throwable, d: Int): String =
     trimmedLines(t, d).mkString(IO.Newline)
-}
+end StackTrace
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/Terminal.scala b/internal/util-logging/src/main/scala/sbt/internal/util/Terminal.scala
index bcbb63698..7eb77bd6c 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/Terminal.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/Terminal.scala
@@ -20,7 +20,7 @@ import scala.concurrent.duration.*
 import scala.util.Try
 import scala.util.control.NonFatal
 
-trait Terminal extends AutoCloseable {
+trait Terminal extends AutoCloseable:
 
   /**
    * Gets the current width of the terminal. The implementation reads a property from the jline
@@ -154,12 +154,12 @@ trait Terminal extends AutoCloseable {
   private[sbt] def setSize(width: Int, height: Int): Unit
 
   private[sbt] def name: String
-  private[sbt] final def withRawInput[T](f: => T): T = {
+  private[sbt] final def withRawInput[T](f: => T): T =
     enterRawMode()
-    try f
-    catch { case e: InterruptedIOException => throw new InterruptedException }
+    try
+      try f
+      catch case e: InterruptedIOException => throw new InterruptedException
     finally exitRawMode()
-  }
   private[sbt] def enterRawMode(): Unit
   private[sbt] def exitRawMode(): Unit
   private[sbt] def write(bytes: Int*): Unit
@@ -171,7 +171,7 @@ trait Terminal extends AutoCloseable {
   private val promptHolder: AtomicReference[Prompt] = new AtomicReference(Prompt.Batch)
   private[sbt] final def prompt: Prompt = promptHolder.get
   private[sbt] final def setPrompt(newPrompt: Prompt): Unit =
-    if (prompt != Prompt.NoPrompt) promptHolder.set(newPrompt)
+    if prompt != Prompt.NoPrompt then promptHolder.set(newPrompt)
 
   /**
    * Returns the number of lines that the input string will cover given the current width of the
@@ -182,16 +182,14 @@ trait Terminal extends AutoCloseable {
    * @return
    *   the number of lines that the line will cover on the terminal
    */
-  private[sbt] def lineCount(line: String): Int = {
+  private[sbt] def lineCount(line: String): Int =
     val lines = EscHelpers.stripColorsAndMoves(line).split('\n')
     val width = getWidth
-    def count(l: String): Int = {
+    def count(l: String): Int =
       val len = l.length
-      if (width > 0 && len > 0) (len - 1 + width) / width else 0
-    }
-    if (lines.nonEmpty) lines.tail.foldLeft(lines.headOption.fold(0)(count))(_ + count(_))
+      if width > 0 && len > 0 then (len - 1 + width) / width else 0
+    if lines.nonEmpty then lines.tail.foldLeft(lines.headOption.fold(0)(count))(_ + count(_))
     else 0
-  }
   private[sbt] def flush(): Unit = printStream.flush()
 
   private[sbt] def readArrow: Int = withRawInput {
@@ -199,28 +197,25 @@ trait Terminal extends AutoCloseable {
     val ESC = '\u001B'
     val EOT = '\u0004'
     def readBracket: Int =
-      in.read() match {
+      in.read() match
         case '[' => readAnsiControl
         case _   => 0
-      }
     def readAnsiControl: Int =
-      in.read() match {
+      in.read() match
         case 'A' => Terminal.VK_UP
         case 'B' => Terminal.VK_DOWN
         case 'C' => Terminal.VK_RIGHT
         case 'D' => Terminal.VK_LEFT
         case _   => 0
-      }
-    in.read() match {
+    in.read() match
       case ESC => readBracket
       // Ctrl+D to quit
       case EOT => -1
       case c   => c
-    }
   }
-}
+end Terminal
 
-object Terminal {
+object Terminal:
   private[sbt] final val VK_UP = 256
   private[sbt] final val VK_DOWN = 257
   private[sbt] final val VK_RIGHT = 258
@@ -228,26 +223,25 @@ object Terminal {
 
   val NO_BOOT_CLIENTS_CONNECTED: Int = -2
   // Disable noisy jline log spam
-  if (System.getProperty("sbt.jline.verbose", "false") != "true")
+  if System.getProperty("sbt.jline.verbose", "false") != "true" then
     jline.internal.Log.setOutput(new PrintStream(_ => {}, false))
   private val isCI = System.getProperty("sbt.ci", "") == "true" ||
     sys.env.contains("BUILD_NUMBER") || sys.env.contains("CI")
-  def consoleLog(string: String): Unit = {
+  def consoleLog(string: String): Unit =
     try Terminal.console.printStream.println(s"[info] $string")
-    catch { case _: IOException => }
-  }
+    catch
+      case _: IOException =>
 
   private val writeLock = new AnyRef
-  def withWriteLock[A](f: => A): A = {
+  def withWriteLock[A](f: => A): A =
     writeLock.synchronized {
       f
     }
-  }
 
   private[sbt] def set(terminal: Terminal): Terminal = activeTerminal.getAndSet(terminal)
-  extension (term: Terminal) {
+  extension (term: Terminal)
     def ansi(richString: => String, string: => String): String =
-      if (term.isAnsiSupported) richString else string
+      if term.isAnsiSupported then richString else string
     /*
      * Whenever we are dealing with JLine, which is true in sbt's ConsoleReader
      * as well as in the scala `console` task, we need to provide a jline.Terminal2
@@ -255,9 +249,9 @@ object Terminal {
      * already wraps a jline terminal, so we can just return the wrapped jline
      * terminal.
      */
-    private[sbt] def toJLine: jline.Terminal & jline.Terminal2 = term match {
+    private[sbt] def toJLine: jline.Terminal & jline.Terminal2 = term match
       case _ =>
-        new jline.Terminal with jline.Terminal2 {
+        new jline.Terminal with jline.Terminal2:
           override def init(): Unit = {}
           override def restore(): Unit = {}
           override def reset(): Unit = {}
@@ -279,21 +273,17 @@ object Terminal {
             term.getNumericCapability(capability)
           override def getStringCapability(capability: String): String =
             term.getStringCapability(capability)
-        }
-    }
-  }
+  end extension
 
   /*
    * Closes the standard input and output streams for the process. This allows
    * the sbt client to detach from the server it launches.
    */
-  def close(): Unit = {
-    if (!hasConsole) {
+  def close(): Unit =
+    if !hasConsole then
       originalOut.close()
       originalIn.close()
       originalErr.close()
-    }
-  }
 
   /**
    * Returns true if System.in is attached. When sbt is run as a subprocess, like in scripted or as
@@ -305,24 +295,21 @@ object Terminal {
    */
   def systemInIsAttached: Boolean = attached.get
 
-  def read: Int = inputStream.get match {
+  def read: Int = inputStream.get match
     case null => -1
     case is   => is.read
-  }
 
   /**
    * Returns an InputStream that will throw a [[ClosedChannelException]] if read returns -1.
    * @return
    *   the wrapped InputStream.
    */
-  private[sbt] def throwOnClosedSystemIn(in: InputStream): InputStream = new InputStream {
+  private[sbt] def throwOnClosedSystemIn(in: InputStream): InputStream = new InputStream:
     override def available(): Int = in.available()
-    override def read(): Int = in.read() match {
+    override def read(): Int = in.read() match
       case -1          => throw new ClosedChannelException
       case r if r >= 0 => r
       case _           => -1
-    }
-  }
 
   /**
    * Provides a wrapper around System.in. The wrapped stream in will check if the terminal is
@@ -342,14 +329,13 @@ object Terminal {
   private val hasProgress: AtomicBoolean = new AtomicBoolean(false)
 
   private[sbt] def parseLogOption(s: String): Option[Boolean] =
-    s.toLowerCase match {
+    s.toLowerCase match
       case "always" => Some(true)
       case "auto"   => None
       case "never"  => Some(false)
       case "true"   => Some(true)
       case "false"  => Some(false)
       case _        => None
-    }
 
   /**
    * Indicates whether formatting has been disabled in environment variables.
@@ -357,27 +343,23 @@ object Terminal {
    *      3. -Dsbt.colour=always/auto/never/true/false 4.
    * -Dsbt.log.format=always/auto/never/true/false
    */
-  private lazy val logFormatEnabled: Option[Boolean] = {
-    sys.props.get("sbt.log.noformat") match {
+  private lazy val logFormatEnabled: Option[Boolean] =
+    sys.props.get("sbt.log.noformat") match
       case Some(_) => Some(!java.lang.Boolean.getBoolean("sbt.log.noformat"))
       case _       => sys.props.get("sbt.log.format").flatMap(parseLogOption)
-    }
-  }
   private[sbt] lazy val isAnsiSupported: Boolean = logFormatEnabled.getOrElse(useColorDefault)
 
   private val isDumb = Some("dumb") == sys.env.get("TERM")
   private def isDumbTerminal = isDumb || System.getProperty("jline.terminal", "") == "none"
-  private[sbt] val hasConsole = {
+  private[sbt] val hasConsole =
     System.console != null && {
-      try {
+      try
         val isTerminal = System.console.getClass.getMethod("isTerminal")
         isTerminal.invoke(System.console).asInstanceOf[Boolean]
-      } catch {
+      catch
         case _: NoSuchMethodException =>
           true
-      }
     }
-  }
 
   /**
    * Pure function that determines whether color output should be enabled.
@@ -418,7 +400,7 @@ object Terminal {
   private[sbt] lazy val isColorEnabled = useColorDefault
 
   private[sbt] def red(str: String, doRed: Boolean): String =
-    if (isColorEnabled && doRed) Console.RED + str + Console.RESET
+    if isColorEnabled && doRed then Console.RED + str + Console.RESET
     else str
 
   private def hasVirtualIO = System.getProperty("sbt.io.virtual", "") == "true" || !isCI
@@ -434,18 +416,18 @@ object Terminal {
    * @return
    *   the result of the thunk
    */
-  private[sbt] def withStreams[T](isServer: Boolean, isSubProcess: Boolean)(f: => T): T = {
+  private[sbt] def withStreams[T](isServer: Boolean, isSubProcess: Boolean)(f: => T): T =
     // In ci environments, don't touch the io streams unless run with -Dsbt.io.virtual=true
-    if ((hasConsole && !isDumbTerminal) || isSubProcess)
+    if (hasConsole && !isDumbTerminal) || isSubProcess then
       consoleTerminalHolder.set(newConsoleTerminal())
-    if (hasVirtualIO) {
+    if hasVirtualIO then
       hasProgress.set(isServer && isAnsiSupported)
       Terminal.set(consoleTerminalHolder.get)
       try withOut(withIn(f))
-      finally {
+      finally
         jline.TerminalFactory.reset()
-        if (isServer) {
-          console match {
+        if isServer then
+          console match
             case c: ConsoleTerminal if !isWindows =>
               /*
                * Entering raw mode in this way causes the standard in InputStream
@@ -455,37 +437,34 @@ object Terminal {
                * this on a background thread in case the read blocks indefinitely.
                */
               c.system.enterRawMode()
-              val runnable: Runnable = () => {
+              val runnable: Runnable = () =>
                 try Util.ignoreResult(c.inputStream.read)
-                catch { case _: InterruptedException => }
-              }
+                catch
+                  case _: InterruptedException =>
               val thread = new Thread(runnable, "sbt-console-background-close")
               thread.setDaemon(true)
               thread.start()
               // The thread should exit almost instantly but give it 200ms to spin up
               thread.join(200)
-              if (thread.isAlive) thread.interrupt()
+              if thread.isAlive then thread.interrupt()
               c.close()
             case c => c.close()
-          }
-        } else {
-          console.close()
-        }
-      }
-    } else f
-  }
+        else console.close()
+        end if
+      end try
+    else f
+    end if
+  end withStreams
 
-  private object ProxyTerminal extends Terminal {
-    private def t: Terminal = {
+  private object ProxyTerminal extends Terminal:
+    private def t: Terminal =
       val current = activeTerminal.get
       // if the activeTerminal is yet to be initialized on use,
       // initialize to the conventional simple terminal for compatibility and testing
-      if (current ne null) current
-      else {
+      if current ne null then current
+      else
         Terminal.set(Terminal.SimpleTerminal)
         activeTerminal.get
-      }
-    }
     override private[sbt] def progressState: ProgressState = t.progressState
     override private[sbt] def enterRawMode(): Unit = t.enterRawMode()
     override private[sbt] def exitRawMode(): Unit = t.exitRawMode()
@@ -522,63 +501,55 @@ object Terminal {
     override def getLines: Seq[String] = t.getLines
     override private[sbt] def name: String = t.name
     override def toString: String = s"ProxyTerminal(current = $t)"
-  }
+  end ProxyTerminal
   private[sbt] def get: Terminal = ProxyTerminal
   private[sbt] def current: Terminal = activeTerminal.get
 
-  private[sbt] def withIn[T](in: InputStream)(f: => T): T = {
+  private[sbt] def withIn[T](in: InputStream)(f: => T): T =
     val original = inputStream.get
-    try {
+    try
       inputStream.set(in)
       System.setIn(in)
       scala.Console.withIn(in)(f)
-    } finally {
+    finally
       inputStream.set(original)
       System.setIn(original)
-    }
-  }
 
-  private[sbt] def withOut[T](out: PrintStream)(f: => T): T = {
+  private[sbt] def withOut[T](out: PrintStream)(f: => T): T =
     val originalOut = System.out
     val originalErr = System.err
     val originalProxyOut = ConsoleOut.getGlobalProxy
-    try {
+    try
       ConsoleOut.setGlobalProxy(ConsoleOut.printStreamOut(out))
       System.setOut(out)
       System.setErr(out)
       scala.Console.withErr(out)(scala.Console.withOut(out)(f))
-    } finally {
+    finally
       ConsoleOut.setGlobalProxy(originalProxyOut)
       System.setOut(originalOut)
       System.setErr(originalErr)
-    }
-  }
 
   val sepBytes = System.lineSeparator.getBytes("UTF-8")
-  private class LinePrintStream(outputStream: OutputStream)
-      extends PrintStream(outputStream, true) {
+  private class LinePrintStream(outputStream: OutputStream) extends PrintStream(outputStream, true):
     override def println(s: String): Unit = withWriteLock {
       out.write(s.getBytes("UTF-8") ++ sepBytes)
       out.flush()
     }
-  }
   private val originalOut = new LinePrintStream(System.out)
   private val originalErr = System.err
   private val originalIn = System.in
   private[sbt] class WriteableInputStream(in: InputStream, name: String)
       extends SimpleInputStream
-      with AutoCloseable {
+      with AutoCloseable:
     private val isRaw = new AtomicBoolean(false)
     final def write(bytes: Int*): Unit = buffer.synchronized {
       bytes.foreach(b => buffer.put(b))
     }
-    def setRawMode(toggle: Boolean): Unit = {
+    def setRawMode(toggle: Boolean): Unit =
       isRaw.set(toggle)
-      in match {
+      in match
         case win: WindowsInputStream => win.setRawMode(toggle)
         case _                       =>
-      }
-    }
     private val executor =
       Executors.newSingleThreadExecutor(r => new Thread(r, s"sbt-$name-input-reader"))
     private val buffer = new LinkedBlockingQueue[Integer]
@@ -596,76 +567,67 @@ object Terminal {
      * by setting the terminal to raw mode, which the input stream makes it non blocking,
      * but this approach only works on posix platforms.
      */
-    private val runnable: Runnable = () => {
-      @tailrec def impl(): Unit = {
+    private val runnable: Runnable = () =>
+      @tailrec def impl(): Unit =
         val _ = readQueue.take
         val b = in.read
         buffer.synchronized(buffer.put(b))
-        if (Thread.interrupted() || (b == -1 && isRaw.get)) closed.set(true)
+        if Thread.interrupted() || (b == -1 && isRaw.get) then closed.set(true)
         else impl()
-      }
       try impl()
-      catch { case _: InterruptedException => closed.set(true) }
-    }
+      catch case _: InterruptedException => closed.set(true)
     executor.submit(runnable)
     def read(result: LinkedBlockingQueue[Integer]): Unit =
-      if (!closed.get)
+      if !closed.get then
         readThread.synchronized {
           readThread.set(Thread.currentThread)
           try
-            buffer.poll match {
+            buffer.poll match
               case null =>
                 readQueue.put(())
                 result.put(buffer.take)
               case b if b == -1 => throw new ClosedChannelException
               case b            => result.put(b)
-            }
           finally readThread.set(null)
         }
-    override def read(): Int = {
+    override def read(): Int =
       val result = new LinkedBlockingQueue[Integer]
       read(result)
-      result.poll match {
+      result.poll match
         case null => -1
         case i    => i.toInt
-      }
-    }
     def cancel(): Unit = readThread.synchronized {
       Option(readThread.getAndSet(null)).foreach(_.interrupt())
       readQueue.clear()
     }
 
-    override def available(): Int = {
+    override def available(): Int =
       buffer.size
-    }
-    override def close(): Unit = if (closed.compareAndSet(false, true)) {
+    override def close(): Unit = if closed.compareAndSet(false, true) then
       executor.shutdownNow()
       buffer.synchronized(buffer.put(-1: Integer))
       ()
-    }
-  }
-  private def nonBlockingIn(term: org.jline.terminal.Terminal): WriteableInputStream = {
-    val in = if (Util.isNonCygwinWindows) new WindowsInputStream(term, originalIn) else originalIn
+  end WriteableInputStream
+  private def nonBlockingIn(term: org.jline.terminal.Terminal): WriteableInputStream =
+    val in =
+      if Util.isNonCygwinWindows then new WindowsInputStream(term, originalIn) else originalIn
     new WriteableInputStream(in, "console")
-  }
 
   private val inputStream = new AtomicReference[InputStream](System.in)
-  private def withOut[T](f: => T): T = {
-    try {
+  private def withOut[T](f: => T): T =
+    try
       System.setOut(proxyPrintStream)
       System.setErr(proxyErrorStream)
       scala.Console.withErr(proxyErrorStream)(scala.Console.withOut(proxyPrintStream)(f))
-    } finally {
+    finally
       System.setOut(originalOut)
       System.setErr(originalErr)
-    }
-  }
   private def withIn[T](f: => T): T =
-    try {
+    try
       inputStream.set(proxyInputStream)
       System.setIn(proxyInputStream)
       scala.Console.withIn(proxyInputStream)(f)
-    } finally System.setIn(originalIn)
+    finally System.setIn(originalIn)
 
   private[sbt] def withPrintStream[T](f: PrintStream => T): T = console.withPrintStream(f)
   private val attached = new AtomicBoolean(true)
@@ -708,23 +670,19 @@ object Terminal {
   private[sbt] def setBootStreams(
       bootInputStream: InputStream,
       bootOutputStream: OutputStream
-  ): Unit = {
+  ): Unit =
     bootInputStreamHolder.set(bootInputStream)
     bootOutputStreamHolder.set(bootOutputStream)
-  }
 
-  private[sbt] trait SimpleInputStream extends InputStream {
+  private[sbt] trait SimpleInputStream extends InputStream:
     override def read(b: Array[Byte]): Int = read(b, 0, b.length)
-    override def read(b: Array[Byte], off: Int, len: Int): Int = {
-      read() match {
+    override def read(b: Array[Byte], off: Int, len: Int): Int =
+      read() match
         case -1   => -1
         case byte =>
           b(off) = byte.toByte
           1
-      }
-    }
-  }
-  private object proxyInputStream extends SimpleInputStream {
+  private object proxyInputStream extends SimpleInputStream:
     private val isScripted = System.getProperty("sbt.scripted", "false") == "true"
     /*
      * This is to handle the case when a remote client starts sbt and the build fails.
@@ -736,98 +694,84 @@ object Terminal {
      * of the input streams and periodically interrupt the thread to switch between
      * the two input streams.
      */
-    private class ReadThread extends Thread with AutoCloseable {
+    private class ReadThread extends Thread with AutoCloseable:
       val result = new LinkedBlockingQueue[Integer]
       val running = new AtomicBoolean(true)
       setDaemon(true)
       start()
-      override def run(): Unit = while (running.get) {
-        bootInputStreamHolder.get match {
+      override def run(): Unit = while running.get do
+        bootInputStreamHolder.get match
           case null =>
           case is   =>
             def readFrom(inputStream: InputStream) =
-              try {
-                if (running.get) {
-                  inputStream.read match {
+              try
+                if running.get then
+                  inputStream.read match
                     case -1                          =>
                     case `NO_BOOT_CLIENTS_CONNECTED` =>
-                      if (!Terminal.hasConsole) {
+                      if !Terminal.hasConsole then
                         result.put(-1)
                         running.set(false)
-                      }
                     case i =>
                       result.put(i)
                       running.set(false)
-                  }
-                }
-              } catch { case _: InterruptedException => }
+              catch
+                case _: InterruptedException =>
             readFrom(is)
             readFrom(activeTerminal.get().inputStream)
-        }
-      }
-      override def close(): Unit = if (running.compareAndSet(true, false)) this.interrupt()
-    }
-    override def read(): Int = {
-      if (isScripted) -1
-      else if (bootInputStreamHolder.get == null) activeTerminal.get().inputStream.read()
-      else {
+      override def close(): Unit = if running.compareAndSet(true, false) then this.interrupt()
+    end ReadThread
+    override def read(): Int =
+      if isScripted then -1
+      else if bootInputStreamHolder.get == null then activeTerminal.get().inputStream.read()
+      else
         val thread = new ReadThread
-        @tailrec def poll(): Int = thread.result.poll(10, TimeUnit.MILLISECONDS) match {
+        @tailrec def poll(): Int = thread.result.poll(10, TimeUnit.MILLISECONDS) match
           case null =>
             thread.interrupt()
             poll()
           case i => i
-        }
         poll()
-      }
-    }
     override def available(): Int =
-      if (isScripted) 0
+      if isScripted then 0
       else
-        bootInputStreamHolder.get match {
+        bootInputStreamHolder.get match
           case null   => activeTerminal.get().inputStream.available()
           case stream => stream.available() + activeTerminal.get().inputStream.available()
-        }
-  }
-  private object proxyOutputStream extends OutputStream {
+  end proxyInputStream
+  private object proxyOutputStream extends OutputStream:
     private def os: OutputStream = activeTerminal.get().outputStream
-    def write(byte: Int): Unit = {
+    def write(byte: Int): Unit =
       os.write(byte)
       os.flush()
-      if (byte == 10) os.flush()
-    }
+      if byte == 10 then os.flush()
     override def write(bytes: Array[Byte]): Unit = write(bytes, 0, bytes.length)
-    override def write(bytes: Array[Byte], offset: Int, len: Int): Unit = {
+    override def write(bytes: Array[Byte], offset: Int, len: Int): Unit =
       os.write(bytes, offset, len)
       os.flush()
-    }
     override def flush(): Unit = os.flush()
-  }
-  private val proxyPrintStream = new LinePrintStream(proxyOutputStream) {
+  private val proxyPrintStream = new LinePrintStream(proxyOutputStream):
     override def toString: String = s"proxyPrintStream($proxyOutputStream)"
-  }
-  private object proxyErrorOutputStream extends OutputStream {
+  private object proxyErrorOutputStream extends OutputStream:
     private def os: OutputStream = activeTerminal.get().errorStream
     def write(byte: Int): Unit = os.write(byte)
     override def write(bytes: Array[Byte]): Unit = write(bytes, 0, bytes.length)
     override def write(bytes: Array[Byte], offset: Int, len: Int): Unit =
       os.write(bytes, offset, len)
     override def flush(): Unit = os.flush()
-  }
   private object proxyErrorStream extends PrintStream(proxyErrorOutputStream, true)
   private lazy val isWindows =
     System.getProperty("os.name", "").toLowerCase(Locale.ENGLISH).indexOf("windows") >= 0
-  private object WrappedSystemIn extends SimpleInputStream {
+  private object WrappedSystemIn extends SimpleInputStream:
     private val in = proxyInputStream
-    override def available(): Int = if (attached.get) in.available() else 0
+    override def available(): Int = if attached.get then in.available() else 0
     override def read(): Int = synchronized {
-      if (attached.get) {
+      if attached.get then
         val res = in.read()
-        if (res == -1) attached.set(false)
+        if res == -1 then attached.set(false)
         res
-      } else -1
+      else -1
     }
-  }
 
   /*
    * When the server is booted by a remote client, it may not be able to accurately
@@ -844,7 +788,7 @@ object Terminal {
   )
   private[sbt] val TERMINAL_PROPS = "SBT_TERMINAL_PROPS"
   private val props = sys.env.get(TERMINAL_PROPS) flatMap { p =>
-    p.split(",") match {
+    p.split(",") match
       case Array(width, height, ansi, color, supershell) =>
         Try(
           new Props(
@@ -856,29 +800,26 @@ object Terminal {
           )
         ).toOption
       case _ => None
-    }
   }
   private[sbt] def startedByRemoteClient = props.isDefined
 
-  private def newConsoleTerminal(): Terminal = {
+  private def newConsoleTerminal(): Terminal =
     val system = JLine3.system
     new ConsoleTerminal(nonBlockingIn(system), originalOut, system)
-  }
 
-  private[sbt] def reset(): Unit = {
+  private[sbt] def reset(): Unit =
     jline.TerminalFactory.reset()
     console.close()
-    if (hasConsole && !isDumbTerminal) consoleTerminalHolder.set(newConsoleTerminal())
-  }
+    if hasConsole && !isDumbTerminal then consoleTerminalHolder.set(newConsoleTerminal())
 
   // translate explicit class names to type in order to support
   //  older Scala, since it shaded classes but not the system property
-  private def fixTerminalProperty(): Unit = {
+  private def fixTerminalProperty(): Unit =
     val terminalProperty = "jline.terminal"
     val newValue =
-      if (!isAnsiSupported && System.getProperty("sbt.io.virtual", "") == "false") "none"
+      if !isAnsiSupported && System.getProperty("sbt.io.virtual", "") == "false" then "none"
       else
-        System.getProperty(terminalProperty) match {
+        System.getProperty(terminalProperty) match
           case "jline.UnixTerminal"                             => "unix"
           case null if System.getProperty("sbt.cygwin") != null => "unix"
           case "jline.WindowsTerminal"                          => "windows"
@@ -886,26 +827,20 @@ object Terminal {
           case "jline.UnsupportedTerminal"                      => "none"
           case null if isDumb                                   => "none"
           case x                                                => x
-        }
-    if (newValue != null) {
+    if newValue != null then
       System.setProperty(terminalProperty, newValue)
       ()
-    }
-  }
   fixTerminalProperty()
 
-  private[sbt] def createReader(term: Terminal, prompt: Prompt): ConsoleReader = {
-    new ConsoleReader(term.inputStream, term.outputStream, term.toJLine) {
+  private[sbt] def createReader(term: Terminal, prompt: Prompt): ConsoleReader =
+    new ConsoleReader(term.inputStream, term.outputStream, term.toJLine):
       override def readLine(prompt: String, mask: Character): String =
         term.withRawInput(super.readLine(prompt, mask))
       override def readLine(prompt: String): String = term.withRawInput(super.readLine(prompt))
-    }
-  }
 
-  def console: Terminal = consoleTerminalHolder.get match {
+  def console: Terminal = consoleTerminalHolder.get match
     case null => throw new IllegalStateException("Uninitialized terminal.")
     case term => term
-  }
 
   private val capabilityMap =
     org.jline.utils.InfoCmp.Capability.values().map(c => c.toString -> c).toMap
@@ -917,67 +852,62 @@ object Terminal {
       in: WriteableInputStream,
       out: OutputStream,
       private[util] val system: org.jline.terminal.Terminal,
-  ) extends TerminalImpl(in, out, originalErr, "console0") {
+  ) extends TerminalImpl(in, out, originalErr, "console0"):
     private val rawMode = new AtomicBoolean(false)
-    if (Util.isWindows && hasConsole) {
+    if Util.isWindows && hasConsole then
       // It is necessary to enter and exit raw mode in order to get the windows
       // console to echo input.
       enterRawMode()
       exitRawMode()
-    }
-    override private[sbt] def getSizeImpl: (Int, Int) = {
+    override private[sbt] def getSizeImpl: (Int, Int) =
       val size = system.getSize
       (size.getColumns, size.getRows)
-    }
     override lazy val isAnsiSupported: Boolean =
       !isDumbTerminal && Terminal.isAnsiSupported && !isCI
     override private[sbt] def progressState: ProgressState = consoleProgressState.get
     override def isSuccessEnabled: Boolean = true
     private lazy val echoEnabled: AtomicBoolean = new AtomicBoolean({
       try system.echo()
-      catch {
-        case _: InterruptedIOException => false
-      }
+      catch case _: InterruptedIOException => false
     })
     override def isEchoEnabled: Boolean = echoEnabled.get()
     override def setEchoEnabled(toggle: Boolean): Unit =
-      try {
+      try
         Util.ignoreResult(system.echo(toggle))
         echoEnabled.set(toggle)
-      } catch { case _: InterruptedIOException => }
+      catch
+        case _: InterruptedIOException =>
     override def getBooleanCapability(capability: String): Boolean =
       capabilityMap.get(capability).fold(false)(system.getBooleanCapability)
     override def getNumericCapability(capability: String): Integer =
       capabilityMap.get(capability).fold(null: Integer)(system.getNumericCapability)
-    override def getStringCapability(capability: String): String = {
+    override def getStringCapability(capability: String): String =
       val res = capabilityMap.get(capability).fold(null: String)(system.getStringCapability)
       res
-    }
     override private[sbt] def restore(): Unit = exitRawMode()
 
     override private[sbt] def getAttributes: Map[String, String] =
       Try(JLine3.toMap(system.getAttributes)).getOrElse(Map.empty)
-    override private[sbt] def setAttributes(attributes: Map[String, String]): Unit = {
+    override private[sbt] def setAttributes(attributes: Map[String, String]): Unit =
       system.setAttributes(JLine3.attributesFromMap(attributes))
       JLine3.setEnableProcessInput()
-    }
     override private[sbt] def setSize(width: Int, height: Int): Unit =
       system.setSize(new org.jline.terminal.Size(width, height))
 
     override def inputStream: InputStream = in
 
     override private[sbt] def enterRawMode(): Unit =
-      if (rawMode.compareAndSet(false, true) && hasConsole) {
+      if rawMode.compareAndSet(false, true) && hasConsole then
         in.setRawMode(true)
         try JLine3.enterRawMode(system)
-        catch { case _: java.io.IOError => }
-      }
+        catch
+          case _: java.io.IOError =>
     override private[sbt] def exitRawMode(): Unit =
-      if (rawMode.compareAndSet(true, false) && hasConsole) {
+      if rawMode.compareAndSet(true, false) && hasConsole then
         in.setRawMode(false)
         try JLine3.exitRawMode(system)
-        catch { case _: java.io.IOError => }
-      }
+        catch
+          case _: java.io.IOError =>
     override lazy val isColorEnabled: Boolean =
       props
         .map(_.color)
@@ -986,65 +916,59 @@ object Terminal {
     override lazy val isSupershellEnabled: Boolean =
       props
         .map(_.supershell)
-        .getOrElse(System.getProperty("sbt.supershell") match {
+        .getOrElse(System.getProperty("sbt.supershell") match
           case null =>
             !(sys.env.contains("BUILD_NUMBER") || sys.env
               .contains("CI")) && isColorEnabled && !Util.isEmacs
           case "true" => true
-          case _      => false
-        })
-    override def close(): Unit = {
-      try {
+          case _      => false)
+    override def close(): Unit =
+      try
         system.setAttributes(JLine3.initialAttributes.get)
         system.close()
         in.close()
-      } catch { case NonFatal(_) => }
+      catch
+        case NonFatal(_) =>
       super.close()
-    }
-  }
+  end ConsoleTerminal
   private[sbt] abstract class TerminalImpl private[sbt] (
       val in: WriteableInputStream,
       val out: OutputStream,
       override val errorStream: OutputStream,
       override private[sbt] val name: String
-  ) extends Terminal { self =>
+  ) extends Terminal:
+    self =>
     private[sbt] def getSizeImpl: (Int, Int)
     private val sizeRefreshPeriod = 1.second
     private val size =
       new AtomicReference[((Int, Int), Deadline)](((1, 1), Deadline.now - 1.day))
     private def setSize() = size.set((Try(getSizeImpl).getOrElse((1, 1)), Deadline.now))
-    private def getSize = size.get match {
+    private def getSize = size.get match
       case (s, d) if (d + sizeRefreshPeriod).isOverdue() =>
         setSize()
         size.get._1
       case (s, _) => s
-    }
     override def getWidth: Int = getSize._1
     override def getHeight: Int = getSize._2
     private val rawMode = new AtomicBoolean(false)
-    def throwIfClosed[R](f: => R): R = if (isStopped.get) throw new ClosedChannelException else f
+    def throwIfClosed[R](f: => R): R = if isStopped.get then throw new ClosedChannelException else f
     override def getLastLine: Option[String] = progressState.currentLine
     override def getLines: Seq[String] = progressState.getLines
 
-    private val combinedOutputStream = new OutputStream {
-      override def write(b: Int): Unit = {
+    private val combinedOutputStream = new OutputStream:
+      override def write(b: Int): Unit =
         Option(bootOutputStreamHolder.get).foreach(_.write(b))
         out.write(b)
-      }
-      override def write(b: Array[Byte]): Unit = {
+      override def write(b: Array[Byte]): Unit =
         write(b, 0, b.length)
-      }
-      override def write(b: Array[Byte], offset: Int, len: Int): Unit = {
+      override def write(b: Array[Byte], offset: Int, len: Int): Unit =
         Option(bootOutputStreamHolder.get).foreach(_.write(b, offset, len))
         out.write(b, offset, len)
-      }
-      override def flush(): Unit = {
+      override def flush(): Unit =
         Option(bootOutputStreamHolder.get).foreach(_.flush())
         out.flush()
-      }
-    }
 
-    override val outputStream = new OutputStream {
+    override val outputStream = new OutputStream:
       override def write(b: Int): Unit = throwIfClosed {
         write(Array((b & 0xff).toByte))
       }
@@ -1055,19 +979,18 @@ object Terminal {
         write(Arrays.copyOfRange(b, offset, offset + length))
       }
       override def flush(): Unit = combinedOutputStream.flush()
-    }
     private def doWrite(rawBytes: Array[Byte]): Unit = withPrintStream { ps =>
       val (toWrite, len) =
-        if (rawBytes.contains(27.toByte)) {
-          if (!self.isAnsiSupported || !self.isColorEnabled)
+        if rawBytes.contains(27.toByte) then
+          if !self.isAnsiSupported || !self.isColorEnabled then
             EscHelpers.strip(
               rawBytes,
               stripAnsi = !self.isAnsiSupported,
               stripColor = !self.isColorEnabled
             )
           else (rawBytes, rawBytes.length)
-        } else (rawBytes, rawBytes.length)
-      val bytes = if (len < toWrite.length) toWrite.take(len) else toWrite
+        else (rawBytes, rawBytes.length)
+      val bytes = if len < toWrite.length then toWrite.take(len) else toWrite
       progressState.write(TerminalImpl.this, bytes, ps, hasProgress.get && !rawMode.get)
     }
     override private[sbt] val printStream: PrintStream = new LinePrintStream(outputStream)
@@ -1076,37 +999,33 @@ object Terminal {
     private[sbt] def write(bytes: Int*): Unit = in.write(bytes*)
     private val isStopped = new AtomicBoolean(false)
 
-    override def getLineHeightAndWidth(line: String): (Int, Int) = getWidth match {
+    override def getLineHeightAndWidth(line: String): (Int, Int) = getWidth match
       case width if width > 0 =>
         val position = EscHelpers.cursorPosition(line)
         val count = (position + width - 1) / width
         (count, position - (math.max((count - 1), 0) * width))
       case _ => (0, 0)
-    }
 
-    private[sbt] def withRawOutput[R](f: => R): R = {
+    private[sbt] def withRawOutput[R](f: => R): R =
       rawMode.set(true)
       try f
       finally rawMode.set(false)
-    }
     private val rawPrintStream: PrintStream = new LinePrintStream(combinedOutputStream)
     override def withPrintStream[T](f: PrintStream => T): T =
       writeLock.synchronized(f(rawPrintStream))
 
-    override def close(): Unit = if (isStopped.compareAndSet(false, true)) {
-      in.close()
-    }
-  }
-  private lazy val nullInputStream: InputStream = () => {
+    override def close(): Unit = if isStopped.compareAndSet(false, true) then in.close()
+  end TerminalImpl
+  private lazy val nullInputStream: InputStream = () =>
     try this.synchronized(this.wait())
-    catch { case _: InterruptedException => }
+    catch
+      case _: InterruptedException =>
     -1
-  }
   private[sbt] class DefaultTerminal(
       val inputStream: InputStream,
       val outputStream: OutputStream,
       val errorStream: OutputStream
-  ) extends Terminal {
+  ) extends Terminal:
     override def close(): Unit = {}
     override private[sbt] def progressState: ProgressState = new ProgressState(1)
     override private[sbt] def enterRawMode(): Unit = {}
@@ -1134,5 +1053,5 @@ object Terminal {
     override private[sbt] def withPrintStream[T](f: PrintStream => T): T = f(printStream)
     override private[sbt] def write(bytes: Int*): Unit = {}
     override private[sbt] def withRawOutput[R](f: => R): R = f
-  }
-}
+  end DefaultTerminal
+end Terminal
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/WindowsInputStream.scala b/internal/util-logging/src/main/scala/sbt/internal/util/WindowsInputStream.scala
index a46595aab..b60330d27 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/WindowsInputStream.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/WindowsInputStream.scala
@@ -16,22 +16,18 @@ import org.jline.utils.InfoCmp.Capability
 import scala.annotation.tailrec
 import Terminal.SimpleInputStream
 
-private object WindowsSupport {
-  def getConsoleMode = {
+private object WindowsSupport:
+  def getConsoleMode =
     val console = Kernel32.GetStdHandle(Kernel32.STD_INPUT_HANDLE);
     val mode = new Array[Int](1);
-    if (Kernel32.GetConsoleMode(console, mode) == 0) -1 else mode.head
-  }
-  def setConsoleMode(mode: Int): Unit = {
+    if Kernel32.GetConsoleMode(console, mode) == 0 then -1 else mode.head
+  def setConsoleMode(mode: Int): Unit =
     val console = Kernel32.GetStdHandle(Kernel32.STD_INPUT_HANDLE);
     Kernel32.SetConsoleMode(console, mode)
     ()
-  }
-  def readConsoleInput(count: Int) = {
+  def readConsoleInput(count: Int) =
     val console = Kernel32.GetStdHandle(Kernel32.STD_INPUT_HANDLE);
     Kernel32.readConsoleInputHelper(console, 1, false)
-  }
-}
 /*
  * We need a special input stream for windows because special key events
  * like arrow keys are not reported by System.in. What makes this extra
@@ -45,23 +41,22 @@ private object WindowsSupport {
  * raw mode.
  */
 private[util] class WindowsInputStream(term: org.jline.terminal.Terminal, in: InputStream)
-    extends SimpleInputStream {
+    extends SimpleInputStream:
 
   private val RIGHT_ALT_PRESSED = 0x0001;
   private val LEFT_ALT_PRESSED = 0x0002;
   private val RIGHT_CTRL_PRESSED = 0x0004;
   private val LEFT_CTRL_PRESSED = 0x0008;
   private val SHIFT_PRESSED = 0x0010;
-  private def getCapability(cap: Capability): String = term.getStringCapability(cap) match {
+  private def getCapability(cap: Capability): String = term.getStringCapability(cap) match
     case null => null
     case c    => c.replace("\\E", "\u001B")
-  }
   /*
    * This function is a hybrid of jline 2 WindowsTerminal.readConsoleInput
    * and jline3 AbstractTerminal.getEscapeSequence.
    */
-  private def readConsoleInput(): Array[Byte] = {
-    WindowsSupport.readConsoleInput(1) match {
+  private def readConsoleInput(): Array[Byte] =
+    WindowsSupport.readConsoleInput(1) match
       case null   => Array.empty
       case events =>
         val sb = new StringBuilder();
@@ -71,26 +66,20 @@ private[util] class WindowsInputStream(term: org.jline.terminal.Terminal, in: In
           val isCtrl = (controlKeyState & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED)) > 0;
           val isAlt = (controlKeyState & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED)) > 0;
           val isShift = (controlKeyState & SHIFT_PRESSED) > 0;
-          if (keyEvent.keyDown) {
-            if (keyEvent.uchar > 0) {
-              if (
-                ((keyEvent.uchar >= '@' && keyEvent.uchar <= '_') || (keyEvent.uchar >= 'a' && keyEvent.uchar <= 'z'))
+          if keyEvent.keyDown then
+            if keyEvent.uchar > 0 then
+              if ((keyEvent.uchar >= '@' && keyEvent.uchar <= '_') || (keyEvent.uchar >= 'a' && keyEvent.uchar <= 'z'))
                 && isAlt && !isCtrl
-              ) {
-                sb.append('\u001B') // ESC
-              }
-              if (isShift && keyEvent.keyCode == 9) {
-                getCapability(Capability.key_btab) match {
+              then sb.append('\u001B') // ESC
+              if isShift && keyEvent.keyCode == 9 then
+                getCapability(Capability.key_btab) match
                   case null => sb.append(keyEvent.uchar)
                   case cap  => sb.append(cap)
-                }
-              } else {
-                sb.append(keyEvent.uchar)
-              }
-            } else {
+              else sb.append(keyEvent.uchar)
+            else
               // virtual keycodes: http://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
               // just add support for basic editing keys (no control state, no numpad keys)
-              val escapeSequence = keyEvent.keyCode match {
+              val escapeSequence = keyEvent.keyCode match
                 case 0x21 /* VK_PRIOR PageUp*/  => getCapability(Capability.key_ppage);
                 case 0x22 /* VK_NEXT PageDown*/ => getCapability(Capability.key_npage);
                 case 0x24 /* VK_HOME */         => getCapability(Capability.key_home)
@@ -119,36 +108,27 @@ private[util] class WindowsInputStream(term: org.jline.terminal.Terminal, in: In
                 case 0x2e /* VK_DELETE */ =>
                   Option(getCapability(Capability.key_dc)).getOrElse("\u001B[3~")
                 case _ => null
-              }
-              escapeSequence match {
+              escapeSequence match
                 case null =>
                 case es   => (0 until keyEvent.repeatCount.toInt).foreach(_ => sb.append(es))
-              }
-            }
-          } else {
+          else
             // key up event
             // support ALT+NumPad input method
-            if (keyEvent.keyCode == 0x12 /*VK_MENU ALT key*/ && keyEvent.uchar > 0) {
+            if keyEvent.keyCode == 0x12 /*VK_MENU ALT key*/ && keyEvent.uchar > 0 then
               sb.append(keyEvent.uchar);
-            }
-          }
+          end if
         }
         sb.toString().getBytes()
-    }
-  }
-  private val raw: InputStream = new SimpleInputStream {
+  private val raw: InputStream = new SimpleInputStream:
     val buffer = new LinkedBlockingQueue[Integer]
     @tailrec
-    override def read(): Int = {
-      buffer.poll match {
+    override def read(): Int =
+      buffer.poll match
         case null =>
           readConsoleInput().foreach(b => buffer.put(b & 0xff))
-          if (!Thread.interrupted) read() else throw new InterruptedException
+          if !Thread.interrupted then read() else throw new InterruptedException
         case b => b
-      }
-    }
-  }
   private val isRaw = new AtomicBoolean(true)
   private[sbt] def setRawMode(toggle: Boolean): Unit = isRaw.set(toggle)
-  override def read(): Int = if (isRaw.get) raw.read() else in.read()
-}
+  override def read(): Int = if isRaw.get then raw.read() else in.read()
+end WindowsInputStream
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/JValueFormats.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/JValueFormats.scala
index 443a18ff6..31a11dbfb 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/codec/JValueFormats.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/JValueFormats.scala
@@ -13,11 +13,11 @@ package util.codec
 import sjsonnew.{ JsonWriter as JW, JsonReader as JR, JsonFormat as JF, * }
 import sjsonnew.shaded.scalajson.ast.unsafe.*
 
-trait JValueFormats { self: sjsonnew.BasicJsonProtocol =>
-  given JNullFormat: JF[JNull.type] = new JF[JNull.type] {
+trait JValueFormats:
+  self: sjsonnew.BasicJsonProtocol =>
+  given JNullFormat: JF[JNull.type] = new JF[JNull.type]:
     def write[J](x: JNull.type, b: Builder[J]) = b.writeNull()
     def read[J](j: Option[J], u: Unbuilder[J]) = JNull
-  }
 
   given JBooleanFormat: JF[JBoolean] = projectFormat(_.get, (x: Boolean) => JBoolean(x))
   given JStringFormat: JF[JString] = projectFormat(_.value, (x: String) => JString(x))
@@ -28,34 +28,28 @@ trait JValueFormats { self: sjsonnew.BasicJsonProtocol =>
   given JArrayFormat(using JF[JValue]): JF[JArray] =
     projectFormat[JArray, Array[JValue]](_.value, JArray(_))
 
-  given JObjectJsonWriter: JW[JObject] = new JW[JObject] {
-    def write[J](x: JObject, b: Builder[J]) = {
+  given JObjectJsonWriter: JW[JObject] = new JW[JObject]:
+    def write[J](x: JObject, b: Builder[J]) =
       b.beginObject()
       x.value foreach (jsonField => JValueFormat.addField(jsonField.field, jsonField.value, b))
       b.endObject()
-    }
-  }
 
-  given JValueJsonWriter: JW[JValue] = new JW[JValue] {
-    def write[J](x: JValue, b: Builder[J]) = x match {
+  given JValueJsonWriter: JW[JValue] = new JW[JValue]:
+    def write[J](x: JValue, b: Builder[J]) = x match
       case x: JNull.type => JNullFormat.write(x, b)
       case x: JBoolean   => JBooleanFormat.write(x, b)
       case x: JString    => JStringFormat.write(x, b)
       case x: JNumber    => JNumberFormat.write(x, b)
       case x: JArray     => JArrayFormat.write(x, b)
       case x: JObject    => JObjectJsonWriter.write(x, b)
-    }
-  }
 
   // This passes through JValue, or returns JNull instead of blowing up with unimplemented.
-  given JValueJsonReader: JR[JValue] = new JR[JValue] {
-    def read[J](j: Option[J], u: Unbuilder[J]) = j match {
+  given JValueJsonReader: JR[JValue] = new JR[JValue]:
+    def read[J](j: Option[J], u: Unbuilder[J]) = j match
       case Some(x: JValue) => x
       case Some(x)         => sys.error(s"Unknown AST $x")
       case _               => JNull
-    }
-  }
 
   given JValueFormat: JF[JValue] =
     jsonFormat[JValue](JValueJsonReader, JValueJsonWriter)
-}
+end JValueFormats
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/PositionFormats.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/PositionFormats.scala
index d1009a048..61bae400d 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/codec/PositionFormats.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/PositionFormats.scala
@@ -12,10 +12,11 @@ import sjsonnew.{ deserializationError, Builder, JsonFormat, Unbuilder }
 import xsbti.Position
 import java.util.Optional
 
-trait PositionFormats { self: sjsonnew.BasicJsonProtocol =>
-  given PositionFormat: JsonFormat[Position] = new JsonFormat[Position] {
-    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Position = {
-      jsOpt match {
+trait PositionFormats:
+  self: sjsonnew.BasicJsonProtocol =>
+  given PositionFormat: JsonFormat[Position] = new JsonFormat[Position]:
+    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Position =
+      jsOpt match
         case Some(js) =>
           unbuilder.beginObject(js)
           val line0 = unbuilder.readField[Optional[java.lang.Integer]]("line")
@@ -33,7 +34,7 @@ trait PositionFormats { self: sjsonnew.BasicJsonProtocol =>
           val endColumn0 = unbuilder.readField[Optional[java.lang.Integer]]("endColumn")
 
           unbuilder.endObject()
-          new Position() {
+          new Position():
             override val line = line0
             override val lineContent = lineContent0
             override val offset = offset0
@@ -48,12 +49,9 @@ trait PositionFormats { self: sjsonnew.BasicJsonProtocol =>
             override val endLine = endLine0
             override val endColumn = endColumn0
 
-          }
         case None =>
           deserializationError("Expected JsObject but found None")
-      }
-    }
-    override def write[J](obj: Position, builder: Builder[J]): Unit = {
+    override def write[J](obj: Position, builder: Builder[J]): Unit =
       builder.beginObject()
       builder.addField("line", obj.line)
       builder.addField("lineContent", obj.lineContent)
@@ -70,6 +68,4 @@ trait PositionFormats { self: sjsonnew.BasicJsonProtocol =>
       builder.addField("endColumn", obj.endColumn)
 
       builder.endObject()
-    }
-  }
-}
+end PositionFormats
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/ProblemFormats.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/ProblemFormats.scala
index d73a13952..3fcbea4fe 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/codec/ProblemFormats.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/ProblemFormats.scala
@@ -12,10 +12,11 @@ import xsbti.{ Problem, Severity, Position }
 import _root_.sjsonnew.{ deserializationError, Builder, JsonFormat, Unbuilder }
 import java.util.Optional
 
-trait ProblemFormats { self: SeverityFormats & PositionFormats & sjsonnew.BasicJsonProtocol =>
-  given ProblemFormat: JsonFormat[Problem] = new JsonFormat[Problem] {
-    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Problem = {
-      jsOpt match {
+trait ProblemFormats:
+  self: SeverityFormats & PositionFormats & sjsonnew.BasicJsonProtocol =>
+  given ProblemFormat: JsonFormat[Problem] = new JsonFormat[Problem]:
+    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Problem =
+      jsOpt match
         case Some(js) =>
           unbuilder.beginObject(js)
           val category0 = unbuilder.readField[String]("category")
@@ -25,18 +26,15 @@ trait ProblemFormats { self: SeverityFormats & PositionFormats & sjsonnew.BasicJ
           val rendered0 = unbuilder.readField[Optional[String]]("rendered")
 
           unbuilder.endObject()
-          new Problem {
+          new Problem:
             override val category = category0
             override val position = position0
             override val message = message0
             override val severity = severity0
             override val rendered = rendered0
-          }
         case None =>
           deserializationError("Expected JsObject but found None")
-      }
-    }
-    override def write[J](obj: Problem, builder: Builder[J]): Unit = {
+    override def write[J](obj: Problem, builder: Builder[J]): Unit =
       builder.beginObject()
       builder.addField("category", obj.category)
       builder.addField("severity", obj.severity)
@@ -44,6 +42,4 @@ trait ProblemFormats { self: SeverityFormats & PositionFormats & sjsonnew.BasicJ
       builder.addField("position", obj.position)
       builder.addField("rendered", obj.rendered)
       builder.endObject()
-    }
-  }
-}
+end ProblemFormats
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/SeverityFormats.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/SeverityFormats.scala
index 19d16f636..5e8d3ed37 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/codec/SeverityFormats.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/SeverityFormats.scala
@@ -11,27 +11,21 @@ package sbt.internal.util.codec
 import _root_.sjsonnew.{ deserializationError, Builder, JsonFormat, Unbuilder }
 import xsbti.Severity;
 
-trait SeverityFormats { self: sjsonnew.BasicJsonProtocol =>
-  given SeverityFormat: JsonFormat[Severity] = new JsonFormat[Severity] {
-    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Severity = {
-      jsOpt match {
+trait SeverityFormats:
+  self: sjsonnew.BasicJsonProtocol =>
+  given SeverityFormat: JsonFormat[Severity] = new JsonFormat[Severity]:
+    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Severity =
+      jsOpt match
         case Some(js) =>
-          unbuilder.readString(js) match {
+          unbuilder.readString(js) match
             case "Info"  => Severity.Info
             case "Warn"  => Severity.Warn
             case "Error" => Severity.Error
-          }
         case None =>
           deserializationError("Expected JsString but found None")
-      }
-    }
-    override def write[J](obj: Severity, builder: Builder[J]): Unit = {
-      val str = obj match {
+    override def write[J](obj: Severity, builder: Builder[J]): Unit =
+      val str = obj match
         case Severity.Info  => "Info"
         case Severity.Warn  => "Warn"
         case Severity.Error => "Error"
-      }
       builder.writeString(str)
-    }
-  }
-}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/SuccessEventShowLines.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/SuccessEventShowLines.scala
index fdc67da39..3e52c140d 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/codec/SuccessEventShowLines.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/SuccessEventShowLines.scala
@@ -12,11 +12,8 @@ package internal.util.codec
 import sbt.util.ShowLines
 import sbt.internal.util.SuccessEvent
 
-trait SuccessEventShowLines {
+trait SuccessEventShowLines:
   given sbtSuccessEventShowLines: ShowLines[SuccessEvent] =
-    ShowLines[SuccessEvent]((e: SuccessEvent) => {
-      Vector(e.message)
-    })
-}
+    ShowLines[SuccessEvent]((e: SuccessEvent) => Vector(e.message))
 
 object SuccessEventShowLines extends SuccessEventShowLines
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/ThrowableShowLines.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/ThrowableShowLines.scala
index e25bf55d5..d2ddd4840 100644
--- a/internal/util-logging/src/main/scala/sbt/internal/util/codec/ThrowableShowLines.scala
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/ThrowableShowLines.scala
@@ -12,22 +12,20 @@ package internal.util.codec
 import sbt.util.ShowLines
 import sbt.internal.util.{ StackTrace, TraceEvent }
 
-trait ThrowableShowLines {
+trait ThrowableShowLines:
   given sbtThrowableShowLines: ShowLines[Throwable] =
-    ShowLines[Throwable]((t: Throwable) => {
+    ShowLines[Throwable]((t: Throwable) =>
       // 0 means enabled with default behavior. See StackTrace.scala.
       val traceLevel = 0
       List(StackTrace.trimmed(t, traceLevel))
-    })
-}
+    )
 
 object ThrowableShowLines extends ThrowableShowLines
 
-trait TraceEventShowLines {
+trait TraceEventShowLines:
   given sbtTraceEventShowLines: ShowLines[TraceEvent] =
-    ShowLines[TraceEvent]((t: TraceEvent) => {
+    ShowLines[TraceEvent]((t: TraceEvent) =>
       ThrowableShowLines.sbtThrowableShowLines.showLines(t.message)
-    })
-}
+    )
 
 object TraceEventShowLines extends TraceEventShowLines
diff --git a/internal/util-logging/src/main/scala/sbt/util/AbstractLogger.scala b/internal/util-logging/src/main/scala/sbt/util/AbstractLogger.scala
index 69a3de344..8c3e4408c 100644
--- a/internal/util-logging/src/main/scala/sbt/util/AbstractLogger.scala
+++ b/internal/util-logging/src/main/scala/sbt/util/AbstractLogger.scala
@@ -8,7 +8,7 @@
 
 package sbt.util
 
-abstract class AbstractLogger extends Logger {
+abstract class AbstractLogger extends Logger:
   def getLevel: Level.Value
   def setLevel(newLevel: Level.Value): Unit
   def setTrace(flag: Int): Unit
@@ -23,8 +23,8 @@ abstract class AbstractLogger extends Logger {
   def logAll(events: Seq[LogEvent]): Unit
 
   /** Defined in terms of other methods in Logger and should not be called from them. */
-  final def log(event: LogEvent): Unit = {
-    event match {
+  final def log(event: LogEvent): Unit =
+    event match
       case s: Success       => success(s.msg)
       case l: Log           => log(l.level, l.msg)
       case t: Trace         => trace(t.exception)
@@ -32,6 +32,4 @@ abstract class AbstractLogger extends Logger {
       case setT: SetTrace   => setTrace(setT.level)
       case setS: SetSuccess => setSuccessEnabled(setS.enabled)
       case c: ControlEvent  => control(c.event, c.msg)
-    }
-  }
-}
+end AbstractLogger
diff --git a/internal/util-logging/src/main/scala/sbt/util/InterfaceUtil.scala b/internal/util-logging/src/main/scala/sbt/util/InterfaceUtil.scala
index 1f866babb..e94950551 100644
--- a/internal/util-logging/src/main/scala/sbt/util/InterfaceUtil.scala
+++ b/internal/util-logging/src/main/scala/sbt/util/InterfaceUtil.scala
@@ -27,10 +27,9 @@ import xsbti.{
 
 import scala.collection.mutable.ListBuffer
 
-object InterfaceUtil {
-  def toSupplier[A](a: => A): Supplier[A] = new Supplier[A] {
+object InterfaceUtil:
+  def toSupplier[A](a: => A): Supplier[A] = new Supplier[A]:
     override def get: A = a
-  }
 
   import java.util.function.Function as JavaFunction
   def toJavaFunction[A1, R](f: A1 => R): JavaFunction[A1, R] =
@@ -39,35 +38,31 @@ object InterfaceUtil {
   def t2[A1, A2](x: (A1, A2)): T2[A1, A2] = new ConcreteT2(x._1, x._2)
 
   def toOption[A](m: Optional[A]): Option[A] =
-    if (m.isPresent) Some(m.get) else None
+    if m.isPresent then Some(m.get) else None
 
   def toOptional[A](o: Option[A]): Optional[A] =
-    o match {
+    o match
       case Some(v) => Optional.of(v)
       case None    => Optional.empty()
-    }
 
   def jo2o[A](o: Optional[A]): Option[A] =
-    if (o.isPresent) Some(o.get)
+    if o.isPresent then Some(o.get)
     else None
 
   def o2jo[A](o: Option[A]): Optional[A] =
-    o match {
+    o match
       case Some(v) => Optional.ofNullable(v)
       case None    => Optional.empty[A]()
-    }
 
-  def l2jl[A](l: List[A]): ju.List[A] = {
+  def l2jl[A](l: List[A]): ju.List[A] =
     val jl = new ju.ArrayList[A](l.size)
     l.foreach(jl.add(_))
     jl
-  }
 
-  def jl2l[A](jl: ju.List[A]): List[A] = {
+  def jl2l[A](jl: ju.List[A]): List[A] =
     val l = ListBuffer[A]()
     jl.forEach(l += _)
     l.toList
-  }
 
   def position(
       line0: Option[Integer],
@@ -144,21 +139,18 @@ object InterfaceUtil {
     new ConcreteDiagnosticRelatedInformation(position, message)
 
   private final class ConcreteT2[A1, A2](override val get1: A1, override val get2: A2)
-      extends T2[A1, A2] {
+      extends T2[A1, A2]:
     override def toString: String = s"ConcreteT2($get1, $get2)"
-    override def equals(o: Any): Boolean = o match {
+    override def equals(o: Any): Boolean = o match
       case o: ConcreteT2[?, ?] =>
         this.get1 == o.get1 &&
         this.get2 == o.get2
       case _ => false
-    }
-    override def hashCode: Int = {
+    override def hashCode: Int =
       var hash = 1
       hash = hash * 31 + this.get1.##
       hash = hash * 31 + this.get2.##
       hash
-    }
-  }
 
   private final class ConcretePosition(
       line0: Option[Integer],
@@ -174,7 +166,7 @@ object InterfaceUtil {
       startColumn0: Option[Integer],
       endLine0: Option[Integer],
       endColumn0: Option[Integer]
-  ) extends Position {
+  ) extends Position:
     val line = o2jo(line0)
     val lineContent = content
     val offset = o2jo(offset0)
@@ -188,21 +180,17 @@ object InterfaceUtil {
     override val startColumn = o2jo(startColumn0)
     override val endLine = o2jo(endLine0)
     override val endColumn = o2jo(endColumn0)
-    override def toString: String = {
-      val src = sourcePath0 match {
+    override def toString: String =
+      val src = sourcePath0 match
         case Some(x) => s"$x"
         case None    => "none"
-      }
-      val line = line0 match {
+      val line = line0 match
         case Some(x) => s":$x"
         case None    => ""
-      }
-      val offset = offset0 match {
+      val offset = offset0 match
         case Some(x) => s":$x"
         case None    => ""
-      }
       s"""$src$line$offset"""
-    }
     private def toTuple(p: Position) =
       (
         p.line,
@@ -220,11 +208,10 @@ object InterfaceUtil {
         p.endColumn,
       )
     override def hashCode: Int = toTuple(this).##
-    override def equals(o: Any): Boolean = o match {
+    override def equals(o: Any): Boolean = o match
       case o: Position => toTuple(this) == toTuple(o)
       case _           => false
-    }
-  }
+  end ConcretePosition
 
   private final class ConcreteProblem(
       override val category: String,
@@ -235,7 +222,7 @@ object InterfaceUtil {
       diagnosticCode0: Option[DiagnosticCode],
       diagnosticRelatedInformation0: List[DiagnosticRelatedInformation],
       actions0: List[Action],
-  ) extends Problem {
+  ) extends Problem:
     override val rendered = o2jo(rendered0)
     override def diagnosticCode: Optional[DiagnosticCode] = o2jo(diagnosticCode0)
     override def diagnosticRelatedInformation(): ju.List[DiagnosticRelatedInformation] =
@@ -258,17 +245,16 @@ object InterfaceUtil {
         p.actions,
       )
     override def hashCode: Int = toTuple(this).##
-    override def equals(o: Any): Boolean = o match {
+    override def equals(o: Any): Boolean = o match
       case o: Problem => toTuple(this) == toTuple(o)
       case _          => false
-    }
-  }
+  end ConcreteProblem
 
   private final class ConcreteAction(
       override val title: String,
       description0: Option[String],
       override val edit: WorkspaceEdit,
-  ) extends Action {
+  ) extends Action:
     override def description(): Optional[String] =
       o2jo(description0)
     override def toString(): String =
@@ -280,28 +266,24 @@ object InterfaceUtil {
         a.edit,
       )
     override def hashCode: Int = toTuple(this).##
-    override def equals(o: Any): Boolean = o match {
+    override def equals(o: Any): Boolean = o match
       case o: Action => toTuple(this) == toTuple(o)
       case _         => false
-    }
-  }
 
-  private final class ConcreteWorkspaceEdit(changes0: List[TextEdit]) extends WorkspaceEdit {
+  private final class ConcreteWorkspaceEdit(changes0: List[TextEdit]) extends WorkspaceEdit:
     override def changes(): ju.List[TextEdit] = l2jl(changes0)
     override def toString(): String =
       s"WorkspaceEdit($changes0)"
     private def toTuple(w: WorkspaceEdit) = jl2l(w.changes)
     override def hashCode: Int = toTuple(this).##
-    override def equals(o: Any): Boolean = o match {
+    override def equals(o: Any): Boolean = o match
       case o: WorkspaceEdit => toTuple(this) == toTuple(o)
       case _                => false
-    }
-  }
 
   private final class ConcreteTextEdit(
       override val position: Position,
       override val newText: String
-  ) extends TextEdit {
+  ) extends TextEdit:
     override def toString(): String =
       s"TextEdit($position, $newText)"
     private def toTuple(edit: TextEdit) =
@@ -310,16 +292,14 @@ object InterfaceUtil {
         edit.newText,
       )
     override def hashCode: Int = toTuple(this).##
-    override def equals(o: Any): Boolean = o match {
+    override def equals(o: Any): Boolean = o match
       case o: TextEdit => toTuple(this) == toTuple(o)
       case _           => false
-    }
-  }
 
   private final class ConcreteDiagnosticCode(
       override val code: String,
       explanation0: Option[String]
-  ) extends DiagnosticCode {
+  ) extends DiagnosticCode:
     val explanation: Optional[String] = o2jo(explanation0)
     override def toString(): String = s"DiagnosticCode($code)"
     private def toTuple(c: DiagnosticCode) =
@@ -328,16 +308,14 @@ object InterfaceUtil {
         c.explanation,
       )
     override def hashCode: Int = toTuple(this).##
-    override def equals(o: Any): Boolean = o match {
+    override def equals(o: Any): Boolean = o match
       case o: DiagnosticCode => toTuple(this) == toTuple(o)
       case _                 => false
-    }
-  }
 
   private final class ConcreteDiagnosticRelatedInformation(
       override val position: Position,
       override val message: String
-  ) extends DiagnosticRelatedInformation {
+  ) extends DiagnosticRelatedInformation:
     override def toString(): String = s"DiagnosticRelatedInformation($position, $message)"
     private def toTuple(info: DiagnosticRelatedInformation) =
       (
@@ -345,9 +323,7 @@ object InterfaceUtil {
         info.message,
       )
     override def hashCode: Int = toTuple(this).##
-    override def equals(o: Any): Boolean = o match {
+    override def equals(o: Any): Boolean = o match
       case o: DiagnosticRelatedInformation => toTuple(this) == toTuple(o)
       case _                               => false
-    }
-  }
-}
+end InterfaceUtil
diff --git a/internal/util-logging/src/main/scala/sbt/util/Level.scala b/internal/util-logging/src/main/scala/sbt/util/Level.scala
index 5e2fa1326..69e95b2ea 100644
--- a/internal/util-logging/src/main/scala/sbt/util/Level.scala
+++ b/internal/util-logging/src/main/scala/sbt/util/Level.scala
@@ -12,7 +12,7 @@ package sbt.util
  * An enumeration defining the levels available for logging. A level includes all of the levels with
  * id larger than its own id. For example, Warn (id=3) includes Error (id=4).
  */
-object Level extends Enumeration {
+object Level extends Enumeration:
   val Debug = Value(1, "debug")
   val Info = Value(2, "info")
   val Warn = Value(3, "warn")
@@ -24,7 +24,7 @@ object Level extends Enumeration {
    */
   val SuccessLabel = "success"
 
-  def union(a: Value, b: Value) = if (a.id < b.id) a else b
+  def union(a: Value, b: Value) = if a.id < b.id then a else b
   def unionAll(vs: Seq[Value]) = vs reduceLeft union
 
   /**
@@ -35,4 +35,4 @@ object Level extends Enumeration {
 
   /** Same as apply, defined for use in pattern matching. */
   private[sbt] def unapply(s: String) = apply(s)
-}
+end Level
diff --git a/internal/util-logging/src/main/scala/sbt/util/LogEvent.scala b/internal/util-logging/src/main/scala/sbt/util/LogEvent.scala
index 74068c0ff..3867296f1 100644
--- a/internal/util-logging/src/main/scala/sbt/util/LogEvent.scala
+++ b/internal/util-logging/src/main/scala/sbt/util/LogEvent.scala
@@ -17,10 +17,8 @@ final class SetTrace(val level: Int) extends LogEvent
 final class SetSuccess(val enabled: Boolean) extends LogEvent
 final class ControlEvent(val event: ControlEvent.Value, val msg: String) extends LogEvent
 
-object ControlEvent {
-  enum Value {
+object ControlEvent:
+  enum Value:
     case Start
     case Header
     case Finish
-  }
-}
diff --git a/internal/util-logging/src/main/scala/sbt/util/LogExchange.scala b/internal/util-logging/src/main/scala/sbt/util/LogExchange.scala
index bd1e0cbac..2d7ed30e7 100644
--- a/internal/util-logging/src/main/scala/sbt/util/LogExchange.scala
+++ b/internal/util-logging/src/main/scala/sbt/util/LogExchange.scala
@@ -12,26 +12,24 @@ import sbt.internal.util.{ Appender, ManagedLogger, TraceEvent, SuccessEvent }
 import sbt.internal.util.appmacro.StringTypeTag
 import scala.collection.concurrent
 
-sealed abstract class LogExchange {
+sealed abstract class LogExchange:
   private[sbt] val stringCodecs: concurrent.Map[String, ShowLines[?]] = concurrent.TrieMap()
   private[sbt] val builtInStringCodecs: Unit = initStringCodecs()
 
   def logger(name: String): ManagedLogger = logger(name, None, None)
   def logger(name: String, channelName: Option[String], execId: Option[String]): ManagedLogger =
     LoggerContext.globalContext.logger(name, channelName, execId)
-  def unbindLoggerAppenders(loggerName: String): Unit = {
+  def unbindLoggerAppenders(loggerName: String): Unit =
     LoggerContext.globalContext.clearAppenders(loggerName)
-  }
 
   def bindLoggerAppenders(
       loggerName: String,
       appenders: Seq[(Appender, Level.Value)]
-  ): Unit = {
+  ): Unit =
     appenders.foreach(LoggerContext.globalContext.addAppender(loggerName, _))
     ()
-  }
 
-  private[sbt] def initStringCodecs(): Unit = {
+  private[sbt] def initStringCodecs(): Unit =
     import sbt.internal.util.codec.SuccessEventShowLines.given
     import sbt.internal.util.codec.ThrowableShowLines.given
     import sbt.internal.util.codec.TraceEventShowLines.given
@@ -39,7 +37,6 @@ sealed abstract class LogExchange {
     registerStringCodec[Throwable]
     registerStringCodec[TraceEvent]
     registerStringCodec[SuccessEvent]
-  }
 
   def stringCodec[A](tag: String): Option[ShowLines[A]] =
     stringCodecs.get(tag) map { _.asInstanceOf[ShowLines[A]] }
@@ -48,10 +45,9 @@ sealed abstract class LogExchange {
   def getOrElseUpdateStringCodec[A](tag: String, v: ShowLines[A]): ShowLines[A] =
     stringCodecs.getOrElseUpdate(tag, v).asInstanceOf[ShowLines[A]]
 
-  private[sbt] def registerStringCodec[A: ShowLines: StringTypeTag]: Unit = {
+  private[sbt] def registerStringCodec[A: ShowLines: StringTypeTag]: Unit =
     val ev = implicitly[ShowLines[A]]
     val tag = implicitly[StringTypeTag[A]]
     val _ = getOrElseUpdateStringCodec(tag.key, ev)
-  }
-}
+end LogExchange
 object LogExchange extends LogExchange
diff --git a/internal/util-logging/src/main/scala/sbt/util/Logger.scala b/internal/util-logging/src/main/scala/sbt/util/Logger.scala
index 2c4253dcc..6d61fa3be 100644
--- a/internal/util-logging/src/main/scala/sbt/util/Logger.scala
+++ b/internal/util-logging/src/main/scala/sbt/util/Logger.scala
@@ -19,7 +19,7 @@ import java.util.function.Supplier
  * This is intended to be the simplest logging interface for use by code that wants to log. It does
  * not include configuring the logger.
  */
-abstract class Logger extends xLogger {
+abstract class Logger extends xLogger:
   final def verbose(message: => String): Unit = debug(message)
   final def debug(message: => String): Unit = log(Level.Debug, message)
   final def info(message: => String): Unit = log(Level.Info, message)
@@ -43,15 +43,14 @@ abstract class Logger extends xLogger {
   def trace(msg: Supplier[Throwable]): Unit = trace(msg.get())
   def success(msg: Supplier[String]): Unit = success(msg.get())
   def log(level: Level.Value, msg: Supplier[String]): Unit = log(level, msg.get)
-}
+end Logger
 
-object Logger {
-  def transferLevels(oldLog: AbstractLogger, newLog: AbstractLogger): Unit = {
+object Logger:
+  def transferLevels(oldLog: AbstractLogger, newLog: AbstractLogger): Unit =
     newLog.setLevel(oldLog.getLevel)
     newLog.setTrace(oldLog.getTrace)
-  }
 
-  val Null: AbstractLogger = new AbstractLogger {
+  val Null: AbstractLogger = new AbstractLogger:
     def getLevel: Level.Value = Level.Error
     def setLevel(newLevel: Level.Value): Unit = ()
     def getTrace: Int = 0
@@ -63,19 +62,17 @@ object Logger {
     def trace(t: => Throwable): Unit = ()
     def success(message: => String): Unit = ()
     def log(level: Level.Value, message: => String): Unit = ()
-  }
 
   implicit def absLog2PLog(log: AbstractLogger): ProcessLogger =
     new BufferedLogger(log) with ProcessLogger
 
   implicit def log2PLog(log: Logger): ProcessLogger = absLog2PLog(new FullLogger(log))
 
-  implicit def xlog2Log(lg: xLogger): Logger = lg match {
+  implicit def xlog2Log(lg: xLogger): Logger = lg match
     case l: Logger => l
     case _         => wrapXLogger(lg)
-  }
 
-  private def wrapXLogger(lg: xLogger): Logger = new Logger {
+  private def wrapXLogger(lg: xLogger): Logger = new Logger:
     import InterfaceUtil.toSupplier
     override def debug(msg: Supplier[String]): Unit = lg.debug(msg)
     override def warn(msg: Supplier[String]): Unit = lg.warn(msg)
@@ -85,17 +82,14 @@ object Logger {
     override def log(level: Level.Value, msg: Supplier[String]): Unit = lg.log(level, msg)
     def trace(t: => Throwable): Unit = trace(toSupplier(t))
     def success(s: => String): Unit = info(toSupplier(s))
-    def log(level: Level.Value, msg: => String): Unit = {
+    def log(level: Level.Value, msg: => String): Unit =
       val fmsg = toSupplier(msg)
-      level match {
+      level match
         case Level.Debug => lg.debug(fmsg)
         case Level.Info  => lg.info(fmsg)
         case Level.Warn  => lg.warn(fmsg)
         case Level.Error => lg.error(fmsg)
-      }
-    }
-  }
 
   def jo2o[A](o: Optional[A]): Option[A] = InterfaceUtil.jo2o(o)
   def o2jo[A](o: Option[A]): Optional[A] = InterfaceUtil.o2jo(o)
-}
+end Logger
diff --git a/internal/util-logging/src/main/scala/sbt/util/LoggerContext.scala b/internal/util-logging/src/main/scala/sbt/util/LoggerContext.scala
index b21784c31..a2fd902c4 100644
--- a/internal/util-logging/src/main/scala/sbt/util/LoggerContext.scala
+++ b/internal/util-logging/src/main/scala/sbt/util/LoggerContext.scala
@@ -21,7 +21,7 @@ import java.util.concurrent.atomic.{ AtomicReference, AtomicBoolean }
  * when it became clear that it was very difficult to manage the loggers and appenders without
  * introducing memory leaks.
  */
-sealed trait LoggerContext extends AutoCloseable {
+sealed trait LoggerContext extends AutoCloseable:
   def logger(name: String, channelName: Option[String], execId: Option[String]): ManagedLogger
   def clearAppenders(loggerName: String): Unit
   def addAppender(
@@ -30,83 +30,65 @@ sealed trait LoggerContext extends AutoCloseable {
   ): Unit
   def appenders(loggerName: String): Seq[Appender]
   def remove(name: String): Unit
-}
-object LoggerContext {
+object LoggerContext:
   private[sbt] lazy val globalContext: LoggerContext = new LoggerContext.LoggerContextImpl
 
-  private[util] class LoggerContextImpl extends LoggerContext {
-    private class Log extends MiniLogger {
+  private[util] class LoggerContextImpl extends LoggerContext:
+    private class Log extends MiniLogger:
       private val consoleAppenders: AtomicReference[Vector[(Appender, Level.Value)]] =
         new AtomicReference(Vector.empty)
-      def log(level: Level.Value, message: => String): Unit = {
+      def log(level: Level.Value, message: => String): Unit =
         val toAppend = consoleAppenders.get.filter { (a, l) => level.compare(l) >= 0 }
-        if (toAppend.nonEmpty) {
+        if toAppend.nonEmpty then
           val m = message
           toAppend.foreach { (a, l) => a.appendLog(level, m) }
-        }
-      }
-      def log[T](level: Level.Value, message: ObjectEvent[T]): Unit = {
+      def log[T](level: Level.Value, message: ObjectEvent[T]): Unit =
         consoleAppenders.get.foreach { (a, l) =>
-          if (level.compare(l) >= 0) a.appendObjectEvent(level, message)
+          if level.compare(l) >= 0 then a.appendObjectEvent(level, message)
         }
-      }
       def addAppender(newAppender: (Appender, Level.Value)): Unit =
         Util.ignoreResult(consoleAppenders.updateAndGet(_ :+ newAppender))
-      def clearAppenders(): Unit = {
+      def clearAppenders(): Unit =
         consoleAppenders.get.foreach { case (a, _) => a.close() }
         consoleAppenders.set(Vector.empty)
-      }
       def appenders: Seq[Appender] = consoleAppenders.get.map(_._1)
-    }
     private val loggers = new ConcurrentHashMap[String, Log]
     private val closed = new AtomicBoolean(false)
     override def logger(
         name: String,
         channelName: Option[String],
         execId: Option[String]
-    ): ManagedLogger = {
-      if (closed.get) {
+    ): ManagedLogger =
+      if closed.get then
         throw new IllegalStateException("Tried to create logger for closed LoggerContext")
-      }
       val xlogger = new Log
       loggers.put(name, xlogger)
       new ManagedLogger(name, channelName, execId, xlogger, Some(Terminal.get), this)
-    }
-    override def clearAppenders(loggerName: String): Unit = {
-      loggers.get(loggerName) match {
+    override def clearAppenders(loggerName: String): Unit =
+      loggers.get(loggerName) match
         case null =>
         case l    => l.clearAppenders()
-      }
-    }
     override def addAppender(
         loggerName: String,
         appender: (Appender, Level.Value)
-    ): Unit = {
-      if (closed.get) {
+    ): Unit =
+      if closed.get then
         throw new IllegalStateException("Tried to add appender for closed LoggerContext")
-      }
-      loggers.get(loggerName) match {
+      loggers.get(loggerName) match
         case null =>
         case l    => l.addAppender(appender)
-      }
-    }
-    override def appenders(loggerName: String): Seq[Appender] = {
-      loggers.get(loggerName) match {
+    override def appenders(loggerName: String): Seq[Appender] =
+      loggers.get(loggerName) match
         case null => Nil
         case l    => l.appenders
-      }
-    }
-    override def remove(name: String): Unit = {
-      loggers.remove(name) match {
+    override def remove(name: String): Unit =
+      loggers.remove(name) match
         case null =>
         case l    => l.clearAppenders()
-      }
-    }
-    def close(): Unit = {
+    def close(): Unit =
       closed.set(true)
       loggers.forEach((_, l) => l.clearAppenders())
       loggers.clear()
-    }
-  }
+  end LoggerContextImpl
   private[sbt] def apply() = new LoggerContextImpl
-}
+end LoggerContext
diff --git a/internal/util-logging/src/main/scala/sbt/util/ShowLines.scala b/internal/util-logging/src/main/scala/sbt/util/ShowLines.scala
index dc6417ad6..737c7dca7 100644
--- a/internal/util-logging/src/main/scala/sbt/util/ShowLines.scala
+++ b/internal/util-logging/src/main/scala/sbt/util/ShowLines.scala
@@ -8,14 +8,10 @@
 
 package sbt.util
 
-trait ShowLines[A] {
+trait ShowLines[A]:
   def showLines(a: A): Seq[String]
-}
-object ShowLines {
+object ShowLines:
   def apply[A](f: A => Seq[String]): ShowLines[A] =
     (a: A) => f(a)
 
-  extension [A: ShowLines](a: A) {
-    def lines: Seq[String] = implicitly[ShowLines[A]].showLines(a)
-  }
-}
+  extension [A: ShowLines](a: A) def lines: Seq[String] = implicitly[ShowLines[A]].showLines(a)
diff --git a/internal/util-logging/src/test/scala/Escapes.scala b/internal/util-logging/src/test/scala/Escapes.scala
index ead9e9c42..ad871dc5b 100644
--- a/internal/util-logging/src/test/scala/Escapes.scala
+++ b/internal/util-logging/src/test/scala/Escapes.scala
@@ -16,7 +16,7 @@ import EscHelpers.{ ESC, hasEscapeSequence, isEscapeTerminator, removeEscapeSequ
 
 import scala.annotation.tailrec
 
-object Escapes extends Properties("Escapes") {
+object Escapes extends Properties("Escapes"):
   property("genTerminator only generates terminators") =
     forAllNoShrink(genTerminator)((c: Char) => isEscapeTerminator(c))
 
@@ -69,39 +69,29 @@ object Escapes extends Properties("Escapes") {
           (original == removed)
     }
 
-  def diffIndex(expect: String, original: String): String = {
+  def diffIndex(expect: String, original: String): String =
     @tailrec
-    def loop(i: Int): Option[String] = {
-      if (i < expect.length && i < original.length) {
-        if (expect.charAt(i) != original.charAt(i)) {
+    def loop(i: Int): Option[String] =
+      if i < expect.length && i < original.length then
+        if expect.charAt(i) != original.charAt(i) then
           Some(
             "Differing character, idx: " + i + ", char: " + original.charAt(i) +
               ", expected: " + expect.charAt(i)
           )
-        } else {
-          loop(i + 1)
-        }
-      } else {
-        None
-      }
-    }
+        else loop(i + 1)
+      else None
     loop(0).getOrElse(
-      if (expect.length != original.length) {
-        "Strings are different lengths!"
-      } else {
-        "No differences found"
-      }
+      if expect.length != original.length then "Strings are different lengths!"
+      else "No differences found"
     )
-  }
 
-  final case class EscapeAndNot(escape: EscapeSequence, notEscape: String) {
+  final case class EscapeAndNot(escape: EscapeSequence, notEscape: String):
     override def toString =
       s"EscapeAntNot(escape = [$escape], notEscape = [${notEscape.map(_.toInt)}])"
-  }
 
   // 2.10.5 warns on "implicit numeric widening" but it looks like a bug: https://issues.scala-lang.org/browse/SI-8450
-  final case class EscapeSequence(content: String, terminator: Char) {
-    if (!content.isEmpty) {
+  final case class EscapeSequence(content: String, terminator: Char):
+    if !content.isEmpty then
       assert(
         content.tail.forall(c => !isEscapeTerminator(c)),
         "Escape sequence content contains an escape terminator: '" + content + "'"
@@ -110,14 +100,12 @@ object Escapes extends Properties("Escapes") {
         (content.head == '[') || !isEscapeTerminator(content.head),
         "Escape sequence content contains an escape terminator: '" + content.headOption + "'"
       )
-    }
     assert(isEscapeTerminator(terminator))
     def makeString: String = s"$ESC$content$terminator"
 
     override def toString =
-      if (content.isEmpty) s"ESC (${terminator.toInt})"
+      if content.isEmpty then s"ESC (${terminator.toInt})"
       else s"ESC ($content) (${terminator.toInt})"
-  }
 
   private def noEscape(s: String): String = s.replace(ESC, ' ')
 
@@ -125,13 +113,13 @@ object Escapes extends Properties("Escapes") {
     oneOf(genKnownSequence, genTwoCharacterSequence, genArbitraryEscapeSequence)
 
   lazy val genEscapePair: Gen[EscapeAndNot] =
-    for (esc <- genEscapeSequence; not <- genWithoutEscape) yield EscapeAndNot(esc, not)
+    for esc <- genEscapeSequence; not <- genWithoutEscape yield EscapeAndNot(esc, not)
 
   lazy val genEscapePairs: Gen[List[EscapeAndNot]] = listOf(genEscapePair)
 
   lazy val genArbitraryEscapeSequence: Gen[EscapeSequence] =
-    for (content <- genWithoutTerminator if !content.isEmpty; term <- genTerminator)
-      yield new EscapeSequence("[" + content, term)
+    for content <- genWithoutTerminator if !content.isEmpty; term <- genTerminator
+    yield new EscapeSequence("[" + content, term)
 
   lazy val genKnownSequence: Gen[EscapeSequence] =
     oneOf((misc ++ setGraphicsMode ++ setMode ++ resetMode).map(toEscapeSequence))
@@ -141,8 +129,8 @@ object Escapes extends Properties("Escapes") {
   lazy val misc = Seq("14;23H", "5;3f", "2A", "94B", "19C", "85D", "s", "u", "2J", "K")
 
   lazy val setGraphicsMode: Seq[String] =
-    for (txt <- 0 to 8; fg <- 30 to 37; bg <- 40 to 47)
-      yield txt.toString + ";" + fg.toString + ";" + bg.toString + "m"
+    for txt <- 0 to 8; fg <- 30 to 37; bg <- 40 to 47
+    yield txt.toString + ";" + fg.toString + ";" + bg.toString + "m"
 
   lazy val resetMode = setModeLike('I')
   lazy val setMode = setModeLike('h')
@@ -159,8 +147,8 @@ object Escapes extends Properties("Escapes") {
   lazy val genWithoutEscape: Gen[String] = genRawString.map(noEscape)
 
   def genWithRandomEscapes: Gen[String] =
-    for (ls <- listOf(genRawString); end <- genRawString)
-      yield ls.mkString("", ESC.toString, ESC.toString + end)
+    for ls <- listOf(genRawString); end <- genRawString
+    yield ls.mkString("", ESC.toString, ESC.toString + end)
 
   private def genRawString = Arbitrary.arbString.arbitrary
-}
+end Escapes
diff --git a/internal/util-logging/src/test/scala/LogWriterTest.scala b/internal/util-logging/src/test/scala/LogWriterTest.scala
index b5f0eec4d..f8ce77e97 100644
--- a/internal/util-logging/src/test/scala/LogWriterTest.scala
+++ b/internal/util-logging/src/test/scala/LogWriterTest.scala
@@ -16,7 +16,7 @@ import Prop.*
 
 import java.io.Writer
 
-object LogWriterTest extends Properties("Log Writer") {
+object LogWriterTest extends Properties("Log Writer"):
   final val MaxLines = 100
   final val MaxSegments = 10
 
@@ -37,27 +37,22 @@ object LogWriterTest extends Properties("Log Writer") {
    * `Log` types and non-printable characters should be escaped
    */
   def show(event: LogEvent): String =
-    event match {
+    event match
       case l: Log => "Log('" + Escape(l.msg) + "', " + l.level + ")"
       case _      => "Not Log"
-    }
 
   /**
    * Writes the given lines to the Writer. `lines` is taken to be a list of lines, which are
    * represented as separately written segments (ToLog instances). ToLog.`byCharacter` indicates
    * whether to write the segment by character (true) or all at once (false)
    */
-  def logLines(writer: Writer, lines: List[List[ToLog]], newLine: String): Unit = {
-    for (line <- lines; section <- line) {
+  def logLines(writer: Writer, lines: List[List[ToLog]], newLine: String): Unit =
+    for line <- lines; section <- line do
       val content = section.content
       val normalized = Escape.newline(content, newLine)
-      if (section.byCharacter)
-        normalized.foreach(c => writer.write(c.toInt))
-      else
-        writer.write(normalized)
-    }
+      if section.byCharacter then normalized.foreach(c => writer.write(c.toInt))
+      else writer.write(normalized)
     writer.flush()
-  }
 
   /**
    * Converts the given lines in segments to lines as Strings for checking the results of the test.
@@ -85,23 +80,22 @@ object LogWriterTest extends Properties("Log Writer") {
   implicit lazy val arbLevel: Arbitrary[Level.Value] = Arbitrary(genLevel)
 
   implicit def genLine(using logG: Gen[ToLog]): Gen[List[ToLog]] =
-    for (l <- listOf[ToLog](MaxSegments); last <- logG)
-      yield (addNewline(last) :: l.filter(!_.content.isEmpty)).reverse
+    for l <- listOf[ToLog](MaxSegments); last <- logG
+    yield (addNewline(last) :: l.filter(!_.content.isEmpty)).reverse
 
   implicit def genLog(using content: Arbitrary[String], byChar: Arbitrary[Boolean]): Gen[ToLog] =
-    for (c <- content.arbitrary; by <- byChar.arbitrary) yield {
+    for c <- content.arbitrary; by <- byChar.arbitrary yield
       assert(c != null)
       new ToLog(removeNewlines(c), by)
-    }
 
   given genNewLine: Gen[NewLine] =
-    for (str <- oneOf("\n", "\r", "\r\n")) yield new NewLine(str)
+    for str <- oneOf("\n", "\r", "\r\n") yield new NewLine(str)
 
   given genLevel: Gen[Level.Value] =
     oneOf(Level.values.toSeq)
 
   given genOutput: Gen[Output] =
-    for (ls <- listOf[List[ToLog]](MaxLines); lv <- genLevel) yield new Output(ls, lv)
+    for ls <- listOf[List[ToLog]](MaxLines); lv <- genLevel yield new Output(ls, lv)
 
   def removeNewlines(s: String) = s.replaceAll("""[\n\r]+""", "")
   def addNewline(l: ToLog): ToLog =
@@ -112,63 +106,54 @@ object LogWriterTest extends Properties("Log Writer") {
 
   def listOf[T](max: Int)(using content: Arbitrary[T]): Gen[List[T]] =
     Gen.choose(0, max) flatMap (sz => listOfN(sz, content.arbitrary))
-}
+end LogWriterTest
 
 /* Helper classes*/
 
-final class Output(val lines: List[List[ToLog]], val level: Level.Value) {
+final class Output(val lines: List[List[ToLog]], val level: Level.Value):
   override def toString =
     "Level: " + level + "\n" + lines.map(_.mkString).mkString("\n")
-}
 
-final class NewLine(val str: String) {
+final class NewLine(val str: String):
   override def toString = Escape(str)
-}
 
-final class ToLog(val content: String, val byCharacter: Boolean) {
+final class ToLog(val content: String, val byCharacter: Boolean):
   def contentOnly = Escape.newline(content, "")
 
   override def toString =
-    if (content.isEmpty) "" else "ToLog('" + Escape(contentOnly) + "', " + byCharacter + ")"
-}
+    if content.isEmpty then "" else "ToLog('" + Escape(contentOnly) + "', " + byCharacter + ")"
 
 /** Defines some utility methods for escaping unprintable characters. */
-object Escape {
+object Escape:
 
   /** Escapes characters with code less than 20 by printing them as unicode escapes. */
-  def apply(s: String): String = {
+  def apply(s: String): String =
     val builder = new StringBuilder(s.length)
-    for (c <- s) {
+    for c <- s do
       val char = c.toInt
       def escaped = pad(char.toHexString.toUpperCase, 4, '0')
-      if (c < 20) builder.append("\\u").append(escaped) else builder.append(c)
-    }
+      if c < 20 then builder.append("\\u").append(escaped) else builder.append(c)
     builder.toString
-  }
 
-  def pad(s: String, minLength: Int, extra: Char) = {
+  def pad(s: String, minLength: Int, extra: Char) =
     val diff = minLength - s.length
-    if (diff <= 0) s else List.fill(diff)(extra).mkString("", "", s)
-  }
+    if diff <= 0 then s else List.fill(diff)(extra).mkString("", "", s)
 
   /** Replaces a \n character at the end of a string `s` with `nl`. */
   def newline(s: String, nl: String): String =
-    if (s.endsWith("\n")) s.substring(0, s.length - 1) + nl else s
-
-}
+    if s.endsWith("\n") then s.substring(0, s.length - 1) + nl else s
 
 /** Records logging events for later retrieval. */
-final class RecordingLogger extends BasicLogger {
+final class RecordingLogger extends BasicLogger:
   private var events: List[LogEvent] = Nil
 
   def getEvents = events.reverse
 
   def ansiCodesSupported = true
-  def trace(t: => Throwable): Unit = { events ::= new Trace(t) }
-  def log(level: Level.Value, message: => String): Unit = { events ::= new Log(level, message) }
-  def success(message: => String): Unit = { events ::= new Success(message) }
-  def logAll(es: Seq[LogEvent]): Unit = { events :::= es.toList }
+  def trace(t: => Throwable): Unit = events ::= new Trace(t)
+  def log(level: Level.Value, message: => String): Unit = events ::= new Log(level, message)
+  def success(message: => String): Unit = events ::= new Success(message)
+  def logAll(es: Seq[LogEvent]): Unit = events :::= es.toList
 
   def control(event: ControlEvent.Value, message: => String): Unit =
     events ::= new ControlEvent(event, message)
-}
diff --git a/internal/util-logging/src/test/scala/ProblemTest.scala b/internal/util-logging/src/test/scala/ProblemTest.scala
index 2164fb393..a57dda41f 100644
--- a/internal/util-logging/src/test/scala/ProblemTest.scala
+++ b/internal/util-logging/src/test/scala/ProblemTest.scala
@@ -15,7 +15,7 @@ import _root_.sbt.util.InterfaceUtil
 import InterfaceUtil.{ jl2l, jo2o, l2jl }
 import xsbti.*
 
-object ProblemTest extends Properties {
+object ProblemTest extends Properties:
   override def tests: List[Test] = List(
     property(
       "All problems can toString",
@@ -42,7 +42,7 @@ object ProblemTest extends Properties {
   def toStringCheck(p: Problem): Result =
     Result.assert(p.toString() != "")
 
-  def equalityCheck(p: Problem): Result = {
+  def equalityCheck(p: Problem): Result =
     val other = InterfaceUtil.problem(
       p.category,
       p.position,
@@ -56,25 +56,21 @@ object ProblemTest extends Properties {
     Result
       .assert(p == other)
       .log(s"$p == $other")
-  }
 
-  def equalityCheck(c: DiagnosticCode): Result = {
+  def equalityCheck(c: DiagnosticCode): Result =
     val other = copy(c)
     Result.assert(c == other)
-  }
 
-  def equalityCheck(info: DiagnosticRelatedInformation): Result = {
+  def equalityCheck(info: DiagnosticRelatedInformation): Result =
     val other = copy(info)
     Result.assert(info == other)
-  }
 
-  def equalityCheck(a: Action): Result = {
+  def equalityCheck(a: Action): Result =
     val other = copy(a)
     Result.assert(a == other)
-  }
 
   lazy val genProblem: Gen[Problem] =
-    for {
+    for
       cat <- genString
       pos <- genPosition
       msg <- genString
@@ -83,7 +79,7 @@ object ProblemTest extends Properties {
       code <- optDiagnosticCode
       info <- listDiagnosticRelatedInformation
       actions <- listAction
-    } yield InterfaceUtil.problem(
+    yield InterfaceUtil.problem(
       cat,
       pos,
       msg,
@@ -98,19 +94,18 @@ object ProblemTest extends Properties {
     Gen.choice1(genDiagnosticCode.map(Some(_)), Gen.constant(None))
 
   lazy val genDiagnosticCode: Gen[DiagnosticCode] =
-    for {
-      code <- Gen.int(Range.linear(0, 1024))
-    } yield InterfaceUtil.diagnosticCode("E" + code.toString, None)
+    for code <- Gen.int(Range.linear(0, 1024))
+    yield InterfaceUtil.diagnosticCode("E" + code.toString, None)
 
   lazy val genSeverity: Gen[Severity] =
     Gen.element(Severity.Info, List(Severity.Warn, Severity.Error))
 
   lazy val genPosition: Gen[Position] =
-    for {
+    for
       line <- optIntGen
       content <- genString
       offset <- optIntGen
-    } yield InterfaceUtil.position(
+    yield InterfaceUtil.position(
       line,
       content,
       offset,
@@ -130,39 +125,37 @@ object ProblemTest extends Properties {
     Gen.list(genDiagnosticRelatedInformation, Range.linear(0, 2))
 
   lazy val genDiagnosticRelatedInformation: Gen[DiagnosticRelatedInformation] =
-    for {
+    for
       pos <- genPosition
       message <- genString
-    } yield InterfaceUtil.diagnosticRelatedInformation(pos, message)
+    yield InterfaceUtil.diagnosticRelatedInformation(pos, message)
 
   lazy val listAction: Gen[List[Action]] =
     Gen.list(genAction, Range.linear(0, 2))
 
   lazy val genAction: Gen[Action] =
-    for {
+    for
       title <- genString
       description <- optString
       edit <- genWorkspaceEdit
-    } yield InterfaceUtil.action(title, description, edit)
+    yield InterfaceUtil.action(title, description, edit)
 
   lazy val genWorkspaceEdit: Gen[WorkspaceEdit] =
-    for {
-      changes <- listTextEdit
-    } yield InterfaceUtil.workspaceEdit(changes)
+    for changes <- listTextEdit
+    yield InterfaceUtil.workspaceEdit(changes)
 
   lazy val listTextEdit: Gen[List[TextEdit]] =
     Gen.list(genTextEdit, Range.linear(0, 2))
 
   lazy val genTextEdit: Gen[TextEdit] =
-    for {
+    for
       pos <- genPosition
       newText <- genString
-    } yield InterfaceUtil.textEdit(pos, newText)
+    yield InterfaceUtil.textEdit(pos, newText)
 
   lazy val genUri: Gen[URI] =
-    for {
-      ssp <- genString
-    } yield new URI("file", "///" + ssp, null)
+    for ssp <- genString
+    yield new URI("file", "///" + ssp, null)
 
   lazy val optString: Gen[Option[String]] =
     Gen.choice1(genString.map(Some(_)), Gen.constant(None))
@@ -173,30 +166,26 @@ object ProblemTest extends Properties {
     Gen.choice1(Gen.int(Range.linear(0, 1024)).map(Some(_)), Gen.constant(None))
 
   private def copy(c: DiagnosticCode): DiagnosticCode =
-    new DiagnosticCode() {
+    new DiagnosticCode():
       val code = c.code
       override def explanation = c.explanation
-    }
 
   private def copy(info: DiagnosticRelatedInformation): DiagnosticRelatedInformation =
-    new DiagnosticRelatedInformation() {
+    new DiagnosticRelatedInformation():
       override def position = info.position
       override def message = info.message
-    }
 
   private def copy(a: Action): Action =
-    new Action {
+    new Action:
       override def title = a.title
       override def description = a.description
       override def edit = copy(a.edit)
-    }
 
   private def copy(edit: WorkspaceEdit): WorkspaceEdit =
     () => l2jl(jl2l(edit.changes).map(copy))
 
   private def copy(edit: TextEdit): TextEdit =
-    new TextEdit {
+    new TextEdit:
       override val position = edit.position
       override val newText = edit.newText
-    }
-}
+end ProblemTest
diff --git a/internal/util-logging/src/test/scala/TestLogger.scala b/internal/util-logging/src/test/scala/TestLogger.scala
index 80e46c8b6..7403c4061 100644
--- a/internal/util-logging/src/test/scala/TestLogger.scala
+++ b/internal/util-logging/src/test/scala/TestLogger.scala
@@ -10,10 +10,8 @@ package sbt.internal.util
 
 import sbt.util.*
 
-object TestLogger {
-  def apply[T](f: Logger => T): T = {
+object TestLogger:
+  def apply[T](f: Logger => T): T =
     val log = new BufferedLogger(ConsoleLogger())
     log.setLevel(Level.Debug)
     log.bufferQuietly(f(log))
-  }
-}
diff --git a/internal/util-logging/src/test/scala/sbt/internal/util/CleanStringSpec.scala b/internal/util-logging/src/test/scala/sbt/internal/util/CleanStringSpec.scala
index 9d459fc9a..0e54aa84a 100644
--- a/internal/util-logging/src/test/scala/sbt/internal/util/CleanStringSpec.scala
+++ b/internal/util-logging/src/test/scala/sbt/internal/util/CleanStringSpec.scala
@@ -10,7 +10,7 @@ package sbt.internal.util
 
 import verify.BasicTestSuite
 
-object CleanStringSpec extends BasicTestSuite {
+object CleanStringSpec extends BasicTestSuite:
   test("EscHelpers should not modify normal strings") {
     val cleanString = s"1234"
     assert(EscHelpers.stripColorsAndMoves(cleanString) == cleanString)
@@ -108,4 +108,4 @@ object CleanStringSpec extends BasicTestSuite {
     val expected2 = "[info] + com.acme.CoyoteTest.makeTrap 9ms  \n"
     assert(new String(bytes2, 0, len2) == expected2)
   }
-}
+end CleanStringSpec
diff --git a/internal/util-logging/src/test/scala/sbt/internal/util/TerminalColorSpec.scala b/internal/util-logging/src/test/scala/sbt/internal/util/TerminalColorSpec.scala
index 69adc8d93..72e2c966c 100644
--- a/internal/util-logging/src/test/scala/sbt/internal/util/TerminalColorSpec.scala
+++ b/internal/util-logging/src/test/scala/sbt/internal/util/TerminalColorSpec.scala
@@ -18,7 +18,12 @@ object TerminalColorSpec extends BasicTestSuite:
       out: ByteArrayOutputStream
   ): Terminal.TerminalImpl =
     new Terminal.TerminalImpl(
-      new Terminal.WriteableInputStream(new InputStream { def read() = -1 }, "test"),
+      new Terminal.WriteableInputStream(
+        new InputStream:
+          def read() = -1
+        ,
+        "test"
+      ),
       out,
       new ByteArrayOutputStream(),
       "test"
diff --git a/internal/util-logic/src/main/scala/sbt/internal/util/logic/Logic.scala b/internal/util-logic/src/main/scala/sbt/internal/util/logic/Logic.scala
index 8000a88d9..dfb15e325 100644
--- a/internal/util-logic/src/main/scala/sbt/internal/util/logic/Logic.scala
+++ b/internal/util-logic/src/main/scala/sbt/internal/util/logic/Logic.scala
@@ -36,17 +36,16 @@ as is this:
  */
 
 /** Disjunction (or) of the list of clauses. */
-final case class Clauses(clauses: List[Clause]) {
+final case class Clauses(clauses: List[Clause]):
   assert(clauses.nonEmpty, "At least one clause is required.")
   override def toString: String =
     s"Clauses(${clauses.mkString("\n")})"
-}
 
 /** When the `body` Formula succeeds, atoms in `head` are true. */
 final case class Clause(body: Formula, head: Set[Atom])
 
 /** A literal is an [[Atom]] or its negation ([[Negated]]). */
-sealed abstract class Literal extends Formula {
+sealed abstract class Literal extends Formula:
 
   /** The underlying (positive) atom. */
   def atom: Atom
@@ -54,56 +53,46 @@ sealed abstract class Literal extends Formula {
   /** Negates this literal. */
   def unary_! : Literal
 
-}
-
 /** A variable with name `label`. */
-final case class Atom(label: String) extends Literal {
+final case class Atom(label: String) extends Literal:
   def atom = this
   def unary_! : Negated = Negated(this)
-}
 
 /**
  * A negated atom, in the sense of negation as failure, not logical negation. That is, it is true if
  * `atom` is not known/defined.
  */
-final case class Negated(atom: Atom) extends Literal {
+final case class Negated(atom: Atom) extends Literal:
   def unary_! : Atom = atom
-}
 
 /**
  * A formula consists of variables, negation, and conjunction (and). (Disjunction is not currently
  * included- it is modeled at the level of a sequence of clauses. This is less convenient when
  * defining clauses, but is not less powerful.)
  */
-sealed abstract class Formula {
+sealed abstract class Formula:
 
   /** Constructs a clause that proves `atoms` when this formula is true. */
   def proves(atom: Atom, atoms: Atom*): Clause = Clause(this, (atom +: atoms).toSet)
 
   /** Constructs a formula that is true iff this formula and `f` are both true. */
-  def &&(f: Formula): Formula = (this, f) match {
+  def &&(f: Formula): Formula = (this, f) match
     case (True, x)                => x
     case (x, True)                => x
     case (And(as), And(bs))       => And(as ++ bs)
     case (And(as), b: Literal)    => And(as + b)
     case (a: Literal, And(bs))    => And(bs + a)
     case (a: Literal, b: Literal) => And(Set(a, b))
-  }
 
-}
-
-object Formula {
+object Formula:
 
   /** A conjunction of literals. */
-  final case class And(literals: Set[Literal]) extends Formula {
+  final case class And(literals: Set[Literal]) extends Formula:
     assert(literals.nonEmpty, "'And' requires at least one literal.")
-  }
 
   case object True extends Formula
 
-}
-
-object Logic {
+object Logic:
   def reduceAll(
       clauses: List[Clause],
       initialFacts: Set[Literal]
@@ -116,7 +105,7 @@ object Logic {
    * `initialFacts` cannot be in the head of any clauses in `clause`. These restrictions ensure that
    * the logic program has a unique minimal model.
    */
-  def reduce(clauses: Clauses, initialFacts: Set[Literal]): Either[LogicException, Matched] = {
+  def reduce(clauses: Clauses, initialFacts: Set[Literal]): Either[LogicException, Matched] =
     val (posSeq, negSeq) = separate(initialFacts.toSeq)
     val (pos, neg) = (posSeq.toSet, negSeq.toSet)
 
@@ -128,7 +117,6 @@ object Logic {
     problem.toLeft(
       reduce0(clauses, initialFacts, Matched.empty)
     )
-  }
 
   /**
    * Verifies `initialFacts` are not in the head of any `clauses`. This avoids the situation where
@@ -138,19 +126,17 @@ object Logic {
   private def checkOverlap(
       clauses: Clauses,
       initialFacts: Set[Atom]
-  ): Option[InitialOverlap] = {
+  ): Option[InitialOverlap] =
     val as = atoms(clauses)
     val initialOverlap = initialFacts.filter(as.inHead)
-    if (initialOverlap.nonEmpty) Some(new InitialOverlap(initialOverlap)) else None
-  }
+    if initialOverlap.nonEmpty then Some(new InitialOverlap(initialOverlap)) else None
 
   private def checkContradictions(
       pos: Set[Atom],
       neg: Set[Atom]
-  ): Option[InitialContradictions] = {
+  ): Option[InitialContradictions] =
     val contradictions = pos intersect neg
-    if (contradictions.nonEmpty) Some(new InitialContradictions(contradictions)) else None
-  }
+    if contradictions.nonEmpty then Some(new InitialContradictions(contradictions)) else None
 
   sealed abstract class LogicException(override val toString: String)
 
@@ -170,21 +156,18 @@ object Logic {
       )
 
   /** Tracks proven atoms in the reverse order they were proved. */
-  final class Matched private (val provenSet: Set[Atom], reverseOrdered: List[Atom]) {
+  final class Matched private (val provenSet: Set[Atom], reverseOrdered: List[Atom]):
     def add(atoms: Set[Atom]): Matched = add(atoms.toList)
 
-    def add(atoms: List[Atom]): Matched = {
+    def add(atoms: List[Atom]): Matched =
       val newOnly = atoms.filterNot(provenSet)
       new Matched(provenSet ++ newOnly.toSet, newOnly ::: reverseOrdered)
-    }
 
     def ordered: List[Atom] = reverseOrdered.reverse
     override def toString = ordered.map(_.label).mkString("Matched(", ",", ")")
-  }
 
-  object Matched {
+  object Matched:
     val empty = new Matched(Set.empty, Nil)
-  }
 
   /** Separates a sequence of literals into `(pos, neg)` atom sequences. */
   private def separate(lits: Seq[Literal]): (Seq[Atom], Seq[Atom]) =
@@ -197,10 +180,9 @@ object Logic {
    * Finds clauses that have no body and thus prove their head. Returns `(<proven atoms>, <remaining
    * unproven clauses>)`.
    */
-  private def findProven(c: Clauses): (Set[Atom], List[Clause]) = {
+  private def findProven(c: Clauses): (Set[Atom], List[Clause]) =
     val (proven, unproven) = c.clauses.partition(_.body == True)
     (proven.flatMap(_.head).toSet, unproven)
-  }
 
   private def keepPositive(lits: Set[Literal]): Set[Atom] =
     lits.collect { case a: Atom => a }
@@ -211,28 +193,26 @@ object Logic {
       factsToProcess: Set[Literal],
       state: Matched
   ): Matched =
-    applyAll(clauses, factsToProcess) match {
+    applyAll(clauses, factsToProcess) match
       case None          => state // all of the remaining clauses failed on the new facts
       case Some(applied) =>
         val (proven, unprovenClauses) = findProven(applied)
         val processedFacts = state.add(keepPositive(factsToProcess))
         val newlyProven = proven -- processedFacts.provenSet
         val newState = processedFacts.add(newlyProven)
-        if (unprovenClauses.isEmpty) newState // no remaining clauses, done.
-        else {
+        if unprovenClauses.isEmpty then newState // no remaining clauses, done.
+        else
           val unproven = Clauses(unprovenClauses)
           val nextFacts: Set[Literal] =
-            if (newlyProven.nonEmpty) newlyProven.toSet[Literal]
+            if newlyProven.nonEmpty then newlyProven.toSet[Literal]
             else inferFailure(unproven)
           reduce0(unproven, nextFacts, newState)
-        }
-    }
 
   /**
    * Finds negated atoms under the negation as failure rule and returns them. This should be called
    * only after there are no more known atoms to be substituted.
    */
-  private def inferFailure(clauses: Clauses): Set[Literal] = {
+  private def inferFailure(clauses: Clauses): Set[Literal] =
     /* At this point, there is at least one clause and one of the following is the case as the
        result of the acyclic negation rule:
          i. there is at least one variable that occurs in a clause body but not in the head of a
@@ -245,16 +225,13 @@ object Logic {
      */
     val allAtoms = atoms(clauses)
     val newFacts: Set[Literal] = negated(allAtoms.triviallyFalse)
-    if (newFacts.nonEmpty) newFacts
-    else {
+    if newFacts.nonEmpty then newFacts
+    else
       val possiblyTrue = hasNegatedDependency(clauses.clauses, Relation.empty, Relation.empty)
       val newlyFalse: Set[Literal] = negated(allAtoms.inHead -- possiblyTrue)
-      if (newlyFalse.nonEmpty)
-        newlyFalse
+      if newlyFalse.nonEmpty then newlyFalse
       else // should never happen due to the acyclic negation rule
         sys.error(s"No progress:\n\tclauses: $clauses\n\tpossibly true: $possiblyTrue")
-    }
-  }
 
   private def negated(atoms: Set[Atom]): Set[Literal] = atoms.map(a => (Negated(a): Literal))
 
@@ -269,7 +246,7 @@ object Logic {
       posDeps: Relation[Atom, Atom],
       negDeps: Relation[Atom, Atom]
   ): List[Atom] =
-    clauses match {
+    clauses match
       case Seq() =>
         // because cycles between positive literals are allowed, this isn't strictly a topological sort
         Dag.topologicalSortUnchecked(negDeps._1s)(posDeps.reverse)
@@ -281,7 +258,6 @@ object Logic {
           (pdeps.+(d, pos), ndeps.+(d, neg))
         }
         hasNegatedDependency(tail, newPos, newNeg)
-    }
 
   /** Computes the `(positive, negative)` literals in `formula`. */
   private def directDeps(formula: Formula): (Seq[Atom], Seq[Atom]) =
@@ -290,27 +266,25 @@ object Logic {
       case a: Atom    => Left(a)
     }
 
-  private def literals(formula: Formula): Set[Literal] = formula match {
+  private def literals(formula: Formula): Set[Literal] = formula match
     case And(lits)  => lits
     case l: Literal => Set(l)
     case True       => Set.empty
-  }
 
   /** Computes the atoms in the heads and bodies of the clauses in `clause`. */
   def atoms(cs: Clauses): Atoms = cs.clauses.map(c => Atoms(c.head, atoms(c.body))).reduce(_ ++ _)
 
   /** Computes the set of all atoms in `formula`. */
-  def atoms(formula: Formula): Set[Atom] = formula match {
+  def atoms(formula: Formula): Set[Atom] = formula match
     case And(lits)    => lits.map(_.atom)
     case Negated(lit) => Set(lit)
     case a: Atom      => Set(a)
     case True         => Set()
-  }
 
   /**
    * Represents the set of atoms in the heads of clauses and in the bodies (formulas) of clauses.
    */
-  final case class Atoms(inHead: Set[Atom], inFormula: Set[Atom]) {
+  final case class Atoms(inHead: Set[Atom], inFormula: Set[Atom]):
 
     /** Concatenates this with `as`. */
     def ++(as: Atoms): Atoms = Atoms(inHead ++ as.inHead, inFormula ++ as.inFormula)
@@ -318,8 +292,6 @@ object Logic {
     /** Atoms that cannot be true because they do not occur in a head. */
     def triviallyFalse: Set[Atom] = inFormula -- inHead
 
-  }
-
   /**
    * Applies known facts to `clause`s, deriving a new, possibly empty list of clauses.
    *   1. If a fact is in the body of a clause, the derived clause has that fact removed from the
@@ -333,39 +305,33 @@ object Logic {
    * Postcondition: no atom in `facts` is present in the result Postcondition: No clauses have an
    * empty head
    */
-  def applyAll(cs: Clauses, facts: Set[Literal]): Option[Clauses] = {
+  def applyAll(cs: Clauses, facts: Set[Literal]): Option[Clauses] =
     val newClauses =
-      if (facts.isEmpty)
+      if facts.isEmpty then
         cs.clauses.filter(_.head.nonEmpty) // still need to drop clauses with an empty head
-      else
-        cs.clauses.map(c => applyAll(c, facts)).flatMap(_.toList)
-    if (newClauses.isEmpty) None else Some(Clauses(newClauses))
-  }
+      else cs.clauses.map(c => applyAll(c, facts)).flatMap(_.toList)
+    if newClauses.isEmpty then None else Some(Clauses(newClauses))
 
-  def applyAll(c: Clause, facts: Set[Literal]): Option[Clause] = {
+  def applyAll(c: Clause, facts: Set[Literal]): Option[Clause] =
     val atoms = facts.map(_.atom)
     val newHead = c.head -- atoms // 3.
-    if (newHead.isEmpty) // 4. empty head
+    if newHead.isEmpty then // 4. empty head
       None
-    else
-      substitute(c.body, facts).map(f => Clause(f, newHead)) // 1, 2
-  }
+    else substitute(c.body, facts).map(f => Clause(f, newHead)) // 1, 2
 
   /** Derives the formula that results from substituting `facts` into `formula`. */
-  @tailrec def substitute(formula: Formula, facts: Set[Literal]): Option[Formula] = formula match {
+  @tailrec def substitute(formula: Formula, facts: Set[Literal]): Option[Formula] = formula match
     case And(lits) =>
       def negated(lits: Set[Literal]): Set[Literal] = lits.map(a => !a)
-      if (lits.exists(negated(facts))) // 2.
+      if lits.exists(negated(facts)) then // 2.
         None
-      else {
+      else
         val newLits = lits -- facts
         val newF =
-          if (newLits.isEmpty) (True: Formula)
+          if newLits.isEmpty then (True: Formula)
           else (And(newLits): Formula)
         Some(newF) // 1.
-      }
     case True         => Some(True)
     case lit: Literal => // define in terms of And
       substitute(And(Set(lit)), facts)
-  }
-}
+end Logic
diff --git a/internal/util-logic/src/test/scala/sbt/logic/Test.scala b/internal/util-logic/src/test/scala/sbt/logic/Test.scala
index 5649ce7ee..5ed9e2ac0 100644
--- a/internal/util-logic/src/test/scala/sbt/logic/Test.scala
+++ b/internal/util-logic/src/test/scala/sbt/logic/Test.scala
@@ -13,7 +13,7 @@ import org.scalacheck.*
 import Prop.secure
 import Logic.{ LogicException, Matched }
 
-object LogicTest extends Properties("Logic") {
+object LogicTest extends Properties("Logic"):
   import TestClauses.*
 
   property("Handles trivial resolution.") = secure(expect(trivial, Set(A)))
@@ -34,18 +34,16 @@ object LogicTest extends Properties("Logic") {
   )
    */
 
-  def expect(result: Either[LogicException, Matched], expected: Set[Atom]) = result match {
+  def expect(result: Either[LogicException, Matched], expected: Set[Atom]) = result match
     case Left(_)    => false
     case Right(res) =>
       val actual = res.provenSet
-      if (actual != expected)
+      if actual != expected then
         sys.error(s"Expected to prove $expected, but actually proved $actual")
-      else
-        true
-  }
-}
+      else true
+end LogicTest
 
-object TestClauses {
+object TestClauses:
 
   val A = Atom("A")
   val B = Atom("B")
@@ -71,7 +69,7 @@ object TestClauses {
     A.proves(D) ::
       clauses
 
-  val excludedNeg = {
+  val excludedNeg =
     val cs =
       (!A).proves(B) ::
         Nil
@@ -80,9 +78,8 @@ object TestClauses {
         (!B) ::
         Nil
     Logic.reduceAll(cs, init.toSet)
-  }
 
-  val excludedPos = {
+  val excludedPos =
     val cs =
       A.proves(B) ::
         Nil
@@ -91,39 +88,34 @@ object TestClauses {
         (!B) ::
         Nil
     Logic.reduceAll(cs, init.toSet)
-  }
 
-  val trivial = {
+  val trivial =
     val cs =
       Formula.True.proves(A) ::
         Nil
     Logic.reduceAll(cs, Set.empty)
-  }
 
-  val lessTrivial = {
+  val lessTrivial =
     val cs =
       Formula.True.proves(A) ::
         Formula.True.proves(B) ::
         (A && B && (!C)).proves(D) ::
         Nil
     Logic.reduceAll(cs, Set())
-  }
 
-  val ordering = {
+  val ordering =
     val cs =
       E.proves(F) ::
         (C && !D).proves(E) ::
         (A && B).proves(C) ::
         Nil
     Logic.reduceAll(cs, Set(A, B))
-  }
 
-  def all(): Unit = {
+  def all(): Unit =
     println(s"Cycles: $cycles")
     println(s"xNeg: $excludedNeg")
     println(s"xPos: $excludedPos")
     println(s"trivial: $trivial")
     println(s"lessTrivial: $lessTrivial")
     println(s"ordering: $ordering")
-  }
-}
+end TestClauses
diff --git a/internal/util-position/src/main/scala-3/sbt/internal/util/SourcePositionMacro.scala b/internal/util-position/src/main/scala-3/sbt/internal/util/SourcePositionMacro.scala
index 130c7d753..ab8605059 100644
--- a/internal/util-position/src/main/scala-3/sbt/internal/util/SourcePositionMacro.scala
+++ b/internal/util-position/src/main/scala-3/sbt/internal/util/SourcePositionMacro.scala
@@ -9,7 +9,7 @@ package sbt.internal.util
 
 import scala.quoted.{ Expr, Quotes, quotes }
 
-abstract class SourcePositionImpl {
+abstract class SourcePositionImpl:
 
   /**
    * Creates a SourcePosition by using the enclosing position of the invocation of this method.
@@ -18,11 +18,10 @@ abstract class SourcePositionImpl {
    */
   inline def fromEnclosing(): SourcePosition =
     ${ SourcePositionImpl.fromEnclosingImpl }
-}
 
-object SourcePositionImpl {
+object SourcePositionImpl:
 
-  def fromEnclosingImpl(using Quotes): Expr[SourcePosition] = {
+  def fromEnclosingImpl(using Quotes): Expr[SourcePosition] =
     val pos = quotes.reflect.Position.ofMacroExpansion
     if pos.startLine >= 0 then
       '{
@@ -32,5 +31,3 @@ object SourcePositionImpl {
         ).withSourceCode(${ Expr(pos.sourceCode) })
       }
     else '{ NoPosition }
-  }
-}
diff --git a/internal/util-position/src/main/scala/sbt/internal/util/Positions.scala b/internal/util-position/src/main/scala/sbt/internal/util/Positions.scala
index ad4e611a6..c50e9c1d3 100644
--- a/internal/util-position/src/main/scala/sbt/internal/util/Positions.scala
+++ b/internal/util-position/src/main/scala/sbt/internal/util/Positions.scala
@@ -10,15 +10,14 @@ package sbt.internal.util
 
 sealed trait SourcePosition
 
-sealed trait FilePosition extends SourcePosition {
+sealed trait FilePosition extends SourcePosition:
   def path: String
   def startLine: Int
   def sourceCode: Option[String]
-}
 
 case object NoPosition extends SourcePosition
 
-final case class LinePosition(path: String, startLine: Int) extends FilePosition {
+final case class LinePosition(path: String, startLine: Int) extends FilePosition:
   private var _sourceCode: Option[String] = None
   def sourceCode: Option[String] = _sourceCode
   def withSourceCode(code: String): LinePosition =
@@ -29,13 +28,11 @@ final case class LinePosition(path: String, startLine: Int) extends FilePosition
     c match
       case Some(code) => this.withSourceCode(code)
       case None       => this
-}
 
-final case class LineRange(start: Int, end: Int) {
+final case class LineRange(start: Int, end: Int):
   def shift(n: Int) = new LineRange(start + n, end + n)
-}
 
-final case class RangePosition(path: String, range: LineRange) extends FilePosition {
+final case class RangePosition(path: String, range: LineRange) extends FilePosition:
   private var _sourceCode: Option[String] = None
   def startLine = range.start
   def sourceCode: Option[String] = _sourceCode
@@ -47,6 +44,5 @@ final case class RangePosition(path: String, range: LineRange) extends FilePosit
     c match
       case Some(code) => this.withSourceCode(code)
       case None       => this
-}
 
 object SourcePosition extends SourcePositionImpl
diff --git a/internal/util-position/src/test/scala/sbt/internal/util/SourcePositionSpec.scala b/internal/util-position/src/test/scala/sbt/internal/util/SourcePositionSpec.scala
index 8d4ecabea..bad346364 100644
--- a/internal/util-position/src/test/scala/sbt/internal/util/SourcePositionSpec.scala
+++ b/internal/util-position/src/test/scala/sbt/internal/util/SourcePositionSpec.scala
@@ -17,7 +17,7 @@ object SourcePositionSpec extends Properties:
       "SourcePosition() should return a SourcePosition", {
         val filename = "SourcePositionSpec.scala"
         val lineNumber = 19
-        SourcePosition.fromEnclosing() match {
+        SourcePosition.fromEnclosing() match
           case pos @ LinePosition(path, startLine) =>
             Result.assert(path == filename && startLine == lineNumber).log(pos.toString())
             Result
@@ -26,7 +26,6 @@ object SourcePositionSpec extends Properties:
           case pos @ RangePosition(path, range) =>
             Result.assert(path == filename && inRange(range, lineNumber)).log(pos.toString())
           case NoPosition => Result.assert(false).log("No source position found")
-        }
       }
     )
   )
diff --git a/internal/util-relation/src/main/scala/sbt/internal/util/Relation.scala b/internal/util-relation/src/main/scala/sbt/internal/util/Relation.scala
index b6e9179e1..eeb1fd1e9 100644
--- a/internal/util-relation/src/main/scala/sbt/internal/util/Relation.scala
+++ b/internal/util-relation/src/main/scala/sbt/internal/util/Relation.scala
@@ -10,7 +10,7 @@ package sbt.internal.util
 
 import Relation.*
 
-object Relation {
+object Relation:
 
   /** Constructs a new immutable, finite relation that is initially empty. */
   def empty[A, B]: Relation[A, B] = make(Map.empty, Map.empty)
@@ -27,24 +27,22 @@ object Relation {
    * Constructs a relation such that for every entry `_1 -> _2s` in `forward` and every `_2` in
    * `_2s`, `(_1, _2)` is in the relation.
    */
-  def reconstruct[A, B](forward: Map[A, Set[B]]): Relation[A, B] = {
-    val reversePairs = for ((a, bs) <- forward.view; b <- bs.view) yield (b, a)
+  def reconstruct[A, B](forward: Map[A, Set[B]]): Relation[A, B] =
+    val reversePairs = for (a, bs) <- forward.view; b <- bs.view yield (b, a)
     val reverse = reversePairs.foldLeft(Map.empty[B, Set[A]]) { case (m, (b, a)) =>
       add(m, b, a :: Nil)
     }
     make(forward filter { (a, bs) => bs.nonEmpty }, reverse)
-  }
 
   def merge[A, B](rels: Iterable[Relation[A, B]]): Relation[A, B] =
     rels.foldLeft(Relation.empty[A, B])(_ ++ _)
 
   private[sbt] def remove[X, Y](map: M[X, Y], from: X, to: Y): M[X, Y] =
-    map.get(from) match {
+    map.get(from) match
       case Some(tos) =>
         val newSet = tos - to
-        if (newSet.isEmpty) map - from else map.updated(from, newSet)
+        if newSet.isEmpty then map - from else map.updated(from, newSet)
       case None => map
-    }
 
   private[sbt] def combine[X, Y](a: M[X, Y], b: M[X, Y]): M[X, Y] =
     b.foldLeft(a)((map, mapping) => add(map, mapping._1, mapping._2))
@@ -57,7 +55,7 @@ object Relation {
   private[sbt] type M[X, Y] = Map[X, Set[Y]]
 
   /** when both parameters taken by relation are the same type, switch calls a function on them. */
-  private[sbt] def switch[X, Y](relation: Relation[X, X], f: X => Y): Relation[Y, Y] = {
+  private[sbt] def switch[X, Y](relation: Relation[X, X], f: X => Y): Relation[Y, Y] =
     val forward = relation.forwardMap.map { (first, second) =>
       f(first) -> second.map(f)
     }
@@ -65,11 +63,10 @@ object Relation {
       f(first) -> second.map(f)
     }
     make(forward, reverse)
-  }
-}
+end Relation
 
 /** Binary relation between A and B.  It is a set of pairs (_1, _2) for _1 in A, _2 in B. */
-trait Relation[A, B] {
+trait Relation[A, B]:
 
   /** Returns the set of all `_2`s such that `(_1, _2)` is in this relation. */
   def forward(_1: A): Set[B]
@@ -153,11 +150,11 @@ trait Relation[A, B] {
    * is in this relation.
    */
   def reverseMap: Map[B, Set[A]]
-}
+end Relation
 
 // Note that we assume without checking that fwd and rev are consistent.
 private final class MRelation[A, B](fwd: Map[A, Set[B]], rev: Map[B, Set[A]])
-    extends Relation[A, B] {
+    extends Relation[A, B]:
   def forwardMap = fwd
   def reverseMap = rev
 
@@ -175,7 +172,7 @@ private final class MRelation[A, B](fwd: Map[A, Set[B]], rev: Map[B, Set[A]])
   def +(pair: (A, B)) = this + (pair._1, Set(pair._2))
   def +(from: A, to: B) = this + (from, to :: Nil)
   def +(from: A, to: Iterable[B]) =
-    if (to.isEmpty) this
+    if to.isEmpty then this
     else new MRelation(add(fwd, from, to), to.foldLeft(rev)((map, t) => add(map, t, from :: Nil)))
 
   def ++(rs: Iterable[(A, B)]) = rs.foldLeft(this: Relation[A, B]) { _ + _ }
@@ -191,35 +188,32 @@ private final class MRelation[A, B](fwd: Map[A, Set[B]], rev: Map[B, Set[A]])
     new MRelation(remove(fwd, pair._1, pair._2), remove(rev, pair._2, pair._1))
 
   def -(t: A): Relation[A, B] =
-    fwd.get(t) match {
+    fwd.get(t) match
       case Some(rs) =>
         val upRev = rs.foldLeft(rev)((map, r) => remove(map, r, t))
         new MRelation(fwd - t, upRev)
       case None => this
-    }
 
   def filter(f: (A, B) => Boolean): Relation[A, B] = Relation.empty[A, B] ++ all.filter(f.tupled)
 
-  def partition(f: (A, B) => Boolean): (Relation[A, B], Relation[A, B]) = {
+  def partition(f: (A, B) => Boolean): (Relation[A, B], Relation[A, B]) =
     val (y, n) = all.partition(f.tupled)
     (Relation.empty[A, B] ++ y, Relation.empty[A, B] ++ n)
-  }
 
   def groupBy[K](discriminator: ((A, B)) => K): Map[K, Relation[A, B]] =
     all.groupBy(discriminator).view.mapValues { Relation.empty[A, B] ++ _ }.toMap
 
   def contains(a: A, b: B): Boolean = forward(a)(b)
 
-  override def equals(other: Any) = other match {
+  override def equals(other: Any) = other match
     // We assume that the forward and reverse maps are consistent, so we only use the forward map
     // for equality. Note that key -> Empty is semantically the same as key not existing.
     case o: MRelation[?, ?] =>
       forwardMap.filterNot(_._2.isEmpty) == o.forwardMap.filterNot(_._2.isEmpty)
     case _ => false
-  }
 
   override def hashCode = fwd.filterNot(_._2.isEmpty).hashCode()
 
   override def toString =
     all.map { (a, b) => s"$a -> $b" }.mkString("Relation [", ", ", "]")
-}
+end MRelation
diff --git a/internal/util-relation/src/test/scala/RelationTest.scala b/internal/util-relation/src/test/scala/RelationTest.scala
index d280c4c5e..886216274 100644
--- a/internal/util-relation/src/test/scala/RelationTest.scala
+++ b/internal/util-relation/src/test/scala/RelationTest.scala
@@ -11,12 +11,12 @@ package sbt.internal.util
 import org.scalacheck.*
 import Prop.*
 
-object RelationTest extends Properties("Relation") {
+object RelationTest extends Properties("Relation"):
   property("Added entry check") = forAll { (pairs: List[(Int, Double)]) =>
     val r = Relation.empty[Int, Double] ++ pairs
     check(r, pairs)
   }
-  def check(r: Relation[Int, Double], pairs: Seq[(Int, Double)]) = {
+  def check(r: Relation[Int, Double], pairs: Seq[(Int, Double)]) =
     val _1s = pairs.map(_._1).toSet
     val _2s = pairs.map(_._2).toSet
 
@@ -28,7 +28,6 @@ object RelationTest extends Properties("Relation") {
       (r.forwardMap(a) contains b) &&
       (r.reverseMap(b) contains a)
     }
-  }
 
   property("Does not contain removed entries") = forAll { (pairs: List[(Int, Double, Boolean)]) =>
     val add = pairs.map { (a, b, c) => (a, b) }
@@ -71,10 +70,10 @@ object RelationTest extends Properties("Relation") {
   }
 
   def all[T](s: Seq[T])(p: T => Prop): Prop =
-    if (s.isEmpty) true else s.map(p).reduceLeft(_ && _)
-}
+    if s.isEmpty then true else s.map(p).reduceLeft(_ && _)
+end RelationTest
 
-object EmptyRelationTest extends Properties("Empty relation") {
+object EmptyRelationTest extends Properties("Empty relation"):
   lazy val e = Relation.empty[Int, Double]
 
   property("Forward empty") = forAll((i: Int) => e.forward(i).isEmpty)
@@ -83,4 +82,3 @@ object EmptyRelationTest extends Properties("Empty relation") {
   property("Reverse map empty") = e.reverseMap.isEmpty
   property("_1 empty") = e._1s.isEmpty
   property("_2 empty") = e._2s.isEmpty
-}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/CommentHandler.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/CommentHandler.scala
index d832536d0..2dffec766 100644
--- a/internal/util-scripted/src/main/scala/sbt/internal/scripted/CommentHandler.scala
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/CommentHandler.scala
@@ -10,6 +10,5 @@ package sbt
 package internal
 package scripted
 
-object CommentHandler extends BasicStatementHandler {
+object CommentHandler extends BasicStatementHandler:
   def apply(command: String, args: List[String]) = ()
-}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/FileCommands.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/FileCommands.scala
index 8a5c34412..195608ede 100644
--- a/internal/util-scripted/src/main/scala/sbt/internal/scripted/FileCommands.scala
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/FileCommands.scala
@@ -16,7 +16,7 @@ import sbt.io.{ IO, Path }
 import sbt.io.syntax.*
 import Path.*
 
-class FileCommands(baseDirectory: File) extends BasicStatementHandler {
+class FileCommands(baseDirectory: File) extends BasicStatementHandler:
   final val OR = "||"
   lazy val view = FileTreeView.Ops(FileTreeView.default)
   val baseGlob = Glob(baseDirectory)
@@ -46,10 +46,9 @@ class FileCommands(baseDirectory: File) extends BasicStatementHandler {
     )
 
   def apply(command: String, arguments: List[String]): Unit =
-    commands.get(command).map(_(arguments)) match {
+    commands.get(command).map(_(arguments)) match
       case Some(_) => ()
       case _       => scriptError("Unknown command " + command); ()
-    }
 
   def scriptError(message: String): Unit = sys.error("Test script error: " + message)
   def spaced[T](l: Seq[T]) = l.mkString(" ")
@@ -77,6 +76,7 @@ class FileCommands(baseDirectory: File) extends BasicStatementHandler {
       List(combined)
     if exprs.contains("||") then orGlobs
     else globs(exprs)
+  end filterFromStrings
 
   def touch(paths: List[String]): Unit = IO.touch(fromStrings(paths))
   def delete(paths: List[String]): Unit =
@@ -92,47 +92,37 @@ class FileCommands(baseDirectory: File) extends BasicStatementHandler {
     IO.copyFile(fromString(from), fromString(to))
   def makeDirectories(paths: List[String]) =
     IO.createDirectories(fromStrings(paths))
-  def diffFiles(file1: String, file2: String): Unit = {
+  def diffFiles(file1: String, file2: String): Unit =
     val lines1 = IO.readLines(fromString(file1))
     val lines2 = IO.readLines(fromString(file2))
-    if (lines1 != lines2)
+    if lines1 != lines2 then
       scriptError(
         "File contents are different:\n" + lines1.mkString("\n") +
           "\nAnd:\n" + lines2.mkString("\n")
       )
-  }
 
-  def newer(a: String, b: String): Unit = {
+  def newer(a: String, b: String): Unit =
     val pathA = fromString(a)
     val pathB = fromString(b)
     val isNewer = pathA.exists &&
       (!pathB.exists || IO.getModifiedTimeOrZero(pathA) > IO.getModifiedTimeOrZero(pathB))
-    if (!isNewer) {
-      scriptError(s"$pathA is not newer than $pathB")
-    }
-  }
+    if !isNewer then scriptError(s"$pathA is not newer than $pathB")
   // use FileTreeView to test if a file with the given filter exists
   def exists0(filter: PathFilter): Boolean =
     view.list(baseGlob / RecursiveGlob, filter).nonEmpty
-  def exists(paths: List[String]): Unit = {
+  def exists(paths: List[String]): Unit =
     val notPresent = filterFromStrings(paths).filter(!exists0(_))
-    if (notPresent.nonEmpty)
+    if notPresent.nonEmpty then
       scriptError("File(s) did not exist: " + notPresent.mkString("[ ", " , ", " ]"))
-  }
-  def absent(paths: List[String]): Unit = {
+  def absent(paths: List[String]): Unit =
     val present = filterFromStrings(paths).filter(exists0)
-    if (present.nonEmpty)
-      scriptError("File(s) existed: " + present.mkString("[ ", " , ", " ]"))
-  }
+    if present.nonEmpty then scriptError("File(s) existed: " + present.mkString("[ ", " , ", " ]"))
   def execute(command: List[String]): Unit = execute0(command.head, command.tail)
-  def execute0(command: String, args: List[String]): Unit = {
-    if (command.trim.isEmpty) scriptError("Command was empty.")
-    else {
+  def execute0(command: String, args: List[String]): Unit =
+    if command.trim.isEmpty then scriptError("Command was empty.")
+    else
       val exitValue = sys.process.Process(command :: args, baseDirectory).!
-      if (exitValue != 0)
-        sys.error("Nonzero exit value (" + exitValue + ")")
-    }
-  }
+      if exitValue != 0 then sys.error("Nonzero exit value (" + exitValue + ")")
 
   type NamedCommand = (String, List[String] => Unit)
 
@@ -140,10 +130,8 @@ class FileCommands(baseDirectory: File) extends BasicStatementHandler {
   extension (commandName: String)
     def nonEmpty(action: List[String] => Unit): NamedCommand =
       commandName -> { paths =>
-        if (paths.isEmpty)
-          scriptError("No arguments specified for " + commandName + " command.")
-        else
-          action(paths)
+        if paths.isEmpty then scriptError("No arguments specified for " + commandName + " command.")
+        else action(paths)
       }
     def twoArg(requiredArgs: String, action: (String, String) => Unit): NamedCommand =
       commandName -> {
@@ -181,4 +169,5 @@ class FileCommands(baseDirectory: File) extends BasicStatementHandler {
         "Wrong number of arguments to " + commandName + " command.  " +
           requiredArgs + " required, found: '" + spaced(args) + "'."
       )
-}
+  end extension
+end FileCommands
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/FilteredLoader.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/FilteredLoader.scala
index efaa8a6d8..fc4729d3d 100644
--- a/internal/util-scripted/src/main/scala/sbt/internal/scripted/FilteredLoader.scala
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/FilteredLoader.scala
@@ -13,14 +13,11 @@ package scripted
 import java.util as ju
 import java.net.URL
 
-final class FilteredLoader(parent: ClassLoader) extends ClassLoader(parent) {
+final class FilteredLoader(parent: ClassLoader) extends ClassLoader(parent):
   @throws(classOf[ClassNotFoundException])
-  override final def loadClass(className: String, resolve: Boolean): Class[?] = {
-    if (className.startsWith("java.") || className.startsWith("javax."))
+  override final def loadClass(className: String, resolve: Boolean): Class[?] =
+    if className.startsWith("java.") || className.startsWith("javax.") then
       super.loadClass(className, resolve)
-    else
-      throw new ClassNotFoundException(className)
-  }
+    else throw new ClassNotFoundException(className)
   override def getResources(name: String): ju.Enumeration[URL] = null
   override def getResource(name: String): URL = null
-}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/HandlersProvider.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/HandlersProvider.scala
index 06ccdf023..5b9c76fa6 100644
--- a/internal/util-scripted/src/main/scala/sbt/internal/scripted/HandlersProvider.scala
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/HandlersProvider.scala
@@ -8,6 +8,5 @@
 
 package sbt.internal.scripted
 
-trait HandlersProvider {
+trait HandlersProvider:
   def getHandlers(config: ScriptConfig): Map[Char, StatementHandler]
-}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptRunner.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptRunner.scala
index 85b61ad59..1e3b65d17 100644
--- a/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptRunner.scala
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptRunner.scala
@@ -13,46 +13,35 @@ package scripted
 final class TestException(statement: Statement, msg: String, exception: Throwable)
     extends RuntimeException(statement.linePrefix + " " + msg, exception)
 
-class ScriptRunner {
+class ScriptRunner:
   import scala.collection.mutable.HashMap
-  def apply(statements: List[(StatementHandler, Statement)]): Unit = {
+  def apply(statements: List[(StatementHandler, Statement)]): Unit =
     val states = new HashMap[StatementHandler, Any]
-    def processStatement(handler: StatementHandler, statement: Statement): Unit = {
+    def processStatement(handler: StatementHandler, statement: Statement): Unit =
       val state = states(handler).asInstanceOf[handler.State]
       val nextState =
-        try {
-          Right(handler(statement.command, statement.arguments, state))
-        } catch {
-          case e: Exception => Left(e)
-        }
-      nextState match {
+        try Right(handler(statement.command, statement.arguments, state))
+        catch case e: Exception => Left(e)
+      nextState match
         case Left(err) =>
-          if (statement.successExpected) {
-            err match {
+          if statement.successExpected then
+            err match
               case t: TestFailed =>
                 throw new TestException(statement, "Command failed: " + t.getMessage, null)
               case _ => throw new TestException(statement, "Command failed", err)
-            }
-          } else
-            ()
+          else ()
         case Right(s) =>
-          if (statement.successExpected)
-            states(handler) = s
+          if statement.successExpected then states(handler) = s
           else
             throw new TestException(statement, "Command succeeded but failure was expected", null)
-      }
-    }
     val handlers = Set() ++ statements.map(_._1)
 
-    try {
+    try
       handlers.foreach(handler => states(handler) = handler.initialState)
       statements foreach (Function.tupled(processStatement))
-    } finally {
-      for (handler <- handlers; state <- states.get(handler)) {
-        try {
-          handler.finish(state.asInstanceOf[handler.State])
-        } catch { case e: Exception => () }
-      }
-    }
-  }
-}
+    finally
+      for handler <- handlers; state <- states.get(handler) do
+        try handler.finish(state.asInstanceOf[handler.State])
+        catch case e: Exception => ()
+  end apply
+end ScriptRunner
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptedTests.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptedTests.scala
index c9db381c5..9cfc856c6 100644
--- a/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptedTests.scala
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptedTests.scala
@@ -19,13 +19,13 @@ import sbt.io.syntax.*
 import sbt.internal.io.Resources
 import java.util.concurrent.atomic.AtomicInteger
 
-object ScriptedRunnerImpl {
+object ScriptedRunnerImpl:
   def run(
       resourceBaseDirectory: File,
       bufferLog: Boolean,
       tests: Array[String],
       handlersProvider: HandlersProvider
-  ): Unit = {
+  ): Unit =
     val context = LoggerContext()
     val runner = new ScriptedTests(resourceBaseDirectory, bufferLog, handlersProvider)
     val logger = newLogger(context)
@@ -33,38 +33,32 @@ object ScriptedRunnerImpl {
       case ScriptedTest(group, name) =>
         runner.scriptedTest(group, name, logger, context)
     }
-    if (tests.nonEmpty && allTests.isEmpty) {
+    if tests.nonEmpty && allTests.isEmpty then
       sys.error(s"No tests found matching: ${tests.mkString(", ")}")
-    }
     runAll(allTests)
-  }
-  def runAll(tests: Seq[() => Option[String]]): Unit = {
-    val errors = for (test <- tests; err <- test()) yield err
-    if (errors.nonEmpty)
-      sys.error(errors.mkString("Failed tests:\n\t", "\n\t", "\n"))
-  }
+  def runAll(tests: Seq[() => Option[String]]): Unit =
+    val errors = for test <- tests; err <- test() yield err
+    if errors.nonEmpty then sys.error(errors.mkString("Failed tests:\n\t", "\n\t", "\n"))
   def get(tests: Seq[String], baseDirectory: File, log: ManagedLogger): Seq[ScriptedTest] =
-    if (tests.isEmpty) listTests(baseDirectory, log) else parseTests(tests)
+    if tests.isEmpty then listTests(baseDirectory, log) else parseTests(tests)
   def listTests(baseDirectory: File, log: ManagedLogger): Seq[ScriptedTest] =
     (new ListTests(baseDirectory, _ => true, log)).listTests
   def parseTests(in: Seq[String]): Seq[ScriptedTest] =
-    for (testString <- in) yield {
+    for testString <- in yield
       val Array(group, name) = testString.split("/").map(_.trim)
       ScriptedTest(group, name)
-    }
   private[sbt] val generateId: AtomicInteger = new AtomicInteger
-  private[sbt] def newLogger(context: LoggerContext): ManagedLogger = {
+  private[sbt] def newLogger(context: LoggerContext): ManagedLogger =
     val loggerName = "scripted-" + generateId.incrementAndGet
     context.logger(loggerName, None, None)
-  }
-}
+end ScriptedRunnerImpl
 
 final class ScriptedTests(
     resourceBaseDirectory: File,
     bufferLog: Boolean,
     handlersProvider: HandlersProvider,
     stripQuotes: Boolean
-) {
+):
   def this(resourceBaseDirectory: File, bufferLog: Boolean, handlersProvider: HandlersProvider) =
     this(resourceBaseDirectory, bufferLog, handlersProvider, true)
   private val testResources = new Resources(resourceBaseDirectory)
@@ -105,29 +99,23 @@ final class ScriptedTests(
       prescripted: File => Unit,
       log: ManagedLogger,
       context: LoggerContext,
-  ): Seq[() => Option[String]] = {
-    for (groupDir <- (resourceBaseDirectory * group).get(); nme <- (groupDir * name).get()) yield {
+  ): Seq[() => Option[String]] =
+    for groupDir <- (resourceBaseDirectory * group).get(); nme <- (groupDir * name).get() yield
       val g = groupDir.getName
       val n = nme.getName
       val str = s"$g / $n"
-      () => {
+      () =>
         println("Running " + str)
         testResources.readWriteResourceDirectory(g, n) { testDirectory =>
           val disabled = new File(testDirectory, "disabled").isFile
-          if (disabled) {
+          if disabled then
             log.info("D " + str + " [DISABLED]")
             None
-          } else {
-            try {
+          else
+            try
               scriptedTest(str, testDirectory, prescripted, log, context); None
-            } catch {
-              case _: TestException | _: PendingTestSuccessException => Some(str)
-            }
-          }
+            catch case _: TestException | _: PendingTestSuccessException => Some(str)
         }
-      }
-    }
-  }
 
   private def scriptedTest(
       label: String,
@@ -135,104 +123,88 @@ final class ScriptedTests(
       prescripted: File => Unit,
       log: ManagedLogger,
       context: LoggerContext,
-  ): Unit = {
+  ): Unit =
     val buffered = BufferedAppender(appender)
     context.clearAppenders(log.name)
     context.addAppender(log.name, (buffered -> Level.Debug))
-    if (bufferLog) {
-      buffered.record()
-    }
-    def createParser() = {
+    if bufferLog then buffered.record()
+    def createParser() =
       // val fileHandler = new FileCommands(testDirectory)
       // // val sbtHandler = new SbtHandler(testDirectory, launcher, buffered, launchOpts)
       // new TestScriptParser(Map('$' -> fileHandler, /* '>' -> sbtHandler, */ '#' -> CommentHandler))
       val scriptConfig = new ScriptConfig(label, testDirectory, log)
       new TestScriptParser(handlersProvider.getHandlers(scriptConfig))
-    }
-    val (file, pending) = {
+    val (file, pending) =
       val normal = new File(testDirectory, ScriptFilename)
       val pending = new File(testDirectory, PendingScriptFilename)
-      if (pending.isFile) (pending, true) else (normal, false)
-    }
-    val pendingString = if (pending) " [PENDING]" else ""
+      if pending.isFile then (pending, true) else (normal, false)
+    val pendingString = if pending then " [PENDING]" else ""
 
-    def runTest(): Unit = {
+    def runTest(): Unit =
       val run = new ScriptRunner
       val parser = createParser()
       run(parser.parse(file, stripQuotes))
-    }
-    def testFailed(): Unit = {
-      if (pending) buffered.clearBuffer() else buffered.stopBuffer()
+    def testFailed(): Unit =
+      if pending then buffered.clearBuffer() else buffered.stopBuffer()
       log.error("x " + label + pendingString)
-    }
 
-    try {
+    try
       prescripted(testDirectory)
       runTest()
       log.info("+ " + label + pendingString)
-      if (pending) throw new PendingTestSuccessException(label)
-    } catch {
+      if pending then throw new PendingTestSuccessException(label)
+    catch
       case e: TestException =>
         testFailed()
-        e.getCause match {
+        e.getCause match
           case null | _: java.net.SocketException => log.error("   " + e.getMessage)
-          case _                                  => if (!pending) e.printStackTrace
-        }
-        if (!pending) throw e
+          case _                                  => if !pending then e.printStackTrace
+        if !pending then throw e
       case e: PendingTestSuccessException =>
         testFailed()
         log.error("  Mark as passing to remove this failure.")
         throw e
       case e: Exception =>
         testFailed()
-        if (!pending) throw e
-    } finally {
-      buffered.clearBuffer()
-    }
-  }
-}
+        if !pending then throw e
+    finally buffered.clearBuffer()
+  end scriptedTest
+end ScriptedTests
 
 // object ScriptedTests extends ScriptedRunner {
 //   val emptyCallback: File => Unit = { _ => () }
 // }
 
-final case class ScriptedTest(group: String, name: String) {
+final case class ScriptedTest(group: String, name: String):
   override def toString = group + "/" + name
-}
 
-object ListTests {
+object ListTests:
   def list(directory: File, filter: java.io.FileFilter): Seq[File] =
     wrapNull(directory.listFiles(filter)).toSeq
-}
 import ListTests.*
-final class ListTests(baseDirectory: File, accept: ScriptedTest => Boolean, log: Logger) {
+final class ListTests(baseDirectory: File, accept: ScriptedTest => Boolean, log: Logger):
   def filter = DirectoryFilter -- HiddenFileFilter
-  def listTests: Seq[ScriptedTest] = {
+  def listTests: Seq[ScriptedTest] =
     list(baseDirectory, filter) flatMap { group =>
       val groupName = group.getName
       listTests(group).map(ScriptedTest(groupName, _))
     }
-  }
-  private def listTests(group: File): Seq[String] = {
+  private def listTests(group: File): Seq[String] =
     val groupName = group.getName
     val allTests = list(group, filter).sortBy(_.getName)
-    if (allTests.isEmpty) {
+    if allTests.isEmpty then
       log.warn("No tests in test group " + groupName)
       Seq.empty
-    } else {
+    else
       val (included, skipped) =
         allTests.toList.partition(test => accept(ScriptedTest(groupName, test.getName)))
-      if (included.isEmpty) log.warn("Test group " + groupName + " skipped.")
-      else if (skipped.nonEmpty) {
+      if included.isEmpty then log.warn("Test group " + groupName + " skipped.")
+      else if skipped.nonEmpty then
         log.warn("Tests skipped in group " + group.getName + ":")
         skipped.foreach(testName => log.warn(" " + testName.getName))
-      }
       Seq(included.map(_.getName)*)
-    }
-  }
-}
+end ListTests
 
-class PendingTestSuccessException(label: String) extends Exception {
+class PendingTestSuccessException(label: String) extends Exception:
   override def getMessage: String =
     s"The pending test $label succeeded. Mark this test as passing to remove this failure."
-}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/StatementHandler.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/StatementHandler.scala
index 872ecbb1c..9d22a94fa 100644
--- a/internal/util-scripted/src/main/scala/sbt/internal/scripted/StatementHandler.scala
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/StatementHandler.scala
@@ -10,14 +10,13 @@ package sbt
 package internal
 package scripted
 
-trait StatementHandler {
+trait StatementHandler:
   type State
   def initialState: State
   def apply(command: String, arguments: List[String], state: State): State
   def finish(state: State): Unit
-}
 
-trait BasicStatementHandler extends StatementHandler {
+trait BasicStatementHandler extends StatementHandler:
   final type State = Unit
   final def initialState: State = ()
 
@@ -26,9 +25,7 @@ trait BasicStatementHandler extends StatementHandler {
 
   def apply(command: String, arguments: List[String]): Unit
   def finish(state: Unit) = ()
-}
 
 /** Use when a stack trace is not useful */
-final class TestFailed(msg: String) extends RuntimeException(msg) {
+final class TestFailed(msg: String) extends RuntimeException(msg):
   override def fillInStackTrace: Throwable = this
-}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/TestScriptParser.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/TestScriptParser.scala
index faa04cb44..c0124ee2b 100644
--- a/internal/util-scripted/src/main/scala/sbt/internal/scripted/TestScriptParser.scala
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/TestScriptParser.scala
@@ -30,25 +30,22 @@ final case class Statement(
     arguments: List[String],
     successExpected: Boolean,
     line: Int
-) {
+):
   def linePrefix = "{line " + line + "} "
-}
 
-private object TestScriptParser {
+private object TestScriptParser:
   val SuccessLiteral = "success"
   val FailureLiteral = "failure"
   val WordRegex = """[^ \[\]\s'\"][^ \[\]\s]*""".r
-}
 
 import TestScriptParser.*
-class TestScriptParser(handlers: Map[Char, StatementHandler]) extends RegexParsers {
+class TestScriptParser(handlers: Map[Char, StatementHandler]) extends RegexParsers:
   require(handlers.nonEmpty)
   override def skipWhitespace = false
 
   import IO.read
-  if (handlers.keys.exists(isWhitespace))
-    sys.error("Start characters cannot be whitespace")
-  if (handlers.keys.exists(key => key == '+' || key == '-'))
+  if handlers.keys.exists(isWhitespace) then sys.error("Start characters cannot be whitespace")
+  if handlers.keys.exists(key => key == '+' || key == '-') then
     sys.error("Start characters cannot be '+' or '-'")
 
   @deprecated("Use variant that specifies whether to strip quotes or not", "1.4.0")
@@ -65,15 +62,12 @@ class TestScriptParser(handlers: Map[Char, StatementHandler]) extends RegexParse
       script: String,
       label: Option[String],
       stripQuotes: Boolean
-  ): List[(StatementHandler, Statement)] = {
-    parseAll(statements(stripQuotes), script) match {
+  ): List[(StatementHandler, Statement)] =
+    parseAll(statements(stripQuotes), script) match
       case Success(result, next) => result
-      case err: NoSuccess        => {
+      case err: NoSuccess        =>
         val labelString = label.map("'" + _ + "' ").getOrElse("")
         sys.error("Could not parse test script, " + labelString + err.toString)
-      }
-    }
-  }
 
   @deprecated("Use variant that specifies whether to strip quotes or not", "1.4.0")
   lazy val statements = rep1(space ~> statement <~ newline)
@@ -82,23 +76,20 @@ class TestScriptParser(handlers: Map[Char, StatementHandler]) extends RegexParse
 
   @deprecated("Use variant that specifies whether to strip quotes or not", "1.4.0")
   def statement: Parser[(StatementHandler, Statement)] = statement(stripQuotes = true)
-  def statement(stripQuotes: Boolean): Parser[(StatementHandler, Statement)] = {
-    trait PositionalStatement extends Positional {
+  def statement(stripQuotes: Boolean): Parser[(StatementHandler, Statement)] =
+    trait PositionalStatement extends Positional:
       def tuple: (StatementHandler, Statement)
-    }
     positioned {
-      val w = if (stripQuotes) word else rawWord
+      val w = if stripQuotes then word else rawWord
       val command = w | err("expected command")
       val arguments = rep(space ~> w | failure("expected argument"))
       (successParser ~ (space ~> startCharacterParser <~ space) ~! command ~! arguments) ^^ {
         case successExpected ~ start ~ command ~ arguments =>
-          new PositionalStatement {
+          new PositionalStatement:
             def tuple =
               (handlers(start), new Statement(command, arguments, successExpected, pos.line))
-          }
       }
     } ^^ (_.tuple)
-  }
 
   def successParser: Parser[Boolean] = ('+' ^^^ true) | ('-' ^^^ false) | success(true)
   def space: Parser[String] = """[ \t]*""".r
@@ -116,4 +107,4 @@ class TestScriptParser(handlers: Map[Char, StatementHandler]) extends RegexParse
       )
 
   def newline = """\s*([\n\r]|$)""".r
-}
+end TestScriptParser
diff --git a/launcher-package/build.sbt b/launcher-package/build.sbt
index f9d710038..8a492c7c7 100755
--- a/launcher-package/build.sbt
+++ b/launcher-package/build.sbt
@@ -6,48 +6,43 @@ import DebianConstants.*
 import Dependencies.*
 
 lazy val sbtOfflineInstall =
-  sys.props.getOrElse("sbt.build.offline", sys.env.getOrElse("sbt.build.offline", "false")) match {
+  sys.props.getOrElse("sbt.build.offline", sys.env.getOrElse("sbt.build.offline", "false")) match
     case "true" | "1"  => true
     case "false" | "0" => false
     case _             => false
-  }
 lazy val sbtIncludeSbtn =
   sys.props.getOrElse(
     "sbt.build.includesbtn",
     sys.env.getOrElse("sbt.build.includesbtn", "true")
-  ) match {
+  ) match
     case "true" | "1"  => true
     case "false" | "0" => false
     case _             => false
-  }
 lazy val sbtIncludeSbtLaunch =
   sys.props.getOrElse(
     "sbt.build.includesbtlaunch",
     sys.env.getOrElse("sbt.build.includesbtlaunch", "true")
-  ) match {
+  ) match
     case "true" | "1"  => true
     case "false" | "0" => false
     case _             => false
-  }
 lazy val sbtVersionToRelease = sys.props
   .getOrElse("sbt.build.version", sys.env.getOrElse("sbt.build.version", "1.12.0"))
 
 lazy val scala210 = "2.10.7"
 lazy val scala210Jline = "org.scala-lang" % "jline" % scala210
-lazy val jansi = {
-  if (sbtVersionToRelease.startsWith("1.")) "org.fusesource.jansi" % "jansi" % "1.12"
+lazy val jansi =
+  if sbtVersionToRelease.startsWith("1.") then "org.fusesource.jansi" % "jansi" % "1.12"
   else "org.fusesource.jansi" % "jansi" % "1.4"
-}
 lazy val scala212Compiler = "org.scala-lang" % "scala-compiler" % scala212
 lazy val scala212Jline = "jline" % "jline" % "2.14.6"
 // use the scala-xml version used by the compiler not the latest: https://github.com/scala/scala/blob/v2.12.21/versions.properties
 lazy val scala212Xml = "org.scala-lang.modules" % "scala-xml_2.12" % "2.3.0"
 lazy val sbtActual = "org.scala-sbt" % "sbt" % sbtVersionToRelease
 
-lazy val sbt013ExtraDeps = {
-  if (sbtVersionToRelease.startsWith("0.13.")) Seq(scala210Jline)
+lazy val sbt013ExtraDeps =
+  if sbtVersionToRelease.startsWith("0.13.") then Seq(scala210Jline)
   else Seq()
-}
 
 lazy val isWindows: Boolean =
   sys.props("os.name").toLowerCase(java.util.Locale.ENGLISH).contains("windows")
@@ -115,10 +110,9 @@ val launcherPackage = (project in file("."))
       clean.value
     },
     credentials ++= {
-      (sys.env.get("BINTRAY_USER"), sys.env.get("BINTRAY_PASS")) match {
+      (sys.env.get("BINTRAY_USER"), sys.env.get("BINTRAY_PASS")) match
         case (Some(u), Some(p)) => Seq(Credentials("Bintray API Realm", "api.bintray.com", u, p))
         case _                  => Nil
-      }
     },
     pgpSecretRing := file(s"""${sys.props("user.home")}""") / ".ssh" / "scalasbt.key",
     pgpPublicRing := file(s"""${sys.props("user.home")}""") / ".ssh" / "scalasbt.pub",
@@ -128,20 +122,17 @@ val launcherPackage = (project in file("."))
     sbtLaunchJar := {
       val uri = sbtLaunchJarUrl.value
       val file = sbtLaunchJarLocation.value
-      if (!file.exists) {
+      if !file.exists then
         // oddly, some places require us to create the file before writing...
         IO.touch(file)
         val url = new URI(uri).toURL
         val connection = url.openConnection()
         val input = connection.getInputStream
         val writer = new java.io.BufferedOutputStream(new java.io.FileOutputStream(file))
-        try {
-          input.transferTo(writer)
-        } finally {
+        try input.transferTo(writer)
+        finally
           input.close()
           writer.close()
-        }
-      }
       // TODO - GPG Trust validation.
       fileConverter.value.toVirtualFile(file.toPath)
     },
@@ -158,76 +149,64 @@ val launcherPackage = (project in file("."))
       val linuxX86Tar = t / linuxX86ImageTar
       val linuxAarch64Tar = t / linuxAarch64ImageTar
       val windowsZip = t / windowsImageZip
-      if (!macosUniversalTar.exists && !isWindows && sbtIncludeSbtn) {
+      if !macosUniversalTar.exists && !isWindows && sbtIncludeSbtn then
         IO.touch(macosUniversalTar)
         val url = new URI(s"$baseUrl/v$v/$macosUniversalImageTar").toURL
         val connection = url.openConnection()
         val input = connection.getInputStream
         val writer =
           new java.io.BufferedOutputStream(new java.io.FileOutputStream(macosUniversalTar))
-        try {
-          input.transferTo(writer)
-        } finally {
+        try input.transferTo(writer)
+        finally
           input.close()
           writer.close()
-        }
         val platformDir = t / universalMacPlatform
         IO.createDirectory(platformDir)
         s"tar zxvf $macosUniversalTar --directory $platformDir".!
         IO.move(platformDir / "sbtn", t / universalMacImageName)
-      }
-      if (!linuxX86Tar.exists && !isWindows && sbtIncludeSbtn) {
+      if !linuxX86Tar.exists && !isWindows && sbtIncludeSbtn then
         IO.touch(linuxX86Tar)
         val url = new URI(s"$baseUrl/v$v/$linuxX86ImageTar").toURL
         val connection = url.openConnection()
         val input = connection.getInputStream
         val writer = new java.io.BufferedOutputStream(new java.io.FileOutputStream(linuxX86Tar))
-        try {
-          input.transferTo(writer)
-        } finally {
+        try input.transferTo(writer)
+        finally
           input.close()
           writer.close()
-        }
         val platformDir = t / x86LinuxPlatform
         IO.createDirectory(platformDir)
         s"""tar zxvf $linuxX86Tar --directory $platformDir""".!
         IO.move(platformDir / "sbtn", t / x86LinuxImageName)
-      }
-      if (!linuxAarch64Tar.exists && !isWindows && sbtIncludeSbtn) {
+      if !linuxAarch64Tar.exists && !isWindows && sbtIncludeSbtn then
         IO.touch(linuxAarch64Tar)
         val url = new URI(s"$baseUrl/v$v/$linuxAarch64ImageTar").toURL
         val connection = url.openConnection()
         val input = connection.getInputStream
         val writer = new java.io.BufferedOutputStream(new java.io.FileOutputStream(linuxAarch64Tar))
-        try {
-          input.transferTo(writer)
-        } finally {
+        try input.transferTo(writer)
+        finally
           input.close()
           writer.close()
-        }
         val platformDir = t / aarch64LinuxPlatform
         IO.createDirectory(platformDir)
         s"""tar zxvf $linuxAarch64Tar --directory $platformDir""".!
         IO.move(platformDir / "sbtn", t / aarch64LinuxImageName)
-      }
-      if (!windowsZip.exists && sbtIncludeSbtn) {
+      if !windowsZip.exists && sbtIncludeSbtn then
         IO.touch(windowsZip)
         val url = new URI(s"$baseUrl/v$v/$windowsImageZip").toURL
         val connection = url.openConnection()
         val input = connection.getInputStream
         val writer = new java.io.BufferedOutputStream(new java.io.FileOutputStream(windowsZip))
-        try {
-          input.transferTo(writer)
-        } finally {
+        try input.transferTo(writer)
+        finally
           input.close()
           writer.close()
-        }
         val platformDir = t / x86WindowsPlatform
         IO.unzip(windowsZip, platformDir)
         IO.move(platformDir / "sbtn.exe", t / x86WindowsImageName)
-      }
-      if (!sbtIncludeSbtn) Seq()
-      else if (isWindows)
+      if !sbtIncludeSbtn then Seq()
+      else if isWindows then
         Seq(
           fileConverter.value
             .toVirtualFile((t / x86WindowsImageName).toPath) -> s"bin/$x86WindowsImageName"
@@ -251,10 +230,10 @@ val launcherPackage = (project in file("."))
     // Here we remove the jar file and launch lib from the symlinks:
     linuxPackageSymlinks := {
       val links = linuxPackageSymlinks.value
-      for {
+      for
         link <- links
         if !link.destination.endsWith("sbt-launch.jar")
-      } yield link
+      yield link
     },
 
     // DEBIAN SPECIFIC
@@ -262,7 +241,7 @@ val launcherPackage = (project in file("."))
       .getOrElse("sbt.build.patch", sys.env.getOrElse("DIST_PATCHVER", "0"))
       .toInt,
     Debian / version := {
-      if (debianBuildId.value == 0) sbtVersionToRelease
+      if debianBuildId.value == 0 then sbtVersionToRelease
       else sbtVersionToRelease + "." + debianBuildId.value
     },
     // Used to have "openjdk-8-jdk" but that doesn't work on Ubuntu 14.04 https://github.com/sbt/sbt/issues/3105
@@ -287,11 +266,12 @@ val launcherPackage = (project in file("."))
     Rpm / version := {
       val stable0 = (sbtVersionToRelease.split("[^\\d]") filterNot (_.isEmpty) mkString ".")
       val stable =
-        if (rpmRelease.value == "0") stable0
+        if rpmRelease.value == "0" then stable0
         else stable0 + "." + rpmRelease.value
-      if (isExperimental) (sbtVersionToRelease.split("[^\\d]").filterNot(_.isEmpty).toList match {
-        case List(_, _, c, d) => List(0, 99, c, d).mkString(".")
-      })
+      if isExperimental then
+        (sbtVersionToRelease.split("[^\\d]").filterNot(_.isEmpty).toList match
+          case List(_, _, c, d) => List(0, 99, c, d).mkString(".")
+      )
       else stable
     },
     // remove sbtn from RPM because it complains about it being noarch
@@ -319,12 +299,11 @@ val launcherPackage = (project in file("."))
     Windows / version := {
       val bid = windowsBuildId.value
       val sv = sbtVersionToRelease
-      sv.split("[^\\d]").filterNot(_.isEmpty) match {
+      sv.split("[^\\d]").filterNot(_.isEmpty) match
         case Array(major, minor, bugfix, _*) if bid == 0 => Seq(major, minor, bugfix) mkString "."
         case Array(major, minor, bugfix, _*) => Seq(major, minor, bugfix, bid.toString) mkString "."
         case Array(major, minor)             => Seq(major, minor, "0", bid.toString) mkString "."
         case Array(major)                    => Seq(major, "0", "0", bid.toString) mkString "."
-      }
     },
     Windows / maintainer := "Scala Center",
     Windows / packageSummary := "sbt " + (Windows / version).value,
@@ -360,10 +339,9 @@ val launcherPackage = (project in file("."))
             )
           )
 
-          if (FileSystems.getDefault.supportedFileAttributeViews.contains("posix")) {
+          if FileSystems.getDefault.supportedFileAttributeViews.contains("posix") then
             val perms = Files.getPosixFilePermissions(fileConverter.value.toPath(k))
             Files.setPosixFilePermissions((t / "sbt").toPath, perms)
-          }
 
           (fileConverter.value.toVirtualFile((t / "sbt").toPath), BinSbt)
         case (k, BinBat) =>
@@ -380,7 +358,7 @@ val launcherPackage = (project in file("."))
       }
     },
     Universal / mappings ++= (Def.taskDyn {
-      if (sbtIncludeSbtLaunch)
+      if sbtIncludeSbtLaunch then
         Def.task {
           Seq(
             sbtLaunchJar.value -> "bin/sbt-launch.jar"
@@ -390,14 +368,14 @@ val launcherPackage = (project in file("."))
     }).value,
     Universal / mappings ++= sbtnJarsMappings.value,
     Universal / mappings ++= (Def.taskDyn {
-      if (sbtOfflineInstall && sbtVersionToRelease.startsWith("1."))
+      if sbtOfflineInstall && sbtVersionToRelease.startsWith("1.") then
         Def.task {
           val _ = ((dist / exportRepoUsingCoursier)).value
           directory(((dist / target)).value / "lib").map { (k, v) =>
             fileConverter.value.toVirtualFile(k.toPath) -> v
           }
         }
-      else if (sbtOfflineInstall)
+      else if sbtOfflineInstall then
         Def.task {
           val _ = ((dist / exportRepo)).value
           directory(((dist / target)).value / "lib").map { (k, v) =>
@@ -409,7 +387,7 @@ val launcherPackage = (project in file("."))
     Universal / mappings ++= {
       val base = baseDirectory.value
       val converter = fileConverter.value
-      if (sbtVersionToRelease.startsWith("0.13.")) Nil
+      if sbtVersionToRelease.startsWith("0.13.") then Nil
       else
         Seq[(HashedVirtualFileRef, String)](
           converter.toVirtualFile((base.getParentFile / "LICENSE").toPath) -> "LICENSE",
@@ -437,7 +415,7 @@ val launcherPackage = (project in file("."))
   )
 
 def downloadUrlForVersion(v: String) =
-  (v.split("[^\\d]") flatMap (i => catching(classOf[Exception]) opt (i.toInt))) match {
+  (v.split("[^\\d]") flatMap (i => catching(classOf[Exception]) opt (i.toInt))) match
     case Array(0, 11, 3, _*) =>
       "https://repo.typesafe.com/typesafe/ivy-releases/org.scala-sbt/sbt-launch/0.11.3-2/sbt-launch.jar"
     case Array(0, 11, x, _*) if x >= 3 =>
@@ -448,9 +426,8 @@ def downloadUrlForVersion(v: String) =
       "https://repo.scala-sbt.org/scalasbt/maven-snapshots/org/scala-sbt/sbt-launch/" + v + "/sbt-launch.jar"
     case _ =>
       "https://repo1.maven.org/maven2/org/scala-sbt/sbt-launch/" + v + "/sbt-launch-" + v + ".jar"
-  }
 
-def makePublishToForConfig(config: Configuration) = {
+def makePublishToForConfig(config: Configuration) =
   // Add the publish to and ensure global resolvers has the resolver we just configured.
   inConfig(config)(
     Seq(
@@ -461,14 +438,13 @@ def makePublishToForConfig(config: Configuration) = {
       bintrayRpmExperimentalUrl := s"https://scala.jfrog.io/artifactory/rpm-experimental/",
       bintrayGenericPackagesUrl := s"https://scala.jfrog.io/artifactory/native-packages/",
       bintrayTripple := {
-        config.name match {
+        config.name match
           case Debian.name if isExperimental =>
             ("debian-experimental", bintrayDebianExperimentalUrl.value, artifactoryDebianPattern)
           case Debian.name => ("debian", bintrayDebianUrl.value, artifactoryDebianPattern)
           case Rpm.name if isExperimental =>
             ("rpm-experimental", bintrayRpmExperimentalUrl.value, artifactoryLinuxPattern)
           case Rpm.name => ("rpm", bintrayRpmUrl.value, artifactoryLinuxPattern)
-        }
       },
       publishTo := {
         val (id, url, pattern) = bintrayTripple.value
@@ -477,26 +453,21 @@ def makePublishToForConfig(config: Configuration) = {
       }
     )
   )
-}
 
 def publishToSettings =
   Seq[Configuration](Debian, Rpm) flatMap makePublishToForConfig
 
-def downloadUrl(uri: URI, out: File): Unit = {
-  if (!out.exists) {
+def downloadUrl(uri: URI, out: File): Unit =
+  if !out.exists then
     IO.touch(out)
     val url = new URI(uri.toString).toURL
     val connection = url.openConnection()
     val input = connection.getInputStream
     val writer = new java.io.BufferedOutputStream(new java.io.FileOutputStream(out))
-    try {
-      input.transferTo(writer)
-    } finally {
+    try input.transferTo(writer)
+    finally
       input.close()
       writer.close()
-    }
-  }
-}
 
 def colonName(m: ModuleID): String = s"${m.organization}:${m.name}:${m.revision}"
 
@@ -504,7 +475,7 @@ lazy val dist = (project in file("dist"))
   .settings(
     name := "dist",
     scalaVersion := {
-      if (sbtVersionToRelease.startsWith("0.13.")) scala210
+      if sbtVersionToRelease.startsWith("0.13.") then scala210
       else scala212
     },
     libraryDependencies ++= Seq(
@@ -516,7 +487,7 @@ lazy val dist = (project in file("dist"))
     ) ++ sbt013ExtraDeps,
     exportRepo := {
       val outDir = exportRepoDirectory.value
-      sbtVersionToRelease match {
+      sbtVersionToRelease match
         case v if v.startsWith("1.") =>
           sys.error("sbt 1.x should use coursier")
         case v if v.startsWith("0.13.") =>
@@ -533,7 +504,6 @@ lazy val dist = (project in file("dist"))
             outbase / "srcs" / "compiler-interface-sources.jar"
           )
         case _ =>
-      }
       outDir
     },
     exportRepoDirectory := target.value / "lib" / "local-preloaded",
@@ -541,7 +511,7 @@ lazy val dist = (project in file("dist"))
     exportRepoUsingCoursier := {
       val outDirectory = exportRepoCsrDirectory.value
       val csr =
-        if (isWindows) (LocalRootProject / baseDirectory).value / "bin" / "coursier.bat"
+        if isWindows then (LocalRootProject / baseDirectory).value / "bin" / "coursier.bat"
         else (LocalRootProject / baseDirectory).value / "bin" / "coursier"
       val cache = target.value / "coursier"
       IO.delete(cache)
@@ -555,7 +525,7 @@ lazy val dist = (project in file("dist"))
         .listFiles(mavenCache / "org" / "scala-sbt" / "compiler-bridge_2.12", DirectoryFilter)
         .toList
         .headOption
-      compilerBridgeVer match {
+      compilerBridgeVer match
         case Some(bridgeDir) =>
           val bridgeVer = bridgeDir.getName
           s"$csr fetch --cache $cache --sources org.scala-sbt:compiler-bridge_2.10:$bridgeVer".!
@@ -564,7 +534,6 @@ lazy val dist = (project in file("dist"))
           s"$csr fetch --cache $cache --sources org.scala-sbt:compiler-bridge_2.13:$bridgeVer".!
         case _ =>
           sys.error("bridge not found")
-      }
       IO.copyDirectory(mavenCache, outDirectory, true, true)
       outDirectory
     },
diff --git a/launcher-package/integration-test/src/test/scala/BspConfigTest.scala b/launcher-package/integration-test/src/test/scala/BspConfigTest.scala
index da6d8369d..c7e24f6c7 100644
--- a/launcher-package/integration-test/src/test/scala/BspConfigTest.scala
+++ b/launcher-package/integration-test/src/test/scala/BspConfigTest.scala
@@ -61,7 +61,7 @@ object BspConfigTest extends BasicTestSuite:
       // Test execution of the generated argv
       // Run the BSP command with a very short timeout to verify it starts correctly
       // We just need to verify the command doesn't fail immediately on startup
-      if (!isWindows) {
+      if !isWindows then
         // On Unix, we can test the argv execution
         // Create a process and check if it starts (will timeout waiting for BSP input)
         val process = Process(argv.toSeq, tmp)
@@ -76,14 +76,13 @@ object BspConfigTest extends BasicTestSuite:
 
         // The process should either still be alive (waiting for BSP messages)
         // or have exited with code 0 (graceful)
-        if (!isAlive) {
+        if !isAlive then
           val exitCode = processBuilder.exitValue()
           assert(
             exitCode == 0 || exitCode == 143, // 143 = SIGTERM from destroy()
             s"BSP process failed with exit code $exitCode"
           )
-        }
-      }
+      end if
     }
     ()
   }
diff --git a/launcher-package/integration-test/src/test/scala/ExtendedRunnerTest.scala b/launcher-package/integration-test/src/test/scala/ExtendedRunnerTest.scala
index f001182aa..106b592c8 100755
--- a/launcher-package/integration-test/src/test/scala/ExtendedRunnerTest.scala
+++ b/launcher-package/integration-test/src/test/scala/ExtendedRunnerTest.scala
@@ -53,13 +53,12 @@ object ExtendedRunnerTest extends BasicTestSuite:
     assert(!out.linesIterator.exists(_.startsWith("sbt runner version:")))
   }
 
-  def testVersion(lines: List[String]): Unit = {
+  def testVersion(lines: List[String]): Unit =
     assert(lines.size >= 2)
     val expected0 = s"(?m)^sbt version in this project: $versionRegEx(\\r)?"
     assert(lines(0).matches(expected0))
     val expected1 = s"sbt runner version: $versionRegEx$$"
     assert(lines(1).matches(expected1))
-  }
 
   /* TODO: The lines seems to return List([0Jsbt runner version: 1.11.4) on CI
   test("sbt -V|-version|--version should print sbtVersion") {
@@ -113,12 +112,11 @@ object ExtendedRunnerTest extends BasicTestSuite:
   }
 
   test("sbt \"testOnly *\"") {
-    if (isMac) ()
-    else {
+    if isMac then ()
+    else
       val out = sbtProcess("testOnly *", "--no-colors", "-v").!!.linesIterator.toList
       assert(out.contains[String]("[info] HelloTest"))
       ()
-    }
   }
 
   test("sbt in empty directory") {
@@ -143,24 +141,17 @@ object ExtendedRunnerTest extends BasicTestSuite:
   }
 
   test("sbt --jvm-client") {
-    if (isMac) {
+    if isMac then
       // `--jvm-client` is flaky in macOS CI due to intermittent startup/connection failures.
       // Keep coverage on Linux/Windows where the behavior is stable.
       ()
-    } else {
+    else
       val out = sbtProcess("--jvm-client", "--no-colors", "compile").!!.linesIterator.toList
-      if (isWindows) {
-        println(out)
-      } else {
-        assert(out.exists { _.contains("server was not detected") })
-      }
+      if isWindows then println(out)
+      else assert(out.exists { _.contains("server was not detected") })
       val out2 = sbtProcess("--jvm-client", "--no-colors", "shutdown").!!.linesIterator.toList
-      if (isWindows) {
-        println(out2)
-      } else {
-        assert(out2.exists { _.contains("disconnected") })
-      }
-    }
+      if isWindows then println(out2)
+      else assert(out2.exists { _.contains("disconnected") })
     ()
   }
 
@@ -199,10 +190,10 @@ object ExtendedRunnerTest extends BasicTestSuite:
   // Test for issue #6485: Test `sbt --client` startup
   // https://github.com/sbt/sbt/issues/6485
   test("sbt --client startup time") {
-    if (isWindows || isMac) {
+    if isWindows || isMac then
       // Skip on Windows (sbtn behavior differs) and macOS CI (slow hostname resolution)
       ()
-    } else {
+    else
       // First call starts the server if not running (warmup)
       val warmup = sbtProcess("--client", "version").!
       assert(warmup == 0, "Warmup sbt --client version failed")
@@ -235,17 +226,17 @@ object ExtendedRunnerTest extends BasicTestSuite:
       // Cleanup: shutdown the server
       val shutdown = sbtProcess("--client", "shutdown").!
       assert(shutdown == 0, "Failed to shutdown sbt server")
-    }
+    end if
     ()
   }
 
   // Test for issue #8644: sbt.bat fails when project path contains parentheses
   // https://github.com/sbt/sbt/issues/8644
   test("sbt.bat handles paths with parentheses") {
-    if (!isWindows) {
+    if !isWindows then
       // This test is Windows-specific, skip on other platforms
       ()
-    } else {
+    else
       IO.withTemporaryDirectory { baseDir =>
         // Create a temporary directory with parentheses in the name
         val testDir = new File(baseDir, "test(parentheses)")
@@ -288,7 +279,7 @@ object ExtendedRunnerTest extends BasicTestSuite:
           s"Error message should not contain parsing error when path has parentheses. Error output: $errorOutput"
         )
       }
-    }
+    end if
     ()
   }
 end ExtendedRunnerTest
diff --git a/launcher-package/integration-test/src/test/scala/IntegrationTestPaths.scala b/launcher-package/integration-test/src/test/scala/IntegrationTestPaths.scala
index 1045e3844..b3339616c 100644
--- a/launcher-package/integration-test/src/test/scala/IntegrationTestPaths.scala
+++ b/launcher-package/integration-test/src/test/scala/IntegrationTestPaths.scala
@@ -8,30 +8,29 @@ import java.io.File
  * sbt.test.integrationtest.basedir when Test/fork is true so paths are
  * correct regardless of the forked JVM's working directory (e.g. on Windows).
  */
-object IntegrationTestPaths {
+object IntegrationTestPaths:
   private val baseDir: Option[File] =
     sys.props.get("sbt.test.integrationtest.basedir").map(new File(_))
 
   def sbtScript(isWindows: Boolean): File =
-    baseDir match {
+    baseDir match
       case Some(b) =>
-        val name = if (isWindows) "sbt.bat" else "sbt"
+        val name = if isWindows then "sbt.bat" else "sbt"
         new File(
           b.getParentFile.getParentFile,
           s"target/out/jvm/u/sbt-launcher-packaging/universal/stage/bin/$name"
         ).getAbsoluteFile
       case None =>
         val rel =
-          if (isWindows) "../../target/out/jvm/u/sbt-launcher-packaging/universal/stage/bin/sbt.bat"
+          if isWindows then
+            "../../target/out/jvm/u/sbt-launcher-packaging/universal/stage/bin/sbt.bat"
           else "../../target/out/jvm/u/sbt-launcher-packaging/universal/stage/bin/sbt"
         new File(rel).getAbsoluteFile
-    }
 
   def citestDir(citestVariant: String = "citest"): File =
-    baseDir match {
+    baseDir match
       case Some(b) =>
         new File(b.getParentFile, citestVariant).getAbsoluteFile
       case None =>
         new File("..", citestVariant).getAbsoluteFile
-    }
-}
+end IntegrationTestPaths
diff --git a/launcher-package/integration-test/src/test/scala/LauncherTestHelper.scala b/launcher-package/integration-test/src/test/scala/LauncherTestHelper.scala
index 324b5e67c..59feac95a 100644
--- a/launcher-package/integration-test/src/test/scala/LauncherTestHelper.scala
+++ b/launcher-package/integration-test/src/test/scala/LauncherTestHelper.scala
@@ -6,7 +6,7 @@ import java.util.Locale
  * Shared helper for launcher integration tests. When sbt.test.useSbtw=true on Windows,
  * tests use sbtw (JVM) as the runner instead of sbt.bat, to validate sbtw as a drop-in.
  */
-object LauncherTestHelper {
+object LauncherTestHelper:
   def isWindows: Boolean =
     sys.props("os.name").toLowerCase(Locale.ENGLISH).contains("windows")
 
@@ -21,4 +21,3 @@ object LauncherTestHelper {
       val cp = sys.props.get("sbt.test.classpath").getOrElse(System.getProperty("java.class.path"))
       Seq("java", "-cp", cp, "sbtw.Main")
     else Seq(scriptPath)
-}
diff --git a/launcher-package/integration-test/src/test/scala/RunnerScriptTest.scala b/launcher-package/integration-test/src/test/scala/RunnerScriptTest.scala
index 548ea1b7d..7214cd8ac 100644
--- a/launcher-package/integration-test/src/test/scala/RunnerScriptTest.scala
+++ b/launcher-package/integration-test/src/test/scala/RunnerScriptTest.scala
@@ -29,7 +29,7 @@ abstract class RunnerScriptTest extends verify.BasicTestSuite with ShellScriptUt
 
   testOutput("sbt --no-colors in SBT_OPTS", sbtOpts = "--no-colors")("compile", "-v"):
     (out: List[String]) =>
-      if (isWindows) cancel("Test not supported on windows")
+      if isWindows then cancel("Test not supported on windows")
       assert(out.contains[String]("-Dsbt.log.noformat=true"))
 
   testOutput("sbt --no-server")("compile", "--no-server", "-v"): (out: List[String]) =>
@@ -92,7 +92,7 @@ abstract class RunnerScriptTest extends verify.BasicTestSuite with ShellScriptUt
     javaOpts = "",
     sbtOpts = "-debug"
   )("compile", "-v"): (out: List[String]) =>
-    if (isWindows) cancel("Test not supported on windows")
+    if isWindows then cancel("Test not supported on windows")
 
     // Debug argument must appear in the 'commands' section (after the sbt-launch.jar argument) to work
     val sbtLaunchMatcher = """^.+sbt-launch.jar["]{0,1}$""".r
@@ -138,7 +138,7 @@ abstract class RunnerScriptTest extends verify.BasicTestSuite with ShellScriptUt
 
   testOutput("accept `--ivy` in `SBT_OPTS`", sbtOpts = "--ivy /ivy/dir")("-v"):
     (out: List[String]) =>
-      if (isWindows) cancel("Test not supported on windows")
+      if isWindows then cancel("Test not supported on windows")
       else assert(out.contains[String]("-Dsbt.ivy.home=/ivy/dir"))
 
   testOutput(
@@ -270,7 +270,7 @@ abstract class RunnerScriptTest extends verify.BasicTestSuite with ShellScriptUt
     distSbtoptsContents = "-Dsbt.test.config=dist-default",
     sbtOptsFileContents = "-Dsbt.test.config=project-local"
   )("-d", "-v"): (out: List[String]) =>
-    if (isWindows) cancel("Test not supported on windows")
+    if isWindows then cancel("Test not supported on windows")
     else
       // Find the command line section
       val cmdLineStart = out.indexWhere(_.contains("Executing command line"))
@@ -292,7 +292,7 @@ abstract class RunnerScriptTest extends verify.BasicTestSuite with ShellScriptUt
     machineSbtoptsContents = "-Dsbt.test.config=machine-config",
     sbtOptsFileContents = "-Dsbt.test.config=project-local"
   )("-d", "-v"): (out: List[String]) =>
-    if (isWindows) cancel("Test not supported on windows")
+    if isWindows then cancel("Test not supported on windows")
     else
       // Find the command line section
       val cmdLineStart = out.indexWhere(_.contains("Executing command line"))
@@ -315,7 +315,7 @@ abstract class RunnerScriptTest extends verify.BasicTestSuite with ShellScriptUt
     machineSbtoptsContents = "-Dsbt.test.config=machine-config",
     sbtOptsFileContents = "-Dsbt.test.config=project-local"
   )("-d", "-v"): (out: List[String]) =>
-    if (isWindows) cancel("Test not supported on windows")
+    if isWindows then cancel("Test not supported on windows")
     else
       // Find the command line section
       val cmdLineStart = out.indexWhere(_.contains("Executing command line"))
@@ -341,7 +341,7 @@ abstract class RunnerScriptTest extends verify.BasicTestSuite with ShellScriptUt
     sbtOptsFileContents =
       "-J-Xmx2g\n-J-XX:ReservedCodeCacheSize=1g\n-J-XX:MaxMetaspaceSize=2g\n-J-Xss512m\n-J-XX:+UseG1GC"
   )("-d", "-v", "-mem", "12288"): (out: List[String]) =>
-    if (isWindows) cancel("Test not supported on windows")
+    if isWindows then cancel("Test not supported on windows")
     else
       val cmdLineStart = out.indexWhere(_.contains("Executing command line"))
       assert(cmdLineStart >= 0, "Command line section not found")
diff --git a/launcher-package/integration-test/src/test/scala/ShellScriptUtil.scala b/launcher-package/integration-test/src/test/scala/ShellScriptUtil.scala
index 9661a3464..1eb5986e5 100644
--- a/launcher-package/integration-test/src/test/scala/ShellScriptUtil.scala
+++ b/launcher-package/integration-test/src/test/scala/ShellScriptUtil.scala
@@ -8,21 +8,19 @@ import scala.collection.mutable
 import scala.sys.process.{ BasicIO, Process, ProcessIO }
 import verify.BasicTestSuite
 
-trait ShellScriptUtil extends BasicTestSuite {
+trait ShellScriptUtil extends BasicTestSuite:
   val isWindows: Boolean =
     sys.props("os.name").toLowerCase(java.util.Locale.ENGLISH).contains("windows")
 
   protected val javaBinDir = new File("bin").getAbsolutePath
 
   protected def retry[A1](f: () => A1, maxAttempt: Int = 10): A1 =
-    try {
-      f()
-    } catch {
+    try f()
+    catch
       case e: Exception if maxAttempt > 1 =>
         Thread.sleep(100)
         retry(f, maxAttempt - 1)
       case e: Exception => throw e
-    }
 
   def isGitBashTest: Boolean = false
   lazy val sbtScript = IntegrationTestPaths.sbtScript(isWindows && !isGitBashTest)
@@ -56,31 +54,23 @@ trait ShellScriptUtil extends BasicTestSuite {
         val citestDir = IntegrationTestPaths.citestDir(citestVariant)
         // Clean target directory if it exists to avoid copying temporary files that may be deleted during copy
         val targetDir = new File(citestDir, "target")
-        if (targetDir.exists()) {
-          try {
-            IO.delete(targetDir)
-          } catch {
+        if targetDir.exists() then
+          try IO.delete(targetDir)
+          catch
             case _: Exception => // Ignore deletion errors, will retry copy
-          }
-        }
         // Retry copy operation to handle race conditions with temporary files
-        retry(() => {
-          try {
-            IO.copyDirectory(citestDir, workingDirectory)
-          } catch {
+        retry(() =>
+          try IO.copyDirectory(citestDir, workingDirectory)
+          catch
             case e: java.io.IOException if e.getMessage.contains("does not exist") =>
               // If a file doesn't exist during copy, clean target and retry
               val targetInCitest = new File(citestDir, "target")
-              if (targetInCitest.exists()) {
-                try {
-                  IO.delete(targetInCitest)
-                } catch {
+              if targetInCitest.exists() then
+                try IO.delete(targetInCitest)
+                catch
                   case _: Exception => // Ignore
-                }
-              }
               throw e // Re-throw to trigger retry
-          }
-        })
+        )
 
         var sbtHome: Option[File] = None
         var configHome: Option[File] = None
@@ -90,36 +80,32 @@ trait ShellScriptUtil extends BasicTestSuite {
           val sbtOptsFile = new File(workingDirectory, ".sbtopts")
           sbtOptsFile.createNewFile()
           val writer = new PrintWriter(sbtOptsFile)
-          try {
+          try
             writer.write(sbtOptsFileContents)
-          } finally {
+          finally
             writer.close()
-          }
 
           // Create .jvmopts file if contents provided
-          if (jvmoptsFileContents.nonEmpty) {
+          if jvmoptsFileContents.nonEmpty then
             val jvmoptsFile = new File(workingDirectory, ".jvmopts")
             jvmoptsFile.createNewFile()
             val jvmoptsWriter = new PrintWriter(jvmoptsFile)
-            try {
+            try
               jvmoptsWriter.write(jvmoptsFileContents)
-            } finally {
+            finally
               jvmoptsWriter.close()
-            }
-          }
 
-          if (buildPropsContents.nonEmpty) {
+          if buildPropsContents.nonEmpty then
             val projectDir = new File(workingDirectory, "project")
             projectDir.mkdirs()
             IO.write(new File(projectDir, "build.properties"), buildPropsContents)
-          }
 
           val envVars = scala.collection.mutable.Map[String, String]()
 
           // Set up dist sbtopts if provided
           // Note: sbt script derives sbt_home from script location, not SBT_HOME env var
           // Copy the sbt staging directory to a temp location to avoid modifying the staging directory
-          if (distSbtoptsContents.nonEmpty || stagedRunnerVersionOverride.nonEmpty) {
+          if distSbtoptsContents.nonEmpty || stagedRunnerVersionOverride.nonEmpty then
             val originalSbtHome = sbtScript.getParentFile.getParentFile
             val tempSbtHomeDir = Files.createTempDirectory("sbt-home-test").toFile
             tempSbtHome = Some(tempSbtHomeDir)
@@ -128,18 +114,17 @@ trait ShellScriptUtil extends BasicTestSuite {
             // Get the script from the copied directory
             val binDir = new File(tempSbtHomeDir, "bin")
             testSbtScript = new File(binDir, sbtScript.getName)
-            if (distSbtoptsContents.nonEmpty) {
+            if distSbtoptsContents.nonEmpty then
               // Create dist sbtopts in the copied directory
               val distSbtoptsDir = new File(tempSbtHomeDir, "conf")
               distSbtoptsDir.mkdirs()
               IO.write(new File(distSbtoptsDir, "sbtopts"), distSbtoptsContents)
-            }
-            if (stagedRunnerVersionOverride.nonEmpty) {
+            if stagedRunnerVersionOverride.nonEmpty then
               val isBat = testSbtScript.getName.endsWith(".bat")
               val prefix =
-                if (isBat) "set init_sbt_version=" else "declare init_sbt_version="
+                if isBat then "set init_sbt_version=" else "declare init_sbt_version="
               val pattern =
-                if (isBat) "(?m)^set init_sbt_version=.*$"
+                if isBat then "(?m)^set init_sbt_version=.*$"
                 else "(?m)^declare init_sbt_version=.*$"
               val original = IO.read(testSbtScript)
               val regex = pattern.r
@@ -152,17 +137,15 @@ trait ShellScriptUtil extends BasicTestSuite {
               val updated = regex.replaceAllIn(original, replacement)
               assert(updated.contains(prefix + stagedRunnerVersionOverride))
               IO.write(testSbtScript, updated)
-              if (!isBat) testSbtScript.setExecutable(true)
-            }
+              if !isBat then testSbtScript.setExecutable(true)
             // Store reference for cleanup
             sbtHome = Some(tempSbtHomeDir)
-          }
+          end if
 
           // Ensure no machine sbtopts exists when testing dist-only (unless explicitly provided)
           // The script only loads dist if machine doesn't exist
-          if (
-            distSbtoptsContents.nonEmpty && machineSbtoptsContents.isEmpty && configHome.isEmpty
-          ) {
+          if distSbtoptsContents.nonEmpty && machineSbtoptsContents.isEmpty && configHome.isEmpty
+          then
             // Set XDG_CONFIG_HOME to a temp directory without sbtopts to prevent default machine sbtopts from being found
             val emptyConfigHome = Files.createTempDirectory("empty-config-home").toFile
             envVars("XDG_CONFIG_HOME") = emptyConfigHome.getAbsolutePath
@@ -170,10 +153,9 @@ trait ShellScriptUtil extends BasicTestSuite {
             sys.env.get("SBT_ETC_FILE").foreach(_ => envVars("SBT_ETC_FILE") = "")
             // Store for cleanup
             configHome = Some(emptyConfigHome)
-          }
 
           // Set up machine sbtopts if provided
-          if (machineSbtoptsContents.nonEmpty) {
+          if machineSbtoptsContents.nonEmpty then
             val configHomeDir = Files.createTempDirectory("config-home").toFile
             configHome = Some(configHomeDir)
             val machineSbtoptsDir = new File(configHomeDir, "sbt")
@@ -181,7 +163,6 @@ trait ShellScriptUtil extends BasicTestSuite {
             val machineSbtoptsFile = new File(machineSbtoptsDir, "sbtopts")
             IO.write(machineSbtoptsFile, machineSbtoptsContents)
             envVars("XDG_CONFIG_HOME") = configHomeDir.getAbsolutePath
-          }
 
           val path = sys.env.getOrElse("PATH", sys.env.getOrElse("Path", ""))
           val javaHomeEnv = sys.env.getOrElse("JAVA_HOME", System.getProperty("java.home"))
@@ -220,5 +201,6 @@ trait ShellScriptUtil extends BasicTestSuite {
           // Clean up temporary sbt home directory if we created one
           tempSbtHome.foreach(IO.delete)
           configHome.foreach(IO.delete)
+        end try
       }
-}
+end ShellScriptUtil
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/CompatibilityWarning.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/CompatibilityWarning.scala
index 5f7550a4a..be9121093 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/CompatibilityWarning.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/CompatibilityWarning.scala
@@ -10,7 +10,7 @@ final class CompatibilityWarningOptions private[sbt] (
     val level: Level.Value
 )
 
-object CompatibilityWarningOptions {
+object CompatibilityWarningOptions:
   def default: CompatibilityWarningOptions =
     apply(configurations = List(Compile, Runtime), level = Level.Warn)
   def apply(
@@ -21,39 +21,33 @@ object CompatibilityWarningOptions {
       configurations = configurations,
       level = level
     )
-}
 
-private[sbt] object CompatibilityWarning {
+private[sbt] object CompatibilityWarning:
   def run(
       config: CompatibilityWarningOptions,
       module: ModuleDescriptor,
       mavenStyle: Boolean,
       log: Logger
-  ): Unit = {
-    if (mavenStyle) {
-      processIntransitive(config, module, log)
-    }
-  }
+  ): Unit =
+    if mavenStyle then processIntransitive(config, module, log)
   def processIntransitive(
       config: CompatibilityWarningOptions,
       module: ModuleDescriptor,
       log: Logger
-  ): Unit = {
+  ): Unit =
     val monitoredConfigsStr: Set[String] = (config.configurations map { _.name }).toSet
     def inMonitoredConfigs(configOpt: Option[String]): Boolean =
-      configOpt match {
+      configOpt match
         case Some(c) => (c.split(",").toSet intersect monitoredConfigsStr).nonEmpty
         case None    => monitoredConfigsStr contains "compile"
-      }
     module.directDependencies foreach { m =>
-      if (!m.isTransitive && inMonitoredConfigs(m.configurations)) {
+      if !m.isTransitive && inMonitoredConfigs(m.configurations) then
         log.warn(
           s"""Found intransitive dependency ($m) while publishMavenStyle is true, but Maven repositories
              |  do not support intransitive dependencies. Use exclusions instead so transitive dependencies
              |  will be correctly excluded in dependent projects.
            """.stripMargin
         )
-      } else ()
+      else ()
     }
-  }
-}
+end CompatibilityWarning
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/InternalDefaults.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/InternalDefaults.scala
index 3a13b5722..eccc6ce00 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/InternalDefaults.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/InternalDefaults.scala
@@ -8,7 +8,7 @@ import sbt.io.syntax.*
 /**
  * This is a list of functions with default values.
  */
-object InternalDefaults {
+object InternalDefaults:
   val sbtOrgTemp = JsonUtil.sbtOrgTemp
   val modulePrefixTemp = "temp-module-"
 
@@ -26,4 +26,3 @@ object InternalDefaults {
 
   def getDeliverStatus(opt: Option[String]): String =
     opt.getOrElse("release")
-}
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/IvyConfigurations.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/IvyConfigurations.scala
index 766ee55d4..2d0a2caac 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/IvyConfigurations.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/IvyConfigurations.scala
@@ -3,18 +3,15 @@
  */
 package sbt.librarymanagement
 
-private[librarymanagement] abstract class InlineConfigurationFunctions {
+private[librarymanagement] abstract class InlineConfigurationFunctions:
   def configurations(
       explicitConfigurations: Iterable[Configuration],
       defaultConfiguration: Option[Configuration]
   ) =
-    if (explicitConfigurations.isEmpty) {
-      defaultConfiguration match {
+    if explicitConfigurations.isEmpty then
+      defaultConfiguration match
         case Some(Configurations.DefaultIvyConfiguration)   => Configurations.Default :: Nil
         case Some(Configurations.DefaultMavenConfiguration) =>
           Configurations.defaultMavenConfigurations
         case _ => Nil
-      }
-    } else
-      explicitConfigurations
-}
+    else explicitConfigurations
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/IvySbt.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/IvySbt.scala
index c4f5650be..430fec7a0 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/IvySbt.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/IvySbt.scala
@@ -7,6 +7,5 @@ import sbt.librarymanagement.ModuleSettings
  * [[https://github.com/sbt/sbt/issues/9676]]
  */
 @deprecated("will be removed", "2.1.0")
-private[librarymanagement] final class IvySbt {
+private[librarymanagement] final class IvySbt:
   final class Module(rawModuleSettings: ModuleSettings)
-}
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/JsonUtil.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/JsonUtil.scala
index eea16125e..28e497c67 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/JsonUtil.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/JsonUtil.scala
@@ -5,7 +5,7 @@ import sbt.util.{ CacheStore, Logger }
 import sbt.librarymanagement.*, LibraryManagementCodec.given
 import sbt.io.IO
 
-private[sbt] object JsonUtil {
+private[sbt] object JsonUtil:
   def sbtOrgTemp = "org.scala-sbt.temp"
   def fakeCallerOrganization = "org.scala-sbt.temp-callers"
 
@@ -13,28 +13,25 @@ private[sbt] object JsonUtil {
       path: File,
       cachedDescriptor: File,
       log: Logger
-  ): UpdateReport = {
-    try {
+  ): UpdateReport =
+    try
       val lite = CacheStore(path).read[UpdateReportLite]()
       fromLite(lite, cachedDescriptor)
-    } catch {
+    catch
       case e: Throwable =>
         log.error(s"Unable to parse mini graph: $path")
         throw e
-    }
-  }
 
-  def writeUpdateReport(ur: UpdateReport, graphPath: File): Unit = {
+  def writeUpdateReport(ur: UpdateReport, graphPath: File): Unit =
     val updateReportLite = toLite(ur)
     IO.createDirectory(graphPath.getParentFile)
     CacheStore(graphPath).write(updateReportLite)
-  }
 
   /** The per-module normalization `toLite` applies; anything stored alongside it must match. */
-  private[sbt] def withFilteredCallers(mr: ModuleReport): ModuleReport = {
+  private[sbt] def withFilteredCallers(mr: ModuleReport): ModuleReport =
     val callers = filterOutArtificialCallers(mr.callers)
     // Reuse the instance when filtering changed nothing, so interning is not undone here.
-    if (callers eq mr.callers) mr
+    if callers eq mr.callers then mr
     else
       ModuleReport(
         mr.module,
@@ -56,11 +53,12 @@ private[sbt] object JsonUtil {
         mr.licenses,
         callers
       )
-  }
+    end if
+  end withFilteredCallers
 
   def toLite(ur: UpdateReport): UpdateReportLite =
     UpdateReportLite(ur.configurations map { cr =>
-      val details0 = if (cr.details.nonEmpty) cr.details else modulesToDetails(cr.modules)
+      val details0 = if cr.details.nonEmpty then cr.details else modulesToDetails(cr.modules)
       ConfigurationReportLite(
         cr.configuration.name,
         details0 map { oar =>
@@ -74,20 +72,19 @@ private[sbt] object JsonUtil {
     })
 
   private def modulesToDetails(modules: Vector[ModuleReport]): Vector[OrganizationArtifactReport] =
-    if (modules.isEmpty) Vector.empty
-    else {
+    if modules.isEmpty then Vector.empty
+    else
       val grouped = modules.groupBy(m => (m.module.organization, m.module.name))
       val orderedKeys = modules.map(m => (m.module.organization, m.module.name)).distinct
       orderedKeys.map { case (organization, name) =>
         OrganizationArtifactReport(organization, name, grouped((organization, name)))
       }
-    }
 
   // #1763/#2030. Caller takes up 97% of space, so we need to shrink it down,
   // but there are semantics associated with some of them.
   def filterOutArtificialCallers(callers: Vector[Caller]): Vector[Caller] =
-    if (callers.isEmpty) callers
-    else {
+    if callers.isEmpty then callers
+    else
       val nonArtificial = callers filter { c =>
         (c.caller.organization != sbtOrgTemp) &&
         (c.caller.organization != fakeCallerOrganization)
@@ -96,9 +93,8 @@ private[sbt] object JsonUtil {
         c.caller.organization == sbtOrgTemp
       }).toVector
       interProj ++ nonArtificial
-    }
 
-  def fromLite(lite: UpdateReportLite, cachedDescriptor: File): UpdateReport = {
+  def fromLite(lite: UpdateReportLite, cachedDescriptor: File): UpdateReport =
     val stats = UpdateStats(0L, 0L, 0L, false)
     val configReports = lite.configurations map { cr =>
       val details = cr.details
@@ -110,9 +106,8 @@ private[sbt] object JsonUtil {
       ConfigurationReport(ConfigRef(cr.configuration), modules, details)
     }
     UpdateReport(cachedDescriptor, configReports, stats, Map.empty)
-  }
 
-  def fromLiteFull(lite: UpdateReportLite, cachedDescriptor: File): UpdateReport = {
+  def fromLiteFull(lite: UpdateReportLite, cachedDescriptor: File): UpdateReport =
     val stats = UpdateStats(0L, 0L, 0L, false)
     val configReports = lite.configurations map { cr =>
       val details = cr.details
@@ -120,5 +115,4 @@ private[sbt] object JsonUtil {
       ConfigurationReport(ConfigRef(cr.configuration), modules, details)
     }
     UpdateReport(cachedDescriptor, configReports, stats, Map.empty)
-  }
-}
+end JsonUtil
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/LMSysProp.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/LMSysProp.scala
index 209e0cd11..95c2cbace 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/LMSysProp.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/LMSysProp.scala
@@ -12,15 +12,14 @@ package librarymanagement
 import java.util.Locale
 import scala.util.control.NonFatal
 
-object LMSysProp {
+object LMSysProp:
   def booleanOpt(name: String): Option[Boolean] =
     sys.props.get(name).flatMap { x =>
-      x.toLowerCase(Locale.ENGLISH) match {
+      x.toLowerCase(Locale.ENGLISH) match
         case "1" | "always" | "true" => Some(true)
         case "0" | "never" | "false" => Some(false)
         case "auto"                  => None
         case _                       => None
-      }
     }
 
   def getOrFalse(name: String): Boolean = booleanOpt(name).getOrElse(false)
@@ -44,23 +43,18 @@ object LMSysProp {
   lazy val modifyVersionRange: Boolean = getOrTrue("sbt.modversionrange")
 
   lazy val isJavaVersion9Plus: Boolean = javaVersion > 8
-  lazy val javaVersion: Int = {
-    try {
+  lazy val javaVersion: Int =
+    try
       // See Oracle section 1.5.3 at:
       // https://docs.oracle.com/javase/8/docs/technotes/guides/versioning/spec/versioning2.html
       val version = sys.props("java.specification.version").split("\\.").toList.map(_.toInt)
-      version match {
+      version match
         case 1 :: minor :: _ => minor
         case major :: _      => major
         case _               => 0
-      }
-    } catch {
-      case NonFatal(_) => 0
-    }
-  }
+    catch case NonFatal(_) => 0
 
   lazy val useGigahorse: Boolean = getOrFalse("sbt.gigahorse")
   lazy val maxPublishAttempts: Int =
     java.lang.Integer.getInteger("sbt.repository.publish.attempts", 3)
-
-}
+end LMSysProp
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/SemSelOperator.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/SemSelOperator.scala
index 942672269..9fd9294c3 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/SemSelOperator.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/SemSelOperator.scala
@@ -1,18 +1,15 @@
 package sbt.internal.librarymanagement
 
-sealed abstract class SemSelOperator {
-  override def toString: String = this match {
+sealed abstract class SemSelOperator:
+  override def toString: String = this match
     case SemSelOperator.Lte => "<="
     case SemSelOperator.Lt  => "<"
     case SemSelOperator.Gte => ">="
     case SemSelOperator.Gt  => ">"
     case SemSelOperator.Eq  => "="
-  }
-}
-object SemSelOperator {
+object SemSelOperator:
   case object Lte extends SemSelOperator
   case object Lt extends SemSelOperator
   case object Gte extends SemSelOperator
   case object Gt extends SemSelOperator
   case object Eq extends SemSelOperator
-}
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/SemanticSelectorExtra.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/SemanticSelectorExtra.scala
index 036fa3483..cfd09f30e 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/SemanticSelectorExtra.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/SemanticSelectorExtra.scala
@@ -6,68 +6,61 @@ import sbt.internal.librarymanagement.SemSelOperator.{ Lt, Lte, Gt, Gte, Eq }
 import scala.annotation.tailrec
 import java.util.Locale
 
-private[librarymanagement] abstract class SemSelAndChunkFunctions {
-  protected def parse(andClauseToken: String): SemSelAndChunk = {
+private[librarymanagement] abstract class SemSelAndChunkFunctions:
+  protected def parse(andClauseToken: String): SemSelAndChunk =
     val comparatorTokens =
       scala.collection.immutable.ArraySeq.unsafeWrapArray(andClauseToken.split("\\s+"))
     val hyphenIndex = comparatorTokens.indexWhere(_ == "-")
-    val comparators = if (hyphenIndex == -1) {
-      comparatorTokens.map(SemComparator.apply)
-    } else {
+    val comparators = if hyphenIndex == -1 then comparatorTokens.map(SemComparator.apply)
+    else
       // interpret `A.B.C - D.E.F` to `>=A.B.C <=D.E.F`
       val (before, after) = comparatorTokens.splitAt(hyphenIndex)
-      (before.lastOption, after.drop(1).headOption) match {
+      (before.lastOption, after.drop(1).headOption) match
         case (Some(fromStr), Some(toStr)) =>
           // from and to cannot have an operator.
-          if (hasOperator(fromStr) || hasOperator(toStr)) {
+          if hasOperator(fromStr) || hasOperator(toStr) then
             throw new IllegalArgumentException(
               s"Invalid ' - ' range, both side of comparators cannot have an operator: $fromStr - $toStr"
             )
-          }
           val from = SemComparator(fromStr)
           val to = SemComparator(toStr)
           val comparatorsBefore = before.dropRight(1).map(SemComparator.apply)
-          val comparatorsAfter = after.drop(2) match {
+          val comparatorsAfter = after.drop(2) match
             case tokens if !tokens.isEmpty =>
               parse(tokens.mkString(" ")).comparators
             case _ => Seq.empty
-          }
           from.withOp(Gte) +: to.withOp(Lte) +:
             (comparatorsBefore ++ comparatorsAfter)
         case _ =>
           throw new IllegalArgumentException(
             s"Invalid ' - ' range position, both side of versions must be specified: $andClauseToken"
           )
-      }
-    }
     SemSelAndChunk(comparators.flatMap(_.expandWildcard))
-  }
+  end parse
 
-  private def hasOperator(comparator: String): Boolean = {
+  private def hasOperator(comparator: String): Boolean =
     comparator.startsWith("<") ||
-    comparator.startsWith(">") ||
-    comparator.startsWith("=")
-  }
-}
+      comparator.startsWith(">") ||
+      comparator.startsWith("=")
+end SemSelAndChunkFunctions
 
-private[librarymanagement] abstract class SemComparatorExtra {
+private[librarymanagement] abstract class SemComparatorExtra:
   val op: SemSelOperator
   val major: Option[Long]
   val minor: Option[Long]
   val patch: Option[Long]
   val tags: Seq[String]
 
-  protected def toStringImpl: String = {
+  protected def toStringImpl: String =
     val versionStr = Seq(major, minor, patch)
       .collect { case Some(v) =>
         v.toString
       }
       .mkString(".")
-    val tagsStr = if (tags.nonEmpty) s"-${tags.mkString("-")}" else ""
+    val tagsStr = if tags.nonEmpty then s"-${tags.mkString("-")}" else ""
     s"$op$versionStr$tagsStr"
-  }
 
-  protected def matchesImpl(version: VersionNumber): Boolean = {
+  protected def matchesImpl(version: VersionNumber): Boolean =
     // Fill empty fields of version specifier with 0 or max value of Long.
     // By filling them, SemComparator realize the properties below
     // `<=1.0` is equivalent to `<1.1.0` (`<=1.0.${Long.MaxValue}`)
@@ -78,13 +71,12 @@ private[librarymanagement] abstract class SemComparatorExtra {
     // However this fills 0 for a comparator that have `=` operator,
     // a comparator that have empty part of version and `=` operator won't appear
     // because of expanding it to and clause of comparators.
-    val assumed = op match {
+    val assumed = op match
       case Lte => Long.MaxValue
       case Lt  => 0L
       case Gte => 0L
       case Gt  => Long.MaxValue
       case Eq  => 0L
-    }
     // empty fields of the version number are assumed to be 0.
     val versionNumber =
       (version._1.getOrElse(0L), version._2.getOrElse(0L), version._3.getOrElse(0L))
@@ -92,36 +84,34 @@ private[librarymanagement] abstract class SemComparatorExtra {
     val normalVersionCmp =
       implicitly[Ordering[(Long, Long, Long)]].compare(versionNumber, selector)
     val cmp =
-      if (normalVersionCmp == 0) comparePreReleaseTags(version.tags, tags)
+      if normalVersionCmp == 0 then comparePreReleaseTags(version.tags, tags)
       else normalVersionCmp
-    op match {
+    op match
       case Lte if cmp <= 0 => true
       case Lt if cmp < 0   => true
       case Gte if cmp >= 0 => true
       case Gt if cmp > 0   => true
       case Eq if cmp == 0  => true
       case _               => false
-    }
-  }
-  private def comparePreReleaseTags(ts1: Seq[String], ts2: Seq[String]): Int = {
+  end matchesImpl
+  private def comparePreReleaseTags(ts1: Seq[String], ts2: Seq[String]): Int =
     // > When major, minor, and patch are equal, a pre-release version has lower precedence than a normal version.
-    if (ts1.isEmpty && ts2.isEmpty) 0
-    else if (ts1.nonEmpty && ts2.isEmpty) -1 // ts1 is pre-release version
-    else if (ts1.isEmpty && ts2.nonEmpty) 1 // ts2 is pre-release version
+    if ts1.isEmpty && ts2.isEmpty then 0
+    else if ts1.nonEmpty && ts2.isEmpty then -1 // ts1 is pre-release version
+    else if ts1.isEmpty && ts2.nonEmpty then 1 // ts2 is pre-release version
     else compareTags(ts1, ts2)
-  }
 
   @tailrec
-  private def compareTags(ts1: Seq[String], ts2: Seq[String]): Int = {
+  private def compareTags(ts1: Seq[String], ts2: Seq[String]): Int =
     // > A larger set of pre-release fields has a higher precedence than a smaller set,
     // > if all of the preceding identifiers are equal.
-    if (ts1.isEmpty && ts2.isEmpty) 0
-    else if (ts1.nonEmpty && ts2.isEmpty) 1
-    else if (ts1.isEmpty && ts2.nonEmpty) -1
-    else {
+    if ts1.isEmpty && ts2.isEmpty then 0
+    else if ts1.nonEmpty && ts2.isEmpty then 1
+    else if ts1.isEmpty && ts2.nonEmpty then -1
+    else
       val ts1head = ts1.head
       val ts2head = ts2.head
-      val cmp = (ts1head.matches("\\d+"), ts2head.matches("\\d+")) match {
+      val cmp = (ts1head.matches("\\d+"), ts2head.matches("\\d+")) match
         // Identifiers consisting of only digits are compared numerically.
         // Numeric identifiers always have lower precedence than non-numeric identifiers.
         // Identifiers with letters are compared case-insensitive lexical order.
@@ -130,19 +120,16 @@ private[librarymanagement] abstract class SemComparatorExtra {
         case (true, false)  => -1
         case (false, false) =>
           ts1head.toLowerCase(Locale.ENGLISH).compareTo(ts2head.toLowerCase(Locale.ENGLISH))
-      }
-      if (cmp == 0) compareTags(ts1.tail, ts2.tail)
+      if cmp == 0 then compareTags(ts1.tail, ts2.tail)
       else cmp
-    }
-  }
 
   // Expand wildcard with `=` operator to and clause of comparators.
   // `=1.0` is equivalent to `>=1.0 <=1.0`
   protected def allFieldsSpecified: Boolean =
     major.isDefined && minor.isDefined && patch.isDefined
-}
+end SemComparatorExtra
 
-private[librarymanagement] abstract class SemComparatorFunctions {
+private[librarymanagement] abstract class SemComparatorFunctions:
   private val ComparatorRegex = """(?x)^
       ([<>]=?|=)?
       (?:(\d+|[xX*])
@@ -151,8 +138,8 @@ private[librarymanagement] abstract class SemComparatorFunctions {
         )?
       )((?:-\w+(?:\.\w+)*)*)$
     """.r
-  protected def parse(comparator: String): SemComparator = {
-    comparator match {
+  protected def parse(comparator: String): SemComparator =
+    comparator match
       case ComparatorRegex(rawOp, rawMajor, rawMinor, rawPatch, ts) =>
         val opStr = Option(rawOp)
         val major = Option(rawMajor)
@@ -167,8 +154,8 @@ private[librarymanagement] abstract class SemComparatorFunctions {
           case Some(str) => str.matches("[xX*]")
           case None      => false
         }
-        if (hasXrangeSelector) {
-          if (tags.nonEmpty)
+        if hasXrangeSelector then
+          if tags.nonEmpty then
             throw new IllegalArgumentException(
               s"Pre-release version requires major, minor, patch versions to be specified: $comparator"
             )
@@ -183,12 +170,12 @@ private[librarymanagement] abstract class SemComparatorFunctions {
               }
               .mkString(".")
           )
-        } else {
-          if (tags.nonEmpty && (major.isEmpty || minor.isEmpty || patch.isEmpty))
+        else
+          if tags.nonEmpty && (major.isEmpty || minor.isEmpty || patch.isEmpty) then
             throw new IllegalArgumentException(
               s"Pre-release version requires major, minor, patch versions to be specified: $comparator"
             )
-          val operator = opStr match {
+          val operator = opStr match
             case Some("<")  => Lt
             case Some("<=") => Lte
             case Some(">")  => Gt
@@ -197,7 +184,6 @@ private[librarymanagement] abstract class SemComparatorFunctions {
             case None       => Eq
             case Some(_)    =>
               throw new IllegalArgumentException(s"Invalid operator: $opStr")
-          }
           SemComparator(
             operator,
             major.map(_.toLong),
@@ -205,12 +191,10 @@ private[librarymanagement] abstract class SemComparatorFunctions {
             patch.map(_.toLong),
             tags
           )
-        }
+        end if
       case _ => throw new IllegalArgumentException(s"Invalid comparator: $comparator")
-    }
-  }
   private def splitOn(s: String, sep: Char): Vector[String] =
-    if (s eq null) Vector()
+    if s eq null then Vector()
     else s.split(sep).filterNot(_ == "").toVector
   private def splitDash(s: String) = splitOn(s, '-')
-}
+end SemComparatorFunctions
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/StringUtilities.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/StringUtilities.scala
index e5d878cec..650c29468 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/StringUtilities.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/StringUtilities.scala
@@ -3,8 +3,7 @@
  */
 package sbt.internal.librarymanagement
 
-object StringUtilities {
+object StringUtilities:
   def nonEmpty(s: String, label: String): Unit =
     require(s.trim.length > 0, label + " cannot be empty.")
-  def appendable(s: String) = if (s.isEmpty) "" else "_" + s
-}
+  def appendable(s: String) = if s.isEmpty then "" else "_" + s
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateClassifiersUtil.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateClassifiersUtil.scala
index 239a49c03..2094768b7 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateClassifiersUtil.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateClassifiersUtil.scala
@@ -4,13 +4,13 @@ import java.io.File
 import sbt.librarymanagement.*
 import sbt.librarymanagement.syntax.*
 
-object UpdateClassifiersUtil {
+object UpdateClassifiersUtil:
 
   def restrictedCopy(m: ModuleID, confs: Boolean) =
     ModuleID(m.organization, m.name, m.revision)
       .withCrossVersion(m.crossVersion)
       .withExtraAttributes(m.extraAttributes)
-      .withConfigurations(if (confs) m.configurations else None)
+      .withConfigurations(if confs then m.configurations else None)
       .branch(m.branchName)
 
   // This version adds explicit artifact
@@ -18,37 +18,33 @@ object UpdateClassifiersUtil {
       classifiers: Vector[String],
       exclude: Map[ModuleID, Set[ConfigRef]],
       artifacts: Vector[(String, ModuleID, Artifact, File)]
-  )(m: ModuleID): Option[ModuleID] = {
+  )(m: ModuleID): Option[ModuleID] =
     def sameModule(m1: ModuleID, m2: ModuleID): Boolean =
       m1.organization == m2.organization && m1.name == m2.name && m1.revision == m2.revision
-    def explicitArtifacts = {
+    def explicitArtifacts =
       val arts = (artifacts collect {
         case (_, x, art, _) if sameModule(m, x) && art.classifier.isDefined => art
       }).distinct
-      if (arts.isEmpty) None
+      if arts.isEmpty then None
       else Some(intransitiveModuleWithExplicitArts(m, arts))
-    }
     def hardcodedArtifacts = classifiedArtifacts(classifiers, exclude)(m)
     explicitArtifacts orElse hardcodedArtifacts
-  }
 
   def classifiedArtifacts(
       classifiers: Vector[String],
       exclude: Map[ModuleID, Set[ConfigRef]]
-  )(m: ModuleID): Option[ModuleID] = {
+  )(m: ModuleID): Option[ModuleID] =
     val excluded: Set[ConfigRef] = exclude.getOrElse(restrictedCopy(m, false), Set.empty)
     val exls = excluded map { _.name }
     val included = classifiers filterNot exls
-    if (included.isEmpty) None
-    else {
+    if included.isEmpty then None
+    else
       Some(
         intransitiveModuleWithExplicitArts(
           module = m,
           arts = classifiedArtifacts(m.name, included)
         )
       )
-    }
-  }
 
   def classifiedArtifacts(name: String, classifiers: Vector[String]): Vector[Artifact] =
     classifiers map { c =>
@@ -98,5 +94,4 @@ object UpdateClassifiersUtil {
 
   private def getExcluded(id: ModuleID, exclude: Map[ModuleID, Set[String]]): Set[String] =
     exclude.getOrElse(restrictedCopy(id, false), Set.empty[String])
-
-}
+end UpdateClassifiersUtil
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateReportInterner.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateReportInterner.scala
index 3da755a08..ffa65fd95 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateReportInterner.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateReportInterner.scala
@@ -16,7 +16,7 @@ import sbt.librarymanagement.*
  *
  * The pools are weak, so an entry lives only as long as some report references it.
  */
-object UpdateReportInterner {
+object UpdateReportInterner:
 
   private val configRefs = new WeakInterner[ConfigRef]
   private val rules = new WeakInterner[InclExclRule]
@@ -36,16 +36,15 @@ object UpdateReportInterner {
     artifacts.internWith(a) { artifact =>
       // Canonicalize the nested vectors so value-equal artifacts share their pieces even when only
       // encountered once.
-      if (artifact.configurations.isEmpty) artifact
+      if artifact.configurations.isEmpty then artifact
       else artifact.withConfigurations(artifact.configurations.map(intern))
     }
 
   def intern(m: ModuleID): ModuleID =
     moduleIds.internWith(m) { moduleId =>
-      if (
-        moduleId.inclusions.isEmpty && moduleId.exclusions.isEmpty &&
+      if moduleId.inclusions.isEmpty && moduleId.exclusions.isEmpty &&
         moduleId.explicitArtifacts.isEmpty
-      ) moduleId
+      then moduleId
       else
         moduleId
           .withInclusions(moduleId.inclusions.map(intern))
@@ -62,7 +61,7 @@ object UpdateReportInterner {
 
   def intern(mr: ModuleReport): ModuleReport =
     // A publicationDate is a mutable Calendar, so canonicalize such a report but never pool it.
-    if (mr.publicationDate.isDefined) canonicalize(mr)
+    if mr.publicationDate.isDefined then canonicalize(mr)
     else moduleReports.internWith(mr)(canonicalize)
 
   private def canonicalize(mr: ModuleReport): ModuleReport =
@@ -71,4 +70,4 @@ object UpdateReportInterner {
       .withMissingArtifacts(mr.missingArtifacts.map(intern))
       .withConfigurations(mr.configurations.map(intern))
       .withCallers(mr.callers.map(intern))
-}
+end UpdateReportInterner
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateReportPersistence.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateReportPersistence.scala
index 70ddf5470..e4f518133 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateReportPersistence.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/UpdateReportPersistence.scala
@@ -141,6 +141,7 @@ object UpdateReportPersistence:
         case hit => hit.intValue
 
     def result(): Vector[ModuleReport] = table.result()
+  end ModuleTable
 
   private def writeV1[J](obj: UpdateReportCache, builder: Builder[J]): Unit =
     val modules = new ModuleTable
@@ -196,6 +197,7 @@ object UpdateReportPersistence:
       cachedDescriptor,
       configurations.map(cfg => cfg.modules.getOrElse(cfg.details.flatMap(_.modules)).map(modules))
     )
+  end readV1
 
   /**
    * `lookupField` consumes nothing, so the branch readers below still see every field. Each branch
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/VersionRange.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/VersionRange.scala
index bf5c62bba..bbf9f2823 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/VersionRange.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/VersionRange.scala
@@ -4,18 +4,17 @@ package librarymanagement
 
 import sbt.librarymanagement.VersionNumber
 
-object VersionRange {
+object VersionRange:
 
   /** True if the revision is an ivy-range, not a complete revision. */
-  def isVersionRange(revision: String): Boolean = {
+  def isVersionRange(revision: String): Boolean =
     (revision.endsWith("+")) ||
-    (revision.contains("[")) ||
-    (revision.contains("]")) ||
-    (revision.contains("(")) ||
-    (revision.contains(")")) ||
-    // Comma-separated range e.g. "1.3.1,2.3" (fixes #6244 when Coursier passes range without brackets)
-    (revision.contains(",") && revision.exists(_.isDigit))
-  }
+      (revision.contains("[")) ||
+      (revision.contains("]")) ||
+      (revision.contains("(")) ||
+      (revision.contains(")")) ||
+      // Comma-separated range e.g. "1.3.1,2.3" (fixes #6244 when Coursier passes range without brackets)
+      (revision.contains(",") && revision.exists(_.isDigit))
 
   /**
    * Checks if a version satisfies a version range.
@@ -23,46 +22,40 @@ object VersionRange {
    * @param range The version range (e.g., "[4.1.0,5)" or "[1.0,2.0]")
    * @return true if version is within the range, false otherwise
    */
-  def versionSatisfiesRange(version: String, range: String): Boolean = {
-    if (!isVersionRange(range)) {
+  def versionSatisfiesRange(version: String, range: String): Boolean =
+    if !isVersionRange(range) then
       // Not a range, just compare directly
       version == range
-    } else if (range.contains(",") && !hasMavenVersionRange(range)) {
+    else if range.contains(",") && !hasMavenVersionRange(range) then
       // Comma-separated range without brackets e.g. "1.3.1,2.3" (fixes #6244)
       val parts = range.split(",", 2)
-      if (parts.length == 2) {
+      if parts.length == 2 then
         val lower = parts(0).trim
         val upper = parts(1).trim
         lower.nonEmpty && upper.nonEmpty &&
         compareVersions(version, lower) >= 0 && compareVersions(version, upper) <= 0
-      } else false
-    } else if (range.endsWith("+")) {
+      else false
+    else if range.endsWith("+") then
       // Handle plus ranges like "1.0+" meaning >= 1.0
       val base = range.dropRight(1)
       compareVersions(version, base) >= 0
-    } else if (hasMavenVersionRange(range)) {
+    else if hasMavenVersionRange(range) then
       // Parse Maven-style range like [1.0,2.0) or (1.0,2.0]
-      parseMavenRange(range) match {
+      parseMavenRange(range) match
         case Some((lowerBound, lowerInclusive, upperBound, upperInclusive)) =>
-          val lowerOk = lowerBound match {
+          val lowerOk = lowerBound match
             case Some(lb) =>
               val cmp = compareVersions(version, lb)
-              if (lowerInclusive) cmp >= 0 else cmp > 0
+              if lowerInclusive then cmp >= 0 else cmp > 0
             case None => true
-          }
-          val upperOk = upperBound match {
+          val upperOk = upperBound match
             case Some(ub) =>
               val cmp = compareVersions(version, ub)
-              if (upperInclusive) cmp <= 0 else cmp < 0
+              if upperInclusive then cmp <= 0 else cmp < 0
             case None => true
-          }
           lowerOk && upperOk
         case None => false
-      }
-    } else {
-      false
-    }
-  }
+    else false
 
   /**
    * Parses a Maven-style version range.
@@ -70,48 +63,46 @@ object VersionRange {
    */
   private def parseMavenRange(
       range: String
-  ): Option[(Option[String], Boolean, Option[String], Boolean)] = {
+  ): Option[(Option[String], Boolean, Option[String], Boolean)] =
     val trimmed = range.trim
-    if (trimmed.length < 2) None
-    else {
+    if trimmed.length < 2 then None
+    else
       val startChar = trimmed.head
       val endChar = trimmed.last
 
       val lowerInclusive = startChar == '['
       val upperInclusive = endChar == ']'
 
-      if (!Set('[', '(').contains(startChar) || !Set(']', ')').contains(endChar)) {
-        None
-      } else {
+      if !Set('[', '(').contains(startChar) || !Set(']', ')').contains(endChar) then None
+      else
         val inner = trimmed.substring(1, trimmed.length - 1)
         val commaIdx = inner.indexOf(',')
 
-        if (commaIdx < 0) {
+        if commaIdx < 0 then
           // Single version constraint like [1.0] means exactly 1.0
           val v = inner.trim
-          if (v.nonEmpty) Some((Some(v), true, Some(v), true))
+          if v.nonEmpty then Some((Some(v), true, Some(v), true))
           else None
-        } else {
+        else
           val lower = inner.substring(0, commaIdx).trim
           val upper = inner.substring(commaIdx + 1).trim
           Some(
             (
-              if (lower.nonEmpty) Some(lower) else None,
+              if lower.nonEmpty then Some(lower) else None,
               lowerInclusive,
-              if (upper.nonEmpty) Some(upper) else None,
+              if upper.nonEmpty then Some(upper) else None,
               upperInclusive
             )
           )
-        }
-      }
-    }
-  }
+      end if
+    end if
+  end parseMavenRange
 
   /**
    * Compares two version strings.
    * @return negative if v1 < v2, 0 if v1 == v2, positive if v1 > v2
    */
-  private def compareVersions(v1: String, v2: String): Int = {
+  private def compareVersions(v1: String, v2: String): Int =
     val vn1 = VersionNumber(v1)
     val vn2 = VersionNumber(v2)
 
@@ -122,13 +113,13 @@ object VersionRange {
 
     val numericComparison = (0 until maxLen).iterator
       .map { i =>
-        val n1 = if (i < nums1.length) nums1(i) else 0L
-        val n2 = if (i < nums2.length) nums2(i) else 0L
+        val n1 = if i < nums1.length then nums1(i) else 0L
+        val n2 = if i < nums2.length then nums2(i) else 0L
         n1.compare(n2)
       }
       .find(_ != 0)
 
-    numericComparison match {
+    numericComparison match
       case Some(cmp) => cmp
       case None      =>
         // If numeric parts are equal, compare tags (versions with tags are usually pre-releases)
@@ -136,61 +127,56 @@ object VersionRange {
         val tags2 = vn2.tags
 
         // No tags means release version, which is higher than any pre-release
-        if (tags1.isEmpty && tags2.nonEmpty) 1
-        else if (tags1.nonEmpty && tags2.isEmpty) -1
-        else {
+        if tags1.isEmpty && tags2.nonEmpty then 1
+        else if tags1.nonEmpty && tags2.isEmpty then -1
+        else
           // Compare tags lexicographically
           val tagMaxLen = math.max(tags1.length, tags2.length)
           val tagComparison = (0 until tagMaxLen).iterator
             .map { i =>
-              val t1 = if (i < tags1.length) tags1(i) else ""
-              val t2 = if (i < tags2.length) tags2(i) else ""
+              val t1 = if i < tags1.length then tags1(i) else ""
+              val t2 = if i < tags2.length then tags2(i) else ""
               t1.compare(t2)
             }
             .find(_ != 0)
           tagComparison.getOrElse(0)
-        }
-    }
-  }
+    end match
+  end compareVersions
 
   // Assuming Ivy is used to resolve conflict, this removes the version range
   // when it is open-ended to avoid dependency resolution hitting the Internet to get the latest.
   // See https://github.com/sbt/sbt/issues/2954
   def stripMavenVersionRange(version: String): Option[String] =
-    if (isVersionRange(version)) {
+    if isVersionRange(version) then
       val noSpace = version.replace(" ", "")
-      noSpace match {
+      noSpace match
         case MavenVersionSetPattern(open1, x1, comma, x2, close1, _) =>
           // http://maven.apache.org/components/enforcer/enforcer-rules/versionRanges.html
-          (open1, Option(x1), Option(comma), Option(x2), close1) match {
+          (open1, Option(x1), Option(comma), Option(x2), close1) match
             case (_, None, _, Some(x2), "]") => Some(x2)
             // a good upper bound is unknown
             case (_, None, _, Some(_), ")") => None
             case (_, Some(x1), _, None, _)  => Some(x1)
             case _                          => None
-          }
         case _ => None
-      }
-    } else None
+    else None
 
   /** Converts Ivy revision ranges to that of Maven POM */
-  def fromIvyToMavenVersion(revision: String): String = {
-    def plusRange(s: String, shift: Int = 0) = {
-      def pow(i: Int): Int = if (i > 0) 10 * pow(i - 1) else 1
-      val (prefixVersion, lastVersion) = (s + "0" * shift).reverse.split("\\.", 2) match {
+  def fromIvyToMavenVersion(revision: String): String =
+    def plusRange(s: String, shift: Int = 0) =
+      def pow(i: Int): Int = if i > 0 then 10 * pow(i - 1) else 1
+      val (prefixVersion, lastVersion) = (s + "0" * shift).reverse.split("\\.", 2) match
         case Array(revLast, revRest) =>
           (revRest.reverse + ".", revLast.reverse)
         case Array(revLast) => ("", revLast.reverse)
-      }
       val lastVersionInt = lastVersion.toInt
       s"[${prefixVersion}${lastVersion},${prefixVersion}${lastVersionInt + pow(shift)})"
-    }
     val DotPlusPattern = """(.+)\.\+""".r
     val DotNumPlusPattern = """(.+)\.(\d+)\+""".r
     val NumPlusPattern = """(\d+)\+""".r
     val maxDigit = 5
-    try {
-      revision match {
+    try
+      revision match
         case "+"                  => "[0,)"
         case DotPlusPattern(base) => plusRange(base)
         // This is a heuristic.  Maven just doesn't support Ivy's notions of 1+, so
@@ -204,24 +190,23 @@ object VersionRange {
           val start = rev(0)
           val stop = rev(rev.length - 1)
           val mid = rev.substring(1, rev.length - 1)
-          (if (start == ']') "(" else start.toString) + mid + (if (stop == '[') ")" else stop)
+          (if start == ']' then "(" else start.toString) + mid + (if stop == '[' then ")" else stop)
         case _ => revision
-      }
-    } catch {
+    catch
       case _: NumberFormatException =>
         // TODO - if the version doesn't meet our expectations, maybe we just issue a hard
         //        error instead of softly ignoring the attempt to rewrite.
         // sys.error(s"Could not fix version [$revision] into maven style version")
         revision
-    }
-  }
+    end try
+  end fromIvyToMavenVersion
 
   def hasMavenVersionRange(version: String): Boolean =
-    if (version.length <= 1) false
+    if version.length <= 1 then false
     else startSym(version(0)) && stopSym(version(version.length - 1))
 
   private val startSym = Set(']', '[', '(')
   private val stopSym = Set(']', '[', ')')
   private val MavenVersionSetPattern =
     """([\]\[\(])([\w\.\-]+)?(,)?([\w\.\-]+)?([\]\[\)])(,.+)?""".r
-}
+end VersionRange
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/VersionSchemes.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/VersionSchemes.scala
index 685894312..d44bc4cc9 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/VersionSchemes.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/VersionSchemes.scala
@@ -13,7 +13,7 @@ import sbt.internal.librarymanagement.mavenint.SbtPomExtraProperties
 import sbt.librarymanagement.{ EvictionWarningOptions, ModuleID, ScalaModuleInfo }
 
 // See APIMappings.scala
-private[sbt] object VersionSchemes {
+private[sbt] object VersionSchemes:
   final val EarlySemVer = "early-semver"
   final val SemVerSpec = "semver-spec"
   final val PackVer = "pvp"
@@ -21,7 +21,7 @@ private[sbt] object VersionSchemes {
   final val Always = "always"
 
   def validateScheme(value: String): Unit =
-    value match {
+    value match
       case EarlySemVer | SemVerSpec | PackVer | Strict | Always => ()
       case "semver"                                             =>
         sys.error(
@@ -34,7 +34,6 @@ private[sbt] object VersionSchemes {
              |Specify 'semver-spec' for the spec-correct SemVer.""".stripMargin
         )
       case x => sys.error(s"unknown version scheme: $x")
-    }
 
   /**
    * info.versionScheme property will be included into POM after sbt 1.4.0.
@@ -47,11 +46,10 @@ private[sbt] object VersionSchemes {
   def evalFunc(
       scheme: String
   ): Function1[(ModuleID, Option[ModuleID], Option[ScalaModuleInfo]), Boolean] =
-    scheme match {
+    scheme match
       case EarlySemVer => EvictionWarningOptions.guessEarlySemVer
       case SemVerSpec  => EvictionWarningOptions.guessSemVer
       case PackVer     => EvictionWarningOptions.evalPvp
       case Strict      => EvictionWarningOptions.guessStrict
       case Always      => EvictionWarningOptions.guessTrue
-    }
-}
+end VersionSchemes
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/WeakPools.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/WeakPools.scala
index 91108dc53..8b76f54f5 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/WeakPools.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/WeakPools.scala
@@ -18,56 +18,48 @@ import scala.annotation.tailrec
  *
  * Ported from zinc's `sbt.internal.inc.WeakInterner` to avoid a new dependency, plus `internWith`.
  */
-private[librarymanagement] final class WeakInterner[A <: AnyRef] {
+private[librarymanagement] final class WeakInterner[A <: AnyRef]:
   private val stale = new ReferenceQueue[A]
   private val pool = new ConcurrentHashMap[WeakValue[A], WeakValue[A]]
 
   def intern(a: A): A = internWith(a)(identity)
 
   /** Like `intern`, but applies `canonicalize` only on a miss, since equality is structural. */
-  def internWith(a: A)(canonicalize: A => A): A = {
+  def internWith(a: A)(canonicalize: A => A): A =
     expunge()
-    lookup(a) match {
+    lookup(a) match
       case null => publish(canonicalize(a))
       case hit  => hit
-    }
-  }
 
   /** The pooled instance value-equal to `a`, or null if there is none. */
-  private def lookup(a: A): A = {
+  private def lookup(a: A): A =
     val probe = new WeakValue(a, stale)
     try
-      pool.get(probe) match {
+      pool.get(probe) match
         case null     => null.asInstanceOf[A]
         case existing => existing.get // null if it was collected since it matched
-      }
     finally probe.clear() // never enqueue a reference that was not pooled
-  }
 
-  private def publish(a: A): A = {
+  private def publish(a: A): A =
     val candidate = new WeakValue(a, stale)
-    @tailrec def attempt(): A = pool.putIfAbsent(candidate, candidate) match {
+    @tailrec def attempt(): A = pool.putIfAbsent(candidate, candidate) match
       case null     => a
       case existing =>
-        existing.get match {
+        existing.get match
           case null => // collected since it matched: drop the dead entry and retry
             pool.remove(existing, existing)
             attempt()
           case canonical =>
             candidate.clear()
             canonical
-        }
-    }
     attempt()
-  }
 
-  @tailrec private def expunge(): Unit = stale.poll() match {
+  @tailrec private def expunge(): Unit = stale.poll() match
     case null => ()
     case dead =>
       pool.remove(dead, dead)
       expunge()
-  }
-}
+end WeakInterner
 
 /**
  * Weak reference that hashes and compares by its referent's value.
@@ -76,16 +68,14 @@ private[librarymanagement] final class WeakInterner[A <: AnyRef] {
  * could never be found and removed.
  */
 private final class WeakValue[A <: AnyRef](a: A, stale: ReferenceQueue[A])
-    extends WeakReference[A](a, stale) {
+    extends WeakReference[A](a, stale):
   private val hash: Int = a.hashCode
 
   override def hashCode(): Int = hash
-  override def equals(other: Any): Boolean = other match {
+  override def equals(other: Any): Boolean = other match
     case that: WeakValue[?] =>
       (this `eq` that) || {
         val value = get
         value != null && value == that.get
       }
     case _ => false
-  }
-}
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/cross/CrossVersionUtil.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/cross/CrossVersionUtil.scala
index 6e6630e01..4416e9d7c 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/cross/CrossVersionUtil.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/cross/CrossVersionUtil.scala
@@ -3,7 +3,7 @@ package cross
 
 import scala.annotation.tailrec
 
-object CrossVersionUtil {
+object CrossVersionUtil:
   val trueString = "true"
   val falseString = "false"
   val fullString = "full"
@@ -41,7 +41,7 @@ object CrossVersionUtil {
    * RCs for x.y.0 are considered API compatible.
    * Compatible versions include 0.12.0-1 and 0.12.0-RC1 for Some(0, 12).
    */
-  private[sbt] def sbtApiVersion(v: String): Option[(Long, Long)] = v match {
+  private[sbt] def sbtApiVersion(v: String): Option[(Long, Long)] = v match
     case ReleaseV(x, y, _, _)      => Some(sbtApiVersion(x.toLong, y.toLong))
     case CandidateV(x, y, _, _)    => Some(sbtApiVersion(x.toLong, y.toLong))
     case BinCompatV(x, y, _, _, _) => Some(sbtApiVersion(x.toLong, y.toLong))
@@ -50,15 +50,13 @@ object CrossVersionUtil {
     case NonReleaseV_n(x, y, z, _) if x.toLong > 0 && (y.toLong > 0 || z.toLong > 0) =>
       Some(sbtApiVersion(x.toLong, y.toLong))
     case _ => None
-  }
 
-  private def sbtApiVersion(x: Long, y: Long) = {
+  private def sbtApiVersion(x: Long, y: Long) =
     // Prior to sbt 1 the "sbt api version" was the X.Y in the X.Y.Z version.
     // For example for sbt 0.13.x releases, the sbt api version is 0.13
     // As of sbt 1 it is now X.0.
     // This means, for example, that all versions of sbt 1.x have sbt api version 1.0
-    if (x > 0) (x, 0L) else (x, y)
-  }
+    if x > 0 then (x, 0L) else (x, y)
 
   private[sbt] def isScalaApiCompatible(v: String): Boolean = scalaApiVersion(v).isDefined
 
@@ -66,29 +64,26 @@ object CrossVersionUtil {
    * Returns Scala binary interface x.y API compatible with the given version string v.
    * Compatible versions include 2.10.0-1 and 2.10.1-M1 for Some(2, 10), but not 2.10.0-RC1.
    */
-  private[sbt] def scalaApiVersion(v: String): Option[(Long, Long)] = v match {
+  private[sbt] def scalaApiVersion(v: String): Option[(Long, Long)] = v match
     case ReleaseV(x, y, _, _)                      => Some((x.toLong, y.toLong))
     case BinCompatV(x, y, _, _, _)                 => Some((x.toLong, y.toLong))
     case NonReleaseV_1(x, y, z, _) if z.toLong > 0 => Some((x.toLong, y.toLong))
     case _                                         => None
-  }
 
   private[sbt] def partialVersion(s: String): Option[(Long, Long)] =
-    s match {
+    s match
       case PartialVersion(major, minor) => Some((major.toLong, minor.toLong))
       case MajorV(major)                => Some((major.toLong, 0L))
       case _                            => None
-    }
 
   @tailrec
-  private[sbt] def binaryScala3Version(full: String): String = full match {
+  private[sbt] def binaryScala3Version(full: String): String = full match
     case ReleaseV(maj, _, _, _)                                                  => maj
     case NonReleaseV_n(maj, min, patch, _) if min.toLong > 0 || patch.toLong > 0 => maj
     case BinCompatV(maj, min, patch, stageOrNull, _)                             =>
-      val stage = if (stageOrNull != null) stageOrNull else ""
+      val stage = if stageOrNull != null then stageOrNull else ""
       binaryScala3Version(s"$maj.$min.$patch$stage")
     case _ => full
-  }
 
   // Uses the following rules:
   //
@@ -98,8 +93,8 @@ object CrossVersionUtil {
   //
   //   - For non-stable Scala 3 versions, compiler versions can read TASTy in an older stable format but their TASTY versions are not compatible between each other even if the compilers have the same minor version (https://docs.scala-lang.org/scala3/reference/language-versions/binary-compatibility.html)
   //
-  private[sbt] def isScalaBinaryCompatibleWith(newVersion: String, origVersion: String): Boolean = {
-    (newVersion, origVersion) match {
+  private[sbt] def isScalaBinaryCompatibleWith(newVersion: String, origVersion: String): Boolean =
+    (newVersion, origVersion) match
       case (NonReleaseV_n("2", _, _, _), NonReleaseV_n("2", _, _, _)) =>
         val api1 = scalaApiVersion(newVersion)
         val api2 = scalaApiVersion(origVersion)
@@ -112,11 +107,9 @@ object CrossVersionUtil {
         nMin.toInt > oMin.toInt
       case _ =>
         newVersion == origVersion
-    }
-  }
 
   def binaryScalaVersion(full: String): String =
-    full match {
+    full match
       // Handle dynamic Scala 3 version patterns like "3-latest.candidate"
       case DynamicScala3V(maj)        => maj
       case _ if full.startsWith("2.") =>
@@ -124,7 +117,6 @@ object CrossVersionUtil {
           scalaApiVersion
         ) // Scala 2 binary version
       case _ => binaryScala3Version(full)
-    }
 
   /**
    * Returns the binary version of the Scala, except for
@@ -133,7 +125,7 @@ object CrossVersionUtil {
    * In Scala 3 onwards, it would be the major version.
    */
   def earlyScalaVersion(full: String): String =
-    full match {
+    full match
       // Handle dynamic Scala 3 version patterns like "3-latest.candidate"
       case DynamicScala3V(maj)        => maj
       case _ if full.startsWith("2.") =>
@@ -144,29 +136,25 @@ object CrossVersionUtil {
         partialVersion(full) match
           case Some((major, minor)) => major.toString
           case None                 => full
-    }
 
   def binarySbtVersion(full: String): String =
-    sbtApiVersion(full) match {
+    sbtApiVersion(full) match
       case Some((0, minor)) if minor < 12 => full
       case Some((0, minor))               => s"0.$minor"
       case Some((1, minor))               => s"1.$minor"
       case Some((major, _))               => major.toString
       case _                              => full
-    }
 
   private def isNewer(major: Long, minor: Long, minMajor: Long, minMinor: Long): Boolean =
     major > minMajor || (major == minMajor && minor >= minMinor)
 
   private def binaryVersionWithApi(full: String, cutoff: String)(
       apiVersion: String => Option[(Long, Long)]
-  ): String = {
-    (apiVersion(full), partialVersion(cutoff)) match {
+  ): String =
+    (apiVersion(full), partialVersion(cutoff)) match
       case (Some((major, minor)), None) => s"$major.$minor"
       case (Some((major, minor)), Some((minMajor, minMinor)))
           if isNewer(major, minor, minMajor, minMinor) =>
         s"$major.$minor"
       case _ => full
-    }
-  }
-}
+end CrossVersionUtil
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/GlobalLockFormat.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/GlobalLockFormat.scala
index 4fe27fb77..3eda27612 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/GlobalLockFormat.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/GlobalLockFormat.scala
@@ -9,7 +9,8 @@ import java.util.concurrent.Callable
  * A fake JsonFormat for xsbti.GlobalLock.
  * This is mostly for making IvyConfiguration serializable to JSON.
  */
-trait GlobalLockFormat { self: BasicJsonProtocol =>
+trait GlobalLockFormat:
+  self: BasicJsonProtocol =>
   import GlobalLockFormats.*
 
   given globalLockIsoString: IsoString[GlobalLock] =
@@ -18,10 +19,7 @@ trait GlobalLockFormat { self: BasicJsonProtocol =>
   given GlobalLockFormat: JsonFormat[GlobalLock] = isoStringFormat(using
     globalLockIsoString
   )
-}
 
-private[sbt] object GlobalLockFormats {
-  object NoGlobalLock extends GlobalLock {
+private[sbt] object GlobalLockFormats:
+  object NoGlobalLock extends GlobalLock:
     def apply[T](lockFile: File, run: Callable[T]) = run.call()
-  }
-}
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/LoggerFormat.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/LoggerFormat.scala
index 7364c3c3e..bc6d17fbf 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/LoggerFormat.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/LoggerFormat.scala
@@ -8,9 +8,9 @@ import sbt.util.Logger.Null
  * A fake JsonFormat for xsbti.Logger.
  * This is mostly for making IvyConfiguration serializable to JSON.
  */
-trait LoggerFormat { self: BasicJsonProtocol =>
+trait LoggerFormat:
+  self: BasicJsonProtocol =>
   given xsbtiLoggerIsoString: IsoString[Logger] =
     IsoString.iso(_ => "<logger>", _ => Null)
 
   given LoggerFormat: JsonFormat[Logger] = isoStringFormat(using implicitly)
-}
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/LogicalClockFormats.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/LogicalClockFormats.scala
index 518539e23..d47b7b9cf 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/LogicalClockFormats.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/LogicalClockFormats.scala
@@ -4,10 +4,10 @@ import sjsonnew.*
 
 import sbt.librarymanagement.LogicalClock
 
-trait LogicalClockFormats { self: BasicJsonProtocol =>
+trait LogicalClockFormats:
+  self: BasicJsonProtocol =>
   given LogicalClockFormat: JsonFormat[LogicalClock] =
     projectFormat[LogicalClock, String](
       cl => cl.toString,
       str => LogicalClock(str)
     )
-}
diff --git a/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/NodeSeqFormat.scala b/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/NodeSeqFormat.scala
index 3a1834aad..86a0500cf 100644
--- a/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/NodeSeqFormat.scala
+++ b/lm-core/src/main/scala/sbt/internal/librarymanagement/formats/NodeSeqFormat.scala
@@ -3,9 +3,9 @@ package sbt.internal.librarymanagement.formats
 import sjsonnew.*
 import scala.xml.*
 
-trait NodeSeqFormat { self: BasicJsonProtocol =>
+trait NodeSeqFormat:
+  self: BasicJsonProtocol =>
   given NodeSeqFormat: JsonFormat[NodeSeq] = projectFormat[NodeSeq, String](
     xml => <binary>{xml}</binary>.toString,
     str => XML.loadString(str).child
   )
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/ArtifactExtra.scala b/lm-core/src/main/scala/sbt/librarymanagement/ArtifactExtra.scala
index 000f96354..9126e8c01 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/ArtifactExtra.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/ArtifactExtra.scala
@@ -6,18 +6,17 @@ package sbt.librarymanagement
 import java.io.File
 import java.net.URI
 
-private[librarymanagement] abstract class ArtifactExtra {
+private[librarymanagement] abstract class ArtifactExtra:
   def extraAttributes: Map[String, String]
 
   def withExtraAttributes(extraAttributes: Map[String, String]): Artifact
 
   def extra(attributes: (String, String)*) =
     withExtraAttributes(extraAttributes ++ ModuleID.checkE(attributes))
-}
 
 import Configurations.{ Optional, Pom, Test }
 
-private[librarymanagement] abstract class ArtifactFunctions {
+private[librarymanagement] abstract class ArtifactFunctions:
   def apply(name: String, extra: Map[String, String]): Artifact =
     Artifact(name, DefaultType, DefaultExtension, None, Vector.empty, None, extra, None)
   def apply(name: String, classifier: String): Artifact =
@@ -80,17 +79,14 @@ private[librarymanagement] abstract class ArtifactFunctions {
   assert(DefaultSourceTypes contains SourceType)
 
   def extract(uri: URI, default: String): String = extract(uri.toString, default)
-  def extract(name: String, default: String): String = {
+  def extract(name: String, default: String): String =
     val i = name.lastIndexOf('.')
-    if (i >= 0)
-      name.substring(i + 1)
-    else
-      default
-  }
-  def defaultArtifact(file: File) = {
+    if i >= 0 then name.substring(i + 1)
+    else default
+  def defaultArtifact(file: File) =
     val name = file.getName
     val i = name.lastIndexOf('.')
-    val base = if (i >= 0) name.substring(0, i) else name
+    val base = if i >= 0 then name.substring(0, i) else name
     Artifact(
       base,
       extract(name, DefaultType),
@@ -99,18 +95,17 @@ private[librarymanagement] abstract class ArtifactFunctions {
       Vector.empty,
       Some(file.toURI)
     )
-  }
-  def artifactName(scalaVersion: ScalaVersion, module: ModuleID, artifact: Artifact): String = {
+  def artifactName(scalaVersion: ScalaVersion, module: ModuleID, artifact: Artifact): String =
     import artifact.*
-    val classifierStr = classifier match { case None => ""; case Some(c) => "-" + c }
+    val classifierStr = classifier match
+      case None    => "";
+      case Some(c) => "-" + c
     val cross = CrossVersion(module.crossVersion, scalaVersion.full, scalaVersion.binary)
-    val withPlatform = module.crossVersion match {
+    val withPlatform = module.crossVersion match
       case _: Disabled => artifact.name
       case _           => CrossVersion.addPlatformSuffix(artifact.name, module.platformOpt, None)
-    }
     val base = CrossVersion.applyCross(withPlatform, cross)
     base + "-" + module.revision + classifierStr + "." + artifact.extension
-  }
 
   /**
    * Like `artifactName`, but omits the module's version.
@@ -134,10 +129,8 @@ private[librarymanagement] abstract class ArtifactFunctions {
   val classifierTypeMap = Map(SourceClassifier -> SourceType, DocClassifier -> DocType)
   @deprecated("Configuration should not be decided from the classifier.", "1.0")
   def classifierConf(classifier: String): Configuration =
-    if (classifier.startsWith(TestsClassifier))
-      Test
-    else
-      Optional
+    if classifier.startsWith(TestsClassifier) then Test
+    else Optional
   def classifierType(classifier: String): String =
     classifierTypeMap.getOrElse(classifier.stripPrefix(TestsClassifier + "-"), DefaultType)
 
@@ -155,4 +148,4 @@ private[librarymanagement] abstract class ArtifactFunctions {
       Vector.empty,
       None
     )
-}
+end ArtifactFunctions
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/ConfigRef.scala b/lm-core/src/main/scala/sbt/librarymanagement/ConfigRef.scala
index 9dceb8526..47085e963 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/ConfigRef.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/ConfigRef.scala
@@ -9,29 +9,24 @@ import scala.collection.concurrent.TrieMap
  * A reference to Configuration.
  * @param name The name of the configuration that eventually get used by Maven.
  */
-final class ConfigRef private (val name: String) extends Serializable {
+final class ConfigRef private (val name: String) extends Serializable:
 
   override def equals(o: Any): Boolean =
     this.eq(o.asInstanceOf[AnyRef])
 
-  override val hashCode: Int = {
+  override val hashCode: Int =
     37 * (37 * (17 + "sbt.librarymanagement.ConfigRef".##) + name.##)
-  }
 
-  override def toString: String = {
+  override def toString: String =
     name
-  }
 
-  private def copy(name: String = name): ConfigRef = {
+  private def copy(name: String = name): ConfigRef =
     ConfigRef(name)
-  }
 
-  def withName(name: String): ConfigRef = {
+  def withName(name: String): ConfigRef =
     copy(name = name)
-  }
-}
 
-object ConfigRef extends sbt.librarymanagement.ConfigRefFunctions {
+object ConfigRef extends sbt.librarymanagement.ConfigRefFunctions:
   // cache the reference to ConfigRefs
   private val cache = new TrieMap[String, ConfigRef]
   private lazy val Default = new ConfigRef("default")
@@ -52,7 +47,7 @@ object ConfigRef extends sbt.librarymanagement.ConfigRefFunctions {
   private lazy val CompileInternal = new ConfigRef("compile-internal")
   private lazy val ZincTool = new ConfigRef("zinc-tool")
 
-  def apply(name: String): ConfigRef = name match {
+  def apply(name: String): ConfigRef = name match
     case "default"          => Default
     case "compile"          => Compile
     case "provided"         => Provided
@@ -71,5 +66,4 @@ object ConfigRef extends sbt.librarymanagement.ConfigRefFunctions {
     case "compile-internal" => CompileInternal
     case "zinc-tool"        => ZincTool
     case _                  => cache.getOrElseUpdate(name, new ConfigRef(name))
-  }
-}
+end ConfigRef
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/ConfigRefFormats.scala b/lm-core/src/main/scala/sbt/librarymanagement/ConfigRefFormats.scala
index f18ebc73e..5bc53a9ad 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/ConfigRefFormats.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/ConfigRefFormats.scala
@@ -5,14 +5,15 @@ package sbt.librarymanagement
 
 import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
 
-trait ConfigRefFormats { self: sjsonnew.BasicJsonProtocol =>
+trait ConfigRefFormats:
+  self: sjsonnew.BasicJsonProtocol =>
   given ConfigRefFormat: JsonFormat[sbt.librarymanagement.ConfigRef] =
-    new JsonFormat[sbt.librarymanagement.ConfigRef] {
+    new JsonFormat[sbt.librarymanagement.ConfigRef]:
       override def read[J](
           __jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.librarymanagement.ConfigRef = {
-        __jsOpt match {
+      ): sbt.librarymanagement.ConfigRef =
+        __jsOpt match
           case Some(__js) =>
             unbuilder.beginObject(__js)
             val name = unbuilder.readField[String]("name")
@@ -20,12 +21,7 @@ trait ConfigRefFormats { self: sjsonnew.BasicJsonProtocol =>
             sbt.librarymanagement.ConfigRef(name)
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
-      override def write[J](obj: sbt.librarymanagement.ConfigRef, builder: Builder[J]): Unit = {
+      override def write[J](obj: sbt.librarymanagement.ConfigRef, builder: Builder[J]): Unit =
         builder.beginObject()
         builder.addField("name", obj.name)
         builder.endObject()
-      }
-    }
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/Configuration.scala b/lm-core/src/main/scala/sbt/librarymanagement/Configuration.scala
index 9ffbd7047..6a1d8571b 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/Configuration.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/Configuration.scala
@@ -10,7 +10,7 @@ final class Configuration private[sbt] (
     val extendsConfigs: Vector[Configuration],
     val transitive: Boolean
 ) extends ConfigurationExtra
-    with Serializable {
+    with Serializable:
 
   require(name != null, "name cannot be null")
   require(name.nonEmpty, "name cannot be empty")
@@ -18,7 +18,7 @@ final class Configuration private[sbt] (
   require(id.nonEmpty, "id cannot be empty")
   require(id.head.isUpper, s"id must be capitalized: $id")
 
-  override def equals(o: Any): Boolean = o match {
+  override def equals(o: Any): Boolean = o match
     case x: Configuration =>
       (this.id == x.id) &&
       (this.name == x.name) &&
@@ -27,7 +27,6 @@ final class Configuration private[sbt] (
       (this.extendsConfigs == x.extendsConfigs) &&
       (this.transitive == x.transitive)
     case _ => false
-  }
 
   override val hashCode: Int =
     37 * (37 * (37 * (37 * (37 * (37 * (17 +
@@ -56,9 +55,9 @@ final class Configuration private[sbt] (
     copy(transitive = transitive)
 
   def toConfigRef: ConfigRef = ConfigRef(name)
-}
+end Configuration
 
-object Configuration {
+object Configuration:
   // Don't call this directly. It's intended to be used from config macro.
   def of(id: String, name: String): Configuration =
     new Configuration(id, name, "", true, Vector.empty, true)
@@ -72,7 +71,6 @@ object Configuration {
       transitive: Boolean
   ): Configuration =
     new Configuration(id, name, description, isPublic, extendsConfigs, transitive)
-}
 
 /*
 Configuration isn't defined with Contraband.
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/ConfigurationExtra.scala b/lm-core/src/main/scala/sbt/librarymanagement/ConfigurationExtra.scala
index 966df7c9d..4a3fbca50 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/ConfigurationExtra.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/ConfigurationExtra.scala
@@ -6,7 +6,7 @@ package sbt.librarymanagement
 import scala.annotation.tailrec
 import scala.quoted.*
 
-object Configurations {
+object Configurations:
   inline def config(name: String): Configuration = ${
     ConfigurationMacro.configMacroImpl('{ name })
   }
@@ -23,12 +23,11 @@ object Configurations {
   lazy val TestInternal = fullInternal(Test)
   lazy val CompileInternal = fullInternal(Compile)
 
-  def internalMap(c: Configuration) = c match {
+  def internalMap(c: Configuration) = c match
     case Compile => CompileInternal
     case Test    => TestInternal
     case Runtime => RuntimeInternal
     case _       => c
-  }
 
   private[sbt] def internal(base: Configuration, ext: Configuration*) =
     Configuration.of(base.id + "Internal", base.name + "-internal").extend(ext*).hide
@@ -56,24 +55,23 @@ object Configurations {
   private[sbt] val DefaultMavenConfiguration = defaultConfiguration(true)
   private[sbt] val DefaultIvyConfiguration = defaultConfiguration(false)
   private[sbt] def DefaultConfiguration(mavenStyle: Boolean) =
-    if (mavenStyle) DefaultMavenConfiguration else DefaultIvyConfiguration
+    if mavenStyle then DefaultMavenConfiguration else DefaultIvyConfiguration
   private[sbt] def defaultConfiguration(mavenStyle: Boolean) =
-    if (mavenStyle) Configurations.Compile else Configurations.Default
+    if mavenStyle then Configurations.Compile else Configurations.Default
   private[sbt] def removeDuplicates(configs: Iterable[Configuration]) =
     configs.map(config => (config.name, config)).toMap.values.toSet
 
   /** Returns true if the configuration should be under the influence of scalaVersion. */
   private[sbt] def underScalaVersion(c: Configuration): Boolean =
-    c match {
+    c match
       case Default | Compile | Provided | Runtime | Test | Optional | CompilerPlugin |
           CompileInternal | RuntimeInternal | TestInternal =>
         true
       case config =>
         config.extendsConfigs.exists(underScalaVersion)
-    }
-}
+end Configurations
 
-private[librarymanagement] abstract class ConfigurationExtra {
+private[librarymanagement] abstract class ConfigurationExtra:
   def id: String
   def name: String
   def description: String
@@ -98,7 +96,7 @@ private[librarymanagement] abstract class ConfigurationExtra {
   def notTransitive = intransitive
   def intransitive = Configuration.of(id, name, description, isPublic, extendsConfigs, false)
   def hide = Configuration.of(id, name, description, false, extendsConfigs, transitive)
-}
+end ConfigurationExtra
 
 private[sbt] object ConfigurationMacro:
   def configMacroImpl(name: Expr[String])(using Quotes): Expr[Configuration] =
@@ -122,7 +120,6 @@ private[sbt] object ConfigurationMacro:
     '{ Configuration.of($id, $name) }
 end ConfigurationMacro
 
-private[librarymanagement] abstract class ConfigRefFunctions {
+private[librarymanagement] abstract class ConfigRefFunctions:
   implicit def configToConfigRef(c: Configuration): ConfigRef =
     c.toConfigRef
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/ConfigurationFormats.scala b/lm-core/src/main/scala/sbt/librarymanagement/ConfigurationFormats.scala
index 0fc97c39a..1be7a9848 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/ConfigurationFormats.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/ConfigurationFormats.scala
@@ -6,15 +6,15 @@ package librarymanagement
 
 import _root_.sjsonnew.{ deserializationError, Builder, JsonFormat, Unbuilder }
 
-trait ConfigurationFormats {
+trait ConfigurationFormats:
   self: sbt.librarymanagement.ConfigurationFormats & sjsonnew.BasicJsonProtocol =>
   given ConfigurationFormat: JsonFormat[sbt.librarymanagement.Configuration] =
-    new JsonFormat[sbt.librarymanagement.Configuration] {
+    new JsonFormat[sbt.librarymanagement.Configuration]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.librarymanagement.Configuration = {
-        jsOpt match {
+      ): sbt.librarymanagement.Configuration =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
             val id = unbuilder.readField[String]("id")
@@ -35,9 +35,7 @@ trait ConfigurationFormats {
             )
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
-      override def write[J](obj: sbt.librarymanagement.Configuration, builder: Builder[J]): Unit = {
+      override def write[J](obj: sbt.librarymanagement.Configuration, builder: Builder[J]): Unit =
         builder.beginObject()
         builder.addField("id", obj.id)
         builder.addField("name", obj.name)
@@ -46,6 +44,4 @@ trait ConfigurationFormats {
         builder.addField("extendsConfigs", obj.extendsConfigs)
         builder.addField("transitive", obj.transitive)
         builder.endObject()
-      }
-    }
-}
+end ConfigurationFormats
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/ConflictWarning.scala b/lm-core/src/main/scala/sbt/librarymanagement/ConflictWarning.scala
index 010f51bfd..be173db57 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/ConflictWarning.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/ConflictWarning.scala
@@ -8,65 +8,55 @@ import sbt.util.{ Logger, Level }
  * library dependency graph by mistake, but it won't be caught by eviction.
  */
 final case class ConflictWarning(label: String, level: Level.Value, failOnConflict: Boolean) {}
-object ConflictWarning {
+object ConflictWarning:
   def disable: ConflictWarning = ConflictWarning("", Level.Debug, false)
 
   private def idString(org: String, name: String) = s"$org:$name"
 
   def default(label: String): ConflictWarning = ConflictWarning(label, Level.Error, true)
 
-  def apply(config: ConflictWarning, report: UpdateReport, log: Logger): Unit = {
+  def apply(config: ConflictWarning, report: UpdateReport, log: Logger): Unit =
     processCrossVersioned(config, report, log)
-  }
   private def processCrossVersioned(
       config: ConflictWarning,
       report: UpdateReport,
       log: Logger
-  ): Unit = {
+  ): Unit =
     val crossMismatches = crossVersionMismatches(report)
-    if (crossMismatches.nonEmpty) {
+    if crossMismatches.nonEmpty then
       val pre =
         s"Modules were resolved with conflicting cross-version suffixes in ${config.label}:\n   "
       val conflictMsgs =
-        for (((org, rawName), fullNames) <- crossMismatches) yield {
+        for ((org, rawName), fullNames) <- crossMismatches yield
           val suffixes = fullNames.map(getCrossSuffix).mkString(", ")
           s"${idString(org, rawName)} $suffixes"
-        }
       log.log(config.level, conflictMsgs.mkString(pre, "\n   ", ""))
-      if (config.failOnConflict) {
+      if config.failOnConflict then
         val summary =
           crossMismatches.map { case ((org, raw), _) => idString(org, raw) }.mkString(", ")
         sys.error("Conflicting cross-version suffixes in: " + summary)
-      }
-    }
-  }
 
   /** Map from (organization, rawName) to set of multiple full names. */
-  def crossVersionMismatches(report: UpdateReport): Map[(String, String), Set[String]] = {
+  def crossVersionMismatches(report: UpdateReport): Map[(String, String), Set[String]] =
     val mismatches = report.configurations.flatMap { confReport =>
       groupByRawName(confReport.allModules).view.mapValues { modules =>
         val differentFullNames = modules.map(_.name).toSet
-        if (differentFullNames.size > 1) differentFullNames else Set.empty[String]
+        if differentFullNames.size > 1 then differentFullNames else Set.empty[String]
       }
     }
     mismatches.foldLeft(Map.empty[(String, String), Set[String]])(merge)
-  }
   private def merge[A, B](m: Map[A, Set[B]], b: (A, Set[B])): Map[A, Set[B]] =
-    if (b._2.isEmpty) m
-    else
-      m.updated(b._1, m.getOrElse(b._1, Set.empty) ++ b._2)
+    if b._2.isEmpty then m
+    else m.updated(b._1, m.getOrElse(b._1, Set.empty) ++ b._2)
 
   private def groupByRawName(ms: Seq[ModuleID]): Map[(String, String), Seq[ModuleID]] =
     ms.groupBy(m => (m.organization, dropCrossSuffix(m.name)))
 
   private val CrossSuffixPattern = """(.+)_(\d+(?:\.\d+)?(?:\.\d+)?(?:-.+)?)""".r
-  private def dropCrossSuffix(s: String): String = s match {
+  private def dropCrossSuffix(s: String): String = s match
     case CrossSuffixPattern(raw, _) => raw
     case _                          => s
-  }
-  private def getCrossSuffix(s: String): String = s match {
+  private def getCrossSuffix(s: String): String = s match
     case CrossSuffixPattern(_, v) => "_" + v
     case _                        => "<none>"
-  }
-
-}
+end ConflictWarning
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/Credentials.scala b/lm-core/src/main/scala/sbt/librarymanagement/Credentials.scala
index 38ed45f32..e28202a7f 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/Credentials.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/Credentials.scala
@@ -19,22 +19,19 @@ object Credentials:
   def apply(file: File): Credentials =
     new FileCredentials(file)
 
-  final class FileCredentials(val path: File) extends Credentials {
+  final class FileCredentials(val path: File) extends Credentials:
     override def toString = s"""FileCredentials("$path")"""
-  }
 
   final class DirectCredentials(
       val realm: String,
       val host: String,
       val userName: String,
       val passwd: String
-  ) extends Credentials {
-    override def toString = {
+  ) extends Credentials:
+    override def toString =
       val dq = '"'
       val r =
-        if (realm == null) "null"
+        if realm == null then "null"
         else s"$dq$realm$dq"
       s"""DirectCredentials($r, "$host", "$userName", ****)"""
-    }
-  }
 end Credentials
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/CrossVersion.scala b/lm-core/src/main/scala/sbt/librarymanagement/CrossVersion.scala
index aea152e22..f50200d4e 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/CrossVersion.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/CrossVersion.scala
@@ -6,37 +6,28 @@ package sbt.librarymanagement
 import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
 
 /** Configures how a module will be cross-versioned. */
-abstract class CrossVersion() extends Serializable {
-  override def equals(o: Any): Boolean = o match {
+abstract class CrossVersion() extends Serializable:
+  override def equals(o: Any): Boolean = o match
     case _: CrossVersion => true
     case _               => false
-  }
-  override def hashCode: Int = {
+  override def hashCode: Int =
     37 * (17 + "sbt.librarymanagement.CrossVersion".##)
-  }
-  override def toString: String = {
+  override def toString: String =
     "CrossVersion()"
-  }
-}
 object CrossVersion extends sbt.librarymanagement.CrossVersionFunctions {}
 
 /** Disables cross versioning for a module. */
-sealed class Disabled private () extends sbt.librarymanagement.CrossVersion() with Serializable {
+sealed class Disabled private () extends sbt.librarymanagement.CrossVersion() with Serializable:
 
-  override def equals(o: Any): Boolean = o match {
+  override def equals(o: Any): Boolean = o match
     case _: Disabled => true
     case _           => false
-  }
-  override def hashCode: Int = {
+  override def hashCode: Int =
     37 * (17 + "sbt.librarymanagement.Disabled".##)
-  }
-  override def toString: String = {
+  override def toString: String =
     "Disabled()"
-  }
-}
-object Disabled extends sbt.librarymanagement.Disabled {
+object Disabled extends sbt.librarymanagement.Disabled:
   def apply(): Disabled = Disabled
-}
 
 /**
  * Cross-versions a module using the result of
@@ -46,86 +37,66 @@ object Disabled extends sbt.librarymanagement.Disabled {
  */
 final class Binary private (val prefix: String, val suffix: String)
     extends sbt.librarymanagement.CrossVersion()
-    with Serializable {
+    with Serializable:
 
   private def this() = this("", "")
 
-  override def equals(o: Any): Boolean = o match {
+  override def equals(o: Any): Boolean = o match
     case x: Binary => (this.prefix == x.prefix) && (this.suffix == x.suffix)
     case _         => false
-  }
-  override def hashCode: Int = {
+  override def hashCode: Int =
     37 * (37 * (37 * (17 + "sbt.librarymanagement.Binary".##) + prefix.##) + suffix.##)
-  }
-  override def toString: String = {
+  override def toString: String =
     "Binary(" + prefix + ", " + suffix + ")"
-  }
-  private def copy(prefix: String = prefix, suffix: String = suffix): Binary = {
+  private def copy(prefix: String = prefix, suffix: String = suffix): Binary =
     new Binary(prefix, suffix)
-  }
-  def withPrefix(prefix: String): Binary = {
+  def withPrefix(prefix: String): Binary =
     copy(prefix = prefix)
-  }
-  def withSuffix(suffix: String): Binary = {
+  def withSuffix(suffix: String): Binary =
     copy(suffix = suffix)
-  }
-}
-object Binary {
+object Binary:
 
   def apply(): Binary = new Binary()
   def apply(prefix: String, suffix: String): Binary = new Binary(prefix, suffix)
-}
 
 /** Cross-versions a module using the string `value`. */
 final class Constant private (val value: String)
     extends sbt.librarymanagement.CrossVersion()
-    with Serializable {
+    with Serializable:
 
   private def this() = this("")
 
-  override def equals(o: Any): Boolean = o match {
+  override def equals(o: Any): Boolean = o match
     case x: Constant => (this.value == x.value)
     case _           => false
-  }
-  override def hashCode: Int = {
+  override def hashCode: Int =
     37 * (37 * (17 + "sbt.librarymanagement.Constant".##) + value.##)
-  }
-  override def toString: String = {
+  override def toString: String =
     "Constant(" + value + ")"
-  }
-  private def copy(value: String): Constant = {
+  private def copy(value: String): Constant =
     new Constant(value)
-  }
-  def withValue(value: String): Constant = {
+  def withValue(value: String): Constant =
     copy(value = value)
-  }
-}
-object Constant {
+object Constant:
   def apply(): Constant = new Constant()
   def apply(value: String): Constant = new Constant(value)
-}
 
 /**
  * Cross-versions a module by stripping off -bin-suffix.
  * This is intended for patch-version compatible alternative replacements.
  */
-final class Patch private () extends sbt.librarymanagement.CrossVersion() with Serializable {
+final class Patch private () extends sbt.librarymanagement.CrossVersion() with Serializable:
 
-  override def equals(o: Any): Boolean = o match {
+  override def equals(o: Any): Boolean = o match
     case _: Patch => true
     case _        => false
-  }
-  override def hashCode: Int = {
+  override def hashCode: Int =
     37 * (17 + "sbt.librarymanagement.Patch".##)
-  }
-  override def toString: String = {
+  override def toString: String =
     "Patch()"
-  }
-}
 
-object Patch {
+object Patch:
   def apply(): Patch = new Patch()
-}
 
 /**
  * Cross-versions a module with the result of
@@ -135,35 +106,27 @@ object Patch {
  */
 final class Full private (val prefix: String, val suffix: String)
     extends sbt.librarymanagement.CrossVersion()
-    with Serializable {
+    with Serializable:
 
   private def this() = this("", "")
 
-  override def equals(o: Any): Boolean = o match {
+  override def equals(o: Any): Boolean = o match
     case x: Full => (this.prefix == x.prefix) && (this.suffix == x.suffix)
     case _       => false
-  }
-  override def hashCode: Int = {
+  override def hashCode: Int =
     37 * (37 * (37 * (17 + "sbt.librarymanagement.Full".##) + prefix.##) + suffix.##)
-  }
-  override def toString: String = {
+  override def toString: String =
     "Full(" + prefix + ", " + suffix + ")"
-  }
-  private def copy(prefix: String = prefix, suffix: String = suffix): Full = {
+  private def copy(prefix: String = prefix, suffix: String = suffix): Full =
     new Full(prefix, suffix)
-  }
-  def withPrefix(prefix: String): Full = {
+  def withPrefix(prefix: String): Full =
     copy(prefix = prefix)
-  }
-  def withSuffix(suffix: String): Full = {
+  def withSuffix(suffix: String): Full =
     copy(suffix = suffix)
-  }
-}
 
-object Full {
+object Full:
   def apply(): Full = new Full()
   def apply(prefix: String, suffix: String): Full = new Full(prefix, suffix)
-}
 
 /**
  * Similar to Binary except that if the binary version is 3
@@ -173,35 +136,27 @@ object Full {
  */
 final class For3Use2_13 private (val prefix: String, val suffix: String)
     extends sbt.librarymanagement.CrossVersion()
-    with Serializable {
+    with Serializable:
 
   private def this() = this("", "")
 
-  override def equals(o: Any): Boolean = o match {
+  override def equals(o: Any): Boolean = o match
     case x: For3Use2_13 => (this.prefix == x.prefix) && (this.suffix == x.suffix)
     case _              => false
-  }
-  override def hashCode: Int = {
+  override def hashCode: Int =
     37 * (37 * (37 * (17 + "sbt.librarymanagement.For3Use2_13".##) + prefix.##) + suffix.##)
-  }
-  override def toString: String = {
+  override def toString: String =
     "For3Use2_13(" + prefix + ", " + suffix + ")"
-  }
-  private def copy(prefix: String = prefix, suffix: String = suffix): For3Use2_13 = {
+  private def copy(prefix: String = prefix, suffix: String = suffix): For3Use2_13 =
     new For3Use2_13(prefix, suffix)
-  }
-  def withPrefix(prefix: String): For3Use2_13 = {
+  def withPrefix(prefix: String): For3Use2_13 =
     copy(prefix = prefix)
-  }
-  def withSuffix(suffix: String): For3Use2_13 = {
+  def withSuffix(suffix: String): For3Use2_13 =
     copy(suffix = suffix)
-  }
-}
-object For3Use2_13 {
+object For3Use2_13:
 
   def apply(): For3Use2_13 = new For3Use2_13()
   def apply(prefix: String, suffix: String): For3Use2_13 = new For3Use2_13(prefix, suffix)
-}
 
 /**
  * Similar to Binary except that if the binary version is 2.13
@@ -211,44 +166,37 @@ object For3Use2_13 {
  */
 final class For2_13Use3 private (val prefix: String, val suffix: String)
     extends sbt.librarymanagement.CrossVersion()
-    with Serializable {
+    with Serializable:
 
   private def this() = this("", "")
 
-  override def equals(o: Any): Boolean = o match {
+  override def equals(o: Any): Boolean = o match
     case x: For2_13Use3 => (this.prefix == x.prefix) && (this.suffix == x.suffix)
     case _              => false
-  }
-  override def hashCode: Int = {
+  override def hashCode: Int =
     37 * (37 * (37 * (17 + "sbt.librarymanagement.For3Use2_13".##) + prefix.##) + suffix.##)
-  }
-  override def toString: String = {
+  override def toString: String =
     "For3Use2_13(" + prefix + ", " + suffix + ")"
-  }
-  private def copy(prefix: String = prefix, suffix: String = suffix): For2_13Use3 = {
+  private def copy(prefix: String = prefix, suffix: String = suffix): For2_13Use3 =
     new For2_13Use3(prefix, suffix)
-  }
-  def withPrefix(prefix: String): For2_13Use3 = {
+  def withPrefix(prefix: String): For2_13Use3 =
     copy(prefix = prefix)
-  }
-  def withSuffix(suffix: String): For2_13Use3 = {
+  def withSuffix(suffix: String): For2_13Use3 =
     copy(suffix = suffix)
-  }
-}
-object For2_13Use3 {
+object For2_13Use3:
 
   def apply(): For2_13Use3 = new For2_13Use3()
   def apply(prefix: String, suffix: String): For2_13Use3 = new For2_13Use3(prefix, suffix)
-}
 
-trait DisabledFormats { self: sjsonnew.BasicJsonProtocol =>
+trait DisabledFormats:
+  self: sjsonnew.BasicJsonProtocol =>
   given DisabledFormat: JsonFormat[sbt.librarymanagement.Disabled] =
-    new JsonFormat[sbt.librarymanagement.Disabled] {
+    new JsonFormat[sbt.librarymanagement.Disabled]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.librarymanagement.Disabled = {
-        jsOpt match {
+      ): sbt.librarymanagement.Disabled =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
 
@@ -256,22 +204,18 @@ trait DisabledFormats { self: sjsonnew.BasicJsonProtocol =>
             sbt.librarymanagement.Disabled()
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
-      override def write[J](obj: sbt.librarymanagement.Disabled, builder: Builder[J]): Unit = {
+      override def write[J](obj: sbt.librarymanagement.Disabled, builder: Builder[J]): Unit =
         builder.beginObject()
 
         builder.endObject()
-      }
-    }
 
   given DisabledObjectFormat: JsonFormat[sbt.librarymanagement.Disabled.type] =
-    new JsonFormat[sbt.librarymanagement.Disabled.type] {
+    new JsonFormat[sbt.librarymanagement.Disabled.type]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.librarymanagement.Disabled.type = {
-        jsOpt match {
+      ): sbt.librarymanagement.Disabled.type =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
 
@@ -279,24 +223,21 @@ trait DisabledFormats { self: sjsonnew.BasicJsonProtocol =>
             sbt.librarymanagement.Disabled
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
-      override def write[J](obj: sbt.librarymanagement.Disabled.type, builder: Builder[J]): Unit = {
+      override def write[J](obj: sbt.librarymanagement.Disabled.type, builder: Builder[J]): Unit =
         builder.beginObject()
 
         builder.endObject()
-      }
-    }
-}
+end DisabledFormats
 
-trait BinaryFormats { self: sjsonnew.BasicJsonProtocol =>
+trait BinaryFormats:
+  self: sjsonnew.BasicJsonProtocol =>
   given BinaryFormat: JsonFormat[sbt.librarymanagement.Binary] =
-    new JsonFormat[sbt.librarymanagement.Binary] {
+    new JsonFormat[sbt.librarymanagement.Binary]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.librarymanagement.Binary = {
-        jsOpt match {
+      ): sbt.librarymanagement.Binary =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
             val prefix = unbuilder.readField[String]("prefix")
@@ -305,25 +246,22 @@ trait BinaryFormats { self: sjsonnew.BasicJsonProtocol =>
             sbt.librarymanagement.Binary(prefix, suffix)
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
-      override def write[J](obj: sbt.librarymanagement.Binary, builder: Builder[J]): Unit = {
+      override def write[J](obj: sbt.librarymanagement.Binary, builder: Builder[J]): Unit =
         builder.beginObject()
         builder.addField("prefix", obj.prefix)
         builder.addField("suffix", obj.suffix)
         builder.endObject()
-      }
-    }
-}
+end BinaryFormats
 
-trait ConstantFormats { self: sjsonnew.BasicJsonProtocol =>
+trait ConstantFormats:
+  self: sjsonnew.BasicJsonProtocol =>
   given ConstantFormat: JsonFormat[sbt.librarymanagement.Constant] =
-    new JsonFormat[sbt.librarymanagement.Constant] {
+    new JsonFormat[sbt.librarymanagement.Constant]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.librarymanagement.Constant = {
-        jsOpt match {
+      ): sbt.librarymanagement.Constant =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
             val value = unbuilder.readField[String]("value")
@@ -331,24 +269,20 @@ trait ConstantFormats { self: sjsonnew.BasicJsonProtocol =>
             sbt.librarymanagement.Constant(value)
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
-      override def write[J](obj: sbt.librarymanagement.Constant, builder: Builder[J]): Unit = {
+      override def write[J](obj: sbt.librarymanagement.Constant, builder: Builder[J]): Unit =
         builder.beginObject()
         builder.addField("value", obj.value)
         builder.endObject()
-      }
-    }
-}
 
-trait PatchFormats { self: sjsonnew.BasicJsonProtocol =>
+trait PatchFormats:
+  self: sjsonnew.BasicJsonProtocol =>
   given PatchFormat: JsonFormat[sbt.librarymanagement.Patch] =
-    new JsonFormat[sbt.librarymanagement.Patch] {
+    new JsonFormat[sbt.librarymanagement.Patch]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.librarymanagement.Patch = {
-        jsOpt match {
+      ): sbt.librarymanagement.Patch =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
 
@@ -356,24 +290,20 @@ trait PatchFormats { self: sjsonnew.BasicJsonProtocol =>
             sbt.librarymanagement.Patch()
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
-      override def write[J](obj: sbt.librarymanagement.Patch, builder: Builder[J]): Unit = {
+      override def write[J](obj: sbt.librarymanagement.Patch, builder: Builder[J]): Unit =
         builder.beginObject()
 
         builder.endObject()
-      }
-    }
-}
 
-trait FullFormats { self: sjsonnew.BasicJsonProtocol =>
+trait FullFormats:
+  self: sjsonnew.BasicJsonProtocol =>
   given FullFormat: JsonFormat[sbt.librarymanagement.Full] =
-    new JsonFormat[sbt.librarymanagement.Full] {
+    new JsonFormat[sbt.librarymanagement.Full]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.librarymanagement.Full = {
-        jsOpt match {
+      ): sbt.librarymanagement.Full =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
             val prefix = unbuilder.readField[String]("prefix")
@@ -382,25 +312,22 @@ trait FullFormats { self: sjsonnew.BasicJsonProtocol =>
             sbt.librarymanagement.Full(prefix, suffix)
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
-      override def write[J](obj: sbt.librarymanagement.Full, builder: Builder[J]): Unit = {
+      override def write[J](obj: sbt.librarymanagement.Full, builder: Builder[J]): Unit =
         builder.beginObject()
         builder.addField("prefix", obj.prefix)
         builder.addField("suffix", obj.suffix)
         builder.endObject()
-      }
-    }
-}
+end FullFormats
 
-trait For3Use2_13Formats { self: sjsonnew.BasicJsonProtocol =>
+trait For3Use2_13Formats:
+  self: sjsonnew.BasicJsonProtocol =>
   given For3Use2_13Format: JsonFormat[sbt.librarymanagement.For3Use2_13] =
-    new JsonFormat[sbt.librarymanagement.For3Use2_13] {
+    new JsonFormat[sbt.librarymanagement.For3Use2_13]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.librarymanagement.For3Use2_13 = {
-        jsOpt match {
+      ): sbt.librarymanagement.For3Use2_13 =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
             val prefix = unbuilder.readField[String]("prefix")
@@ -409,25 +336,22 @@ trait For3Use2_13Formats { self: sjsonnew.BasicJsonProtocol =>
             sbt.librarymanagement.For3Use2_13(prefix, suffix)
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
-      override def write[J](obj: sbt.librarymanagement.For3Use2_13, builder: Builder[J]): Unit = {
+      override def write[J](obj: sbt.librarymanagement.For3Use2_13, builder: Builder[J]): Unit =
         builder.beginObject()
         builder.addField("prefix", obj.prefix)
         builder.addField("suffix", obj.suffix)
         builder.endObject()
-      }
-    }
-}
+end For3Use2_13Formats
 
-trait For2_13Use3Formats { self: sjsonnew.BasicJsonProtocol =>
+trait For2_13Use3Formats:
+  self: sjsonnew.BasicJsonProtocol =>
   given For2_13Use3Format: JsonFormat[sbt.librarymanagement.For2_13Use3] =
-    new JsonFormat[sbt.librarymanagement.For2_13Use3] {
+    new JsonFormat[sbt.librarymanagement.For2_13Use3]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.librarymanagement.For2_13Use3 = {
-        jsOpt match {
+      ): sbt.librarymanagement.For2_13Use3 =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
             val prefix = unbuilder.readField[String]("prefix")
@@ -436,23 +360,19 @@ trait For2_13Use3Formats { self: sjsonnew.BasicJsonProtocol =>
             sbt.librarymanagement.For2_13Use3(prefix, suffix)
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
-      override def write[J](obj: sbt.librarymanagement.For2_13Use3, builder: Builder[J]): Unit = {
+      override def write[J](obj: sbt.librarymanagement.For2_13Use3, builder: Builder[J]): Unit =
         builder.beginObject()
         builder.addField("prefix", obj.prefix)
         builder.addField("suffix", obj.suffix)
         builder.endObject()
-      }
-    }
-}
+end For2_13Use3Formats
 
-trait CrossVersionFormats {
+trait CrossVersionFormats:
   self: sjsonnew.BasicJsonProtocol & sbt.librarymanagement.DisabledFormats &
     sbt.librarymanagement.BinaryFormats & sbt.librarymanagement.ConstantFormats &
     sbt.librarymanagement.PatchFormats & sbt.librarymanagement.FullFormats &
     sbt.librarymanagement.For3Use2_13Formats & sbt.librarymanagement.For2_13Use3Formats =>
-  given CrossVersionFormat: JsonFormat[CrossVersion] = {
+  given CrossVersionFormat: JsonFormat[CrossVersion] =
     val format = flatUnionFormat8[
       CrossVersion,
       Disabled,
@@ -465,19 +385,17 @@ trait CrossVersionFormats {
       For2_13Use3
     ]("type")
     // This is a hand-crafted formatter to avoid Disabled$ showing up in JSON
-    new JsonFormat[CrossVersion] {
+    new JsonFormat[CrossVersion]:
       override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): CrossVersion =
         format.read(jsOpt, unbuilder)
-      override def write[J](obj: CrossVersion, builder: Builder[J]): Unit = {
-        if (obj == Disabled) {
+      override def write[J](obj: CrossVersion, builder: Builder[J]): Unit =
+        if obj == Disabled then
           builder.beginPreObject()
           builder.addFieldName("type")
           builder.writeString("Disabled")
           builder.endPreObject()
           builder.beginObject()
           builder.endObject()
-        } else format.write(obj, builder)
-      }
-    }
-  }
-}
+        else format.write(obj, builder)
+  end CrossVersionFormat
+end CrossVersionFormats
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/CrossVersionExtra.scala b/lm-core/src/main/scala/sbt/librarymanagement/CrossVersionExtra.scala
index 7fe5ed64b..96476fd53 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/CrossVersionExtra.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/CrossVersionExtra.scala
@@ -5,7 +5,7 @@ import sbt.librarymanagement.syntax.*
 
 final case class ScalaVersion(full: String, binary: String)
 
-private[librarymanagement] abstract class CrossVersionFunctions {
+private[librarymanagement] abstract class CrossVersionFunctions:
 
   /** Compatibility with 0.13 */
   @deprecated(
@@ -84,30 +84,26 @@ private[librarymanagement] abstract class CrossVersionFunctions {
   def for2_13Use3With(prefix: String, suffix: String): CrossVersion = For2_13Use3(prefix, suffix)
 
   private[sbt] def getPrefixSuffix(value: CrossVersion): (String, String) =
-    value match {
+    value match
       case (_: Disabled | _: Constant | _: Patch) => ("", "")
       case b: Binary                              => (b.prefix, b.suffix)
       case f: Full                                => (f.prefix, f.suffix)
       case c: For3Use2_13                         => (c.prefix, c.suffix)
       case c: For2_13Use3                         => (c.prefix, c.suffix)
-    }
 
   private[sbt] def setPrefixSuffix(value: CrossVersion, p: String, s: String): CrossVersion =
-    value match {
+    value match
       case (_: Disabled | _: Constant | _: Patch) => value
       case b: Binary                              => b.withPrefix(p).withSuffix(s)
       case f: Full                                => f.withPrefix(p).withSuffix(s)
       case c: For3Use2_13                         => c.withPrefix(p).withSuffix(s)
       case c: For2_13Use3                         => c.withPrefix(p).withSuffix(s)
-    }
 
-  private[sbt] def patchFun(fullVersion: String): String = {
+  private[sbt] def patchFun(fullVersion: String): String =
     import sbt.internal.librarymanagement.cross.CrossVersionUtil.BinCompatV
-    fullVersion match {
-      case BinCompatV(x, y, z, w, _) => s"""$x.$y.$z${if (w == null) "" else w}"""
+    fullVersion match
+      case BinCompatV(x, y, z, w, _) => s"""$x.$y.$z${if w == null then "" else w}"""
       case other                     => other
-    }
-  }
 
   private[sbt] def append(s: String): Option[String => String] = Some(x => crossName(x, s))
 
@@ -121,7 +117,7 @@ private[librarymanagement] abstract class CrossVersionFunctions {
       fullVersion: String,
       binaryVersion: String
   ): Option[String => String] =
-    cross match {
+    cross match
       case _: Disabled    => None
       case b: Binary      => append(b.prefix + binaryVersion + b.suffix)
       case c: Constant    => append(c.value)
@@ -129,15 +125,14 @@ private[librarymanagement] abstract class CrossVersionFunctions {
       case f: Full        => append(f.prefix + fullVersion + f.suffix)
       case c: For3Use2_13 =>
         val compat =
-          if (binaryVersion == "3" || binaryVersion.startsWith("3.0.0")) "2.13"
+          if binaryVersion == "3" || binaryVersion.startsWith("3.0.0") then "2.13"
           else binaryVersion
         append(c.prefix + compat + c.suffix)
       case c: For2_13Use3 =>
         val compat =
-          if (binaryVersion == "2.13") "3"
+          if binaryVersion == "2.13" then "3"
           else binaryVersion
         append(c.prefix + compat + c.suffix)
-    }
 
   /**
    * Constructs the cross-version function defined by `module` and `is`, if one is configured.
@@ -160,16 +155,14 @@ private[librarymanagement] abstract class CrossVersionFunctions {
       artifacts: Vector[Artifact],
       cross: Option[String => String]
   ): Vector[Artifact] =
-    cross match {
+    cross match
       case None    => artifacts
       case Some(_) => substituteCrossA(artifacts, cross)
-    }
 
   private[sbt] def applyCross(s: String, fopt: Option[String => String]): String =
-    fopt match {
+    fopt match
       case None       => s
       case Some(fopt) => fopt(s)
-    }
 
   private[sbt] def crossName(name: String, cross: String): String =
     name + "_" + cross
@@ -192,13 +185,12 @@ private[librarymanagement] abstract class CrossVersionFunctions {
   private[sbt] def substituteCross(
       exclude: ExclusionRule,
       is: Option[ScalaModuleInfo]
-  ): ExclusionRule = {
+  ): ExclusionRule =
     val fopt: Option[String => String] =
       is flatMap { i =>
         CrossVersion(exclude.crossVersion, i.scalaFullVersion, i.scalaBinaryVersion)
       }
     exclude.withName(applyCross(exclude.name, fopt))
-  }
 
   /** Cross-versions `a` according to cross-version function `cross`. */
   def substituteCross(a: Artifact, cross: Option[String => String]): Artifact =
@@ -214,14 +206,12 @@ private[librarymanagement] abstract class CrossVersionFunctions {
    * for the given full and binary Scala versions `scalaFullVersion` and `scalaBinaryVersion`
    * according to the ModuleID's cross-versioning setting.
    */
-  def apply(scalaFullVersion: String, scalaBinaryVersion: String): ModuleID => ModuleID = m => {
+  def apply(scalaFullVersion: String, scalaBinaryVersion: String): ModuleID => ModuleID = m =>
     val cross = apply(m.crossVersion, scalaFullVersion, scalaBinaryVersion)
-    if (cross.isDefined)
+    if cross.isDefined then
       m.withName(applyCross(m.name, cross))
         .withExplicitArtifacts(substituteCrossA(m.explicitArtifacts, cross))
-    else
-      m
-  }
+    else m
 
   def isSbtApiCompatible(v: String): Boolean = CrossVersionUtil.isSbtApiCompatible(v)
 
@@ -271,4 +261,4 @@ private[librarymanagement] abstract class CrossVersionFunctions {
    */
   def isScalaBinaryCompatibleWith(newVersion: String, origVersion: String): Boolean =
     CrossVersionUtil.isScalaBinaryCompatibleWith(newVersion, origVersion)
-}
+end CrossVersionFunctions
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/DependencyBuilders.scala b/lm-core/src/main/scala/sbt/librarymanagement/DependencyBuilders.scala
index 0080ab372..08388731f 100755
--- a/lm-core/src/main/scala/sbt/librarymanagement/DependencyBuilders.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/DependencyBuilders.scala
@@ -8,7 +8,7 @@ import sbt.internal.librarymanagement.StringUtilities.nonEmpty
 /**
  * DependencyBuilders implements the implicits for % and %% DSL.
  */
-trait DependencyBuilders {
+trait DependencyBuilders:
   // See http://www.scala-lang.org/news/2.12.0#traits-compile-to-interfaces
   // Avoid defining fields (val or var, but a constant is ok – final val without result type)
   // Avoid calling super
@@ -16,60 +16,48 @@ trait DependencyBuilders {
 
   import DependencyBuilders.*
 
-  implicit def stringToOrganization(organization: String): Organization = {
+  implicit def stringToOrganization(organization: String): Organization =
     nonEmpty(organization, "Organization")
     new Organization(organization)
-  }
 
-  implicit def toRepositoryName(name: String): RepositoryName = {
+  implicit def toRepositoryName(name: String): RepositoryName =
     nonEmpty(name, "Repository name")
     new RepositoryName(name)
-  }
 
-  implicit def moduleIDConfigurable(m: ModuleID): ModuleIDConfigurable = {
+  implicit def moduleIDConfigurable(m: ModuleID): ModuleIDConfigurable =
     require(m.configurations.isEmpty, "Configurations already specified for module " + m)
     new ModuleIDConfigurable(m)
-  }
-}
 
-object DependencyBuilders {
-  final class Organization private[sbt] (private[sbt] val organization: String) {
+object DependencyBuilders:
+  final class Organization private[sbt] (private[sbt] val organization: String):
     def %(name: String) = organizationArtifact(name, Disabled())
     def %%(name: String): OrganizationArtifactName =
       organizationArtifact(name, CrossVersion.binary)
 
-    private def organizationArtifact(name: String, cross: CrossVersion) = {
+    private def organizationArtifact(name: String, cross: CrossVersion) =
       nonEmpty(name, "Name")
       new OrganizationArtifactName(organization, name, cross)
-    }
-  }
 
   final class OrganizationArtifactName private[sbt] (
       private[sbt] val organization: String,
       private[sbt] val name: String,
       private[sbt] val crossVersion: CrossVersion
-  ) {
-    def %(revision: String): ModuleID = {
+  ):
+    def %(revision: String): ModuleID =
       nonEmpty(revision, "Revision")
       ModuleID(organization, name, revision).cross(crossVersion)
-    }
-  }
 
-  final class ModuleIDConfigurable private[sbt] (moduleID: ModuleID) {
+  final class ModuleIDConfigurable private[sbt] (moduleID: ModuleID):
     def %(configuration: Configuration): ModuleID = %(configuration.name)
     def %(configuration: ConfigRef): ModuleID = %(configuration.name)
 
-    def %(configurations: String): ModuleID = {
+    def %(configurations: String): ModuleID =
       nonEmpty(configurations, "Configurations")
       val c = configurations
       moduleID.withConfigurations(configurations = Some(c))
-    }
-  }
 
-  final class RepositoryName private[sbt] (name: String) {
-    infix def at(location: String): MavenRepository = {
+  final class RepositoryName private[sbt] (name: String):
+    infix def at(location: String): MavenRepository =
       nonEmpty(location, "Repository location")
       MavenRepository(name, location)
-    }
-  }
-}
+end DependencyBuilders
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/DependencyFilter.scala b/lm-core/src/main/scala/sbt/librarymanagement/DependencyFilter.scala
index f17cd2066..d4425fdd3 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/DependencyFilter.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/DependencyFilter.scala
@@ -5,7 +5,7 @@ package sbt.librarymanagement
 
 import sbt.io.{ AllPassFilter, NameFilter }
 
-trait DependencyFilterExtra {
+trait DependencyFilterExtra:
   // See http://www.scala-lang.org/news/2.12.0#traits-compile-to-interfaces
   // Avoid defining fields (val or var, but a constant is ok – final val without result type)
   // Avoid calling super
@@ -33,9 +33,9 @@ trait DependencyFilterExtra {
 
   def configurationFilter(name: NameFilter = AllPassFilter): ConfigurationFilter =
     (c: ConfigRef) => name.accept(c.name)
-}
+end DependencyFilterExtra
 
-object DependencyFilter extends DependencyFilterExtra {
+object DependencyFilter extends DependencyFilterExtra:
   def make(
       configuration: ConfigurationFilter = configurationFilter(),
       module: ModuleFilter = moduleFilter(),
@@ -56,14 +56,13 @@ object DependencyFilter extends DependencyFilterExtra {
   implicit def fnToConfigurationFilter(f: ConfigRef => Boolean): ConfigurationFilter =
     (c: ConfigRef) => f(c)
   implicit def subDepFilterToFn[Arg](f: SubDepFilter[Arg, ?]): Arg => Boolean = f.apply(_)
-}
-trait DependencyFilter {
+end DependencyFilter
+trait DependencyFilter:
   def apply(configuration: ConfigRef, module: ModuleID, artifact: Artifact): Boolean
   final def &&(o: DependencyFilter) = DependencyFilter(this, o, _ && _)
   final def ||(o: DependencyFilter) = DependencyFilter(this, o, _ || _)
   final def --(o: DependencyFilter) = DependencyFilter(this, o, _ && !_)
-}
-sealed trait SubDepFilter[Arg, Self <: SubDepFilter[Arg, Self]] extends DependencyFilter {
+sealed trait SubDepFilter[Arg, Self <: SubDepFilter[Arg, Self]] extends DependencyFilter:
   self: Self =>
   def apply(a: Arg): Boolean
   protected def make(f: Arg => Boolean): Self
@@ -72,22 +71,18 @@ sealed trait SubDepFilter[Arg, Self <: SubDepFilter[Arg, Self]] extends Dependen
   final def -(o: Self): Self = combine(o, _ && !_)
   private def combine(o: Self, f: (Boolean, Boolean) => Boolean): Self =
     make((m: Arg) => f(this(m), o(m)))
-}
-trait ModuleFilter extends SubDepFilter[ModuleID, ModuleFilter] {
+trait ModuleFilter extends SubDepFilter[ModuleID, ModuleFilter]:
   protected final def make(f: ModuleID => Boolean) =
     (m: ModuleID) => f(m)
   final def apply(configuration: ConfigRef, module: ModuleID, artifact: Artifact): Boolean =
     apply(module)
-}
-trait ArtifactFilter extends SubDepFilter[Artifact, ArtifactFilter] {
+trait ArtifactFilter extends SubDepFilter[Artifact, ArtifactFilter]:
   protected final def make(f: Artifact => Boolean) =
     (m: Artifact) => f(m)
   final def apply(configuration: ConfigRef, module: ModuleID, artifact: Artifact): Boolean =
     apply(artifact)
-}
-trait ConfigurationFilter extends SubDepFilter[ConfigRef, ConfigurationFilter] {
+trait ConfigurationFilter extends SubDepFilter[ConfigRef, ConfigurationFilter]:
   protected final def make(f: ConfigRef => Boolean) =
     (m: ConfigRef) => f(m)
   final def apply(configuration: ConfigRef, module: ModuleID, artifact: Artifact): Boolean =
     apply(configuration)
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/DependencyResolution.scala b/lm-core/src/main/scala/sbt/librarymanagement/DependencyResolution.scala
index e015f1c03..f5b4ea09c 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/DependencyResolution.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/DependencyResolution.scala
@@ -8,7 +8,7 @@ import sbt.librarymanagement.syntax.*
 /**
  * Library management API to resolve dependencies.
  */
-class DependencyResolution private[sbt] (lmEngine: DependencyResolutionInterface) {
+class DependencyResolution private[sbt] (lmEngine: DependencyResolutionInterface):
   import sbt.internal.librarymanagement.InternalDefaults.*
   import sbt.internal.librarymanagement.UpdateClassifiersUtil.*
 
@@ -33,12 +33,11 @@ class DependencyResolution private[sbt] (lmEngine: DependencyResolutionInterface
       moduleId: ModuleID,
       directDependencies: Vector[ModuleID],
       scalaModuleInfo: Option[ScalaModuleInfo]
-  ): ModuleDescriptor = {
+  ): ModuleDescriptor =
     val moduleSetting = ModuleDescriptorConfiguration(moduleId, ModuleInfo(moduleId.name))
       .withScalaModuleInfo(scalaModuleInfo)
       .withDependencies(directDependencies)
     moduleDescriptor(moduleSetting)
-  }
 
   /**
    * Resolves the given module's dependencies performing a retrieval.
@@ -77,12 +76,11 @@ class DependencyResolution private[sbt] (lmEngine: DependencyResolutionInterface
   def wrapDependencyInModule(
       dependencyId: ModuleID,
       scalaModuleInfo: Option[ScalaModuleInfo]
-  ): ModuleDescriptor = {
+  ): ModuleDescriptor =
     val sha1 = Hash.toHex(Hash(dependencyId.name))
     val dummyID = ModuleID(sbtOrgTemp, modulePrefixTemp + sha1, dependencyId.revision)
       .withConfigurations(dependencyId.configurations)
     moduleDescriptor(dummyID, Vector(dependencyId), scalaModuleInfo)
-  }
 
   /**
    * Resolves the given dependency, and retrieves the artifacts to a directory.
@@ -113,7 +111,7 @@ class DependencyResolution private[sbt] (lmEngine: DependencyResolutionInterface
       module: ModuleDescriptor,
       retrieveDirectory: File,
       log: Logger
-  ): Either[UnresolvedWarning, Vector[File]] = {
+  ): Either[UnresolvedWarning, Vector[File]] =
     // Using the default artifact type filter here, so sources and docs are excluded.
     val retrieveConfiguration = RetrieveConfiguration()
       .withRetrieveDirectory(retrieveDirectory)
@@ -126,15 +124,15 @@ class DependencyResolution private[sbt] (lmEngine: DependencyResolutionInterface
       updateConfiguration,
       UnresolvedWarningConfiguration(),
       log
-    ) match {
+    ) match
       case Left(unresolvedWarning) => Left(unresolvedWarning)
       case Right(updateReport)     =>
         val allFiles =
-          for {
+          for
             conf <- updateReport.configurations
             m <- conf.modules
             (_, f) <- m.artifacts
-          } yield f
+          yield f
         log.debug(s"Files retrieved for ${directDependenciesNames(module)}:")
         log.debug(allFiles mkString ", ")
         // allFiles filter predicate match {
@@ -142,8 +140,8 @@ class DependencyResolution private[sbt] (lmEngine: DependencyResolutionInterface
         //   case files => Some(files)
         // }
         Right(allFiles)
-    }
-  }
+    end match
+  end retrieve
 
   /**
    * Creates explicit artifacts for each classifier in `config.module`, and then attempts to resolve them directly. This
@@ -159,7 +157,7 @@ class DependencyResolution private[sbt] (lmEngine: DependencyResolutionInterface
       uwconfig: UnresolvedWarningConfiguration,
       artifacts: Vector[(String, ModuleID, Artifact, File)],
       log: Logger
-  ): Either[UnresolvedWarning, UpdateReport] = {
+  ): Either[UnresolvedWarning, UpdateReport] =
     import config.module.*
     val artifactFilter = getArtifactTypeFilter(config.updateConfiguration.artifactFilter)
     assert(classifiers.nonEmpty, "classifiers cannot be empty")
@@ -179,7 +177,7 @@ class DependencyResolution private[sbt] (lmEngine: DependencyResolutionInterface
 
     // c.copy ensures c.types is preserved too
     val upConf = config.updateConfiguration.withMissingOk(true)
-    update(module, upConf, uwconfig, log) match {
+    update(module, upConf, uwconfig, log) match
       case Right(r) =>
         // The artifacts that came from Ivy don't have their classifier set, let's set it according to
         // FIXME: this is only done because IDE plugins depend on `classifier` to determine type. They
@@ -193,17 +191,15 @@ class DependencyResolution private[sbt] (lmEngine: DependencyResolutionInterface
           }
         })
       case Left(w) => Left(w)
-    }
-  }
+  end updateClassifiers
 
   protected def directDependenciesNames(module: ModuleDescriptor): String =
     (module.directDependencies map { case mID: ModuleID =>
       import mID.*
       s"$organization % $name % $revision"
     }).mkString(", ")
-}
+end DependencyResolution
 
-object DependencyResolution {
+object DependencyResolution:
   def apply(lmEngine: DependencyResolutionInterface): DependencyResolution =
     new DependencyResolution(lmEngine)
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/EvictionError.scala b/lm-core/src/main/scala/sbt/librarymanagement/EvictionError.scala
index 5b7bfc8ba..44481bf54 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/EvictionError.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/EvictionError.scala
@@ -6,14 +6,13 @@ import sbt.internal.librarymanagement.VersionSchemes
 import sbt.util.{ Level, ShowLines }
 import EvictionWarningOptions.isNameScalaSuffixed
 
-object EvictionError {
+object EvictionError:
   def apply(
       report: UpdateReport,
       module: ModuleDescriptor,
       schemes: Seq[ModuleID],
-  ): EvictionError = {
+  ): EvictionError =
     apply(report, module, schemes, "always", "always", Level.Debug)
-  }
 
   def apply(
       report: UpdateReport,
@@ -22,7 +21,7 @@ object EvictionError {
       assumedVersionScheme: String,
       assumedVersionSchemeJava: String,
       assumedEvictionErrorLevel: Level.Value,
-  ): EvictionError = {
+  ): EvictionError =
     apply(
       report,
       module,
@@ -32,7 +31,6 @@ object EvictionError {
       assumedEvictionErrorLevel,
       EvictionWarningOptions.default.configurations,
     )
-  }
 
   def apply(
       report: UpdateReport,
@@ -42,7 +40,7 @@ object EvictionError {
       assumedVersionSchemeJava: String,
       assumedEvictionErrorLevel: Level.Value,
       configurations: Seq[ConfigRef],
-  ): EvictionError = {
+  ): EvictionError =
     val evictions = EvictionWarning
       .buildEvictions(configurations, report)
     processEvictions(
@@ -53,7 +51,6 @@ object EvictionError {
       assumedVersionSchemeJava,
       assumedEvictionErrorLevel,
     )
-  }
 
   private[sbt] def processEvictions(
       module: ModuleDescriptor,
@@ -62,14 +59,14 @@ object EvictionError {
       assumedVersionScheme: String,
       assumedVersionSchemeJava: String,
       assumedEvictionErrorLevel: Level.Value,
-  ): EvictionError = {
+  ): EvictionError =
     val directDependencies = module.directDependencies
     val sbvOpt = module.scalaModuleInfo.map(_.scalaBinaryVersion)
     val userDefinedSchemes: Map[(String, String), String] = Map(schemes flatMap { s =>
       val organization = s.organization
       VersionSchemes.validateScheme(s.revision)
       val versionScheme = s.revision
-      (s.crossVersion, sbvOpt) match {
+      (s.crossVersion, sbvOpt) match
         case (b: Binary, Some("2.13")) =>
           List(
             (s.organization, s"${s.name}${b.suffix}_2.13") -> versionScheme,
@@ -84,7 +81,6 @@ object EvictionError {
           List((s.organization, s"${s.name}${b.suffix}_$sbv") -> versionScheme)
         case _ =>
           List((s.organization, s.name) -> versionScheme)
-      }
     }*)
     val pairs = reports
       .flatMap { case (config, detail) =>
@@ -92,10 +88,10 @@ object EvictionError {
         val winner = (detail.modules filterNot { _.evicted }).headOption
         // don't report on a transitive eviction that does not have a winner
         // https://github.com/sbt/sbt/issues/4946
-        winner match {
+        winner match
           case Some(winner) =>
             // from libraryDependencyScheme or defined in the pom using the `info.versionScheme` attribute
-            val userDefinedSchemeOrFromPom = {
+            val userDefinedSchemeOrFromPom =
               def fromLibraryDependencySchemes(org: String = "*", mod: String = "*") =
                 userDefinedSchemes.get((org, mod))
               def fromWinnerPom = VersionSchemes.extractFromExtraAttributes(
@@ -106,9 +102,8 @@ object EvictionError {
                 .orElse(fromLibraryDependencySchemes(detail.organization)) // for whole org
                 .orElse(fromWinnerPom) // from pom
                 .orElse(fromLibraryDependencySchemes()) // global
-            }
             val assumedScheme =
-              if (isNameScalaSuffixed(detail.name)) assumedVersionScheme
+              if isNameScalaSuffixed(detail.name) then assumedVersionScheme
               else assumedVersionSchemeJava
 
             // We want the user to be able to suppress eviction errors for a specific library,
@@ -118,14 +113,13 @@ object EvictionError {
               .map(scheme => (scheme, false))
               .getOrElse((assumedScheme, true))
 
-            val hasIncompatibleVersionForScheme = {
+            val hasIncompatibleVersionForScheme =
               val isCompat = VersionSchemes.evalFunc(scheme)
               evicteds.exists { r =>
                 !isCompat((r.module, Some(winner.module), module.scalaModuleInfo))
               }
-            }
 
-            if (hasIncompatibleVersionForScheme)
+            if hasIncompatibleVersionForScheme then
               Some(
                 (
                   EvictionErrorPair(
@@ -143,7 +137,7 @@ object EvictionError {
               )
             else None
           case None => None
-        }
+        end match
       }
       // Deduplicate eviction pairs by configuration.
       .groupMap(_._1)(_._2)
@@ -157,29 +151,27 @@ object EvictionError {
       incompatibleEvictions.toList,
       assumedIncompatibleEvictions.toList,
     )
-  }
+  end processEvictions
 
   private def callers(
       winner: ModuleReport,
       evicteds: Vector[ModuleReport],
-  ): List[(ModuleID, String)] = {
+  ): List[(ModuleID, String)] =
     val seen: mutable.Set[ModuleID] = mutable.Set()
     (evicteds.toList :+ winner).flatMap { r =>
       val rev = r.module.revision
       r.callers.toList flatMap { caller =>
-        if (seen(caller.caller)) Nil
-        else {
+        if seen(caller.caller) then Nil
+        else
           seen += caller.caller
           List((caller.caller, rev))
-        }
       }
     }
-  }
 
   given evictionErrorLines: ShowLines[EvictionError] = ShowLines { (a: EvictionError) =>
     a.toLines
   }
-}
+end EvictionError
 
 private final case class EvictionErrorPair(
     name: String,
@@ -195,11 +187,9 @@ private final case class EvictionErrorPair(
 final class EvictionError private[sbt] (
     val incompatibleEvictions: Seq[EvictionErrorPair],
     val assumedIncompatibleEvictions: Seq[EvictionErrorPair],
-) {
+):
   def run(): Unit =
-    if (incompatibleEvictions.nonEmpty) {
-      sys.error(toLines.mkString("\n"))
-    }
+    if incompatibleEvictions.nonEmpty then sys.error(toLines.mkString("\n"))
 
   def toLines: List[String] = toLines(incompatibleEvictions, false)
 
@@ -208,7 +198,7 @@ final class EvictionError private[sbt] (
   def toLines(
       evictions: Seq[EvictionErrorPair],
       assumed: Boolean
-  ): List[String] = {
+  ): List[String] =
     val out: mutable.ListBuffer[String] = mutable.ListBuffer()
     out += "found version conflict(s) in library dependencies; some are suspected to be binary incompatible:"
     out += ""
@@ -216,21 +206,21 @@ final class EvictionError private[sbt] (
       val callers: List[String] = a.callers.map { case (caller, rev) =>
         f"\t    +- ${caller}%-50s (depends on $rev)"
       }
-      val que = if (assumed) "?" else ""
+      val que = if assumed then "?" else ""
       val evictedRevs = a.evicted.map(_.revision)
       val evictedRevsTitle =
-        if (evictedRevs.size <= 1) evictedRevs.mkString
+        if evictedRevs.size <= 1 then evictedRevs.mkString
         else evictedRevs.mkString("{", ", ", "}")
 
       val winnerRev =
         s":${a.winner.revision} (${a.scheme}$que) is selected over ${evictedRevsTitle}"
       val configurationTitle =
-        if (a.configurations.size <= 1) a.configurations.mkString
+        if a.configurations.size <= 1 then a.configurations.mkString
         else a.configurations.mkString("{", ", ", "}")
       val title = s"\t* ${a.organization}:${a.name}$winnerRev for $configurationTitle"
       val lines = title :: callers.reverse ::: List("")
       out ++= lines
     })
     out.toList
-  }
-}
+  end toLines
+end EvictionError
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/EvictionWarning.scala b/lm-core/src/main/scala/sbt/librarymanagement/EvictionWarning.scala
index 5f668165a..865449c23 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/EvictionWarning.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/EvictionWarning.scala
@@ -17,7 +17,7 @@ final class EvictionWarningOptions private[sbt] (
     val infoAllEvictions: Boolean,
     val showCallers: Boolean,
     val guessCompatible: Function1[(ModuleID, Option[ModuleID], Option[ScalaModuleInfo]), Boolean]
-) {
+):
   def withConfigurations(configurations: Seq[ConfigRef]): EvictionWarningOptions =
     copy(configurations = configurations)
   def withWarnScalaVersionEviction(warnScalaVersionEviction: Boolean): EvictionWarningOptions =
@@ -58,9 +58,9 @@ final class EvictionWarningOptions private[sbt] (
       showCallers = showCallers,
       guessCompatible = guessCompatible
     )
-}
+end EvictionWarningOptions
 
-object EvictionWarningOptions {
+object EvictionWarningOptions:
   def empty: EvictionWarningOptions =
     new EvictionWarningOptions(
       Vector(),
@@ -106,24 +106,22 @@ object EvictionWarningOptions {
   lazy val guessSecondSegment
       : PartialFunction[(ModuleID, Option[ModuleID], Option[ScalaModuleInfo]), Boolean] = {
     case (m1, Some(m2), Some(_)) if isNameScalaSuffixed(m2.name) =>
-      (m1.revision, m2.revision) match {
+      (m1.revision, m2.revision) match
         case (VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2)) =>
           VersionNumber.SecondSegment
             .isCompatible(VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2))
         case _ => false
-      }
   }
 
   /** A partial function that checks two versions match pvp. */
   private[sbt] lazy val evalPvp
       : PartialFunction[(ModuleID, Option[ModuleID], Option[ScalaModuleInfo]), Boolean] = {
     case (m1, Some(m2), _) =>
-      (m1.revision, m2.revision) match {
+      (m1.revision, m2.revision) match
         case (VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2)) =>
           VersionNumber.SecondSegment
             .isCompatible(VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2))
         case _ => false
-      }
   }
 
   lazy val guessSbtOne
@@ -132,45 +130,41 @@ object EvictionWarningOptions {
         if (m2.organization == "org.scala-sbt") &&
           (m2.name.endsWith("_" + scalaModuleInfo.scalaFullVersion) ||
             m2.name.endsWith("_" + scalaModuleInfo.scalaBinaryVersion)) =>
-      (m1.revision, m2.revision) match {
+      (m1.revision, m2.revision) match
         case (VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2)) =>
           VersionNumber.SemVer
             .isCompatible(VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2))
         case _ => false
-      }
   }
 
   lazy val guessSemVer
       : PartialFunction[(ModuleID, Option[ModuleID], Option[ScalaModuleInfo]), Boolean] = {
     case (m1, Some(m2), _) =>
-      (m1.revision, m2.revision) match {
+      (m1.revision, m2.revision) match
         case (VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2)) =>
           VersionNumber.SemVer
             .isCompatible(VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2))
         case _ => false
-      }
   }
 
   lazy val guessEarlySemVer
       : PartialFunction[(ModuleID, Option[ModuleID], Option[ScalaModuleInfo]), Boolean] = {
     case (m1, Some(m2), _) =>
-      (m1.revision, m2.revision) match {
+      (m1.revision, m2.revision) match
         case (VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2)) =>
           VersionNumber.EarlySemVer
             .isCompatible(VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2))
         case _ => false
-      }
   }
 
   lazy val guessStrict
       : PartialFunction[(ModuleID, Option[ModuleID], Option[ScalaModuleInfo]), Boolean] = {
     case (m1, Some(m2), _) =>
-      (m1.revision, m2.revision) match {
+      (m1.revision, m2.revision) match
         case (VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2)) =>
           VersionNumber.Strict
             .isCompatible(VersionNumber(ns1, ts1, es1), VersionNumber(ns2, ts2, es2))
         case _ => false
-      }
   }
 
   lazy val guessFalse
@@ -182,7 +176,7 @@ object EvictionWarningOptions {
       : PartialFunction[(ModuleID, Option[ModuleID], Option[ScalaModuleInfo]), Boolean] = {
     case (_, _, _) => true
   }
-}
+end EvictionWarningOptions
 
 final class EvictionPair private[sbt] (
     val organization: String,
@@ -191,49 +185,43 @@ final class EvictionPair private[sbt] (
     val evicteds: Vector[ModuleReport],
     val includesDirect: Boolean,
     val showCallers: Boolean
-) {
-  val evictedRevs: String = {
+):
+  val evictedRevs: String =
     val revs = evicteds map { _.module.revision }
-    if (revs.size <= 1) revs.mkString else revs.distinct.mkString("{", ", ", "}")
-  }
+    if revs.size <= 1 then revs.mkString else revs.distinct.mkString("{", ", ", "}")
 
   override def toString: String =
     EvictionPair.evictionPairLines.showLines(this).mkString
-  override def equals(o: Any): Boolean = o match {
+  override def equals(o: Any): Boolean = o match
     case o: EvictionPair =>
       (this.organization == o.organization) &&
       (this.name == o.name)
     case _ => false
-  }
-  override def hashCode: Int = {
+  override def hashCode: Int =
     var hash = 1
     hash = hash * 31 + this.organization.##
     hash = hash * 31 + this.name.##
     hash
-  }
-}
+end EvictionPair
 
-object EvictionPair {
+object EvictionPair:
   given evictionPairLines: ShowLines[EvictionPair] = ShowLines { (a: EvictionPair) =>
     val seen: mutable.Set[ModuleID] = mutable.Set()
     val callers: List[String] = (a.evicteds.toList ::: a.winner.toList) flatMap { r =>
       val rev = r.module.revision
       r.callers.toList flatMap { caller =>
-        if (seen(caller.caller)) Nil
-        else {
+        if seen(caller.caller) then Nil
+        else
           seen += caller.caller
           List(f"\t    +- ${caller}%-50s (depends on $rev)")
-        }
       }
     }
-    val winnerRev = a.winner match {
+    val winnerRev = a.winner match
       case Some(r) => s":${r.module.revision} is selected over ${a.evictedRevs}"
       case _       => " is evicted for all versions"
-    }
     val title = s"\t* ${a.organization}:${a.name}$winnerRev"
-    title :: (if (a.showCallers) callers.reverse else Nil) ::: List("")
+    title :: (if a.showCallers then callers.reverse else Nil) ::: List("")
   }
-}
 
 final class EvictionWarning private[sbt] (
     val options: EvictionWarningOptions,
@@ -242,7 +230,7 @@ final class EvictionWarning private[sbt] (
     val transitiveEvictions: Seq[EvictionPair],
     val allEvictions: Seq[EvictionPair],
     val binaryIncompatibleEvictionExists: Boolean
-) {
+):
   private[sbt] def this(
       options: EvictionWarningOptions,
       scalaEvictions: Seq[EvictionPair],
@@ -253,9 +241,8 @@ final class EvictionWarning private[sbt] (
   def reportedEvictions: Seq[EvictionPair] =
     scalaEvictions ++ directEvictions ++ transitiveEvictions
   private[sbt] def infoAllTheThings: List[String] = EvictionWarning.infoAllTheThings(this)
-}
 
-object EvictionWarning {
+object EvictionWarning:
   @deprecated("Use variant that doesn't take an unused logger", "1.2.0")
   def apply(
       module: ModuleDescriptor,
@@ -268,51 +255,45 @@ object EvictionWarning {
       module: ModuleDescriptor,
       options: EvictionWarningOptions,
       report: UpdateReport
-  ): EvictionWarning = {
+  ): EvictionWarning =
     val evictions = buildEvictions(options.configurations, report)
     processEvictions(module, options, evictions)
-  }
 
   private[sbt] def buildEvictions(
       configurations: Seq[ConfigRef],
       report: UpdateReport
-  ): Seq[(ConfigRef, OrganizationArtifactReport)] = {
+  ): Seq[(ConfigRef, OrganizationArtifactReport)] =
     val confs = report.configurations filter { x =>
       configurations.contains[ConfigRef](x.configuration)
     }
     confs.flatMap { confReport =>
       confReport.details.map(report => (confReport.configuration, report))
     }.toVector
-  }
 
   private[sbt] def isScalaArtifact(
       module: ModuleDescriptor,
       organization: String,
       name: String
   ): Boolean =
-    module.scalaModuleInfo match {
+    module.scalaModuleInfo match
       case Some(s) =>
         organization == s.scalaOrganization &&
         (name == LibraryID) || (name == CompilerID)
       case _ => false
-    }
 
   private[sbt] def processEvictions(
       module: ModuleDescriptor,
       options: EvictionWarningOptions,
       configsAndReports: Seq[(ConfigRef, OrganizationArtifactReport)]
-  ): EvictionWarning = {
+  ): EvictionWarning =
     val directDependencies = module.directDependencies
     val buffer: mutable.ListBuffer[OrganizationArtifactReport] = mutable.ListBuffer()
     configsAndReports.foreach { case (_, detail) =>
-      if (
-        (detail.modules exists { _.evicted }) &&
+      if (detail.modules exists { _.evicted }) &&
         !(buffer exists { x =>
           (x.organization == detail.organization) && (x.name == detail.name)
         })
-      ) {
-        buffer += detail
-      }
+      then buffer += detail
     }
     val reports = buffer.toList.toVector
     val pairs = reports map { detail =>
@@ -345,23 +326,20 @@ object EvictionWarning {
         // Check if the evicted module's revision is a version range and if the winner satisfies it
         // This handles cases like [4.1.0,5) where 4.2.1 would be within range (fixes #3978)
         // and [1.3.1,2.3] where 2.3 is valid (fixes #6244)
-        val winnerSatisfiesRange: Boolean = winnerOpt match {
+        val winnerSatisfiesRange: Boolean = winnerOpt match
           case Some(winner) if VersionRange.isVersionRange(evictedRev) =>
             VersionRange.versionSatisfiesRange(winner.revision, evictedRev)
           case _ => false
-        }
-        if (sameVersion || winnerSatisfiesRange) {
-          true
-        } else {
-          val extraAttributes = ((p.winner match {
+        if sameVersion || winnerSatisfiesRange then true
+        else
+          val extraAttributes = ((p.winner match
             case Some(r) => r.extraAttributes
             case _       => Map.empty
-          }): collection.immutable.Map[String, String]) ++ (winnerOpt match {
+          ): collection.immutable.Map[String, String]) ++ (winnerOpt match
             case Some(w) => w.extraAttributes
-            case _       => Map.empty
-          })
+            case _       => Map.empty)
           val schemeOpt = VersionSchemes.extractFromExtraAttributes(extraAttributes)
-          val f = (winnerOpt, schemeOpt) match {
+          val f = (winnerOpt, schemeOpt) match
             case (Some(_), Some(VersionSchemes.Always)) =>
               EvictionWarningOptions.guessTrue
             case (Some(_), Some(VersionSchemes.Strict)) =>
@@ -373,36 +351,26 @@ object EvictionWarning {
             case (Some(_), Some(VersionSchemes.PackVer)) =>
               EvictionWarningOptions.evalPvp
             case _ => options.guessCompatible(_)
-          }
           f((r.module, winnerOpt, module.scalaModuleInfo))
-        }
+        end if
       }
     pairs foreach {
       case p if isScalaArtifact(module, p.organization, p.name) =>
-        (module.scalaModuleInfo, p.winner) match {
+        (module.scalaModuleInfo, p.winner) match
           case (Some(s), Some(winner)) if (s.scalaFullVersion != winner.module.revision) =>
-            if (options.warnScalaVersionEviction)
-              scalaEvictions += p
-            if (options.warnEvictionSummary)
-              binaryIncompatibleEvictionExists = true
+            if options.warnScalaVersionEviction then scalaEvictions += p
+            if options.warnEvictionSummary then binaryIncompatibleEvictionExists = true
           case _ =>
-        }
       case p if p.includesDirect =>
-        if (!guessCompatible(p)) {
-          if (options.warnDirectEvictions)
-            directEvictions += p
-          if (options.warnEvictionSummary)
-            binaryIncompatibleEvictionExists = true
-        }
+        if !guessCompatible(p) then
+          if options.warnDirectEvictions then directEvictions += p
+          if options.warnEvictionSummary then binaryIncompatibleEvictionExists = true
       case p =>
         // don't report on a transitive eviction that does not have a winner
         // https://github.com/sbt/sbt/issues/4946
-        if (!guessCompatible(p) && p.winner.isDefined) {
-          if (options.warnTransitiveEvictions)
-            transitiveEvictions += p
-          if (options.warnEvictionSummary)
-            binaryIncompatibleEvictionExists = true
-        }
+        if !guessCompatible(p) && p.winner.isDefined then
+          if options.warnTransitiveEvictions then transitiveEvictions += p
+          if options.warnEvictionSummary then binaryIncompatibleEvictionExists = true
     }
     new EvictionWarning(
       options,
@@ -412,47 +380,42 @@ object EvictionWarning {
       pairs,
       binaryIncompatibleEvictionExists
     )
-  }
+  end processEvictions
 
   given evictionWarningLines: ShowLines[EvictionWarning] = ShowLines { (a: EvictionWarning) =>
     import ShowLines.*
     val out: mutable.ListBuffer[String] = mutable.ListBuffer()
-    if (a.options.warnEvictionSummary && a.binaryIncompatibleEvictionExists) {
+    if a.options.warnEvictionSummary && a.binaryIncompatibleEvictionExists then
       out += "There may be incompatibilities among your library dependencies; run 'evicted' to see detailed eviction warnings."
-    }
 
-    if (a.scalaEvictions.nonEmpty) {
+    if a.scalaEvictions.nonEmpty then
       out += "Scala version was updated by one of library dependencies:"
       out ++= (a.scalaEvictions flatMap { _.lines })
       out += "To force scalaVersion, add the following:"
       out += "\tscalaModuleInfo ~= (_.map(_.withOverrideScalaVersion(true)))"
-    }
 
-    if (a.directEvictions.nonEmpty || a.transitiveEvictions.nonEmpty) {
+    if a.directEvictions.nonEmpty || a.transitiveEvictions.nonEmpty then
       out += "Found version conflict(s) in library dependencies; some are suspected to be binary incompatible:"
       out += ""
       out ++= (a.directEvictions flatMap { _.lines })
       out ++= (a.transitiveEvictions flatMap { _.lines })
-    }
 
     out.toList
   }
 
   private[sbt] def infoAllTheThings(a: EvictionWarning): List[String] =
-    if (a.options.infoAllEvictions) {
+    if a.options.infoAllEvictions then
       import ShowLines.*
       val evo = a.options
       val out: mutable.ListBuffer[String] = mutable.ListBuffer()
       a.allEvictions foreach { ev =>
-        if ((a.scalaEvictions.contains[EvictionPair](ev)) && evo.warnScalaVersionEviction) ()
-        else if ((a.directEvictions.contains[EvictionPair](ev)) && evo.warnDirectEvictions) ()
-        else if ((a.transitiveEvictions.contains[EvictionPair](ev)) && evo.warnTransitiveEvictions)
-          ()
-        else {
-          out ++= ev.lines
-        }
+        if (a.scalaEvictions.contains[EvictionPair](ev)) && evo.warnScalaVersionEviction then ()
+        else if (a.directEvictions.contains[EvictionPair](ev)) && evo.warnDirectEvictions then ()
+        else if (a.transitiveEvictions.contains[EvictionPair](ev)) && evo.warnTransitiveEvictions
+        then ()
+        else out ++= ev.lines
       }
-      if (out.isEmpty) Nil
+      if out.isEmpty then Nil
       else List("Here are other dependency conflicts that were resolved:", "") ::: out.toList
-    } else Nil
-}
+    else Nil
+end EvictionWarning
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/Extra.scala b/lm-core/src/main/scala/sbt/librarymanagement/Extra.scala
index 421a40505..1c861d4c9 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/Extra.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/Extra.scala
@@ -5,7 +5,7 @@ package sbt.librarymanagement
 
 import sbt.librarymanagement.DependencyBuilders.{ Organization, OrganizationArtifactName }
 
-private[librarymanagement] abstract class InclExclRuleFunctions {
+private[librarymanagement] abstract class InclExclRuleFunctions:
   def everything = InclExclRule("*", "*", "*", Vector.empty, Disabled())
 
   def apply(organization: String, name: String): InclExclRule =
@@ -20,29 +20,26 @@ private[librarymanagement] abstract class InclExclRuleFunctions {
   implicit def organizationArtifactNameToExclusionRule(oa: OrganizationArtifactName): InclExclRule =
     InclExclRule(oa.organization, oa.name, "*", Vector.empty, oa.crossVersion)
 
-  implicit def moduleIDToExclusionRule(moduleID: ModuleID): InclExclRule = {
+  implicit def moduleIDToExclusionRule(moduleID: ModuleID): InclExclRule =
     val org = moduleID.organization
     val name = moduleID.name
     val version = moduleID.revision
     val crossVersion = moduleID.crossVersion
     InclExclRule(org, name, version, Vector.empty, crossVersion)
-  }
-}
+end InclExclRuleFunctions
 
-private[librarymanagement] abstract class ArtifactTypeFilterExtra {
+private[librarymanagement] abstract class ArtifactTypeFilterExtra:
   def inverted: Boolean
 
   def withInverted(inverted: Boolean): ArtifactTypeFilter
 
   def invert = withInverted(!inverted)
-}
 
-private[librarymanagement] abstract class ArtifactTypeFilterFunctions {
+private[librarymanagement] abstract class ArtifactTypeFilterFunctions:
   def allow(types: Set[String]) = ArtifactTypeFilter(types, false)
   def forbid(types: Set[String]) = ArtifactTypeFilter(types, true)
-}
 
-private[librarymanagement] abstract class ConflictManagerFunctions {
+private[librarymanagement] abstract class ConflictManagerFunctions:
   // To avoid NPE (or making the val's below lazy)
   // For case classes refchecks rewrites apply calls to constructor calls, we have to do it manually
   def apply(name: String, organization: String = "*", module: String = "*"): ConflictManager
@@ -54,4 +51,3 @@ private[librarymanagement] abstract class ConflictManagerFunctions {
   val latestCompatible = ConflictManager("latest-compatible")
   val strict = ConflictManager("strict")
   val default = latestRevision
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/Http.scala b/lm-core/src/main/scala/sbt/librarymanagement/Http.scala
index 0ac5f5dc9..ad464b030 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/Http.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/Http.scala
@@ -3,6 +3,5 @@ package sbt.librarymanagement
 import gigahorse.*, support.apachehttp.Gigahorse
 import scala.concurrent.duration.DurationInt
 
-object Http {
+object Http:
   lazy val http: HttpClient = Gigahorse.http(gigahorse.Config().withReadTimeout(60.minutes))
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/LibraryManagementInterface.scala b/lm-core/src/main/scala/sbt/librarymanagement/LibraryManagementInterface.scala
index 7ae9ce20f..e828f1ab4 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/LibraryManagementInterface.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/LibraryManagementInterface.scala
@@ -6,7 +6,7 @@ import sbt.util.Logger
 /**
  * Interface for dependency resolution intended for engine authors.
  */
-trait DependencyResolutionInterface {
+trait DependencyResolutionInterface:
 
   /**
    * Builds a ModuleDescriptor that describes a subproject with dependencies.
@@ -32,12 +32,12 @@ trait DependencyResolutionInterface {
       uwconfig: UnresolvedWarningConfiguration,
       log: Logger
   ): Either[UnresolvedWarning, UpdateReport]
-}
+end DependencyResolutionInterface
 
 /**
  * Interface for publishing modules.
  */
-trait PublisherInterface {
+trait PublisherInterface:
 
   /**
    * Builds a ModuleDescriptor that describes a subproject with dependencies.
@@ -65,13 +65,13 @@ trait PublisherInterface {
    * @return The `File` containing the POM descriptor.
    */
   def makePomFile(module: ModuleDescriptor, configuration: MakePomConfiguration, log: Logger): File
-}
+end PublisherInterface
 
 /**
  * Describes the representation of a module, including its dependencies
  * and the version of Scala it uses, if any.
  */
-trait ModuleDescriptor {
+trait ModuleDescriptor:
 
   /**
    * The direct dependencies of this module.
@@ -93,4 +93,4 @@ trait ModuleDescriptor {
    * Hash for extra parameter that were not captured as `moduleSettings`.
    */
   def extraInputHash: Long
-}
+end ModuleDescriptor
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/LibraryManagementSyntax.scala b/lm-core/src/main/scala/sbt/librarymanagement/LibraryManagementSyntax.scala
index d37764b3e..3b60818da 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/LibraryManagementSyntax.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/LibraryManagementSyntax.scala
@@ -2,19 +2,18 @@ package sbt.librarymanagement
 
 import java.net.URI
 
-trait LibraryManagementSyntax0 {
+trait LibraryManagementSyntax0:
   // See http://www.scala-lang.org/news/2.12.0#traits-compile-to-interfaces
   // Avoid defining fields (val or var, but a constant is ok – final val without result type)
   // Avoid calling super
   // Avoid initializer statements in the body
 
   implicit def richUpdateReport(ur: UpdateReport): RichUpdateReport = new RichUpdateReport(ur)
-}
 
 trait LibraryManagementSyntax
     extends LibraryManagementSyntax0
     with DependencyBuilders
-    with DependencyFilterExtra {
+    with DependencyFilterExtra:
   // See http://www.scala-lang.org/news/2.12.0#traits-compile-to-interfaces
   // Avoid defining fields (val or var, but a constant is ok – final val without result type)
   // Avoid calling super
@@ -38,6 +37,6 @@ trait LibraryManagementSyntax
 
   given Conversion[(String, URI), License] with
     inline def apply(x: (String, URI)): License = License(x._1, x._2)
-}
+end LibraryManagementSyntax
 
 object syntax extends LibraryManagementSyntax
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/LogicalClock.scala b/lm-core/src/main/scala/sbt/librarymanagement/LogicalClock.scala
index f55a61b82..aa5d4fc49 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/LogicalClock.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/LogicalClock.scala
@@ -4,18 +4,14 @@ package sbt.librarymanagement
  * Represents a logical time point for dependency resolution.
  * This is used to cache dependencies across subproject resolution which may change over time.
  */
-trait LogicalClock {
+trait LogicalClock:
   def toString: String
-}
 
-object LogicalClock {
-  def apply(hashCode: Int): LogicalClock = {
+object LogicalClock:
+  def apply(hashCode: Int): LogicalClock =
     def intToByteArray(x: Int): Array[Byte] =
       Array((x >>> 24).toByte, (x >> 16 & 0xff).toByte, (x >> 8 & 0xff).toByte, (x & 0xff).toByte)
     apply(sbt.io.Hash.toHex(intToByteArray(hashCode)))
-  }
-  def apply(x: String): LogicalClock = new LogicalClock {
+  def apply(x: String): LogicalClock = new LogicalClock:
     override def toString: String = x
-  }
   def unknown: LogicalClock = apply("unknown")
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/MakePomConfigurationExtra.scala b/lm-core/src/main/scala/sbt/librarymanagement/MakePomConfigurationExtra.scala
index 1b5edbb9c..a8115a448 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/MakePomConfigurationExtra.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/MakePomConfigurationExtra.scala
@@ -1,6 +1,6 @@
 package sbt.librarymanagement
 
-private[librarymanagement] abstract class MakePomConfigurationFunctions {
+private[librarymanagement] abstract class MakePomConfigurationFunctions:
   private[sbt] lazy val constTrue: MavenRepository => Boolean = _ => true
 
   def apply(): MakePomConfiguration =
@@ -14,4 +14,3 @@ private[librarymanagement] abstract class MakePomConfigurationFunctions {
       true,
       Set(Artifact.DefaultType, Artifact.PomType)
     )
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/MemoizedFileFormats.scala b/lm-core/src/main/scala/sbt/librarymanagement/MemoizedFileFormats.scala
index f0ee3c36d..1a67fbccc 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/MemoizedFileFormats.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/MemoizedFileFormats.scala
@@ -27,17 +27,16 @@ import sjsonnew.{ FileIsoStringLongs, HashUtil, IsoStringLong }
  * Mix in after `BasicJsonProtocol` (via `contrabandCodecParents`) so these overrides win in
  * linearization.
  */
-trait MemoizedFileFormats extends FileIsoStringLongs {
+trait MemoizedFileFormats extends FileIsoStringLongs:
   import MemoizedFileFormats.{ Entry, hashCache }
 
   // sjsonnew.HashUtil.sha256ToLong is private[sjsonnew]; same semantics via the public sha256
-  private def hashFile(path: Path): Long = {
+  private def hashFile(path: Path): Long =
     val buf = HashUtil.sha256(path.toFile())
     if buf.length < 8 then 0L else ByteBuffer.wrap(buf).getLong()
-  }
 
   private def memoizedHash(path: Path): Long =
-    Try(Files.readAttributes(path, classOf[BasicFileAttributes])).toOption match {
+    Try(Files.readAttributes(path, classOf[BasicFileAttributes])).toOption match
       case None =>
         // no size/mtime to validate a cache entry against, so hash uncached
         if Files.isRegularFile(path) then hashFile(path) else 0L
@@ -45,15 +44,13 @@ trait MemoizedFileFormats extends FileIsoStringLongs {
         val key = path.toString
         val mtime = attrs.lastModifiedTime.toMillis
         val cached = hashCache.getIfPresent(key)
-        if (cached != null && cached.size == attrs.size && cached.mtime == mtime) cached.hash
-        else {
-          val h = if (attrs.isDirectory) 0L else hashFile(path)
+        if cached != null && cached.size == attrs.size && cached.mtime == mtime then cached.hash
+        else
+          val h = if attrs.isDirectory then 0L else hashFile(path)
           // 0L is the sentinel for directories and files that vanish mid-hash, not a
           // content hash; caching it would keep serving 0 for the key
-          if (h != 0L) hashCache.put(key, new Entry(attrs.size, mtime, h))
+          if h != 0L then hashCache.put(key, new Entry(attrs.size, mtime, h))
           h
-        }
-    }
 
   override implicit lazy val fileStringLongIso: IsoStringLong[File] = IsoStringLong.iso[File](
     file => (IO.toURI(file).toASCIIString, memoizedHash(file.toPath())),
@@ -64,13 +61,12 @@ trait MemoizedFileFormats extends FileIsoStringLongs {
     path => (path.toString, memoizedHash(path)),
     p => Paths.get(p._1)
   )
-}
+end MemoizedFileFormats
 
-private[librarymanagement] object MemoizedFileFormats {
+private[librarymanagement] object MemoizedFileFormats:
   private final class Entry(val size: Long, val mtime: Long, val hash: Long)
 
   // shared by every mix-in of the trait; a per-instance cache would re-hash the same
   // files for each codec object that extends MemoizedFileFormats
   private val hashCache: Cache[String, Entry] =
     Caffeine.newBuilder().maximumSize(65536).build[String, Entry]()
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/ModuleIDExtra.scala b/lm-core/src/main/scala/sbt/librarymanagement/ModuleIDExtra.scala
index cc517d0f6..2929beabe 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/ModuleIDExtra.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/ModuleIDExtra.scala
@@ -11,7 +11,7 @@ import sbt.librarymanagement.syntax.*
 import sbt.util.Logger
 import sbt.librarymanagement.DependencyBuilders.OrganizationArtifactName
 
-private[librarymanagement] abstract class ModuleIDExtra {
+private[librarymanagement] abstract class ModuleIDExtra:
   def organization: String
   def name: String
   def revision: String
@@ -38,26 +38,21 @@ private[librarymanagement] abstract class ModuleIDExtra {
 
   protected def toStringImpl: String =
     s"""$organization:$name:$revision""" +
-      (configurations match { case Some(s) => ":" + s; case None => "" }) + {
+      (configurations match
+        case Some(s) => ":" + s;
+        case None    => "") + {
         val attr = attributeString
-        if (attr == "") ""
+        if attr == "" then ""
         else " " + attr
       } +
-      (if (extraAttributes.isEmpty) "" else " " + extraString)
+      (if extraAttributes.isEmpty then "" else " " + extraString)
 
-  protected def attributeString: String = {
+  protected def attributeString: String =
     val buffer = ListBuffer.empty[String]
-    if (isChanging) {
-      buffer += "changing"
-    }
-    if (!isTransitive) {
-      buffer += "intransitive"
-    }
-    if (isForce) {
-      buffer += "force"
-    }
+    if isChanging then buffer += "changing"
+    if !isTransitive then buffer += "intransitive"
+    if isForce then buffer += "force"
     buffer.toList.mkString(";")
-  }
 
   /** String representation of the extra attributes, excluding any information only attributes. */
   def extraString: String =
@@ -71,7 +66,7 @@ private[librarymanagement] abstract class ModuleIDExtra {
     "Use `cross(CrossVersion)`, the variant accepting a CrossVersion value constructed by a member of the CrossVersion object instead.",
     "0.12.0"
   )
-  def cross(v: Boolean): ModuleID = cross(if (v) CrossVersion.binary else Disabled())
+  def cross(v: Boolean): ModuleID = cross(if v then CrossVersion.binary else Disabled())
 
   /**
    * Specifies the cross-version behavior for this module. See [CrossVersion] for details.
@@ -87,14 +82,12 @@ private[librarymanagement] abstract class ModuleIDExtra {
    * This allows `.cross(...)` to play well with `%%%` operator provided by sbt-platform-deps.
    */
   def cross(v: CrossVersion): ModuleID =
-    withCrossVersion(CrossVersion.getPrefixSuffix(this.crossVersion) match {
+    withCrossVersion(CrossVersion.getPrefixSuffix(this.crossVersion) match
       case ("", "")         => v
       case (prefix, suffix) =>
-        CrossVersion.getPrefixSuffix(v) match {
+        CrossVersion.getPrefixSuffix(v) match
           case ("", "") => CrossVersion.setPrefixSuffix(v, prefix, suffix)
-          case _        => v
-        }
-    })
+          case _        => v)
 
   // () required for chaining
   /** Do not follow dependencies of this module.  Synonym for `intransitive`. */
@@ -117,9 +110,8 @@ private[librarymanagement] abstract class ModuleIDExtra {
    */
   def force(): ModuleID = withIsForce(true)
 
-  private[sbt] def validateProtocol(logger: Logger): Unit = {
+  private[sbt] def validateProtocol(logger: Logger): Unit =
     explicitArtifacts foreach { _.validateProtocol(logger) }
-  }
 
   /**
    * Specifies a URL from which the main artifact for this dependency can be downloaded.
@@ -161,9 +153,8 @@ private[librarymanagement] abstract class ModuleIDExtra {
     excludeAll(ExclusionRule().withOrganization(org).withName(name))
 
   /** Excludes the dependency from being introduced by this dependency during resolution. */
-  def exclude(rule: OrganizationArtifactName): ModuleID = {
+  def exclude(rule: OrganizationArtifactName): ModuleID =
     excludeAll(rule)
-  }
 
   /**
    * Adds extra attributes for this module.  All keys are prefixed with `e:` if they are not already so prefixed.
@@ -202,7 +193,7 @@ private[librarymanagement] abstract class ModuleIDExtra {
    */
   def withJavadoc(): ModuleID = jarIfEmpty.javadoc()
 
-  private def jarIfEmpty = if (explicitArtifacts.isEmpty) jar() else this
+  private def jarIfEmpty = if explicitArtifacts.isEmpty then jar() else this
 
   /**
    * Declares a dependency on the main artifact.  This is implied by default unless artifacts are explicitly declared, such
@@ -218,12 +209,11 @@ private[librarymanagement] abstract class ModuleIDExtra {
   def branch(branchName: Option[String]): ModuleID = withBranchName(branchName)
 
   def platform(platform: String): ModuleID = withPlatformOpt(Some(platform))
-}
+end ModuleIDExtra
 
-private[librarymanagement] abstract class ModuleIDFunctions {
+private[librarymanagement] abstract class ModuleIDFunctions:
 
   /** Prefixes all keys with `e:` if they are not already so prefixed. */
   def checkE(attributes: Seq[(String, String)]) =
-    for ((key, value) <- attributes)
-      yield if (key.startsWith("e:")) (key, value) else ("e:" + key, value)
-}
+    for (key, value) <- attributes
+    yield if key.startsWith("e:") then (key, value) else ("e:" + key, value)
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/Publisher.scala b/lm-core/src/main/scala/sbt/librarymanagement/Publisher.scala
index c071240f9..c6dcd976c 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/Publisher.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/Publisher.scala
@@ -6,7 +6,7 @@ import sbt.util.Logger
 /**
  * Library management API to publish artifacts.
  */
-class Publisher private[sbt] (publisherEngine: PublisherInterface) {
+class Publisher private[sbt] (publisherEngine: PublisherInterface):
 
   /**
    * Builds a ModuleDescriptor that describes a subproject with dependencies.
@@ -41,9 +41,8 @@ class Publisher private[sbt] (publisherEngine: PublisherInterface) {
       log: Logger
   ): File =
     publisherEngine.makePomFile(module, configuration, log)
-}
+end Publisher
 
-object Publisher {
+object Publisher:
   def apply(publisherEngine: PublisherInterface): Publisher =
     new Publisher(publisherEngine)
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/ResolverExtra.scala b/lm-core/src/main/scala/sbt/librarymanagement/ResolverExtra.scala
index 702554fc5..25e409284 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/ResolverExtra.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/ResolverExtra.scala
@@ -12,41 +12,35 @@ import sbt.util.Logger
 
 import scala.util.matching.Regex
 
-final class RawRepository(val resolver: AnyRef, name: String) extends Resolver(name) {
+final class RawRepository(val resolver: AnyRef, name: String) extends Resolver(name):
   override def toString = "Raw(" + resolver.toString + ")"
 
-  override def equals(o: Any): Boolean = o match {
+  override def equals(o: Any): Boolean = o match
     case o: RawRepository =>
       this.name == o.name
     case _ => false
-  }
 
-  override def hashCode: Int = {
+  override def hashCode: Int =
     var hash = 1
     hash = hash * 31 + this.name.##
     hash
-  }
-}
 
-private[librarymanagement] abstract class MavenRepositoryFunctions {
+private[librarymanagement] abstract class MavenRepositoryFunctions:
   def apply(name: String, root: String, localIfFile: Boolean = true): MavenRepository =
     MavenRepo(name, root, localIfFile)
-}
 
-private[librarymanagement] abstract class PatternsFunctions {
+private[librarymanagement] abstract class PatternsFunctions:
   implicit def defaultPatterns: Patterns = Resolver.defaultPatterns
 
   def apply(artifactPatterns: String*): Patterns = Patterns(false, artifactPatterns*)
-  def apply(isMavenCompatible: Boolean, artifactPatterns: String*): Patterns = {
+  def apply(isMavenCompatible: Boolean, artifactPatterns: String*): Patterns =
     val patterns = artifactPatterns.toVector
     Patterns()
       .withIvyPatterns(patterns)
       .withArtifactPatterns(patterns)
       .withIsMavenCompatible(isMavenCompatible)
-  }
-}
 
-private[librarymanagement] trait SshBasedRepositoryExtra {
+private[librarymanagement] trait SshBasedRepositoryExtra:
 
   /** The object representing the configured ssh connection for this repository. */
   def connection: SshConnection
@@ -69,9 +63,9 @@ private[librarymanagement] trait SshBasedRepositoryExtra {
 
   def as(user: String, keyfile: File, password: Option[String]): RepositoryType =
     copy(KeyFileAuthentication(user, keyfile, password))
-}
+end SshBasedRepositoryExtra
 
-private[librarymanagement] trait SshRepositoryExtra extends SshBasedRepositoryExtra {
+private[librarymanagement] trait SshRepositoryExtra extends SshBasedRepositoryExtra:
   def name: String
   def patterns: sbt.librarymanagement.Patterns
   def publishPermissions: Option[String]
@@ -80,9 +74,8 @@ private[librarymanagement] trait SshRepositoryExtra extends SshBasedRepositoryEx
 
   protected def copy(connection: SshConnection): SshRepository =
     SshRepository(name, connection, patterns, publishPermissions)
-}
 
-private[librarymanagement] trait SftpRepositoryExtra extends SshBasedRepositoryExtra {
+private[librarymanagement] trait SftpRepositoryExtra extends SshBasedRepositoryExtra:
   def name: String
   def patterns: sbt.librarymanagement.Patterns
 
@@ -90,14 +83,12 @@ private[librarymanagement] trait SftpRepositoryExtra extends SshBasedRepositoryE
 
   protected def copy(connection: SshConnection): SftpRepository =
     SftpRepository(name, connection, patterns)
-}
 
 /** A repository that conforms to sbt launcher's interface */
-private[sbt] class FakeRepository(resolver: AnyRef, name: String) extends xsbti.Repository {
+private[sbt] class FakeRepository(resolver: AnyRef, name: String) extends xsbti.Repository:
   def rawRepository = new RawRepository(resolver, name)
-}
 
-private[librarymanagement] abstract class ResolverFunctions {
+private[librarymanagement] abstract class ResolverFunctions:
   val TypesafeRepositoryRoot = "https://repo.typesafe.com/typesafe"
   val SbtRepositoryRoot = "https://repo.scala-sbt.org/scalasbt"
   @deprecated("Renamed to SbtRepositoryRoot.", "1.0.0")
@@ -152,7 +143,7 @@ private[librarymanagement] abstract class ResolverFunctions {
   def sonatypeRepo(status: String) =
     MavenRepository(
       "sonatype-" + status,
-      if (status == "releases") SonatypeReleasesRepository
+      if status == "releases" then SonatypeReleasesRepository
       else SonatypeRepositoryRoot + "/" + status
     )
   private def sonatypeS01Repo(status: String) =
@@ -212,23 +203,22 @@ private[librarymanagement] abstract class ResolverFunctions {
       appResolvers: Vector[Resolver],
       mavenCentral: Boolean
   ): Vector[Resolver] =
-    appResolvers.partition(_ == Resolver.defaultLocal) match {
+    appResolvers.partition(_ == Resolver.defaultLocal) match
       case (locals, xs) =>
         locals ++
-          (xs.partition(_ == DefaultMavenRepository) match {
-            case (_, xs) =>
-              single(
-                DefaultMavenRepository,
-                mavenCentral
-              ) ++ xs // TODO - Do we need to filter out duplicates?
-          })
-    }
+          (xs.partition(_ == DefaultMavenRepository) match
+              case (_, xs) =>
+                single(
+                  DefaultMavenRepository,
+                  mavenCentral
+                ) ++ xs // TODO - Do we need to filter out duplicates?
+          )
 
   private def single[T](value: T, nonEmpty: Boolean): Vector[T] =
-    if (nonEmpty) Vector(value) else Vector.empty
+    if nonEmpty then Vector(value) else Vector.empty
 
   /** A base class for defining factories for interfaces to Ivy repositories that require a hostname , port, and patterns. */
-  sealed abstract class Define[RepositoryType <: SshBasedRepository] {
+  sealed abstract class Define[RepositoryType <: SshBasedRepository]:
 
     /** Subclasses should implement this method to */
     protected def construct(
@@ -289,7 +279,7 @@ private[librarymanagement] abstract class ResolverFunctions {
         implicit basePatterns: Patterns
     ): RepositoryType =
       construct(name, SshConnection(None, hostname, port), resolvePatterns(basePath, basePatterns))
-  }
+  end Define
 
   /**
    * A factory to construct an interface to an Ivy SSH resolver.
@@ -299,10 +289,9 @@ private[librarymanagement] abstract class ResolverFunctions {
    * literal (e.g. `org.example`), supply Ivy-style patterns such as a [[Patterns]] built with
    * `isMavenCompatible = false` (the [[Patterns]] default). See issue #535.
    */
-  object ssh extends Define[SshRepository] {
+  object ssh extends Define[SshRepository]:
     protected def construct(name: String, connection: SshConnection, patterns: Patterns) =
       SshRepository(name, connection, patterns, None)
-  }
 
   /**
    * A factory to construct an interface to an Ivy SFTP resolver.
@@ -312,13 +301,12 @@ private[librarymanagement] abstract class ResolverFunctions {
    * literal (e.g. `org.example`), supply Ivy-style patterns such as a [[Patterns]] built with
    * `isMavenCompatible = false` (the [[Patterns]] default). See issue #535.
    */
-  object sftp extends Define[SftpRepository] {
+  object sftp extends Define[SftpRepository]:
     protected def construct(name: String, connection: SshConnection, patterns: Patterns) =
       SftpRepository(name, connection, patterns)
-  }
 
   /** A factory to construct an interface to an Ivy filesystem resolver. */
-  object file {
+  object file:
 
     /**
      * Constructs a file resolver with the given name.  The patterns to use must be explicitly specified
@@ -336,7 +324,6 @@ private[librarymanagement] abstract class ResolverFunctions {
       )
 
     private def toUri(dir: File): URI = dir.toPath.toUri
-  }
   object url:
 
     /**
@@ -379,13 +366,12 @@ private[librarymanagement] abstract class ResolverFunctions {
    * Otherwise, the ivy file and artifact patterns in `patterns` are resolved against the given base.
    */
   private def resolvePatterns(base: Option[String], patterns: Patterns): Patterns =
-    base match {
+    base match
       case Some(path) => resolvePatterns(path, patterns)
       case None       => patterns
-    }
 
   /** Resolves the ivy file and artifact patterns in `patterns` against the given base. */
-  private def resolvePatterns(base: String, basePatterns: Patterns): Patterns = {
+  private def resolvePatterns(base: String, basePatterns: Patterns): Patterns =
     def resolveAll(patterns: Vector[String]) = patterns.map(p => resolvePattern(base, p))
     Patterns(
       resolveAll(basePatterns.ivyPatterns),
@@ -394,12 +380,10 @@ private[librarymanagement] abstract class ResolverFunctions {
       basePatterns.descriptorOptional,
       basePatterns.skipConsistencyCheck
     )
-  }
-  private[sbt] def resolvePattern(base: String, pattern: String): String = {
+  private[sbt] def resolvePattern(base: String, pattern: String): String =
     val normBase = base.replace('\\', '/')
-    if (normBase.endsWith("/") || pattern.startsWith("/")) normBase + pattern
+    if normBase.endsWith("/") || pattern.startsWith("/") then normBase + pattern
     else normBase + "/" + pattern
-  }
   def defaultFileConfiguration = FileConfiguration(true, None)
 
   /**
@@ -428,7 +412,7 @@ private[librarymanagement] abstract class ResolverFunctions {
       str: String,
       envVars: Map[String, String] = sys.env,
       props: Map[String, String] = sys.props.toMap
-  ): String = {
+  ): String =
     // Aren't regular expressions beautifully clear and concise.
     // This means "find all ${...}" blocks, with the first group of each being the text between curly brackets.
     val findQuoted = "\\$\\{([^}]*)}".r
@@ -438,25 +422,23 @@ private[librarymanagement] abstract class ResolverFunctions {
       str,
       regexMatch =>
         Regex.quoteReplacement {
-          regexMatch.group(1) match {
+          regexMatch.group(1) match
             case env(variable) => envVars.getOrElse(variable, "")
             case property      => props.getOrElse(property, "")
-          }
         }
     )
-  }
 
-  private def mavenLocalDir: File = {
+  private def mavenLocalDir: File =
     def loadHomeFromSettings(f: () => File): Option[File] =
-      try {
+      try
         val file = f()
-        if (!file.exists) None
+        if !file.exists then None
         else
-          ((XML.loadFile(file) \ "localRepository").text match {
+          ((XML.loadFile(file) \ "localRepository").text match
             case ""    => None
             case e @ _ => Some(new File(expandMavenSettings(e)))
-          })
-      } catch {
+        )
+      catch
         // Occurs inside File constructor when property or environment variable does not exist
         case _: NullPointerException => None
         // Occurs when File does not exist
@@ -464,82 +446,73 @@ private[librarymanagement] abstract class ResolverFunctions {
         case e: SAXParseException =>
           System.err.println(s"WARNING: Problem parsing ${f().getAbsolutePath}, ${e.getMessage}");
           None
-      }
     sys.props.get("maven.repo.local").map(new File(_)) orElse
       loadHomeFromSettings(() => new File(sbt.io.Path.userHome, ".m2/settings.xml")) orElse
       loadHomeFromSettings(() =>
         new File(new File(System.getenv("M2_HOME")), "conf/settings.xml")
       ) getOrElse
       new File(sbt.io.Path.userHome, ".m2/repository")
-  }
+  end mavenLocalDir
   // TODO - should this just be the *exact* same as mavenLocal?  probably...
   def publishMavenLocal: MavenCache = new MavenCache("publish-m2-local", mavenLocalDir)
   def mavenLocal: MavenRepository = new MavenCache("Maven2 Local", mavenLocalDir)
   def defaultLocal = defaultUserFileRepository("local")
   def defaultShared = defaultUserFileRepository("shared")
-  def defaultUserFileRepository(id: String) = {
+  def defaultUserFileRepository(id: String) =
     val pList = Vector(s"$${ivy.home}/$id/$localBasePattern")
     FileRepository(
       id,
       defaultFileConfiguration,
       Patterns().withIvyPatterns(pList).withArtifactPatterns(pList).withIsMavenCompatible(false)
     )
-  }
-  def defaultIvyPatterns = {
+  def defaultIvyPatterns =
     val pList = Vector(localBasePattern)
     Patterns().withIvyPatterns(pList).withArtifactPatterns(pList).withIsMavenCompatible(false)
-  }
 
   // to display all error messages at once, just log here don't throw
-  private[sbt] def warnHttp(value: String, suggestion: String, logger: Logger): Unit = {
+  private[sbt] def warnHttp(value: String, suggestion: String, logger: Logger): Unit =
     logger.error(s"insecure HTTP request is unsupported '$value'; switch to HTTPS$suggestion")
-  }
-  private[sbt] def isInsecureUrl(str: String): Boolean = {
+  private[sbt] def isInsecureUrl(str: String): Boolean =
     // don't try to parse str as URL because it could contain $variable from Ivy pattern
     str.startsWith("http:") &&
-    !(str.startsWith("http://localhost/")
-      || str.startsWith("http://localhost:")
-      || str.startsWith("http://127.0.0.1/")
-      || str.startsWith("http://127.0.0.1:"))
-  }
-  private[sbt] def validateURLRepository(repo: URLRepository, logger: Logger): Boolean = {
-    if (repo.allowInsecureProtocol) false
-    else {
+      !(str.startsWith("http://localhost/")
+        || str.startsWith("http://localhost:")
+        || str.startsWith("http://127.0.0.1/")
+        || str.startsWith("http://127.0.0.1:"))
+  private[sbt] def validateURLRepository(repo: URLRepository, logger: Logger): Boolean =
+    if repo.allowInsecureProtocol then false
+    else
       val patterns = repo.patterns
-      val ivy = patterns.ivyPatterns.headOption match {
+      val ivy = patterns.ivyPatterns.headOption match
         case Some(x) => isInsecureUrl(x)
         case _       => false
-      }
-      val art = patterns.artifactPatterns.headOption match {
+      val art = patterns.artifactPatterns.headOption match
         case Some(x) => isInsecureUrl(x)
         case _       => false
-      }
-      if (ivy || art) {
+      if ivy || art then
         warnHttp(
           patterns.toString,
           s""" or opt-in as Resolver.uri("${repo.name}", url(...)).withAllowInsecureProtocol(true), or by using allowInsecureProtocol in repositories file""",
           logger
         )
         true
-      } else false
-    }
-  }
+      else false
 
   private[sbt] def validateMavenRepo(repo: MavenRepo, logger: Logger): Boolean =
-    if (repo.allowInsecureProtocol) false
-    else if (isInsecureUrl(repo.root)) {
+    if repo.allowInsecureProtocol then false
+    else if isInsecureUrl(repo.root) then
       warnHttp(
         repo.root,
         s""" or opt-in as ("${repo.name}" at "${repo.root}").withAllowInsecureProtocol(true), or by using allowInsecureProtocol in repositories file""",
         logger
       )
       true
-    } else false
+    else false
 
   private[sbt] def validateArtifact(art: Artifact, logger: Logger): Boolean =
-    if (art.allowInsecureProtocol) false
+    if art.allowInsecureProtocol then false
     else
-      art.url match {
+      art.url match
         case Some(url) if isInsecureUrl(url.toString) =>
           warnHttp(
             art.toString,
@@ -548,5 +521,4 @@ private[librarymanagement] abstract class ResolverFunctions {
           )
           true
         case _ => false
-      }
-}
+end ResolverFunctions
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/RichUpdateReport.scala b/lm-core/src/main/scala/sbt/librarymanagement/RichUpdateReport.scala
index 66bf8dadf..0bed38730 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/RichUpdateReport.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/RichUpdateReport.scala
@@ -8,8 +8,8 @@ import sbt.io.IO
  * Provides extra methods for filtering the contents of an `UpdateReport`
  * and for obtaining references to a selected subset of the underlying files.
  */
-final class RichUpdateReport(report: UpdateReport) {
-  private[sbt] def recomputeStamps(): UpdateReport = {
+final class RichUpdateReport(report: UpdateReport):
+  private[sbt] def recomputeStamps(): UpdateReport =
     val files = report.cachedDescriptor +: allFiles
     val stamps = files
       .map(f =>
@@ -24,7 +24,6 @@ final class RichUpdateReport(report: UpdateReport) {
       )
       .toMap
     UpdateReport(report.cachedDescriptor, report.configurations, report.stats, stamps)
-  }
 
   import DependencyFilter.*
 
@@ -50,19 +49,17 @@ final class RichUpdateReport(report: UpdateReport) {
     select(configurationFilter(), moduleFilter(), artifact)
 
   private def select0(f: DependencyFilter): Vector[File] =
-    for {
+    for
       cReport <- report.configurations
       mReport <- cReport.modules
       (artifact, file) <- mReport.artifacts
       if f(cReport.configuration, mReport.module, artifact)
-    } yield {
-      if (file == null) {
+    yield
+      if file == null then
         sys.error(
           s"Null file: conf=${cReport.configuration}, module=${mReport.module}, art: $artifact"
         )
-      }
       file
-    }
 
   /** Constructs a new report that only contains files matching the specified filter. */
   def filter(f: DependencyFilter): UpdateReport =
@@ -92,18 +89,18 @@ final class RichUpdateReport(report: UpdateReport) {
 
   def toSeq: Seq[(ConfigRef, ModuleID, Artifact, File)] = toVector
   def toVector: Vector[(ConfigRef, ModuleID, Artifact, File)] =
-    for {
+    for
       confReport <- report.configurations
       modReport <- confReport.modules
       (artifact, file) <- modReport.artifacts
-    } yield (confReport.configuration, modReport.module, artifact, file)
+    yield (confReport.configuration, modReport.module, artifact, file)
 
   def allMissing: Vector[(ConfigRef, ModuleID, Artifact)] =
-    for {
+    for
       confReport <- report.configurations
       modReport <- confReport.modules
       artifact <- modReport.missingArtifacts
-    } yield (confReport.configuration, modReport.module, artifact)
+    yield (confReport.configuration, modReport.module, artifact)
 
   private[sbt] def addMissing(f: ModuleID => Seq[Artifact]): UpdateReport =
     moduleReportMap { (configuration, modReport) =>
@@ -111,7 +108,7 @@ final class RichUpdateReport(report: UpdateReport) {
         .withMissingArtifacts((modReport.missingArtifacts ++ f(modReport.module)).distinct)
     }
 
-  private[sbt] def moduleReportMap(f: (ConfigRef, ModuleReport) => ModuleReport): UpdateReport = {
+  private[sbt] def moduleReportMap(f: (ConfigRef, ModuleReport) => ModuleReport): UpdateReport =
     val newConfigurations = report.configurations.map { confReport =>
       import confReport.*
       val newModules = modules map { modReport =>
@@ -120,5 +117,4 @@ final class RichUpdateReport(report: UpdateReport) {
       ConfigurationReport(configuration, newModules, details)
     }
     UpdateReport(report.cachedDescriptor, newConfigurations, report.stats, report.stamps)
-  }
-}
+end RichUpdateReport
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/ScalaArtifacts.scala b/lm-core/src/main/scala/sbt/librarymanagement/ScalaArtifacts.scala
index 4ccb7255d..3a0549e7c 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/ScalaArtifacts.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/ScalaArtifacts.scala
@@ -1,6 +1,6 @@
 package sbt.librarymanagement
 
-object ScalaArtifacts {
+object ScalaArtifacts:
   final val Organization = "org.scala-lang"
   final val LibraryID = "scala-library"
   final val CompilerID = "scala-compiler"
@@ -28,19 +28,17 @@ object ScalaArtifacts {
   private[sbt] final val Scala3TastyInspectorPrefix = Scala3TastyInspectorID + "_"
   private[sbt] final val Scala3ReplPrefix = Scala3ReplID + "_"
 
-  def isScala2Artifact(name: String): Boolean = {
+  def isScala2Artifact(name: String): Boolean =
     name == LibraryID || name == CompilerID || name == ReflectID || name == ActorsID || name == ScalapID
-  }
-  def isScala3Artifact(name: String): Boolean = {
+  def isScala3Artifact(name: String): Boolean =
     name.startsWith(Scala3LibraryPrefix) ||
-    name.startsWith(Scala3CompilerPrefix) ||
-    name.startsWith(TastyCorePrefix) ||
-    name == Scala3InterfacesID ||
-    name.startsWith(ScaladocPrefix) ||
-    name.startsWith(Scala3DocPrefix) ||
-    name.startsWith(Scala3TastyInspectorPrefix) ||
-    name.startsWith(Scala3ReplPrefix)
-  }
+      name.startsWith(Scala3CompilerPrefix) ||
+      name.startsWith(TastyCorePrefix) ||
+      name == Scala3InterfacesID ||
+      name.startsWith(ScaladocPrefix) ||
+      name.startsWith(Scala3DocPrefix) ||
+      name.startsWith(Scala3TastyInspectorPrefix) ||
+      name.startsWith(Scala3ReplPrefix)
 
   def isScala3(scalaVersion: String): Boolean =
     scalaVersion.startsWith("3.") || scalaVersion.startsWith("3-latest.")
@@ -49,26 +47,22 @@ object ScalaArtifacts {
    * Returns true for pre-release nightlies intentionally.
    */
   def isScala3_8Plus(scalaVersion: String): Boolean =
-    isScala3(scalaVersion) && (scalaVersion match {
+    isScala3(scalaVersion) && (scalaVersion match
       case VersionNumber(numbers, _, _) if numbers.size > 2 && numbers(1) >= 8 => true
-      case _                                                                   => false
-    })
+      case _                                                                   => false)
 
   private[sbt] def isScala3M123(scalaVersion: String): Boolean =
     (scalaVersion == "3.0.0-M1") ||
       (scalaVersion == "3.0.0-M2") ||
       (scalaVersion == "3.0.0-M3")
 
-  def libraryIds(version: String): Array[String] = {
-    if (isScala3(version))
-      Array(Scala3LibraryID, LibraryID)
+  def libraryIds(version: String): Array[String] =
+    if isScala3(version) then Array(Scala3LibraryID, LibraryID)
     else Array(LibraryID)
-  }
 
-  def compilerId(version: String): String = {
-    if (isScala3(version)) Scala3CompilerID
+  def compilerId(version: String): String =
+    if isScala3(version) then Scala3CompilerID
     else CompilerID
-  }
 
   def libraryDependency(version: String): ModuleID = libraryDependency(Organization, version)
 
@@ -83,7 +77,7 @@ object ScalaArtifacts {
       org: String,
       version: String
   ): Seq[ModuleID] =
-    if (isScala3_8Plus(version))
+    if isScala3_8Plus(version) then
       Seq(
         ModuleID(org, Scala3ReplID, version)
           .withConfigurations(Some(Configurations.ScalaReplTool.name + "->default(compile)"))
@@ -95,13 +89,13 @@ object ScalaArtifacts {
       org: String,
       version: String
   ): Seq[ModuleID] =
-    if (isScala3M123(version))
+    if isScala3M123(version) then
       Seq(
         ModuleID(org, Scala3DocID, version)
           .withConfigurations(Some(Configurations.ScalaDocTool.name + "->default(compile)"))
           .withCrossVersion(CrossVersion.binary)
       )
-    else if (isScala3(version))
+    else if isScala3(version) then
       Seq(
         ModuleID(org, ScaladocID, version)
           .withConfigurations(Some(Configurations.ScalaDocTool.name + "->default(compile)"))
@@ -114,7 +108,7 @@ object ScalaArtifacts {
       org: String,
       version: String
   ): Seq[ModuleID] =
-    if (isScala3(version))
+    if isScala3(version) then
       Seq(
         ModuleID(org, Scala3CompilerID, version)
           .withConfigurations(Some(Configurations.ScalaTool.name + "->default(compile)"))
@@ -156,8 +150,7 @@ object ScalaArtifacts {
           .platform(Platform.jvm)
       )
     else Nil
-}
+end ScalaArtifacts
 
-object SbtArtifacts {
+object SbtArtifacts:
   val Organization = "org.scala-sbt"
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/TrackLevel.scala b/lm-core/src/main/scala/sbt/librarymanagement/TrackLevel.scala
index e92b37d68..e4ea90cd2 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/TrackLevel.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/TrackLevel.scala
@@ -4,30 +4,24 @@ package sbt.librarymanagement
  * An enumeration defining the tracking of dependencies.  A level includes all of the levels
  * with id larger than its own id.  For example, Warn (id=3) includes Error (id=4).
  */
-object TrackLevel {
-  case object NoTracking extends TrackLevel {
+object TrackLevel:
+  case object NoTracking extends TrackLevel:
     override def id: Int = 0
-  }
-  case object TrackIfMissing extends TrackLevel {
+  case object TrackIfMissing extends TrackLevel:
     override def id: Int = 1
-  }
-  case object TrackAlways extends TrackLevel {
+  case object TrackAlways extends TrackLevel:
     override def id: Int = 10
-  }
 
   private[sbt] def apply(x: Int): TrackLevel =
-    x match {
+    x match
       case 0  => NoTracking
       case 1  => TrackIfMissing
       case 10 => TrackAlways
-    }
 
   def intersection(a: TrackLevel, b: TrackLevel): TrackLevel =
-    if (a.id < b.id) a
+    if a.id < b.id then a
     else b
   def intersectionAll(vs: List[TrackLevel]): TrackLevel = vs reduceLeft intersection
-}
 
-sealed trait TrackLevel {
+sealed trait TrackLevel:
   def id: Int
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/UnresolvedWarning.scala b/lm-core/src/main/scala/sbt/librarymanagement/UnresolvedWarning.scala
index 22a807d1c..46cdf6640 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/UnresolvedWarning.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/UnresolvedWarning.scala
@@ -8,7 +8,7 @@ final class ResolveException(
     val messages: Seq[String],
     val failed: Seq[ModuleID],
     val failedPaths: Map[ModuleID, Seq[ModuleID]]
-) extends RuntimeException(messages.mkString("\n")) {
+) extends RuntimeException(messages.mkString("\n")):
   def this(messages: Seq[String], failed: Seq[ModuleID]) =
     this(
       messages,
@@ -17,7 +17,6 @@ final class ResolveException(
         m -> Nil
       }*)
     )
-}
 
 /**
  * Represents unresolved dependency warning, which displays reconstructed dependency tree
@@ -28,11 +27,11 @@ final class UnresolvedWarning(
     val failedPaths: Seq[Seq[(ModuleID, Option[SourcePosition])]]
 )
 
-object UnresolvedWarning {
+object UnresolvedWarning:
   def apply(
       err: ResolveException,
       config: UnresolvedWarningConfiguration
-  ): UnresolvedWarning = {
+  ): UnresolvedWarning =
     def modulePosition(m0: ModuleID): Option[SourcePosition] =
       config.modulePositions.find { case (m, _) =>
         (m.organization == m0.organization) &&
@@ -47,44 +46,38 @@ object UnresolvedWarning {
       }
     }
     new UnresolvedWarning(err, failedPaths)
-  }
 
   private[sbt] def sourcePosStr(posOpt: Option[SourcePosition]): String =
-    posOpt match {
+    posOpt match
       case Some(LinePosition(path, start))                  => s" ($path#L$start)"
       case Some(RangePosition(path, LineRange(start, end))) => s" ($path#L$start-$end)"
       case _                                                => ""
-    }
   given unresolvedWarningLines: ShowLines[UnresolvedWarning] = ShowLines { a =>
     val withExtra = a.resolveException.failed.filter(_.extraDependencyAttributes.nonEmpty)
     val buffer = mutable.ListBuffer[String]()
-    if (withExtra.nonEmpty) {
+    if withExtra.nonEmpty then
       buffer += "\n\tNote: Some unresolved dependencies have extra attributes.  Check that these dependencies exist with the requested attributes."
       withExtra foreach { id =>
         buffer += "\t\t" + id
       }
-    }
-    if (a.failedPaths.nonEmpty) {
+    if a.failedPaths.nonEmpty then
       buffer += "\n\tNote: Unresolved dependencies path:"
       a.failedPaths foreach { path =>
-        if (path.nonEmpty) {
+        if path.nonEmpty then
           val head = path.head
           buffer += "\t\t" + head._1.toString + sourcePosStr(head._2)
           path.tail foreach { (m, pos) =>
             buffer += "\t\t  +- " + m.toString + sourcePosStr(pos)
           }
-        }
       }
-    }
     buffer.toList
   }
-}
+end UnresolvedWarning
 
 final class UnresolvedWarningConfiguration private[sbt] (
     val modulePositions: Map[ModuleID, SourcePosition]
 )
-object UnresolvedWarningConfiguration {
+object UnresolvedWarningConfiguration:
   def apply(): UnresolvedWarningConfiguration = apply(Map())
   def apply(modulePositions: Map[ModuleID, SourcePosition]): UnresolvedWarningConfiguration =
     new UnresolvedWarningConfiguration(modulePositions)
-}
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/UpdateReportExtra.scala b/lm-core/src/main/scala/sbt/librarymanagement/UpdateReportExtra.scala
index 83f30a58b..555dd33a3 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/UpdateReportExtra.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/UpdateReportExtra.scala
@@ -6,7 +6,7 @@ package sbt.librarymanagement
 import java.io.File
 import java.util as ju
 
-private[librarymanagement] abstract class ConfigurationReportExtra {
+private[librarymanagement] abstract class ConfigurationReportExtra:
   def configuration: ConfigRef
   def modules: Vector[ModuleReport]
   def details: Vector[OrganizationArtifactReport]
@@ -20,13 +20,12 @@ private[librarymanagement] abstract class ConfigurationReportExtra {
    * For a given organization and module name, there is only one revision/`ModuleID` in this sequence.
    */
   def allModules: Seq[ModuleID] = modules map addConfiguration
-  private def addConfiguration(mr: ModuleReport): ModuleID = {
+  private def addConfiguration(mr: ModuleReport): ModuleID =
     val module = mr.module
-    if (module.configurations.isEmpty) {
+    if module.configurations.isEmpty then
       val conf = mr.configurations map (c => s"$configuration->$c") mkString ";"
       module.withConfigurations(Some(conf))
-    } else module
-  }
+    else module
 
   def retrieve(f: (ConfigRef, ModuleID, Artifact, File) => File): ConfigurationReport =
     ConfigurationReport(
@@ -36,9 +35,9 @@ private[librarymanagement] abstract class ConfigurationReportExtra {
       },
       details
     )
-}
+end ConfigurationReportExtra
 
-private[librarymanagement] abstract class ModuleReportExtra {
+private[librarymanagement] abstract class ModuleReportExtra:
   def module: ModuleID
   def artifacts: Vector[(Artifact, File)]
   def missingArtifacts: Vector[Artifact]
@@ -65,7 +64,7 @@ private[librarymanagement] abstract class ModuleReportExtra {
 
   def detailReport: String =
     s"\t\t- ${module.revision}\n" +
-      (if (arts.size <= 1) "" else arts.mkString("\t\t\t", "\n\t\t\t", "\n")) +
+      (if arts.size <= 1 then "" else arts.mkString("\t\t\t", "\n\t\t\t", "\n")) +
       reportStr("status", status) +
       reportStr("publicationDate", publicationDate map calendarToString) +
       reportStr("resolver", resolver) +
@@ -77,49 +76,40 @@ private[librarymanagement] abstract class ModuleReportExtra {
       reportStr("homepage", homepage) +
       reportStr(
         "extraAttributes",
-        if (extraAttributes.isEmpty) None
-        else {
-          Some(extraAttributes.toString)
-        }
+        if extraAttributes.isEmpty then None
+        else Some(extraAttributes.toString)
       ) +
       reportStr("isDefault", isDefault map { _.toString }) +
       reportStr("branch", branch) +
       reportStr(
         "configurations",
-        if (configurations.isEmpty) None
-        else {
-          Some(configurations.mkString(", "))
-        }
+        if configurations.isEmpty then None
+        else Some(configurations.mkString(", "))
       ) +
       reportStr(
         "licenses",
-        if (licenses.isEmpty) None
-        else {
-          Some(licenses.mkString(", "))
-        }
+        if licenses.isEmpty then None
+        else Some(licenses.mkString(", "))
       ) +
       reportStr(
         "callers",
-        if (callers.isEmpty) None
-        else {
-          Some(callers.mkString(", "))
-        }
+        if callers.isEmpty then None
+        else Some(callers.mkString(", "))
       )
   private[sbt] def reportStr(key: String, value: Option[String]): String =
     value map { x =>
       s"\t\t\t$key: $x\n"
     } getOrElse ""
 
-  private def calendarToString(c: ju.Calendar): String = {
+  private def calendarToString(c: ju.Calendar): String =
     import sjsonnew.*, BasicJsonProtocol.*
     implicitly[IsoString[ju.Calendar]].to(c)
-  }
 
   def retrieve(f: (ModuleID, Artifact, File) => File): ModuleReport =
     withArtifacts(artifacts.map { (art, file) => (art, f(module, art, file)) })
-}
+end ModuleReportExtra
 
-private[librarymanagement] abstract class UpdateReportExtra {
+private[librarymanagement] abstract class UpdateReportExtra:
   def cachedDescriptor: File
   def configurations: Vector[ConfigurationReport]
   def stats: UpdateStats
@@ -128,34 +118,30 @@ private[librarymanagement] abstract class UpdateReportExtra {
   private[sbt] def moduleKey(m: ModuleID) = (m.organization, m.name, m.revision)
 
   /** All resolved modules in all configurations. */
-  def allModules: Vector[ModuleID] = {
+  def allModules: Vector[ModuleID] =
     configurations.flatMap(_.allModules).groupBy(moduleKey).toVector map { case (_, v) =>
       v reduceLeft { (agg, x) =>
         agg.withConfigurations(
-          (agg.configurations, x.configurations) match {
+          (agg.configurations, x.configurations) match
             case (None, _)            => x.configurations
             case (Some(ac), None)     => Some(ac)
             case (Some(ac), Some(xc)) => Some(s"$ac;$xc")
-          }
         )
       }
     }
-  }
 
-  def allModuleReports: Vector[ModuleReport] = {
+  def allModuleReports: Vector[ModuleReport] =
     configurations.flatMap(_.modules).groupBy(mR => moduleKey(mR.module)).toVector map {
       case (_, v) =>
         v reduceLeft { (agg, x) =>
           agg.withConfigurations(
-            (agg.configurations, x.configurations) match {
+            (agg.configurations, x.configurations) match
               case (v, _) if v.isEmpty  => x.configurations
               case (ac, v) if v.isEmpty => ac
               case (ac, xc)             => ac ++ xc
-            }
           )
         }
     }
-  }
 
   def retrieve(f: (ConfigRef, ModuleID, Artifact, File) => File): UpdateReport =
     UpdateReport(cachedDescriptor, configurations.map { _.retrieve(f) }, stats, stamps)
@@ -165,4 +151,4 @@ private[librarymanagement] abstract class UpdateReportExtra {
 
   /** Gets the names of all resolved configurations.  This `UpdateReport` contains one `ConfigurationReport` for each configuration in this list. */
   def allConfigurations: Vector[ConfigRef] = configurations.map(_.configuration)
-}
+end UpdateReportExtra
diff --git a/lm-core/src/main/scala/sbt/librarymanagement/VersionNumber.scala b/lm-core/src/main/scala/sbt/librarymanagement/VersionNumber.scala
index e4af203db..1d28f8f4f 100644
--- a/lm-core/src/main/scala/sbt/librarymanagement/VersionNumber.scala
+++ b/lm-core/src/main/scala/sbt/librarymanagement/VersionNumber.scala
@@ -4,7 +4,7 @@ final class VersionNumber private[sbt] (
     val numbers: Seq[Long],
     val tags: Seq[String],
     val extras: Seq[String]
-) {
+):
 
   def _1: Option[Long] = get(0)
   def _2: Option[Long] = get(1)
@@ -22,21 +22,19 @@ final class VersionNumber private[sbt] (
 
   override def hashCode: Int = numbers.## * 41 * 41 + tags.## * 41 + extras.##
 
-  override def equals(that: Any): Boolean = that match {
+  override def equals(that: Any): Boolean = that match
     case v: VersionNumber => (numbers == v.numbers) && (tags == v.tags) && (extras == v.extras)
     case _                => false
-  }
 
-  def matchesSemVer(selsem: SemanticSelector): Boolean = {
+  def matchesSemVer(selsem: SemanticSelector): Boolean =
     selsem.matches(this)
-  }
 
   /** A variant of mkString that returns the empty string if the sequence is empty. */
   private def mkString1[A](xs: Seq[A], start: String, sep: String, end: String): String =
-    if (xs.isEmpty) "" else xs.mkString(start, sep, end)
-}
+    if xs.isEmpty then "" else xs.mkString(start, sep, end)
+end VersionNumber
 
-object VersionNumber {
+object VersionNumber:
 
   /**
    * @param numbers numbers delimited by a dot.
@@ -47,19 +45,18 @@ object VersionNumber {
     new VersionNumber(numbers, tags, extras)
 
   def apply(s: String): VersionNumber =
-    unapply(s) match {
+    unapply(s) match
       case Some((ns, ts, es)) => VersionNumber(ns, ts, es)
       case _                  => throw new IllegalArgumentException(s"Invalid version number: $s")
-    }
 
   def unapply(v: VersionNumber): Option[(Seq[Long], Seq[String], Seq[String])] =
     Some((v.numbers, v.tags, v.extras))
 
-  def unapply(s: String): Option[(Seq[Long], Seq[String], Seq[String])] = {
+  def unapply(s: String): Option[(Seq[Long], Seq[String], Seq[String])] =
 
     // null safe, empty string safe
     def splitOn(s: String, sep: Char): Vector[String] =
-      if (s eq null) Vector()
+      if s eq null then Vector()
       else s.split(sep).filterNot(_ == "").toVector
 
     def splitDot(s: String) = splitOn(s, '.') map (_.toLong)
@@ -69,7 +66,7 @@ object VersionNumber {
     val TaggedVersion = """(\d{1,14})([\.\d{1,14}]*)((?:-\w+(?:\.\w+)*)*)((?:\+.+)*)""".r
     val NonSpaceString = """(\S+)""".r
 
-    s match {
+    s match
       case TaggedVersion(m, ns, ts, es) =>
         val numbers = Vector(m.toLong) ++ splitDot(ns)
         val tags = splitDash(ts)
@@ -78,17 +75,15 @@ object VersionNumber {
       case ""                => None
       case NonSpaceString(s) => Some((Vector.empty, Vector.empty, Vector(s)))
       case _                 => None
-    }
-  }
+  end unapply
 
   /** Strict. Checks everything. */
-  object Strict extends VersionNumberCompatibility {
+  object Strict extends VersionNumberCompatibility:
     def name: String = "Strict"
     def isCompatible(v1: VersionNumber, v2: VersionNumber): Boolean = v1 == v2
-  }
 
   /** Semantic Versioning. See http://semver.org/spec/v2.0.0.html */
-  object SemVer extends VersionNumberCompatibility {
+  object SemVer extends VersionNumberCompatibility:
     def name: String = "Semantic Versioning"
 
     /* Quotes of parts of the rules in the SemVer Spec relevant to compatibility checking:
@@ -141,44 +136,41 @@ object VersionNumber {
       doIsCompat(dropBuildMetadata(v1), dropBuildMetadata(v2))
 
     private def doIsCompat(v1: VersionNumber, v2: VersionNumber): Boolean =
-      (v1, v2) match {
+      (v1, v2) match
         case (NormalVersion(0, _, _), NormalVersion(0, _, _))   => v1 == v2 // R4
         case (NormalVersion(_, 0, 0), NormalVersion(_, 0, 0))   => v1 == v2 // R9 maybe?
         case (NormalVersion(x1, _, _), NormalVersion(x2, _, _)) => x1 == x2 // R6, R7 & R8
         case _                                                  => false
-      }
 
     // SemVer Spec Rule 10 (above)
     private[VersionNumber] def dropBuildMetadata(v: VersionNumber) =
-      if (v.extras.isEmpty) v else VersionNumber(v.numbers, v.tags, Nil)
+      if v.extras.isEmpty then v else VersionNumber(v.numbers, v.tags, Nil)
 
     // An extractor for SemVer's "normal version number" - SemVer Spec Rule 2 & Rule 9 (above)
-    private[VersionNumber] object NormalVersion {
+    private[VersionNumber] object NormalVersion:
       def unapply(v: VersionNumber): Option[(Long, Long, Long)] =
         PartialFunction.condOpt(v.numbers) {
           // NOTE! We allow the z to be missing, because of legacy like commons-io 1.3
           case Seq(x, y, _*) => (x, y, v._3 getOrElse 0)
         }
-    }
-  }
+  end SemVer
 
   /**
    * A variant of SemVar that seems to be common among the Scala libraries.
    * The second segment (y in x.y.z) increments breaks the binary compatibility even when x > 0.
    * Also API compatibility is expected even when the first segment is zero.
    */
-  object SecondSegment extends VersionNumberCompatibility {
+  object SecondSegment extends VersionNumberCompatibility:
     def name: String = "Second Segment Variant"
     def isCompatible(v1: VersionNumber, v2: VersionNumber): Boolean =
       PackVer.isCompatible(v1, v2)
-  }
 
   /**
    * A variant of SemVar that seems to be common among the Scala libraries.
    * The second segment (y in x.y.z) increments breaks the binary compatibility even when x > 0.
    * Also API compatibility is expected even when the first segment is zero.
    */
-  object PackVer extends VersionNumberCompatibility {
+  object PackVer extends VersionNumberCompatibility:
     import SemVer.*
 
     def name: String = "Package Versioning Policy"
@@ -186,19 +178,16 @@ object VersionNumber {
     def isCompatible(v1: VersionNumber, v2: VersionNumber): Boolean =
       doIsCompat(dropBuildMetadata(v1), dropBuildMetadata(v2))
 
-    private def doIsCompat(v1: VersionNumber, v2: VersionNumber): Boolean = {
-      (v1, v2) match {
+    private def doIsCompat(v1: VersionNumber, v2: VersionNumber): Boolean =
+      (v1, v2) match
         case (NormalVersion(_, _, 0), NormalVersion(_, _, 0))     => v1 == v2 // R9 maybe?
         case (NormalVersion(x1, y1, _), NormalVersion(x2, y2, _)) => (x1 == x2) && (y1 == y2)
         case _                                                    => false
-      }
-    }
-  }
 
   /**
    * A variant of SemVar that enforces API compatibility when the first segment is zero.
    */
-  object EarlySemVer extends VersionNumberCompatibility {
+  object EarlySemVer extends VersionNumberCompatibility:
     import SemVer.*
 
     def name: String = "Early Semantic Versioning"
@@ -250,17 +239,15 @@ object VersionNumber {
       doIsCompat(dropBuildMetadata(v1), dropBuildMetadata(v2))
 
     private def doIsCompat(v1: VersionNumber, v2: VersionNumber): Boolean =
-      (v1, v2) match {
+      (v1, v2) match
         case (NormalVersion(0, _, 0), NormalVersion(0, _, 0))   => v1 == v2
         case (NormalVersion(0, y1, _), NormalVersion(0, y2, _)) => y1 == y2
         case (NormalVersion(_, 0, 0), NormalVersion(_, 0, 0))   => v1 == v2 // R9 maybe?
         case (NormalVersion(x1, _, _), NormalVersion(x2, _, _)) => x1 == x2 // R6, R7 & R8
         case _                                                  => false
-      }
-  }
-}
+  end EarlySemVer
+end VersionNumber
 
-trait VersionNumberCompatibility {
+trait VersionNumberCompatibility:
   def name: String
   def isCompatible(v1: VersionNumber, v2: VersionNumber): Boolean
-}
diff --git a/lm-core/src/test/scala/ConfigMacroSpec.scala b/lm-core/src/test/scala/ConfigMacroSpec.scala
index 1be735466..a060ed62b 100644
--- a/lm-core/src/test/scala/ConfigMacroSpec.scala
+++ b/lm-core/src/test/scala/ConfigMacroSpec.scala
@@ -6,26 +6,23 @@ import scala.util.control.NonFatal
 import org.scalacheck.*
 import Prop.*
 
-class ConfigDefs {
+class ConfigDefs:
   lazy val Kompile = config("kompile")
   val X = config("x")
   val Z = config("z").hide
   val A: Configuration = config("a")
   lazy val Aa: Configuration = config("aa")
-}
 
-object ConfigMacroSpec extends Properties("ConfigMacroSpec") {
+object ConfigMacroSpec extends Properties("ConfigMacroSpec"):
   lazy val cd = new ConfigDefs
   import cd.*
 
   def secure(f: => Prop): Prop =
-    try {
-      Prop.secure(f)
-    } catch {
+    try Prop.secure(f)
+    catch
       case NonFatal(e) =>
         e.printStackTrace
         throw e
-    }
 
   property("Explicit type on lazy val supported") = secure {
     check(Aa, "Aa", "aa", true)
@@ -47,7 +44,7 @@ object ConfigMacroSpec extends Properties("ConfigMacroSpec") {
     check(Z, "Z", "z", false)
   }
 
-  def check(c: Configuration, id: String, name: String, isPublic: Boolean): Prop = {
+  def check(c: Configuration, id: String, name: String, isPublic: Boolean): Prop =
     s"Expected id: $id" |:
       s"Expected name: $name" |:
       s"Expected isPublic: $isPublic" |:
@@ -57,5 +54,4 @@ object ConfigMacroSpec extends Properties("ConfigMacroSpec") {
       (c.id == id) &&
       (c.name == name) &&
       (c.isPublic == isPublic)
-  }
-}
+end ConfigMacroSpec
diff --git a/lm-core/src/test/scala/example/tests/CrossVersionCompatTest.scala b/lm-core/src/test/scala/example/tests/CrossVersionCompatTest.scala
index ab5f47633..c7981f04e 100644
--- a/lm-core/src/test/scala/example/tests/CrossVersionCompatTest.scala
+++ b/lm-core/src/test/scala/example/tests/CrossVersionCompatTest.scala
@@ -5,12 +5,11 @@ import verify.BasicTestSuite
 import scala.annotation.nowarn
 
 @nowarn
-object CrossVersionCompatTest extends BasicTestSuite {
+object CrossVersionCompatTest extends BasicTestSuite:
   test("CrossVersion.Disabled is typed to be Disabled") {
-    assert(CrossVersion.Disabled match {
+    assert(CrossVersion.Disabled match
       case _: Disabled => true
-      case _           => false
-    })
+      case _           => false)
   }
 
   test("CrossVersion.Disabled functions as disabled") {
@@ -19,10 +18,9 @@ object CrossVersionCompatTest extends BasicTestSuite {
   }
 
   test("CrossVersion.Disabled() is typed to be Disabled") {
-    assert(CrossVersion.Disabled() match {
+    assert(CrossVersion.Disabled() match
       case _: Disabled => true
-      case _           => false
-    })
+      case _           => false)
   }
 
   test("CrossVersion.Disabled() functions as disabled") {
@@ -31,31 +29,27 @@ object CrossVersionCompatTest extends BasicTestSuite {
   }
 
   test("CrossVersion.Disabled is stable") {
-    assert(CrossVersion.Disabled match {
+    assert(CrossVersion.Disabled match
       case CrossVersion.Disabled => true
-      case _                     => false
-    })
+      case _                     => false)
   }
 
   test("sbt.librarymanagement.Disabled is typed to be Disabled") {
-    assert(Disabled match {
+    assert(Disabled match
       case _: Disabled => true
-      case _           => false
-    })
+      case _           => false)
   }
 
   test("sbt.librarymanagement.Disabled is stable") {
-    assert(Disabled match {
+    assert(Disabled match
       case Disabled => true
-      case _        => false
-    })
+      case _        => false)
   }
 
   test("sbt.librarymanagement.Disabled() is typed to be Disabled") {
-    assert(Disabled() match {
+    assert(Disabled() match
       case _: Disabled => true
-      case _           => false
-    })
+      case _           => false)
   }
 
   test("CrossVersion.disabled is sbt.librarymanagement.Disabled") {
@@ -69,4 +63,4 @@ object CrossVersionCompatTest extends BasicTestSuite {
   test("CrossVersion.Disabled() is sbt.librarymanagement.Disabled") {
     assert(CrossVersion.Disabled() == Disabled)
   }
-}
+end CrossVersionCompatTest
diff --git a/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportCacheCodecSpec.scala b/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportCacheCodecSpec.scala
index a40bb578a..5ab9deddb 100644
--- a/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportCacheCodecSpec.scala
+++ b/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportCacheCodecSpec.scala
@@ -98,3 +98,4 @@ object UpdateReportCacheCodecSpec extends verify.BasicTestSuite:
       UpdateStats(0L, 0L, 0L, false),
       Map.empty
     )
+end UpdateReportCacheCodecSpec
diff --git a/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportFormatSpec.scala b/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportFormatSpec.scala
index 01706228a..3927976d7 100644
--- a/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportFormatSpec.scala
+++ b/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportFormatSpec.scala
@@ -343,3 +343,4 @@ object UpdateReportFormatSpec extends verify.BasicTestSuite:
       UpdateStats(100L, 50L, 1024L, false, Some("stamp")),
       Map(descriptor.getAbsolutePath -> 12345L)
     )
+end UpdateReportFormatSpec
diff --git a/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportInternerSpec.scala b/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportInternerSpec.scala
index 6e6043fd3..f27d9fe3b 100644
--- a/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportInternerSpec.scala
+++ b/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportInternerSpec.scala
@@ -130,3 +130,4 @@ object UpdateReportInternerSpec extends verify.BasicTestSuite:
       Thread.sleep(20)
       i += 1
     ref.get == null
+end UpdateReportInternerSpec
diff --git a/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportPersistenceBenchmark.scala b/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportPersistenceBenchmark.scala
index 97e0f1ffc..595f9484a 100644
--- a/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportPersistenceBenchmark.scala
+++ b/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportPersistenceBenchmark.scala
@@ -37,7 +37,7 @@ object UpdateReportPersistenceBenchmark:
       modulesPerConfig: Int = 50,
       warmupIterations: Int = 10
   ): Either[String, BenchmarkResult] =
-    for {
+    for
       _ <- Either.cond(iterations > 0, (), "iterations must be positive")
       _ <- Either.cond(configs.nonEmpty, (), "configs must be non-empty")
       _ <- Either.cond(modulesPerConfig > 0, (), "modulesPerConfig must be positive")
@@ -85,7 +85,7 @@ object UpdateReportPersistenceBenchmark:
           )
         catch case e: Exception => Left(s"Benchmark failed: ${e.getMessage}")
         finally IO.delete(baseDir)
-    } yield result
+    yield result
 
   def buildSampleReport(
       baseDir: File,
@@ -138,6 +138,7 @@ object UpdateReportPersistenceBenchmark:
     val stamps = Map(cachedDescriptor.getAbsolutePath -> System.currentTimeMillis())
 
     UpdateReport(cachedDescriptor, configReports, stats, stamps)
+  end buildSampleReport
 
   def formatResult(result: BenchmarkResult): String =
     f"""UpdateReport Persistence Benchmark Results
diff --git a/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportPersistenceSpec.scala b/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportPersistenceSpec.scala
index b6e2458c1..65d87d87a 100644
--- a/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportPersistenceSpec.scala
+++ b/lm-core/src/test/scala/sbt/internal/librarymanagement/UpdateReportPersistenceSpec.scala
@@ -60,6 +60,7 @@ class UpdateReportPersistenceSpec extends AnyFlatSpec with Matchers:
     val stamps = Map(cachedDescriptor.getAbsolutePath -> 12345L)
 
     UpdateReport(cachedDescriptor, Vector(configReport), stats, stamps)
+  end buildTestReport
 
   "UpdateReportPersistence.toCache and fromCache" should "preserve stats and stamps" in:
     IO.withTemporaryDirectory: baseDir =>
@@ -199,6 +200,7 @@ class UpdateReportPersistenceSpec extends AnyFlatSpec with Matchers:
       Vector.empty,
       Vector.empty
     )
+  end moduleFor
 
   // `managedJars` derives the managed classpath's order from `ConfigurationReport.modules`, and that
   // order is part of the compile task's cache key.
diff --git a/lm-core/src/test/scala/sbt/internal/librarymanagement/WeakInternerSpec.scala b/lm-core/src/test/scala/sbt/internal/librarymanagement/WeakInternerSpec.scala
index 7c307c704..98e96f752 100644
--- a/lm-core/src/test/scala/sbt/internal/librarymanagement/WeakInternerSpec.scala
+++ b/lm-core/src/test/scala/sbt/internal/librarymanagement/WeakInternerSpec.scala
@@ -117,3 +117,4 @@ object WeakInternerSpec extends verify.BasicTestSuite:
       Thread.sleep(20)
       i += 1
     ref.get == null
+end WeakInternerSpec
diff --git a/lm-core/src/test/scala/sbt/librarymanagement/ArtifactTest.scala b/lm-core/src/test/scala/sbt/librarymanagement/ArtifactTest.scala
index 04bc1115f..73d866cd3 100644
--- a/lm-core/src/test/scala/sbt/librarymanagement/ArtifactTest.scala
+++ b/lm-core/src/test/scala/sbt/librarymanagement/ArtifactTest.scala
@@ -2,7 +2,7 @@ package sbt.librarymanagement
 
 import sbt.internal.librarymanagement.UnitSpec
 
-class ArtifactTest extends UnitSpec {
+class ArtifactTest extends UnitSpec:
 
   "Artifact.artifactName" should "include the platform suffix before the Scala suffix" in {
     val m = ModuleID("com.example", "root-178", "0.1.0-SNAPSHOT")
@@ -38,4 +38,4 @@ class ArtifactTest extends UnitSpec {
     Artifact.artifactName(sv, m, a) shouldBe
       s"$expectedMavenArtifactId-0.0.9-SNAPSHOT.pom"
   }
-}
+end ArtifactTest
diff --git a/lm-core/src/test/scala/sbt/librarymanagement/ConfigMacroTest.scala b/lm-core/src/test/scala/sbt/librarymanagement/ConfigMacroTest.scala
index 27103395a..0a13c7d69 100644
--- a/lm-core/src/test/scala/sbt/librarymanagement/ConfigMacroTest.scala
+++ b/lm-core/src/test/scala/sbt/librarymanagement/ConfigMacroTest.scala
@@ -3,11 +3,10 @@ package sbt.librarymanagement
 import org.scalatest.funspec.AnyFunSpec
 import org.scalatest.matchers.should.Matchers
 
-class ConfigMacroTest extends AnyFunSpec with Matchers {
+class ConfigMacroTest extends AnyFunSpec with Matchers:
   describe("Configurations.config") {
     it("should validate the ID in compile time") {
       """val A = Configurations.config("a")""" should compile
       """val b = Configurations.config("b")""" shouldNot compile
     }
   }
-}
diff --git a/lm-core/src/test/scala/sbt/librarymanagement/CrossVersionTest.scala b/lm-core/src/test/scala/sbt/librarymanagement/CrossVersionTest.scala
index 3bb8b59c4..d4b3a65b2 100644
--- a/lm-core/src/test/scala/sbt/librarymanagement/CrossVersionTest.scala
+++ b/lm-core/src/test/scala/sbt/librarymanagement/CrossVersionTest.scala
@@ -5,7 +5,7 @@ import CrossVersion.*
 import sbt.librarymanagement.syntax.*
 import scala.annotation.nowarn
 
-class CrossVersionTest extends UnitSpec {
+class CrossVersionTest extends UnitSpec:
   "sbtApiVersion" should "for xyz return None" in {
     sbtApiVersion("xyz") shouldBe None
   }
@@ -449,4 +449,4 @@ class CrossVersionTest extends UnitSpec {
       Some("sjs1")
     ) shouldBe None
   }
-}
+end CrossVersionTest
diff --git a/lm-core/src/test/scala/sbt/librarymanagement/MemoizedFileFormatsSpec.scala b/lm-core/src/test/scala/sbt/librarymanagement/MemoizedFileFormatsSpec.scala
index cc356acae..7a8dbb493 100644
--- a/lm-core/src/test/scala/sbt/librarymanagement/MemoizedFileFormatsSpec.scala
+++ b/lm-core/src/test/scala/sbt/librarymanagement/MemoizedFileFormatsSpec.scala
@@ -131,3 +131,4 @@ object MemoizedFileFormatsSpec extends BasicTestSuite:
       UpdateStats(0L, 0L, 0L, false),
       Map.empty
     )
+end MemoizedFileFormatsSpec
diff --git a/lm-core/src/test/scala/sbt/librarymanagement/ModuleIdTest.scala b/lm-core/src/test/scala/sbt/librarymanagement/ModuleIdTest.scala
index e5a063791..620608f00 100644
--- a/lm-core/src/test/scala/sbt/librarymanagement/ModuleIdTest.scala
+++ b/lm-core/src/test/scala/sbt/librarymanagement/ModuleIdTest.scala
@@ -2,7 +2,7 @@ package sbt.librarymanagement
 
 import sjsonnew.support.scalajson.unsafe.{ Converter, CompactPrinter, Parser }
 
-object ModuleIdTest extends verify.BasicTestSuite {
+object ModuleIdTest extends verify.BasicTestSuite:
   test("Module Id should return cross-disabled module id as equal to a copy") {
     assert(ModuleID("com.acme", "foo", "1") == ModuleID("com.acme", "foo", "1"))
   }
@@ -46,4 +46,4 @@ object ModuleIdTest extends verify.BasicTestSuite {
 
   def expectedJson =
     """{"organization":"com.acme","name":"foo","revision":"1","isChanging":false,"isTransitive":true,"isForce":false,"explicitArtifacts":[],"inclusions":[],"exclusions":[],"extraAttributes":{},"crossVersion":{"type":"Disabled"}}"""
-}
+end ModuleIdTest
diff --git a/lm-core/src/test/scala/sbt/librarymanagement/ResolverTest.scala b/lm-core/src/test/scala/sbt/librarymanagement/ResolverTest.scala
index 878d7968c..35d0d8021 100644
--- a/lm-core/src/test/scala/sbt/librarymanagement/ResolverTest.scala
+++ b/lm-core/src/test/scala/sbt/librarymanagement/ResolverTest.scala
@@ -4,7 +4,7 @@ import java.net.URI
 
 import sbt.internal.librarymanagement.UnitSpec
 
-class ResolverTest extends UnitSpec {
+class ResolverTest extends UnitSpec:
 
   "Resolver uri" should "propagate pattern descriptorOptional and skipConsistencyCheck." in {
     val pats = Vector("[orgPath]")
@@ -83,4 +83,4 @@ class ResolverTest extends UnitSpec {
     repo.patterns.artifactPatterns shouldBe Vector(artifacts)
     repo.patterns.isMavenCompatible shouldBe false
   }
-}
+end ResolverTest
diff --git a/lm-core/src/test/scala/sbt/librarymanagement/SemanticSelectorSpec.scala b/lm-core/src/test/scala/sbt/librarymanagement/SemanticSelectorSpec.scala
index 64a586430..998e1b34d 100644
--- a/lm-core/src/test/scala/sbt/librarymanagement/SemanticSelectorSpec.scala
+++ b/lm-core/src/test/scala/sbt/librarymanagement/SemanticSelectorSpec.scala
@@ -3,7 +3,7 @@ package sbt.librarymanagement
 import org.scalatest.freespec.AnyFreeSpec
 import org.scalatest.matchers.should.Matchers
 
-class SemanticSelectorSpec extends AnyFreeSpec with Matchers {
+class SemanticSelectorSpec extends AnyFreeSpec with Matchers:
   semsel("<=1.2.3") { sel =>
     assertMatches(sel, "1.2.3")
     assertMatches(sel, "1.2-beta")
@@ -396,4 +396,4 @@ class SemanticSelectorSpec extends AnyFreeSpec with Matchers {
     s"""should parse as an error""" in {
       an[IllegalArgumentException] should be thrownBy SemanticSelector(s.value)
     }
-}
+end SemanticSelectorSpec
diff --git a/lm-core/src/test/scala/sbt/librarymanagement/VersionNumberSpec.scala b/lm-core/src/test/scala/sbt/librarymanagement/VersionNumberSpec.scala
index e98da9ea1..f90ac1e8b 100644
--- a/lm-core/src/test/scala/sbt/librarymanagement/VersionNumberSpec.scala
+++ b/lm-core/src/test/scala/sbt/librarymanagement/VersionNumberSpec.scala
@@ -5,7 +5,7 @@ import org.scalatest.freespec.AnyFreeSpec
 import org.scalatest.matchers.should.Matchers
 
 // This is a specification to check VersionNumber and VersionNumberCompatibility.
-class VersionNumberSpec extends AnyFreeSpec with Matchers with Inside {
+class VersionNumberSpec extends AnyFreeSpec with Matchers with Inside:
   import VersionNumber.{ EarlySemVer, SemVer, PackVer }
 
   version("1") { v =>
@@ -179,12 +179,11 @@ class VersionNumberSpec extends AnyFreeSpec with Matchers with Inside {
         (v._4 shouldBe buildNumber)
     }
 
-  private def assertCascadesTo(v: VersionString, ns: Seq[String]): Unit = {
+  private def assertCascadesTo(v: VersionString, ns: Seq[String]): Unit =
     s"should cascade to $ns" in {
       val versionNumbers = ns.toVector map VersionNumber.apply
       VersionNumber(v.value).cascadingVersions shouldBe versionNumbers
     }
-  }
 
   private def assertIsCompatibleWith(
       v1: VersionString,
@@ -205,16 +204,14 @@ class VersionNumberSpec extends AnyFreeSpec with Matchers with Inside {
       vnc: VersionNumberCompatibility,
       v1: VersionString,
       v2: String
-  ) = {
-    val prefix = if (expectOutcome) "should" else "should NOT"
-    val compatibilityStrategy = vnc match {
+  ) =
+    val prefix = if expectOutcome then "should" else "should NOT"
+    val compatibilityStrategy = vnc match
       case SemVer      => "SemVer"
       case PackVer     => "PackVer"
       case EarlySemVer => "EarlySemVer"
       case _           => val s = vnc.name; if s.contains(" ") then s""""$s"""" else s
-    }
     s"$prefix be $compatibilityStrategy compatible with $v2" in {
       vnc.isCompatible(VersionNumber(v1.value), VersionNumber(v2)) shouldBe expectOutcome
     }
-  }
-}
+end VersionNumberSpec
diff --git a/lm-core/src/test/scala/sbt/librarymanagement/VersionRangeSpec.scala b/lm-core/src/test/scala/sbt/librarymanagement/VersionRangeSpec.scala
index faba93d46..6a863e1bc 100644
--- a/lm-core/src/test/scala/sbt/librarymanagement/VersionRangeSpec.scala
+++ b/lm-core/src/test/scala/sbt/librarymanagement/VersionRangeSpec.scala
@@ -2,7 +2,7 @@ package sbt
 package internal
 package librarymanagement
 
-class VersionRangeSpec extends UnitSpec {
+class VersionRangeSpec extends UnitSpec:
   "Version range" should "strip 1.0 to None" in stripTo("1.0", None)
   it should "strip (,1.0] to 1.0" in stripTo("(,1.0]", Some("1.0"))
   it should "strip (,1.0) to None" in stripTo("(,1.0)", None)
@@ -113,4 +113,4 @@ class VersionRangeSpec extends UnitSpec {
     assert(VersionRange.versionSatisfiesRange("1.3.1", "1.3.1,2.3") == true)
     assert(VersionRange.versionSatisfiesRange("2.4", "1.3.1,2.3") == false)
   }
-}
+end VersionRangeSpec
diff --git a/lm-coursier/definitions/src/main/scala/lmcoursier/credentials/DirectCredentials.scala b/lm-coursier/definitions/src/main/scala/lmcoursier/credentials/DirectCredentials.scala
index c767abf70..98769e628 100644
--- a/lm-coursier/definitions/src/main/scala/lmcoursier/credentials/DirectCredentials.scala
+++ b/lm-coursier/definitions/src/main/scala/lmcoursier/credentials/DirectCredentials.scala
@@ -14,7 +14,6 @@ import dataclass.*
     matchHost: Boolean = false,
     @since("1.3")
     httpsOnly: Boolean = true
-) extends Credentials {
+) extends Credentials:
 
   override def toString(): String = s"DirectCredentials(host=$host, username=$username)"
-}
diff --git a/lm-coursier/definitions/src/main/scala/lmcoursier/definitions/Authentication.scala b/lm-coursier/definitions/src/main/scala/lmcoursier/definitions/Authentication.scala
index 054cb4c08..35b2af374 100644
--- a/lm-coursier/definitions/src/main/scala/lmcoursier/definitions/Authentication.scala
+++ b/lm-coursier/definitions/src/main/scala/lmcoursier/definitions/Authentication.scala
@@ -13,7 +13,6 @@ import dataclass.*
     httpsOnly: Boolean = true,
     @since("1.2")
     passOnRedirect: Boolean = false
-) {
+):
   override def toString(): String =
     s"Authentication(user=$user)"
-}
diff --git a/lm-coursier/src/main/scala/lmcoursier/CoursierDependencyResolution.scala b/lm-coursier/src/main/scala/lmcoursier/CoursierDependencyResolution.scala
index 01e4f781d..170bc8366 100644
--- a/lm-coursier/src/main/scala/lmcoursier/CoursierDependencyResolution.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/CoursierDependencyResolution.scala
@@ -35,7 +35,7 @@ class CoursierDependencyResolution(
     conf: CoursierConfiguration,
     protocolHandlerConfiguration: Option[CoursierConfiguration],
     bootstrappingProtocolHandler: Boolean
-) extends DependencyResolutionInterface {
+) extends DependencyResolutionInterface:
 
   def this(conf: CoursierConfiguration) =
     this(
@@ -51,16 +51,14 @@ class CoursierDependencyResolution(
       configuration: UpdateConfiguration,
       uwconfig: UnresolvedWarningConfiguration,
       log: Logger
-  ): ClassLoader = {
+  ): ClassLoader =
 
     val conf0 = protocolHandlerConfiguration.getOrElse(conf)
 
-    def isUnknownProtocol(rawURL: String): Boolean = {
-      Try(new URI(rawURL).toURL) match {
+    def isUnknownProtocol(rawURL: String): Boolean =
+      Try(new URI(rawURL).toURL) match
         case Failure(ex) if ex.getMessage.startsWith("unknown protocol: ") => true
         case _                                                             => false
-      }
-    }
 
     val confWithoutUnknownProtocol =
       conf0.withResolvers(
@@ -88,7 +86,7 @@ class CoursierDependencyResolution(
     val reportOrUnresolved =
       resolution.update(moduleDescriptor(fakeModule), configuration, uwconfig, log)
 
-    val report = reportOrUnresolved match {
+    val report = reportOrUnresolved match
       case Right(report0) =>
         report0
 
@@ -96,17 +94,16 @@ class CoursierDependencyResolution(
         import sbt.util.ShowLines.*
         unresolvedWarning.lines.foreach(log.warn(_))
         throw unresolvedWarning.resolveException
-    }
 
     val jars =
-      for {
+      for
         reportConfiguration <- report.configurations.filter(_.configuration.name == "runtime")
         module <- reportConfiguration.modules
         (_, jar) <- module.artifacts
-      } yield jar
+      yield jar
 
     new URLClassLoader(jars.map(_.toURI().toURL()).toArray)
-  }
+  end fetchProtocolHandlerClassLoader
 
   /*
    * Based on earlier implementations by @leonardehrenfried (https://github.com/sbt/librarymanagement/pull/190)
@@ -122,29 +119,26 @@ class CoursierDependencyResolution(
       configuration: UpdateConfiguration,
       uwconfig: UnresolvedWarningConfiguration,
       log: Logger
-  ): Either[UnresolvedWarning, UpdateReport] = {
+  ): Either[UnresolvedWarning, UpdateReport] =
 
-    if (bootstrappingProtocolHandler && protocolHandlerClassLoader.isEmpty)
+    if bootstrappingProtocolHandler && protocolHandlerClassLoader.isEmpty then
       protocolHandlerClassLoaderLock.synchronized {
-        if (bootstrappingProtocolHandler && protocolHandlerClassLoader.isEmpty) {
+        if bootstrappingProtocolHandler && protocolHandlerClassLoader.isEmpty then
           val classLoader = fetchProtocolHandlerClassLoader(configuration, uwconfig, log)
           protocolHandlerClassLoader = Some(classLoader)
-        }
       }
 
     val conf = this.conf.withUpdateConfiguration(configuration)
 
     // TODO Take stuff in configuration into account? uwconfig too?
 
-    val module0 = module match {
+    val module0 = module match
       case c: CoursierModuleDescriptor =>
         c.descriptor
       case other =>
-        other.moduleSettings match {
+        other.moduleSettings match
           case d: ModuleDescriptorConfiguration => d
           case s                                => sys.error(s"unrecognized module settings: $s")
-        }
-    }
 
     val soOpt = module0.scalaModuleInfo
       .map(_.scalaOrganization)
@@ -169,16 +163,13 @@ class CoursierDependencyResolution(
       optionalCrossVer = true,
       projectPlatform = projectPlatform
     )
-    val interProjectDependencies = {
+    val interProjectDependencies =
       val needed = conf.interProjectDependencies.exists { p =>
         p.module == mod && p.version == ver
       }
 
-      if (needed)
-        conf.interProjectDependencies.map(ToCoursier.project)
-      else
-        Vector.empty[coursier.core.Project]
-    }
+      if needed then conf.interProjectDependencies.map(ToCoursier.project)
+      else Vector.empty[coursier.core.Project]
 
     val extraProjects = conf.extraProjects.map(ToCoursier.project)
 
@@ -194,10 +185,8 @@ class CoursierDependencyResolution(
     val ivyProperties = ResolutionParams.defaultIvyProperties(conf.ivyHome)
 
     val classifiers =
-      if (conf.hasClassifiers)
-        Some(conf.classifiers.map(Classifier(_)))
-      else
-        None
+      if conf.hasClassifiers then Some(conf.classifiers.map(Classifier(_)))
+      else None
 
     val authenticationByRepositoryId = conf.authenticationByRepositoryId.toMap
 
@@ -238,7 +227,7 @@ class CoursierDependencyResolution(
       }
       .map { (config, dep) =>
         val depForResolve =
-          if (boms.nonEmpty && (dep.version == "*" || dep.version.isEmpty))
+          if boms.nonEmpty && (dep.version == "*" || dep.version.isEmpty) then
             lmcoursier.definitions.Dependency(
               dep.module,
               "",
@@ -248,8 +237,7 @@ class CoursierDependencyResolution(
               dep.optional,
               dep.transitive
             )
-          else
-            dep
+          else dep
         (ToCoursier.configuration(config), ToCoursier.dependency(depForResolve))
       }
 
@@ -279,7 +267,7 @@ class CoursierDependencyResolution(
       dependencies = dependencies,
       fallbackDependencies = conf.fallbackDependencies,
       orderedConfigs = orderedConfigs,
-      autoScalaLibOpt = if (autoScalaLib) Some((so, sv)) else None,
+      autoScalaLibOpt = if autoScalaLib then Some((so, sv)) else None,
       mainRepositories = mainRepositories,
       parentProjectCache = Map.empty,
       interProjectDependencies = interProjectDependencies,
@@ -357,7 +345,7 @@ class CoursierDependencyResolution(
         classLoaders = protocolHandlerClassLoader.toSeq,
       )
 
-    val e = for {
+    val e = for
       (resolutions, lockDataOpt) <- ResolutionRun.resolutionsWithLockFileData(
         resolutionParams,
         verbosityLevel,
@@ -365,22 +353,19 @@ class CoursierDependencyResolution(
         conf.lockFile,
         conf.scalaVersion
       )
-      artifactResult0 <- lockDataOpt match {
+      artifactResult0 <- lockDataOpt match
         case Some(lockData) =>
-          LockedArtifactsRun.fetchFromLockFile(lockData, cache0, verbosityLevel, log) match {
+          LockedArtifactsRun.fetchFromLockFile(lockData, cache0, verbosityLevel, log) match
             case Right(arts) => Right(arts)
             case Left(err)   =>
-              if (verbosityLevel >= 1) {
+              if verbosityLevel >= 1 then
                 log.warn(s"Failed to fetch from lock file: $err, falling back to normal fetch")
-              }
               ArtifactsRun(artifactsParams(resolutions), verbosityLevel, log)
                 .map(_.fullDetailedArtifacts0)
-          }
         case None =>
           ArtifactsRun(artifactsParams(resolutions), verbosityLevel, log)
             .map(_.fullDetailedArtifacts0)
-      }
-    } yield {
+    yield
       val artifactResult = artifactResult0.map {
         case (d, p: Publication, a, o) =>
           (d, (Right(p): Either[VariantPublication, Publication]), a, o)
@@ -388,7 +373,7 @@ class CoursierDependencyResolution(
       }
       val updateParams0 = updateParams(resolutions, artifactResult)
       val report = UpdateRun.update(updateParams0, verbosityLevel, log)
-      if (lockDataOpt.isEmpty) {
+      if lockDataOpt.isEmpty then
         conf.lockFile.foreach: lockFile =>
           val artifactMap = artifactResult
             .groupBy(_._1)
@@ -411,11 +396,10 @@ class CoursierDependencyResolution(
           ) match
             case Right(lockData) => LockFile.write(lockFile, lockData)
             case Left(err)       => throw err
-      }
+      end if
       report
-    }
     e.left.map(unresolvedWarningOrThrow(module0.module, uwconfig, _))
-  }
+  end update
 
   private def toModuleId(module: coursier.core.Module, version: String): ModuleID =
     ModuleID(module.organization.value, module.name.value, version)
@@ -439,9 +423,7 @@ class CoursierDependencyResolution(
       resolution.dependenciesOf0(dependency, false, false) match
         case Right(deps) => sortDependencies(deps)
         case Left(_)     => Vector.empty
-    catch {
-      case NonFatal(_) => Vector.empty
-    }
+    catch case NonFatal(_) => Vector.empty
 
   private def pathScore(path: Vector[Dependency]): (Int, String) =
     path.size -> path
@@ -454,26 +436,24 @@ class CoursierDependencyResolution(
       candidate: Vector[Dependency],
       currentBest: Option[Vector[Dependency]]
   ): Option[Vector[Dependency]] =
-    currentBest match {
+    currentBest match
       case Some(best) =>
         val (bestLength, bestPathStr) = pathScore(best)
         val (candidateLength, candidatePathStr) = pathScore(candidate)
-        if (
-          bestLength > candidateLength || (bestLength == candidateLength && bestPathStr >= candidatePathStr)
-        ) currentBest
+        if bestLength > candidateLength || (bestLength == candidateLength && bestPathStr >= candidatePathStr)
+        then currentBest
         else Some(candidate)
       case _ => Some(candidate)
-    }
 
   private def longestPathToTarget(
       resolution: Resolution,
       current: Dependency,
       target: DependencyKey,
       seen: Set[DependencyKey]
-  ): Option[Vector[Dependency]] = {
+  ): Option[Vector[Dependency]] =
     val currentKey = dependencyKey(current)
-    if (currentKey == target) Some(Vector(current))
-    else {
+    if currentKey == target then Some(Vector(current))
+    else
       safeDependenciesOf(resolution, current).iterator
         .filterNot(dep => seen(dependencyKey(dep)))
         .foldLeft(Option.empty[Vector[Dependency]]) { (best, dep) =>
@@ -481,36 +461,31 @@ class CoursierDependencyResolution(
           val candidate = longestPathToTarget(resolution, dep, target, seen + key).map { tail =>
             current +: tail
           }
-          candidate match {
+          candidate match
             case Some(path) => betterPath(path, best)
             case None       => best
-          }
         }
-    }
-  }
 
   private def resolvePath(
       resolution: Resolution,
       failedDependency: Dependency,
       rootModule: ModuleID
-  ): Seq[ModuleID] = {
+  ): Seq[ModuleID] =
     val normalizedRootModule = rootModule.withConfigurations(None)
     val roots = sortDependencies(resolution.rootDependencies)
     val target = dependencyKey(failedDependency)
     val resolvedPath = roots
       .foldLeft(Option.empty[Vector[Dependency]]) { (best, root) =>
         val candidate = longestPathToTarget(resolution, root, target, Set(dependencyKey(root)))
-        candidate match {
+        candidate match
           case Some(path) => betterPath(path, best)
           case None       => best
-        }
       }
       .getOrElse(Vector(failedDependency))
 
     normalizedRootModule +: resolvedPath.map(dep =>
       toModuleId(dep.module, dep.versionConstraint.asString)
     )
-  }
 
   private def failedPaths(
       rootModule: ModuleID,
@@ -527,19 +502,18 @@ class CoursierDependencyResolution(
       rootModule: ModuleID,
       uwconfig: UnresolvedWarningConfiguration,
       ex: coursier.error.CoursierError
-  ): UnresolvedWarning = {
+  ): UnresolvedWarning =
 
     // TODO Take coursier.error.FetchError.DownloadingArtifacts into account
 
-    val downloadErrors = ex match {
+    val downloadErrors = ex match
       case ex0: coursier.error.ResolutionError =>
         ex0.errors.collect { case err: coursier.error.ResolutionError.CantDownloadModule =>
           err
         }
       case _ =>
         Nil
-    }
-    val otherErrors = ex match {
+    val otherErrors = ex match
       case ex0: coursier.error.ResolutionError =>
         ex0.errors.flatMap {
           case _: coursier.error.ResolutionError.CantDownloadModule => None
@@ -547,13 +521,11 @@ class CoursierDependencyResolution(
         }
       case _ =>
         Seq(ex)
-    }
 
-    if (otherErrors.isEmpty) {
-      val resolution = ex match {
+    if otherErrors.isEmpty then
+      val resolution = ex match
         case ex0: coursier.error.ResolutionError => ex0.resolution
         case _                                   => Resolution()
-      }
       val resolvedPaths = failedPaths(rootModule, resolution, downloadErrors)
       val r = new ResolveException(
         downloadErrors.map(_.getMessage),
@@ -568,12 +540,11 @@ class CoursierDependencyResolution(
         resolvedPaths
       )
       UnresolvedWarning(r, uwconfig)
-    } else
-      throw ex
-  }
-}
+    else throw ex
+  end unresolvedWarningOrThrow
+end CoursierDependencyResolution
 
-object CoursierDependencyResolution {
+object CoursierDependencyResolution:
   def apply(configuration: CoursierConfiguration): DependencyResolution =
     DependencyResolution(new CoursierDependencyResolution(configuration))
 
@@ -594,4 +565,4 @@ object CoursierDependencyResolution {
 
   private[lmcoursier] def cacheFileToOriginalUrl(fileUrl: String, cacheDir: File): String =
     lmcoursier.internal.CacheUrlConversion.cacheFileToOriginalUrl(fileUrl, cacheDir)
-}
+end CoursierDependencyResolution
diff --git a/lm-coursier/src/main/scala/lmcoursier/FromSbt.scala b/lm-coursier/src/main/scala/lmcoursier/FromSbt.scala
index 0516dcd32..59706963e 100644
--- a/lm-coursier/src/main/scala/lmcoursier/FromSbt.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/FromSbt.scala
@@ -17,7 +17,7 @@ import lmcoursier.definitions.{
 import sbt.internal.librarymanagement.mavenint.SbtPomExtraProperties
 import sbt.librarymanagement.{ Configuration as _, * }
 
-object FromSbt {
+object FromSbt:
 
   private def sbtCrossName(
       name: String,
@@ -27,7 +27,7 @@ object FromSbt {
       scalaBinaryVersion: => String,
       optionalCrossVer: Boolean = false,
       projectPlatform: Option[String],
-  ): String = {
+  ): String =
     val name0 = name
     val name1 =
       crossVersion match
@@ -35,16 +35,12 @@ object FromSbt {
         case _           => addPlatformSuffix(name0, platformOpt, projectPlatform)
     val updatedName = CrossVersion(crossVersion, scalaVersion, scalaBinaryVersion)
       .fold(name1)(_(name1))
-    if (!optionalCrossVer || updatedName.length <= name0.length)
-      updatedName
-    else {
+    if !optionalCrossVer || updatedName.length <= name0.length then updatedName
+    else
       val suffix = updatedName.substring(name0.length)
-      if (name0.endsWith(suffix))
-        name0
-      else
-        updatedName
-    }
-  }
+      if name0.endsWith(suffix) then name0
+      else updatedName
+  end sbtCrossName
 
   // Duplicate of sbt.librarymanagement.CrossVersion.addPlatformSuffix. Keep the two in sync
   // until lm-coursier moves under sbt
@@ -52,20 +48,17 @@ object FromSbt {
       name: String,
       platformOpt: Option[String],
       projectPlatform: Option[String]
-  ): String = {
+  ): String =
     def addSuffix(platformName: String): String =
-      platformName match {
+      platformName match
         case "" | "jvm" => name
         case _          => s"${name}_$platformName"
-      }
-    (platformOpt, projectPlatform) match {
+    (platformOpt, projectPlatform) match
       case (Some(p), _) =>
         addSuffix(p) // Use explicit platform if set (don't override with project platform)
       case (None, Some(p)) =>
         addSuffix(p) // Only use project platform if dependency has no explicit platform
       case _ => name
-    }
-  }
 
   private def attributes(attr: Map[String, String]): Map[String, String] =
     attr
@@ -82,7 +75,7 @@ object FromSbt {
       scalaBinaryVersion: String,
       optionalCrossVer: Boolean,
       projectPlatform: Option[String],
-  ): (Module, String) = {
+  ): (Module, String) =
 
     val fullName =
       sbtCrossName(
@@ -103,7 +96,7 @@ object FromSbt {
     val version = module.revision
 
     (module0, version)
-  }
+  end moduleVersion
 
   def moduleVersion(
       module: ModuleID,
@@ -124,7 +117,7 @@ object FromSbt {
       scalaBinaryVersion: String,
       optionalCrossVer: Boolean = false,
       projectPlatform: Option[String] = None,
-  ): Seq[(Configuration, Dependency)] = {
+  ): Seq[(Configuration, Dependency)] =
 
     // TODO Warn about unsupported properties in `module`
 
@@ -159,7 +152,7 @@ object FromSbt {
     }
 
     val publications =
-      if (module.explicitArtifacts.isEmpty)
+      if module.explicitArtifacts.isEmpty then
         Seq(Publication("", Type(""), Extension(""), Classifier("")))
       else
         module.explicitArtifacts
@@ -172,30 +165,28 @@ object FromSbt {
             )
           }
 
-    for {
+    for
       (from, to) <- allMappings.distinct
       pub <- publications.distinct
-    } yield {
+    yield
       val dep0 = dep
         .withConfiguration(to)
         .withPublication(pub)
       from -> dep0
-    }
-  }
+  end dependencies
 
   def fallbackDependencies(
       allDependencies: Seq[ModuleID],
       scalaVersion: String,
       scalaBinaryVersion: String
   ): Seq[FallbackDependency] =
-    for {
+    for
       module <- allDependencies
       artifact <- module.explicitArtifacts
       uri <- artifact.url.toSeq
-    } yield {
+    yield
       val (module0, version) = moduleVersion(module, scalaVersion, scalaBinaryVersion)
       FallbackDependency(module0, version, uri, module.isChanging)
-    }
 
   def project(
       projectID: ModuleID,
@@ -204,7 +195,7 @@ object FromSbt {
       scalaVersion: String,
       scalaBinaryVersion: String,
       projectPlatform: Option[String],
-  ): Project = {
+  ): Project =
 
     val deps = allDependencies.flatMap(
       dependencies(_, scalaVersion, scalaBinaryVersion, projectPlatform = projectPlatform)
@@ -240,5 +231,5 @@ object FromSbt {
       Nil,
       Info("", "", Nil, Nil, None)
     )
-  }
-}
+  end project
+end FromSbt
diff --git a/lm-coursier/src/main/scala/lmcoursier/Inputs.scala b/lm-coursier/src/main/scala/lmcoursier/Inputs.scala
index f4ae809f9..d7c76e1bc 100644
--- a/lm-coursier/src/main/scala/lmcoursier/Inputs.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/Inputs.scala
@@ -8,7 +8,7 @@ import sbt.util.Logger
 import scala.annotation.tailrec
 import scala.collection.mutable
 
-object Inputs {
+object Inputs:
 
   def ivyXmlMappings(mapping: String): Seq[(Configuration, Configuration)] =
     initialIvyXmlMappings(mapping).map { (from, to) =>
@@ -28,32 +28,27 @@ object Inputs {
 
   def coursierConfigurationsMap(
       configurations: Seq[sbt.librarymanagement.Configuration]
-  ): Map[Configuration, Set[Configuration]] = {
+  ): Map[Configuration, Set[Configuration]] =
 
     val configs0 = configExtendsSeq(configurations).toMap
 
-    def allExtends(c: Configuration) = {
+    def allExtends(c: Configuration) =
       // possibly bad complexity
       @tailrec
-      def helper(current: Set[Configuration]): Set[Configuration] = {
+      def helper(current: Set[Configuration]): Set[Configuration] =
         val newSet = current ++ current.flatMap(configs0.getOrElse(_, Nil))
-        if ((newSet -- current).nonEmpty)
-          helper(newSet)
-        else
-          newSet
-      }
+        if (newSet -- current).nonEmpty then helper(newSet)
+        else newSet
 
       helper(Set(c))
-    }
 
     configs0.map { case (config, _) =>
       config -> allExtends(config)
     }
-  }
 
   def orderedConfigurations(
       configurations: Seq[(Configuration, Seq[Configuration])]
-  ): Seq[(Configuration, Seq[Configuration])] = {
+  ): Seq[(Configuration, Seq[Configuration])] =
 
     val map = configurations.toMap
 
@@ -61,31 +56,25 @@ object Inputs {
         done: Set[Configuration],
         toAdd: List[Configuration]
     ): LazyList[(Configuration, Seq[Configuration])] =
-      toAdd match {
+      toAdd match
         case Nil            => LazyList.empty
         case config :: rest =>
           val extends0 = map.getOrElse(config, Nil)
           val missingExtends = extends0.filterNot(done)
-          if (missingExtends.isEmpty)
-            (config, extends0) #:: helper(done + config, rest)
-          else
-            helper(done, missingExtends.toList ::: toAdd)
-      }
+          if missingExtends.isEmpty then (config, extends0) #:: helper(done + config, rest)
+          else helper(done, missingExtends.toList ::: toAdd)
 
     helper(Set.empty, configurations.map(_._1).toList).toVector
-  }
 
   @deprecated("Now unused internally, to be removed in the future", "2.0.0-RC6-5")
-  def ivyGraphs(configurations: Map[Configuration, Seq[Configuration]]): Seq[Set[Configuration]] = {
+  def ivyGraphs(configurations: Map[Configuration, Seq[Configuration]]): Seq[Set[Configuration]] =
 
     // probably bad complexity, but that shouldn't matter given the size of the graphs involved...
 
-    final class Wrapper(val set: mutable.HashSet[Configuration]) {
-      def ++=(other: Wrapper): this.type = {
+    final class Wrapper(val set: mutable.HashSet[Configuration]):
+      def ++=(other: Wrapper): this.type =
         set ++= other.set
         this
-      }
-    }
 
     val sets =
       new mutable.HashMap[Configuration, Wrapper] ++= configurations.map { (k, l) =>
@@ -95,53 +84,48 @@ object Inputs {
         k -> new Wrapper(s)
       }
 
-    for (k <- configurations.keys) {
+    for k <- configurations.keys do
       val s = sets(k)
 
       var foundNew = true
-      while (foundNew) {
+      while foundNew do
         foundNew = false
-        for (other <- s.set.toVector) {
+        for other <- s.set.toVector do
           val otherS = sets(other)
-          if (!otherS.eq(s)) {
+          if !otherS.eq(s) then
             s ++= otherS
             sets += other -> s
             foundNew = true
-          }
-        }
-      }
-    }
 
     sets.values.toVector.distinct.map(_.set.toSet)
-  }
+  end ivyGraphs
 
   def exclusionsSeq(
       excludeDeps: Seq[InclExclRule],
       sv: String,
       sbv: String,
       log: Logger
-  ): Seq[(Organization, ModuleName)] = {
+  ): Seq[(Organization, ModuleName)] =
 
     var anyNonSupportedExclusionRule = false
 
     val res = excludeDeps
       .flatMap { rule =>
-        if (rule.artifact != "*" || rule.configurations.nonEmpty) {
+        if rule.artifact != "*" || rule.configurations.nonEmpty then
           log.warn(s"Unsupported exclusion rule $rule")
           anyNonSupportedExclusionRule = true
           Nil
-        } else {
+        else
           val name = CrossVersion(rule.crossVersion, sv, sbv)
             .fold(rule.name)(_(rule.name))
           Seq((Organization(rule.organization), ModuleName(name)))
-        }
       }
 
-    if (anyNonSupportedExclusionRule)
+    if anyNonSupportedExclusionRule then
       log.warn("Only supported exclusion rule fields: organization, name")
 
     res
-  }
+  end exclusionsSeq
 
   def exclusions(
       excludeDeps: Seq[InclExclRule],
@@ -153,5 +137,4 @@ object Inputs {
 
   def forceVersions(depOverrides: Seq[ModuleID], sv: String, sbv: String): Seq[(Module, String)] =
     depOverrides.map(FromSbt.moduleVersion(_, sv, sbv))
-
-}
+end Inputs
diff --git a/lm-coursier/src/main/scala/lmcoursier/IvyXml.scala b/lm-coursier/src/main/scala/lmcoursier/IvyXml.scala
index 02ba01912..ad7a7754b 100644
--- a/lm-coursier/src/main/scala/lmcoursier/IvyXml.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/IvyXml.scala
@@ -4,7 +4,7 @@ import lmcoursier.definitions.Project
 
 import scala.xml.{ Node, PrefixedAttribute }
 
-object IvyXml {
+object IvyXml:
 
   @deprecated("Use the override accepting 3 arguments", "2.0.0-RC6-6")
   def apply(
@@ -17,7 +17,7 @@ object IvyXml {
       currentProject: Project,
       exclusions: Seq[(String, String)],
       overrides: Seq[(String, String, String)]
-  ): String = {
+  ): String =
 
     // Important: width = Int.MaxValue, so that no tag gets truncated.
     // In particular, that prevents things like <foo /> to be split to
@@ -29,14 +29,13 @@ object IvyXml {
 
     """<?xml version="1.0" encoding="UTF-8"?>""" + '\n' +
       printer.format(content(currentProject, exclusions, overrides))
-  }
 
   // These are required for publish to be fine, later on.
   private def content(
       project: Project,
       exclusions: Seq[(String, String)],
       overrides: Seq[(String, String, String)]
-  ): Node = {
+  ): Node =
 
     val props = project.module.attributes.toSeq ++ project.properties
     val infoAttrs = props.foldLeft[xml.MetaData](xml.Null) { case (acc, (k, v)) =>
@@ -63,12 +62,10 @@ object IvyXml {
     } % infoAttrs
 
     val confElems = project.configurations.toVector.collect { (name, extends0) =>
-      val visibility = if (project.privateConfigs.contains(name)) "private" else "public"
+      val visibility = if project.privateConfigs.contains(name) then "private" else "public"
       val n = <conf name={name.value} visibility={visibility} description="" />
-      if (extends0.nonEmpty)
-        n % <x extends={extends0.map(_.value).mkString(",")} />.attributes
-      else
-        n
+      if extends0.nonEmpty then n % <x extends={extends0.map(_.value).mkString(",")} />.attributes
+      else n
     }
 
     val publications = project.publications
@@ -79,10 +76,8 @@ object IvyXml {
         configs.map(_.value).mkString(",")
       } />
 
-      if (pub.classifier.value.nonEmpty)
-        n % <x e:classifier={pub.classifier.value} />.attributes
-      else
-        n
+      if pub.classifier.value.nonEmpty then n % <x e:classifier={pub.classifier.value} />.attributes
+      else n
     }
 
     val dependencyElems = project.dependencies.toVector.map { (conf, dep) =>
@@ -120,6 +115,5 @@ object IvyXml {
       <publications>{publicationElems}</publications>
       <dependencies>{dependencyElems}{excludeElems}{overrideElems}</dependencies>
     </ivy-module>
-  }
-
-}
+  end content
+end IvyXml
diff --git a/lm-coursier/src/main/scala/lmcoursier/definitions/CacheLogger.scala b/lm-coursier/src/main/scala/lmcoursier/definitions/CacheLogger.scala
index e64c9ae07..1b954b6ab 100644
--- a/lm-coursier/src/main/scala/lmcoursier/definitions/CacheLogger.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/definitions/CacheLogger.scala
@@ -1,6 +1,6 @@
 package lmcoursier.definitions
 
-abstract class CacheLogger {
+abstract class CacheLogger:
   def foundLocally(url: String): Unit = {}
 
   def downloadingArtifact(url: String): Unit = {}
@@ -30,9 +30,8 @@ abstract class CacheLogger {
   // sizeHint: estimated # of artifacts to be downloaded (doesn't include side stuff like checksums)
   def init(sizeHint: Option[Int] = None): Unit = {}
   def stop(): Unit = {}
-}
+end CacheLogger
 
-object CacheLogger {
+object CacheLogger:
   def nop: CacheLogger =
     new CacheLogger {}
-}
diff --git a/lm-coursier/src/main/scala/lmcoursier/definitions/CachePolicy.scala b/lm-coursier/src/main/scala/lmcoursier/definitions/CachePolicy.scala
index 482c323a8..fdf00c2cf 100644
--- a/lm-coursier/src/main/scala/lmcoursier/definitions/CachePolicy.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/definitions/CachePolicy.scala
@@ -2,7 +2,7 @@ package lmcoursier.definitions
 
 sealed abstract class CachePolicy extends Serializable
 
-object CachePolicy {
+object CachePolicy:
   /* NOTE: the following comments are copied from coursier.cache.CachePolicy for the benefit of users within an IDE
   that reads the javadocs. Please keep in sync from the original ADT.
    */
@@ -69,4 +69,4 @@ object CachePolicy {
    * Erases files already in cache.
    */
   case object ForceDownload extends CachePolicy
-}
+end CachePolicy
diff --git a/lm-coursier/src/main/scala/lmcoursier/definitions/FromCoursier.scala b/lm-coursier/src/main/scala/lmcoursier/definitions/FromCoursier.scala
index fb92ac7d2..be999c41e 100644
--- a/lm-coursier/src/main/scala/lmcoursier/definitions/FromCoursier.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/definitions/FromCoursier.scala
@@ -2,10 +2,10 @@ package lmcoursier.definitions
 
 // TODO Make private[lmcoursier]
 // private[coursier]
-object FromCoursier {
+object FromCoursier:
 
   def cachePolicy(r: coursier.cache.CachePolicy): CachePolicy =
-    (r: @unchecked) match {
+    (r: @unchecked) match
       case coursier.cache.CachePolicy.LocalOnly           => CachePolicy.LocalOnly
       case coursier.cache.CachePolicy.LocalOnlyIfValid    => CachePolicy.LocalOnlyIfValid
       case coursier.cache.CachePolicy.LocalUpdateChanging => CachePolicy.LocalUpdateChanging
@@ -14,5 +14,3 @@ object FromCoursier {
       case coursier.cache.CachePolicy.Update              => CachePolicy.Update
       case coursier.cache.CachePolicy.FetchMissing        => CachePolicy.FetchMissing
       case coursier.cache.CachePolicy.ForceDownload       => CachePolicy.ForceDownload
-    }
-}
diff --git a/lm-coursier/src/main/scala/lmcoursier/definitions/Reconciliation.scala b/lm-coursier/src/main/scala/lmcoursier/definitions/Reconciliation.scala
index 31ff20a43..089428296 100644
--- a/lm-coursier/src/main/scala/lmcoursier/definitions/Reconciliation.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/definitions/Reconciliation.scala
@@ -2,18 +2,16 @@ package lmcoursier.definitions
 
 sealed abstract class Reconciliation extends Serializable
 
-object Reconciliation {
+object Reconciliation:
   case object Default extends Reconciliation
   case object Relaxed extends Reconciliation
   case object Strict extends Reconciliation
   case object SemVer extends Reconciliation
 
   def apply(input: String): Option[Reconciliation] =
-    input match {
+    input match
       case "default" => Some(Default)
       case "relaxed" => Some(Relaxed)
       case "strict"  => Some(Strict)
       case "semver"  => Some(SemVer)
       case _         => None
-    }
-}
diff --git a/lm-coursier/src/main/scala/lmcoursier/definitions/ToCoursier.scala b/lm-coursier/src/main/scala/lmcoursier/definitions/ToCoursier.scala
index 92b02eaa6..80e0f6de1 100644
--- a/lm-coursier/src/main/scala/lmcoursier/definitions/ToCoursier.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/definitions/ToCoursier.scala
@@ -8,7 +8,7 @@ import scala.annotation.nowarn
 
 // TODO Make private[lmcoursier]
 // private[coursier]
-object ToCoursier {
+object ToCoursier:
 
   def configuration(configuration: Configuration): coursier.core.Configuration =
     coursier.core.Configuration(configuration.value)
@@ -63,12 +63,11 @@ object ToCoursier {
 
   @nowarn
   def reconciliation(r: Reconciliation): coursier.core.Reconciliation =
-    r match {
+    r match
       case Reconciliation.Default => coursier.core.Reconciliation.Default
       case Reconciliation.Relaxed => coursier.core.Reconciliation.Relaxed
       case Reconciliation.Strict  => coursier.core.Reconciliation.Strict
       case Reconciliation.SemVer  => coursier.core.Reconciliation.SemVer
-    }
 
   @nowarn
   def reconciliation(
@@ -162,7 +161,7 @@ object ToCoursier {
     )
 
   def credentials(credentials: Credentials): coursier.credentials.Credentials =
-    credentials match {
+    credentials match
       case d: DirectCredentials =>
         coursier.credentials
           .DirectCredentials()
@@ -177,10 +176,9 @@ object ToCoursier {
         coursier.credentials
           .FileCredentials(f.path)
           .withOptional(f.optional)
-    }
 
   def cacheLogger(logger: CacheLogger): coursier.cache.CacheLogger =
-    new coursier.cache.CacheLogger {
+    new coursier.cache.CacheLogger:
       override def foundLocally(url: String): Unit =
         logger.foundLocally(url)
       override def downloadingArtifact(url: String): Unit =
@@ -214,7 +212,6 @@ object ToCoursier {
         logger.init(sizeHint)
       override def stop(): Unit =
         logger.stop()
-    }
 
   def strict(strict: Strict): coursier.params.rule.Strict =
     coursier.params.rule
@@ -234,7 +231,7 @@ object ToCoursier {
       .withSemVer(strict.semVer)
 
   def cachePolicy(r: CachePolicy): coursier.cache.CachePolicy =
-    r match {
+    r match
       case CachePolicy.LocalOnly           => coursier.cache.CachePolicy.LocalOnly
       case CachePolicy.LocalOnlyIfValid    => coursier.cache.CachePolicy.LocalOnlyIfValid
       case CachePolicy.LocalUpdateChanging => coursier.cache.CachePolicy.LocalUpdateChanging
@@ -243,5 +240,4 @@ object ToCoursier {
       case CachePolicy.Update              => coursier.cache.CachePolicy.Update
       case CachePolicy.FetchMissing        => coursier.cache.CachePolicy.FetchMissing
       case CachePolicy.ForceDownload       => coursier.cache.CachePolicy.ForceDownload
-    }
-}
+end ToCoursier
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/ArtifactsRun.scala b/lm-coursier/src/main/scala/lmcoursier/internal/ArtifactsRun.scala
index 9dd4e0db4..302b2c8a6 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/ArtifactsRun.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/ArtifactsRun.scala
@@ -7,34 +7,32 @@ import coursier.core.Type
 import sbt.util.Logger
 
 // private[lmcoursier]
-object ArtifactsRun {
+object ArtifactsRun:
 
   def apply(
       params: ArtifactsParams,
       verbosityLevel: Int,
       log: Logger
-  ): Either[coursier.error.FetchError, Artifacts.Result] = {
+  ): Either[coursier.error.FetchError, Artifacts.Result] =
 
     val printOptionalMessage = verbosityLevel >= 0 && verbosityLevel <= 1
 
     val artifactInitialMessage =
-      if (verbosityLevel >= 0)
+      if verbosityLevel >= 0 then
         s"Fetching artifacts of ${params.projectName}" +
-          (if (params.sbtClassifiers) " (sbt classifiers)" else "")
-      else
-        ""
+          (if params.sbtClassifiers then " (sbt classifiers)" else "")
+      else ""
 
     val coursierLogger = params.loggerOpt.getOrElse {
       RefreshLogger.create(
-        if (RefreshLogger.defaultFallbackMode)
-          new FallbackRefreshDisplay()
+        if RefreshLogger.defaultFallbackMode then new FallbackRefreshDisplay()
         else
           ProgressBarRefreshDisplay.create(
-            if (printOptionalMessage) log.info(artifactInitialMessage),
-            if (printOptionalMessage || verbosityLevel >= 2)
+            if printOptionalMessage then log.info(artifactInitialMessage),
+            if printOptionalMessage || verbosityLevel >= 2 then
               log.info(
                 s"Fetched artifacts of ${params.projectName}" +
-                  (if (params.sbtClassifiers) " (sbt classifiers)" else "")
+                  (if params.sbtClassifiers then " (sbt classifiers)" else "")
               )
           )
       )
@@ -48,7 +46,7 @@ object ArtifactsRun {
     ) {
       result(params, coursierLogger)
     }
-  }
+  end apply
 
   private def result(
       params: ArtifactsParams,
@@ -61,20 +59,16 @@ object ArtifactsRun {
       .withClassifiers(params.classifiers.getOrElse(Nil).toSet)
       .withClasspathOrder(params.classpathOrder)
       .addExtraArtifacts { l =>
-        if (params.includeSignatures)
-          l.flatMap(_._3.extra.get("sig").toSeq)
-        else
-          Nil
+        if params.includeSignatures then l.flatMap(_._3.extra.get("sig").toSeq)
+        else Nil
       }
       .addTransformArtifacts { artifacts =>
-        if (params.missingOk)
+        if params.missingOk then
           artifacts.map { (dependency, publication, artifact) =>
             (dependency, publication, artifact.withOptional(true))
           }
-        else
-          artifacts
+        else artifacts
       }
       .withCache(params.cache.withLogger(coursierLogger))
       .eitherResult()
-
-}
+end ArtifactsRun
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/BuildClock.scala b/lm-coursier/src/main/scala/lmcoursier/internal/BuildClock.scala
index 119c7a8ab..eab2cadac 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/BuildClock.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/BuildClock.scala
@@ -4,14 +4,14 @@ import coursier.core.{ Configuration, Dependency, Repository }
 import java.security.MessageDigest
 import scala.collection.immutable.Seq
 
-object BuildClock {
+object BuildClock:
 
   def compute(
       dependencies: Seq[(Configuration, Dependency)],
       repositories: Seq[Repository],
       scalaVersion: Option[String],
       params: ResolutionParams
-  ): String = {
+  ): String =
     val digest = MessageDigest.getInstance("SHA-1")
 
     dependencies
@@ -50,7 +50,7 @@ object BuildClock {
 
     val hashBytes = digest.digest()
     hashBytes.map("%02x".format(_)).mkString
-  }
+  end compute
 
   def matches(
       lockFileData: LockFileData,
@@ -58,8 +58,7 @@ object BuildClock {
       repositories: Seq[Repository],
       scalaVersion: Option[String],
       params: ResolutionParams
-  ): Boolean = {
+  ): Boolean =
     val currentClock = compute(dependencies, repositories, scalaVersion, params)
     lockFileData.buildClock == currentClock
-  }
-}
+end BuildClock
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/CacheUrlConversion.scala b/lm-coursier/src/main/scala/lmcoursier/internal/CacheUrlConversion.scala
index 24f490f3f..84defd057 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/CacheUrlConversion.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/CacheUrlConversion.scala
@@ -10,7 +10,7 @@ package lmcoursier.internal
 
 import java.io.File
 
-object CacheUrlConversion {
+object CacheUrlConversion:
 
   final val FileUrlPrefix = "file:"
   final val UnconvertiblePrefix = "${CSR_CACHE}"
@@ -18,38 +18,32 @@ object CacheUrlConversion {
   private def normalizePathForComparison(path: String): String =
     path.replace('\\', '/')
 
-  private def normalizedFilePath(fileUrl: String): String = {
+  private def normalizedFilePath(fileUrl: String): String =
     val afterPrefix = fileUrl.stripPrefix(FileUrlPrefix).replaceFirst("^/+", "/")
     val withForwardSlash = normalizePathForComparison(afterPrefix)
-    if (
-      withForwardSlash.length >= 3 && withForwardSlash
+    if withForwardSlash.length >= 3 && withForwardSlash
         .charAt(0) == '/' && withForwardSlash.charAt(2) == ':'
-    )
-      withForwardSlash.substring(1)
-    else
-      withForwardSlash
-  }
+    then withForwardSlash.substring(1)
+    else withForwardSlash
 
-  def cacheFileToOriginalUrl(fileUrl: String, cacheDir: File): String = {
-    if (!fileUrl.startsWith(FileUrlPrefix)) {
-      fileUrl
-    } else {
+  def cacheFileToOriginalUrl(fileUrl: String, cacheDir: File): String =
+    if !fileUrl.startsWith(FileUrlPrefix) then fileUrl
+    else
       val filePath = normalizedFilePath(fileUrl)
       val cachePaths = Seq(
         cacheDir.getAbsolutePath,
         cacheDir.getCanonicalPath
       ).distinct.map(p =>
-        normalizePathForComparison(if (p.endsWith("/") || p.endsWith("\\")) p else p + "/")
+        normalizePathForComparison(if p.endsWith("/") || p.endsWith("\\") then p else p + "/")
       )
 
-      def extractHttpUrl(relativePath: String): Option[String] = {
+      def extractHttpUrl(relativePath: String): Option[String] =
         val protocolSepIndex = relativePath.indexOf('/')
-        if (protocolSepIndex > 0) {
+        if protocolSepIndex > 0 then
           val protocol = relativePath.substring(0, protocolSepIndex)
           val rest = relativePath.substring(protocolSepIndex + 1)
           Some(s"$protocol://$rest")
-        } else None
-      }
+        else None
 
       cachePaths
         .collectFirst {
@@ -59,9 +53,7 @@ object CacheUrlConversion {
         }
         .flatten
         .getOrElse(s"$UnconvertiblePrefix$filePath")
-    }
-  }
 
   def isPortableUrl(url: String): Boolean =
     !url.startsWith(FileUrlPrefix) && !url.contains(UnconvertiblePrefix)
-}
+end CacheUrlConversion
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/CoursierModuleDescriptor.scala b/lm-coursier/src/main/scala/lmcoursier/internal/CoursierModuleDescriptor.scala
index bd74d63d7..b5dad8c01 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/CoursierModuleDescriptor.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/CoursierModuleDescriptor.scala
@@ -6,7 +6,7 @@ import sbt.librarymanagement.*
 private[lmcoursier] final case class CoursierModuleDescriptor(
     descriptor: ModuleDescriptorConfiguration,
     conf: CoursierConfiguration
-) extends ModuleDescriptor {
+) extends ModuleDescriptor:
 
   def directDependencies: Vector[ModuleID] =
     descriptor.dependencies
@@ -21,4 +21,3 @@ private[lmcoursier] final case class CoursierModuleDescriptor(
     // Exclude log/logger fields — they contain Logger instances with
     // non-deterministic hashCodes that would break update caching.
     conf.withLog(None).withLogger(None).##
-}
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/InterProjectRepository.scala b/lm-coursier/src/main/scala/lmcoursier/internal/InterProjectRepository.scala
index 17348540c..064a9864b 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/InterProjectRepository.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/InterProjectRepository.scala
@@ -4,7 +4,7 @@ import coursier.core.*
 import coursier.util.{ EitherT, Monad }
 
 // private[coursier]
-final case class InterProjectRepository(projects: Seq[Project]) extends Repository {
+final case class InterProjectRepository(projects: Seq[Project]) extends Repository:
 
   private val map = projects
     .map(proj =>
@@ -20,7 +20,7 @@ final case class InterProjectRepository(projects: Seq[Project]) extends Reposito
       fetch: Repository.Fetch[F]
   )(using
       F: Monad[F]
-  ): EitherT[F, String, (ArtifactSource, Project)] = {
+  ): EitherT[F, String, (ArtifactSource, Project)] =
 
     val res = map
       .get((module, version))
@@ -28,7 +28,6 @@ final case class InterProjectRepository(projects: Seq[Project]) extends Reposito
       .toRight("Not found")
 
     EitherT(F.point(res))
-  }
 
   override def artifacts(
       dependency: Dependency,
@@ -36,4 +35,4 @@ final case class InterProjectRepository(projects: Seq[Project]) extends Reposito
       overrideClassifiers: Option[Seq[Classifier]]
   ) =
     Nil
-}
+end InterProjectRepository
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/Lock.scala b/lm-coursier/src/main/scala/lmcoursier/internal/Lock.scala
index 6e3f789a2..56486a2ff 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/Lock.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/Lock.scala
@@ -1,6 +1,6 @@
 package lmcoursier.internal
 
-private[lmcoursier] object Lock {
+private[lmcoursier] object Lock:
   private val lock = new Object
 
   /* The lock guards coursier's interactive progress bar (ProgressBarRefreshDisplay), the only thing
@@ -13,6 +13,5 @@ private[lmcoursier] object Lock {
 
   /* Progress bars require us to only work on one module at the time. Without those we can go faster */
   def maybeSynchronized[T](needsLock: Boolean)(f: => T): T =
-    if (needsLock) lock.synchronized(f)
+    if needsLock then lock.synchronized(f)
     else f
-}
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/LockFile.scala b/lm-coursier/src/main/scala/lmcoursier/internal/LockFile.scala
index 920c824af..969312149 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/LockFile.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/LockFile.scala
@@ -5,41 +5,35 @@ import java.nio.file.Files
 import sjsonnew.support.scalajson.unsafe.{ Converter, Parser, PrettyPrinter }
 import scala.util.{ Try, Success, Failure }
 
-object LockFile {
+object LockFile:
   import LockFileFormats.given
 
   val defaultLockFileName = "deps.lock"
 
-  def read(lockFile: File): Either[String, LockFileData] = {
-    if (!lockFile.exists()) {
-      Left(s"Lock file does not exist: ${lockFile.getAbsolutePath}")
-    } else {
+  def read(lockFile: File): Either[String, LockFileData] =
+    if !lockFile.exists() then Left(s"Lock file does not exist: ${lockFile.getAbsolutePath}")
+    else
       Try {
         val content = Files.readString(lockFile.toPath)
         val json = Parser.parseFromString(content).get
         Converter.fromJson[LockFileData](json).get
-      } match {
+      } match
         case Success(data) => Right(data)
         case Failure(ex)   => Left(s"Failed to parse lock file: ${ex.getMessage}")
-      }
-    }
-  }
 
-  def write(lockFile: File, data: LockFileData): Either[String, Unit] = {
+  def write(lockFile: File, data: LockFileData): Either[String, Unit] =
     Try {
       val json = Converter.toJson(data).get
       val content = PrettyPrinter(json)
       lockFile.getParentFile.mkdirs()
       Files.writeString(lockFile.toPath, content)
-    } match {
+    } match
       case Success(_)  => Right(())
       case Failure(ex) => Left(s"Failed to write lock file: ${ex.getMessage}")
-    }
-  }
 
   def getLockFile(baseDirectory: File): File =
     new File(baseDirectory, defaultLockFileName)
 
   def exists(baseDirectory: File): Boolean =
     getLockFile(baseDirectory).exists()
-}
+end LockFile
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/LockFileConstants.scala b/lm-coursier/src/main/scala/lmcoursier/internal/LockFileConstants.scala
index e29012ff4..71dc2069b 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/LockFileConstants.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/LockFileConstants.scala
@@ -1,5 +1,4 @@
 package lmcoursier.internal
 
-object LockFileConstants {
+object LockFileConstants:
   val currentVersion = "1.0"
-}
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/LockFileFormats.scala b/lm-coursier/src/main/scala/lmcoursier/internal/LockFileFormats.scala
index 424726e75..ac0e54cb8 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/LockFileFormats.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/LockFileFormats.scala
@@ -2,10 +2,11 @@ package lmcoursier.internal
 
 import sjsonnew.*
 
-trait ArtifactLockFormats { self: sjsonnew.BasicJsonProtocol =>
-  given ArtifactLockFormat: JsonFormat[ArtifactLock] = new JsonFormat[ArtifactLock] {
+trait ArtifactLockFormats:
+  self: sjsonnew.BasicJsonProtocol =>
+  given ArtifactLockFormat: JsonFormat[ArtifactLock] = new JsonFormat[ArtifactLock]:
     override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): ArtifactLock =
-      jsOpt match {
+      jsOpt match
         case Some(js) =>
           unbuilder.beginObject(js)
           val url = unbuilder.readField[String]("url")
@@ -16,23 +17,21 @@ trait ArtifactLockFormats { self: sjsonnew.BasicJsonProtocol =>
           ArtifactLock(url, classifier, extension, tpe)
         case None =>
           deserializationError("Expected JsObject but found None")
-      }
 
-    override def write[J](obj: ArtifactLock, builder: Builder[J]): Unit = {
+    override def write[J](obj: ArtifactLock, builder: Builder[J]): Unit =
       builder.beginObject()
       builder.addField("url", obj.url)
       builder.addField("classifier", obj.classifier)
       builder.addField("extension", obj.extension)
       builder.addField("tpe", obj.tpe)
       builder.endObject()
-    }
-  }
-}
+end ArtifactLockFormats
 
-trait DependencyLockFormats { self: sjsonnew.BasicJsonProtocol & ArtifactLockFormats =>
-  given DependencyLockFormat: JsonFormat[DependencyLock] = new JsonFormat[DependencyLock] {
+trait DependencyLockFormats:
+  self: sjsonnew.BasicJsonProtocol & ArtifactLockFormats =>
+  given DependencyLockFormat: JsonFormat[DependencyLock] = new JsonFormat[DependencyLock]:
     override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): DependencyLock =
-      jsOpt match {
+      jsOpt match
         case Some(js) =>
           unbuilder.beginObject(js)
           val organization = unbuilder.readField[String]("organization")
@@ -56,9 +55,8 @@ trait DependencyLockFormats { self: sjsonnew.BasicJsonProtocol & ArtifactLockFor
           )
         case None =>
           deserializationError("Expected JsObject but found None")
-      }
 
-    override def write[J](obj: DependencyLock, builder: Builder[J]): Unit = {
+    override def write[J](obj: DependencyLock, builder: Builder[J]): Unit =
       builder.beginObject()
       builder.addField("organization", obj.organization)
       builder.addField("name", obj.name)
@@ -69,15 +67,13 @@ trait DependencyLockFormats { self: sjsonnew.BasicJsonProtocol & ArtifactLockFor
       builder.addField("transitives", obj.transitives)
       builder.addField("artifacts", obj.artifacts)
       builder.endObject()
-    }
-  }
-}
+end DependencyLockFormats
 
-trait ConfigurationLockFormats {
+trait ConfigurationLockFormats:
   self: sjsonnew.BasicJsonProtocol & ArtifactLockFormats & DependencyLockFormats =>
-  given ConfigurationLockFormat: JsonFormat[ConfigurationLock] = new JsonFormat[ConfigurationLock] {
+  given ConfigurationLockFormat: JsonFormat[ConfigurationLock] = new JsonFormat[ConfigurationLock]:
     override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): ConfigurationLock =
-      jsOpt match {
+      jsOpt match
         case Some(js) =>
           unbuilder.beginObject(js)
           val name = unbuilder.readField[String]("name")
@@ -86,21 +82,18 @@ trait ConfigurationLockFormats {
           ConfigurationLock(name, dependencies)
         case None =>
           deserializationError("Expected JsObject but found None")
-      }
 
-    override def write[J](obj: ConfigurationLock, builder: Builder[J]): Unit = {
+    override def write[J](obj: ConfigurationLock, builder: Builder[J]): Unit =
       builder.beginObject()
       builder.addField("name", obj.name)
       builder.addField("dependencies", obj.dependencies)
       builder.endObject()
-    }
-  }
-}
 
-trait LockFileMetadataFormats { self: sjsonnew.BasicJsonProtocol =>
-  given LockFileMetadataFormat: JsonFormat[LockFileMetadata] = new JsonFormat[LockFileMetadata] {
+trait LockFileMetadataFormats:
+  self: sjsonnew.BasicJsonProtocol =>
+  given LockFileMetadataFormat: JsonFormat[LockFileMetadata] = new JsonFormat[LockFileMetadata]:
     override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): LockFileMetadata =
-      jsOpt match {
+      jsOpt match
         case Some(js) =>
           unbuilder.beginObject(js)
           val sbtVersion = unbuilder.readField[String]("sbtVersion")
@@ -109,23 +102,19 @@ trait LockFileMetadataFormats { self: sjsonnew.BasicJsonProtocol =>
           LockFileMetadata(sbtVersion, scalaVersion)
         case None =>
           deserializationError("Expected JsObject but found None")
-      }
 
-    override def write[J](obj: LockFileMetadata, builder: Builder[J]): Unit = {
+    override def write[J](obj: LockFileMetadata, builder: Builder[J]): Unit =
       builder.beginObject()
       builder.addField("sbtVersion", obj.sbtVersion)
       builder.addField("scalaVersion", obj.scalaVersion)
       builder.endObject()
-    }
-  }
-}
 
-trait LockFileDataFormats {
+trait LockFileDataFormats:
   self: sjsonnew.BasicJsonProtocol & ArtifactLockFormats & DependencyLockFormats &
     ConfigurationLockFormats & LockFileMetadataFormats =>
-  given LockFileDataFormat: JsonFormat[LockFileData] = new JsonFormat[LockFileData] {
+  given LockFileDataFormat: JsonFormat[LockFileData] = new JsonFormat[LockFileData]:
     override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): LockFileData =
-      jsOpt match {
+      jsOpt match
         case Some(js) =>
           unbuilder.beginObject(js)
           val version = unbuilder.readField[String]("version")
@@ -136,18 +125,15 @@ trait LockFileDataFormats {
           LockFileData(version, buildClock, configurations, metadata)
         case None =>
           deserializationError("Expected JsObject but found None")
-      }
 
-    override def write[J](obj: LockFileData, builder: Builder[J]): Unit = {
+    override def write[J](obj: LockFileData, builder: Builder[J]): Unit =
       builder.beginObject()
       builder.addField("version", obj.version)
       builder.addField("buildClock", obj.buildClock)
       builder.addField("configurations", obj.configurations)
       builder.addField("metadata", obj.metadata)
       builder.endObject()
-    }
-  }
-}
+end LockFileDataFormats
 
 object LockFileFormats
     extends sjsonnew.BasicJsonProtocol
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/LockedArtifactsRun.scala b/lm-coursier/src/main/scala/lmcoursier/internal/LockedArtifactsRun.scala
index 0ee16818a..9674e4e8d 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/LockedArtifactsRun.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/LockedArtifactsRun.scala
@@ -10,25 +10,23 @@ import java.io.File
 import scala.concurrent.{ Await, ExecutionContext }
 import scala.concurrent.duration.Duration
 
-object LockedArtifactsRun {
+object LockedArtifactsRun:
 
   def fetchFromLockFile(
       lockFileData: LockFileData,
       cache: FileCache[coursier.util.Task],
       verbosityLevel: Int,
       log: Logger
-  ): Either[String, Seq[(Dependency, Publication, Artifact, Option[File])]] = {
+  ): Either[String, Seq[(Dependency, Publication, Artifact, Option[File])]] =
     given ExecutionContext = cache.ec
 
-    if (verbosityLevel >= 1) {
-      log.info("Fetching artifacts from lock file")
-    }
+    if verbosityLevel >= 1 then log.info("Fetching artifacts from lock file")
 
-    val artifactsToFetch = for {
+    val artifactsToFetch = for
       configLock <- lockFileData.configurations
       depLock <- configLock.dependencies
       artLock <- depLock.artifacts
-    } yield {
+    yield
       val module = coursier.Module(
         coursier.Organization(depLock.organization),
         coursier.ModuleName(depLock.name),
@@ -61,36 +59,30 @@ object LockedArtifactsRun {
       )
 
       (dependency, publication, artifact)
-    }
 
     val fetchTasks = artifactsToFetch.map { case (dep, pub, art) =>
       cache.file(art).run.map { result =>
-        result match {
+        result match
           case Left(err) =>
-            if (verbosityLevel >= 2) {
-              log.debug(s"Failed to fetch ${art.url}: ${err.describe}")
-            }
+            if verbosityLevel >= 2 then log.debug(s"Failed to fetch ${art.url}: ${err.describe}")
             (dep, pub, art, None: Option[File])
           case Right(file) =>
             (dep, pub, art, Some(file))
-        }
       }
     }
 
-    try {
+    try
       val results = fetchTasks.map { task =>
         Await.result(task.future(), Duration.Inf)
       }
 
       val failures = results.filter(_._4.isEmpty)
-      if (failures.nonEmpty && verbosityLevel >= 1) {
+      if failures.nonEmpty && verbosityLevel >= 1 then
         log.warn(s"Failed to fetch ${failures.size} artifacts from lock file")
-      }
 
       Right(results)
-    } catch {
+    catch
       case ex: Exception =>
         Left(s"Failed to fetch artifacts: ${ex.getMessage}")
-    }
-  }
-}
+  end fetchFromLockFile
+end LockedArtifactsRun
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionParams.scala b/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionParams.scala
index 784d58e31..fc1f490a1 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionParams.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionParams.scala
@@ -33,23 +33,20 @@ final case class ResolutionParams(
     missingOk: Boolean,
     retry: (FiniteDuration, Int),
     boms: Seq[BomDependency] = Nil
-) {
+):
 
-  lazy val allConfigExtends: Map[Configuration, Set[Configuration]] = {
+  lazy val allConfigExtends: Map[Configuration, Set[Configuration]] =
     val map = new mutable.HashMap[Configuration, Set[Configuration]]
-    for ((config, extends0) <- orderedConfigs) {
+    for (config, extends0) <- orderedConfigs do
       val allExtends = extends0.iterator
         // the else of the getOrElse shouldn't be hit (because of the ordering of the configurations)
         .foldLeft(Set(config))((acc, ext) => acc ++ map.getOrElse(ext, Set(ext)))
       map += config -> allExtends
-    }
     map.toMap
-  }
 
   val fallbackDependenciesRepositories =
-    if (fallbackDependencies.isEmpty)
-      Nil
-    else {
+    if fallbackDependencies.isEmpty then Nil
+    else
       val map = fallbackDependencies.map { dep =>
         (ToCoursier.module(dep.module), dep.version) -> ((dep.uri, dep.changing))
       }.toMap
@@ -57,9 +54,8 @@ final case class ResolutionParams(
       Seq(
         TemporaryInMemoryRepository(map, cache)
       )
-    }
 
-  lazy val resolutionKey = {
+  lazy val resolutionKey =
     val cleanCache = cache
       .withPool(null)
       .withLogger(null)
@@ -78,9 +74,8 @@ final case class ResolutionParams(
       cleanCache,
       missingOk
     )
-  }
 
-  override lazy val hashCode = this match {
+  override lazy val hashCode = this match
     case ResolutionParams(
           a1,
           a2,
@@ -102,16 +97,14 @@ final case class ResolutionParams(
           a18
         ) =>
       (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18).##
-  }
 
   // ResolutionParams.unapply(this).get.##
-
-}
+end ResolutionParams
 
 // private[coursier]
-object ResolutionParams {
+object ResolutionParams:
 
-  def defaultIvyProperties(ivyHomeOpt: Option[File]): Map[String, String] = {
+  def defaultIvyProperties(ivyHomeOpt: Option[File]): Map[String, String] =
 
     val ivyHome = sys.props
       .get("ivy.home")
@@ -127,7 +120,5 @@ object ResolutionParams {
       "ivy.home" -> ivyHome,
       "sbt.ivy.home" -> sbtIvyHome
     ) ++ sys.props
-  }
 
   val defaultRetry: (FiniteDuration, Int) = (1.seconds, 3)
-}
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionRun.scala b/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionRun.scala
index 49a5c81d7..203e1a9d4 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionRun.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionRun.scala
@@ -17,7 +17,7 @@ import scala.concurrent.duration.FiniteDuration
 import scala.collection.mutable
 
 // private[coursier]
-object ResolutionRun {
+object ResolutionRun:
 
   private def resolution(
       params: ResolutionParams,
@@ -25,7 +25,7 @@ object ResolutionRun {
       log: Logger,
       configs: Set[Configuration],
       startingResolutionOpt: Option[Resolution]
-  ): Either[coursier.error.ResolutionError, Resolution] = {
+  ): Either[coursier.error.ResolutionError, Resolution] =
 
     val isScalaToolConfig = configs(Configuration("scala-tool"))
     // Ref coursier/coursier#1340 coursier/coursier#1442
@@ -36,7 +36,7 @@ object ResolutionRun {
     def isSandboxConfig: Boolean = isScalaToolConfig
 
     val repositories =
-      params.internalRepositories.drop(if (isSandboxConfig) 1 else 0) ++
+      params.internalRepositories.drop(if isSandboxConfig then 1 else 0) ++
         params.mainRepositories ++
         params.fallbackDependenciesRepositories
 
@@ -56,20 +56,17 @@ object ResolutionRun {
 
     val initialMessage =
       Seq(
-        if (verbosityLevel >= 0)
+        if verbosityLevel >= 0 then
           Seq(
-            s"Updating ${params.projectName}" + (if (params.sbtClassifiers) " (sbt classifiers)"
+            s"Updating ${params.projectName}" + (if params.sbtClassifiers then " (sbt classifiers)"
                                                  else "")
           )
-        else
-          Nil,
-        if (verbosityLevel >= 2)
-          depsRepr(params.dependencies).map(depRepr => s"  $depRepr")
-        else
-          Nil
+        else Nil,
+        if verbosityLevel >= 2 then depsRepr(params.dependencies).map(depRepr => s"  $depRepr")
+        else Nil
       ).flatten.mkString("\n")
 
-    if (verbosityLevel >= 2) {
+    if verbosityLevel >= 2 then
       val repoReprs = repositories.map {
         case r: IvyRepository =>
           s"ivy:${r.pattern}"
@@ -86,13 +83,11 @@ object ResolutionRun {
         "Repositories:\n" +
           repoReprs.map("  " + _).mkString("\n")
       )
-    }
 
-    if (verbosityLevel >= 2)
-      log.info(initialMessage)
+    if verbosityLevel >= 2 then log.info(initialMessage)
 
     @nowarn
-    val resolveTask: Resolve[Task] = {
+    val resolveTask: Resolve[Task] =
       Resolve()
         // re-using various caches from a resolution of a configuration we extend
         .withInitialResolution(startingResolutionOpt)
@@ -107,7 +102,7 @@ object ResolutionRun {
         .withResolutionParams(
           params.params
             .addForceVersion(
-              (if (isSandboxConfig) Nil
+              (if isSandboxConfig then Nil
                else params.interProjectDependencies.map(_.moduleVersion))*
             )
             .withForceScalaVersion(params.autoScalaLibOpt.nonEmpty)
@@ -120,22 +115,20 @@ object ResolutionRun {
             .withLogger(
               params.loggerOpt.getOrElse {
                 RefreshLogger.create(
-                  if (RefreshLogger.defaultFallbackMode)
-                    new FallbackRefreshDisplay()
+                  if RefreshLogger.defaultFallbackMode then new FallbackRefreshDisplay()
                   else
                     ProgressBarRefreshDisplay.create(
-                      if (printOptionalMessage) log.info(initialMessage),
-                      if (printOptionalMessage || verbosityLevel >= 2)
+                      if printOptionalMessage then log.info(initialMessage),
+                      if printOptionalMessage || verbosityLevel >= 2 then
                         log.info(s"Resolved ${params.projectName} dependencies")
                     )
                 )
               }
             )
         )
-    }
 
     val (period, maxAttempts) = params.retry
-    val finalResult: Either[ResolutionError, Resolution] = {
+    val finalResult: Either[ResolutionError, Resolution] =
 
       def retry(
           attempt: Int,
@@ -144,18 +137,16 @@ object ResolutionRun {
         resolveTask.io.attempt
           .flatMap {
             case Left(e: ResolutionError) =>
-              if (isTransientResolutionError(e))
-                if (attempt + 1 >= maxAttempts) {
+              if isTransientResolutionError(e) then
+                if attempt + 1 >= maxAttempts then
                   log.error(s"Failed, maximum iterations ($maxAttempts) reached")
                   Task.point(Left(e))
-                } else {
+                else
                   log.warn(s"Attempt ${attempt + 1} failed: $e")
                   Task.completeAfter(retryScheduler, waitOnError).flatMap { _ =>
                     retry(attempt + 1, waitOnError * 2)
                   }
-                }
-              else
-                Task.point(Left(e))
+              else Task.point(Left(e))
             case Left(ex) =>
               Task.fail(ex)
             case Right(value) =>
@@ -163,28 +154,25 @@ object ResolutionRun {
           }
 
       retry(0, period).unsafeRun()(using resolveTask.cache.ec)
-    }
+    end finalResult
 
-    finalResult match {
+    finalResult match
       case Left(err) if params.missingOk => Right(err.resolution)
       case others                        => others
-    }
-  }
+  end resolution
 
   @nowarn
   def resolutions(
       params: ResolutionParams,
       verbosityLevel: Int,
       log: Logger
-  ): Either[coursier.error.ResolutionError, Map[Configuration, Resolution]] = {
+  ): Either[coursier.error.ResolutionError, Map[Configuration, Resolution]] =
 
     // TODO Warn about possible duplicated modules from source repositories?
 
-    if (verbosityLevel >= 2) {
+    if verbosityLevel >= 2 then
       log.info("InterProjectRepository")
-      for (p <- params.interProjectDependencies)
-        log.info(s"  ${p.module}:${p.version}")
-    }
+      for p <- params.interProjectDependencies do log.info(s"  ${p.module}:${p.version}")
 
     SbtCoursierCache.default.resolutionOpt(params.resolutionKey).map(Right(_)).getOrElse {
       val resOrError =
@@ -198,27 +186,24 @@ object ResolutionRun {
           val either = params.orderedConfigs.foldLeft[Either[coursier.error.ResolutionError, Unit]](
             Right(())
           ) { case (acc, (config, extends0)) =>
-            for {
+            for
               _ <- acc
-              initRes = {
+              initRes =
                 val it = extends0.iterator.flatMap(map.get(_).iterator)
-                if (it.hasNext) Some(it.next())
+                if it.hasNext then Some(it.next())
                 else None
-              }
               allExtends = params.allConfigExtends.getOrElse(config, Set.empty)
               res <- resolution(params, verbosityLevel, log, allExtends, initRes)
-            } yield {
+            yield
               map += config -> res
               ()
-            }
           }
           either.map(_ => map.toMap)
         }
-      for (res <- resOrError)
-        SbtCoursierCache.default.putResolution(params.resolutionKey, res)
+      for res <- resOrError do SbtCoursierCache.default.putResolution(params.resolutionKey, res)
       resOrError
     }
-  }
+  end resolutions
 
   def resolutionsWithLockFile(
       params: ResolutionParams,
@@ -226,10 +211,9 @@ object ResolutionRun {
       log: Logger,
       lockFileOpt: Option[java.io.File],
       scalaVersion: Option[String]
-  ): Either[coursier.error.ResolutionError, (Map[Configuration, Resolution], Boolean)] = {
+  ): Either[coursier.error.ResolutionError, (Map[Configuration, Resolution], Boolean)] =
     resolutionsWithLockFileData(params, verbosityLevel, log, lockFileOpt, scalaVersion)
       .map { case (res, lockDataOpt) => (res, lockDataOpt.isDefined) }
-  }
 
   def resolutionsWithLockFileData(
       params: ResolutionParams,
@@ -240,42 +224,32 @@ object ResolutionRun {
   ): Either[
     coursier.error.ResolutionError,
     (Map[Configuration, Resolution], Option[LockFileData])
-  ] = {
+  ] =
     lockFileOpt
       .flatMap { lockFile =>
-        LockFile.read(lockFile) match {
+        LockFile.read(lockFile) match
           case Right(lockData) =>
-            if (
-              BuildClock.matches(
+            if BuildClock.matches(
                 lockData,
                 params.dependencies,
                 params.mainRepositories,
                 scalaVersion,
                 params
               )
-            ) {
-              if (verbosityLevel >= 1) {
-                log.info(s"Using lock file: ${lockFile.getAbsolutePath}")
-              }
+            then
+              if verbosityLevel >= 1 then log.info(s"Using lock file: ${lockFile.getAbsolutePath}")
               val reconstructed = ResolutionSerializer.reconstructResolutions(lockData, params)
               Some(Right((reconstructed, Some(lockData))))
-            } else {
-              if (verbosityLevel >= 1) {
-                log.info(s"Lock file outdated, performing resolution")
-              }
+            else
+              if verbosityLevel >= 1 then log.info(s"Lock file outdated, performing resolution")
               None
-            }
           case Left(err) =>
-            if (verbosityLevel >= 2) {
-              log.debug(s"Lock file error: $err")
-            }
+            if verbosityLevel >= 2 then log.debug(s"Lock file error: $err")
             None
-        }
       }
       .getOrElse {
         resolutions(params, verbosityLevel, log).map(res => (res, None))
       }
-  }
 
   private lazy val retryScheduler = ThreadUtil.fixedScheduledThreadPool(1)
 
@@ -290,4 +264,4 @@ object ResolutionRun {
 
   private def isServerError(err: CantDownloadModule): Boolean =
     err.perRepositoryErrors.exists(_.contains("Server returned HTTP response code: 5"))
-}
+end ResolutionRun
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionSerializer.scala b/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionSerializer.scala
index c48efdc93..48702528a 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionSerializer.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/ResolutionSerializer.scala
@@ -7,7 +7,7 @@ import coursier.version.VersionConstraint
 import scala.annotation.nowarn
 import scala.collection.immutable.Seq
 
-object ResolutionSerializer {
+object ResolutionSerializer:
 
   def extractLockFileData(
       resolutions: Map[Configuration, Resolution],
@@ -42,6 +42,7 @@ object ResolutionSerializer {
         configurations = configurations,
         metadata = metadata
       )
+  end extractLockFileData
 
   private def extractDependencies(
       resolution: Resolution,
@@ -69,7 +70,7 @@ object ResolutionSerializer {
               artifactMap.getOrElse(dep, Seq.empty).map { case (url, classifier, ext) =>
                 ArtifactLock(
                   url = url,
-                  classifier = if (classifier.isEmpty) None else Some(classifier),
+                  classifier = if classifier.isEmpty then None else Some(classifier),
                   extension = ext,
                   tpe = dep.attributes.`type`.value
                 )
@@ -80,15 +81,16 @@ object ResolutionSerializer {
               name = dep.module.name.value,
               version = resolvedVersion,
               configuration = dep.variantSelector.repr,
-              classifier = dep.attributes.classifier.value match {
+              classifier = dep.attributes.classifier.value match
                 case "" => None
                 case c  => Some(c)
-              },
+              ,
               tpe = dep.attributes.`type`.value,
               transitives = transitives.toVector,
               artifacts = artifacts.toVector
             )
     traverseEither(xs)
+  end extractDependencies
 
   private def traverseEither[A1, A2](xs: Vector[Either[A1, A2]]): Either[A1, Vector[A2]] =
     xs.foldLeft(Right(Vector.empty): Either[A1, Vector[A2]]) {
@@ -100,18 +102,17 @@ object ResolutionSerializer {
   def reconstructResolutions(
       lockFileData: LockFileData,
       params: ResolutionParams
-  ): Map[Configuration, Resolution] = {
+  ): Map[Configuration, Resolution] =
     lockFileData.configurations.map { configLock =>
       val config = Configuration(configLock.name)
       val resolution = reconstructResolution(configLock, params)
       config -> resolution
     }.toMap
-  }
 
   private def reconstructResolution(
       configLock: ConfigurationLock,
       params: ResolutionParams
-  ): Resolution = {
+  ): Resolution =
     val forceVersions: Map[Module, String] = configLock.dependencies.map { depLock =>
       val module = Module(
         coursier.Organization(depLock.organization),
@@ -168,24 +169,22 @@ object ResolutionSerializer {
       .withDependencies(dependencies)
       .withForceVersions(forceVersions ++ params.params.forceVersion)
       .withProjectCache(projectCache): @nowarn)
-  }
+  end reconstructResolution
 
-  private object EmptyArtifactSource extends ArtifactSource {
+  private object EmptyArtifactSource extends ArtifactSource:
     def artifacts(
         dependency: Dependency,
         project: Project,
         overrideClassifiers: Option[scala.collection.immutable.Seq[coursier.core.Classifier]]
     ): scala.collection.immutable.Seq[(coursier.core.Publication, coursier.util.Artifact)] =
       scala.collection.immutable.Seq.empty
-  }
 
   def getLockedArtifacts(
       lockFileData: LockFileData
-  ): Map[(String, String, String), Seq[ArtifactLock]] = {
+  ): Map[(String, String, String), Seq[ArtifactLock]] =
     lockFileData.configurations.flatMap { configLock =>
       configLock.dependencies.map { depLock =>
         (depLock.organization, depLock.name, depLock.version) -> depLock.artifacts
       }
     }.toMap
-  }
-}
+end ResolutionSerializer
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/Resolvers.scala b/lm-coursier/src/main/scala/lmcoursier/internal/Resolvers.scala
index 40a3a734e..479965fad 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/Resolvers.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/Resolvers.scala
@@ -12,10 +12,10 @@ import sbt.util.Logger
 
 import scala.jdk.CollectionConverters.*
 
-object Resolvers {
+object Resolvers:
 
   private def mavenCompatibleBaseOpt(patterns: Patterns): Option[String] =
-    if (patterns.isMavenCompatible) {
+    if patterns.isMavenCompatible then
       // input  : /Users/user/custom/repo/[organisation]/[module](_[scalaVersion])(_[sbtVersion])/[revision]/[artifact]-[revision](-[classifier]).[ext]
       // output : /Users/user/custom/repo/
       def basePattern(pattern: String): String = pattern.takeWhile(c => c != '[' && c != '(')
@@ -23,12 +23,9 @@ object Resolvers {
       val baseIvyPattern = basePattern(patterns.ivyPatterns.head)
       val baseArtifactPattern = basePattern(patterns.artifactPatterns.head)
 
-      if (baseIvyPattern == baseArtifactPattern)
-        Some(baseIvyPattern)
-      else
-        None
-    } else
-      None
+      if baseIvyPattern == baseArtifactPattern then Some(baseIvyPattern)
+      else None
+    else None
 
   private def mavenRepositoryOpt(
       root: String,
@@ -36,16 +33,16 @@ object Resolvers {
       authentication: Option[Authentication],
       classLoaders: Seq[ClassLoader]
   ): Option[SbtMavenRepository] =
-    try {
+    try
       CacheUrl.url(root, classLoaders) // ensure root is a URL whose protocol can be handled here
-      val root0 = if (root.endsWith("/")) root else root + "/"
+      val root0 = if root.endsWith("/") then root else root + "/"
       Some(
         SbtMavenRepository(
           root0,
           authentication = authentication
         )
       )
-    } catch {
+    catch
       case e: MalformedURLException =>
         log.warn(
           "Error parsing Maven repository base " +
@@ -55,19 +52,15 @@ object Resolvers {
         )
 
         None
-    }
 
   // this handles whitespace in path
-  private def pathToUriString(path: String): String = {
+  private def pathToUriString(path: String): String =
     val stopAtIdx = path.indexWhere(c => c == '[' || c == '$' || c == '(')
-    if (stopAtIdx > 0) {
+    if stopAtIdx > 0 then
       val (pathPart, patternPart) = path.splitAt(stopAtIdx)
       Paths.get(pathPart).toUri.toASCIIString + patternPart
-    } else if (stopAtIdx == 0)
-      "file://" + path
-    else
-      Paths.get(path).toUri.toASCIIString
-  }
+    else if stopAtIdx == 0 then "file://" + path
+    else Paths.get(path).toUri.toASCIIString
 
   def repository(
       resolver: Resolver,
@@ -76,7 +69,7 @@ object Resolvers {
       authentication: Option[Authentication],
       classLoaders: Seq[ClassLoader]
   ): Option[Repository] =
-    resolver match {
+    resolver match
       case r: sbt.librarymanagement.MavenRepository =>
         mavenRepositoryOpt(r.root, log, authentication, classLoaders)
 
@@ -85,7 +78,7 @@ object Resolvers {
             r.patterns.artifactPatterns.lengthCompare(1) == 0 =>
         val mavenCompatibleBaseOpt0 = mavenCompatibleBaseOpt(r.patterns)
 
-        mavenCompatibleBaseOpt0 match {
+        mavenCompatibleBaseOpt0 match
           case None =>
             val repo = IvyRepository.parse(
               pathToUriString(r.patterns.artifactPatterns.head),
@@ -94,14 +87,13 @@ object Resolvers {
               properties = ivyProperties,
               dropInfoAttributes = true,
               authentication = authentication
-            ) match {
+            ) match
               case Left(err) =>
                 sys.error(
                   s"Cannot parse Ivy patterns ${r.patterns.artifactPatterns.head} and ${r.patterns.ivyPatterns.head}: $err"
                 )
               case Right(repo) =>
                 repo
-            }
 
             Some(repo)
 
@@ -112,7 +104,7 @@ object Resolvers {
               authentication,
               classLoaders
             )
-        }
+        end match
 
       case r: URLRepository if patternMatchGuard(r.patterns) =>
         parseMavenCompatResolver(log, ivyProperties, authentication, r.patterns, classLoaders)
@@ -127,15 +119,14 @@ object Resolvers {
       case other =>
         log.warn(s"Unrecognized repository ${other.name}, ignoring it")
         None
-    }
 
-  private object IBiblioRepository {
+  private object IBiblioRepository:
 
     // Use reflection to avoid a compile-time dependency on lm-ivy / Apache Ivy.
     // At runtime the class will be present on the classpath via the main module.
     private val ibiblioClass: Option[Class[?]] =
       try Some(Class.forName("org.apache.ivy.plugins.resolver.IBiblioResolver"))
-      catch { case _: ClassNotFoundException => None }
+      catch case _: ClassNotFoundException => None
 
     private def stringVector(v: java.util.List[?]): Vector[String] =
       Option(v).map(_.asScala.toVector).getOrElse(Vector.empty).collect { case s: String =>
@@ -159,7 +150,7 @@ object Resolvers {
       )
 
     def unapply(r: Resolver): Option[Patterns] =
-      r match {
+      r match
         case raw: RawRepository =>
           ibiblioClass match
             case Some(cls) if cls.isInstance(raw.resolver) =>
@@ -169,8 +160,7 @@ object Resolvers {
               None
         case _ =>
           None
-      }
-  }
+  end IBiblioRepository
 
   private def patternMatchGuard(patterns: Patterns): Boolean =
     patterns.ivyPatterns.lengthCompare(1) == 0 &&
@@ -182,10 +172,10 @@ object Resolvers {
       authentication: Option[Authentication],
       patterns: Patterns,
       classLoaders: Seq[ClassLoader],
-  ): Option[Repository] = {
+  ): Option[Repository] =
     val mavenCompatibleBaseOpt0 = mavenCompatibleBaseOpt(patterns)
 
-    mavenCompatibleBaseOpt0 match {
+    mavenCompatibleBaseOpt0 match
       case None =>
         val repo = IvyRepository.parse(
           patterns.artifactPatterns.head,
@@ -194,19 +184,18 @@ object Resolvers {
           properties = ivyProperties,
           dropInfoAttributes = true,
           authentication = authentication
-        ) match {
+        ) match
           case Left(err) =>
             sys.error(
               s"Cannot parse Ivy patterns ${patterns.artifactPatterns.head} and ${patterns.ivyPatterns.head}: $err"
             )
           case Right(repo) =>
             repo
-        }
 
         Some(repo)
 
       case Some(mavenCompatibleBase) =>
         mavenRepositoryOpt(mavenCompatibleBase, log, authentication, classLoaders)
-    }
-  }
-}
+    end match
+  end parseMavenCompatResolver
+end Resolvers
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/SbtBootJars.scala b/lm-coursier/src/main/scala/lmcoursier/internal/SbtBootJars.scala
index d38c5f53e..9ca1c2f85 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/SbtBootJars.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/SbtBootJars.scala
@@ -5,7 +5,7 @@ import java.io.File
 import coursier.core.{ Module, ModuleName, Organization }
 
 // private[coursier]
-object SbtBootJars {
+object SbtBootJars:
   def apply(
       scalaOrg: Organization,
       scalaVersion: String,
@@ -18,4 +18,3 @@ object SbtBootJars {
 
         (mod, scalaVersion) -> jar
     }.toMap
-}
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/SbtCoursierCache.scala b/lm-coursier/src/main/scala/lmcoursier/internal/SbtCoursierCache.scala
index eb9877ae1..735c9380c 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/SbtCoursierCache.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/SbtCoursierCache.scala
@@ -8,7 +8,7 @@ import coursier.cache.FileCache
 import coursier.util.Task
 
 // private[coursier]
-class SbtCoursierCache {
+class SbtCoursierCache:
 
   import SbtCoursierCache.*
 
@@ -28,18 +28,16 @@ class SbtCoursierCache {
   def putReport(key: ReportKey, report: UpdateReport): Unit =
     reportsCache.put(key, report)
 
-  def clear(): Unit = {
+  def clear(): Unit =
     resolutionsCache.clear()
     reportsCache.clear()
-  }
 
   def isEmpty: Boolean =
     resolutionsCache.isEmpty && reportsCache.isEmpty
-
-}
+end SbtCoursierCache
 
 // private[coursier]
-object SbtCoursierCache {
+object SbtCoursierCache:
 
   final case class ResolutionKey(
       dependencies: Seq[(Configuration, Dependency)],
@@ -61,5 +59,4 @@ object SbtCoursierCache {
 
   // private[coursier]
   val default = new SbtCoursierCache
-
-}
+end SbtCoursierCache
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/SbtUpdateReport.scala b/lm-coursier/src/main/scala/lmcoursier/internal/SbtUpdateReport.scala
index d1c4ee260..319c13b68 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/SbtUpdateReport.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/SbtUpdateReport.scala
@@ -23,9 +23,9 @@ import scala.annotation.nowarn
 
 import scala.annotation.tailrec
 
-private[internal] object SbtUpdateReport {
+private[internal] object SbtUpdateReport:
 
-  private def caching[K, V](f: K => V): K => V = {
+  private def caching[K, V](f: K => V): K => V =
 
     val cache = Collections.synchronizedMap(new WeakHashMap[K, V])
 
@@ -37,7 +37,6 @@ private[internal] object SbtUpdateReport {
         val concurrentValueOpt = Option(cache.putIfAbsent(key, value))
         concurrentValueOpt.getOrElse(value)
       }
-  }
 
   private def infoProperties(project: Project): Seq[(String, String)] =
     project.properties.filter(_._1.startsWith("info."))
@@ -185,20 +184,19 @@ private[internal] object SbtUpdateReport {
       classpathOrder: Boolean,
       missingOk: Boolean,
       classLoaders: Seq[ClassLoader]
-  ): Vector[ModuleReport] = {
+  ): Vector[ModuleReport] =
 
-    val deps = classifiersOpt match {
+    val deps = classifiersOpt match
       case Some(classifiers) =>
         res.dependencyArtifacts(Some(classifiers), classpathOrder)
       case None =>
         res.dependencyArtifacts(None, classpathOrder)
-    }
 
-    val depArtifacts1 = fullArtifactsOpt match {
+    val depArtifacts1 = fullArtifactsOpt match
       case Some(map) =>
         deps.map { (d, p, a) =>
           val d0 = d.withAttributes(d.attributes.withClassifier(p.classifier))
-          val a0 = if (missingOk) a.withOptional(true) else a
+          val a0 = if missingOk then a.withOptional(true) else a
           val f = map.get((d0, Right(p), a0)).flatten
           (d, p, a0, f) // not d0
         }
@@ -206,18 +204,17 @@ private[internal] object SbtUpdateReport {
         deps.map { (d, p, a) =>
           (d, p, a, None)
         }
-    }
 
     val depArtifacts0 = depArtifacts1.filter { case (_, pub, _, _) =>
       pub.attributes != Attributes(Type.pom, Classifier.empty)
     }
 
     val depArtifacts =
-      if (includeSignatures) {
+      if includeSignatures then
 
         val notFound = depArtifacts0.filter(!_._3.extra.contains("sig"))
 
-        if (notFound.isEmpty)
+        if notFound.isEmpty then
           depArtifacts0.flatMap { (dep, pub, a, f) =>
             val sigPub = pub
               // not too sure about those
@@ -226,15 +223,12 @@ private[internal] object SbtUpdateReport {
             Seq((dep, pub, a, f)) ++
               a.extra.get("sig").toSeq.map((dep, sigPub, _, None))
           }
-        else {
-          for ((_, _, a, _) <- notFound)
-            log.error(s"No signature found for ${a.url}")
+        else
+          for (_, _, a, _) <- notFound do log.error(s"No signature found for ${a.url}")
           sys.error(s"${notFound.length} signature(s) not found")
-        }
-      } else
-        depArtifacts0
+      else depArtifacts0
 
-    val groupedDepArtifacts = {
+    val groupedDepArtifacts =
       val m = depArtifacts.groupBy(_._1)
       val fromLib = depArtifacts.map(_._1).distinct.map { dep =>
         dep -> m.getOrElse(dep, Nil).map { case (_, pub, a, f) => (pub, a, f) }
@@ -243,7 +237,6 @@ private[internal] object SbtUpdateReport {
         .withFilter(p => p.module != thisModule._1)
         .map(p => Dependency(p.module, p.version) -> Nil)
       fromLib ++ fromInterProj
-    }
 
     val versions = (Vector(
       Dependency(thisModule._1, thisModule._2)
@@ -266,11 +259,10 @@ private[internal] object SbtUpdateReport {
     val projectCache = res.projectCache
 
     def lookupProject(mv: coursier.core.Resolution.ModuleVersion): Option[Project] =
-      projectCache.get(mv) match {
+      projectCache.get(mv) match
         case Some((_, p)) => Some(p)
         case _            =>
           interProjectDependencies.find(p => mv == (p.module, p.version))
-      }
 
     /**
      * Assemble the project info, resolving inherited fields. Only implements resolving
@@ -279,18 +271,14 @@ private[internal] object SbtUpdateReport {
      * @see https://maven.apache.org/pom.html#Inheritance
      * @see https://maven.apache.org/ref/3-LATEST/maven-model-builder/index.html#Inheritance_Assembly
      */
-    def assemble(project: Project): Project = {
+    def assemble(project: Project): Project =
       @tailrec
-      def licenseInfo(project: Project): Seq[Info.License] = {
-        if (project.info.licenseInfo.nonEmpty || project.parent.isEmpty)
-          project.info.licenseInfo
-        else
-          licenseInfo(lookupProject(project.parent.get).get)
-      }
+      def licenseInfo(project: Project): Seq[Info.License] =
+        if project.info.licenseInfo.nonEmpty || project.parent.isEmpty then project.info.licenseInfo
+        else licenseInfo(lookupProject(project.parent.get).get)
       project.withInfo(
         project.info.withLicenseInfo(licenseInfo(project))
       )
-    }
 
     val m = Dependency(thisModule._1, "")
     val directReverseDependencies = res.rootDependencies.toSet
@@ -299,14 +287,13 @@ private[internal] object SbtUpdateReport {
       .map(dep => dep -> Vector(m))
       .toMap
 
-    val reverseDependencies = {
+    val reverseDependencies =
       val transitiveReverseDependencies = res.reverseDependencies.toVector
         .map { (k, v) => clean(k) -> v.map(clean) }
         .groupMapReduce(_._1)((_, deps) => deps)(_ ++ _)
 
       (transitiveReverseDependencies.toVector ++ directReverseDependencies.toVector)
         .groupMapReduce(_._1)((_, deps) => deps)(_ ++ _)
-    }
 
     groupedDepArtifacts.toVector.map { (dep, artifacts) =>
       val proj = lookupProject(dep.moduleVersion).get
@@ -318,7 +305,7 @@ private[internal] object SbtUpdateReport {
         .flatMap { dependee0 =>
           val version = versions(dependee0.module)
           val dependee = dependee0.withVersion(version)
-          lookupProject(dependee.moduleVersion) match {
+          lookupProject(dependee.moduleVersion) match
             case Some(dependeeProj) =>
               Vector(
                 (
@@ -332,11 +319,10 @@ private[internal] object SbtUpdateReport {
               )
             case _ =>
               Vector.empty
-          }
         }
       val filesOpt = artifacts.map { (pub, a, fileOpt) =>
         val fileOpt0 = fileOpt.orElse {
-          if (fullArtifactsOpt.isEmpty)
+          if fullArtifactsOpt.isEmpty then
             artifactFileOpt(proj.module, proj.version, pub.attributes, a)
           else None
         }
@@ -352,7 +338,7 @@ private[internal] object SbtUpdateReport {
         )
       )
     }
-  }
+  end moduleReports
 
   @nowarn
   def apply(
@@ -371,7 +357,7 @@ private[internal] object SbtUpdateReport {
       missingOk: Boolean,
       forceVersions: Map[Module, String],
       classLoaders: Seq[ClassLoader],
-  ): UpdateReport = {
+  ): UpdateReport =
 
     val configReports = resolutions.map { (config, subRes) =>
       val reports = moduleReports(
@@ -392,7 +378,7 @@ private[internal] object SbtUpdateReport {
       // three times per conflict.
       val subProjectCache = subRes.projectCache
 
-      val reports0 = subRes.rootDependencies match {
+      val reports0 = subRes.rootDependencies match
         case Seq(dep) if subProjectCache.contains(dep.moduleVersion) =>
           // quick hack ensuring the module for the only root dependency
           // appears first in the update report, see https://github.com/coursier/coursier/issues/650
@@ -405,7 +391,6 @@ private[internal] object SbtUpdateReport {
           }
           main ++ other
         case _ => reports
-      }
 
       val mainReportDetails = reports0.map { rep =>
         OrganizationArtifactReport(rep.module.organization, rep.module.name, Vector(rep))
@@ -414,7 +399,7 @@ private[internal] object SbtUpdateReport {
       def conflicts: Seq[coursier.graph.Conflict] =
         try coursier.graph.Conflict(subRes)
         catch case e: Throwable if missingOk => Nil
-      val evicted = for {
+      val evicted = for
         c <- conflicts
         // ideally, forceVersions should be taken into account by coursier.core.Resolution itself, when
         // it computes transitive dependencies. It only handles forced versions at a global level for now,
@@ -425,10 +410,10 @@ private[internal] object SbtUpdateReport {
           .get((c.module, c.wantedVersion))
           .orElse(subProjectCache.get((c.module, c.version)))
         (_, proj) <- projOpt.toSeq
-      } yield {
+      yield
         val dep = Dependency(c.module, c.wantedVersion)
         val dependee = Dependency(c.dependeeModule, c.dependeeVersion)
-        val dependeeProj = subProjectCache.get((c.dependeeModule, c.dependeeVersion)) match {
+        val dependeeProj = subProjectCache.get((c.dependeeModule, c.dependeeVersion)) match
           case Some((_, p)) =>
             ProjectInfo(
               p.version,
@@ -438,14 +423,12 @@ private[internal] object SbtUpdateReport {
           case None =>
             // should not happen
             ProjectInfo(c.dependeeVersion, Vector.empty, Vector.empty)
-        }
         val rep = moduleReport(
           (dep, Seq((dependee, dependeeProj)), proj.withVersion(c.wantedVersion), Nil, classLoaders)
         )
           .withEvicted(true)
           .withEvictedData(Some("version selection")) // ??? put latest-revision like sbt/ivy here?
         OrganizationArtifactReport(c.module.organization.value, c.module.name.value, Vector(rep))
-      }
 
       val details = (mainReportDetails ++ evicted)
         .groupBy(r => (r.organization, r.name))
@@ -468,11 +451,11 @@ private[internal] object SbtUpdateReport {
       UpdateStats(-1L, -1L, -1L, cached = false, stamp = Some(System.currentTimeMillis().toString)),
       Map.empty
     )
-  }
+  end apply
 
   private case class ProjectInfo(
       version: String,
       configs: Vector[ConfigRef],
       properties: Seq[(String, String)]
   )
-}
+end SbtUpdateReport
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/TemporaryInMemoryRepository.scala b/lm-coursier/src/main/scala/lmcoursier/internal/TemporaryInMemoryRepository.scala
index 5d1e71f58..4fe13420e 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/TemporaryInMemoryRepository.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/TemporaryInMemoryRepository.scala
@@ -10,17 +10,15 @@ import coursier.util.{ Artifact, EitherT, Monad }
 import scala.annotation.nowarn
 import scala.util.Try
 
-object TemporaryInMemoryRepository {
+object TemporaryInMemoryRepository:
 
-  def closeConn(conn: URLConnection): Unit = {
+  def closeConn(conn: URLConnection): Unit =
     Try(conn.getInputStream).toOption.filter(_ != null).foreach(_.close())
-    conn match {
+    conn match
       case conn0: HttpURLConnection =>
         Try(conn0.getErrorStream).toOption.filter(_ != null).foreach(_.close())
         conn0.disconnect()
       case _ =>
-    }
-  }
 
   def exists(
       uri: URI,
@@ -32,29 +30,26 @@ object TemporaryInMemoryRepository {
       uri: URI,
       localArtifactsShouldBeCached: Boolean,
       cacheOpt: Option[FileCache[Nothing]]
-  ): Boolean = {
+  ): Boolean =
 
     // Sometimes HEAD attempts fail even though standard GETs are fine.
     // E.g. https://github.com/NetLogo/NetLogo/releases/download/5.3.1/NetLogo.jar
     // returning 403s. Hence the second attempt below.
 
-    val protocolSpecificAttemptOpt = {
+    val protocolSpecificAttemptOpt =
 
-      def ifFile: Option[Boolean] = {
-        if (localArtifactsShouldBeCached && !new File(uri).exists()) {
+      def ifFile: Option[Boolean] =
+        if localArtifactsShouldBeCached && !new File(uri).exists() then
           val cachePath = coursier.cache.CacheDefaults.location
           // 'file' here stands for the protocol (e.g. it's https instead for https:// URLs)
           Some(new File(cachePath, s"file/${uri.getPath}").exists())
-        } else {
-          Some(new File(uri).exists()) // FIXME Escaping / de-escaping needed here?
-        }
-      }
+        else Some(new File(uri).exists()) // FIXME Escaping / de-escaping needed here?
 
-      def ifHttp: Option[Boolean] = {
+      def ifHttp: Option[Boolean] =
         // HEAD request attempt, adapted from http://stackoverflow.com/questions/22541629/android-how-can-i-make-an-http-head-request/22545275#22545275
 
         var conn: URLConnection = null
-        try {
+        try
           conn = ConnectionBuilder(uri.toASCIIString)
             .withFollowHttpToHttpsRedirections(
               cacheOpt.fold(false)(_.followHttpToHttpsRedirections)
@@ -71,40 +66,32 @@ object TemporaryInMemoryRepository {
           // iff this doesn't throw.
           conn.getInputStream.close()
           Some(true)
-        } catch {
+        catch
           case _: FileNotFoundException => Some(false)
           case _: IOException           => None // error other than not found
-        } finally {
-          if (conn != null)
-            closeConn(conn)
-        }
-      }
+        finally if conn != null then closeConn(conn)
+        end try
+      end ifHttp
 
-      uri.getScheme match {
+      uri.getScheme match
         case "file"           => ifFile
         case "http" | "https" => ifHttp
         case _                => None
-      }
-    }
+    end protocolSpecificAttemptOpt
 
-    def genericAttempt: Boolean = {
+    def genericAttempt: Boolean =
       var conn: URLConnection = null
-      try {
+      try
         conn = uri.toURL.openConnection()
         // NOT setting request type to HEAD here.
         conn.getInputStream.close()
         true
-      } catch {
-        case _: IOException => false
-      } finally {
-        if (conn != null)
-          closeConn(conn)
-      }
-    }
+      catch case _: IOException => false
+      finally if conn != null then closeConn(conn)
 
     protocolSpecificAttemptOpt
       .getOrElse(genericAttempt)
-  }
+  end exists
 
   def apply(
       fallbacks: Map[(Module, String), (URI, Boolean)]
@@ -126,14 +113,13 @@ object TemporaryInMemoryRepository {
       localArtifactsShouldBeCached = cache.localArtifactsShouldBeCached,
       Some(cache.asInstanceOf[FileCache[Nothing]])
     )
-
-}
+end TemporaryInMemoryRepository
 
 final class TemporaryInMemoryRepository private (
     val fallbacks: Map[(Module, String), (URI, Boolean)],
     val localArtifactsShouldBeCached: Boolean,
     val cacheOpt: Option[FileCache[Nothing]]
-) extends Repository {
+) extends Repository:
 
   @nowarn
   def find[F[_]](
@@ -142,7 +128,7 @@ final class TemporaryInMemoryRepository private (
       fetch: Repository.Fetch[F]
   )(using
       F: Monad[F]
-  ): EitherT[F, String, (ArtifactSource, Project)] = {
+  ): EitherT[F, String, (ArtifactSource, Project)] =
 
     def res = fallbacks
       .get((module, version))
@@ -151,12 +137,11 @@ final class TemporaryInMemoryRepository private (
           val urlStr = uri.toURL.toExternalForm
           val idx = urlStr.lastIndexOf('/')
 
-          if (idx < 0 || urlStr.endsWith("/"))
-            Left(s"$uri doesn't point to a file")
-          else {
+          if idx < 0 || urlStr.endsWith("/") then Left(s"$uri doesn't point to a file")
+          else
             val (dirUrlStr, fileName) = urlStr.splitAt(idx + 1)
 
-            if (TemporaryInMemoryRepository.exists(uri, localArtifactsShouldBeCached, cacheOpt)) {
+            if TemporaryInMemoryRepository.exists(uri, localArtifactsShouldBeCached, cacheOpt) then
               val proj = Project(
                 module,
                 version,
@@ -176,21 +161,21 @@ final class TemporaryInMemoryRepository private (
               )
 
               Right((this, proj))
-            } else
-              Left(s"$fileName not found under $dirUrlStr")
-          }
+            else Left(s"$fileName not found under $dirUrlStr")
+            end if
+          end if
       }
 
     // EitherT(F.bind(F.point(()))(_ => F.point(res)))
     EitherT(F.map(F.point(()))(_ => res))
-  }
+  end find
 
   @nowarn
   def artifacts(
       dependency: Dependency,
       project: Project,
       overrideClassifiers: Option[Seq[Classifier]]
-  ): Seq[(Publication, Artifact)] = {
+  ): Seq[(Publication, Artifact)] =
     fallbacks
       .get(dependency.moduleVersion)
       .toSeq
@@ -205,6 +190,4 @@ final class TemporaryInMemoryRepository private (
         )
         (pub, Artifact(url0, Map.empty, Map.empty, changing, optional = false, None))
       }
-  }
-
-}
+end TemporaryInMemoryRepository
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/UpdateParams.scala b/lm-coursier/src/main/scala/lmcoursier/internal/UpdateParams.scala
index cb3c1eb84..dd265e06a 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/UpdateParams.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/UpdateParams.scala
@@ -23,30 +23,28 @@ final case class UpdateParams(
     classpathOrder: Boolean,
     missingOk: Boolean,
     classLoaders: Seq[ClassLoader]
-) {
+):
 
   def artifactFileOpt(
       module: Module,
       version: String,
       attributes: Attributes,
       artifact: Artifact
-  ): Option[File] = {
+  ): Option[File] =
 
     // Under some conditions, SBT puts the scala JARs of its own classpath
     // in the application classpath. Ensuring we return SBT's jars rather than
     // JARs from the coursier cache, so that a same JAR doesn't land twice in the
     // application classpath (once via SBT jars, once via coursier cache).
     val fromBootJars =
-      if (attributes.classifier.isEmpty && attributes.`type` == Type.jar)
+      if attributes.classifier.isEmpty && attributes.`type` == Type.jar then
         sbtBootJarOverrides.get((module, version))
-      else
-        None
+      else None
 
     val artifact0 =
-      if (missingOk) artifact.withOptional(true)
+      if missingOk then artifact.withOptional(true)
       else artifact
 
     fromBootJars.orElse(artifacts.get(artifact0))
-  }
-
-}
+  end artifactFileOpt
+end UpdateParams
diff --git a/lm-coursier/src/main/scala/lmcoursier/internal/UpdateRun.scala b/lm-coursier/src/main/scala/lmcoursier/internal/UpdateRun.scala
index 643d08c2c..8ec259e76 100644
--- a/lm-coursier/src/main/scala/lmcoursier/internal/UpdateRun.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/internal/UpdateRun.scala
@@ -9,7 +9,7 @@ import sbt.util.Logger
 import scala.annotation.nowarn
 
 // private[coursier]
-object UpdateRun {
+object UpdateRun:
 
   // Move back to coursier.util (in core module) after 1.0?
   @nowarn
@@ -17,7 +17,7 @@ object UpdateRun {
       res: Map[Configuration, Resolution],
       depsByConfig: Map[Configuration, Seq[Dependency]],
       configs: Map[Configuration, Set[Configuration]]
-  ): Map[Configuration, Set[Dependency]] = {
+  ): Map[Configuration, Set[Dependency]] =
 
     val allDepsByConfig = depsByConfig.map { (config, deps) =>
       config -> res(config).subset(deps).minDependencies
@@ -32,7 +32,6 @@ object UpdateRun {
     }
 
     filteredAllDepsByConfig
-  }
 
   // Move back to coursier.util (in core module) after 1.0?
   @nowarn
@@ -59,7 +58,7 @@ object UpdateRun {
   ): UpdateReport = Lock.maybeSynchronized(needsLock = !RefreshLogger.defaultFallbackMode) {
     val depsByConfig = grouped(params.dependencies)
 
-    if (verbosityLevel >= 2) {
+    if verbosityLevel >= 2 then
       val finalDeps = dependenciesWithConfig(
         params.res,
         depsByConfig,
@@ -71,7 +70,6 @@ object UpdateRun {
       )
       val repr = Print.dependenciesUnknownConfigs(finalDeps.toVector, projCache)
       log.info(repr.split('\n').map("  " + _).mkString("\n"))
-    }
 
     SbtUpdateReport(
       params.thisModule,
@@ -92,5 +90,4 @@ object UpdateRun {
 
   private def grouped[K, V](map: Seq[(K, V)]): Map[K, Seq[V]] =
     map.groupMap(_._1)((_, values) => values)
-
-}
+end UpdateRun
diff --git a/lm-coursier/src/main/scala/lmcoursier/syntax/package.scala b/lm-coursier/src/main/scala/lmcoursier/syntax/package.scala
index d2b39dffb..97e4e7a25 100644
--- a/lm-coursier/src/main/scala/lmcoursier/syntax/package.scala
+++ b/lm-coursier/src/main/scala/lmcoursier/syntax/package.scala
@@ -9,8 +9,8 @@ import xsbti.Logger
 import scala.concurrent.duration.{ Duration, FiniteDuration }
 import java.io.File
 
-package object syntax {
-  extension (value: CoursierConfiguration.type) {
+package object syntax:
+  extension (value: CoursierConfiguration.type)
     @deprecated(
       "Legacy cache location support was dropped, this method does nothing.",
       "2.0.0-RC6-10"
@@ -80,9 +80,9 @@ package object syntax {
         localArtifactsShouldBeCached = false,
         lockFile = None,
       )
-  }
+  end extension
 
-  extension (value: CoursierConfiguration) {
+  extension (value: CoursierConfiguration)
     def withLog(log: Logger): CoursierConfiguration =
       value.withLog(Option(log))
     def withSbtScalaOrganization(sbtScalaOrganization: String): CoursierConfiguration =
@@ -120,9 +120,9 @@ package object syntax {
 
     def withRetry(retry: (FiniteDuration, Int)): CoursierConfiguration =
       value.withRetry(Some((retry._1, retry._2)))
-  }
+  end extension
 
-  extension (value: Publication) {
+  extension (value: Publication)
     def attributes: Attributes =
       Attributes(value.`type`, value.classifier)
 
@@ -130,9 +130,8 @@ package object syntax {
       value
         .withType(attributes.`type`)
         .withClassifier(attributes.classifier)
-  }
 
-  extension (value: Dependency.type) {
+  extension (value: Dependency.type)
     def apply(
         module: Module,
         version: String,
@@ -151,9 +150,8 @@ package object syntax {
         optional,
         transitive
       )
-  }
 
-  extension (value: Dependency) {
+  extension (value: Dependency)
     def attributes: Attributes = value.publication.attributes
 
     def withAttributes(attributes: Attributes): Dependency =
@@ -162,9 +160,8 @@ package object syntax {
           .withType(attributes.`type`)
           .withClassifier(attributes.classifier)
       )
-  }
 
-  extension (value: ModuleMatchers.type) {
+  extension (value: ModuleMatchers.type)
     def all: ModuleMatchers =
       ModuleMatchers(Set.empty, Set.empty)
     def only(organization: String, moduleName: String): ModuleMatchers =
@@ -175,21 +172,18 @@ package object syntax {
       )
     def only(mod: Module): ModuleMatchers =
       ModuleMatchers(Set.empty, Set(mod), includeByDefault = false)
-  }
 
-  extension (value: Strict) {
+  extension (value: Strict)
     def addInclude(include: (String, String)*): Strict =
       value.withInclude(value.include ++ include)
     def addExclude(exclude: (String, String)*): Strict =
       value.withExclude(value.exclude ++ exclude)
-  }
 
-  extension (value: Authentication.type) {
+  extension (value: Authentication.type)
     def apply(headers: Seq[(String, String)]): Authentication =
       Authentication("", "").withHeaders(headers)
-  }
 
-  extension (value: DirectCredentials.type) {
+  extension (value: DirectCredentials.type)
     def apply(host: String, username: String, password: String, realm: String): DirectCredentials =
       DirectCredentials(host, username, password, Option(realm))
     def apply(
@@ -200,14 +194,12 @@ package object syntax {
         optional: Boolean
     ): DirectCredentials =
       DirectCredentials(host, username, password, Option(realm))
-  }
 
-  extension (value: DirectCredentials) {
+  extension (value: DirectCredentials)
     def withRealm(realm: String): DirectCredentials =
       value.withRealm(Option(realm))
-  }
 
-  extension (value: Credentials.type) {
+  extension (value: Credentials.type)
     def apply(): DirectCredentials = DirectCredentials()
     def apply(host: String, username: String, password: String): DirectCredentials =
       DirectCredentials(host, username, password)
@@ -257,5 +249,5 @@ package object syntax {
       FileCredentials(f.getAbsolutePath)
     def apply(f: File, optional: Boolean): FileCredentials =
       FileCredentials(f.getAbsolutePath, optional)
-  }
-}
+  end extension
+end syntax
diff --git a/lm-coursier/src/test/scala/lmcoursier/CoursierDependencyResolutionTests.scala b/lm-coursier/src/test/scala/lmcoursier/CoursierDependencyResolutionTests.scala
index da164ffc3..582190c6a 100644
--- a/lm-coursier/src/test/scala/lmcoursier/CoursierDependencyResolutionTests.scala
+++ b/lm-coursier/src/test/scala/lmcoursier/CoursierDependencyResolutionTests.scala
@@ -5,16 +5,15 @@ import org.scalatest.propspec.AnyPropSpec
 import sbt.librarymanagement.*
 import sbt.util.Logger
 
-class CoursierDependencyResolutionTests extends AnyPropSpec with Matchers {
+class CoursierDependencyResolutionTests extends AnyPropSpec with Matchers:
 
-  private val logger: Logger = new Logger {
+  private val logger: Logger = new Logger:
     def log(level: sbt.util.Level.Value, message: => String): Unit =
       System.err.println(s"${level.id} $message")
     def success(message: => String): Unit =
       System.err.println(message)
     def trace(t: => Throwable): Unit =
       System.err.println(s"trace $t")
-  }
 
   private val conf211 =
     CoursierConfiguration().withAutoScalaLibrary(true).withScalaVersion(Some("2.11.12"))
@@ -66,14 +65,13 @@ class CoursierDependencyResolutionTests extends AnyPropSpec with Matchers {
       .withConfigurations(Vector(Configuration.of("Compile", "compile")))
     val module = depRes.moduleDescriptor(desc)
 
-    depRes.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), logger) match {
+    depRes.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), logger) match
       case Left(x)  => throw x.resolveException
       case Right(x) =>
         x.allModules.collect {
           case m: ModuleID if m.organization == scalaModule212.organization && m.name == m.name =>
             m.revision
         } should (contain(conf211.scalaVersion.get) and have length 1) // from config
-    }
   }
 
   property("get scalalib at local version, scalaModuleInfo:overrideScalaVersion") {
@@ -86,7 +84,7 @@ class CoursierDependencyResolutionTests extends AnyPropSpec with Matchers {
       .withScalaModuleInfo(scalaModuleInfo213.withOverrideScalaVersion(true))
     val module = depRes.moduleDescriptor(desc)
 
-    depRes.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), logger) match {
+    depRes.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), logger) match
       case Left(x)  => throw x.resolveException
       case Right(x) =>
         x.allModules.collect {
@@ -95,7 +93,6 @@ class CoursierDependencyResolutionTests extends AnyPropSpec with Matchers {
         } should (
           contain(scalaModuleInfo213.scalaFullVersion) and have length 1
         ) // from autoScalaLib
-    }
   }
 
   property("get scalalib at local version, scalaModuleInfo:!overrideScalaVersion") {
@@ -107,14 +104,13 @@ class CoursierDependencyResolutionTests extends AnyPropSpec with Matchers {
       .withScalaModuleInfo(scalaModuleInfo213.withOverrideScalaVersion(false))
     val module = depRes.moduleDescriptor(desc)
 
-    depRes.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), logger) match {
+    depRes.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), logger) match
       case Left(x)  => throw x.resolveException
       case Right(x) =>
         x.allModules.collect {
           case m: ModuleID if m.organization == scalaModule212.organization && m.name == m.name =>
             m.revision
         } should (contain(scalaModule212.revision) and have length 1) // from dependency
-    }
   }
 
   property(
@@ -129,7 +125,7 @@ class CoursierDependencyResolutionTests extends AnyPropSpec with Matchers {
       .withScalaModuleInfo(scalaModuleInfo213.withOverrideScalaVersion(true))
     val module = depRes.moduleDescriptor(desc)
 
-    depRes.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), logger) match {
+    depRes.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), logger) match
       case Left(x)  => throw x.resolveException
       case Right(x) =>
         x.allModules.collect {
@@ -138,7 +134,6 @@ class CoursierDependencyResolutionTests extends AnyPropSpec with Matchers {
         } should (
           contain(scalaModuleInfo213.scalaFullVersion) and have length 1
         ) // from autoScalaLib
-    }
   }
 
   property(
@@ -153,14 +148,12 @@ class CoursierDependencyResolutionTests extends AnyPropSpec with Matchers {
       .withScalaModuleInfo(scalaModuleInfo213.withOverrideScalaVersion(false))
     val module = depRes.moduleDescriptor(desc)
 
-    depRes.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), logger) match {
+    depRes.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), logger) match
       case Left(x)  => throw x.resolveException
       case Right(x) =>
         x.allModules.collect {
           case m: ModuleID if m.organization == scalaModule212.organization && m.name == m.name =>
             CrossVersion.binaryScalaVersion(m.revision)
         } should (contain("2.12") and have length 1) // from transitive dependency
-    }
   }
-
-}
+end CoursierDependencyResolutionTests
diff --git a/lm-coursier/src/test/scala/lmcoursier/EvictionErrorSpec.scala b/lm-coursier/src/test/scala/lmcoursier/EvictionErrorSpec.scala
index 99e97d6a9..faab51a50 100644
--- a/lm-coursier/src/test/scala/lmcoursier/EvictionErrorSpec.scala
+++ b/lm-coursier/src/test/scala/lmcoursier/EvictionErrorSpec.scala
@@ -6,7 +6,7 @@ import sbt.librarymanagement.syntax.*
 import sbt.util.Level
 import TestKit.*
 
-object EvictionErrorSpec extends verify.BasicTestSuite {
+object EvictionErrorSpec extends verify.BasicTestSuite:
   // This is a specification to check the eviction errors
 
   import TestShowLines.*
@@ -134,12 +134,11 @@ object EvictionErrorSpec extends verify.BasicTestSuite {
     val userDefinedSchemes: Map[(String, String), String] = Map(schemes flatMap { s =>
       val organization = s.organization
       val versionScheme = s.revision
-      (s.crossVersion, sbvOpt) match {
+      (s.crossVersion, sbvOpt) match
         case (b: Binary, Some(sbv)) =>
           List((s.organization, s"${s.name}${b.suffix}_$sbv") -> versionScheme)
         case _ =>
           List((s.organization, s.name) -> versionScheme)
-      }
     }*)
 
     // The key should include the platform suffix "_sjs1" before the Scala version
@@ -230,4 +229,4 @@ object EvictionErrorSpec extends verify.BasicTestSuite {
       filterImplicit = false,
       overrideScalaVersion = true
     )
-}
+end EvictionErrorSpec
diff --git a/lm-coursier/src/test/scala/lmcoursier/EvictionWarningSpec.scala b/lm-coursier/src/test/scala/lmcoursier/EvictionWarningSpec.scala
index 8d39ad5cb..5413b2494 100644
--- a/lm-coursier/src/test/scala/lmcoursier/EvictionWarningSpec.scala
+++ b/lm-coursier/src/test/scala/lmcoursier/EvictionWarningSpec.scala
@@ -5,7 +5,7 @@ import sbt.internal.librarymanagement.cross.CrossVersionUtil
 import sbt.librarymanagement.syntax.*
 import TestKit.*
 
-object EvictionWarningSpec extends verify.BasicTestSuite {
+object EvictionWarningSpec extends verify.BasicTestSuite:
   // This is a specification to check the eviction warnings
 
   import TestShowLines.*
@@ -392,4 +392,4 @@ object EvictionWarningSpec extends verify.BasicTestSuite {
       filterImplicit = false,
       overrideScalaVersion = true
     )
-}
+end EvictionWarningSpec
diff --git a/lm-coursier/src/test/scala/lmcoursier/FromSbtPlatformSpec.scala b/lm-coursier/src/test/scala/lmcoursier/FromSbtPlatformSpec.scala
index f957a8770..dd6bdf79a 100644
--- a/lm-coursier/src/test/scala/lmcoursier/FromSbtPlatformSpec.scala
+++ b/lm-coursier/src/test/scala/lmcoursier/FromSbtPlatformSpec.scala
@@ -4,7 +4,7 @@ import org.scalatest.matchers.should.Matchers
 import org.scalatest.propspec.AnyPropSpec
 import sbt.librarymanagement.*
 
-final class FromSbtPlatformSpec extends AnyPropSpec with Matchers {
+final class FromSbtPlatformSpec extends AnyPropSpec with Matchers:
 
   property("explicit platform should not be overridden by project platform") {
     // Test case for issue #8665: Auto-injected Scala library with explicit .platform(Platform.jvm)
@@ -124,4 +124,4 @@ final class FromSbtPlatformSpec extends AnyPropSpec with Matchers {
     module.name.value shouldBe "sniper_native0.5_3"
     version shouldBe "0.0.9-SNAPSHOT"
   }
-}
+end FromSbtPlatformSpec
diff --git a/lm-coursier/src/test/scala/lmcoursier/InclExclSpec.scala b/lm-coursier/src/test/scala/lmcoursier/InclExclSpec.scala
index d2ccadc35..8a98a5cd2 100644
--- a/lm-coursier/src/test/scala/lmcoursier/InclExclSpec.scala
+++ b/lm-coursier/src/test/scala/lmcoursier/InclExclSpec.scala
@@ -5,7 +5,7 @@ import sbt.librarymanagement.syntax.*
 import scala.annotation.nowarn
 import TestKit.*
 
-object InclExclSpec extends verify.BasicTestSuite {
+object InclExclSpec extends verify.BasicTestSuite:
   val scala210 = Some("2.10.4")
   test("it should exclude any version of lift-json via a new exclusion rule") {
     val toExclude = ExclusionRule("net.liftweb", "lift-json_2.10")
@@ -81,12 +81,11 @@ object InclExclSpec extends verify.BasicTestSuite {
       .cross(CrossVersion.full)
       .excludeAll(toExclude)
 
-  def getUpdateReport(dep: ModuleID, scalaVersion: Option[String]): UpdateReport = {
+  def getUpdateReport(dep: ModuleID, scalaVersion: Option[String]): UpdateReport =
     val m = module(defaultModuleId, Vector(dep), scalaVersion)
     coursierUpdate(m)
-  }
 
-  def testLiftJsonIsMissing(report: UpdateReport): Unit = {
+  def testLiftJsonIsMissing(report: UpdateReport): Unit =
     assert(
       !report.allModules.exists(_.name.contains("lift-json")),
       "lift-json has not been excluded."
@@ -95,9 +94,8 @@ object InclExclSpec extends verify.BasicTestSuite {
       !report.allModuleReports.exists(_.module.name.contains("lift-json")),
       "lift-json has not been excluded."
     )
-  }
 
-  def testScalaLibraryIsMissing(report: UpdateReport): Unit = {
+  def testScalaLibraryIsMissing(report: UpdateReport): Unit =
     assert(
       !report.allModules.exists(_.name.contains("scala-library")),
       "scala-library has not been excluded."
@@ -106,9 +104,8 @@ object InclExclSpec extends verify.BasicTestSuite {
       !report.allModuleReports.exists(_.module.name.contains("scala-library")),
       "scala-library has not been excluded."
     )
-  }
 
-  def testScalahostIsMissing(report: UpdateReport): Unit = {
+  def testScalahostIsMissing(report: UpdateReport): Unit =
     assert(
       !report.allModules.exists(_.name.contains("scalahost")),
       "scalahost has not been excluded."
@@ -117,5 +114,4 @@ object InclExclSpec extends verify.BasicTestSuite {
       !report.allModuleReports.exists(_.module.name.contains("scalahost")),
       "scalahost has not been excluded."
     )
-  }
-}
+end InclExclSpec
diff --git a/lm-coursier/src/test/scala/lmcoursier/IvyXmlTests.scala b/lm-coursier/src/test/scala/lmcoursier/IvyXmlTests.scala
index 1261a93e3..d10b09d71 100644
--- a/lm-coursier/src/test/scala/lmcoursier/IvyXmlTests.scala
+++ b/lm-coursier/src/test/scala/lmcoursier/IvyXmlTests.scala
@@ -4,7 +4,7 @@ import lmcoursier.definitions.{ Configuration, Info, Module, ModuleName, Organiz
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.propspec.AnyPropSpec
 
-class IvyXmlTests extends AnyPropSpec with Matchers {
+class IvyXmlTests extends AnyPropSpec with Matchers:
 
   property("no truncation") {
     val project = Project(
@@ -26,5 +26,4 @@ class IvyXmlTests extends AnyPropSpec with Matchers {
 
     assert(!content.contains("</conf>"))
   }
-
-}
+end IvyXmlTests
diff --git a/lm-coursier/src/test/scala/lmcoursier/LockFileSpec.scala b/lm-coursier/src/test/scala/lmcoursier/LockFileSpec.scala
index ffd5bad9f..f38cfa487 100644
--- a/lm-coursier/src/test/scala/lmcoursier/LockFileSpec.scala
+++ b/lm-coursier/src/test/scala/lmcoursier/LockFileSpec.scala
@@ -5,7 +5,7 @@ import org.scalatest.funsuite.AnyFunSuite
 import java.io.File
 import sbt.io.IO
 
-class LockFileSpec extends AnyFunSuite {
+class LockFileSpec extends AnyFunSuite:
 
   test("LockFileData serialization round-trip") {
     val lockData = LockFileData(
@@ -152,4 +152,4 @@ class LockFileSpec extends AnyFunSuite {
       assert(result == httpUrl)
     }
   }
-}
+end LockFileSpec
diff --git a/lm-coursier/src/test/scala/lmcoursier/ResolutionSpec.scala b/lm-coursier/src/test/scala/lmcoursier/ResolutionSpec.scala
index 3071e898d..570999570 100644
--- a/lm-coursier/src/test/scala/lmcoursier/ResolutionSpec.scala
+++ b/lm-coursier/src/test/scala/lmcoursier/ResolutionSpec.scala
@@ -11,7 +11,7 @@ import sbt.util.ShowLines.*
 // import sbt.librarymanagement.{ Resolver, UnresolvedWarningConfiguration, UpdateConfiguration }
 import sbt.librarymanagement.syntax.*
 
-final class ResolutionSpec extends AnyPropSpec with Matchers {
+final class ResolutionSpec extends AnyPropSpec with Matchers:
 
   lazy val log = ConsoleLogger()
 
@@ -22,7 +22,7 @@ final class ResolutionSpec extends AnyPropSpec with Matchers {
       deps: Vector[ModuleID],
       scalaFullVersion: Option[String],
       overrideScalaVersion: Boolean = true
-  ): ModuleDescriptor = {
+  ): ModuleDescriptor =
     val scalaModuleInfo = scalaFullVersion map { fv =>
       ScalaModuleInfo(
         scalaFullVersion = fv,
@@ -39,7 +39,7 @@ final class ResolutionSpec extends AnyPropSpec with Matchers {
       .withConfigurations(configurations)
       .withScalaModuleInfo(scalaModuleInfo)
     lmEngine.moduleDescriptor(moduleSetting)
-  }
+  end module
 
   def resolvers = Vector(
     DefaultMavenRepository,
@@ -52,11 +52,10 @@ final class ResolutionSpec extends AnyPropSpec with Matchers {
   private final val stubModule = "com.example" % "foo" % "0.1.0" % "compile"
 
   private def unresolvedWarningLines(module: ModuleDescriptor): Seq[String] =
-    lmEngine.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), log) match {
+    lmEngine.update(module, UpdateConfiguration(), UnresolvedWarningConfiguration(), log) match
       case Left(uw)      => uw.lines
       case Right(report) =>
         fail(s"Expected resolution to fail, but it succeeded with report: $report")
-    }
 
   private def assertContainsAll(lines: Seq[String], expected: Seq[String]): Unit =
     expected.foreach { line =>
@@ -337,23 +336,21 @@ final class ResolutionSpec extends AnyPropSpec with Matchers {
       resolution.toOption.get.configurations.find(_.configuration == Compile.toConfigRef).get
     val tikaCaller = "org.apache.tika:tika-core:3.3.1"
 
-    def callerOf(name: String): ModuleReport = {
+    def callerOf(name: String): ModuleReport =
       val reports = compileConfig.modules.filter(_.module.name == name)
       withClue(s"$name not found in: ${compileConfig.modules.map(_.module.name).mkString(", ")}") {
         reports should have size 1
       }
       reports.head
-    }
 
     def coord(m: sbt.librarymanagement.ModuleID): String =
       s"${m.organization}:${m.name}:${m.revision}"
 
-    for (transitive <- Seq("commons-io", "slf4j-api")) {
+    for transitive <- Seq("commons-io", "slf4j-api") do
       val report = callerOf(transitive)
       val callerCoords = report.callers.map(c => coord(c.caller)).toSet
       withClue(s"$transitive callers: $callerCoords") {
         callerCoords should contain(tikaCaller)
       }
-    }
   }
-}
+end ResolutionSpec
diff --git a/lm-coursier/src/test/scala/lmcoursier/TestKit.scala b/lm-coursier/src/test/scala/lmcoursier/TestKit.scala
index 172b0f54c..26eb9c300 100644
--- a/lm-coursier/src/test/scala/lmcoursier/TestKit.scala
+++ b/lm-coursier/src/test/scala/lmcoursier/TestKit.scala
@@ -75,6 +75,7 @@ object TestKit:
       .withConfigurations(configurations)
       .withScalaModuleInfo(scalaModuleInfo)
     lmEngine.moduleDescriptor(moduleSetting)
+  end module
 
   def defaultModuleId: ModuleID =
     ModuleID("com.example", "foo", "0.1.0").withConfigurations(Some("compile"))
diff --git a/lm-coursier/src/test/scala/lmcoursier/internal/ResolutionRunSpec.scala b/lm-coursier/src/test/scala/lmcoursier/internal/ResolutionRunSpec.scala
index a3ad3f4e0..acf81b377 100644
--- a/lm-coursier/src/test/scala/lmcoursier/internal/ResolutionRunSpec.scala
+++ b/lm-coursier/src/test/scala/lmcoursier/internal/ResolutionRunSpec.scala
@@ -37,3 +37,4 @@ class ResolutionRunSpec extends AnyFunSuite with Matchers:
       "Server returned HTTP response code: 404 for URL: https://repo.example.com/org/mod/1.0/mod-1.0.pom"
     )
     ResolutionRun.isTransientResolutionError(err) shouldBe false
+end ResolutionRunSpec
diff --git a/main-actions/src/main/scala/sbt/Console.scala b/main-actions/src/main/scala/sbt/Console.scala
index 35378dad0..df1d74434 100644
--- a/main-actions/src/main/scala/sbt/Console.scala
+++ b/main-actions/src/main/scala/sbt/Console.scala
@@ -18,7 +18,7 @@ import xsbti.compile.{ Compilers, Inputs }
 
 import scala.util.Try
 
-final class Console(compiler: AnalyzingCompiler) {
+final class Console(compiler: AnalyzingCompiler):
 
   /** Starts an interactive scala interpreter session with the given classpath. */
   def apply(classpath: Seq[File], log: Logger): Try[Unit] =
@@ -47,18 +47,17 @@ final class Console(compiler: AnalyzingCompiler) {
       options: Seq[String],
       initialCommands: String,
       cleanupCommands: String
-  )(loader: Option[ClassLoader], bindings: Seq[(String, Any)])(using log: Logger): Try[Unit] = {
+  )(loader: Option[ClassLoader], bindings: Seq[(String, Any)])(using log: Logger): Try[Unit] =
     apply(classpath, options, initialCommands, cleanupCommands, Terminal.get)(loader, bindings)
-  }
   def apply(
       classpath: Seq[File],
       options: Seq[String],
       initialCommands: String,
       cleanupCommands: String,
       terminal: Terminal
-  )(loader: Option[ClassLoader], bindings: Seq[(String, Any)])(using log: Logger): Try[Unit] = {
+  )(loader: Option[ClassLoader], bindings: Seq[(String, Any)])(using log: Logger): Try[Unit] =
     def console0(): Unit =
-      try {
+      try
         compiler.console(
           classpath map { x =>
             PlainVirtualFile(x.toPath)
@@ -72,26 +71,26 @@ final class Console(compiler: AnalyzingCompiler) {
           loader,
           bindings
         )
-      } catch { case _: InterruptedException | _: ClosedChannelException => }
+      catch
+        case _: InterruptedException | _: ClosedChannelException =>
     val previous = sys.props.get("scala.color").getOrElse("auto")
     val jline3term = sbt.internal.util.JLine3(terminal)
-    try {
-      sys.props("scala.color") = if (terminal.isColorEnabled) "true" else "false"
+    try
+      sys.props("scala.color") = if terminal.isColorEnabled then "true" else "false"
       terminal.withRawOutput {
         jline.TerminalFactory.set(terminal.toJLine)
         DeprecatedJLine.setTerminalOverride(jline3term)
         terminal.withRawInput(Run.executeSuccess(console0()))
       }
-    } finally {
+    finally
       sys.props("scala.color") = previous
       jline3term.close()
-    }
-  }
-}
+  end apply
+end Console
 
-object Console {
+object Console:
   def apply(conf: Inputs): Console =
-    conf.compilers match {
-      case cs: Compilers => new Console(cs.scalac match { case x: AnalyzingCompiler => x })
-    }
-}
+    conf.compilers match
+      case cs: Compilers =>
+        new Console(cs.scalac match
+          case x: AnalyzingCompiler => x)
diff --git a/main-actions/src/main/scala/sbt/DotGraph.scala b/main-actions/src/main/scala/sbt/DotGraph.scala
index d121893cb..db31b3335 100644
--- a/main-actions/src/main/scala/sbt/DotGraph.scala
+++ b/main-actions/src/main/scala/sbt/DotGraph.scala
@@ -13,25 +13,25 @@ import sbt.internal.util.Relation
 
 import sbt.io.IO
 
-object DotGraph {
+object DotGraph:
   def generateGraph[K, V](
       file: File,
       graphName: String,
       relation: Relation[K, V],
       keyToString: K => String,
       valueToString: V => String
-  ): Unit = {
+  ): Unit =
     import scala.collection.mutable.{ HashMap, HashSet }
     val mappedGraph = new HashMap[String, HashSet[String]]
-    for ((key, values) <- relation.forwardMap; keyString = keyToString(key); value <- values)
+    for (key, values) <- relation.forwardMap; keyString = keyToString(key); value <- values do
       mappedGraph.getOrElseUpdate(keyString, new HashSet[String]) += valueToString(value)
 
     val mappings =
-      for {
+      for
         (dependsOn, dependents) <- mappedGraph.toSeq
         dependent <- dependents
         if dependent != dependsOn && !dependsOn.isEmpty && !dependent.isEmpty
-      } yield "\"" + dependent + "\" -> \"" + dependsOn + "\""
+      yield "\"" + dependent + "\" -> \"" + dependsOn + "\""
 
     val lines =
       ("digraph " + graphName + " {") +:
@@ -39,13 +39,12 @@ object DotGraph {
         "}"
 
     IO.writeLines(file, lines)
-  }
+  end generateGraph
   def sourceToString(roots: Iterable[File], source: File) =
     relativized(roots, source).trim.stripSuffix(".scala").stripSuffix(".java")
 
-  private def relativized(roots: Iterable[File], path: File): String = {
+  private def relativized(roots: Iterable[File], path: File): String =
     val relativized = roots.flatMap(root => IO.relativize(root, path))
     val shortest = relativized.foldLeft(Int.MaxValue)(_ min _.length)
     relativized.find(_.length == shortest).getOrElse(path.getName)
-  }
-}
+end DotGraph
diff --git a/main-actions/src/main/scala/sbt/ForkTests.scala b/main-actions/src/main/scala/sbt/ForkTests.scala
index 0a798d4de..ce3029ff8 100755
--- a/main-actions/src/main/scala/sbt/ForkTests.scala
+++ b/main-actions/src/main/scala/sbt/ForkTests.scala
@@ -51,7 +51,7 @@ private[sbt] object ForkTests:
       parallelism: Option[Int],
       virtualClasspath: Boolean,
       tags: (Tag, Int)*
-  ): Task[TestOutput] = {
+  ): Task[TestOutput] =
     import std.TaskExtra.*
     val dummyLoader =
       this.getClass.getClassLoader // can't provide the loader for test classes, which is in another jvm
@@ -80,7 +80,7 @@ private[sbt] object ForkTests:
         .dependsOn(all(opts.setup)*)
         .flatMap: results =>
           all(opts.cleanup).join.map(_ => results)
-  }
+  end apply
 
   private def mainTestTask(
       runners: Map[TestFramework, Runner],
@@ -262,6 +262,8 @@ private class React(
           promise.failure(info.error)
         else ()
       case _ => ()
+    end match
+  end processNotification
 
   def blockForResponse(): Int =
     Await.result(promise.future, Duration.Inf)
diff --git a/main-actions/src/main/scala/sbt/Pkg.scala b/main-actions/src/main/scala/sbt/Pkg.scala
index 29a88ade1..daa19d6c3 100644
--- a/main-actions/src/main/scala/sbt/Pkg.scala
+++ b/main-actions/src/main/scala/sbt/Pkg.scala
@@ -41,29 +41,27 @@ import xsbti.{ FileConverter, HashedVirtualFileRef, VirtualFile, VirtualFileRef
 object Pkg:
   def JarManifest(m: Manifest) = PackageOption.JarManifest(m)
   def MainClass(mainClassName: String) = PackageOption.MainClass(mainClassName)
-  def ManifestAttributes(attributes: (String, String)*) = {
-    val converted = for ((name, value) <- attributes) yield (new Attributes.Name(name), value)
+  def ManifestAttributes(attributes: (String, String)*) =
+    val converted = for (name, value) <- attributes yield (new Attributes.Name(name), value)
     PackageOption.ManifestAttributes(converted*)
-  }
   // 2010-01-01
   private val default2010Timestamp: Long = 1262304000000L
   def FixedTimestamp(value: Option[Long]) = PackageOption.FixedTimestamp(value)
   val keepTimestamps: Option[Long] = None
   val fixed2010Timestamp: Option[Long] = Some(default2010Timestamp)
   def gitCommitDateTimestamp: Option[Long] =
-    try {
+    try
       Some(
         OffsetDateTime
           .parse(Process("git show -s --format=%cI").!!.trim)
           .toInstant()
           .toEpochMilli()
       )
-    } catch {
+    catch
       case e: Exception if e.getMessage.startsWith("Nonzero") =>
         sys.error(
           s"git repository was expected for package timestamp; use Package.fixed2010Timestamp or Package.keepTimestamps instead"
         )
-    }
   def setFixedTimestamp(value: Option[Long]): PackageOption =
     FixedTimestamp(value)
 
@@ -81,16 +79,13 @@ object Pkg:
 
   def mergeAttributes(a1: Attributes, a2: Attributes) = a1.asScala ++= a2.asScala
   // merges `mergeManifest` into `manifest` (mutating `manifest` in the process)
-  def mergeManifests(manifest: Manifest, mergeManifest: Manifest): Unit = {
+  def mergeManifests(manifest: Manifest, mergeManifest: Manifest): Unit =
     mergeAttributes(manifest.getMainAttributes, mergeManifest.getMainAttributes)
     val entryMap = manifest.getEntries.asScala
-    for ((key, value) <- mergeManifest.getEntries.asScala) {
-      entryMap.get(key) match {
+    for (key, value) <- mergeManifest.getEntries.asScala do
+      entryMap.get(key) match
         case Some(attributes) => mergeAttributes(attributes, value); ()
         case None             => entryMap.put(key, value); ()
-      }
-    }
-  }
 
   /**
    * The jar package configuration. Contains all relevant information to create a jar file.
@@ -103,7 +98,7 @@ object Pkg:
       val sources: Seq[(HashedVirtualFileRef, String)],
       val jar: VirtualFileRef,
       val options: Seq[PackageOption]
-  ) {
+  ):
     import sbt.util.CacheImplicits.hashedVirtualFileRefToStr
     private def sourcesStr: String =
       sources
@@ -117,7 +112,6 @@ object Pkg:
   options = ...,
 )    
 """
-  }
 
   object Configuration:
     given IsoLList.Aux[
@@ -178,26 +172,23 @@ object Pkg:
    *
    * @param main the current jar attributes
    */
-  def setVersion(main: Attributes): Unit = {
+  def setVersion(main: Attributes): Unit =
     val version = Attributes.Name.MANIFEST_VERSION
-    if (main.getValue(version) eq null) {
+    if main.getValue(version) eq null then
       main.put(version, "1.0")
       ()
-    }
-  }
-  def addSpecManifestAttributes(name: String, version: String, orgName: String): PackageOption = {
+  def addSpecManifestAttributes(name: String, version: String, orgName: String): PackageOption =
     import Attributes.Name.*
     val attribKeys = Seq(SPECIFICATION_TITLE, SPECIFICATION_VERSION, SPECIFICATION_VENDOR)
     val attribVals = Seq(name, version, orgName)
     PackageOption.ManifestAttributes(attribKeys.zip(attribVals)*)
-  }
   def addImplManifestAttributes(
       name: String,
       version: String,
       homepage: Option[URI],
       org: String,
       orgName: String
-  ): PackageOption = {
+  ): PackageOption =
     import Attributes.Name.*
 
     // The ones in Attributes.Name are deprecated saying:
@@ -215,7 +206,7 @@ object Pkg:
     PackageOption.ManifestAttributes(attribKeys.zip(attribVals) ++ {
       homepage map (h => (IMPLEMENTATION_URL, h.toString))
     }*)
-  }
+  end addImplManifestAttributes
 
   def makeJar(
       sources: Seq[(File, String)],
@@ -223,25 +214,22 @@ object Pkg:
       manifest: Manifest,
       log: Logger,
       time: Option[Long]
-  ): Unit = {
+  ): Unit =
     val path = jar.getAbsolutePath
     log.debug("Packaging " + path + " ...")
-    if (jar.exists)
-      if (!jar.isFile)
-        sys.error(path + " exists, but is not a regular file")
+    if jar.exists then if !jar.isFile then sys.error(path + " exists, but is not a regular file")
     log.debug(sourcesDebugString(sources))
     IO.jarParallel(sources, jar, manifest, time)
     log.debug("Done packaging.")
-  }
   def sourcesDebugString(sources: Seq[(File, String)]): String =
     "Input file mappings:\n\t" + (sources map { (f, s) => s + "\n\t  " + f } mkString ("\n\t"))
 
   given manifestFormat: JsonFormat[Manifest] = projectFormat[Manifest, Array[Byte]](
-    m => {
+    m =>
       val bos = new java.io.ByteArrayOutputStream()
       m.write(bos)
       bos.toByteArray
-    },
+    ,
     bs => new Manifest(new java.io.ByteArrayInputStream(bs))
   )
 end Pkg
diff --git a/main-actions/src/main/scala/sbt/RawCompileLike.scala b/main-actions/src/main/scala/sbt/RawCompileLike.scala
index 08893dc2b..9d80ea2a8 100644
--- a/main-actions/src/main/scala/sbt/RawCompileLike.scala
+++ b/main-actions/src/main/scala/sbt/RawCompileLike.scala
@@ -20,23 +20,19 @@ import sbt.util.FileInfo.{ exists, hash, lastModified }
 import sbt.internal.util.ManagedLogger
 import xsbti.compile.ClasspathOptions
 
-object RawCompileLike {
+object RawCompileLike:
   type Gen = (Seq[File], Seq[File], File, Seq[String], Int, ManagedLogger) => Unit
 
-  private def optionFiles(options: Seq[String], fileInputOpts: Seq[String]): List[File] = {
+  private def optionFiles(options: Seq[String], fileInputOpts: Seq[String]): List[File] =
     @tailrec
-    def loop(opt: List[String], result: List[File]): List[File] = {
-      opt.dropWhile(!fileInputOpts.contains(_)) match {
-        case List(_, fileOpt, tail*) => {
+    def loop(opt: List[String], result: List[File]): List[File] =
+      opt.dropWhile(!fileInputOpts.contains(_)) match
+        case List(_, fileOpt, tail*) =>
           val file = new File(fileOpt)
-          if (file.isFile) loop(tail.toList, file :: result)
+          if file.isFile then loop(tail.toList, file :: result)
           else loop(tail.toList, result)
-        }
         case Nil | List(_) => result
-      }
-    }
     loop(options.toList, Nil)
-  }
 
   def cached(cacheStoreFactory: CacheStoreFactory, doCompile: Gen): Gen =
     cached(cacheStoreFactory, Seq(), doCompile)
@@ -46,7 +42,7 @@ object RawCompileLike {
       fileInputOpts: Seq[String],
       doCompile: Gen
   ): Gen =
-    (sources, classpath, outputDirectory, options, maxErrors, log) => {
+    (sources, classpath, outputDirectory, options, maxErrors, log) =>
       type Inputs = (
           FilesInfo[HashFileInfo],
           FilesInfo[ModifiedFileInfo],
@@ -66,36 +62,31 @@ object RawCompileLike {
       val cachedComp = inputChanged(cacheStoreFactory.make("inputs")) { (inChanged, in: Inputs) =>
         inputChanged(cacheStoreFactory.make("output")) {
           (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
-            if (inChanged || outChanged)
+            if inChanged || outChanged then
               doCompile(sources, classpath, outputDirectory, options, maxErrors, log)
-            else
-              log.debug("Uptodate: " + outputDirectory.getAbsolutePath)
+            else log.debug("Uptodate: " + outputDirectory.getAbsolutePath)
         }
       }
       cachedComp(inputs)(exists(outputDirectory.allPaths.get().toSet))
-    }
 
   def prepare(description: String, doCompile: Gen): Gen =
-    (sources, classpath, outputDirectory, options, maxErrors, log) => {
-      if (sources.isEmpty) log.info("No sources available, skipping " + description + "...")
-      else {
+    (sources, classpath, outputDirectory, options, maxErrors, log) =>
+      if sources.isEmpty then log.info("No sources available, skipping " + description + "...")
+      else
         log.info(description.capitalize + " to " + outputDirectory.absolutePath + "...")
         IO.delete(outputDirectory)
         IO.createDirectory(outputDirectory)
         doCompile(sources, classpath, outputDirectory, options, maxErrors, log)
         log.info(description.capitalize + " successful.")
-      }
-    }
 
   def filterSources(f: File => Boolean, doCompile: Gen): Gen =
     (sources, classpath, outputDirectory, options, maxErrors, log) =>
       doCompile(sources filter f, classpath, outputDirectory, options, maxErrors, log)
 
   def rawCompile(instance: ScalaInstance, cpOptions: ClasspathOptions): Gen =
-    (sources, classpath, outputDirectory, options, _, log) => {
+    (sources, classpath, outputDirectory, options, _, log) =>
       val compiler = new RawCompiler(instance, cpOptions, log)
       compiler(sources.map(_.toPath), classpath.map(_.toPath), outputDirectory.toPath, options)
-    }
 
   def compile(
       label: String,
@@ -106,4 +97,4 @@ object RawCompileLike {
     cached(cacheStoreFactory, prepare(label + " sources", rawCompile(instance, cpOptions)))
 
   val nop: Gen = (_, _, _, _, _, _) => ()
-}
+end RawCompileLike
diff --git a/main-actions/src/main/scala/sbt/Sync.scala b/main-actions/src/main/scala/sbt/Sync.scala
index 541f8d36f..c67d3000f 100644
--- a/main-actions/src/main/scala/sbt/Sync.scala
+++ b/main-actions/src/main/scala/sbt/Sync.scala
@@ -40,7 +40,7 @@ import xsbti.{ FileConverter, VirtualFileRef }
  * Warning: Specifically, don't mix this with a directory containing manually created files, like sources.
  * It is safe to use for its intended purpose: copying resources to a class output directory.
  */
-object Sync {
+object Sync:
   @deprecated("Use sync, which doesn't take the unused outStyle param", "1.1.1")
   def apply(
       store: CacheStore,
@@ -67,7 +67,7 @@ object Sync {
       inStyle: FileInfo.Style,
       fileConverter: FileConverter
   ): Iterable[(File, File)] => Relation[File, File] =
-    mappings => {
+    mappings =>
       val relation = Relation.empty ++ mappings
       noDuplicateTargets(relation)
       val currentInfo = relation._1s.map(s => (s, inStyle(s))).toMap
@@ -92,31 +92,28 @@ object Sync {
 
       writeInfoVirtual(store, relation, currentInfo, fileConverter)(using inStyle.format)
       relation
-    }
 
   def copy(source: File, target: File): Unit =
-    if (source.isFile) IO.copyFile(source, target, true)
-    else if (!target.exists) { // we don't want to update the last modified time of an existing directory
+    if source.isFile then IO.copyFile(source, target, true)
+    else if !target.exists
+    then // we don't want to update the last modified time of an existing directory
       IO.createDirectory(target)
       IO.copyLastModified(source, target)
       ()
-    }
 
-  def noDuplicateTargets(relation: Relation[File, File]): Unit = {
+  def noDuplicateTargets(relation: Relation[File, File]): Unit =
     val dups = relation.reverseMap
       .withFilter { case (_, srcs) => srcs.size >= 2 && srcs.exists(!_.isDirectory) }
       .map { (target, srcs) => "\n\t" + target + "\nfrom\n\t" + srcs.mkString("\n\t\t") }
-    if (dups.nonEmpty)
-      sys.error("Duplicate mappings:" + dups.mkString)
-  }
+    if dups.nonEmpty then sys.error("Duplicate mappings:" + dups.mkString)
 
   given relationFormat[A, B](using
       af: JsonFormat[Map[A, Set[B]]],
       bf: JsonFormat[Map[B, Set[A]]]
   ): JsonFormat[Relation[A, B]] =
-    new JsonFormat[Relation[A, B]] {
+    new JsonFormat[Relation[A, B]]:
       def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Relation[A, B] =
-        jsOpt match {
+        jsOpt match
           case Some(js) =>
             unbuilder.beginArray(js)
             val jForward = unbuilder.nextElement
@@ -125,15 +122,12 @@ object Sync {
             Relation.make(af.read(Some(jForward), unbuilder), bf.read(Some(jReverse), unbuilder))
           case None =>
             deserializationError("Expected JsArray but found None")
-        }
 
-      def write[J](obj: Relation[A, B], builder: Builder[J]): Unit = {
+      def write[J](obj: Relation[A, B], builder: Builder[J]): Unit =
         builder.beginArray()
         af.write(obj.forwardMap, builder)
         bf.write(obj.reverseMap, builder)
         builder.endArray()
-      }
-    }
 
   private lazy val fileIsoString: IsoString[File] =
     val iso = summon[IsoStringLong[File]]
@@ -156,7 +150,7 @@ object Sync {
       relation: Relation[File, File],
       info: Map[File, F],
       fileConverter: FileConverter
-  )(using infoFormat: JsonFormat[F]): Unit = {
+  )(using infoFormat: JsonFormat[F]): Unit =
     val virtualRelation: Relation[VirtualFileRef, VirtualFileRef] =
       Relation.switch(relation, (f: File) => fileConverter.toVirtualFile(f.toPath))
     val virtualInfo: Map[VirtualFileRef, F] = info.map { (file, fileInfo) =>
@@ -172,60 +166,52 @@ object Sync {
         virtualInfo
       )
     )
-  }
+  end writeInfoVirtual
 
   type RelationInfo[F] = (Relation[File, File], Map[File, F])
   type RelationInfoVirtual[F] = (Relation[VirtualFileRef, VirtualFileRef], Map[VirtualFileRef, F])
 
   def readInfoWrapped[F <: FileInfo](store: CacheStore, fileConverter: FileConverter)(using
       infoFormat: JsonFormat[F]
-  ): RelationInfo[F] = {
+  ): RelationInfo[F] =
     convertFromVirtual(readInfoVirtual(store)(using infoFormat), fileConverter)
-  }
 
   def convertFromVirtual[F <: FileInfo](
       info: RelationInfoVirtual[F],
       fileConverter: FileConverter
-  ): RelationInfo[F] = {
+  ): RelationInfo[F] =
     val firstPart = Relation.switch(info._1, (r: VirtualFileRef) => fileConverter.toPath(r).toFile)
     val secondPart = info._2.map { (file, fileInfo) =>
       fileConverter.toPath(file).toFile -> fileInfo
     }
     firstPart -> secondPart
-  }
 
   def readInfo[F <: FileInfo](
       store: CacheStore
   )(using infoFormat: JsonFormat[F]): RelationInfo[F] =
-    try {
-      readUncaught[F](store)(using infoFormat)
-    } catch {
+    try readUncaught[F](store)(using infoFormat)
+    catch
       case _: IOException         => (Relation.empty[File, File], Map.empty[File, F])
       case _: ZipException        => (Relation.empty[File, File], Map.empty[File, F])
       case e: TranslatedException =>
-        e.getCause match {
+        e.getCause match
           case _: ZipException => (Relation.empty[File, File], Map.empty[File, F])
           case _               => throw e
-        }
-    }
 
   def readInfoVirtual[F <: FileInfo](
       store: CacheStore
   )(using infoFormat: JsonFormat[F]): RelationInfoVirtual[F] =
-    try {
-      readUncaughtVirtual[F](store)(using infoFormat)
-    } catch {
+    try readUncaughtVirtual[F](store)(using infoFormat)
+    catch
       case _: IOException =>
         (Relation.empty[VirtualFileRef, VirtualFileRef], Map.empty[VirtualFileRef, F])
       case _: ZipException =>
         (Relation.empty[VirtualFileRef, VirtualFileRef], Map.empty[VirtualFileRef, F])
       case e: TranslatedException =>
-        e.getCause match {
+        e.getCause match
           case _: ZipException =>
             (Relation.empty[VirtualFileRef, VirtualFileRef], Map.empty[VirtualFileRef, F])
           case _ => throw e
-        }
-    }
 
   private def readUncaught[F <: FileInfo](
       store: CacheStore
@@ -236,12 +222,11 @@ object Sync {
 
   private def readUncaughtVirtual[F <: FileInfo](
       store: CacheStore
-  )(using JsonFormat[F]): RelationInfoVirtual[F] = {
+  )(using JsonFormat[F]): RelationInfoVirtual[F] =
     import sjsonnew.IsoString
     given IsoString[VirtualFileRef] =
       IsoString.iso[VirtualFileRef](_.toString, VirtualFileRef.of(_))
     store.read(default =
       (Relation.empty[VirtualFileRef, VirtualFileRef], Map.empty[VirtualFileRef, F])
     )
-  }
-}
+end Sync
diff --git a/main-actions/src/main/scala/sbt/TestResultLogger.scala b/main-actions/src/main/scala/sbt/TestResultLogger.scala
index fbcdbb010..591bc88e8 100644
--- a/main-actions/src/main/scala/sbt/TestResultLogger.scala
+++ b/main-actions/src/main/scala/sbt/TestResultLogger.scala
@@ -150,7 +150,7 @@ object TestResultLogger:
         printStandard: TestResultLogger = Defaults.printStandard,
         printFailures: TestResultLogger = Defaults.printFailures,
         printNoTests: TestResultLogger = Defaults.printNoTests
-    ) extends TestResultLogger {
+    ) extends TestResultLogger:
 
       override def run(log: Logger, results: Output, taskName: String): Unit =
         run(log, results, taskName, Vector.empty)
@@ -160,18 +160,15 @@ object TestResultLogger:
           results: Output,
           taskName: String,
           cached: Vector[String]
-      ): Unit = {
+      ): Unit =
         def run(r: TestResultLogger): Unit = r.run(log, results, taskName, cached)
 
         run(printSummary)
 
-        if (printStandard_?(results))
-          run(printStandard)
+        if printStandard_?(results) then run(printStandard)
 
-        if (results.events.isEmpty)
-          run(printNoTests)
-        else
-          run(printFailures)
+        if results.events.isEmpty then run(printNoTests)
+        else run(printFailures)
 
         // Logging only. Failure propagation lives in the task wrapper
         // (`Defaults.testFull` / `inputTests0`) so the cross-project recap
@@ -179,32 +176,31 @@ object TestResultLogger:
         // the `TestsFailedException` thrown there. The trait contract is
         // "perform logging"; it does not document throwing on failure.
         ()
-      }
-    }
+      end run
+    end Main
 
-    val printSummary = TestResultLogger((log, results, _) => {
+    val printSummary = TestResultLogger((log, results, _) =>
       val multipleFrameworks = results.summaries.size > 1
       for Tests.Summary(name, message) <- results.summaries do
-        if (message.isEmpty) log.debug("Summary for " + name + " not available.")
-        else {
-          if (multipleFrameworks) log.info(name)
+        if message.isEmpty then log.debug("Summary for " + name + " not available.")
+        else
+          if multipleFrameworks then log.info(name)
           log.info(message)
-        }
-    })
+    )
 
     val printStandard_? : Output => Boolean =
       results =>
         // Print the standard one-liner statistic if no framework summary is defined, or when > 1 framework is in used.
         results.summaries.size > 1 || results.summaries.headOption.forall(_.summaryText.isEmpty)
 
-    val printStandard = TestResultLogger((log, results, _, cached) => {
+    val printStandard = TestResultLogger((log, results, _, cached) =>
       val counts = countsString(results.events.values, cached.size, true)
       results.overall match
         case TestResult.Empty  => ()
         case TestResult.Error  => log.error(s"${SummaryStatus.Errored.label}: $counts")
         case TestResult.Passed => log.info(s"${SummaryStatus.Passed.label}: $counts")
         case TestResult.Failed => log.error(s"${SummaryStatus.Failed.label}: $counts")
-    })
+    )
 
     private[sbt] def countsString(events: Iterable[SuiteResult]): String =
       countsString(events, 0, false)
@@ -217,7 +213,7 @@ object TestResultLogger:
         events: Iterable[SuiteResult],
         cachedCount: Int,
         alwaysShowCached: Boolean,
-    ): String = {
+    ): String =
       val (failuresCount, errorsCount, passedCount) =
         events.foldLeft((0, 0, 0)) { case ((failureAcc, errorAcc, passedAcc), suite) =>
           suite.result match
@@ -231,24 +227,22 @@ object TestResultLogger:
       val cachedField =
         if cachedCount > 0 || alwaysShowCached then s", cached $cachedCount" else ""
       base + cachedField
-    }
 
-    val printFailures = TestResultLogger((log, results, _) => {
+    val printFailures = TestResultLogger((log, results, _) =>
       def select(resultTpe: TestResult) = results.events collect {
         case (name, tpe) if tpe.result == resultTpe =>
           scala.reflect.NameTransformer.decode(name)
       }
 
       def show(label: String, level: Level.Value, tests: Iterable[String]): Unit =
-        if (tests.nonEmpty) {
+        if tests.nonEmpty then
           log.log(level, label)
           log.log(level, tests.mkString(suitePadding, s"\n$suitePadding", ""))
-        }
 
       show("passed tests:", Level.Debug, select(TestResult.Passed))
       show("failed tests:", Level.Error, select(TestResult.Failed))
       show("error during tests:", Level.Error, select(TestResult.Error))
-    })
+    )
 
     val printNoTests = TestResultLogger((log, results, taskName, cached) =>
       val suffix = if cached.nonEmpty then s" (${cached.size} cached)" else ""
@@ -345,6 +339,7 @@ object TestResultLogger:
             suites.foreach: (name, st) =>
               lines += s"${suitePadding}${name.padTo(width, ' ')}${st.render(isColorEnabled)}"
           lines.result()
+      end detail
     end Summary
   end Defaults
 end TestResultLogger
diff --git a/main-actions/src/main/scala/sbt/Tests.scala b/main-actions/src/main/scala/sbt/Tests.scala
index 0f2ade0ea..d8d7216d6 100644
--- a/main-actions/src/main/scala/sbt/Tests.scala
+++ b/main-actions/src/main/scala/sbt/Tests.scala
@@ -43,7 +43,7 @@ import sbt.internal.util.complete.{ DefaultParsers, Parser }
 
 sealed trait TestOption
 
-object Tests {
+object Tests:
 
   private[sbt] sealed trait AdhocOption
   private[sbt] object AdhocOption:
@@ -86,7 +86,7 @@ object Tests {
       overall: TestResult,
       events: Map[String, SuiteResult],
       summaries: Iterable[Summary]
-  ) {
+  ):
 
     /**
      * Returns a copy with the throwables removed from every suite result.
@@ -96,7 +96,6 @@ object Tests {
      */
     def withoutThrowables: Output =
       copy(events = events.view.mapValues(_.withoutThrowables).toMap)
-  }
 
   /**
    * Summarizes a test run.
@@ -220,64 +219,56 @@ object Tests {
       val tests: Seq[TestDefinition],
       val runPolicy: TestRunPolicy,
       val tags: Seq[(Tag, Int)]
-  ) extends Serializable {
+  ) extends Serializable:
 
-    def this(name: String, tests: Seq[TestDefinition], runPolicy: TestRunPolicy) = {
+    def this(name: String, tests: Seq[TestDefinition], runPolicy: TestRunPolicy) =
       this(name, tests, runPolicy, Seq.empty)
-    }
 
-    def withName(name: String): Group = {
+    def withName(name: String): Group =
       new Group(name, tests, runPolicy, tags)
-    }
 
-    def withTests(tests: Seq[TestDefinition]): Group = {
+    def withTests(tests: Seq[TestDefinition]): Group =
       new Group(name, tests, runPolicy, tags)
-    }
 
-    def withRunPolicy(runPolicy: TestRunPolicy): Group = {
+    def withRunPolicy(runPolicy: TestRunPolicy): Group =
       new Group(name, tests, runPolicy, tags)
-    }
 
-    def withTags(tags: Seq[(Tag, Int)]): Group = {
+    def withTags(tags: Seq[(Tag, Int)]): Group =
       new Group(name, tests, runPolicy, tags)
-    }
 
     override def hashCode(): Int = (name, tests, runPolicy, tags).##
 
-    override def equals(x1: Any): Boolean = {
+    override def equals(x1: Any): Boolean =
       this.eq(x1.asInstanceOf[Object]) || (x1.isInstanceOf[Group] && ({
         val Group1: Group = x1.asInstanceOf[Group]
         name == Group1.name && tests == Group1.tests &&
         runPolicy == Group1.runPolicy && tags == Group1.tags
       }))
-    }
-  }
+  end Group
 
   object Group
       extends AbstractFunction3[String, Seq[TestDefinition], TestRunPolicy, Group]
-      with Serializable {
+      with Serializable:
     // - EXPANDED CASE CLASS METHOD BEGIN -//
     final override def toString(): String = "Group"
     def apply(
         name: String,
         tests: Seq[TestDefinition],
         runPolicy: TestRunPolicy
-    ): Group = {
+    ): Group =
       new Group(name, tests, runPolicy, Seq.empty)
-    }
 
     def apply(
         name: String,
         tests: Seq[TestDefinition],
         runPolicy: TestRunPolicy,
         tags: Seq[(Tag, Int)]
-    ): Group = {
+    ): Group =
       new Group(name, tests, runPolicy, tags)
-    }
 
     private def readResolve(): Object = Group
     // - EXPANDED CASE CLASS METHOD END -//
-  }
+  end Group
 
   private[sbt] final class ProcessedOptions(
       val tests: Vector[TestDefinition],
@@ -289,7 +280,7 @@ object Tests {
       config: Execution,
       discovered: Vector[TestDefinition],
       log: Logger
-  ): ProcessedOptions = {
+  ): ProcessedOptions =
     import collection.mutable.{ HashSet, ListBuffer }
     val testFilters = new ListBuffer[String => Boolean]
     var orderedFilters = Seq[String => Boolean]()
@@ -302,11 +293,11 @@ object Tests {
     def isExplicitFqn(s: String): Boolean =
       !s.contains('*') && !s.contains('?') && !s.contains("...")
 
-    for (option <- config.options) {
-      option match {
+    for option <- config.options do
+      option match
         case Filter(include)   => testFilters += include; ()
         case Filters(includes) =>
-          if (orderedFilters.nonEmpty) sys.error("Cannot define multiple ordered test filters.")
+          if orderedFilters.nonEmpty then sys.error("Cannot define multiple ordered test filters.")
           else orderedFilters = includes
           ()
         case ExplicitlyRequestedNames(names) =>
@@ -317,12 +308,10 @@ object Tests {
         case Setup(setupFunction, _)     => setup += setupFunction; ()
         case Cleanup(cleanupFunction, _) => cleanup += cleanupFunction; ()
         case _: Argument                 => // now handled by whatever constructs `runners`
-      }
-    }
 
-    if (excludeTestsSet.nonEmpty)
+    if excludeTestsSet.nonEmpty then
       log.debug(excludeTestsSet.mkString("Excluding tests: \n\t", "\n\t", ""))
-    if (undefinedFrameworks.nonEmpty)
+    if undefinedFrameworks.nonEmpty then
       log.warn(
         "Arguments defined for test frameworks that are not present:\n\t" + undefinedFrameworks
           .mkString("\n\t")
@@ -332,7 +321,7 @@ object Tests {
       !excludeTestsSet.contains(test.name) && testFilters.forall(filter => filter(test.name))
     val filtered0 = discovered.filter(includeTest).toList.distinct
     val tests =
-      if (orderedFilters.isEmpty) filtered0
+      if orderedFilters.isEmpty then filtered0
       else orderedFilters.flatMap(f => filtered0.filter(d => f(d.name))).toList.distinct
     val uniqueTests = distinctBy(tests)(_.name)
     // Per TaskDef: explicitlySpecified=true only when user supplied a complete FQN (e.g. testOnly com.example.MySuite),
@@ -351,12 +340,11 @@ object Tests {
       cleanup.toVector,
       testListeners.toVector
     )
-  }
+  end processOptions
 
-  private def distinctBy[T, K](in: Seq[T])(f: T => K): Seq[T] = {
+  private def distinctBy[T, K](in: Seq[T])(f: T => K): Seq[T] =
     val seen = new collection.mutable.HashSet[K]
     in.filter(t => seen.add(f(t)))
-  }
 
   // Called by Defaults
   def apply(
@@ -366,7 +354,7 @@ object Tests {
       o: ProcessedOptions,
       config: Execution,
       log: ManagedLogger
-  ): Task[Output] = {
+  ): Task[Output] =
     testTask(
       testLoader,
       frameworks,
@@ -378,7 +366,6 @@ object Tests {
       o.testListeners,
       config
     )
-  }
 
   def apply(
       frameworks: Map[TestFramework, Framework],
@@ -387,10 +374,9 @@ object Tests {
       discovered: Vector[TestDefinition],
       config: Execution,
       log: ManagedLogger
-  ): Task[Output] = {
+  ): Task[Output] =
     val o = processOptions(config, discovered, log)
     apply(frameworks, testLoader, runners, o, config, log)
-  }
 
   private[sbt] def testTask(
       loader: ClassLoader,
@@ -402,7 +388,7 @@ object Tests {
       log: ManagedLogger,
       testListeners: Vector[TestReportListener],
       config: Execution
-  ): Task[Output] = {
+  ): Task[Output] =
     def fj(actions: Iterable[() => Unit]): Task[Unit] =
       nop.dependsOn(actions.toSeq.fork(_()).map(_.tagw(config.tags*))*)
     def partApp(actions: Iterable[ClassLoader => Unit]) = actions.toSeq map { a => () =>
@@ -414,10 +400,8 @@ object Tests {
 
     val setupTasks = fj(partApp(userSetup) :+ frameworkSetup).tagw(config.tags*)
     val mainTasks =
-      if (config.parallel)
-        makeParallel(loader, runnables, setupTasks, config.tags).map(_.toList)
-      else
-        makeSerial(loader, runnables, setupTasks)
+      if config.parallel then makeParallel(loader, runnables, setupTasks, config.tags).map(_.toList)
+      else makeSerial(loader, runnables, setupTasks)
     val taggedMainTasks = mainTasks.tagw(config.tags*)
     taggedMainTasks
       .map(processResults)
@@ -428,7 +412,7 @@ object Tests {
           results
         }
       }
-  }
+  end testTask
   type TestRunnable = (String, TestFunction)
 
   private def createNestedRunnables(
@@ -466,7 +450,7 @@ object Tests {
       loader: ClassLoader,
       runnables: Seq[TestRunnable],
       tags: Seq[(Tag, Int)]
-  ): Task[Map[String, SuiteResult]] = {
+  ): Task[Map[String, SuiteResult]] =
     val tasks = runnables.map { (name, test) => toTask(loader, name, test, tags) }
     tasks.join.map(_.foldLeft(Map.empty[String, SuiteResult]) { (sum, e) =>
       val merged = sum.toSeq ++ e.toSeq
@@ -475,50 +459,45 @@ object Tests {
         .mapValues(_.map(_._2).foldLeft(SuiteResult.Empty)(_ + _))
         .toMap
     })
-  }
 
   def toTask(
       loader: ClassLoader,
       name: String,
       fun: TestFunction,
       tags: Seq[(Tag, Int)]
-  ): Task[Map[String, SuiteResult]] = {
+  ): Task[Map[String, SuiteResult]] =
     val base = Task(Action.Pure(() => (name, fun.apply()), `inline` = false)).setName(name)
     val taggedBase = base.tagw(tags*).tag(fun.tags.map(ConcurrentRestrictions.Tag(_))*)
     taggedBase flatMap { case (name, (result, nested)) =>
       val nestedRunnables = createNestedRunnables(loader, fun, nested)
       toTasks(loader, nestedRunnables, tags).map { currentResultMap =>
         val newResult =
-          currentResultMap.get(name) match {
+          currentResultMap.get(name) match
             case Some(currentResult) => currentResult + result
             case None                => result
-          }
         currentResultMap.updated(name, newResult)
       }
     }
-  }
 
   def makeSerial(
       loader: ClassLoader,
       runnables: Seq[TestRunnable],
       setupTasks: Task[Unit],
-  ): Task[List[(String, SuiteResult)]] = {
+  ): Task[List[(String, SuiteResult)]] =
     @tailrec
     def processRunnable(
         runnableList: List[TestRunnable],
         acc: List[(String, SuiteResult)]
     ): List[(String, SuiteResult)] =
-      runnableList match {
+      runnableList match
         case hd :: rst =>
           val testFun = hd._2
           val (result, nestedTasks) = testFun.apply()
           val nestedRunnables = createNestedRunnables(loader, testFun, nestedTasks)
           processRunnable(nestedRunnables.toList ::: rst, (hd._1, result) :: acc)
         case Nil => acc
-      }
 
     task { processRunnable(runnables.toList, List.empty) }.dependsOn(setupTasks)
-  }
 
   def processResults(results: Iterable[(String, SuiteResult)]): Output =
     Output(overall(results.map(_._2.result)), results.toMap, Iterable.empty)
@@ -530,28 +509,26 @@ object Tests {
       case TestResult.Error                     => 2
 
   def foldTasks(results: Seq[Task[Output]], parallel: Boolean): Task[Output] =
-    if (results.isEmpty) {
-      task { Output(TestResult.Passed, Map.empty, Nil) }
-    } else if (parallel) {
+    if results.isEmpty then task { Output(TestResult.Passed, Map.empty, Nil) }
+    else if parallel then
       reduced[Output](
         results.toIndexedSeq,
         { case (Output(v1, m1, _), Output(v2, m2, _)) =>
           Output(
-            (if (severity(v1) < severity(v2)) v2 else v1): TestResult,
+            (if severity(v1) < severity(v2) then v2 else v1): TestResult,
             Map((m1.toSeq ++ m2.toSeq)*),
             Iterable.empty[Summary]
           )
         }
       )
-    } else {
+    else
       def sequence(tasks: List[Task[Output]], acc: List[Output]): Task[List[Output]] =
-        tasks match {
+        tasks match
           case Nil      => task(acc.reverse)
           case hd :: tl =>
             hd flatMap { out =>
               sequence(tl, out :: acc)
             }
-        }
       sequence(results.toList, List()) map { res =>
         val (rs, ms) = res.unzip(using (e => (e.overall, e.events)))
         val m = ms reduce { (m1: Map[String, SuiteResult], m2: Map[String, SuiteResult]) =>
@@ -559,10 +536,9 @@ object Tests {
         }
         Output(overall(rs), m, Iterable.empty)
       }
-    }
   def overall(results: Iterable[TestResult]): TestResult =
     results.foldLeft(TestResult.Passed: TestResult) { (acc, result) =>
-      if (severity(acc) < severity(result)) result else acc
+      if severity(acc) < severity(result) then result else acc
     }
   def discover(
       frameworks: Seq[Framework],
@@ -571,7 +547,7 @@ object Tests {
   ): (Seq[TestDefinition], Set[String]) =
     discover(frameworks flatMap TestFramework.getFingerprints, allDefs(analysis), log)
 
-  def allDefs(analysis: CompileAnalysis) = analysis match {
+  def allDefs(analysis: CompileAnalysis) = analysis match
     case analysis: Analysis =>
       val acs: Seq[xsbti.api.AnalyzedClass] = analysis.apis.internal.values.toVector
       acs.flatMap { ac =>
@@ -589,12 +565,11 @@ object Tests {
             if e.getMessage.startsWith("No companions") then Nil
             else throw e
       }.toSeq
-  }
   def discover(
       fingerprints: Seq[Fingerprint],
       definitions: Seq[Definition],
       log: Logger
-  ): (Seq[TestDefinition], Set[String]) = {
+  ): (Seq[TestDefinition], Set[String]) =
     val subclasses = fingerprints collect { case sub: SubclassFingerprint =>
       (sub.superclassName, sub.isModule, sub)
     };
@@ -622,22 +597,21 @@ object Tests {
       case _ => false
     })
     val tests =
-      for {
+      for
         (df, di) <- discovered
         fingerprint <- toFingerprints(di)
-      } yield new TestDefinition(df.name, fingerprint, false, Array(new SuiteSelector: Selector))
+      yield new TestDefinition(df.name, fingerprint, false, Array(new SuiteSelector: Selector))
     val mains = discovered collect { case (df, di) if di.hasMain => df.name }
     (tests, mains.toSet)
-  }
-}
+  end discover
+end Tests
 
 final class TestsFailedException private[sbt] (
     val taskName: String,
     val testOutput: Option[Tests.Output]
 ) extends RuntimeException("Tests unsuccessful")
-    with FeedbackProvidedException {
+    with FeedbackProvidedException:
   // Public no-arg constructor preserved for backward compatibility with
   // callers outside sbt. Internal call sites always use the primary
   // constructor with a real task name.
   def this() = this(taskName = "", testOutput = None)
-}
diff --git a/main-actions/src/main/scala/sbt/internal/WorkerExchange.scala b/main-actions/src/main/scala/sbt/internal/WorkerExchange.scala
index 602e73d21..a528d222a 100644
--- a/main-actions/src/main/scala/sbt/internal/WorkerExchange.scala
+++ b/main-actions/src/main/scala/sbt/internal/WorkerExchange.scala
@@ -67,6 +67,7 @@ object WorkerExchange:
             major >= 16
           catch case NonFatal(_) => false
     jdkIpcSupportCache.getOrElseUpdate(javaHome, doDetect)
+  end supportsUnixDomainSockets
 
   /**
    * Start a worker process.
@@ -90,10 +91,10 @@ object WorkerExchange:
     val (connArgs, closer) = connectionType match
       case WorkerConnection.Tcp =>
         val serverSocket = Retry(ServerSocket(0, 1, loopback))
-        val accepter = Thread(() => {
+        val accepter = Thread(() =>
           val socket = serverSocket.accept()
           runAccepter(socket.getOutputStream(), socket.getInputStream())
-        })
+        )
         accepter.setName("sbt-fork-test-response-reader")
         accepter.setPriority(Thread.NORM_PRIORITY + 1)
         accepter.start()
@@ -106,22 +107,21 @@ object WorkerExchange:
           ch
         }
         @volatile var acceptedChannel: SocketChannel = null
-        val accepter = Thread(() => {
+        val accepter = Thread(() =>
           val channel = serverChannel.accept()
           acceptedChannel = channel
           runAccepter(
             DuplexChannels.newOutputStream(channel),
             DuplexChannels.newInputStream(channel)
           )
-        })
+        )
         accepter.setName("sbt-fork-test-response-reader")
         accepter.setPriority(Thread.NORM_PRIORITY + 1)
         accepter.start()
-        val closer: AutoCloseable = () => {
+        val closer: AutoCloseable = () =>
           if acceptedChannel != null then acceptedChannel.close()
           serverChannel.close()
           Files.deleteIfExists(path)
-        }
         (Seq("--ipc", path.toString()), Some(closer))
       case WorkerConnection.Stdio => (Nil, None)
     val options = Seq(
@@ -146,6 +146,7 @@ object WorkerExchange:
     val forkTimeout = fo.connectionTimeout.getOrElse(30.seconds)
     val input = Await.result(inputRef.future, forkTimeout)
     WorkerProxy(input, p, options, closer)
+  end startWorker
 
   /** Generates a fresh path suitable for binding a `WorkerConnection.Ipc` socket. */
   def newIpcSocketPath(): NioPath =
@@ -194,10 +195,10 @@ class WorkerProxy(
     inputStream.println(str)
     inputStream.flush()
 
-  val watch = Thread(() => {
+  val watch = Thread(() =>
     while process.isAlive() do Thread.sleep(100)
     WorkerExchange.listeners.foreach(_.notifyExit(process))
-  })
+  )
   watch.start()
 end WorkerProxy
 
diff --git a/main-actions/src/main/scala/sbt/internal/sona/PackageDeploymentValidationError.scala b/main-actions/src/main/scala/sbt/internal/sona/PackageDeploymentValidationError.scala
index f7a5a02d1..a34013856 100644
--- a/main-actions/src/main/scala/sbt/internal/sona/PackageDeploymentValidationError.scala
+++ b/main-actions/src/main/scala/sbt/internal/sona/PackageDeploymentValidationError.scala
@@ -24,7 +24,7 @@ private case class PackageDeploymentValidationError(
     packageErrors: Seq[String]
 )
 
-private object PackageDeploymentValidationError {
+private object PackageDeploymentValidationError:
 
   /**
    * Example: (it's not an array but an object which makes it hard to parse with the standard contraband means)
@@ -47,7 +47,7 @@ private object PackageDeploymentValidationError {
    *         None - otherwise (Sonatype Central could change the format of the output)
    */
   def parse(errorsNode: JValue): Option[Seq[PackageDeploymentValidationError]] =
-    errorsNode match {
+    errorsNode match
       case JObject(fields) =>
         val errors = fields.toSeq.flatMap {
           case JField(packageInfo, JArray(packageErrors)) =>
@@ -56,19 +56,15 @@ private object PackageDeploymentValidationError {
               case other          => None
             }
             val noParsingIssues = packageErrors.length == packageErrorsTexts.length
-            if (noParsingIssues)
+            if noParsingIssues then
               Some(PackageDeploymentValidationError(packageInfo, packageErrorsTexts.toSeq))
-            else
-              None
+            else None
           case _ =>
             None
         }
         val noParsingIssues = errors.size == fields.length
-        if (noParsingIssues)
-          Some(errors)
-        else
-          None
+        if noParsingIssues then Some(errors)
+        else None
       case _ =>
         None
-    }
-}
+end PackageDeploymentValidationError
diff --git a/main-actions/src/main/scala/sbt/internal/sona/Sona.scala b/main-actions/src/main/scala/sbt/internal/sona/Sona.scala
index 074f8fdff..802af8330 100644
--- a/main-actions/src/main/scala/sbt/internal/sona/Sona.scala
+++ b/main-actions/src/main/scala/sbt/internal/sona/Sona.scala
@@ -25,24 +25,22 @@ import java.util.Base64
 import scala.concurrent.*
 import scala.concurrent.duration.*
 
-class Sona(client: SonaClient) extends AutoCloseable {
+class Sona(client: SonaClient) extends AutoCloseable:
   def uploadBundle(
       bundleZipPath: Path,
       deploymentName: String,
       pt: PublishingType,
       log: Logger,
-  ): Unit = {
+  ): Unit =
     val deploymentId = client.uploadBundle(bundleZipPath, deploymentName, pt, log)
     client.waitForDeploy(deploymentId, deploymentName, pt, 1, log)
-  }
   def close(): Unit = client.close()
-}
 
 class SonaClient(reqTransform: Request => Request, uploadRequestTimeout: FiniteDuration)
-    extends AutoCloseable {
+    extends AutoCloseable:
   import SonaClient.baseUrl
 
-  private val http = {
+  private val http =
     val defaultHttpRequestTimeout = 2.minutes
 
     val gigahorseConfig = Gigahorse.config
@@ -50,14 +48,13 @@ class SonaClient(reqTransform: Request => Request, uploadRequestTimeout: FiniteD
       .withReadTimeout(defaultHttpRequestTimeout)
 
     Gigahorse.http(gigahorseConfig)
-  }
 
   def uploadBundle(
       bundleZipPath: Path,
       deploymentName: String,
       publishingType: PublishingType,
       log: Logger,
-  ): String = {
+  ): String =
     val maxAttempt = 2
     val waitDurationBetweenAtttempt = 5.seconds
     // Adding an extra 5.seconds as security margins
@@ -69,10 +66,9 @@ class SonaClient(reqTransform: Request => Request, uploadRequestTimeout: FiniteD
       // addQuery string doesn't work for post
       val q = queryString(
         "name" -> deploymentName,
-        "publishingType" -> (publishingType match {
+        "publishingType" -> (publishingType match
           case PublishingType.Automatic   => "AUTOMATIC"
-          case PublishingType.UserManaged => "USER_MANAGED"
-        })
+          case PublishingType.UserManaged => "USER_MANAGED")
       )
       val req = Gigahorse
         .url(s"${baseUrl}/publisher/upload?$q")
@@ -85,7 +81,7 @@ class SonaClient(reqTransform: Request => Request, uploadRequestTimeout: FiniteD
       http.run(reqTransform(req), SonaClient.asStringWithErrorBody)
     }
     awaitWithMessage(res, "uploading...", log, totalAwaitDuration)
-  }
+  end uploadBundle
 
   private def queryString(kv: (String, String)*): String =
     kv.map { case (k, v) =>
@@ -99,13 +95,13 @@ class SonaClient(reqTransform: Request => Request, uploadRequestTimeout: FiniteD
       publishingType: PublishingType,
       attempt: Int,
       log: Logger,
-  ): Unit = {
+  ): Unit =
     val status = deploymentStatus(deploymentId)
     log.info(s"deployment $deploymentName ${status.deploymentState} ${attempt}/n")
     val sleepSec =
-      if (attempt <= 3) List(5, 5, 10, 15)(attempt)
+      if attempt <= 3 then List(5, 5, 10, 15)(attempt)
       else 30
-    status.deploymentState match {
+    status.deploymentState match
       case DeploymentState.FAILED =>
         val errorText = failedDeploymentErrorText(deploymentId, status.errors, log)
         sys.error(errorText)
@@ -120,61 +116,53 @@ class SonaClient(reqTransform: Request => Request, uploadRequestTimeout: FiniteD
       case _ =>
         Thread.sleep(sleepSec * 1000L)
         waitForDeploy(deploymentId, deploymentName, publishingType, attempt + 1, log)
-    }
-  }
+  end waitForDeploy
 
-  private def deploymentStatus(deploymentId: String): PublisherStatus = {
+  private def deploymentStatus(deploymentId: String): PublisherStatus =
     val res = retryF(maxAttempt = 5, waitDurationBetweenAttempt = 5.seconds) { (attempt: Int) =>
       deploymentStatusF(deploymentId)
     }
     Await.result(res, 10.minutes)
-  }
 
   /**
    * https://central.sonatype.org/publish/publish-portal-api/#verify-status-of-the-deployment
    */
-  private def deploymentStatusF(deploymentId: String): Future[PublisherStatus] = {
+  private def deploymentStatusF(deploymentId: String): Future[PublisherStatus] =
     val req = Gigahorse
       .url(s"${baseUrl}/publisher/status")
       .addQueryString("id" -> deploymentId)
       .post("", StandardCharsets.UTF_8)
     http.run(reqTransform(req), SonaClient.asPublisherStatus)
-  }
 
   /**
    * Retry future function on any error.
    */
   private def retryF[A1](maxAttempt: Int, waitDurationBetweenAttempt: FiniteDuration)(
       f: Int => Future[A1]
-  ): Future[A1] = {
+  ): Future[A1] =
     import scala.concurrent.ExecutionContext.Implicits.*
-    def impl(retry: Int): Future[A1] = {
+    def impl(retry: Int): Future[A1] =
       val res = f(retry + 1)
       res.recoverWith {
         case _ if retry < maxAttempt =>
           sleep(waitDurationBetweenAttempt).flatMap(_ => impl(retry + 1))
       }
-    }
     impl(0)
-  }
 
   private def awaitWithMessage[A1](
       f: Future[A1],
       msg: String,
       log: Logger,
       awaitDuration: FiniteDuration,
-  ): A1 = {
+  ): A1 =
     import scala.concurrent.ExecutionContext.Implicits.*
     def logLoop(attempt: Int): Unit =
-      if (!f.isCompleted) {
-        if (attempt > 0) {
-          log.info(msg)
-        }
+      if !f.isCompleted then
+        if attempt > 0 then log.info(msg)
         sleep(30.second).foreach(_ => logLoop(attempt + 1))
-      } else ()
+      else ()
     logLoop(0)
     Await.result(f, awaitDuration)
-  }
 
   def close(): Unit = http.close()
 
@@ -184,15 +172,14 @@ class SonaClient(reqTransform: Request => Request, uploadRequestTimeout: FiniteD
         Thread.sleep(duration.toMillis)
       }
     }
-}
+end SonaClient
 
-object Sona {
+object Sona:
   def host: String = SonaClient.host
   def oauthClient(userName: String, userToken: String, uploadRequestTimeout: FiniteDuration): Sona =
     new Sona(SonaClient.oauthClient(userName, userToken, uploadRequestTimeout))
-}
 
-object SonaClient {
+object SonaClient:
   import sbt.internal.sona.codec.JsonProtocol.given
   val host: String = "central.sonatype.com"
   val baseUrl: String = s"https://$host/api/v1"
@@ -206,11 +193,10 @@ object SonaClient {
    * or throws a [[SonaStatusError]] with both the status code and response body on failure.
    * This provides more detailed error information than [[gigahorse.StatusError]].
    */
-  val asStringWithErrorBody: FullResponse => String = { response =>
+  val asStringWithErrorBody: FullResponse => String = response =>
     val body = response.bodyAsString
-    if (response.status >= 200 && response.status < 300) body
+    if response.status >= 200 && response.status < 300 then body
     else throw new SonaStatusError(response.status, body)
-  }
   def oauthClient(
       userName: String,
       userToken: String,
@@ -225,20 +211,18 @@ object SonaClient {
       deploymentId: String,
       errors: Option[JValue],
       log: Logger
-  ): String = {
+  ): String =
     val errorsText = errors.map(presentDeploymentValidationErrors(_, log))
-    val errorsMessagePart = errorsText match {
+    val errorsMessagePart = errorsText match
       case Some(value) =>
         s" with validation errors:\n$value"
       case None => ""
-    }
     s"deployment $deploymentId failed$errorsMessagePart"
-  }
 
   import sbt.internal.sona.SonaClient.PrettyPrint.*
 
-  private def presentDeploymentValidationErrors(errorsNode: JValue, log: Logger): String = {
-    PackageDeploymentValidationError.parse(errorsNode) match {
+  private def presentDeploymentValidationErrors(errorsNode: JValue, log: Logger): String =
+    PackageDeploymentValidationError.parse(errorsNode) match
       case Some(errors) =>
         val errorsPresented: Seq[String] = errors.map {
           case PackageDeploymentValidationError(packageDescriptor, packageErrors) =>
@@ -253,34 +237,28 @@ object SonaClient {
           "Sonatype deployment validation errors JSON format has changed. Please update to the latest sbt version or report the issue to the sbt project"
         )
         PrettyPrinter(errorsNode)
-    }
-  }
 
-  private object PrettyPrint {
+  private object PrettyPrint:
     def asList(lines: Seq[String]): String =
       lines.map("- " + _).mkString("\n")
 
-    def indent(text: String, indentSize: Int): String = {
+    def indent(text: String, indentSize: Int): String =
       val indent = " " * indentSize
       text.linesIterator.map(indent + _).mkString("\n")
-    }
-  }
-}
+end SonaClient
 
 private case class OAuthClient(userName: String, userToken: String)
-    extends Function1[Request, Request] {
+    extends Function1[Request, Request]:
   val base64Credentials =
     Base64.getEncoder.encodeToString(s"${userName}:${userToken}".getBytes(StandardCharsets.UTF_8))
   def apply(request: Request): Request =
     request.addHeaders("Authorization" -> s"Bearer $base64Credentials")
   override def toString: String = "OAuthClient(****)"
-}
 
 sealed trait PublishingType
-object PublishingType {
+object PublishingType:
   case object Automatic extends PublishingType
   case object UserManaged extends PublishingType
-}
 
 /**
  * Exception thrown when an HTTP request to the Sonatype API fails with a non-2xx status.
@@ -292,6 +270,6 @@ object PublishingType {
  */
 class SonaStatusError(val status: Int, val body: String)
     extends RuntimeException(
-      if (body.nonEmpty) s"Unexpected status: $status\n$body"
+      if body.nonEmpty then s"Unexpected status: $status\n$body"
       else s"Unexpected status: $status"
     )
diff --git a/main-actions/src/test/scala/sbt/CacheIvyTest.scala b/main-actions/src/test/scala/sbt/CacheIvyTest.scala
index 3294d975d..d66e7a008 100644
--- a/main-actions/src/test/scala/sbt/CacheIvyTest.scala
+++ b/main-actions/src/test/scala/sbt/CacheIvyTest.scala
@@ -14,36 +14,37 @@ import Prop.*
 import sbt.librarymanagement.*
 import sjsonnew.shaded.scalajson.ast.unsafe.JValue
 
-class CacheIvyTest extends Properties("CacheIvy") {
+class CacheIvyTest extends Properties("CacheIvy"):
   import sbt.util.{ CacheStore, SingletonCache }
   import SingletonCache.given
 
   import sjsonnew.*
   import sjsonnew.support.scalajson.unsafe.Converter
 
-  private class InMemoryStore(converter: SupportConverter[JValue]) extends CacheStore {
+  private class InMemoryStore(converter: SupportConverter[JValue]) extends CacheStore:
     private var content: JValue = scala.compiletime.uninitialized
     override def delete(): Unit = ()
     override def close(): Unit = ()
 
     override def read[T: JsonReader](): T =
       try converter.fromJsonUnsafe[T](content)
-      catch { case t: Throwable => t.printStackTrace(); throw t }
+      catch
+        case t: Throwable =>
+          t.printStackTrace()
+          throw t
 
     override def read[T: JsonReader](default: => T): T =
       try read[T]()
-      catch { case _: Throwable => default }
+      catch case _: Throwable => default
 
     override def write[T: JsonWriter](value: T): Unit =
       content = converter.toJsonUnsafe(value)
-  }
 
   private def testCache[T, U](
       f: (SingletonCache[T], CacheStore) => U
-  )(using cache: SingletonCache[T]): U = {
+  )(using cache: SingletonCache[T]): U =
     val store = new InMemoryStore(Converter)
     f(cache, store)
-  }
 
   private def cachePreservesEquality[T: JsonFormat](
       m: T,
@@ -56,19 +57,18 @@ class CacheIvyTest extends Properties("CacheIvy") {
   }
 
   given arbConfigRef: Arbitrary[ConfigRef] = Arbitrary(
-    for {
-      n <- Gen.alphaStr
-    } yield ConfigRef(n)
+    for n <- Gen.alphaStr
+    yield ConfigRef(n)
   )
 
   given arbExclusionRule: Arbitrary[InclExclRule] = Arbitrary(
-    for {
+    for
       o <- Gen.alphaStr
       n <- Gen.alphaStr
       a <- Gen.alphaStr
       v <- arbCrossVersion.arbitrary
       cs <- arbitrary[List[ConfigRef]]
-    } yield InclExclRule(o, n, a, cs.toVector, v)
+    yield InclExclRule(o, n, a, cs.toVector, v)
   )
 
   given arbCrossVersion: Arbitrary[CrossVersion] = Arbitrary {
@@ -77,16 +77,15 @@ class CacheIvyTest extends Properties("CacheIvy") {
   }
 
   given arbArtifact: Arbitrary[Artifact] = Arbitrary {
-    for {
-      (n, t, e, cls) <- arbitrary[(String, String, String, String)]
-    } yield Artifact(n, t, e, cls) // keep it simple
+    for (n, t, e, cls) <- arbitrary[(String, String, String, String)]
+    yield Artifact(n, t, e, cls) // keep it simple
   }
 
   given arbModuleID: Arbitrary[ModuleID] = Arbitrary {
-    for {
+    for
       o <- Gen.identifier
       n <- Gen.identifier
-      r <- for { n <- Gen.numChar; ns <- Gen.numStr } yield s"$n$ns"
+      r <- for n <- Gen.numChar; ns <- Gen.numStr yield s"$n$ns"
       cs <- arbitrary[Option[String]]
       branch <- arbitrary[Option[String]]
       isChanging <- arbitrary[Boolean]
@@ -97,7 +96,7 @@ class CacheIvyTest extends Properties("CacheIvy") {
       inclusions <- Gen.listOf(arbitrary[InclExclRule])
       extraAttributes <- Gen.mapOf(arbitrary[(String, String)])
       crossVersion <- arbitrary[CrossVersion]
-    } yield ModuleID(
+    yield ModuleID(
       organization = o,
       name = n,
       revision = r,
@@ -115,22 +114,19 @@ class CacheIvyTest extends Properties("CacheIvy") {
   }
 
   property("moduleIDFormat") = forAll { (m: ModuleID) =>
-    def str(m: ModuleID) = {
+    def str(m: ModuleID) =
       import m.*
       s"ModuleID($organization, ${m.name}, $revision, $configurations, $isChanging, $isTransitive, $isForce, $explicitArtifacts, $exclusions, " +
         s"$inclusions, $extraAttributes, $crossVersion, $branchName)"
-    }
-    def eq(a: ModuleID, b: ModuleID): Prop = {
+    def eq(a: ModuleID, b: ModuleID): Prop =
       def rest = a.withCrossVersion(b.crossVersion) == b
-      (a.crossVersion, b.crossVersion) match {
+      (a.crossVersion, b.crossVersion) match
         case (_: Disabled, _: Disabled) => rest
         case (_: Binary, _: Binary)     => rest
         case (_: Full, _: Full)         => rest
         case (a, b)                     => Prop(false) :| s"CrossVersions don't match: $a vs $b"
-      }
 
-    }
     import sbt.librarymanagement.LibraryManagementCodec.given
     cachePreservesEquality(m, eq, str)
   }
-}
+end CacheIvyTest
diff --git a/main-actions/src/test/scala/sbt/internal/sona/SonaClientTest.scala b/main-actions/src/test/scala/sbt/internal/sona/SonaClientTest.scala
index a376519b3..b30ffeff8 100644
--- a/main-actions/src/test/scala/sbt/internal/sona/SonaClientTest.scala
+++ b/main-actions/src/test/scala/sbt/internal/sona/SonaClientTest.scala
@@ -123,10 +123,10 @@ final class RecordingLogger extends BasicLogger:
   private var events: List[LogEvent] = Nil
 
   def getEvents: List[LogEvent] = events.reverse
-  def trace(t: => Throwable): Unit = { events ::= new Trace(t) }
-  def log(level: Level.Value, message: => String): Unit = { events ::= new Log(level, message) }
-  def success(message: => String): Unit = { events ::= new Success(message) }
-  def logAll(es: Seq[LogEvent]): Unit = { events :::= es.toList }
+  def trace(t: => Throwable): Unit = events ::= new Trace(t)
+  def log(level: Level.Value, message: => String): Unit = events ::= new Log(level, message)
+  def success(message: => String): Unit = events ::= new Success(message)
+  def logAll(es: Seq[LogEvent]): Unit = events :::= es.toList
 
   def control(event: ControlEvent.Value, message: => String): Unit =
     events ::= new ControlEvent(event, message)
diff --git a/main-command/src/main/scala/sbt/BasicCommandStrings.scala b/main-command/src/main/scala/sbt/BasicCommandStrings.scala
index 0034d48de..fc583397f 100644
--- a/main-command/src/main/scala/sbt/BasicCommandStrings.scala
+++ b/main-command/src/main/scala/sbt/BasicCommandStrings.scala
@@ -11,7 +11,7 @@ package sbt
 import sbt.util.Level
 import sbt.internal.util.complete.HistoryCommands
 
-object BasicCommandStrings {
+object BasicCommandStrings:
   val HelpCommand: String = "help"
   val CompletionsCommand: String = "completions"
   val Exit: String = "exit"
@@ -64,14 +64,13 @@ $HelpCommand <regular expression>
   def exitBrief: String = "Terminates the remote client or the build when called from the console."
   def shutdownBrief: String = "Terminates the build."
 
-  def logLevelHelp: Help = {
+  def logLevelHelp: Help =
     val levels = Level.values.toSeq
     val levelList = levels.mkString(", ")
     val brief =
       ("<log-level>", "Sets the logging level to 'log-level'.  Valid levels: " + levelList)
     val detailed = levels.map(l => (l.toString, logLevelDetail(l))).toMap
     Help(brief, detailed)
-  }
 
   private def logLevelDetail(level: Level.Value): String =
     s"""$level
@@ -89,14 +88,13 @@ $HelpCommand <regular expression>
 """
 
   def runEarly(command: String): String = s"$EarlyCommand($command)"
-  private[sbt] def isEarlyCommand(s: String): Boolean = {
+  private[sbt] def isEarlyCommand(s: String): Boolean =
     val levelOptions = Level.values.toSeq flatMap { elem =>
       List("-" + elem, "--" + elem)
     }
     (s.startsWith(EarlyCommand + "(") && s.endsWith(")")) ||
     (levelOptions contains s) ||
     (s.startsWith("-" + AddPluginSbtFileCommand) || s.startsWith("--" + AddPluginSbtFileCommand))
-  }
 
   val EarlyCommand: String = "early"
   val EarlyCommandBrief: (String, String) =
@@ -108,11 +106,10 @@ $HelpCommand <regular expression>
   The order is preserved between all early commands, so `sbt "early(a)" "early(b)"` executes `a` and `b` in order.
 """
 
-  def addPluginSbtFileHelp(): Help = {
+  def addPluginSbtFileHelp(): Help =
     val brief =
       (s"--$AddPluginSbtFileCommand=<file>", "Adds the given *.sbt file to the plugin build.")
     Help(brief)
-  }
 
   val AddPluginSbtFileCommand: String = "addPluginSbtFile"
 
@@ -261,4 +258,4 @@ $AliasCommand name=
 
   private[sbt] val networkExecPrefix = "__"
   private[sbt] val DisconnectNetworkChannel = s"${networkExecPrefix}disconnectNetworkChannel"
-}
+end BasicCommandStrings
diff --git a/main-command/src/main/scala/sbt/BasicCommands.scala b/main-command/src/main/scala/sbt/BasicCommands.scala
index dd97d3deb..28fbc726f 100644
--- a/main-command/src/main/scala/sbt/BasicCommands.scala
+++ b/main-command/src/main/scala/sbt/BasicCommands.scala
@@ -41,7 +41,7 @@ import scala.collection.mutable.ListBuffer
 import scala.util.control.NonFatal
 import xsbti.VirtualFile
 
-object BasicCommands {
+object BasicCommands:
   lazy val allBasicCommands: Seq[Command] = Seq(
     nop,
     ignore,
@@ -79,29 +79,26 @@ object BasicCommands {
       token(l.toString)
     ) reduce (_ | _)
 
-  private def addPluginSbtFileParser: Parser[File] = {
+  private def addPluginSbtFileParser: Parser[File] =
     token(AddPluginSbtFileCommand) ~> (":" | "=" | Space.map(_.toString)) ~> (StringBasic).examples(
       "/some/extra.sbt"
     ) map {
       new File(_)
     }
-  }
 
-  private def addPluginSbtFileStringParser: Parser[String] = {
+  private def addPluginSbtFileStringParser: Parser[String] =
     token(
       token(AddPluginSbtFileCommand) ~ (":" | "=" | Space.map(_.toString)) ~ (StringBasic)
         .examples("/some/extra.sbt") map { case s1 ~ s2 ~ s3 =>
         s1 + s2 + s3
       }
     )
-  }
 
-  private def earlyParser: State => Parser[String] = (s: State) => {
+  private def earlyParser: State => Parser[String] = (s: State) =>
     val p1 = token(EarlyCommand + "(").flatMap(_ => otherCommandParser(s) <~ token(")"))
     val p2 = (token("-") | token("--")).flatMap(_ => levelParser)
     val p3 = (token("-") | token("--")).flatMap(_ => addPluginSbtFileStringParser)
     p1 | p2 | p3
-  }
 
   private def earlyHelp = Help(EarlyCommand, EarlyCommandBrief, EarlyCommandDetailed)
 
@@ -118,23 +115,21 @@ object BasicCommands {
 
   def help: Command = Command.make(HelpCommand, helpBrief, helpDetailed)(helpParser)
 
-  def helpParser(s: State): Parser[() => State] = {
+  def helpParser(s: State): Parser[() => State] =
     val h = s.definedCommands.foldLeft(Help.empty)((a, b) =>
       a ++ (try b.help(s)
-      catch { case NonFatal(_) => Help.empty })
+      catch case NonFatal(_) => Help.empty)
     )
     val helpCommands = h.detail.keySet
     val spacedArg = singleArgument(helpCommands).?
     applyEffect(spacedArg)(runHelp(s, h))
-  }
 
-  def runHelp(s: State, h: Help)(arg: Option[String]): State = {
+  def runHelp(s: State, h: Help)(arg: Option[String]): State =
     val message =
       try Help.message(h, arg)
-      catch { case NonFatal(ex) => ex.toString }
+      catch case NonFatal(ex) => ex.toString
     System.out.println(message)
     s
-  }
 
   def completionsCommand: Command =
     Command(CompletionsCommand, CompletionsBrief, CompletionsDetailed)(_ => completionsParser)(
@@ -144,27 +139,25 @@ object BasicCommands {
   @deprecated("No longer public", "1.1.1")
   def completionsParser(state: State): Parser[String] = completionsParser
 
-  private def completionsParser: Parser[String] = {
+  private def completionsParser: Parser[String] =
     val notQuoted = (NotQuoted ~ any.*) map { (nq, s) => nq + s }
     val quotedOrUnquotedSingleArgument = Space ~> (StringVerbatim | StringEscapable | notQuoted)
     token((quotedOrUnquotedSingleArgument ?? "").examples("", " "))
-  }
 
-  def runCompletions(state: State)(input: String): State = {
+  def runCompletions(state: State)(input: String): State =
     Parser.completions(state.combinedParser, input, 9).get map { c =>
-      if (c.isEmpty) input else input + c.append
+      if c.isEmpty then input else input + c.append
     } foreach { c =>
       System.out.println("[completions] " + c.replaceAll("\n", " "))
     }
     state
-  }
 
   private[sbt] def multiParserImpl(state: Option[State]): Parser[List[String]] =
     multiParserImpl(state, "alias" :: Nil)
   private[sbt] def multiParserImpl(
       state: Option[State],
       exclude: Seq[String]
-  ): Parser[List[String]] = {
+  ): Parser[List[String]] =
     val nonSemi = charClass(_ != ';', "not ';'")
     val nonDelim = charClass(c => c != '"' && c != '{' && c != '}', label = "not '\"', '{', '}'")
     // Accept empty commands to simplify the parser.
@@ -174,10 +167,9 @@ object BasicCommands {
 
     val completionParser: Option[Parser[String]] =
       state.map(s => (matched(s.nonMultiParser) & cmdPart) | cmdPart)
-    val cmdParser = {
+    val cmdParser =
       val parser = completionParser.getOrElse(cmdPart).map(_.trim)
       exclude.foldLeft(parser) { (p, e) => p & not(OptSpace ~ s"$e ", s"!$e").examples() }
-    }
     val multiCmdParser: Parser[String] = token(';') ~> OptSpace ~> cmdParser
 
     /*
@@ -188,30 +180,27 @@ object BasicCommands {
      * we wanted to relax that restriction, then we could just replace the flatMap below with
      * `rest.filterNot(_.isEmpty)`.
      */
-    def validateCommands(s: Seq[String]): Parser[List[String]] = {
+    def validateCommands(s: Seq[String]): Parser[List[String]] =
       val result = new ListBuffer[String]
       val it = s.iterator
       var fail = false
-      while (it.hasNext && !fail) {
-        it.next() match {
+      while it.hasNext && !fail do
+        it.next() match
           case ""   => fail = it.hasNext; ()
           case next => result += next; ()
-        }
-      }
-      if (fail) Parser.failure(s"Couldn't parse empty commands in ${s.mkString(";")}")
+      if fail then Parser.failure(s"Couldn't parse empty commands in ${s.mkString(";")}")
       else Parser.success(result.toList)
-    }
 
     (cmdParser ~ multiCmdParser.+)
       .flatMap {
         case ("", rest) => validateCommands(rest)
         case (p, rest)  => validateCommands(rest).map(p :: _)
       }
-  }
+  end multiParserImpl
 
   def multiParser(s: State): Parser[List[String]] = multiParserImpl(Some(s))
 
-  def multiApplied(state: State): Parser[() => State] = {
+  def multiApplied(state: State): Parser[() => State] =
     Command.applyEffect(multiParserImpl(Some(state))) {
       // the (@ _ :: _) ensures tail length >= 1.
       case commands @ first :: (tail @ _ :: _) =>
@@ -236,7 +225,7 @@ object BasicCommands {
         // fall back to prefixing the multi commands to the state.
         //
         state.nonMultiCommands.view.flatMap { command =>
-          command.nameOption match {
+          command.nameOption match
             case Some(commandName) if first.startsWith(commandName) =>
               // A lot of commands expect leading semicolons in their parsers. In order to
               // ensure that they are multi-command capable, we strip off any leading spaces.
@@ -251,14 +240,11 @@ object BasicCommands {
                 (first.drop(commandName.length).trim :: Nil ::: tail).mkString(";")
               parse(commandArgs, command.parser(state)).toOption
             case _ => none[() => State]
-          }
-        }.headOption match {
+        }.headOption match
           case Some(s) => s()
           case _       => commands ::: state
-        }
       case commands => commands ::: state
     }
-  }
 
   val multi: Command =
     Command.custom(multiApplied, Help(Multi, MultiBrief, MultiDetailed), Multi)
@@ -271,7 +257,7 @@ object BasicCommands {
 
   def ifLast: Command =
     Command(IfLast, Help.more(IfLast, IfLastDetailed))(otherCommandParser)((s, arg) =>
-      if (s.remainingCommands.isEmpty) arg :: s else s
+      if s.remainingCommands.isEmpty then arg :: s else s
     )
 
   def append: Command =
@@ -294,14 +280,14 @@ object BasicCommands {
   def popOnFailure: Command = Command.command(PopOnFailure) { s =>
     val stack = s.get(OnFailureStack).getOrElse(nil)
     val updated =
-      if (stack.isEmpty) s.remove(OnFailureStack) else s.put(OnFailureStack, stack.tail)
+      if stack.isEmpty then s.remove(OnFailureStack) else s.put(OnFailureStack, stack.tail)
     updated.copy(onFailure = stack.headOption.flatten)
   }
 
   def reboot: Command =
     Command(RebootCommand, Help.more(RebootCommand, RebootDetailed))(_ => rebootOptionParser) {
       case (s, (full, currentOnly)) =>
-        val option = if (full) " full" else if (currentOnly) " dev" else ""
+        val option = if full then " full" else if currentOnly then " dev" else ""
         RebootNetwork :: s"$RebootImpl$option" :: s
     }
   def rebootImpl: Command =
@@ -313,11 +299,10 @@ object BasicCommands {
   @deprecated("Use rebootOptionParser", "1.1.0")
   def rebootParser(s: State): Parser[Boolean] = rebootOptionParser map { case (full, _) => full }
 
-  private[sbt] def rebootOptionParser: Parser[(Boolean, Boolean)] = {
+  private[sbt] def rebootOptionParser: Parser[(Boolean, Boolean)] =
     val fullOption = "full" ^^^ ((true, false))
     val devOption = "dev" ^^^ ((false, true))
     token(Space ~> (fullOption | devOption)) ?? ((false, false))
-  }
 
   def call: Command =
     Command(ApplyCommand, Help.more(ApplyCommand, ApplyDetailed))(_ => callParser) {
@@ -325,10 +310,10 @@ object BasicCommands {
         val parentLoader = getClass.getClassLoader
         def argsStr = args mkString ", "
         def cpStr = cp mkString File.pathSeparator
-        def fromCpStr = if (cp.isEmpty) "" else s" from $cpStr"
+        def fromCpStr = if cp.isEmpty then "" else s" from $cpStr"
         state.log.info(s"Applying State transformations $argsStr$fromCpStr")
         val loader =
-          if (cp.isEmpty) parentLoader else toLoader(cp.map(f => Paths.get(f)), parentLoader)
+          if cp.isEmpty then parentLoader else toLoader(cp.map(f => Paths.get(f)), parentLoader)
         val loaded =
           args.map(arg => ModuleUtilities.getObject(arg, loader).asInstanceOf[State => State])
         loaded.foldLeft(state)((s, obj) => obj(s))
@@ -337,14 +322,13 @@ object BasicCommands {
   def callParser: Parser[(Seq[String], Seq[String])] =
     token(Space) ~> ((classpathOptionParser ?? nilSeq) ~ rep1sep(className, token(Space)))
 
-  private def className: Parser[String] = {
+  private def className: Parser[String] =
     val base = StringBasic & not('-' ~> any.*, "Class name cannot start with '-'.")
     def single(s: String) = Completions.single(Completion.displayOnly(s))
     val compl = TokenCompletions.fixed((seen, _) =>
-      if (seen.startsWith("-")) Completions.nil else single("<class name>")
+      if seen.startsWith("-") then Completions.nil else single("<class name>")
     )
     token(base, compl)
-  }
 
   private def classpathOptionParser: Parser[Seq[String]] =
     token(("-cp" | "-classpath") ~> Space) ~> classpathStrings <~ token(Space)
@@ -353,18 +337,16 @@ object BasicCommands {
     token(StringBasic.map(s => IO.pathSplit(s).toSeq), "<classpath>")
 
   def exit: Command = Command.command(TerminateAction, exitBrief, exitBrief) { s =>
-    s.source match {
+    s.source match
       case Some(c) if c.channelName.startsWith("network") =>
         s"${DisconnectNetworkChannel} ${c.channelName}" :: s
       case _ => s.exit(true)
-    }
   }
   def shutdown: Command = Command.command(Shutdown, shutdownBrief, shutdownBrief) { s =>
-    s.source match {
+    s.source match
       case Some(c) if c.channelName.startsWith("network") =>
         s"${DisconnectNetworkChannel} ${c.channelName}" :: (Exec(Shutdown, None) +: s)
       case _ => s.exit(true)
-    }
   }
 
   def history: Command = Command.custom(historyParser, BasicCommandStrings.historyHelp)
@@ -373,12 +355,11 @@ object BasicCommands {
     Command.applyEffect(HistoryCommands.actionParser) { histFun =>
       val hp = s.get(historyPath).flatten
       val lines = hp.toList.flatMap(p => IO.readLines(p)).toIndexedSeq
-      histFun(CHistory(lines, hp)) match {
+      histFun(CHistory(lines, hp)) match
         case Some(commands) =>
           commands foreach println // printing is more appropriate than logging
           (commands ::: s).continue
         case None => s.fail
-      }
     }
 
   def oldshell: Command = Command.command(OldShell, Help.more(Shell, OldShellDetailed)) { s =>
@@ -388,7 +369,7 @@ object BasicCommands {
       case None     => "> "
     val reader = new FullReader(history, s.combinedParser, LineReader.HandleCONT, Terminal.console)
     val line = reader.readLine(prompt)
-    line match {
+    line match
       case Some(line) =>
         val newState = s
           .copy(
@@ -396,9 +377,8 @@ object BasicCommands {
             remainingCommands = Exec(line, s.source) +: Exec(OldShell, None) +: s.remainingCommands
           )
           .setInteractive(true)
-        if (line.trim.isEmpty) newState else newState.clearGlobalLog
+        if line.trim.isEmpty then newState else newState.clearGlobalLog
       case None => s.setInteractive(false)
-    }
   }
 
   def client: Command =
@@ -407,31 +387,28 @@ object BasicCommands {
   def clientParser: Parser[Seq[String]] =
     (token(Space) ~> repsep(StringBasic, token(Space))) | (token(EOF).map(_ => nilSeq))
 
-  def runClient(s0: State, inputArg: Seq[String]): State = {
+  def runClient(s0: State, inputArg: Seq[String]): State =
     val arguments = inputArg.toList ++
-      (s0.remainingCommands match {
+      (s0.remainingCommands match
         case e :: Nil if e.commandLine == "shell" => nil
-        case xs                                   => xs map (_.commandLine)
-      })
+        case xs                                   => xs map (_.commandLine))
     NetworkClient.run(s0.configuration, arguments)
     TerminateAction :: s0.copy(remainingCommands = Nil)
-  }
 
   def read: Command =
     Command(ReadCommand, Help.more(ReadCommand, ReadDetailed))(readParser)(doRead(_)(_))
 
-  def readParser(s: State): Parser[Either[Int, Seq[File]]] = {
+  def readParser(s: State): Parser[Either[Int, Seq[File]]] =
     val files = (token(Space) ~> fileParser(s.baseDir)).+
     val portAndSuccess = token(OptSpace) ~> Port
     portAndSuccess || files
-  }
 
   def doRead(s: State)(arg: Either[Int, Seq[File]]): State =
-    arg match {
+    arg match
       case Left(portAndSuccess) =>
         val port = math.abs(portAndSuccess)
         val previousSuccess = portAndSuccess >= 0
-        readMessage(port, previousSuccess) match {
+        readMessage(port, previousSuccess) match
           case Some(message) =>
             (message :: (ReadCommand + " " + port) :: s).copy(
               onFailure = Some(Exec(ReadCommand + " " + (-port), s.source))
@@ -439,27 +416,23 @@ object BasicCommands {
           case None =>
             System.err.println("Connection closed.")
             s.fail
-        }
       case Right(from) =>
         val notFound = notReadable(from)
-        if (notFound.isEmpty)
+        if notFound.isEmpty then
           // this means that all commands from all files are loaded, parsed, & inserted before any are executed
           readLines(from).toList ::: s
-        else {
+        else
           s.log.error("Command file(s) not readable: \n\t" + notFound.mkString("\n\t"))
           s
-        }
-    }
 
-  private def readMessage(port: Int, previousSuccess: Boolean): Option[String] = {
+  private def readMessage(port: Int, previousSuccess: Boolean): Option[String] =
     // split into two connections because this first connection ends the previous communication
     xsbt.IPC.client(port) { _.send(previousSuccess.toString) }
     //   and this second connection starts the next communication
     xsbt.IPC.client(port) { ipc =>
       val message = ipc.receive
-      if (message eq null) None else Some(message)
+      if message eq null then None else Some(message)
     }
-  }
 
   def alias: Command =
     Command(AliasCommand, Help.more(AliasCommand, AliasDetailed)) { s =>
@@ -478,12 +451,11 @@ object BasicCommands {
       args: Option[(String, Option[Option[String]])],
       definedKeyNames: State => Set[String]
   ): State =
-    args match {
+    args match
       case Some(x ~ None) if !x.isEmpty   => printAlias(s, x.trim); s
       case Some(name ~ Some(None))        => removeAlias(s, name.trim)
       case Some(name ~ Some(Some(value))) => addAlias(s, name.trim, value.trim, definedKeyNames)
       case _                              => printAliases(s); s
-    }
   def addAlias(s: State, name: String, value: String): State =
     addAlias(s, name, value, _ => Set.empty)
 
@@ -522,15 +494,16 @@ object BasicCommands {
   def isAliasNamed(name: String, c: Command): Boolean = isNamed(name, getAlias(c))
 
   def isNamed(name: String, alias: Option[(String, String)]): Boolean =
-    alias match { case None => false; case Some((n, _)) => name == n }
+    alias match
+      case None         => false;
+      case Some((n, _)) => name == n
 
   def getAlias(c: Command): Option[(String, String)] = c.tags.get(CommandAliasKey)
   def printAlias(s: State, name: String): Unit = printAliases(aliases(s, (n, _) => n == name))
   def printAliases(s: State): Unit = printAliases(allAliases(s))
 
   def printAliases(as: Seq[(String, String)]): Unit =
-    for ((name, value) <- as)
-      println("\t" + name + " = " + value)
+    for (name, value) <- as do println("\t" + name + " = " + value)
 
   def aliasNames(s: State): Seq[String] = allAliases(s).map(_._1)
   def allAliases(s: State): Seq[(String, String)] = aliases(s, (_, _) => true)
@@ -542,7 +515,7 @@ object BasicCommands {
       .make(name, (name, s"'$value'"), s"Alias of '$value'")(aliasBody(name, value))
       .tag(CommandAliasKey, (name, value))
 
-  def aliasBody(name: String, value: String)(state: State): Parser[() => State] = {
+  def aliasBody(name: String, value: String)(state: State): Parser[() => State] =
     val aliasRemoved = removeAlias(state, name)
     // apply the alias value to the commands of `state` except for the alias to avoid recursion (#933)
     val partiallyApplied = Parser(aliasRemoved.combinedParser)(value)
@@ -552,15 +525,13 @@ object BasicCommands {
     // by scheduling the expanded alias instead of directly executing,
     // we get errors on the expanded string (#598)
     arg.map(str => () => (value + str) :: state)
-  }
 
   def delegateToAlias(name: String, orElse: Parser[() => State])(
       state: State
   ): Parser[() => State] =
-    aliases(state, (nme, _) => nme == name).headOption match {
+    aliases(state, (nme, _) => nme == name).headOption match
       case None         => orElse
       case Some((n, v)) => aliasBody(n, v)(state)
-    }
 
   val CommandAliasKey: AttributeKey[(String, String)] =
     AttributeKey[(String, String)](
@@ -572,37 +543,31 @@ object BasicCommands {
     (key: Parser[String]).examples() ~> " ".examples() ~> matched(any.*).examples()
   def reportResultsCommand =
     Command.arb(_ => reportParser(ReportResult)) { (state, id) =>
-      val newState = state.get(execMap) match {
+      val newState = state.get(execMap) match
         case Some(m) => state.put(execMap, m - id)
         case _       => state
-      }
-      newState.get(execResults) match {
+      newState.get(execResults) match
         case Some(m) if m.contains(id) => state.put(execResults, m - id)
         case _                         => state.fail
-      }
     }
   def mapExecCommand =
     Command.arb(_ => reportParser(MapExec)) { (state, mapping) =>
-      mapping.split(" ") match {
+      mapping.split(" ") match
         case Array(key, value) =>
-          state.get(execMap) match {
+          state.get(execMap) match
             case Some(m) => state.put(execMap, m + (key -> value))
             case None    => state.put(execMap, Map(key -> value))
-          }
         case _ => state
-      }
     }
   def completeExecCommand =
     Command.arb(_ => reportParser(CompleteExec)) { (state, id) =>
-      val newState = state.get(execResults) match {
+      val newState = state.get(execResults) match
         case Some(m) => state.put(execResults, m + (id -> true))
         case _       => state.put(execResults, Map(id -> true))
-      }
-      newState.get(execMap) match {
+      newState.get(execMap) match
         case Some(m) => newState.put(execMap, m - id)
         case _       => newState
-      }
     }
   private[sbt] val execResults = AttributeKey[Map[String, Boolean]]("execResults", Int.MaxValue)
   private[sbt] val execMap = AttributeKey[Map[String, String]]("execMap", Int.MaxValue)
-}
+end BasicCommands
diff --git a/main-command/src/main/scala/sbt/BasicKeys.scala b/main-command/src/main/scala/sbt/BasicKeys.scala
index bbb2a4029..962d7214a 100644
--- a/main-command/src/main/scala/sbt/BasicKeys.scala
+++ b/main-command/src/main/scala/sbt/BasicKeys.scala
@@ -19,7 +19,7 @@ import sbt.util.{ ActionCacheStore, Level }
 import scala.concurrent.duration.FiniteDuration
 import xsbti.{ FileConverter, VirtualFile }
 
-object BasicKeys {
+object BasicKeys:
   val historyPath = AttributeKey[Option[File]](
     "history",
     "The location where command line history is persisted.",
@@ -178,6 +178,6 @@ object BasicKeys {
     "Toggles whether or not to close system in, out and error when the server starts.",
     1000
   )
-}
+end BasicKeys
 
 case class TemplateResolverInfo(module: ModuleID, implementationClass: String)
diff --git a/main-command/src/main/scala/sbt/Command.scala b/main-command/src/main/scala/sbt/Command.scala
index e0606156c..d7e5d0288 100644
--- a/main-command/src/main/scala/sbt/Command.scala
+++ b/main-command/src/main/scala/sbt/Command.scala
@@ -21,25 +21,23 @@ import sbt.internal.util.Util.nilSeq
  * This means that a command can look at or modify other sbt settings, for example.
  * Typically you would resort to a command when you need to do something that's impossible in a regular task.
  */
-sealed trait Command {
+sealed trait Command:
   def help: State => Help
   def parser: State => Parser[() => State]
 
   def tags: AttributeMap
   def tag[T](key: AttributeKey[T], value: T): Command
 
-  def nameOption: Option[String] = this match {
+  def nameOption: Option[String] = this match
     case sc: SimpleCommand => Some(sc.name)
     case _                 => None
-  }
-}
 
 private[sbt] final class SimpleCommand(
     val name: String,
     private[sbt] val help0: Help,
     val parser: State => Parser[() => State],
     val tags: AttributeMap
-) extends Command {
+) extends Command:
 
   assert(Command.validID(name), s"'$name' is not a valid command name.")
 
@@ -49,21 +47,19 @@ private[sbt] final class SimpleCommand(
     new SimpleCommand(name, help0, parser, tags.put(key, value))
 
   override def toString = s"SimpleCommand($name)"
-}
 
 private[sbt] final class ArbitraryCommand(
     val parser: State => Parser[() => State],
     val help: State => Help,
     val tags: AttributeMap,
     override val nameOption: Option[String]
-) extends Command {
+) extends Command:
   def this(parser: State => Parser[() => State], help: State => Help, tags: AttributeMap) =
     this(parser, help, tags, None)
   def tag[T](key: AttributeKey[T], value: T): ArbitraryCommand =
     new ArbitraryCommand(parser, help, tags.put(key, value))
-}
 
-object Command {
+object Command:
   import DefaultParsers.*
 
   // Lowest-level command construction
@@ -148,10 +144,9 @@ object Command {
   )(effect: (State, T) => State): State => Parser[() => State] =
     s => applyEffect(parser(s))(t => effect(s, t))
 
-  def combine(cmds: Seq[Command]): State => Parser[() => State] = {
+  def combine(cmds: Seq[Command]): State => Parser[() => State] =
     val (simple, arbs) = separateCommands(cmds)
     state => arbs.map(_.parser(state)).foldLeft(simpleParser(simple)(state))(_ | _)
-  }
 
   private def separateCommands(
       cmds: Seq[Command]
@@ -163,43 +158,38 @@ object Command {
   def simpleParser(cmds: Seq[SimpleCommand]): State => Parser[() => State] =
     simpleParser(cmds.map(sc => (sc.name, argParser(sc))).toMap)
 
-  private def argParser(sc: SimpleCommand): State => Parser[() => State] = {
+  private def argParser(sc: SimpleCommand): State => Parser[() => State] =
     def usageError = s"${sc.name} usage:" + Help.message(sc.help0, None)
     s => (Parser.softFailure(usageError, definitive = true): Parser[() => State]) | sc.parser(s)
-  }
 
   def simpleParser(
       commandMap: Map[String, State => Parser[() => State]]
   ): State => Parser[() => State] =
     state =>
       token(OpOrID.examples(commandMap.keys.toSet)).flatMap: id =>
-        (commandMap get id) match {
+        (commandMap get id) match
           case None    => failure(invalidValue("command", commandMap.keys)(id))
           case Some(c) => c(state)
-        }
 
   // overload instead of default parameter to keep binary compatibility
   @deprecated("Use overload that takes the onParseError callback", since = "1.9.4")
   def process(command: String, state: State): State = process(command, state, _ => ())
 
-  def process(command: String, state: State, onParseError: String => Unit): State = {
-    (if (command.contains(";")) parse(command, state.combinedParser)
-     else parse(command, state.nonMultiParser)) match {
+  def process(command: String, state: State, onParseError: String => Unit): State =
+    (if command.contains(";") then parse(command, state.combinedParser)
+     else parse(command, state.nonMultiParser)) match
       case Right(s)     => s() // apply command.  command side effects happen here
       case Left(errMsg) =>
         state.log.error(errMsg)
         onParseError(errMsg)
         state.fail
-    }
-  }
 
   def invalidValue(label: String, allowed: Iterable[String])(value: String): String =
     s"Not a valid $label: $value" + similar(value, allowed)
 
-  def similar(value: String, allowed: Iterable[String]): String = {
-    val suggested = if (value.length > 2) suggestions(value, allowed.toSeq) else nilSeq
-    if (suggested.isEmpty) "" else suggested.mkString(" (similar: ", ", ", ")")
-  }
+  def similar(value: String, allowed: Iterable[String]): String =
+    val suggested = if value.length > 2 then suggestions(value, allowed.toSeq) else nilSeq
+    if suggested.isEmpty then "" else suggested.mkString(" (similar: ", ", ", ")")
 
   def suggestions(
       a: String,
@@ -227,29 +217,27 @@ object Command {
 
   def spacedC(name: String, c: Parser[Char]): Parser[String] =
     ((c & opOrIDSpaced(name)) ~ c.+) map { (f, rem) => (f +: rem).mkString }
-}
+end Command
 
-trait Help {
+trait Help:
   def detail: Map[String, String]
   def brief: Seq[(String, String)]
   def more: Set[String]
   def ++(o: Help): Help
-}
 
 private final class Help0(
     val brief: Seq[(String, String)],
     val detail: Map[String, String],
     val more: Set[String]
-) extends Help {
+) extends Help:
   def ++(h: Help): Help =
     new Help0(
       Help0.this.brief ++ h.brief,
       Map(Help0.this.detail.toSeq ++ h.detail.toSeq*),
       more ++ h.more
     )
-}
 
-object Help {
+object Help:
   val empty: Help = briefDetail(Nil)
 
   def apply(name: String, briefHelp: (String, String), detail: String): Help =
@@ -277,22 +265,18 @@ object Help {
   import CommandUtil.*
 
   def message(h: Help, arg: Option[String]): String =
-    arg match {
+    arg match
       case Some(x) => detail(x, h.detail)
       case None    =>
         val brief = aligned("  ", "   ", h.brief).mkString("\n", "\n", "\n")
         val more = h.more
-        if (more.isEmpty)
-          brief
-        else
-          brief + "\n" + moreMessage(more.toSeq.sorted)
-    }
+        if more.isEmpty then brief
+        else brief + "\n" + moreMessage(more.toSeq.sorted)
 
   def moreMessage(more: Seq[String]): String =
     more.mkString("More command help available using 'help <command>' for:\n  ", ", ", "\n")
-}
+end Help
 
-trait CommandDefinitions extends (State => State) {
+trait CommandDefinitions extends (State => State):
   def commands: Seq[Command] = ReflectUtilities.allValsC(this, classOf[Command]).values.toSeq
   def apply(s: State): State = s ++ commands
-}
diff --git a/main-command/src/main/scala/sbt/CommandUtil.scala b/main-command/src/main/scala/sbt/CommandUtil.scala
index c9a9ac7c6..f8124a672 100644
--- a/main-command/src/main/scala/sbt/CommandUtil.scala
+++ b/main-command/src/main/scala/sbt/CommandUtil.scala
@@ -19,12 +19,11 @@ import sbt.internal.util.Util.nilSeq
 import sbt.io.IO
 import sbt.io.syntax.*
 
-object CommandUtil {
+object CommandUtil:
   def readLines(files: Seq[File]): Seq[String] =
     files flatMap (IO.readLines(_)) flatMap processLine
-  def processLine(s: String): Option[String] = {
-    val s2 = s.trim; if (ignoreLine(s2)) None else Some(s2)
-  }
+  def processLine(s: String): Option[String] =
+    val s2 = s.trim; if ignoreLine(s2) then None else Some(s2)
   def ignoreLine(s: String): Boolean = s.isEmpty || s.startsWith("#")
 
   private def canRead = (_: File).canRead
@@ -34,58 +33,48 @@ object CommandUtil {
   // slightly better fallback in case of older launcher
   def bootDirectory(state: State): File =
     try state.configuration.provider.scalaProvider.launcher.bootDirectory
-    catch { case _: NoSuchMethodError => new File(".").getAbsoluteFile }
+    catch case _: NoSuchMethodError => new File(".").getAbsoluteFile
 
   def aligned(pre: String, sep: String, in: Seq[(String, String)]): Seq[String] =
-    if (in.isEmpty) nilSeq
-    else {
+    if in.isEmpty then nilSeq
+    else
       val width = in.iterator.map(_._1.length).max
-      for ((a, b) <- in) yield pre + fill(a, width) + sep + b
-    }
+      for (a, b) <- in yield pre + fill(a, width) + sep + b
 
   def fill(s: String, size: Int): String = s + " " * math.max(size - s.length, 0)
 
   def withAttribute[T](s: State, key: AttributeKey[T], ifMissing: String)(f: T => State): State =
-    s.get(key) match {
+    s.get(key) match
       case None =>
         s.log.error(ifMissing); s.fail
       case Some(nav) => f(nav)
-    }
 
-  def singleArgument(exampleStrings: Set[String]): Parser[String] = {
+  def singleArgument(exampleStrings: Set[String]): Parser[String] =
     val arg = (NotSpaceClass ~ any.*) map { (ns, s) => (ns +: s).mkString }
     token(Space) ~> token(arg.examples(exampleStrings))
-  }
 
   def detail(selected: String, detailMap: Map[String, String]): String =
-    detailMap.get(selected) match {
+    detailMap.get(selected) match
       case Some(exactDetail) => exactDetail
       case None              =>
-        try {
+        try
           val details = searchHelp(selected, detailMap)
-          if (details.isEmpty)
-            "No matches for regular expression '" + selected + "'."
-          else
-            layoutDetails(details)
-        } catch {
+          if details.isEmpty then "No matches for regular expression '" + selected + "'."
+          else layoutDetails(details)
+        catch
           case pse: PatternSyntaxException =>
             sys.error("Invalid regular expression (java.util.regex syntax).\n" + pse.getMessage)
-        }
-    }
 
-  def searchHelp(selected: String, detailMap: Map[String, String]): Map[String, String] = {
+  def searchHelp(selected: String, detailMap: Map[String, String]): Map[String, String] =
     val pattern = Pattern.compile(selected, HelpPatternFlags)
     detailMap flatMap { (k, v) =>
       val contentMatches = Highlight.showMatches(pattern)(v)
       val keyMatches = Highlight.showMatches(pattern)(k)
       val keyString = Highlight.bold(keyMatches getOrElse k)
       val contentString = contentMatches getOrElse v
-      if (keyMatches.isDefined || contentMatches.isDefined)
-        Seq((keyString, contentString))
-      else
-        nilSeq
+      if keyMatches.isDefined || contentMatches.isDefined then Seq((keyString, contentString))
+      else nilSeq
     }
-  }
 
   def layoutDetails(details: Map[String, String]): String =
     details.map { (k, v) => k + "\n\n  " + v }.mkString("\n", "\n\n", "\n")
@@ -94,4 +83,4 @@ object CommandUtil {
 
   private[sbt] def isSbtBuild(baseDir: File) =
     (baseDir / "project").exists() || (baseDir * "*.sbt").get().nonEmpty
-}
+end CommandUtil
diff --git a/main-command/src/main/scala/sbt/ExceptionCategory.scala b/main-command/src/main/scala/sbt/ExceptionCategory.scala
index 9fdf40eab..bf653171f 100644
--- a/main-command/src/main/scala/sbt/ExceptionCategory.scala
+++ b/main-command/src/main/scala/sbt/ExceptionCategory.scala
@@ -13,23 +13,19 @@ import scala.annotation.tailrec
 
 import sbt.internal.util.{ AlreadyHandledException, MessageOnlyException, UnprintableException }
 
-private[sbt] sealed abstract class ExceptionCategory {
+private[sbt] sealed abstract class ExceptionCategory:
   def isFull: Boolean = false
-}
-private[sbt] object ExceptionCategory {
+private[sbt] object ExceptionCategory:
 
-  @tailrec def apply(t: Throwable): ExceptionCategory = t match {
+  @tailrec def apply(t: Throwable): ExceptionCategory = t match
     case _: AlreadyHandledException | _: UnprintableException => AlreadyHandled
     case ite: InvocationTargetException                       =>
       val cause = ite.getCause
-      if (cause == null || cause == ite) new Full(ite) else apply(cause)
+      if cause == null || cause == ite then new Full(ite) else apply(cause)
     case _: MessageOnlyException => new MessageOnly(t.toString)
     case _                       => new Full(t)
-  }
 
   object AlreadyHandled extends ExceptionCategory
   final class MessageOnly(val message: String) extends ExceptionCategory
-  final class Full(val exception: Throwable) extends ExceptionCategory {
+  final class Full(val exception: Throwable) extends ExceptionCategory:
     override def isFull = true
-  }
-}
diff --git a/main-command/src/main/scala/sbt/Highlight.scala b/main-command/src/main/scala/sbt/Highlight.scala
index f54d320bc..42307bae2 100644
--- a/main-command/src/main/scala/sbt/Highlight.scala
+++ b/main-command/src/main/scala/sbt/Highlight.scala
@@ -13,19 +13,15 @@ import scala.Console.{ BOLD, RESET }
 
 import sbt.internal.util.Terminal as UTerminal
 
-object Highlight {
+object Highlight:
 
-  def showMatches(pattern: Pattern)(line: String): Option[String] = {
+  def showMatches(pattern: Pattern)(line: String): Option[String] =
     val matcher = pattern.matcher(line)
-    if (UTerminal.isColorEnabled) {
+    if UTerminal.isColorEnabled then
       // ANSI codes like \033[39m (normal text color) don't work on Windows
       val highlighted = matcher.replaceAll(scala.Console.RED + "$0" + RESET)
-      if (highlighted == line) None else Some(highlighted)
-    } else if (matcher.find)
-      Some(line)
-    else
-      None
-  }
+      if highlighted == line then None else Some(highlighted)
+    else if matcher.find then Some(line)
+    else None
   def bold(s: String) =
-    if (UTerminal.isColorEnabled) BOLD + s.replace(RESET, RESET + BOLD) + RESET else s
-}
+    if UTerminal.isColorEnabled then BOLD + s.replace(RESET, RESET + BOLD) + RESET else s
diff --git a/main-command/src/main/scala/sbt/MainControl.scala b/main-command/src/main/scala/sbt/MainControl.scala
index 3efb41ffa..b9ad2801a 100644
--- a/main-command/src/main/scala/sbt/MainControl.scala
+++ b/main-command/src/main/scala/sbt/MainControl.scala
@@ -10,17 +10,15 @@ package sbt
 
 import java.io.File
 
-final case class Exit(code: Int) extends xsbti.Exit {
+final case class Exit(code: Int) extends xsbti.Exit:
   require(code >= 0)
-}
 final case class Reboot(
     scalaVersion: String,
     argsList: Seq[String],
     app: xsbti.ApplicationID,
     baseDirectory: File
-) extends xsbti.Reboot {
+) extends xsbti.Reboot:
   def arguments = argsList.toArray
-}
 
 final case class ApplicationID(
     groupID: String,
@@ -30,12 +28,11 @@ final case class ApplicationID(
     components: Seq[String],
     crossVersionedValue: xsbti.CrossValue,
     extra: Seq[File]
-) extends xsbti.ApplicationID {
+) extends xsbti.ApplicationID:
   def mainComponents = components.toArray
   def classpathExtra = extra.toArray
   def crossVersioned = crossVersionedValue != xsbti.CrossValue.Disabled
-}
-object ApplicationID {
+object ApplicationID:
   def apply(delegate: xsbti.ApplicationID, newVersion: String): ApplicationID =
     apply(delegate).copy(version = newVersion)
   def apply(delegate: xsbti.ApplicationID): ApplicationID =
@@ -48,4 +45,3 @@ object ApplicationID {
       delegate.crossVersionedValue,
       delegate.classpathExtra.toSeq
     )
-}
diff --git a/main-command/src/main/scala/sbt/State.scala b/main-command/src/main/scala/sbt/State.scala
index ec575bc9a..29ea5163b 100644
--- a/main-command/src/main/scala/sbt/State.scala
+++ b/main-command/src/main/scala/sbt/State.scala
@@ -50,15 +50,14 @@ final case class State(
     globalLogging: GlobalLogging,
     currentCommand: Option[Exec],
     next: State.Next
-) extends Identity {
+) extends Identity:
   private[sbt] lazy val (multiCommands, nonMultiCommands) =
     definedCommands.partition(_.nameOption.contains(BasicCommandStrings.Multi))
   private[sbt] lazy val nonMultiParser = Command.combine(nonMultiCommands)(this)
   lazy val combinedParser: Parser[() => State] =
-    multiCommands.headOption match {
+    multiCommands.headOption match
       case Some(multi) => multi.parser(this) | nonMultiParser
       case _           => nonMultiParser
-    }
 
   def source: Option[CommandSource] =
     currentCommand match
@@ -68,16 +67,15 @@ final case class State(
     source match
       case Some(s) => s.channelName.startsWith("network")
       case _       => false
-}
+end State
 
-trait Identity {
+trait Identity:
   override final def hashCode = super.hashCode
   override final def equals(a: Any) = super.equals(a)
   override final def toString = super.toString
-}
 
 /** Convenience methods for State transformations and operations. */
-trait StateOps extends Any {
+trait StateOps extends Any:
   def process(f: (Exec, State) => State): State
 
   /** Schedules `commands` to be run before any remaining commands. */
@@ -193,13 +191,12 @@ trait StateOps extends Any {
 
   /** Create and register a class loader cache.  This should be called once at the application entry-point. */
   def initializeClassLoaderCache: State
-}
+end StateOps
 
-object State {
+object State:
   private class UncloseableURLLoader(cp: Seq[File], parent: ClassLoader)
-      extends URLClassLoader(Array.empty, parent) {
+      extends URLClassLoader(Array.empty, parent):
     override def getURLs: Array[URL] = cp.map(_.toURI.toURL).toArray
-  }
 
   /** Indicates where command execution should resume after a failure. */
   val FailureWall = BasicCommandStrings.FailureWall
@@ -225,26 +222,24 @@ object State {
    * @param executed the list of the most recently executed commands, with the most recent command first.
    * @param maxSize the maximum number of commands to keep, or 0 to keep an unlimited number.
    */
-  final class History private[State] (val executed: Seq[Exec], val maxSize: Int) {
+  final class History private[State] (val executed: Seq[Exec], val maxSize: Int):
 
     /** Adds `command` as the most recently executed command. */
-    def ::(command: Exec): History = {
+    def ::(command: Exec): History =
       val prependTo =
-        if (maxSize > 0 && executed.size >= maxSize) executed.take(maxSize - 1) else executed
+        if maxSize > 0 && executed.size >= maxSize then executed.take(maxSize - 1) else executed
       new History(command +: prependTo, maxSize)
-    }
 
     /** Changes the maximum number of commands kept, adjusting the current history if necessary. */
     def setMaxSize(size: Int): History =
-      new History(if (size <= 0) executed else executed.take(size), size)
+      new History(if size <= 0 then executed else executed.take(size), size)
     def currentOption: Option[Exec] = executed.headOption
     def previous: Option[Exec] = executed.drop(1).headOption
-  }
 
   /** Constructs an empty command History with a default, finite command limit. */
   def newHistory = new History(Vector.empty, HistoryCommands.MaxLines)
 
-  def defaultReload(state: State): Reboot = {
+  def defaultReload(state: State): Reboot =
     val app = state.configuration.provider
     new Reboot(
       app.scalaProvider.version,
@@ -252,7 +247,6 @@ object State {
       app.id,
       state.configuration.baseDirectory
     )
-  }
 
   /**
    * Builds the `early(...)` commands that add the extra plugin sbt files back after a reboot.
@@ -265,10 +259,9 @@ object State {
    */
   private[sbt] def addPluginSbtFileArguments(state: State): List[String] =
     state.get(BasicKeys.extraMetaSbtFiles).toList.flatten.distinct.map { vf =>
-      val path = vf match {
+      val path = vf match
         case f: xsbti.PathBasedFile => f.toPath.toString
         case f                      => f.id
-      }
       val command = s"${BasicCommandStrings.AddPluginSbtFileCommand}=${quote(path)}"
       s"${BasicCommandStrings.EarlyCommand}($command)"
     }
@@ -286,9 +279,9 @@ object State {
   def stateOps(s: State): StateOps = new StateOpsImpl(s)
 
   /** Provides operations and transformations on State. */
-  implicit class StateOpsImpl(val s: State) extends AnyVal with StateOps {
-    def process(f: (Exec, State) => State): State = {
-      def runCmd(cmd: Exec, remainingCommands: List[Exec]) = {
+  implicit class StateOpsImpl(val s: State) extends AnyVal with StateOps:
+    def process(f: (Exec, State) => State): State =
+      def runCmd(cmd: Exec, remainingCommands: List[Exec]) =
         log.debug(s"> $cmd")
         val s1 = s.copy(
           remainingCommands = remainingCommands,
@@ -296,11 +289,10 @@ object State {
           history = cmd :: s.history,
         )
         f(cmd, s1)
-      }
-      s.remainingCommands match {
+      s.remainingCommands match
         case Nil     => exit(true)
         case x :: xs =>
-          (x.execId, x.source) match {
+          (x.execId, x.source) match
             /*
              * If the command is coming from a network source, it might be a multi-command. To handle
              * that, we need to give the command a new exec id and wrap some commands around the
@@ -332,9 +324,8 @@ object State {
               val remaining = map :: cmd :: complete :: failureWall :: pop :: report :: xs
               runCmd(stash, remaining)
             case _ => runCmd(x, xs)
-          }
-      }
-    }
+      end match
+    end process
     def :::(newCommands: List[String]): State = ++:(newCommands map { Exec(_, s.source) })
     def ++:(newCommands: List[Exec]): State =
       s.copy(remainingCommands = newCommands ::: s.remainingCommands)
@@ -351,23 +342,21 @@ object State {
     def reboot(full: Boolean): State = reboot(full, false)
 
     /** Implementation of reboot. */
-    private[sbt] def reboot(full: Boolean, currentOnly: Boolean): State = {
+    private[sbt] def reboot(full: Boolean, currentOnly: Boolean): State =
       runExitHooks()
       val remaining: List[String] = s.remainingCommands.map(_.commandLine)
-      val fullRemaining = s.source match {
+      val fullRemaining = s.source match
         case Some(s) if s.channelName.startsWith("network") =>
           StartServer :: remaining.dropWhile(!_.startsWith(ReportResult)).tail ::: "shell" :: Nil
         case _ => remaining
-      }
       val arguments = State.addPluginSbtFileArguments(s) ::: fullRemaining
-      if (currentOnly) throw new RebootCurrent(arguments)
+      if currentOnly then throw new RebootCurrent(arguments)
       else throw new xsbti.FullReload(arguments.toArray, full)
-    }
 
     def reload = runExitHooks().setNext(new Return(defaultReload(s)))
     def clearGlobalLog = setNext(ClearGlobalLog)
     def keepLastLog = setNext(KeepLastLog)
-    def exit(ok: Boolean) = runExitHooks().setNext(new Return(Exit(if (ok) 0 else 1)))
+    def exit(ok: Boolean) = runExitHooks().setNext(new Return(Exit(if ok then 0 else 1)))
     def get[T](key: AttributeKey[T]) = s.attributes.get(key)
     def put[T](key: AttributeKey[T], value: T) = s.copy(attributes = s.attributes.put(key, value))
     def update[T](key: AttributeKey[T])(f: Option[T] => T): State = put(key, f(get(key)))
@@ -375,31 +364,25 @@ object State {
     def remove(key: AttributeKey[?]) = s.copy(attributes = s.attributes.remove(key))
     def log = s.globalLogging.full
     def handleError(t: Throwable): State = handleException(t, s, log)
-    def fail = {
+    def fail =
       val remaining = s.remainingCommands.dropWhile(c => c.commandLine != FailureWall)
-      if (remaining.isEmpty)
-        applyOnFailure(s, Nil, exit(ok = false))
-      else
-        applyOnFailure(s, remaining, s.copy(remainingCommands = remaining))
-    }
+      if remaining.isEmpty then applyOnFailure(s, Nil, exit(ok = false))
+      else applyOnFailure(s, remaining, s.copy(remainingCommands = remaining))
     private def applyOnFailure(s: State, remaining: List[Exec], noHandler: => State): State =
-      s.onFailure match {
+      s.onFailure match
         case Some(c) => s.copy(remainingCommands = c +: remaining, onFailure = None)
         case None    => noHandler
-      }
 
     def addExitHook(act: => Unit): State =
       s.copy(exitHooks = s.exitHooks + ExitHook(act))
-    def runExitHooks(): State = {
+    def runExitHooks(): State =
       ExitHooks.runExitHooks(s.exitHooks.toSeq)
       s.copy(exitHooks = Set.empty)
-    }
     def locked[T](file: File)(t: => T): T =
       s.configuration.provider.scalaProvider.launcher.globalLock.apply(
         file,
-        new Callable[T] {
+        new Callable[T]:
           def call = t
-        }
       )
 
     def interactive = getBoolean(s, BasicKeys.interactive, false)
@@ -419,21 +402,21 @@ object State {
             "Tried to get extended classloader cache for uninitialized state."
           )
         )
-    def initializeClassLoaderCache: State = {
+    def initializeClassLoaderCache: State =
       s.get(BasicKeys.extendedClassLoaderCache).foreach(_.close())
       val cache = newClassLoaderCache
-      s.configuration.provider.scalaProvider.loader match {
+      s.configuration.provider.scalaProvider.loader match
         case null            => // This can happen in scripted
         case fullScalaLoader =>
           val jars = s.configuration.provider.scalaProvider.jars
           val (library, rest) = jars.partition(_.getName == "scala-library.jar")
-          library.toList match {
+          library.toList match
             case l @ lj :: Nil =>
-              fullScalaLoader.getParent match {
+              fullScalaLoader.getParent match
                 case null          => // This can happen for old launchers.
                 case libraryLoader =>
                   cache.cachedCustomClassloader(l, () => new UncloseableURLLoader(l, libraryLoader))
-                  fullScalaLoader match {
+                  fullScalaLoader match
                     case u: URLClassLoader
                         if u.getURLs
                           .filterNot(_ == lj.toURI.toURL)
@@ -444,36 +427,30 @@ object State {
                       )
                       ()
                     case _ =>
-                  }
-              }
             case _ =>
-          }
-      }
+      end match
       s.put(BasicKeys.extendedClassLoaderCache, cache)
         .put(BasicKeys.classLoaderCache, new IncClassLoaderCache(cache))
-    }
+    end initializeClassLoaderCache
     private def newClassLoaderCache =
       new ClassLoaderCache(s.configuration.provider.scalaProvider)
-  }
+  end StateOpsImpl
 
   import ExceptionCategory.*
 
-  private def handleException(t: Throwable, s: State, log: Logger): State = {
-    ExceptionCategory(t) match {
+  private def handleException(t: Throwable, s: State, log: Logger): State =
+    ExceptionCategory(t) match
       case AlreadyHandled => ()
       case m: MessageOnly => log.error(m.message)
       case f: Full        => logFullException(f.exception, log)
-    }
     s.fail
-  }
-  private[sbt] def logFullException(e: Throwable, log: Logger): Unit = {
+  private[sbt] def logFullException(e: Throwable, log: Logger): Unit =
     e.printStackTrace(System.err)
     log.trace(e)
     log.error(ErrorHandling.reducedToString(e))
     log.error("Use 'last' for the full log.")
-  }
   private[sbt] def getBoolean(s: State, key: AttributeKey[Boolean], default: Boolean): Boolean =
     s.get(key) getOrElse default
-}
+end State
 
 private[sbt] final class RebootCurrent(val arguments: List[String]) extends RuntimeException
diff --git a/main-command/src/main/scala/sbt/Watched.scala b/main-command/src/main/scala/sbt/Watched.scala
index ceb521d2a..6c5f1651a 100644
--- a/main-command/src/main/scala/sbt/Watched.scala
+++ b/main-command/src/main/scala/sbt/Watched.scala
@@ -24,7 +24,7 @@ object Watched:
 
   def clearScreen: String = "\u001b[2J\u001b[0;0H"
 
-  object WatchSource {
+  object WatchSource:
 
     /**
      * Creates a new `WatchSource` for watching files, with the given filters.
@@ -45,16 +45,14 @@ object Watched:
      */
     def apply(base: File): Source = apply(base, AllPassFilter, NothingFilter)
 
-  }
-
   private val defaultPollInterval: FiniteDuration = 500.milliseconds
 
   // @nowarn
   private[sbt] val newWatchService: () => WatchService =
     (() => createWatchService(defaultPollInterval)).label("Watched.newWatchService")
-  def createWatchService(pollDelay: FiniteDuration): WatchService = {
+  def createWatchService(pollDelay: FiniteDuration): WatchService =
     def closeWatch = new MacOSXWatchService()
-    sys.props.get("sbt.watch.mode") match {
+    sys.props.get("sbt.watch.mode") match
       case Some("polling") =>
         new PollingWatchService(pollDelay)
       case Some("nio") =>
@@ -63,7 +61,5 @@ object Watched:
       case _ if Properties.isMac => closeWatch
       case _                     =>
         FileSystems.getDefault.newWatchService()
-    }
-  }
 
 end Watched
diff --git a/main-command/src/main/scala/sbt/internal/BootServerSocketProbe.scala b/main-command/src/main/scala/sbt/internal/BootServerSocketProbe.scala
index 56bc767d0..76af9fbac 100644
--- a/main-command/src/main/scala/sbt/internal/BootServerSocketProbe.scala
+++ b/main-command/src/main/scala/sbt/internal/BootServerSocketProbe.scala
@@ -53,4 +53,5 @@ private[sbt] object BootServerSocketProbe:
     t.start()
     done.await(timeoutMillis, TimeUnit.MILLISECONDS)
     answered.get()
+  end liveServerDetected
 end BootServerSocketProbe
diff --git a/main-command/src/main/scala/sbt/internal/CommandChannel.scala b/main-command/src/main/scala/sbt/internal/CommandChannel.scala
index c5dcbaad0..348e035f8 100644
--- a/main-command/src/main/scala/sbt/internal/CommandChannel.scala
+++ b/main-command/src/main/scala/sbt/internal/CommandChannel.scala
@@ -24,7 +24,7 @@ import scala.jdk.CollectionConverters.*
  * that can issue command or listen for some outputs.
  * We can think of a command channel to be an abstraction of the terminal window.
  */
-abstract class CommandChannel {
+abstract class CommandChannel:
   private val commandQueue: ConcurrentLinkedQueue[Exec] = new ConcurrentLinkedQueue()
   private val registered: java.util.Set[java.util.Queue[Exec]] = new java.util.HashSet
   private val fastTrack: java.util.Set[java.util.Queue[FastTrackTask]] = new java.util.HashSet
@@ -34,10 +34,9 @@ abstract class CommandChannel {
   ): Unit =
     registered.synchronized {
       registered.add(queue)
-      if (!commandQueue.isEmpty) {
+      if !commandQueue.isEmpty then
         queue.addAll(commandQueue)
         commandQueue.clear()
-      }
       fastTrack.add(fastTrackQueue)
       ()
     }
@@ -50,19 +49,17 @@ abstract class CommandChannel {
       fastTrack.remove(fastTrackQueue)
       ()
     }
-  private[sbt] final def addFastTrackTask(task: String): Unit = {
+  private[sbt] final def addFastTrackTask(task: String): Unit =
     fastTrack.forEach(q => q.synchronized { q.add(new FastTrackTask(this, task)); () })
-  }
   private[sbt] def mkUIThread: (State, CommandChannel) => UITask
   private[sbt] def makeUIThread(state: State): UITask = mkUIThread(state, this)
-  final def append(exec: Exec): Boolean = {
+  final def append(exec: Exec): Boolean =
     registered.synchronized {
       exec.commandLine.nonEmpty && {
-        if (registered.isEmpty) commandQueue.add(exec)
+        if registered.isEmpty then commandQueue.add(exec)
         else registered.asScala.forall(_.add(exec))
       }
     }
-  }
   protected def appendExec(commandLine: String, execId: Option[String]): Boolean =
     append(Exec(commandLine, execId.orElse(Some(Exec.newExecId)), Some(CommandSource(name))))
   def poll: Option[Exec] = Option(commandQueue.poll)
@@ -71,44 +68,40 @@ abstract class CommandChannel {
   def unprompt(e: ConsoleUnpromptEvent): Unit = userThread.onConsoleUnpromptEvent(e)
   def publishBytes(bytes: Array[Byte]): Unit
   private[sbt] def userThread: UserThread
-  def shutdown(logShutdown: Boolean): Unit = {
+  def shutdown(logShutdown: Boolean): Unit =
     userThread.stopThread()
     userThread.close()
-  }
   @deprecated("Use the variant that takes the logShutdown parameter", "1.4.0")
   def shutdown(): Unit = shutdown(true)
   def name: String
   private val level = new AtomicReference[Level.Value](Level.Info)
   private[sbt] final def setLevel(l: Level.Value): Unit = level.set(l)
   private[sbt] final def logLevel: Level.Value = level.get
-  private def setLevel(value: Level.Value, cmd: String): Boolean = {
+  private def setLevel(value: Level.Value, cmd: String): Boolean =
     level.set(value)
     appendExec(cmd, None)
-  }
   private[sbt] def onCommandLine(cmd: String): Boolean =
-    cmd match {
+    cmd match
       case "error" => setLevel(Level.Error, "error")
       case "debug" => setLevel(Level.Debug, "debug")
       case "info"  => setLevel(Level.Info, "info")
       case "warn"  => setLevel(Level.Warn, "warn")
       case cmd     =>
-        if (cmd.nonEmpty) appendExec(cmd, None)
+        if cmd.nonEmpty then appendExec(cmd, None)
         else false
-    }
-  private[sbt] def onFastTrackTask(cmd: String): Boolean = {
+  private[sbt] def onFastTrackTask(cmd: String): Boolean =
     fastTrack.synchronized(fastTrack.forEach { q =>
       q.add(new FastTrackTask(this, cmd))
       ()
     })
     true
-  }
 
   private[sbt] def terminal: Terminal
   private[sbt] var _active: Boolean = true
   private[sbt] def pause(): Unit = _active = false
   private[sbt] def isPaused: Boolean = !_active
   private[sbt] def resume(): Unit = _active = true
-}
+end CommandChannel
 
 // case class Exec(commandLine: String, source: Option[CommandSource])
 
diff --git a/main-command/src/main/scala/sbt/internal/ConsoleChannel.scala b/main-command/src/main/scala/sbt/internal/ConsoleChannel.scala
index d6ec18cde..ee9b204dc 100644
--- a/main-command/src/main/scala/sbt/internal/ConsoleChannel.scala
+++ b/main-command/src/main/scala/sbt/internal/ConsoleChannel.scala
@@ -16,7 +16,7 @@ import sjsonnew.JsonFormat
 private[sbt] final class ConsoleChannel(
     val name: String,
     override private[sbt] val mkUIThread: (State, CommandChannel) => UITask
-) extends CommandChannel {
+) extends CommandChannel:
 
   def run(s: State): State = s
 
@@ -26,7 +26,5 @@ private[sbt] final class ConsoleChannel(
 
   override val userThread: UserThread = new UserThread(this)
   private[sbt] def terminal = Terminal.console
-}
-private[sbt] object ConsoleChannel {
+private[sbt] object ConsoleChannel:
   private[sbt] def defaultName = "console0"
-}
diff --git a/main-command/src/main/scala/sbt/internal/LabeledFunctions.scala b/main-command/src/main/scala/sbt/internal/LabeledFunctions.scala
index 0c7f585ec..08a1c86ca 100644
--- a/main-command/src/main/scala/sbt/internal/LabeledFunctions.scala
+++ b/main-command/src/main/scala/sbt/internal/LabeledFunctions.scala
@@ -19,14 +19,14 @@ package sbt.internal
  * is not ready to be exposed to users. Until the api matures or we decide that it's worth
  * exposing to users, these should remain sbt package private.
  */
-private[sbt] object LabeledFunctions {
+private[sbt] object LabeledFunctions:
 
   /**
    * Adds extension methods to a zero argument function.
    * @param f the function to extend
    * @tparam R the function result type
    */
-  extension [R](f: () => R) {
+  extension [R](f: () => R)
 
     /**
      * Add a label to the function.
@@ -34,7 +34,6 @@ private[sbt] object LabeledFunctions {
      * @return a wrapped function with an overridden toString method.
      */
     def label(string: String): () => R = new LabeledFunction0(f, string)
-  }
 
   /**
    * Adds extension methods to a single argument function.
@@ -42,7 +41,7 @@ private[sbt] object LabeledFunctions {
    * @tparam T the input parameter
    * @tparam R the function result type
    */
-  extension [T, R](f: T => R) {
+  extension [T, R](f: T => R)
 
     /**
      * Add a label to the function.
@@ -50,7 +49,6 @@ private[sbt] object LabeledFunctions {
      * @return a wrapped function with an overridden toString method.
      */
     def label(string: String): T => R = new LabeledFunction1(f, string)
-  }
 
   /**
    * Adds extension methods to a two argument function.
@@ -59,7 +57,7 @@ private[sbt] object LabeledFunctions {
    * @tparam T2 the second function input parameter
    * @tparam R the function result type
    */
-  extension [T1, T2, R](f: (T1, T2) => R) {
+  extension [T1, T2, R](f: (T1, T2) => R)
 
     /**
      * Add a label to the function.
@@ -67,7 +65,6 @@ private[sbt] object LabeledFunctions {
      * @return a wrapped function with an overridden toString method.
      */
     def label(string: String): (T1, T2) => R = new LabeledFunction2(f, string)
-  }
 
   /**
    * Adds extension methods to a three argument function.
@@ -77,7 +74,7 @@ private[sbt] object LabeledFunctions {
    * @tparam T3 the third function input parameter
    * @tparam R the function result type
    */
-  extension [T1, T2, T3, R](f: (T1, T2, T3) => R) {
+  extension [T1, T2, T3, R](f: (T1, T2, T3) => R)
 
     /**
      * Add a label to the function.
@@ -85,7 +82,6 @@ private[sbt] object LabeledFunctions {
      * @return a wrapped function with an overridden toString method.
      */
     def label(string: String): (T1, T2, T3) => R = new LabeledFunction3(f, string)
-  }
 
   /**
    * Adds extension methods to a three argument function.
@@ -96,7 +92,7 @@ private[sbt] object LabeledFunctions {
    * @tparam T4 the fourth function input parameter
    * @tparam R the function result type
    */
-  extension [T1, T2, T3, T4, R](f: (T1, T2, T3, T4) => R) {
+  extension [T1, T2, T3, T4, R](f: (T1, T2, T3, T4) => R)
 
     /**
      * Add a label to the function.
@@ -104,30 +100,24 @@ private[sbt] object LabeledFunctions {
      * @return a wrapped function with an overridden toString method.
      */
     def label(string: String): (T1, T2, T3, T4) => R = new LabeledFunction4(f, string)
-  }
-  private class LabeledFunction0[+R](private val f: () => R, label: String) extends (() => R) {
+  private class LabeledFunction0[+R](private val f: () => R, label: String) extends (() => R):
     override def apply(): R = f()
     override def toString: String = label
-  }
-  private class LabeledFunction1[-T, +R](private val f: T => R, label: String) extends (T => R) {
+  private class LabeledFunction1[-T, +R](private val f: T => R, label: String) extends (T => R):
     override def apply(t: T): R = f(t)
     override def toString: String = label
-  }
   private class LabeledFunction2[-T1, -T2, +R](private val f: (T1, T2) => R, label: String)
-      extends ((T1, T2) => R) {
+      extends ((T1, T2) => R):
     override def apply(t1: T1, t2: T2): R = f(t1, t2)
     override def toString: String = label
-  }
   private class LabeledFunction3[-T1, -T2, -T3, +R](private val f: (T1, T2, T3) => R, label: String)
-      extends ((T1, T2, T3) => R) {
+      extends ((T1, T2, T3) => R):
     override def apply(t1: T1, t2: T2, t3: T3): R = f(t1, t2, t3)
     override def toString: String = label
-  }
   private class LabeledFunction4[-T1, -T2, -T3, T4, +R](
       private val f: (T1, T2, T3, T4) => R,
       label: String
-  ) extends ((T1, T2, T3, T4) => R) {
+  ) extends ((T1, T2, T3, T4) => R):
     override def apply(t1: T1, t2: T2, t3: T3, t4: T4): R = f(t1, t2, t3, t4)
     override def toString: String = label
-  }
-}
+end LabeledFunctions
diff --git a/main-command/src/main/scala/sbt/internal/classpath/ClassLoaderCache.scala b/main-command/src/main/scala/sbt/internal/classpath/ClassLoaderCache.scala
index 1bc7cb979..20969bfce 100644
--- a/main-command/src/main/scala/sbt/internal/classpath/ClassLoaderCache.scala
+++ b/main-command/src/main/scala/sbt/internal/classpath/ClassLoaderCache.scala
@@ -27,13 +27,12 @@ import scala.annotation.tailrec
 import scala.jdk.CollectionConverters.*
 import scala.util.control.NonFatal
 
-private object ClassLoaderCache {
+private object ClassLoaderCache:
   private def threadID = new AtomicInteger(0)
-}
 private[sbt] class ClassLoaderCache(
     val parent: ClassLoader,
     private val miniProvider: Option[(File, ClassLoader)]
-) extends AbstractClassLoaderCache {
+) extends AbstractClassLoaderCache:
   private val parentHolder = new AtomicReference(parent)
   def commonParent = parentHolder.get()
   def setParent(parent: ClassLoader): Unit = parentHolder.set(parent)
@@ -43,36 +42,32 @@ private[sbt] class ClassLoaderCache(
       scalaProvider.launcher.topLoader, {
         scalaProvider.jars.find(_.getName == "scala-library.jar").flatMap { lib =>
           val clazz = scalaProvider.getClass
-          try {
+          try
             val loader = clazz.getDeclaredMethod("libraryLoaderOnly").invoke(scalaProvider)
             Some(lib -> loader.asInstanceOf[ClassLoader])
-          } catch { case NonFatal(_) => None }
+          catch case NonFatal(_) => None
         }
       }
     )
   private val scalaProviderKey = miniProvider.map { (f, cl) =>
-    new Key((f -> IO.getModifiedTimeOrZero(f)) :: Nil, commonParent) {
+    new Key((f -> IO.getModifiedTimeOrZero(f)) :: Nil, commonParent):
       override def toClassLoader: ClassLoader = cl
-    }
   }
-  private class Key(val fileStamps: Seq[(File, Long)], val parent: ClassLoader) {
+  private class Key(val fileStamps: Seq[(File, Long)], val parent: ClassLoader):
     def this(files: List[File], parent: ClassLoader) =
       this(files.map(f => f -> IO.getModifiedTimeOrZero(f)), parent)
     def this(files: List[File]) = this(files, commonParent)
     lazy val files: Seq[File] = fileStamps.map(_._1)
     lazy val maxStamp: Long = fileStamps.maxBy(_._2)._2
     class CachedClassLoader
-        extends URLClassLoader(fileStamps.map(_._1.toURI.toURL).toArray, parent) {
+        extends URLClassLoader(fileStamps.map(_._1.toURI.toURL).toArray, parent):
       override def toString: String =
         s"CachedClassloader {\n  parent: $parent\n  urls:\n" + getURLs.mkString("    ", "\n", "\n}")
-    }
     def toClassLoader: ClassLoader = new CachedClassLoader
-    override def equals(o: Any): Boolean = o match {
+    override def equals(o: Any): Boolean = o match
       case that: Key => this.fileStamps == that.fileStamps && this.parent == that.parent
-    }
     override def hashCode(): Int = (fileStamps.hashCode * 31) ^ parent.hashCode
     override def toString: String = s"Key(${fileStamps mkString ","}, $parent)"
-  }
   private val delegate =
     new java.util.concurrent.ConcurrentHashMap[Key, Reference[ClassLoader]]()
   private val referenceQueue = new ReferenceQueue[ClassLoader]
@@ -91,59 +86,48 @@ private[sbt] class ClassLoaderCache(
     java.util.Collections.synchronizedMap(new java.util.WeakHashMap[ClassLoader, java.lang.Boolean])
 
   private def clearExpiredLoaders(): Unit = lock.synchronized {
-    val clear = (k: Key, ref: Reference[ClassLoader]) => {
-      ref.get() match {
+    val clear = (k: Key, ref: Reference[ClassLoader]) =>
+      ref.get() match
         case w: WrappedLoader => w.invalidate()
         case _                =>
-      }
-      ref match {
+      ref match
         case ClassLoaderReference(_, underlying) =>
           retired.put(underlying, java.lang.Boolean.TRUE)
         case r =>
-          r.get() match {
+          r.get() match
             case null   =>
             case loader => retired.put(loader, java.lang.Boolean.TRUE)
-          }
-      }
       delegate.remove(k)
       ()
-    }
-    def isInvalidated(classLoader: ClassLoader): Boolean = classLoader match {
+    def isInvalidated(classLoader: ClassLoader): Boolean = classLoader match
       case w: WrappedLoader => w.invalidated()
       case _                => false
-    }
     delegate.asScala.groupBy { case (k, _) => k.parent -> k.files.toSet }.foreach {
       case (_, pairs) if pairs.size > 1 =>
         val max = pairs.map(_._1.maxStamp).max
-        pairs.foreach { (k, v) => if (k.maxStamp != max) clear(k, v) }
+        pairs.foreach { (k, v) => if k.maxStamp != max then clear(k, v) }
       case _ =>
     }
-    delegate.forEach((k, v) => if (isInvalidated(k.parent)) clear(k, v))
+    delegate.forEach((k, v) => if isInvalidated(k.parent) then clear(k, v))
   }
-  private class CleanupThread(private val id: Int)
-      extends Thread(s"classloader-cache-cleanup-$id") {
+  private class CleanupThread(private val id: Int) extends Thread(s"classloader-cache-cleanup-$id"):
     setDaemon(true)
     start()
     @tailrec
-    override final def run(): Unit = {
+    override final def run(): Unit =
       val stop =
-        try {
-          referenceQueue.remove(1000) match {
+        try
+          referenceQueue.remove(1000) match
             case ClassLoaderReference(key, classLoader) =>
               close(classLoader)
               retired.remove(classLoader)
               delegate.remove(key)
               ()
             case _ =>
-          }
           clearExpiredLoaders()
           false
-        } catch {
-          case _: InterruptedException => true
-        }
-      if (!stop) run()
-    }
-  }
+        catch case _: InterruptedException => true
+      if !stop then run()
 
   /*
    * We need to manage the cache differently depending on whether or not sbt is started up with
@@ -180,16 +164,15 @@ private[sbt] class ClassLoaderCache(
     ManagementFactory.getMemoryPoolMXBeans.asScala
       .exists(b => (b.getName == "Metaspace") && (b.getUsage.getMax > 0))
   private val mkReference: (Key, ClassLoader) => Reference[ClassLoader] =
-    if (metaspaceIsLimited) { (_, cl) =>
-      (new SoftReference[ClassLoader](cl, referenceQueue): Reference[ClassLoader])
-    } else ClassLoaderReference.apply
+    if metaspaceIsLimited then
+      (_, cl) => (new SoftReference[ClassLoader](cl, referenceQueue): Reference[ClassLoader])
+    else ClassLoaderReference.apply
   private val cleanupThread = new CleanupThread(ClassLoaderCache.threadID.getAndIncrement())
   private val lock = new Object
 
-  private def close(classLoader: ClassLoader): Unit = classLoader match {
+  private def close(classLoader: ClassLoader): Unit = classLoader match
     case a: AutoCloseable => a.close()
     case _                =>
-  }
   private case class ClassLoaderReference(key: Key, classLoader: ClassLoader)
       extends SoftReference[ClassLoader](
         new WrappedLoader(classLoader),
@@ -199,62 +182,51 @@ private[sbt] class ClassLoaderCache(
       files: List[(File, Long)],
       parent: ClassLoader,
       mkLoader: () => ClassLoader
-  ): ClassLoader = {
+  ): ClassLoader =
     val key = new Key(files, parent)
     get(key, mkLoader)
-  }
-  def apply(files: List[File], parent: ClassLoader): ClassLoader = {
+  def apply(files: List[File], parent: ClassLoader): ClassLoader =
     val key = new Key(files, parent)
     get(key, () => key.toClassLoader)
-  }
-  override def apply(files: List[File]): ClassLoader = {
-    files match {
+  override def apply(files: List[File]): ClassLoader =
+    files match
       case d :: s :: Nil
           if d.getName.startsWith("dotty-library") || d.getName.startsWith("scala3-library") =>
         apply(files, classOf[org.jline.terminal.Terminal].getClassLoader)
       case _ =>
         val key = new Key(files)
         get(key, () => key.toClassLoader)
-    }
-  }
   override def cachedCustomClassloader(
       files: List[File],
       mkLoader: () => ClassLoader
-  ): ClassLoader = {
+  ): ClassLoader =
     val key = new Key(files)
     get(key, mkLoader)
-  }
-  private def get(key: Key, f: () => ClassLoader): ClassLoader = {
-    scalaProviderKey match {
+  private def get(key: Key, f: () => ClassLoader): ClassLoader =
+    scalaProviderKey match
       case Some(k) if k == key => k.toClassLoader
       case _                   =>
-        def addLoader(): ClassLoader = {
+        def addLoader(): ClassLoader =
           val ref = mkReference(key, f())
           val loader = ref.get
           delegate.put(key, ref)
           clearExpiredLoaders()
           loader
-        }
         lock.synchronized {
-          delegate.get(key) match {
+          delegate.get(key) match
             case null => addLoader()
             case ref  =>
-              ref.get match {
+              ref.get match
                 case null => addLoader()
                 case l    => l
-              }
-          }
         }
-    }
-  }
-  private def clear(lock: Object): Unit = {
+  private def clear(lock: Object): Unit =
     delegate.asScala.foreach {
       case (_, ClassLoaderReference(_, classLoader)) => close(classLoader)
       case (_, r: Reference[ClassLoader])            =>
-        r.get match {
+        r.get match
           case null        =>
           case classLoader => close(classLoader)
-        }
     }
     delegate.clear()
     /* Also close loaders that were evicted from the delegate map but never closed (see
@@ -263,7 +235,6 @@ private[sbt] class ClassLoaderCache(
     val evicted = retired.synchronized(new java.util.ArrayList(retired.keySet()).asScala.toList)
     evicted.foreach(close)
     retired.clear()
-  }
 
   /**
    * Clears any ClassLoader instances from the internal cache and closes them. Calling this
@@ -282,15 +253,15 @@ private[sbt] class ClassLoaderCache(
     cleanupThread.join()
     clear(lock)
   }
-}
+end ClassLoaderCache
 
-private[sbt] object AlternativeZincUtil {
+private[sbt] object AlternativeZincUtil:
   def scalaCompiler(
       scalaInstance: ScalaInstance,
       compilerBridgeJar: File,
       classpathOptions: ClasspathOptions,
       classLoaderCache: Option[IncClassLoaderCache]
-  ): AnalyzingCompiler = {
+  ): AnalyzingCompiler =
     val bridgeProvider = ZincUtil.constantBridgeProvider(scalaInstance, compilerBridgeJar)
     new AnalyzingCompiler(
       scalaInstance,
@@ -299,5 +270,3 @@ private[sbt] object AlternativeZincUtil {
       _ => (),
       classLoaderCache
     )
-  }
-}
diff --git a/main-command/src/main/scala/sbt/internal/client/BspClient.scala b/main-command/src/main/scala/sbt/internal/client/BspClient.scala
index 7aadc4cb4..22b905e8e 100644
--- a/main-command/src/main/scala/sbt/internal/client/BspClient.scala
+++ b/main-command/src/main/scala/sbt/internal/client/BspClient.scala
@@ -15,57 +15,49 @@ import java.util.concurrent.atomic.AtomicBoolean
 import sbt.Exit
 import scala.util.control.NonFatal
 
-object BspClient {
-  private[sbt] def bspRun(sbtServer: Socket): Int = {
+object BspClient:
+  private[sbt] def bspRun(sbtServer: Socket): Int =
     val lock = new AnyRef
     val terminated = new AtomicBoolean(false)
     transferTo(terminated, lock, sbtServer.getInputStream, System.out).start()
     transferTo(terminated, lock, System.in, sbtServer.getOutputStream).start()
-    try {
+    try
       lock.synchronized {
-        while (!terminated.get) lock.wait()
+        while !terminated.get do lock.wait()
       }
       0
-    } catch { case _: Throwable => 1 }
+    catch case _: Throwable => 1
     finally sbtServer.close()
-  }
 
   private[sbt] def transferTo(
       terminated: AtomicBoolean,
       lock: AnyRef,
       input: InputStream,
       output: OutputStream
-  ): Thread = {
-    val thread = new Thread {
-      override def run(): Unit = {
+  ): Thread =
+    val thread = new Thread:
+      override def run(): Unit =
         val buffer = Array.ofDim[Byte](1024)
-        try {
-          while (!terminated.get) {
+        try
+          while !terminated.get do
             val size = input.read(buffer)
-            if (size == -1) {
-              terminated.set(true)
-            } else {
+            if size == -1 then terminated.set(true)
+            else
               output.write(buffer, 0, size)
               output.flush()
-            }
-          }
           input.close()
           output.close()
-        } catch {
+        catch
           case _: InterruptedException => terminated.set(true)
           case NonFatal(_)             => ()
-        } finally {
+        finally
           lock.synchronized {
             terminated.set(true)
             lock.notify()
           }
-        }
-      }
-    }
     thread.setDaemon(true)
     thread
-  }
-  def run(configuration: xsbti.AppConfiguration): Exit = {
+  end transferTo
+  def run(configuration: xsbti.AppConfiguration): Exit =
     Exit(NetworkClient.run(configuration, configuration.arguments.toList, redirectOutput = true))
-  }
-}
+end BspClient
diff --git a/main-command/src/main/scala/sbt/internal/client/NetworkClient.scala b/main-command/src/main/scala/sbt/internal/client/NetworkClient.scala
index 76e49bd2f..9f5412166 100644
--- a/main-command/src/main/scala/sbt/internal/client/NetworkClient.scala
+++ b/main-command/src/main/scala/sbt/internal/client/NetworkClient.scala
@@ -74,10 +74,9 @@ import Serialization.{
 import NetworkClient.Arguments
 import java.util.concurrent.TimeoutException
 
-trait ConsoleInterface {
+trait ConsoleInterface:
   def appendLog(level: Level.Value, message: => String): Unit
   def success(msg: String): Unit
-}
 
 /**
  * A NetworkClient connects to a running sbt instance or starts a
@@ -117,7 +116,8 @@ class NetworkClient(
     errorStream: PrintStream,
     printStream: PrintStream,
     useJNI: Boolean,
-) extends AutoCloseable { self =>
+) extends AutoCloseable:
+  self =>
   def this(configuration: xsbti.AppConfiguration, arguments: Arguments) =
     this(
       arguments = arguments.withoutSysProps.withBaseDirectory(configuration.baseDirectory),
@@ -164,10 +164,9 @@ class NetworkClient(
 
   private def mkSocket(file: File): (Socket, Option[String]) = ClientSocket.socket(file, useJNI)
 
-  private[sbt] def logFailure(e: Exception): Unit = {
+  private[sbt] def logFailure(e: Exception): Unit =
     errorStream.println(s"sbt client failed: $e")
     e.printStackTrace(errorStream)
-  }
 
   private def portfile = arguments.baseDirectory / "project" / "target" / "active.json"
 
@@ -186,11 +185,10 @@ class NetworkClient(
   private class ConnectionRefusedException(t: Throwable) extends Throwable(t)
   private class ServerFailedException extends Exception
   private[client] def startInputThread(): Unit = inputThread.request()
-  private lazy val log: Logger = new Logger {
+  private lazy val log: Logger = new Logger:
     def trace(t: => Throwable): Unit = ()
     def success(message: => String): Unit = ()
     def log(level: Level.Value, message: => String): Unit = console.appendLog(level, message)
-  }
   private val interactive = arguments.commandArguments.isEmpty
   private val startupMessages: List[String] =
     "entering thin client - BEEP WHIRR" ::
@@ -274,7 +272,11 @@ class NetworkClient(
                   Level.Warn,
                   "run 'sbt shutdown' for the ones passed here to take effect"
                 )
+          end if
+        end if
       }
+    end if
+  end restartServerIfSysPropsChanged
 
   /**
    * Asks the running server to shut down and waits for it to let go of its socket, so that
@@ -326,75 +328,70 @@ class NetworkClient(
           val deadline = waitFor.fromNow
           // the server drops the portfile when it starts tearing down, and only then is it
           // worth asking its socket whether it is still there
-          while (portfile.exists && !deadline.isOverdue()) Thread.sleep(20)
+          while portfile.exists && !deadline.isOverdue() do Thread.sleep(20)
           // each of these asks costs a connection on a server that is still up, so they
           // get further apart the longer it takes
           var delay = 20L
-          while (!gone && !deadline.isOverdue()) {
+          while !gone && !deadline.isOverdue() do
             Thread.sleep(delay)
-            if (delay < 500) delay = delay * 2
-          }
+            if delay < 500 then delay = delay * 2
           Some(gone)
         finally session.close()
+        end try
+    end match
+  end shutdownRunningServer
 
   private[sbt] def connectOrStartServerAndConnect(
       promptCompleteUsers: Boolean,
       retry: Boolean
   ): (Socket, Option[String]) =
     try
-      if (portfile.exists) restartServerIfSysPropsChanged(promptCompleteUsers)
-      if (!portfile.exists) {
-        if (shutdownOnly) {
+      if portfile.exists then restartServerIfSysPropsChanged(promptCompleteUsers)
+      if !portfile.exists then
+        if shutdownOnly then
           console.appendLog(Level.Info, "no sbt server is running. ciao")
           System.exit(0)
-        } else if (!serverAutoStart) {
+        else if !serverAutoStart then
           console.appendLog(Level.Error, "no sbt server is running (sbt.server.autostart=false)")
           System.exit(1)
-        } else if (promptCompleteUsers) {
-          val msg = if (noTab) "" else "No sbt server is running. Press <tab> to start one..."
+        else if promptCompleteUsers then
+          val msg = if noTab then "" else "No sbt server is running. Press <tab> to start one..."
           errorStream.print(s"\n$msg")
-          if (noStdErr) System.exit(0)
-          else if (noTab) waitForServer(portfile, log = true, startServer = true)
-          else {
+          if noStdErr then System.exit(0)
+          else if noTab then waitForServer(portfile, log = true, startServer = true)
+          else
             startInputThread()
-            stdinBytes.poll(5, TimeUnit.SECONDS) match {
+            stdinBytes.poll(5, TimeUnit.SECONDS) match
               case null        => System.exit(0)
               case i if i == 9 =>
                 errorStream.println("\nStarting server...")
                 waitForServer(portfile, !promptCompleteUsers, startServer = true)
               case _ => System.exit(0)
-            }
-          }
-        } else {
-          waitForServer(portfile, log = true, startServer = true)
-        }
-      }
-      @tailrec def connect(attempt: Int): (Socket, Option[String]) = {
+        else waitForServer(portfile, log = true, startServer = true)
+      end if
+      @tailrec def connect(attempt: Int): (Socket, Option[String]) =
         val res =
           try Some(mkSocket(portfile))
-          catch {
+          catch
             case _: ClientSocket.ConnectionFileReadException if attempt < 10 =>
               None // server may be in the middle of writing the portfile
             case e: IOException =>
-              if (attempt >= 10) throw new ConnectionRefusedException(e)
+              if attempt >= 10 then throw new ConnectionRefusedException(e)
               val msg = Option(e.getMessage).getOrElse("")
               // This catches a pipe busy exception which can happen if two windows clients
               // attempt to connect in rapid succession
-              if (msg.contains("Couldn't open"))
-                if (msg.contains("Access is denied") || msg.contains("(5)")) {
+              if msg.contains("Couldn't open") then
+                if msg.contains("Access is denied") || msg.contains("(5)") then
                   errorStream.println(s"Access denied for portfile $portfile")
                   throw new NetworkClient.AccessDeniedException
-                }
               None // server could be busy, not down, so try again
-          }
-        res match {
+        res match
           case Some(r) => r
           case None    =>
             // Use a random sleep to spread out the competing processes
             Thread.sleep(new java.util.Random().nextInt(20).toLong)
             connect(attempt + 1)
-        }
-      }
+      end connect
       connect(0)
     catch
       case e @ (_: ConnectionRefusedException | _: ClientSocket.ConnectionFileReadException)
@@ -406,20 +403,19 @@ class NetworkClient(
   end connectOrStartServerAndConnect
 
   // Open server connection based on the portfile
-  private def initImpl(promptCompleteUsers: Boolean, retry: Boolean): ServerSession = {
+  private def initImpl(promptCompleteUsers: Boolean, retry: Boolean): ServerSession =
     val (sk, tkn) = connectOrStartServerAndConnect(promptCompleteUsers, retry)
-    val conn = new ServerSessionImpl(sk, s"sbt-serverconnection-${sk.getPort}") {
-      override protected def onNotification(msg: JsonRpcNotificationMessage): Unit = {
-        msg.method match {
+    val conn = new ServerSessionImpl(sk, s"sbt-serverconnection-${sk.getPort}"):
+      override protected def onNotification(msg: JsonRpcNotificationMessage): Unit =
+        msg.method match
           case `Shutdown` =>
-            val (log, rebootCommands) = msg.params match {
+            val (log, rebootCommands) = msg.params match
               case Some(jvalue) =>
                 Converter
                   .fromJson[(Boolean, Option[(String, String)])](jvalue)
                   .getOrElse((true, None))
               case _ => (false, None)
-            }
-            if (rebootCommands.nonEmpty) {
+            if rebootCommands.nonEmpty then
               rebooting.set(true)
               attached.set(false)
               connectionHolder.close()
@@ -427,54 +423,46 @@ class NetworkClient(
               init(promptCompleteUsers = false, retry = false)
               attachUUID.set(sendJson(attach, s"""{"interactive": ${!batchMode.get}}"""))
               rebooting.set(false)
-              rebootCommands match {
+              rebootCommands match
                 case Some((execId, cmd)) if execId.nonEmpty =>
-                  if (batchMode.get && !pendingResults.containsKey(execId) && cmd.nonEmpty) {
+                  if batchMode.get && !pendingResults.containsKey(execId) && cmd.nonEmpty then
                     console.appendLog(
                       Level.Error,
                       s"received request to re-run unknown command '$cmd' after reboot"
                     )
-                  } else if (cmd.nonEmpty) {
-                    if (batchMode.get) self.sendCommand(ExecCommand(cmd, execId))
+                  else if cmd.nonEmpty then
+                    if batchMode.get then self.sendCommand(ExecCommand(cmd, execId))
                     else
                       inLock.synchronized {
                         val toSend = cmd.getBytes :+ '\r'.toByte
                         toSend.foreach(b => sendNotification(systemIn, b.toString))
                       }
-                  } else completeExec(execId, 0)
+                  else completeExec(execId, 0)
                 case _ =>
-              }
-            } else {
-              if (!rebooting.get() && running.compareAndSet(true, false) && log) {
-                if (!arguments.commandArguments.contains(Shutdown)) {
+            else
+              if !rebooting.get() && running.compareAndSet(true, false) && log then
+                if !arguments.commandArguments.contains(Shutdown) then
                   console.appendLog(Level.Error, "sbt server disconnected")
                   exitClean.set(false)
-                }
-              } else {
-                console.appendLog(Level.Info, s"${if (log) "sbt server " else ""}disconnected")
-              }
+              else
+                console.appendLog(Level.Info, s"${if log then "sbt server " else ""}disconnected")
               stdinBytes.offer(-1)
               inputThread.close()
               Option(interactiveThread.get).foreach(_.interrupt)
-            }
+            end if
           case `readSystemIn`       => startInputThread()
           case `cancelReadSystemIn` => inputThread.cancel()
           case _                    => self.onNotification(msg)
-        }
-      }
       override protected def onRequest(msg: JsonRpcRequestMessage): Unit = self.onRequest(msg)
       override protected def onResponse(msg: JsonRpcResponseMessage): Unit = self.onResponse(msg)
-      override protected def onClose(): Unit = if (!rebooting.get) {
-        if (exitClean.get) {
+      override protected def onClose(): Unit = if !rebooting.get then
+        if exitClean.get then
           val serverDropped = running.get
           exitClean.set(!serverDropped)
-          if (serverDropped && !shutdownOnly)
+          if serverDropped && !shutdownOnly then
             console.appendLog(Level.Error, "sbt server disconnected")
-        }
         running.set(false)
         Option(interactiveThread.get).foreach(_.interrupt())
-      }
-    }
     // initiate handshake
     val execId = UUID.randomUUID.toString
     val skipAnalysis = true
@@ -492,13 +480,12 @@ class NetworkClient(
     )
     conn.sendCommand(initCommand)
     conn
-  }
+  end initImpl
 
-  def init(promptCompleteUsers: Boolean, retry: Boolean): ServerSession = {
+  def init(promptCompleteUsers: Boolean, retry: Boolean): ServerSession =
     val conn = initImpl(promptCompleteUsers = promptCompleteUsers, retry = retry)
     connectionHolder.set(conn)
     conn
-  }
 
   private def bootSocketOpt(bootSocketName: String, namedPipeName: String): Option[Socket] =
     Try(ClientSocket.bootSocket(bootSocketName)).toOption match
@@ -519,7 +506,7 @@ class NetworkClient(
    * Forks another instance of sbt in the background.
    * This instance must be shutdown explicitly via `sbt -client shutdown`
    */
-  def waitForServer(portfile: File, log: Boolean, startServer: Boolean): Unit = {
+  def waitForServer(portfile: File, log: Boolean, startServer: Boolean): Unit =
     val base = arguments.baseDirectory.toPath.toRealPath()
     val target = base.resolve("project").resolve("target")
     val hash = HashUtil.farmHash(target.toString().getBytes("UTF-8"))
@@ -534,7 +521,7 @@ class NetworkClient(
     val term = Terminal.console
     term.exitRawMode()
     var serverStderrFile: Option[File] = None
-    val process = socket match {
+    val process = socket match
       case None if startServer =>
         if log then
           startupMessages.foreach: msg =>
@@ -548,8 +535,8 @@ class NetworkClient(
             term.isSupershellEnabled
           ).mkString(",")
 
-        if (log && arguments.sbtLaunchJar.isDefined) {
-          val sbtScript = if (Properties.isWin) "sbt.bat" else "sbt"
+        if log && arguments.sbtLaunchJar.isDefined then
+          val sbtScript = if Properties.isWin then "sbt.bat" else "sbt"
           console.appendLog(Level.Warn, s"server is started using sbt-launch jar directly")
           console.appendLog(
             Level.Warn,
@@ -559,12 +546,11 @@ class NetworkClient(
             Level.Warn,
             s"either upgrade $sbtScript to its latest version or make sure it is accessible from $$PATH, and run 'sbt bspConfig'"
           )
-        }
         val cmd = NetworkClient.serverCommand(arguments)
 
         // https://github.com/sbt/sbt/issues/6271
         val nohup =
-          if (Util.isEmacs && !Util.isWindows) List("nohup")
+          if Util.isEmacs && !Util.isWindows then List("nohup")
           else Nil
 
         // https://github.com/sbt/sbt/issues/8442
@@ -572,7 +558,7 @@ class NetworkClient(
         // the server process will block on writes. Redirect to files instead of
         // inheriting or piping to avoid buffer deadlocks while still capturing
         // errors for diagnostics (https://github.com/sbt/sbt/issues/8812).
-        val nullFile = new File(if (Util.isWindows) "NUL" else "/dev/null")
+        val nullFile = new File(if Util.isWindows then "NUL" else "/dev/null")
         val stderrFile = Files.createTempFile("sbt-server-err", ".log").toFile
         stderrFile.deleteOnExit()
         serverStderrFile = Some(stderrFile)
@@ -583,38 +569,31 @@ class NetworkClient(
             .redirectOutput(nullFile)
             .redirectError(stderrFile)
         processBuilder.environment.put(Terminal.TERMINAL_PROPS, props)
-        if (arguments.forwardsSysProps) {
+        if arguments.forwardsSysProps then
           processBuilder.environment.put(
             NetworkClient.sysPropsEnv,
             NetworkClient.recordedSysProps(arguments.sbtArguments)
           )
           processBuilder.environment
             .put(NetworkClient.sysPropsPortfileEnv, portfile.getCanonicalPath)
-        } else {
+        else
           Util.ignoreResult(processBuilder.environment.remove(NetworkClient.sysPropsEnv))
           Util.ignoreResult(processBuilder.environment.remove(NetworkClient.sysPropsPortfileEnv))
-        }
-        Try(processBuilder.start()) match {
+        Try(processBuilder.start()) match
           case Success(process) =>
             sbtProcess.set(process)
             Some(process)
           case Failure(e) =>
-            if (log) console.appendLog(Level.Error, s"Failed to start server : $e")
+            if log then console.appendLog(Level.Error, s"Failed to start server : $e")
             throw new ServerFailedException
-        }
       case _ =>
-        if (log) {
-          console.appendLog(Level.Info, "sbt server is booting up")
-        }
+        if log then console.appendLog(Level.Info, "sbt server is booting up")
         None
-    }
-    if (!startServer) {
+    if !startServer then
       val deadline = 5.seconds.fromNow
-      while (socket.isEmpty && !deadline.isOverdue()) {
+      while socket.isEmpty && !deadline.isOverdue() do
         socket = bootSocketOpt(bootSocketName, namedPipeName)
-        if (socket.isEmpty) Thread.sleep(20)
-      }
-    }
+        if socket.isEmpty then Thread.sleep(20)
     val shutdown = new Thread(() => Option(sbtProcess.get).foreach(_.destroyForcibly()))
     Runtime.getRuntime.addShutdownHook(shutdown)
     var gotInputBack = false
@@ -624,19 +603,17 @@ class NetworkClient(
      * so it is necessary to read the process output from the socket on a background
      * thread.
      */
-    val readThread = new Thread("client-read-thread") {
+    val readThread = new Thread("client-read-thread"):
       setDaemon(true)
       start()
-      override def run(): Unit = {
-        try {
+      override def run(): Unit =
+        try
           val buffer = mutable.ArrayBuffer.empty[Byte]
-          while (readThreadAlive.get) {
-            if (socket.isEmpty) {
-              socket = bootSocketOpt(bootSocketName, namedPipeName)
-            }
+          while readThreadAlive.get do
+            if socket.isEmpty then socket = bootSocketOpt(bootSocketName, namedPipeName)
             socket.foreach { s =>
-              try {
-                s.getInputStream.read match {
+              try
+                s.getInputStream.read match
                   case -1 | 0 => readThreadAlive.set(false)
                   case 2      => // STX: start of text
                     gotInputBack = true
@@ -651,54 +628,43 @@ class NetworkClient(
                     buffer.clear()
                   case i =>
                     buffer.append(i.toByte)
-                }
-              } catch {
+              catch
                 case e @ (_: IOException | _: InterruptedException) =>
                   readThreadAlive.set(false)
-              }
             }
-            if (socket.isEmpty && readThreadAlive.get) {
+            if socket.isEmpty && readThreadAlive.get then
               try Thread.sleep(10)
-              catch { case _: InterruptedException => }
-            }
-          }
-        } catch { case e: IOException => e.printStackTrace(System.err) }
-      }
-    }
+              catch
+                case _: InterruptedException =>
+          end while
+        catch case e: IOException => e.printStackTrace(System.err)
     val connectDeadline = connectTimeout.fromNow
     @tailrec
-    def blockUntilStart(): Unit = {
+    def blockUntilStart(): Unit =
       val stop =
-        try {
-          socket match {
+        try
+          socket match
             case None =>
               process.foreach { p =>
                 val output = p.getInputStream
-                while (output.available > 0) {
-                  printStream.write(output.read())
-                }
+                while output.available > 0 do printStream.write(output.read())
               }
             case Some(s) =>
-              while (!gotInputBack && !stdinBytes.isEmpty && socket.isDefined) {
+              while !gotInputBack && !stdinBytes.isEmpty && socket.isDefined do
                 val out = s.getOutputStream
                 val b = stdinBytes.poll
-                if (b == -1) {
+                if b == -1 then
                   // server waits for user input but stinBytes has ended
                   shutdown.run()
-                } else {
+                else
                   out.write(b)
                   out.flush()
-                }
-              }
-          }
           process.foreach { p =>
             val error = p.getErrorStream
-            while (error.available > 0) {
-              errorStream.write(error.read())
-            }
+            while error.available > 0 do errorStream.write(error.read())
           }
           false
-        } catch { case e: IOException => true }
+        catch case e: IOException => true
       Thread.sleep(10)
       printStream.flush()
       errorStream.flush()
@@ -709,9 +675,9 @@ class NetworkClient(
        */
       val existsValidProcess =
         process.fold(readThreadAlive.get)(p => p.isAlive || (Properties.isWin || p.exitValue == 2))
-      if (!portfile.exists && !stop && existsValidProcess && !connectDeadline.isOverdue()) {
+      if !portfile.exists && !stop && existsValidProcess && !connectDeadline.isOverdue() then
         blockUntilStart()
-      } else {
+      else
         connectDeadlineExpired = connectDeadline.isOverdue() && !portfile.exists
         socket.foreach { s =>
           s.getInputStream.close()
@@ -724,60 +690,52 @@ class NetworkClient(
           p.getErrorStream.close()
           p.getInputStream.close()
         }
-      }
-    }
+    end blockUntilStart
 
     try blockUntilStart()
-    catch { case t: Throwable => t.printStackTrace() }
-    finally {
+    catch case t: Throwable => t.printStackTrace()
+    finally
       sbtProcess.set(null)
       Util.ignoreResult(Runtime.getRuntime.removeShutdownHook(shutdown))
-    }
-    if (!portfile.exists()) {
-      if (connectDeadlineExpired) {
+    if !portfile.exists() then
+      if connectDeadlineExpired then
         errorStream.write(
           s"sbt server did not start within ${connectTimeout.toSeconds} seconds\n".getBytes("UTF-8")
         )
         errorStream.flush()
-      }
       // Print captured server stderr so users can see why the server failed to start
-      for (errFile <- serverStderrFile) {
-        try {
-          val bytes = Files.readAllBytes(errFile.toPath)
-          if (bytes.nonEmpty) {
-            errorStream.write(bytes)
-            errorStream.flush()
-          }
-        } catch { case _: Exception => }
+      for errFile <- serverStderrFile do
+        try
+          try
+            val bytes = Files.readAllBytes(errFile.toPath)
+            if bytes.nonEmpty then
+              errorStream.write(bytes)
+              errorStream.flush()
+          catch
+            case _: Exception =>
         finally errFile.delete()
-      }
       throw new ServerFailedException
-    }
     // Clean up stderr temp file on successful startup
     serverStderrFile.foreach(_.delete())
-    if (attached.get && !stdinBytes.isEmpty) inputThread.drain()
-  }
+    if attached.get && !stdinBytes.isEmpty then inputThread.drain()
+  end waitForServer
 
   /** Called on the response for a returning message. */
-  def onReturningResponse(msg: JsonRpcResponseMessage): Unit = {
-    def printResponse(): Unit = {
-      msg.result match {
+  def onReturningResponse(msg: JsonRpcResponseMessage): Unit =
+    def printResponse(): Unit =
+      msg.result match
         case Some(result) =>
           // ignore result JSON
           console.success("completed")
         case _ =>
-          msg.error match {
+          msg.error match
             case Some(err) =>
               // ignore err details
               console.appendLog(Level.Error, "completed")
             case _ => // ignore
-          }
-      }
-    }
     printResponse()
-  }
 
-  private def getExitCode(jvalue: Option[JValue]): Integer = jvalue match {
+  private def getExitCode(jvalue: Option[JValue]): Integer = jvalue match
     case Some(o: JObject) =>
       o.value
         .collectFirst {
@@ -786,7 +744,6 @@ class NetworkClient(
         }
         .getOrElse(1)
     case _ => 1
-  }
 
   private val onAttachResponse: PartialFunction[JsonRpcResponseMessage, Unit] = {
     case msg if attachUUID.get == msg.id =>
@@ -795,58 +752,52 @@ class NetworkClient(
       inputThread.drain()
       ()
   }
-  def completeExec(execId: String, exitCode: Int) = {
-    pendingResults.remove(execId) match {
+  def completeExec(execId: String, exitCode: Int) =
+    pendingResults.remove(execId) match
       case null                 => ()
       case (q, startTime, name) =>
         val now = System.currentTimeMillis
         val message = NetworkClient.elapsedString(startTime, now)
-        if (batchMode.get || !attached.get) {
-          if (exitCode == 0) console.success(message)
+        if batchMode.get || !attached.get then
+          if exitCode == 0 then console.success(message)
           else console.appendLog(Level.Error, message)
-        }
         Util.ignoreResult(q.offer(exitCode))
-    }
-  }
   private val onExecResponse: PartialFunction[JsonRpcResponseMessage, Unit] = {
     case msg if pendingResults.containsKey(msg.id) =>
       completeExec(msg.id, getExitCode(msg.result))
   }
   private val onCancellationResponse: PartialFunction[JsonRpcResponseMessage, Unit] = {
     case msg if pendingCancellations.containsKey(msg.id) =>
-      pendingCancellations.remove(msg.id) match {
+      pendingCancellations.remove(msg.id) match
         case null => ()
         case q    => Util.ignoreResult(q.offer(msg.toString.contains("Task cancelled")))
-      }
   }
   private val onCompletionResponse: PartialFunction[JsonRpcResponseMessage, Unit] = {
     case msg if pendingCompletions.containsKey(msg.id) =>
-      pendingCompletions.remove(msg.id) match {
+      pendingCompletions.remove(msg.id) match
         case null        => ()
         case completions =>
-          completions(msg.result match {
+          completions(msg.result match
             case Some(o: JObject) =>
               o.value
                 .foldLeft(CompletionResponse(Vector.empty[String])) { (resp, i) =>
-                  if (i.field == "items")
+                  if i.field == "items" then
                     resp.withItems(
                       Converter
                         .fromJson[Vector[String]](i.value)
                         .getOrElse(Vector.empty[String])
                     )
-                  else if (i.field == "cachedTestNames")
+                  else if i.field == "cachedTestNames" then
                     resp.withCachedTestNames(
                       Converter.fromJson[Boolean](i.value).getOrElse(true)
                     )
-                  else if (i.field == "cachedMainClassNames")
+                  else if i.field == "cachedMainClassNames" then
                     resp.withCachedMainClassNames(
                       Converter.fromJson[Boolean](i.value).getOrElse(true)
                     )
                   else resp
                 }
-            case _ => CompletionResponse(Vector.empty[String])
-          })
-      }
+            case _ => CompletionResponse(Vector.empty[String]))
   }
   // cache the composed plan
   private val responsePlan = Util.reduceIntents[JsonRpcResponseMessage, Unit](
@@ -858,30 +809,27 @@ class NetworkClient(
   )
   def onResponse(msg: JsonRpcResponseMessage): Unit = responsePlan(msg)
 
-  def onNotification(msg: JsonRpcNotificationMessage): Unit = {
+  def onNotification(msg: JsonRpcNotificationMessage): Unit =
     def splitToMessage: Vector[(Level.Value, String)] =
-      (msg.method, msg.params) match {
+      (msg.method, msg.params) match
         case ("build/logMessage", Some(json)) =>
-          if (!attached.get) {
+          if !attached.get then
             import sbt.internal.langserver.codec.JsonProtocol.given
-            Converter.fromJson[LogMessageParams](json) match {
+            Converter.fromJson[LogMessageParams](json) match
               case Success(params) => splitLogMessage(params)
               case Failure(_)      => Vector()
-            }
-          } else Vector()
+          else Vector()
         case (`systemOut`, Some(json)) =>
-          Converter.fromJson[Array[Byte]](json) match {
+          Converter.fromJson[Array[Byte]](json) match
             case Success(bytes) if bytes.nonEmpty && attached.get =>
               synchronized(printStream.write(bytes))
             case _ =>
-          }
           Vector.empty
         case (`systemErr`, Some(json)) =>
-          Converter.fromJson[Array[Byte]](json) match {
+          Converter.fromJson[Array[Byte]](json) match
             case Success(bytes) if bytes.nonEmpty && attached.get =>
               synchronized(errorStream.write(bytes))
             case _ =>
-          }
           Vector.empty
         case (`systemOutFlush`, _) =>
           synchronized(printStream.flush())
@@ -894,13 +842,12 @@ class NetworkClient(
           Vector.empty
         case ("textDocument/publishDiagnostics", Some(json)) =>
           import sbt.internal.langserver.codec.JsonProtocol.given
-          Converter.fromJson[PublishDiagnosticsParams](json) match {
+          Converter.fromJson[PublishDiagnosticsParams](json) match
             case Success(params) => splitDiagnostics(params); Vector()
             case Failure(_)      => Vector()
-          }
         case (`clientJob`, Some(json)) =>
           import sbt.internal.worker.codec.JsonProtocol.given
-          Converter.fromJson[ClientJobParams](json) match {
+          Converter.fromJson[ClientJobParams](json) match
             case Success(params) =>
               clientSideRun(params) match
                 case Success(_) =>
@@ -914,17 +861,15 @@ class NetworkClient(
                     )
                   else throw e
             case Failure(_) => Vector.empty
-          }
         case (`Shutdown`, Some(_))                => Vector.empty
         case (msg, _) if msg.startsWith("build/") => Vector.empty
         case ("sbt/exec", Some(json))             =>
           import sbt.protocol.codec.JsonProtocol.given
-          Converter.fromJson[ExecStatusEvent](json) match {
+          Converter.fromJson[ExecStatusEvent](json) match
             case Success(event) if event.status == "Queued" =>
               event.message.foreach(m => errorStream.println(s"[info] $m"))
               Vector.empty
             case _ => Vector.empty
-          }
         case _ =>
           Vector(
             (
@@ -932,57 +877,50 @@ class NetworkClient(
               s"unknown event: ${msg.method} " + Serialization.compactPrintJsonOpt(msg.params)
             )
           )
-      }
     splitToMessage foreach { (level, msg) =>
       console.appendLog(level, msg)
     }
-  }
+  end onNotification
 
-  def splitLogMessage(params: LogMessageParams): Vector[(Level.Value, String)] = {
+  def splitLogMessage(params: LogMessageParams): Vector[(Level.Value, String)] =
     val level = messageTypeToLevel(params.`type`)
-    if (level == Level.Debug) Vector()
+    if level == Level.Debug then Vector()
     else Vector((level, params.message))
-  }
 
-  def messageTypeToLevel(severity: Long): Level.Value = {
-    severity match {
+  def messageTypeToLevel(severity: Long): Level.Value =
+    severity match
       case MessageType.Error   => Level.Error
       case MessageType.Warning => Level.Warn
       case MessageType.Info    => Level.Info
       case MessageType.Log     => Level.Debug
-    }
-  }
 
-  def splitDiagnostics(params: PublishDiagnosticsParams): Vector[(Level.Value, String)] = {
+  def splitDiagnostics(params: PublishDiagnosticsParams): Vector[(Level.Value, String)] =
     val uri = new URI(params.uri)
     val f = IO.toFile(uri)
 
     params.diagnostics map { d =>
-      val level = d.severity match {
+      val level = d.severity match
         case Some(severity) => messageTypeToLevel(severity)
         case _              => Level.Error
-      }
       val line = d.range.start.line + 1
       val offset = d.range.start.character + 1
       val msg = s"$f:$line:$offset: ${d.message}"
       (level, msg)
     }
-  }
 
   private def clientSideRun(params: ClientJobParams): Try[Unit] =
-    params.runInfo match {
+    params.runInfo match
       case Some(info) => clientSideRun(info)
       case _          => Failure(new MessageOnlyException(s"runInfo is not specified in $params"))
-    }
 
   private def setWindowTitle(title: String): Unit =
     if System.console() != null && System.getenv("TERM") != null then
       Console.print(s"\u001b]0;$title\u0007")
       Console.flush()
 
-  private def clientSideRun(runInfo: RunInfo): Try[Unit] = {
+  private def clientSideRun(runInfo: RunInfo): Try[Unit] =
     runInfo.windowTitle.foreach(setWindowTitle)
-    def nativeRun(info: NativeRunInfo): Try[Unit] = {
+    def nativeRun(info: NativeRunInfo): Try[Unit] =
       import java.lang.ProcessBuilder as JProcessBuilder
       val option = ForkOptions(
         javaHome = None,
@@ -997,26 +935,24 @@ class NetworkClient(
       val jpb = new JProcessBuilder(command*)
       val exitCode =
         try Fork.blockForExitCode(Fork.forkInternal(option, Nil, jpb))
-        catch {
+        catch
           case _: InterruptedException =>
             log.warn("run canceled")
             1
-        }
       Run.processExitCode(exitCode, "runner")
-    }
     inClientSideRun.set(true)
     try
-      if (runInfo.jvm)
+      if runInfo.jvm then
         RunHandler.jvmRun(runInfo.jvmRunInfo.getOrElse(sys.error("missing jvmRunInfo")), log)
       else nativeRun(runInfo.nativeRunInfo.getOrElse(sys.error("missing nativeRunInfo")))
     finally inClientSideRun.set(false)
-  }
+  end clientSideRun
 
-  def onRequest(msg: JsonRpcRequestMessage): Unit = {
+  def onRequest(msg: JsonRpcRequestMessage): Unit =
     import sbt.protocol.codec.JsonProtocol.given
-    (msg.method, msg.params) match {
+    (msg.method, msg.params) match
       case (`terminalCapabilities`, Some(json)) =>
-        Converter.fromJson[TerminalCapabilitiesQuery](json) match {
+        Converter.fromJson[TerminalCapabilitiesQuery](json) match
           case Success(terminalCapabilitiesQuery) =>
             val response = TerminalCapabilitiesResponse(
               terminalCapabilitiesQuery.boolean
@@ -1032,7 +968,6 @@ class NetworkClient(
               msg.id,
             )
           case Failure(_) =>
-        }
       case (`terminalPropertiesQuery`, _) =>
         val response = TerminalPropertiesResponse.apply(
           width = Terminal.console.getWidth,
@@ -1044,7 +979,7 @@ class NetworkClient(
         )
         sendCommandResponse(terminalPropertiesResponse, response, msg.id)
       case (`setTerminalAttributes`, Some(json)) =>
-        Converter.fromJson[TerminalSetAttributesCommand](json) match {
+        Converter.fromJson[TerminalSetAttributesCommand](json) match
           case Success(attributes) =>
             val attrs = Map(
               "iflag" -> attributes.iflag,
@@ -1056,7 +991,6 @@ class NetworkClient(
             Terminal.console.setAttributes(attrs)
             sendCommandResponse("", TerminalSetAttributesResponse(), msg.id)
           case Failure(_) =>
-        }
       case (`getTerminalAttributes`, _) =>
         val attrs = Terminal.console.getAttributes
         val response = TerminalAttributesResponse(
@@ -1074,50 +1008,44 @@ class NetworkClient(
         )
         sendCommandResponse("", response, msg.id)
       case (`terminalSetSize`, Some(json)) =>
-        Converter.fromJson[TerminalSetSizeCommand](json) match {
+        Converter.fromJson[TerminalSetSizeCommand](json) match
           case Success(size) =>
             Terminal.console.setSize(size.width, size.height)
             sendCommandResponse("", TerminalSetSizeResponse(), msg.id)
           case Failure(_) =>
-        }
       case (`terminalSetEcho`, Some(json)) =>
-        Converter.fromJson[TerminalSetEchoCommand](json) match {
+        Converter.fromJson[TerminalSetEchoCommand](json) match
           case Success(echo) =>
             Terminal.console.setEchoEnabled(echo.toggle)
             sendCommandResponse("", TerminalSetEchoResponse(), msg.id)
           case Failure(_) =>
-        }
       case (`terminalSetRawMode`, Some(json)) =>
-        Converter.fromJson[TerminalSetRawModeCommand](json) match {
+        Converter.fromJson[TerminalSetRawModeCommand](json) match
           case Success(raw) =>
-            if (raw.toggle) Terminal.console.enterRawMode()
+            if raw.toggle then Terminal.console.enterRawMode()
             else Terminal.console.exitRawMode()
             sendCommandResponse("", TerminalSetRawModeResponse(), msg.id)
           case Failure(_) =>
-        }
       case _ =>
-    }
-  }
+    end match
+  end onRequest
 
   def connect(promptCompleteUsers: Boolean): Boolean =
-    try {
+    try
       init(promptCompleteUsers, retry = true)
       true
-    } catch {
+    catch
       case _: ServerFailedException =>
         console.appendLog(Level.Error, "failed to connect to server")
         false
-    }
 
-  private val contHandler: () => Unit = () => {
-    if (Terminal.console.getLastLine.nonEmpty)
+  private val contHandler: () => Unit = () =>
+    if Terminal.console.getLastLine.nonEmpty then
       printStream.print(ConsoleAppender.DeleteLine + Terminal.console.getLastLine.get)
-  }
-  private def withSignalHandler[R](handler: () => Unit, sig: String)(f: => R): R = {
+  private def withSignalHandler[R](handler: () => Unit, sig: String)(f: => R): R =
     val registration = Signals.register(handler, sig)
     try f
     finally registration.remove()
-  }
   private val cancelled = new AtomicBoolean(false)
 
   def run(): Int =
@@ -1127,188 +1055,164 @@ class NetworkClient(
       val userCommands = arguments.commandArguments.takeWhile(_ != TerminateAction)
       val exit = arguments.commandArguments.nonEmpty && userCommands.isEmpty
       attachUUID.set(sendJson(attach, s"""{"interactive": $interactive}"""))
-      val handler: () => Unit = () => {
-        def exitAbruptly() = {
+      val handler: () => Unit = () =>
+        def exitAbruptly() =
           exitClean.set(false)
           close()
-        }
         if inClientSideRun.get() then ()
         else if cancelled.compareAndSet(false, true) then
-          val cancelledTasks = {
+          val cancelledTasks =
             val queue = sendCancelAllCommand()
             Option(queue.poll(1, TimeUnit.SECONDS)).getOrElse(true)
-          }
           if (batchMode.get && pendingResults.isEmpty) || !cancelledTasks then exitAbruptly()
           else cancelled.set(false)
         else exitAbruptly() // handles double ctrl+c to force a shutdown
-      }
       withSignalHandler(handler, Signals.INT) {
-        def block(): Int = {
+        def block(): Int =
           try this.synchronized(this.wait())
-          catch { case _: InterruptedException => }
-          if (exitClean.get) 0 else 1
-        }
+          catch
+            case _: InterruptedException =>
+          if exitClean.get then 0 else 1
         if interactive then block()
         else if exit then 0
-        else {
+        else
           batchMode.set(true)
           val res = batchExecute(userCommands.toList)
-          if (!batchMode.get) block() else res
-        }
+          if !batchMode.get then block() else res
       }
     }
 
-  def batchExecute(userCommands: List[String]): Int = {
+  def batchExecute(userCommands: List[String]): Int =
     val cmd = userCommands.mkString(" ")
     sendAndWait(cmd, None)
-  }
 
-  def getCompletions(query: String): Seq[String] = {
+  def getCompletions(query: String): Seq[String] =
     val quoteCount = query.foldLeft(0) {
       case (count, '"') => count + 1
       case (count, _)   => count
     }
     val inQuote = quoteCount % 2 != 0
-    val (rawPrefix, prefix, rawSuffix, suffix) = if (quoteCount > 0) {
-      query.lastIndexOf('"') match {
+    val (rawPrefix, prefix, rawSuffix, suffix) = if quoteCount > 0 then
+      query.lastIndexOf('"') match
         case -1 => (query, query, None, None) // shouldn't happen
         case i  =>
           val rawPrefix = query.substring(0, i)
           val prefix = rawPrefix.replace("\"", "").replace("\\;", ";")
           val rawSuffix = query.substring(i).replace("\\;", ";")
-          val suffix = if (rawSuffix.length > 1) rawSuffix.substring(1) else ""
+          val suffix = if rawSuffix.length > 1 then rawSuffix.substring(1) else ""
           (rawPrefix, prefix, Some(rawSuffix), Some(suffix))
-      }
-    } else (query, query.replace("\\;", ";"), None, None)
+    else (query, query.replace("\\;", ";"), None, None)
     val tailSpace = query.endsWith(" ") || query.endsWith("\"")
     val sanitizedQuery = suffix.foldLeft(prefix) { _ + _ }
-    def getCompletions(query: String, sendCommand: Boolean): Seq[String] = {
+    def getCompletions(query: String, sendCommand: Boolean): Seq[String] =
       val result = new LinkedBlockingQueue[CompletionResponse]()
       val json = s"""{"query":"$query","level":1}"""
       val execId = sendJson("sbt/completion", json)
       pendingCompletions.put(execId, result.put)
-      val response = result.poll(30, TimeUnit.SECONDS) match {
+      val response = result.poll(30, TimeUnit.SECONDS) match
         case null => throw new TimeoutException("no response from server within 30 seconds")
         case r    => r
-      }
-      def fillCompletions(label: String, regex: String, command: String): Seq[String] = {
-        def updateCompletions(): Seq[String] = {
+      def fillCompletions(label: String, regex: String, command: String): Seq[String] =
+        def updateCompletions(): Seq[String] =
           errorStream.println()
           sendJson(attach, s"""{"interactive": false}""")
           sendAndWait(query.replaceAll(regex + ".*", command).trim, None)
           getCompletions(query, false)
-        }
-        if (noStdErr) Nil
-        else if (noTab) updateCompletions()
-        else {
+        if noStdErr then Nil
+        else if noTab then updateCompletions()
+        else
           errorStream.print(s"\nNo cached $label names found. Press '<tab>' to compile: ")
           startInputThread()
-          stdinBytes.poll(5, TimeUnit.SECONDS) match {
+          stdinBytes.poll(5, TimeUnit.SECONDS) match
             case null        => Nil
             case i if i == 9 => updateCompletions()
             case _           => Nil
-          }
-        }
-      }
       val testNameCompletions =
-        if (!response.cachedTestNames.getOrElse(true) && sendCommand)
+        if !response.cachedTestNames.getOrElse(true) && sendCommand then
           fillCompletions("test", "test(Only|Quick)", "definedTestNames")
         else Nil
       val classNameCompletions =
-        if (!response.cachedMainClassNames.getOrElse(true) && sendCommand)
+        if !response.cachedMainClassNames.getOrElse(true) && sendCommand then
           fillCompletions("main class", "runMain", "discoveredMainClasses")
         else Nil
       val completions = response.items
       testNameCompletions ++ classNameCompletions ++ completions
-    }
+    end getCompletions
     getCompletions(sanitizedQuery, true) collect {
       case c if inQuote                      => c
       case c if tailSpace && c.contains(" ") => c.replace(prefix, "")
       case c if !tailSpace                   => c.split(" ").last
     }
-  }
+  end getCompletions
 
-  private def sendAndWait(cmd: String, limit: Option[Deadline]): Int = {
+  private def sendAndWait(cmd: String, limit: Option[Deadline]): Int =
     val queue = sendExecCommand(cmd)
     var result: Integer = null
-    while (running.get && result == null && limit.fold(true)(!_.isOverdue())) {
-      try {
-        result = limit match {
+    while running.get && result == null && limit.fold(true)(!_.isOverdue()) do
+      try
+        result = limit match
           case Some(l) => queue.poll((l - Deadline.now).toMillis, TimeUnit.MILLISECONDS)
           case _       => queue.take
-        }
-      } catch {
+      catch
         case _: InterruptedException if cmd == Shutdown => result = 0
-        case _: InterruptedException                    => result = if (exitClean.get) 0 else 1
-      }
-    }
-    if (result == null) 1 else result
-  }
+        case _: InterruptedException                    => result = if exitClean.get then 0 else 1
+    if result == null then 1 else result
 
-  def sendExecCommand(commandLine: String): LinkedBlockingQueue[Integer] = {
+  def sendExecCommand(commandLine: String): LinkedBlockingQueue[Integer] =
     val execId = UUID.randomUUID.toString
     val queue = new LinkedBlockingQueue[Integer]
     sendCommand(ExecCommand(commandLine, execId))
     pendingResults.put(execId, (queue, System.currentTimeMillis, commandLine))
     queue
-  }
 
-  def sendCancelAllCommand(): LinkedBlockingQueue[Boolean] = {
+  def sendCancelAllCommand(): LinkedBlockingQueue[Boolean] =
     val queue = new LinkedBlockingQueue[Boolean]
     val execId = sendJson(cancelRequest, s"""{"id":"$CancelAll"}""")
     pendingCancellations.put(execId, queue)
     queue
-  }
 
-  def sendCommand(command: CommandMessage): Unit = {
-    try {
+  def sendCommand(command: CommandMessage): Unit =
+    try
       connection.sendCommand(command)
       lock.synchronized {
         status.set("Processing")
       }
-    } catch {
+    catch
       case e: SocketException if command.toString.contains("exit") => running.set(false)
       case e: IOException                                          =>
         errorStream.println(s"Caught exception writing command to server: $e")
         running.set(false)
-    }
-  }
-  def sendCommandResponse(method: String, command: EventMessage, id: String): Unit = {
+  def sendCommandResponse(method: String, command: EventMessage, id: String): Unit =
     import sbt.protocol.codec.JsonProtocol.given
-    try {
-      connection.sendJsonRpcResponse(id, command)
-    } catch {
+    try connection.sendJsonRpcResponse(id, command)
+    catch
       case e: IOException =>
         errorStream.println(s"Caught exception writing command to server: $e")
         running.set(false)
-    }
-  }
-  def sendJson(method: String, params: String): String = {
+  def sendJson(method: String, params: String): String =
     val uuid = UUID.randomUUID.toString
     sendJson(method, params, uuid)
     uuid
-  }
-  def sendJson(method: String, params: String, uuid: String): Unit = {
+  def sendJson(method: String, params: String, uuid: String): Unit =
     connection.sendJsonRpcRaw(uuid, method, params)
-  }
 
-  def sendNotification(method: String, params: String): Unit = {
+  def sendNotification(method: String, params: String): Unit =
     connection.sendJsonRpcNotificationRaw(method, params)
-  }
 
   override def close(): Unit =
-    try {
+    try
       running.set(false)
       stdinBytes.offer(-1)
       val mainThread = interactiveThread.getAndSet(null)
-      if (mainThread != null && mainThread != Thread.currentThread) mainThread.interrupt
-      if (connectionHolder.get ne null)
+      if mainThread != null && mainThread != Thread.currentThread then mainThread.interrupt
+      if connectionHolder.get ne null then
         try sendExecCommand("exit")
         finally connectionHolder.close()
       inputThread.close()
-    } catch {
-      case t: Throwable => t.printStackTrace(); throw t
-    }
+    catch
+      case t: Throwable =>
+        t.printStackTrace()
+        throw t
 
   /**
    * Reads stdin on behalf of the server, which asks for it one byte at a time via
@@ -1342,10 +1246,9 @@ class NetworkClient(
     def request(): Unit = readGate.release()
     def cancel(): Unit = interrupt()
     def drain(): Unit = inLock.synchronized {
-      while (!stdinBytes.isEmpty) {
+      while !stdinBytes.isEmpty do
         val byte = stdinBytes.poll()
         sendNotification(systemIn, byte.toString)
-      }
     }
 
     override def close(): Unit =
@@ -1353,38 +1256,35 @@ class NetworkClient(
       readGate.release()
       RawInputThread.this.interrupt()
   end RawInputThread
-}
+end NetworkClient
 
-object NetworkClient {
+object NetworkClient:
   private[sbt] val CancelAll = "__CancelAll"
-  private def consoleAppenderInterface(printStream: PrintStream): ConsoleInterface = {
+  private def consoleAppenderInterface(printStream: PrintStream): ConsoleInterface =
     val appender = ConsoleAppender("thin", ConsoleOut.printStreamOut(printStream))
-    new ConsoleInterface {
+    new ConsoleInterface:
       override def appendLog(level: Level.Value, message: => String): Unit =
         appender.appendLog(level, message)
       override def success(msg: String): Unit = appender.success(msg)
-    }
-  }
   private def simpleConsoleInterface(
       doPrintln: String => Unit,
       useColor: Boolean
   ): ConsoleInterface =
-    new ConsoleInterface {
+    new ConsoleInterface:
       import scala.Console.{ GREEN, RED, RESET, YELLOW }
       override def appendLog(level: Level.Value, message: => String): Unit = synchronized {
         val prefix =
-          if (useColor) level match {
-            case Level.Error => s"[$RED$level$RESET]"
-            case Level.Warn  => s"[$YELLOW$level$RESET]"
-            case _           => s"[$RESET$level$RESET]"
-          }
+          if useColor then
+            level match
+              case Level.Error => s"[$RED$level$RESET]"
+              case Level.Warn  => s"[$YELLOW$level$RESET]"
+              case _           => s"[$RESET$level$RESET]"
           else s"[$level]"
         message.linesIterator.foreach(line => doPrintln(s"$prefix $line"))
       }
       override def success(msg: String): Unit =
-        if (useColor) doPrintln(s"[${GREEN}success$RESET] $msg")
+        if useColor then doPrintln(s"[${GREEN}success$RESET] $msg")
         else doPrintln(s"[success] $msg")
-    }
   private[client] class Arguments(
       val baseDirectory: File,
       val sbtArguments: Seq[String],
@@ -1397,7 +1297,7 @@ object NetworkClient {
       // false when -D options went to the JVM running this client instead of its arguments,
       // in which case they say nothing about the server
       val forwardsSysProps: Boolean = true,
-  ) {
+  ):
     def withBaseDirectory(file: File): Arguments =
       copy(baseDirectory = file)
     def withoutSysProps: Arguments =
@@ -1417,9 +1317,9 @@ object NetworkClient {
         launcherValueArgs,
         forwardsSysProps,
       )
-  }
+  end Arguments
   private[client] def serverCommand(arguments: Arguments): List[String] =
-    arguments.sbtLaunchJar match {
+    arguments.sbtLaunchJar match
       case Some(lj) =>
         val java =
           Option(Properties.javaHome).map(javaHome => s"$javaHome/bin/java").getOrElse("java")
@@ -1428,7 +1328,6 @@ object NetworkClient {
       case _ =>
         List(arguments.sbtScript) ++ arguments.launcherValueArgs ++ arguments.sbtArguments ++
           List(DashDashDetachStdio, DashDashServer)
-    }
 
   /** Carries the `-D` options a client forwards to the server it starts. */
   private[sbt] val sysPropsEnv = "SBT_SERVER_SYS_PROPS"
@@ -1617,8 +1516,8 @@ object NetworkClient {
   )
   private[client] val launcherValueEqPrefixes: Seq[String] =
     launcherValueFlags.toSeq.map(_ + "=")
-  private[client] def parseArgs(args: Array[String]): Arguments = {
-    val defaultSbtScript = if (Properties.isWin) "sbt.bat" else "sbt"
+  private[client] def parseArgs(args: Array[String]): Arguments =
+    val defaultSbtScript = if Properties.isWin then "sbt.bat" else "sbt"
     var sbtScript = Properties.propOrNone("sbt.script")
     var launchJar: Option[String] = None
     var bsp = false
@@ -1636,25 +1535,22 @@ object NetworkClient {
       case a =>
         var first = true
         a.split(" ").foreach { part =>
-          if (part.nonEmpty) {
+          if part.nonEmpty then
             sanitized += part
             splitFromPrev += !first
             first = false
-          }
         }
     }
-    def valueFrom(start: Int): (String, Int) = {
+    def valueFrom(start: Int): (String, Int) =
       var last = start
       val sb = new StringBuilder(sanitized(start))
-      while (last + 1 < sanitized.length && splitFromPrev(last + 1)) {
+      while last + 1 < sanitized.length && splitFromPrev(last + 1) do
         last += 1
         sb.append(" ").append(sanitized(last))
-      }
       (sb.toString, last)
-    }
     var i = 0
-    while (i < sanitized.length) {
-      sanitized(i) match {
+    while i < sanitized.length do
+      sanitized(i) match
         case a if completionArguments.nonEmpty                        => completionArguments += a
         case a if commandArgs.nonEmpty && emptyBuildFlags.contains(a) =>
           sbtArguments += a
@@ -1685,20 +1581,18 @@ object NetworkClient {
         case a if a.startsWith("-autostart=") =>
           System.setProperty("sbt.server.autostart", a.stripPrefix("-autostart="))
         case a if launcherValueFlags.contains(a) =>
-          if (i + 1 < sanitized.length) {
+          if i + 1 < sanitized.length then
             launcherValueArgs += a
             val (value, last) = valueFrom(i + 1)
             launcherValueArgs += value
             i = last
-          }
         case a if launcherValueEqPrefixes.exists(p => a.startsWith(p)) =>
           val (full, last) = valueFrom(i)
           i = last
           val eq = full.indexOf('=')
-          if (eq < full.length - 1) {
+          if eq < full.length - 1 then
             launcherValueArgs += full.substring(0, eq)
             launcherValueArgs += full.substring(eq + 1)
-          }
         case a if launcherNoValueFlags.contains(a)                => ()
         case a if launcherEqPrefixes.exists(p => a.startsWith(p)) => ()
         case a if a.startsWith("-J")                              => ()
@@ -1707,16 +1601,15 @@ object NetworkClient {
           System.setProperty(key, value)
           sbtArguments += a
         case a => sbtArguments += a
-      }
+      end match
       i += 1
-    }
+    end while
     val base = new File("").getCanonicalFile
-    if (!sbtArguments.contains("-Dsbt.io.virtual=true")) sbtArguments += "-Dsbt.io.virtual=true"
-    if (!sbtArguments.exists(_.startsWith("-Dsbt.script"))) {
+    if !sbtArguments.contains("-Dsbt.io.virtual=true") then sbtArguments += "-Dsbt.io.virtual=true"
+    if !sbtArguments.exists(_.startsWith("-Dsbt.script")) then
       sbtScript.foreach { sbtScript =>
         sbtArguments += s"-Dsbt.script=$sbtScript"
       }
-    }
     new Arguments(
       base,
       sbtArguments.toSeq,
@@ -1727,24 +1620,22 @@ object NetworkClient {
       launchJar,
       launcherValueArgs.toSeq,
     )
-  }
+  end parseArgs
 
   def elapsedString(startTime: Long, endTime: Long): String =
     s"elapsed time: ${elapsedStr(startTime, endTime)}"
 
-  private def elapsedStr(startTime: Long, endTime: Long): String = {
+  private def elapsedStr(startTime: Long, endTime: Long): String =
     val total = (endTime - startTime + 500) / 1000
     s"$total s" +
-      (if (total <= 60) ""
-       else {
+      (if total <= 60 then ""
+       else
          val hours = total / 3600 match
            case 0 => "0"
            case h => f"$h%02d"
          val mins = f"${total % 3600 / 60}%02d"
          val secs = f"${total % 60}%02d"
-         s" ($hours:$mins:$secs.0)"
-       })
-  }
+         s" ($hours:$mins:$secs.0)")
 
   def client(
       baseDirectory: File,
@@ -1753,7 +1644,7 @@ object NetworkClient {
       printStream: PrintStream,
       errorStream: PrintStream,
       useJNI: Boolean
-  ): Int = {
+  ): Int =
     val client =
       simpleClient(
         NetworkClient.parseArgs(args).withBaseDirectory(baseDirectory),
@@ -1762,15 +1653,15 @@ object NetworkClient {
         errorStream,
         useJNI,
       )
-    try {
-      if (client.connect(promptCompleteUsers = false)) client.run()
+    try
+      if client.connect(promptCompleteUsers = false) then client.run()
       else 1
-    } catch {
+    catch
       case e: Exception =>
         client.logFailure(e)
         1
-    } finally client.close()
-  }
+    finally client.close()
+  end client
   def client(
       baseDirectory: File,
       args: Arguments,
@@ -1778,8 +1669,8 @@ object NetworkClient {
       errorStream: PrintStream,
       terminal: Terminal,
       useJNI: Boolean
-  ): Int = {
-    val printStream = if (args.bsp) errorStream else terminal.printStream
+  ): Int =
+    val printStream = if args.bsp then errorStream else terminal.printStream
     val client =
       simpleClient(
         args.withBaseDirectory(baseDirectory),
@@ -1789,23 +1680,19 @@ object NetworkClient {
         useJNI,
       )
     clientImpl(client, args.bsp)
-  }
-  private def clientImpl(client: NetworkClient, isBsp: Boolean): Int = {
-    try {
-      if (isBsp) {
+  private def clientImpl(client: NetworkClient, isBsp: Boolean): Int =
+    try
+      if isBsp then
         val (socket, _) =
           client.connectOrStartServerAndConnect(promptCompleteUsers = false, retry = true)
         BspClient.bspRun(socket)
-      } else {
-        if (client.connect(promptCompleteUsers = false)) client.run()
-        else 1
-      }
-    } catch {
+      else if client.connect(promptCompleteUsers = false) then client.run()
+      else 1
+    catch
       case e: Exception =>
         client.logFailure(e)
         1
-    } finally client.close()
-  }
+    finally client.close()
   def client(
       baseDirectory: File,
       args: Array[String],
@@ -1821,60 +1708,54 @@ object NetworkClient {
       printStream: PrintStream,
       errorStream: PrintStream,
       useJNI: Boolean,
-  ): NetworkClient = {
+  ): NetworkClient =
     val interface =
       NetworkClient.simpleConsoleInterface(printStream.println, Terminal.isColorEnabled)
     new NetworkClient(arguments, interface, inputStream, errorStream, printStream, useJNI)
-  }
-  def main(args: Array[String]): Unit = {
+  def main(args: Array[String]): Unit =
     val (jnaArg, restOfArgs) = args.partition(_ == "--jna")
     val useJNI = jnaArg.isEmpty
     val base = new File("").getCanonicalFile
-    if (restOfArgs.exists(_.startsWith(NetworkClient.completions)))
+    if restOfArgs.exists(_.startsWith(NetworkClient.completions)) then
       System.exit(complete(base, restOfArgs, useJNI, System.in, System.out))
-    else {
-      val hook = new Thread(() => {
+    else
+      val hook = new Thread(() =>
         System.out.print(ConsoleAppender.ClearScreenAfterCursor)
         System.out.flush()
-      })
+      )
       Runtime.getRuntime.addShutdownHook(hook)
       val parsed = parseArgs(restOfArgs)
       System.exit(Terminal.withStreams(isServer = false, isSubProcess = false) {
         val term = Terminal.console
         try client(base, parsed, term.inputStream, System.err, term, useJNI)
-        catch { case _: AccessDeniedException => 1 }
-        finally {
+        catch case _: AccessDeniedException => 1
+        finally
           Runtime.getRuntime.removeShutdownHook(hook)
           hook.run()
-        }
       })
-    }
-  }
+  end main
   def complete(
       baseDirectory: File,
       args: Array[String],
       useJNI: Boolean,
       in: InputStream,
       out: PrintStream
-  ): Int = {
-    val cmd: String = args.find(_.startsWith(NetworkClient.completions)) match {
+  ): Int =
+    val cmd: String = args.find(_.startsWith(NetworkClient.completions)) match
       case Some(c) =>
-        c.split('=').lastOption match {
+        c.split('=').lastOption match
           case Some(query) =>
-            query.indexOf(" ") match {
+            query.indexOf(" ") match
               case -1 => throw new IllegalArgumentException(query)
               case i  => query.substring(i + 1)
-            }
           case _ => throw new IllegalArgumentException(c)
-        }
       case _ => throw new IllegalStateException("should be unreachable")
-    }
     val quiet = args.exists(_ == "--quiet")
-    val errorStream = if (quiet) new PrintStream(_ => {}, false) else System.err
+    val errorStream = if quiet then new PrintStream(_ => {}, false) else System.err
     val sbtArgs = args.takeWhile(!_.startsWith(NetworkClient.completions))
     val arguments = NetworkClient.parseArgs(sbtArgs)
     val noTab = args.contains("--no-tab")
-    try {
+    try
       val client =
         simpleClient(
           arguments.withBaseDirectory(baseDirectory),
@@ -1883,16 +1764,16 @@ object NetworkClient {
           printStream = errorStream,
           useJNI = useJNI,
         )
-      try {
+      try
         val results =
-          if (client.connect(promptCompleteUsers = true)) client.getCompletions(cmd)
+          if client.connect(promptCompleteUsers = true) then client.getCompletions(cmd)
           else Nil
         out.println(results.sorted.distinct mkString "\n")
         0
-      } catch { case _: Exception => 1 }
+      catch case _: Exception => 1
       finally client.close()
-    } catch { case _: AccessDeniedException => 1 }
-  }
+    catch case _: AccessDeniedException => 1
+  end complete
 
   def run(configuration: xsbti.AppConfiguration, arguments: List[String]): Int =
     run(configuration, arguments, false)
@@ -1900,10 +1781,10 @@ object NetworkClient {
       configuration: xsbti.AppConfiguration,
       arguments: List[String],
       redirectOutput: Boolean
-  ): Int = {
+  ): Int =
     val term = Terminal.console
     val err = new PrintStream(term.errorStream)
-    val out = if (redirectOutput) err else new PrintStream(term.outputStream)
+    val out = if redirectOutput then err else new PrintStream(term.outputStream)
     val args =
       parseArgs(arguments.toArray).withoutSysProps.withBaseDirectory(configuration.baseDirectory)
     val useJNI =
@@ -1911,6 +1792,5 @@ object NetworkClient {
         System.getProperty("sbt.ipcsocket.jni", "false") == "true"
     val client = simpleClient(args, term.inputStream, out, err, useJNI = useJNI)
     clientImpl(client, args.bsp)
-  }
   private class AccessDeniedException extends Throwable
-}
+end NetworkClient
diff --git a/main-command/src/main/scala/sbt/internal/server/Server.scala b/main-command/src/main/scala/sbt/internal/server/Server.scala
index 4b83766e5..e47454f4e 100644
--- a/main-command/src/main/scala/sbt/internal/server/Server.scala
+++ b/main-command/src/main/scala/sbt/internal/server/Server.scala
@@ -31,14 +31,13 @@ import sbt.internal.bsp.BuildServerConnection
 import sbt.protocol.ClientSocket
 import xsbti.AppConfiguration
 
-private[sbt] sealed trait ServerInstance {
+private[sbt] sealed trait ServerInstance:
   def shutdown(): Unit
   def serverId: String
   def ready: Future[Unit]
   def authenticate(challenge: String): Boolean
-}
 
-private[sbt] object Server {
+private[sbt] object Server:
   sealed trait JsonProtocol
       extends sjsonnew.BasicJsonProtocol
       with PortFileFormats
@@ -54,7 +53,8 @@ private[sbt] object Server {
       onIncomingSocket: (AtomicReference[Socket], ServerInstance) => Unit,
       log: Logger
   ): ServerInstance =
-    new ServerInstance { self =>
+    new ServerInstance:
+      self =>
       import connection.*
       val running = new AtomicBoolean(false)
       val p: Promise[Unit] = Promise[Unit]()
@@ -64,10 +64,10 @@ private[sbt] object Server {
       private val serverSocketHolder = AtomicCloseable[ServerSocket]()
       override val serverId: String = java.util.UUID.randomUUID().toString
 
-      val serverThread = new Thread("sbt-socket-server") {
-        override def run(): Unit = {
+      val serverThread = new Thread("sbt-socket-server"):
+        override def run(): Unit =
           Try {
-            connection.connectionType match {
+            connection.connectionType match
               case ConnectionType.Local if isWindows =>
                 // Named pipe already has an exclusive lock.
                 addServerError(
@@ -81,7 +81,7 @@ private[sbt] object Server {
                 val maxSocketLength =
                   UnixDomainSocketLibraryProvider.maxSocketLength(connection.useJni) - 1
                 val path = socketfile.getAbsolutePath
-                if (path.length > maxSocketLength)
+                if path.length > maxSocketLength then
                   sys.error(
                     "socket file absolute path too long; " +
                       "either switch to another connection type " +
@@ -94,56 +94,47 @@ private[sbt] object Server {
               case ConnectionType.Tcp =>
                 tryClient(new Socket(InetAddress.getByName(host), port))
                 addServerError(new ServerSocket(port, 50, InetAddress.getByName(host)))
-            }
-          } match {
+          } match
             case Failure(e)            => p.failure(e)
             case Success(serverSocket) =>
               serverSocket.setSoTimeout(5000)
               serverSocketHolder.set(serverSocket)
               log.debug(s"sbt server started at ${connection.shortName}")
               writePortfile()
-              if (connection.bspEnabled) {
+              if connection.bspEnabled then
                 log.debug("Writing bsp connection file")
                 BuildServerConnection.writeConnectionFile(
                   appConfiguration.provider.id.version,
                   appConfiguration.baseDirectory
                 )
-              }
               running.set(true)
               p.success(())
-              while (running.get()) {
+              while running.get() do
                 val clientSocket = AtomicCloseable[Socket]()
-                try {
+                try
                   clientSocket.set(serverSocket.accept())
                   onIncomingSocket(clientSocket.ref, self)
-                } catch {
+                catch
                   case scala.util.control.NonFatal(e) if clientSocket.get ne null =>
                     log.error(s"sbt server failed to serve a client: $e")
                     log.trace(e)
                   case e: IOException if Option(e.getMessage).exists(_.contains("connect")) =>
                   case _: SocketTimeoutException          => // its ok
                   case _: SocketException if !running.get => // the server is shutting down
-                }
                 clientSocket.close()
-              }
               serverSocketHolder.close()
-          }
-        }
-      }
       serverThread.start()
 
       // Try the socket as a client to make sure that the server is not already up.
       // f tries to connect to the server, and flip the result.
-      def tryClient(f: => Socket): Unit = {
-        if (portfile.exists) {
-          Try { f } match {
+      def tryClient(f: => Socket): Unit =
+        if portfile.exists then
+          Try { f } match
             case Failure(_)      => ()
             case Success(socket) =>
               socket.close()
               throw new AlreadyRunningException()
-          }
-        } else ()
-      }
+        else ()
 
       def addServerError(f: => ServerSocket): ServerSocket =
         ErrorHandling.translate(s"server failed to start on ${connection.shortName}. ") {
@@ -151,27 +142,25 @@ private[sbt] object Server {
         }
 
       override def authenticate(challenge: String): Boolean = synchronized {
-        if (token == challenge) {
+        if token == challenge then
           token = nextToken
           writeTokenfile()
           true
-        } else false
+        else false
       }
 
       /** Generates 128-bit non-negative integer, and represent it as decimal string. */
-      private def nextToken: String = {
+      private def nextToken: String =
         new BigInteger(128, rand).toString
-      }
 
-      override def shutdown(): Unit = {
-        if (serverIdOf(portfile).getOrElse(None).contains(serverId)) IO.delete(portfile)
+      override def shutdown(): Unit =
+        if serverIdOf(portfile).getOrElse(None).contains(serverId) then IO.delete(portfile)
         IO.delete(tokenfile)
         running.set(false)
         serverSocketHolder.close()
         log.info("shutting down sbt server")
-      }
 
-      private def writeTokenfile(): Unit = {
+      private def writeTokenfile(): Unit =
         import JsonProtocol.given
 
         val uri = connection.shortName
@@ -181,10 +170,9 @@ private[sbt] object Server {
         IO.writeFileAtomically(tokenfile, ownerOnly = true)(tmp =>
           IO.write(tmp, CompactPrinter(jsonToken), IO.utf8, false)
         )
-      }
 
       // This file exists through the lifetime of the server.
-      private def writePortfile(): Unit = {
+      private def writePortfile(): Unit =
         import JsonProtocol.given
 
         val uri = connection.shortName
@@ -194,34 +182,30 @@ private[sbt] object Server {
           .get(NetworkClient.sysPropsPortfileEnv)
           .map(new File(_).getCanonicalFile)
           .contains(portfile.getCanonicalFile)
-        val recorded = if (startedByThisBuild) sys.env.get(NetworkClient.sysPropsEnv) else None
+        val recorded = if startedByThisBuild then sys.env.get(NetworkClient.sysPropsEnv) else None
         val sysProps = recorded.toVector.flatMap(NetworkClient.decodeSysProps)
         // an empty list of options and no idea what the options are read the same, so say
         // which of the two this is: a client can restart a server over the first but has no
         // business taking down one whose options it never saw
         val sysPropsRecorded = Option(startedByThisBuild)
         val authOK = auth(ServerAuthentication.Token)
-        if (authOK) writeTokenfile()
+        if authOK then writeTokenfile()
         val p = PortFile(
           uri,
-          if (authOK) Some(tokenfile.toString) else None,
-          if (authOK) Some(IO.toURI(tokenfile).toString) else None,
+          if authOK then Some(tokenfile.toString) else None,
+          if authOK then Some(IO.toURI(tokenfile).toString) else None,
           sysProps,
           sysPropsRecorded,
           Some(serverId)
         )
         val json = Converter.toJson(p).get
         IO.writeFileAtomically(portfile)(tmp => IO.write(tmp, CompactPrinter(json)))
-      }
+      end writePortfile
 
-      private[sbt] def prepareSocketfile(): Unit = {
-        if (socketfile.exists) {
-          IO.delete(socketfile)
-        }
+      private[sbt] def prepareSocketfile(): Unit =
+        if socketfile.exists then IO.delete(socketfile)
         IO.createDirectory(socketfile.getParentFile)
-      }
-    }
-}
+end Server
 
 private[sbt] case class ServerConnection(
     connectionType: ConnectionType,
@@ -236,15 +220,12 @@ private[sbt] case class ServerConnection(
     windowsServerSecurityLevel: Int,
     useJni: Boolean,
     bspEnabled: Boolean,
-) {
-  def shortName: String = {
-    connectionType match {
+):
+  def shortName: String =
+    connectionType match
       case ConnectionType.Local if isWindows => s"local:$pipeName"
       case ConnectionType.Local              => s"local://$socketfile"
       case ConnectionType.Tcp                => s"tcp://$host:$port"
       // case ConnectionType.Ssh                => s"ssh://$host:$port"
-    }
-  }
-}
 
 private[sbt] class AlreadyRunningException extends IOException("sbt server is already running.")
diff --git a/main-command/src/main/scala/sbt/internal/server/ServerHandler.scala b/main-command/src/main/scala/sbt/internal/server/ServerHandler.scala
index be88d5237..248340734 100644
--- a/main-command/src/main/scala/sbt/internal/server/ServerHandler.scala
+++ b/main-command/src/main/scala/sbt/internal/server/ServerHandler.scala
@@ -20,11 +20,10 @@ import sbt.internal.langserver.CancelRequestParams as CRP
  * ServerHandler allows plugins to extend sbt server.
  * It's a wrapper around curried function ServerCallback => JsonRpcRequestMessage => Unit.
  */
-final class ServerHandler(val handler: ServerCallback => ServerIntent) {
+final class ServerHandler(val handler: ServerCallback => ServerIntent):
   override def toString: String = s"Serverhandler(...)"
-}
 
-object ServerHandler {
+object ServerHandler:
   def apply(handler: ServerCallback => ServerIntent): ServerHandler =
     new ServerHandler(handler)
 
@@ -40,17 +39,15 @@ object ServerHandler {
       },
     )
   })
-}
 
 final class ServerIntent(
     val onRequest: PartialFunction[JsonRpcRequestMessage, Unit],
     val onResponse: PartialFunction[JsonRpcResponseMessage, Unit],
     val onNotification: PartialFunction[JsonRpcNotificationMessage, Unit]
-) {
+):
   override def toString: String = s"ServerIntent(...)"
-}
 
-object ServerIntent {
+object ServerIntent:
   def apply(
       onRequest: PartialFunction[JsonRpcRequestMessage, Unit],
       onResponse: PartialFunction[JsonRpcResponseMessage, Unit],
@@ -65,12 +62,11 @@ object ServerIntent {
     new ServerIntent(PartialFunction.empty, onResponse, PartialFunction.empty)
   def notify(onNotification: PartialFunction[JsonRpcNotificationMessage, Unit]): ServerIntent =
     new ServerIntent(PartialFunction.empty, PartialFunction.empty, onNotification)
-}
 
 /**
  * Interface to invoke JSON-RPC response.
  */
-trait ServerCallback {
+trait ServerCallback:
   def jsonRpcRespond[A: JsonFormat](event: A, execId: Option[String]): Unit
   def jsonRpcRespondError(execId: Option[String], code: Long, message: String): Unit
   def jsonRpcNotify[A: JsonFormat](method: String, params: A): Unit
@@ -87,4 +83,3 @@ trait ServerCallback {
   private[sbt] def onSettingQuery(execId: Option[String], req: Q): Unit
   private[sbt] def onCompletionRequest(execId: Option[String], cp: CP): Unit
   private[sbt] def onCancellationRequest(execId: Option[String], crp: CRP): Unit
-}
diff --git a/main-command/src/main/scala/sbt/internal/ui/UITask.scala b/main-command/src/main/scala/sbt/internal/ui/UITask.scala
index 6789e8fa0..6971426c3 100644
--- a/main-command/src/main/scala/sbt/internal/ui/UITask.scala
+++ b/main-command/src/main/scala/sbt/internal/ui/UITask.scala
@@ -23,37 +23,30 @@ import sbt.internal.util.complete.Parser
 
 import scala.annotation.tailrec
 
-private[sbt] trait UITask extends Runnable with AutoCloseable {
+private[sbt] trait UITask extends Runnable with AutoCloseable:
   private[sbt] val channel: CommandChannel
   private[sbt] def reader: UITask.Reader
-  private final def handleInput(s: Either[String, String]): Boolean = s match {
+  private final def handleInput(s: Either[String, String]): Boolean = s match
     case Left(m)    => channel.onFastTrackTask(m)
     case Right(cmd) => channel.onCommandLine(cmd)
-  }
   private val isStopped = new AtomicBoolean(false)
-  override def run(): Unit = {
-    @tailrec def impl(): Unit = if (!isStopped.get) {
+  override def run(): Unit =
+    @tailrec def impl(): Unit = if !isStopped.get then
       val res = reader.readLine()
-      if (!handleInput(res) && !isStopped.get) impl()
-    }
+      if !handleInput(res) && !isStopped.get then impl()
     try impl()
-    catch { case _: InterruptedException | _: ClosedChannelException => isStopped.set(true) }
-  }
-  override def close(): Unit = {
+    catch case _: InterruptedException | _: ClosedChannelException => isStopped.set(true)
+  override def close(): Unit =
     isStopped.set(true)
     reader.close()
-  }
-}
 
-private[sbt] object UITask {
-  case object NoShellPrompt extends (State => String) {
+private[sbt] object UITask:
+  case object NoShellPrompt extends (State => String):
     override def apply(state: State): String = ""
-  }
-  trait Reader extends AutoCloseable {
+  trait Reader extends AutoCloseable:
     def readLine(): Either[String, String]
     override def close(): Unit = {}
-  }
-  object Reader {
+  object Reader:
     // Avoid filling the stack trace since it isn't helpful here
     object interrupted extends InterruptedException
 
@@ -63,28 +56,27 @@ private[sbt] object UITask {
     def splitCommand(cmd: String): Either[String, String] =
       // We need to put the empty string on the fast track queue so that we can
       // reprompt the user if another command is running on the server.
-      if (cmd.isEmpty()) Left("")
+      if cmd.isEmpty() then Left("")
       else
-        cmd match {
+        cmd match
           case Shutdown | TerminateAction | Cancel => Left(cmd)
           case cmd                                 => Right(cmd)
-        }
 
     def terminalReader(parser: Parser[?])(
         terminal: Terminal,
         state: State
-    ): Reader = new Reader {
+    ): Reader = new Reader:
       val closed = new AtomicBoolean(false)
       def readLine(): Either[String, String] =
-        try {
+        try
           val clear = terminal.ansi(ClearPromptLine, "")
-          val res = {
+          val res =
             val thread = Thread.currentThread
-            if (thread.isInterrupted || closed.get) throw interrupted
+            if thread.isInterrupted || closed.get then throw interrupted
             val reader = LineReader.createReader(history(state), parser, terminal)
-            if (thread.isInterrupted || closed.get) throw interrupted
+            if thread.isInterrupted || closed.get then throw interrupted
             (try reader.readLine(clear + terminal.prompt.mkPrompt())
-            finally reader.close) match {
+            finally reader.close) match
               case None if terminal == Terminal.console && !hasConsole =>
                 // No stdin is attached to the process so just ignore the result and
                 // block until the thread is interrupted.
@@ -94,33 +86,26 @@ private[sbt] object UITask {
               // ctrl+d with no imput as an exit
               case None            => Left(TerminateAction)
               case Some(s: String) => splitCommand(s.trim())
-            }
-          }
           terminal.setPrompt(Prompt.Pending)
           res
-        } catch { case e: InterruptedException => Left("") }
+        catch case e: InterruptedException => Left("")
       override def close(): Unit = closed.set(true)
-    }
-  }
+  end Reader
   private def history(s: State): Option[File] =
     s.get(historyPath).getOrElse(Some(new File(s.baseDir, ".history")))
   private[sbt] def shellPrompt(terminal: Terminal, s: State): String =
-    s.get(sbt.BasicKeys.shellPrompt) match {
+    s.get(sbt.BasicKeys.shellPrompt) match
       case Some(NoShellPrompt) | None =>
-        s.get(colorShellPrompt) match {
+        s.get(colorShellPrompt) match
           case Some(pf) => pf(terminal.isColorEnabled, s)
           case None     =>
-            def color(s: String): String = if (terminal.isColorEnabled) s"$s" else ""
+            def color(s: String): String = if terminal.isColorEnabled then s"$s" else ""
             s"${color(DeleteLine)}> ${color(ClearScreenAfterCursor)}"
-        }
       case Some(p) => p(s)
-    }
   private[sbt] class AskUserTask(
       state: State,
       override val channel: CommandChannel,
-  ) extends UITask {
-    override private[sbt] lazy val reader: UITask.Reader = {
+  ) extends UITask:
+    override private[sbt] lazy val reader: UITask.Reader =
       UITask.Reader.terminalReader(state.combinedParser)(channel.terminal, state)
-    }
-  }
-}
+end UITask
diff --git a/main-command/src/main/scala/sbt/internal/ui/UserThread.scala b/main-command/src/main/scala/sbt/internal/ui/UserThread.scala
index 4d83485cb..9d7f1205c 100644
--- a/main-command/src/main/scala/sbt/internal/ui/UserThread.scala
+++ b/main-command/src/main/scala/sbt/internal/ui/UserThread.scala
@@ -18,59 +18,50 @@ import scala.concurrent.duration.*
 import sbt.internal.util.JoinThread.*
 import sbt.internal.util.{ ConsoleAppender, ProgressEvent, ProgressState, Prompt }
 
-private[sbt] class UserThread(val channel: CommandChannel) extends AutoCloseable {
+private[sbt] class UserThread(val channel: CommandChannel) extends AutoCloseable:
   private val uiThread = new AtomicReference[(UITask, Thread)]
-  private[sbt] final def onProgressEvent(pe: ProgressEvent): Unit = {
+  private[sbt] final def onProgressEvent(pe: ProgressEvent): Unit =
     lastProgressEvent.set(pe)
     ProgressState.updateProgressState(pe, channel.terminal)
-  }
   private val executor =
     Executors.newSingleThreadExecutor(r => new Thread(r, s"sbt-$name-ui-thread"))
   private val lastProgressEvent = new AtomicReference[ProgressEvent]
   private val isClosed = new AtomicBoolean(false)
 
-  private[sbt] def reset(state: State): Unit = if (!isClosed.get) {
+  private[sbt] def reset(state: State): Unit = if !isClosed.get then
     uiThread.synchronized {
       val task = channel.makeUIThread(state)
-      def submit(): Unit = {
-        val thread: Thread = new Thread(s"sbt-$name-ui-thread") {
+      def submit(): Unit =
+        val thread: Thread = new Thread(s"sbt-$name-ui-thread"):
           setDaemon(true)
           override def run(): Unit =
             try task.run()
-            finally {
-              uiThread.getAndSet(null) match {
+            finally
+              uiThread.getAndSet(null) match
                 case prev @ (_, th) if th != this => uiThread.set(prev)
                 case _                            =>
-              }
-            }
-        }
-        uiThread.getAndSet((task, thread)) match {
+        uiThread.getAndSet((task, thread)) match
           case null                                                         => thread.start()
           case (prevTask, prevThread) if prevTask.getClass != task.getClass =>
             prevTask.close()
             prevThread.joinFor(1.second)
             thread.start()
           case t => uiThread.set(t)
-        }
-      }
-      uiThread.get match {
+      uiThread.get match
         case null                                                => submit()
         case (prevTask, _) if prevTask.getClass == task.getClass =>
         case (t, thread)                                         =>
           stopThreadImpl()
           submit()
-      }
     }
     Option(lastProgressEvent.get).foreach(onProgressEvent)
-  }
 
   private[sbt] def stopThreadImpl(): Unit = uiThread.synchronized {
-    uiThread.getAndSet(null) match {
+    uiThread.getAndSet(null) match
       case null        =>
       case (t, thread) =>
         t.close()
         thread.joinFor(1.second)
-    }
   }
   private[sbt] def stopThread(): Unit = uiThread.synchronized(stopThreadImpl())
 
@@ -78,32 +69,29 @@ private[sbt] class UserThread(val channel: CommandChannel) extends AutoCloseable
     // synchronize to ensure that the state isn't modified during the call to reset
     // at the bottom
     synchronized {
-      if (terminal.isAnsiSupported) {
+      if terminal.isAnsiSupported then
         channel.terminal.withPrintStream { ps =>
           ps.print(ConsoleAppender.ClearScreenAfterCursor)
           ps.flush()
         }
-      }
       val state = consolePromptEvent.state
-      terminal.prompt match {
+      terminal.prompt match
         case Prompt.Running | Prompt.Pending =>
           terminal.setPrompt(Prompt.AskUser(() => UITask.shellPrompt(terminal, state)))
         case _ =>
-      }
       onProgressEvent(ProgressEvent("Info", Vector(), None, None, None))
       reset(state)
     }
 
   private[sbt] def onConsoleUnpromptEvent(
       consoleUnpromptEvent: ConsoleUnpromptEvent
-  ): Unit = {
+  ): Unit =
     terminal.setPrompt(Prompt.Pending)
-    if (consoleUnpromptEvent.lastSource.fold(true)(_.channelName != name)) {
+    if consoleUnpromptEvent.lastSource.fold(true)(_.channelName != name) then
       terminal.progressState.reset()
-    } else stopThread()
-  }
+    else stopThread()
 
-  override def close(): Unit = if (isClosed.compareAndSet(false, true)) executor.shutdown()
+  override def close(): Unit = if isClosed.compareAndSet(false, true) then executor.shutdown()
   private def terminal = channel.terminal
   private def name: String = channel.name
-}
+end UserThread
diff --git a/main-command/src/main/scala/xsbt/IPC.scala b/main-command/src/main/scala/xsbt/IPC.scala
index ef71e7ee7..ba97d79ee 100644
--- a/main-command/src/main/scala/xsbt/IPC.scala
+++ b/main-command/src/main/scala/xsbt/IPC.scala
@@ -15,7 +15,7 @@ import scala.annotation.tailrec
 import scala.util.control.NonFatal
 import scala.util.Using
 
-object IPC {
+object IPC:
   private val portMin = 1025
   private val portMax = 65536
   private val loopback = InetAddress.getByName(null)
@@ -23,62 +23,56 @@ object IPC {
 
   def client[T](port: Int)(f: IPC => T): T = ipc(new Socket(loopback, port))(f)
 
-  def pullServer[T](f: Server => T): T = {
+  def pullServer[T](f: Server => T): T =
     Using.resource(makeServer) { server =>
       f(new Server(server))
     }
-  }
 
   def unmanagedServer: Server = new Server(makeServer)
 
-  def makeServer: ServerSocket = {
+  def makeServer: ServerSocket =
     val random = new java.util.Random
     def nextPort = random.nextInt(portMax - portMin + 1) + portMin
 
     @tailrec
     def createServer(attempts: Int): ServerSocket =
-      if (attempts > 0) {
+      if attempts > 0 then
         try new ServerSocket(nextPort, socketBacklog, loopback)
-        catch { case NonFatal(_) => createServer(attempts - 1) }
-      } else sys.error("Could not connect to socket: maximum attempts exceeded")
+        catch case NonFatal(_) => createServer(attempts - 1)
+      else sys.error("Could not connect to socket: maximum attempts exceeded")
 
     createServer(10)
-  }
 
   def server[T](f: IPC => Option[T]): T = serverImpl(makeServer, f)
 
   def server[T](port: Int)(f: IPC => Option[T]): T =
     serverImpl(new ServerSocket(port, 1, loopback), f)
 
-  private def serverImpl[T](server: ServerSocket, f: IPC => Option[T]): T = {
-    @tailrec def listen(): T = {
-      ipc(server.accept())(f) match {
+  private def serverImpl[T](server: ServerSocket, f: IPC => Option[T]): T =
+    @tailrec def listen(): T =
+      ipc(server.accept())(f) match
         case Some(done) => done
         case None       => listen()
-      }
-    }
 
     try listen()
     finally server.close()
-  }
 
   private def ipc[T](s: Socket)(f: IPC => T): T =
     try f(new IPC(s))
     finally s.close()
 
-  final class Server private[IPC] (s: ServerSocket) {
+  final class Server private[IPC] (s: ServerSocket):
     def port = s.getLocalPort
     def close() = s.close()
     def isClosed: Boolean = s.isClosed
     def connection[T](f: IPC => T): T = IPC.ipc(s.accept())(f)
-  }
-}
+end IPC
 
-final class IPC private (s: Socket) {
+final class IPC private (s: Socket):
   def port = s.getLocalPort
   private val in = new BufferedReader(new InputStreamReader(s.getInputStream))
   private val out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream))
 
-  def send(s: String) = { out.write(s); out.newLine(); out.flush() }
+  def send(s: String) =
+    out.write(s); out.newLine(); out.flush()
   def receive: String = in.readLine()
-}
diff --git a/main-command/src/test/scala/sbt/internal/BootServerSocketSpec.scala b/main-command/src/test/scala/sbt/internal/BootServerSocketSpec.scala
index c8daf5dcd..088d9bbfb 100644
--- a/main-command/src/test/scala/sbt/internal/BootServerSocketSpec.scala
+++ b/main-command/src/test/scala/sbt/internal/BootServerSocketSpec.scala
@@ -16,11 +16,10 @@ object BootServerSocketSpec extends BasicTestSuite:
 
   // the constructor only reads baseDirectory; provider is never touched
   private def config(base: java.io.File): xsbti.AppConfiguration =
-    new xsbti.AppConfiguration {
+    new xsbti.AppConfiguration:
       override def arguments(): Array[String] = Array.empty
       override def baseDirectory(): java.io.File = base
       override def provider(): xsbti.AppProvider = null
-    }
 
   private def probe(location: String): Boolean =
     BootServerSocketProbe.liveServerDetected(location, false)
@@ -56,7 +55,7 @@ object BootServerSocketSpec extends BasicTestSuite:
   }
 
   test("a stale socket file is not a live server and does not block a new socket") {
-    if (!Util.isWindows) {
+    if !Util.isWindows then
       val (base, token) = freshBase("boot-socket-stale")
       val location = Paths.get(BootServerSocket.socketLocation(base.toPath, token))
       Files.createDirectories(location.getParent)
@@ -68,7 +67,6 @@ object BootServerSocketSpec extends BasicTestSuite:
         try probe(location.toString)
         finally server.close()
       assert(liveAfterReclaim)
-    }
   }
 
 end BootServerSocketSpec
diff --git a/main-command/src/test/scala/sbt/internal/client/ClientConnectSpec.scala b/main-command/src/test/scala/sbt/internal/client/ClientConnectSpec.scala
index 14a048780..9f8733eac 100644
--- a/main-command/src/test/scala/sbt/internal/client/ClientConnectSpec.scala
+++ b/main-command/src/test/scala/sbt/internal/client/ClientConnectSpec.scala
@@ -63,6 +63,7 @@ object ClientConnectSpec extends BasicTestSuite:
       Try(client.close())
       instance.shutdown()
       sbt.io.IO.delete(base)
+  end withServerAndClient
 
   test("a portfile that a server is still writing"):
     if !isWindows then
diff --git a/main-command/src/test/scala/sbt/internal/client/NetworkClientSilentDisconnectTest.scala b/main-command/src/test/scala/sbt/internal/client/NetworkClientSilentDisconnectTest.scala
index ae4f31096..9c3323a16 100644
--- a/main-command/src/test/scala/sbt/internal/client/NetworkClientSilentDisconnectTest.scala
+++ b/main-command/src/test/scala/sbt/internal/client/NetworkClientSilentDisconnectTest.scala
@@ -129,7 +129,9 @@ object NetworkClientSilentDisconnectTest extends BasicTestSuite:
     val code = NetworkClient.client(
       base,
       args,
-      new InputStream { override def read(): Int = -1 },
+      new InputStream:
+        override def read(): Int = -1
+      ,
       out,
       err,
       false,
diff --git a/main-command/src/test/scala/sbt/internal/client/NetworkClientSysPropsTest.scala b/main-command/src/test/scala/sbt/internal/client/NetworkClientSysPropsTest.scala
index 82c8e7023..3b17363c6 100644
--- a/main-command/src/test/scala/sbt/internal/client/NetworkClientSysPropsTest.scala
+++ b/main-command/src/test/scala/sbt/internal/client/NetworkClientSysPropsTest.scala
@@ -123,3 +123,4 @@ object NetworkClientSysPropsTest extends BasicTestSuite:
       NetworkClient.sysPropsDiff(Seq("my.prop=garbage"), sysProps("-Dmy.prop=first")) ==
         (Nil, Nil, Seq("my.prop"))
     )
+end NetworkClientSysPropsTest
diff --git a/main-command/src/test/scala/sbt/internal/server/ServerAcceptSpec.scala b/main-command/src/test/scala/sbt/internal/server/ServerAcceptSpec.scala
index 0b07c5038..5669fd518 100644
--- a/main-command/src/test/scala/sbt/internal/server/ServerAcceptSpec.scala
+++ b/main-command/src/test/scala/sbt/internal/server/ServerAcceptSpec.scala
@@ -49,6 +49,7 @@ object ServerAcceptSpec extends BasicTestSuite:
     finally
       instance.shutdown()
       sbt.io.IO.delete(dir)
+  end withServer
 
   private def waitUntil(p: => Boolean): Boolean =
     val deadline = 10.seconds.fromNow
diff --git a/main-command/src/test/scala/sbt/internal/server/ServerTokenSpec.scala b/main-command/src/test/scala/sbt/internal/server/ServerTokenSpec.scala
index d8d9dff31..726c10d0d 100644
--- a/main-command/src/test/scala/sbt/internal/server/ServerTokenSpec.scala
+++ b/main-command/src/test/scala/sbt/internal/server/ServerTokenSpec.scala
@@ -49,6 +49,7 @@ object ServerTokenSpec extends BasicTestSuite:
     finally
       instance.shutdown()
       sbt.io.IO.delete(dir)
+  end withServer
 
   private def tokenIn(tokenfile: File): String =
     import Server.JsonProtocol.given
diff --git a/main-settings/src/main/scala/sbt/Append.scala b/main-settings/src/main/scala/sbt/Append.scala
index 625dcace0..7787c3a41 100644
--- a/main-settings/src/main/scala/sbt/Append.scala
+++ b/main-settings/src/main/scala/sbt/Append.scala
@@ -32,10 +32,9 @@ object Append:
   trait Sequence[A1, -A2, A3] extends Value[A1, A3] with Values[A1, A2]
 
   given appendSeq[T, V <: T]: Sequence[Seq[T], Seq[V], V] =
-    new Sequence[Seq[T], Seq[V], V] {
+    new Sequence[Seq[T], Seq[V], V]:
       def appendValues(a: Seq[T], b: Seq[V]): Seq[T] = a ++ (b: Seq[T])
       def appendValue(a: Seq[T], b: V): Seq[T] = a :+ (b: T)
-    }
 
   given appendSeqImplicit[A1, V](using ev: Conversion[V, A1]): Sequence[Seq[A1], Seq[V], V] with
     override def appendValues(a: Seq[A1], b: Seq[V]): Seq[A1] = a ++ b.map(x => (x: A1))
@@ -49,10 +48,9 @@ object Append:
   given appendTaskKeySeq[T, V <: T]: Value[Seq[Task[T]], TaskKey[V]] = (_, _) => ??? // SAM
 
   given appendList[T, V <: T]: Sequence[List[T], List[V], V] =
-    new Sequence[List[T], List[V], V] {
+    new Sequence[List[T], List[V], V]:
       def appendValues(a: List[T], b: List[V]): List[T] = a ::: (b: List[T])
       def appendValue(a: List[T], b: V): List[T] = a :+ (b: T)
-    }
 
   given appendListImplicit[A1, V](using ev: Conversion[V, A1]): Sequence[List[A1], List[V], V] with
     override def appendValues(a: List[A1], b: List[V]): List[A1] = a ++ b.map(x => (x: A1))
@@ -76,26 +74,23 @@ object Append:
       a :+ Attributed.blank(b)
 
   given appendSet[T, V <: T]: Sequence[Set[T], Set[V], V] =
-    new Sequence[Set[T], Set[V], V] {
+    new Sequence[Set[T], Set[V], V]:
       def appendValues(a: Set[T], b: Set[V]): Set[T] = a ++ (b.toSeq: Seq[T]).toSet
       def appendValue(a: Set[T], b: V): Set[T] = a + (b: T)
-    }
 
   given appendMap[A, B, X <: A, Y <: B]: Sequence[Map[A, B], Map[X, Y], (X, Y)] =
-    new Sequence[Map[A, B], Map[X, Y], (X, Y)] {
+    new Sequence[Map[A, B], Map[X, Y], (X, Y)]:
       def appendValues(a: Map[A, B], b: Map[X, Y]): Map[A, B] =
         (a.toSeq ++ (b.toSeq: Seq[(A, B)])).toMap
       def appendValue(a: Map[A, B], b: (X, Y)): Map[A, B] = a + (b: (A, B))
-    }
 
   given appendOption[T]: Sequence[Seq[T], Option[T], Option[T]] =
-    new Sequence[Seq[T], Option[T], Option[T]] {
+    new Sequence[Seq[T], Option[T], Option[T]]:
       def appendValue(a: Seq[T], b: Option[T]): Seq[T] = b.fold(a)(a :+ _)
       def appendValues(a: Seq[T], b: Option[T]): Seq[T] = b.fold(a)(a :+ _)
-    }
 
   given appendSource: Sequence[Seq[Source], Seq[File], File] =
-    new Sequence[Seq[Source], Seq[File], File] {
+    new Sequence[Seq[Source], Seq[File], File]:
       def appendValue(a: Seq[Source], b: File): Seq[Source] = appendValues(a, Seq(b))
       def appendValues(a: Seq[Source], b: Seq[File]): Seq[Source] =
         a ++ b.map { f =>
@@ -104,19 +99,17 @@ object Append:
           // added via `watchSource += ...` to not trigger a build when they are modified. Since
           // watchSources will be deprecated in 1.3.0, I'm hoping that most people will migrate
           // their builds to the new system, but this will work for most builds in the interim.
-          if (f.isFile && f.getParentFile != null)
+          if f.isFile && f.getParentFile != null then
             new Source(f.getParentFile, f.getName, NothingFilter, recursive = false)
           else new Source(f, AllPassFilter, NothingFilter)
         }
-    }
 
   // Implemented with SAM conversion short-hand
   given appendFunction[A, B]: Value[A => A, A => A] = _.andThen(_)
 
-  given appendSideEffectToFunc[A, B]: Value[A => B, () => Unit] = (f, sideEffect) => {
+  given appendSideEffectToFunc[A, B]: Value[A => B, () => Unit] = (f, sideEffect) =>
     f.andThen { b =>
       sideEffect()
       b
     }
-  }
 end Append
diff --git a/main-settings/src/main/scala/sbt/ConfigKey.scala b/main-settings/src/main/scala/sbt/ConfigKey.scala
index 44e14bdb1..bfbfd33f2 100644
--- a/main-settings/src/main/scala/sbt/ConfigKey.scala
+++ b/main-settings/src/main/scala/sbt/ConfigKey.scala
@@ -9,7 +9,6 @@
 package sbt
 
 final case class ConfigKey(name: String)
-object ConfigKey {
+object ConfigKey:
   implicit def configurationToKey(c: sbt.librarymanagement.Configuration): ConfigKey =
     ConfigKey(c.name)
-}
diff --git a/main-settings/src/main/scala/sbt/Def.scala b/main-settings/src/main/scala/sbt/Def.scala
index e0222d7b2..5ec5a07d8 100644
--- a/main-settings/src/main/scala/sbt/Def.scala
+++ b/main-settings/src/main/scala/sbt/Def.scala
@@ -91,14 +91,14 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
       current: ProjectRef,
       keyNameColor: Option[String] = None,
   ): Show[ScopedKey[?]] =
-    Show[ScopedKey[?]](key => {
+    Show[ScopedKey[?]](key =>
       val color: String => String = withColor(_, keyNameColor)
       key.scope.extra.toOption
         .flatMap(_.get(Scope.customShowString).map(color))
         .getOrElse {
           Scope.display(key.scope, color(key.key.label), ref => displayRelative2(current, ref))
         }
-    })
+    )
 
   private[sbt] def showShortKey(
       keyNameColor: Option[String],
@@ -108,17 +108,15 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
   private[sbt] def showShortKey(
       keyNameColor: Option[String],
       configNameToIdent: String => String,
-  ): Show[ScopedKey[?]] = {
+  ): Show[ScopedKey[?]] =
     def displayShort(
         project: Reference
-    ): String = {
+    ): String =
       val trailing = " /"
-      project match {
+      project match
         case BuildRef(_)      => "ThisBuild" + trailing
         case ProjectRef(_, x) => x + trailing
         case _                => Reference.display(project) + trailing
-      }
-    }
     Show[ScopedKey[?]](key =>
       Scope.display(
         key.scope,
@@ -127,7 +125,6 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
         configNameToIdent
       )
     )
-  }
 
   @deprecated("Use showBuildRelativeKey2 which doesn't take the unused multi param", "1.1.1")
   def showBuildRelativeKey(
@@ -171,33 +168,30 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
       current: ProjectRef,
       project: Reference,
       trailingSlash: Boolean
-  ): String = {
+  ): String =
     import Reference.display as displayRef
-    @tailrec def loop(ref: Reference): String = ref match {
-      case ProjectRef(b, p) => if (b == current.build) loop(LocalProject(p)) else displayRef(ref)
-      case BuildRef(b)      => if (b == current.build) loop(ThisBuild) else displayRef(ref)
-      case RootProject(b)   => if (b == current.build) loop(LocalRootProject) else displayRef(ref)
-      case LocalProject(p)  => if (p == current.project) "" else p
-      case ThisBuild        => "ThisBuild"
+    @tailrec def loop(ref: Reference): String = ref match
+      case ProjectRef(b, p) => if b == current.build then loop(LocalProject(p)) else displayRef(ref)
+      case BuildRef(b)      => if b == current.build then loop(ThisBuild) else displayRef(ref)
+      case RootProject(b)  => if b == current.build then loop(LocalRootProject) else displayRef(ref)
+      case LocalProject(p) => if p == current.project then "" else p
+      case ThisBuild       => "ThisBuild"
       case LocalRootProject => "<root>"
       case LocalAggregate   => "<aggregate>"
       case ThisProject      => "<this>"
-    }
     val str = loop(project)
-    if (trailingSlash && !str.isEmpty) s"$str /"
+    if trailingSlash && !str.isEmpty then s"$str /"
     else str
-  }
 
   @deprecated("Use variant without multi", "1.1.1")
   def displayBuildRelative(currentBuild: URI, multi: Boolean, project: Reference): String =
     displayBuildRelative(currentBuild, project)
 
   def displayBuildRelative(currentBuild: URI, project: Reference): String =
-    project match {
+    project match
       case BuildRef(`currentBuild`)      => "ThisBuild /"
       case ProjectRef(`currentBuild`, x) => x + " /"
       case _                             => Reference.display(project) + " /"
-    }
 
   def displayFull(scoped: ScopedKey[?]): String = displayFull(scoped, None)
 
@@ -212,10 +206,9 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
 
   def withColor(s: String, color: Option[String]): String =
     withColor(s, color, useColor = ITerminal.isColorEnabled)
-  def withColor(s: String, color: Option[String], useColor: Boolean): String = color match {
+  def withColor(s: String, color: Option[String], useColor: Boolean): String = color match
     case Some(c) if useColor => c + s + scala.Console.RESET
     case _                   => s
-  }
 
   override def deriveAllowed[T](s: Setting[T], allowDynamic: Boolean): Option[String] =
     super.deriveAllowed(s, allowDynamic) orElse
@@ -231,14 +224,16 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
   override def intersect(s1: Scope, s2: Scope)(using
       delegates: Scope => Seq[Scope]
   ): Option[Scope] =
-    if (s2 == GlobalScope) Some(s1) // s1 is more specific
-    else if (s1 == GlobalScope) Some(s2) // s2 is more specific
+    if s2 == GlobalScope then Some(s1) // s1 is more specific
+    else if s1 == GlobalScope then Some(s2) // s2 is more specific
     else super.intersect(s1, s2)
 
   private def definedSettingString(s: Setting[?]): String =
     s"derived setting ${s.key.key.label}${positionString(s)}"
   private def positionString(s: Setting[?]): String =
-    s.positionString match { case None => ""; case Some(pos) => s" defined at $pos" }
+    s.positionString match
+      case None      => "";
+      case Some(pos) => s" defined at $pos"
 
   /**
    * A default Parser for splitting input into space-separated arguments.
@@ -352,13 +347,12 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
   private[sbt] def branchS[A, B, C](
       x: Def.Initialize[Task[Either[A, B]]]
   )(l: Def.Initialize[Task[A => C]])(r: Def.Initialize[Task[B => C]]): Def.Initialize[Task[C]] =
-    val lhs: Initialize[Task[Either[B, C]]] = {
+    val lhs: Initialize[Task[Either[B, C]]] =
       val innerLhs: Def.Initialize[Task[Either[A, Either[B, C]]]] =
         x.map((fab: Either[A, B]) => fab.map(Left(_)))
       val innerRhs: Def.Initialize[Task[A => Either[B, C]]] =
         l.map((fn: A => C) => fn.andThen(Right(_)))
       selectITask[A, Either[B, C]](innerLhs, innerRhs)
-    }
     selectITask[B, C](lhs, r)
 
   // derived from select
@@ -368,9 +362,9 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
     val condition: Def.Initialize[Task[Either[Unit, Unit]]] =
       x.map { (p: Boolean) => if p then Left(()) else Right(()) }
     val left: Def.Initialize[Task[Unit => A]] =
-      t.map { (a: A) => { (_: Unit) => a } }
+      t.map { (a: A) => (_: Unit) => a }
     val right: Def.Initialize[Task[Unit => A]] =
-      e.map { (a: A) => { (_: Unit) => a } }
+      e.map { (a: A) => (_: Unit) => a }
     branchS(condition)(left)(right)
 
   /**
@@ -449,13 +443,11 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
         )
       )
 
-  class InitOps[T](private val x: Initialize[T]) extends AnyVal {
+  class InitOps[T](private val x: Initialize[T]) extends AnyVal:
     def toTaskable: Taskable[T] = x
-  }
 
-  class InitTaskOps[T](private val x: Initialize[Task[T]]) extends AnyVal {
+  class InitTaskOps[T](private val x: Initialize[Task[T]]) extends AnyVal:
     def toTaskable: Taskable[T] = x
-  }
 
   /**
    * This works around Scala 2.12.12's
@@ -471,7 +463,7 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
   private[sbt] def dummy[A: ClassTag](name: String, description: String): (TaskKey[A], Task[A]) =
     (TaskKey[A](name, description, DTask), dummyTask(name))
 
-  private[sbt] def dummyTask[T](name: String): Task[T] = {
+  private[sbt] def dummyTask[T](name: String): Task[T] =
     import TaskExtra.named
     val base: Task[T] = TaskExtra
       .task(
@@ -479,7 +471,6 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
       )
       .named(name)
     base.set(isDummyTask, true)
-  }
 
   private[sbt] def isDummy(t: Task[?]): Boolean =
     t.get(isDummyTask).getOrElse(false)
@@ -490,7 +481,8 @@ object Def extends BuildSyntax with Init with InitializeImplicits:
   inline def uncached[A1](inline a: A1): A1 = Uncached(a)
 end Def
 
-sealed trait InitializeImplicits { self: Def.type =>
+sealed trait InitializeImplicits:
+  self: Def.type =>
   implicit def initOps[T](x: Def.Initialize[T]): Def.InitOps[T] = new Def.InitOps(x)
 
   implicit def initTaskOps[T](x: Def.Initialize[Task[T]]): Def.InitTaskOps[T] =
@@ -506,4 +498,3 @@ sealed trait InitializeImplicits { self: Def.type =>
    */
   extension [A](in: Seq[Def.Initialize[Task[A]]])
     def join: Def.Initialize[Task[Seq[A]]] = Scoped.richTaskSeq(in).join
-}
diff --git a/main-settings/src/main/scala/sbt/DelegateIndex.scala b/main-settings/src/main/scala/sbt/DelegateIndex.scala
index a9354a167..7748a6b57 100644
--- a/main-settings/src/main/scala/sbt/DelegateIndex.scala
+++ b/main-settings/src/main/scala/sbt/DelegateIndex.scala
@@ -10,26 +10,22 @@ package sbt
 
 import ScopeAxis.{ Select, zero }
 
-sealed trait DelegateIndex {
+sealed trait DelegateIndex:
   def project(ref: ProjectRef): Seq[ScopeAxis[ResolvedReference]]
   def config(ref: ProjectRef, conf: ConfigKey): Seq[ScopeAxis[ConfigKey]]
   //	def task(ref: ProjectRef, task: ScopedKey[_]): Seq[ScopeAxis[ScopedKey[_]]]
   //	def extra(ref: ProjectRef, e: AttributeMap): Seq[ScopeAxis[AttributeMap]]
-}
-private final class DelegateIndex0(refs: Map[ProjectRef, ProjectDelegates]) extends DelegateIndex {
-  def project(ref: ProjectRef): Seq[ScopeAxis[ResolvedReference]] = refs.get(ref) match {
-    case Some(pd) => pd.refs; case None => Nil
-  }
+private final class DelegateIndex0(refs: Map[ProjectRef, ProjectDelegates]) extends DelegateIndex:
+  def project(ref: ProjectRef): Seq[ScopeAxis[ResolvedReference]] = refs.get(ref) match
+    case Some(pd) => pd.refs;
+    case None     => Nil
   def config(ref: ProjectRef, conf: ConfigKey): Seq[ScopeAxis[ConfigKey]] =
-    refs.get(ref) match {
+    refs.get(ref) match
       case Some(pd) =>
-        pd.confs.get(conf) match {
+        pd.confs.get(conf) match
           case Some(cs) => cs
           case None     => Select(conf) :: zero[ConfigKey] :: Nil
-        }
       case None => Select(conf) :: zero[ConfigKey] :: Nil
-    }
-}
 private final class ProjectDelegates(
     val ref: ProjectRef,
     val refs: Seq[ScopeAxis[ResolvedReference]],
diff --git a/main-settings/src/main/scala/sbt/InputTask.scala b/main-settings/src/main/scala/sbt/InputTask.scala
index b766da3da..b3ea93117 100644
--- a/main-settings/src/main/scala/sbt/InputTask.scala
+++ b/main-settings/src/main/scala/sbt/InputTask.scala
@@ -25,12 +25,11 @@ final class InputTask[A1] private (val parser: State => Parser[Task[A1]]):
 
   def fullInput(in: String): InputTask[A1] =
     InputTask[A1](s =>
-      Parser.parse(in, parser(s)) match {
+      Parser.parse(in, parser(s)) match
         case Right(v)  => Parser.success(v)
         case Left(msg) =>
           val indented = msg.linesIterator.map("   " + _).mkString("\n")
           Parser.failure(s"Invalid programmatic input:\n$indented")
-      }
     )
 end InputTask
 
diff --git a/main-settings/src/main/scala/sbt/KeyRanks.scala b/main-settings/src/main/scala/sbt/KeyRanks.scala
index f4eb4b22f..ca9d0c083 100644
--- a/main-settings/src/main/scala/sbt/KeyRanks.scala
+++ b/main-settings/src/main/scala/sbt/KeyRanks.scala
@@ -8,7 +8,7 @@
 
 package sbt
 
-object KeyRanks {
+object KeyRanks:
   // task and setting ranks, used to prioritize displaying information
   // main tasks
   final val APlusTask = 4
@@ -49,4 +49,4 @@ object KeyRanks {
 
   // implementation details
   val Invisible = Int.MaxValue
-}
+end KeyRanks
diff --git a/main-settings/src/main/scala/sbt/Plugins.scala b/main-settings/src/main/scala/sbt/Plugins.scala
index d3700f6cc..5900eea18 100644
--- a/main-settings/src/main/scala/sbt/Plugins.scala
+++ b/main-settings/src/main/scala/sbt/Plugins.scala
@@ -68,7 +68,7 @@ import PluginTrigger.*
  *
  * then the `MyPlugin` settings (and anything that activates only when `MyPlugin` is activated) will not be added.
  */
-abstract class AutoPlugin extends Plugins.Basic with PluginsFunctions {
+abstract class AutoPlugin extends Plugins.Basic with PluginsFunctions:
 
   /**
    * Determines whether this AutoPlugin will be activated for this project when the `requires` clause is satisfied.
@@ -119,38 +119,34 @@ abstract class AutoPlugin extends Plugins.Basic with PluginsFunctions {
 
   /** If this plugin does not have any requirements, it means it is actually a root plugin. */
   private[sbt] final def isRoot: Boolean =
-    requires match {
+    requires match
       case Empty => true
       case _     => false
-    }
 
   /** If this plugin does not have any requirements, it means it is actually a root plugin. */
   private[sbt] final def isAlwaysEnabled: Boolean =
     isRoot && (trigger == AllRequirements)
-}
+end AutoPlugin
 
 /**
  * An error that occurs when auto-plugins aren't configured properly.
  * It translates the error from the underlying logic system to be targeted at end users.
  */
 final class AutoPluginException private (val message: String, val origin: Option[LogicException])
-    extends RuntimeException(message) {
+    extends RuntimeException(message):
 
   /** Prepends `p` to the error message derived from `origin`. */
   def withPrefix(p: String) = new AutoPluginException(p + message, origin)
-}
-object AutoPluginException {
+object AutoPluginException:
   def apply(msg: String): AutoPluginException = new AutoPluginException(msg, None)
   def apply(origin: LogicException): AutoPluginException =
     new AutoPluginException(Plugins.translateMessage(origin), Some(origin))
-}
 
 /** An expression that matches `AutoPlugin`s. */
-sealed trait Plugins {
+sealed trait Plugins:
   def &&(o: Basic): Plugins
-}
 
-sealed trait PluginsFunctions {
+sealed trait PluginsFunctions:
 
   /** [[Plugins]] instance that doesn't require any [[Plugins]]s. */
   def empty: Plugins = Plugins.Empty
@@ -160,9 +156,8 @@ sealed trait PluginsFunctions {
 
   /** This plugin is activated only when it is manually activated. */
   def noTrigger: PluginTrigger = NoTrigger
-}
 
-object Plugins extends PluginsFunctions {
+object Plugins extends PluginsFunctions:
 
   private[sbt] var defaultRequires: Plugins = scala.compiletime.uninitialized
 
@@ -171,20 +166,20 @@ object Plugins extends PluginsFunctions {
    * The [[AutoPlugin]]s are topologically sorted so that a required [[AutoPlugin]] comes before its requiring [[AutoPlugin]].
    */
   def deducer(defined0: List[AutoPlugin]): (Plugins, Logger) => Seq[AutoPlugin] =
-    if (defined0.isEmpty) (_, _) => Nil
-    else {
+    if defined0.isEmpty then (_, _) => Nil
+    else
       // TODO: defined should return all the plugins
       val allReqs = (defined0 flatMap { asRequirements }).toSet
       val diff = allReqs diff defined0.toSet
       val defined =
-        if (diff.nonEmpty) diff.toList ::: defined0
+        if diff.nonEmpty then diff.toList ::: defined0
         else defined0
 
       val byAtom = defined map { x =>
         (Atom(x.label), x)
       }
       val byAtomMap = byAtom.toMap
-      if (byAtom.size != byAtomMap.size) duplicateProvidesError(byAtom)
+      if byAtom.size != byAtomMap.size then duplicateProvidesError(byAtom)
       // Ignore clauses for plugins that does not require anything else.
       // Avoids the requirement for pure Nature strings *and* possible
       // circular dependencies in the logic.
@@ -193,7 +188,7 @@ object Plugins extends PluginsFunctions {
       val allEnabledByClause = defined.filterNot(_.isRoot).flatMap(d => asEnabledByClauses(d))
 
       // Note: Here is where the function begins.  We're given a list of plugins now.
-      (requestedPlugins, log) => {
+      (requestedPlugins, log) =>
         timed("Plugins.deducer#function", log) {
           def explicitlyDisabled(p: AutoPlugin): Boolean = hasExclude(requestedPlugins, p)
           val alwaysEnabled: List[AutoPlugin] =
@@ -214,7 +209,7 @@ object Plugins extends PluginsFunctions {
           Logic.reduce(
             clauses,
             (flattenConvert(requestedPlugins) ++ convertAll(alwaysEnabled)).toSet
-          ) match {
+          ) match
             case Left(problem)  => throw AutoPluginException(problem)
             case Right(results) =>
               log.debug(s"  :: deduced result: ${results}")
@@ -228,7 +223,7 @@ object Plugins extends PluginsFunctions {
               val forbidden: Set[AutoPlugin] =
                 (selectedPlugins flatMap { Plugins.asExclusions }).toSet
               val c = selectedPlugins.toSet & forbidden
-              if (c.nonEmpty) {
+              if c.nonEmpty then
                 exclusionConflictError(
                   requestedPlugins,
                   selectedPlugins,
@@ -236,81 +231,73 @@ object Plugins extends PluginsFunctions {
                     _.label
                   }
                 )
-              }
               val retval = topologicalSort(selectedPlugins)
               // log.debug(s"  :: sorted deduced result: ${retval.toString}")
               retval
-          }
+          end match
         }
-      }
-    }
 
-  private[sbt] def topologicalSort(ns: List[AutoPlugin]): List[AutoPlugin] = {
+  private[sbt] def topologicalSort(ns: List[AutoPlugin]): List[AutoPlugin] =
     @tailrec
     def doSort(
         found0: List[AutoPlugin],
         notFound0: List[AutoPlugin],
         limit0: Int
-    ): List[AutoPlugin] = {
-      if (limit0 < 0) throw AutoPluginException(s"Failed to sort ${ns} topologically")
-      else if (notFound0.isEmpty) found0
-      else {
+    ): List[AutoPlugin] =
+      if limit0 < 0 then throw AutoPluginException(s"Failed to sort ${ns} topologically")
+      else if notFound0.isEmpty then found0
+      else
         val (found1, notFound1) = notFound0 partition { n =>
           asRequirements(n).toSet subsetOf found0.toSet
         }
         doSort(found0 ::: found1, notFound1, limit0 - 1)
-      }
-    }
     val (roots, nonRoots) = ns partition (_.isRoot)
     doSort(roots, nonRoots, ns.size * ns.size + 1)
-  }
 
-  private[sbt] def translateMessage(e: LogicException) = e match {
+  private[sbt] def translateMessage(e: LogicException) = e match
     case ic: InitialContradictions =>
       s"Contradiction in selected plugins.  These plugins were both included and excluded: ${literalsString(ic.literals.toSeq)}"
     case io: InitialOverlap =>
       s"Cannot directly enable plugins.  Plugins are enabled when their required plugins are satisfied.  The directly selected plugins were: ${literalsString(io.literals.toSeq)}"
     case cn: CyclicNegation =>
       s"Cycles in plugin requirements cannot involve excludes.  The problematic cycle is: ${literalsString(cn.cycle)}"
-  }
 
   private def literalsString(lits: Seq[Literal]): String =
     lits map { case Atom(l) => l; case Negated(Atom(l)) => l } mkString (", ")
 
-  private def duplicateProvidesError(byAtom: Seq[(Atom, AutoPlugin)]): Unit = {
+  private def duplicateProvidesError(byAtom: Seq[(Atom, AutoPlugin)]): Unit =
     val dupsByAtom = Map(byAtom.groupBy(_._1).toSeq.map { (k, v) =>
       k -> v.map(_._2)
     }*)
     val dupStrings =
-      for ((atom, dups) <- dupsByAtom if dups.size > 1)
-        yield s"${atom.label} by ${dups.mkString(", ")}"
-    val (ns, nl) = if (dupStrings.size > 1) ("s", "\n\t") else ("", " ")
+      for (atom, dups) <- dupsByAtom if dups.size > 1
+      yield s"${atom.label} by ${dups.mkString(", ")}"
+    val (ns, nl) = if dupStrings.size > 1 then ("s", "\n\t") else ("", " ")
     val message = s"Plugin$ns provided by multiple AutoPlugins:$nl${dupStrings.mkString(nl)}"
     throw AutoPluginException(message)
-  }
 
   private def exclusionConflictError(
       requested: Plugins,
       selected: Seq[AutoPlugin],
       conflicting: Seq[AutoPlugin]
-  ): Unit = {
+  ): Unit =
     def listConflicts(ns: Seq[AutoPlugin]) =
       (ns map { c =>
-        val reasons = (if (flatten(requested) contains c) List("requested")
+        val reasons = (if flatten(requested) contains c then List("requested")
                        else Nil) ++
-          (if (c.requires != empty && c.trigger == allRequirements)
+          (if c.requires != empty && c.trigger == allRequirements then
              List(s"enabled by ${c.requires.toString}")
            else Nil) ++ {
             val reqs = selected filter { x =>
               asRequirements(x) contains c
             }
-            if (reqs.nonEmpty) List(s"""required by ${reqs.mkString(", ")}""")
+            if reqs.nonEmpty then List(s"""required by ${reqs.mkString(", ")}""")
             else Nil
           } ++ {
             val exs = selected filter { x =>
               asExclusions(x) contains c
             }
-            if (exs.nonEmpty) List(s"""excluded by ${exs.mkString(", ")}""")
+            if exs.nonEmpty then List(s"""excluded by ${exs.mkString(", ")}""")
             else Nil
           }
         s"""  - conflict: ${c.label} is ${reasons.mkString("; ")}"""
@@ -319,52 +306,45 @@ object Plugins extends PluginsFunctions {
   - requested: ${requested.toString}
   - enabled: ${selected.mkString(", ")}
 ${listConflicts(conflicting)}""")
-  }
+  end exclusionConflictError
 
-  private[sbt] object Empty extends Plugins {
+  private[sbt] object Empty extends Plugins:
     def &&(o: Basic): Plugins = o
     override def toString = "<none>"
-  }
 
   /** An included or excluded Nature/Plugin. */
   // TODO: better name than Basic.  Also, can we dump this class
-  sealed abstract class Basic extends Plugins {
+  sealed abstract class Basic extends Plugins:
     def &&(o: Basic): Plugins = And(this :: o :: Nil)
-  }
-  private[sbt] final case class Exclude(n: AutoPlugin) extends Basic {
+  private[sbt] final case class Exclude(n: AutoPlugin) extends Basic:
     override def toString = s"!$n"
-  }
-  private[sbt] final case class And(plugins: List[Basic]) extends Plugins {
+  private[sbt] final case class And(plugins: List[Basic]) extends Plugins:
     def &&(o: Basic): Plugins = And(o :: plugins)
     override def toString = plugins.mkString(" && ")
-  }
-  private[sbt] def and(a: Plugins, b: Plugins) = b match {
+  private[sbt] def and(a: Plugins, b: Plugins) = b match
     case Empty    => a
     case And(ns)  => ns.foldLeft(a)(_ && _)
     case b: Basic => a && b
-  }
 
-  private[sbt] def overrideWith(current: Plugins, update: Plugins): Plugins = {
+  private[sbt] def overrideWith(current: Plugins, update: Plugins): Plugins =
     val opposite: Set[Basic] = flatten(update).map {
       case Exclude(p)    => p: Basic
       case p: AutoPlugin =>
         Exclude(p): Basic
     }.toSet
     and(remove(current, opposite), update)
-  }
 
-  private[sbt] def remove(a: Plugins, del: Set[Basic]): Plugins = a match {
-    case b: Basic => if (del(b)) Empty else b
+  private[sbt] def remove(a: Plugins, del: Set[Basic]): Plugins = a match
+    case b: Basic => if del(b) then Empty else b
     case Empty    => Empty
     case And(ns)  =>
       val removed = ns.filterNot(del)
-      if (removed.isEmpty) Empty else And(removed)
-  }
+      if removed.isEmpty then Empty else And(removed)
 
   /** Defines enabled-by clauses for `ap`. */
   private[sbt] def asEnabledByClauses(ap: AutoPlugin): List[Clause] =
     // `ap` is the head and the required plugins for `ap` is the body.
-    if (ap.trigger == AllRequirements) Clause(convert(ap.requires), Set(Atom(ap.label))) :: Nil
+    if ap.trigger == AllRequirements then Clause(convert(ap.requires), Set(Atom(ap.label))) :: Nil
     else Nil
 
   /** Defines requirements clauses for `ap`. */
@@ -382,7 +362,7 @@ ${listConflicts(conflicting)}""")
       x
     }
   // TODO - This doesn't handle nested AND boolean logic...
-  private[sbt] def hasExclude(n: Plugins, p: AutoPlugin): Boolean = n match {
+  private[sbt] def hasExclude(n: Plugins, p: AutoPlugin): Boolean = n match
     case `p`          => false
     case Exclude(`p`) => true
     // TODO - This is stupidly advanced.  We do a nested check through possible and-ed
@@ -392,34 +372,28 @@ ${listConflicts(conflicting)}""")
     case And(ns)    => ns.forall(n => hasExclude(n, p))
     case _: Basic   => false
     case Empty      => false
-  }
-  private[sbt] def hasInclude(n: Plugins, p: AutoPlugin): Boolean = n match {
+  private[sbt] def hasInclude(n: Plugins, p: AutoPlugin): Boolean = n match
     case `p`        => true
     case Exclude(n) => hasExclude(n, p)
     case And(ns)    => ns.forall(n => hasInclude(n, p))
     case _: Basic   => false
     case Empty      => false
-  }
-  private def flattenConvert(n: Plugins): Seq[Literal] = n match {
+  private def flattenConvert(n: Plugins): Seq[Literal] = n match
     case And(ns)  => convertAll(ns)
     case b: Basic => convertBasic(b) :: Nil
     case Empty    => Nil
-  }
-  private[sbt] def flatten(n: Plugins): Seq[Basic] = n match {
+  private[sbt] def flatten(n: Plugins): Seq[Basic] = n match
     case And(ns)  => ns
     case b: Basic => b :: Nil
     case Empty    => Nil
-  }
 
-  private def convert(n: Plugins): Formula = n match {
+  private def convert(n: Plugins): Formula = n match
     case And(ns)  => convertAll(ns).reduce[Formula](_ && _)
     case b: Basic => convertBasic(b)
     case Empty    => Formula.True
-  }
-  private def convertBasic(b: Basic): Literal = b match {
+  private def convertBasic(b: Basic): Literal = b match
     case Exclude(n)    => !convertBasic(n)
     case a: AutoPlugin => Atom(a.label)
-  }
   private def convertAll(ns: Seq[Basic]): Seq[Literal] = ns map convertBasic
 
   /** True if the trigger clause `n` is satisfied by `model`. */
@@ -443,15 +417,14 @@ ${listConflicts(conflicting)}""")
    * @param loader The plugin loader.
    * @return True if plugin has a stable member `autoImport`, otherwise false.
    */
-  private[sbt] def hasAutoImportGetter(ap: AutoPlugin, loader: ClassLoader): Boolean = {
+  private[sbt] def hasAutoImportGetter(ap: AutoPlugin, loader: ClassLoader): Boolean =
     import java.lang.reflect.Field
     import scala.util.control.Exception.catching
     // Make sure that we don't detect user-defined methods called autoImport
-    def existsAutoImportVal(clazz: Class[?]): Option[Field] = {
+    def existsAutoImportVal(clazz: Class[?]): Option[Field] =
       catching(classOf[NoSuchFieldException])
         .opt(clazz.getDeclaredField(autoImport))
         .orElse(Option(clazz.getSuperclass).flatMap(existsAutoImportVal))
-    }
 
     val pluginClazz = ap.getClass
     existsAutoImportVal(pluginClazz)
@@ -460,14 +433,12 @@ ${listConflicts(conflicting)}""")
           .opt(Class.forName(s"${pluginClazz.getName}$autoImport$$", false, loader))
       )
       .isDefined
-  }
 
   /** Debugging method to time how long it takes to run various compilation tasks. */
-  private def timed[T](label: String, log: Logger)(t: => T): T = {
+  private def timed[T](label: String, log: Logger)(t: => T): T =
     val start = System.nanoTime
     val result = t
     val elapsed = System.nanoTime - start
     log.debug(label + " took " + (elapsed / 1e6) + " ms")
     result
-  }
-}
+end Plugins
diff --git a/main-settings/src/main/scala/sbt/Previous.scala b/main-settings/src/main/scala/sbt/Previous.scala
index 427e545d3..9affeea53 100644
--- a/main-settings/src/main/scala/sbt/Previous.scala
+++ b/main-settings/src/main/scala/sbt/Previous.scala
@@ -23,7 +23,7 @@ import scala.util.control.NonFatal
  * Reads the previous value of tasks on-demand.  The read values are cached so that they are only read once per task execution.
  * `referenced` provides the `Format` to use for each key.
  */
-private[sbt] final class Previous(streams: Streams, referenced: IMap[Previous.Key, Referenced]) {
+private[sbt] final class Previous(streams: Streams, referenced: IMap[Previous.Key, Referenced]):
   private var map = IMap.empty[Previous.Key, ReferencedValue]
   // We can't use mapValues to transform the map because mapValues is lazy and evaluates the
   // transformation function every time a value is fetched from the map, defeating the entire
@@ -31,15 +31,13 @@ private[sbt] final class Previous(streams: Streams, referenced: IMap[Previous.Ke
   for case referenced.TPair(k, v) <- referenced.toTypedSeq do
     map = map.put(k, new ReferencedValue(v))
 
-  private final class ReferencedValue[T](referenced: Referenced[T]) {
+  private final class ReferencedValue[T](referenced: Referenced[T]):
     lazy val previousValue: Option[T] = referenced.read(streams)
-  }
 
   /** Used by the .previous runtime implementation to get the previous value for task `key`. */
   private def get[T](key: Key[T]): Option[T] =
     map.get(key).flatMap(_.previousValue)
-}
-object Previous {
+object Previous:
   import sjsonnew.BasicJsonProtocol.StringJsonFormat
   private[sbt] type ScopedTaskKey[T] = ScopedKey[Task[T]]
   private type AnyTaskKey = ScopedTaskKey[Any]
@@ -50,7 +48,7 @@ object Previous {
   private[sbt] final val DependencyDirectory = "previous-dependencies"
 
   /** Represents a reference task.previous */
-  private[sbt] final class Referenced[T](val key: Key[T], val format: JsonFormat[T]) {
+  private[sbt] final class Referenced[T](val key: Key[T], val format: JsonFormat[T]):
     def this(task: ScopedTaskKey[T], format: JsonFormat[T]) = this(Key(task, task), format)
 
     lazy val stamped: JsonFormat[T] =
@@ -59,8 +57,7 @@ object Previous {
     def setTask(newTask: ScopedKey[Task[T]]) = new Referenced(newTask, format)
     private[sbt] def read(streams: Streams): Option[T] =
       try Option(streams(key.cacheKey).cacheStoreFactory.make(StreamName).read[T]()(using stamped))
-      catch { case NonFatal(_) => None }
-  }
+      catch case NonFatal(_) => None
 
   private[sbt] val references = SettingKey[References](
     "previous-references",
@@ -73,30 +70,24 @@ object Previous {
     KeyRanks.Invisible
   )
 
-  private[sbt] class Key[T](val task: ScopedKey[Task[T]], val enclosing: AnyTaskKey) {
-    override def equals(o: Any): Boolean = o match {
+  private[sbt] class Key[T](val task: ScopedKey[Task[T]], val enclosing: AnyTaskKey):
+    override def equals(o: Any): Boolean = o match
       case that: Key[?] => this.task == that.task && this.enclosing == that.enclosing
       case _            => false
-    }
     override def hashCode(): Int = (task.## * 31) ^ enclosing.##
-    def cacheKey: AnyTaskKey = {
-      if (task == enclosing) task.asInstanceOf[ScopedKey[Task[Any]]]
-      else {
-        val am = enclosing.scope.extra match {
+    def cacheKey: AnyTaskKey =
+      if task == enclosing then task.asInstanceOf[ScopedKey[Task[Any]]]
+      else
+        val am = enclosing.scope.extra match
           case Select(a) => a.put(scopedKeyAttribute, task.asInstanceOf[AnyTaskKey])
           case _ => AttributeMap.empty.put(scopedKeyAttribute, task.asInstanceOf[AnyTaskKey])
-        }
         Def.ScopedKey(enclosing.scope.copy(extra = Select(am)), enclosing.key)
-      }
-    }
-  }
-  private[sbt] object Key {
+  private[sbt] object Key:
     def apply[T, U](key: ScopedKey[Task[T]], enclosing: ScopedKey[Task[U]]): Key[T] =
       new Key(key, enclosing.asInstanceOf[AnyTaskKey])
-  }
 
   /** Records references to previous task value. This should be completely populated after settings finish loading. */
-  private[sbt] final class References {
+  private[sbt] final class References:
     private var map = IMap.empty[Key, Referenced]
 
     // TODO: this arbitrarily chooses a JsonFormat.
@@ -105,14 +96,13 @@ object Previous {
       map = map.put(key, new Referenced(key, format))
     }
     def getReferences: IMap[Key, Referenced] = synchronized { map }
-  }
 
   /** Persists values of tasks t where there is some task referencing it via t.previous. */
   private[sbt] def complete(
       referenced: References,
       results: RMap[TaskId, Result],
       streams: Streams
-  ): Unit = {
+  ): Unit =
     val map = referenced.getReferences
     val reverse = map.keys.groupBy(_.task)
 
@@ -129,17 +119,17 @@ object Previous {
     // the previous value of another task. For each reference we find, we check if the task has
     // been successfully evaluated. If so, we write it to the appropriate previous cache for
     // the completed task.
-    for {
+    for
       (k, v) <- successfulTaskResults
       keys <- reverse.get(k)
       key <- keys if successfulTaskResults.contains(key.enclosing)
       ref <- map.get(key)
-    } {
+    do
       val out = streams(key.cacheKey).cacheStoreFactory.make(StreamName)
       try out.write(v)(using ref.stamped)
-      catch { case NonFatal(_) => }
-    }
-  }
+      catch
+        case NonFatal(_) =>
+  end complete
   private[sbt] val scopedKeyAttribute = AttributeKey[AnyTaskKey](
     "previous-scoped-key-attribute",
     "Specifies a scoped key for a task on which .previous is called. Used to " +
@@ -147,7 +137,7 @@ object Previous {
   )
 
   /** Public as a macro implementation detail.  Do not call directly. */
-  def runtime[T](skey: TaskKey[T])(using format: JsonFormat[T]): Initialize[Task[Option[T]]] = {
+  def runtime[T](skey: TaskKey[T])(using format: JsonFormat[T]): Initialize[Task[Option[T]]] =
     type Inputs = (Task[Previous], ScopedKey[Task[T]], References)
     val inputs = (Global / cache, Def.validated(skey, selfRefOk = true), Global / references)
     Def.app[Inputs, Task[Option[T]]](inputs) { (prevTask, resolved, refs) =>
@@ -155,12 +145,11 @@ object Previous {
       refs.recordReference(key, format) // always evaluated on project load
       prevTask.map(_.get(key)) // evaluated if this task is evaluated
     }
-  }
 
   /** Public as a macro implementation detail.  Do not call directly. */
   def runtimeInEnclosingTask[T](skey: TaskKey[T])(using
       format: JsonFormat[T]
-  ): Initialize[Task[Option[T]]] = {
+  ): Initialize[Task[Option[T]]] =
     type Inputs = (Task[Previous], ScopedKey[Task[T]], References, ScopedKey[?])
     val inputs = (
       Global / cache,
@@ -173,5 +162,4 @@ object Previous {
       refs.recordReference(key, format) // always evaluated on project load
       prevTask.map(_.get(key))
     }
-  }
-}
+end Previous
diff --git a/main-settings/src/main/scala/sbt/Project.scala b/main-settings/src/main/scala/sbt/Project.scala
index f89beb908..70d04edb5 100644
--- a/main-settings/src/main/scala/sbt/Project.scala
+++ b/main-settings/src/main/scala/sbt/Project.scala
@@ -19,7 +19,7 @@ import Scope.ThisScope
 import sbt.Scope.ThisBuildScope
 import sbt.internal.util.Util
 
-sealed trait ProjectDefinition[PR <: ProjectReference] {
+sealed trait ProjectDefinition[PR <: ProjectReference]:
 
   /**
    * The project ID is used to uniquely identify a project within a build.
@@ -72,12 +72,11 @@ sealed trait ProjectDefinition[PR <: ProjectReference] {
 
   override final def hashCode: Int = id.hashCode ^ base.hashCode ^ getClass.hashCode
 
-  override final def equals(o: Any) = o match {
+  override final def equals(o: Any) = o match
     case p: ProjectDefinition[?] => p.getClass == this.getClass && p.id == id && p.base == base
     case _                       => false
-  }
 
-  override def toString = {
+  override def toString =
     val agg = ifNonEmpty("aggregate", aggregate)
     val dep = ifNonEmpty("dependencies", dependencies)
     val conf = ifNonEmpty("configurations", configurations)
@@ -85,17 +84,16 @@ sealed trait ProjectDefinition[PR <: ProjectReference] {
     val fields =
       s"id $id" :: s"base: $base" :: agg ::: dep ::: conf ::: (s"plugins: List($plugins)" :: autos)
     s"Project(${fields.mkString(", ")})"
-  }
 
   private def ifNonEmpty[T](label: String, ts: Iterable[T]): List[String] =
-    if (ts.isEmpty) Nil else s"$label: $ts" :: Nil
-}
+    if ts.isEmpty then Nil else s"$label: $ts" :: Nil
+end ProjectDefinition
 
 trait CompositeProject:
   def componentProjects: Seq[Project]
 end CompositeProject
 
-private[sbt] object CompositeProject {
+private[sbt] object CompositeProject:
 
   /**
    *  Expand user defined projects with the component projects of `compositeProjects`.
@@ -117,14 +115,12 @@ private[sbt] object CompositeProject {
    */
   def expand(compositeProjects: Seq[CompositeProject]): Seq[Project] = {
     val userProjects = compositeProjects.collect { case p: Project => p }
-    for (p <- compositeProjects.flatMap(_.componentProjects)) yield {
-      userProjects.find(_.id == p.id) match {
-        case Some(userProject) => userProject
-        case None              => p
-      }
-    }
+    for p <- compositeProjects.flatMap(_.componentProjects)
+    yield userProjects.find(_.id == p.id) match
+      case Some(userProject) => userProject
+      case None              => p
   }.distinct
-}
+end CompositeProject
 
 sealed trait Project extends ProjectDefinition[ProjectReference] with CompositeProject:
   override def componentProjects: Seq[Project] = this :: Nil
@@ -278,10 +274,9 @@ object Project:
       val plugins: Plugins,
       val autoPlugins: Seq[AutoPlugin],
       val projectOrigin: ProjectOrigin
-  ) extends ProjectDefinition[PR] {
+  ) extends ProjectDefinition[PR]:
     // checks for cyclic references here instead of having to do it in Scope.delegates
     Dag.topologicalSort(configurations)(_.extendsConfigs)
-  }
 
   // Data structure representing an unresolved Project in terms of the project references.
   // This is created in build.sbt by the build user.
@@ -310,6 +305,7 @@ object Project:
       autoPlugins,
       origin
     ) with Project
+  end unresolved
 
   // Data structure representing resolved Project in terms of references to
   // other projects in dependencies etc.
@@ -388,14 +384,13 @@ object Project:
   def normalizeModuleID(id: String): String = normalizeBase(id)
 
   /** Constructs a valid Project ID based on `id` and returns it in Right or returns the error message in Left if one cannot be constructed. */
-  private[sbt] def normalizeProjectID(id: String): Either[String, String] = {
+  private[sbt] def normalizeProjectID(id: String): Either[String, String] =
     val attempt = normalizeBase(id)
     val refined =
-      if (attempt.length < 1) "root"
-      else if (!validProjectIDStart(attempt.substring(0, 1))) "root-" + attempt
+      if attempt.length < 1 then "root"
+      else if !validProjectIDStart(attempt.substring(0, 1)) then "root-" + attempt
       else attempt
     validProjectID(refined).toLeft(refined)
-  }
 
   private def normalizeBase(s: String) =
     s.toLowerCase(Locale.ENGLISH).replaceAll("""\W+""", "-")
@@ -405,19 +400,16 @@ object Project:
     case Current
     case Plugins
 
-  private[sbt] lazy val loadActionParser: Parser[LoadAction] = {
+  private[sbt] lazy val loadActionParser: Parser[LoadAction] =
     import DefaultParsers.*
     token(
       Space ~> ("plugins" ^^^ LoadAction.Plugins | "return" ^^^ LoadAction.Return)
     ) ?? LoadAction.Current
-  }
 end Project
 
-sealed trait ResolvedProject extends ProjectDefinition[ProjectRef] {
+sealed trait ResolvedProject extends ProjectDefinition[ProjectRef]:
 
   /** The [[AutoPlugin]]s enabled for this project as computed from [[plugins]]. */
   def autoPlugins: Seq[AutoPlugin]
 
-}
-
 private[sbt] trait GeneratedRootProject
diff --git a/main-settings/src/main/scala/sbt/PromiseWrap.scala b/main-settings/src/main/scala/sbt/PromiseWrap.scala
index ba485cfc7..dd85d47f8 100644
--- a/main-settings/src/main/scala/sbt/PromiseWrap.scala
+++ b/main-settings/src/main/scala/sbt/PromiseWrap.scala
@@ -13,15 +13,13 @@ import scala.concurrent.Promise as XPromise
 final class PromiseWrap[A]:
   private[sbt] val underlying: XPromise[A] = XPromise()
   def complete(result: Result[A]): Unit =
-    result match {
+    result match
       case Result.Inc(cause)   => underlying.failure(cause)
       case Result.Value(value) => underlying.success(value)
-    }
   def tryComplete(result: Result[A]): Boolean =
-    result match {
+    result match
       case Result.Inc(cause)   => underlying.tryFailure(cause)
       case Result.Value(value) => underlying.trySuccess(value)
-    }
   def success(value: A): Unit = underlying.success(value)
   def failure(cause: Throwable): Unit = underlying.failure(cause)
   def isCompleted: Boolean = underlying.isCompleted
diff --git a/main-settings/src/main/scala/sbt/Reference.scala b/main-settings/src/main/scala/sbt/Reference.scala
index 600211572..17bd103f0 100644
--- a/main-settings/src/main/scala/sbt/Reference.scala
+++ b/main-settings/src/main/scala/sbt/Reference.scala
@@ -74,15 +74,13 @@ case object ThisProject extends ProjectReference
 /** A placeholder for auto aggregation. */
 case object LocalAggregate extends ProjectReference
 
-object ProjectRef {
+object ProjectRef:
   def apply(base: File, id: String): ProjectRef = ProjectRef(IO.toURI(base), id)
-}
-object RootProject {
+object RootProject:
 
   /** Reference to the root project at 'base'. */
   def apply(base: File): RootProject = RootProject(IO.toURI(base))
-}
-object Reference {
+object Reference:
   given resolvedReferenceOrdering: Ordering[ResolvedReference] = {
     case (ba: BuildRef, bb: BuildRef)     => buildRefOrdering.compare(ba, bb)
     case (pa: ProjectRef, pb: ProjectRef) => projectRefOrdering.compare(pa, pb)
@@ -91,42 +89,36 @@ object Reference {
   }
   given buildRefOrdering: Ordering[BuildRef] = (a, b) => a.build.compareTo(b.build)
 
-  given projectRefOrdering: Ordering[ProjectRef] = (a, b) => {
+  given projectRefOrdering: Ordering[ProjectRef] = (a, b) =>
     val bc = a.build.compareTo(b.build)
     if bc == 0 then a.project.compareTo(b.project) else bc
-  }
 
   def display(ref: Reference): String =
-    ref match {
+    ref match
       case pr: ProjectReference => display(pr)
       case br: BuildReference   => display(br)
-    }
 
   def display(ref: BuildReference): String =
-    ref match {
+    ref match
       case ThisBuild     => "{<this>}"
       case BuildRef(uri) => "{" + uri + "}"
-    }
   def display(ref: ProjectReference): String =
-    ref match {
+    ref match
       case ThisProject         => "{<this>}<this>"
       case LocalRootProject    => "{<this>}<root>"
       case LocalAggregate      => "{<this>}<aggregate>"
       case LocalProject(id)    => "{<this>}" + id
       case RootProject(uri)    => "{" + uri + " }<root>"
       case ProjectRef(uri, id) => s"""ProjectRef(uri("$uri"), "$id")"""
-    }
 
-  def buildURI(ref: ResolvedReference): URI = ref match {
+  def buildURI(ref: ResolvedReference): URI = ref match
     case BuildRef(b)      => b
     case ProjectRef(b, _) => b
-  }
 
   /** Extracts the build URI from a Reference if one has been explicitly defined. */
-  def uri(ref: Reference): Option[URI] = ref match {
+  def uri(ref: Reference): Option[URI] = ref match
     case RootProject(b)   => Some(b)
     case ProjectRef(b, _) => Some(b)
     case BuildRef(b)      => Some(b)
     case _                => None
-  }
-}
+end Reference
diff --git a/main-settings/src/main/scala/sbt/Remove.scala b/main-settings/src/main/scala/sbt/Remove.scala
index 37ab5489a..6b08eb01b 100644
--- a/main-settings/src/main/scala/sbt/Remove.scala
+++ b/main-settings/src/main/scala/sbt/Remove.scala
@@ -10,39 +10,33 @@ package sbt
 
 import scala.annotation.implicitNotFound
 
-object Remove {
+object Remove:
   @implicitNotFound(
     msg = "No implicit for Remove.Value[${A}, ${B}] found,\n  so ${B} cannot be removed from ${A}"
   )
-  trait Value[A, B] extends Any {
+  trait Value[A, B] extends Any:
     def removeValue(a: A, b: B): A
-  }
   @implicitNotFound(
     msg = "No implicit for Remove.Values[${A}, ${B}] found,\n  so ${B} cannot be removed from ${A}"
   )
-  trait Values[A, -B] extends Any {
+  trait Values[A, -B] extends Any:
     def removeValues(a: A, b: B): A
-  }
   trait Sequence[A, -B, T] extends Value[A, T] with Values[A, B]
 
   given removeSeq[T, V <: T]: Sequence[Seq[T], Seq[V], V] =
-    new Sequence[Seq[T], Seq[V], V] {
+    new Sequence[Seq[T], Seq[V], V]:
       def removeValue(a: Seq[T], b: V): Seq[T] = a filterNot b.==
       def removeValues(a: Seq[T], b: Seq[V]): Seq[T] = a diff (b: Seq[T])
-    }
   given removeOption[T]: Sequence[Seq[T], Option[T], Option[T]] =
-    new Sequence[Seq[T], Option[T], Option[T]] {
+    new Sequence[Seq[T], Option[T], Option[T]]:
       def removeValue(a: Seq[T], b: Option[T]): Seq[T] = b.fold(a)(a filterNot _.==)
       def removeValues(a: Seq[T], b: Option[T]): Seq[T] = b.fold(a)(a filterNot _.==)
-    }
   given removeSet[T, V <: T]: Sequence[Set[T], Set[V], V] =
-    new Sequence[Set[T], Set[V], V] {
+    new Sequence[Set[T], Set[V], V]:
       def removeValue(a: Set[T], b: V): Set[T] = a - b
       def removeValues(a: Set[T], b: Set[V]): Set[T] = a diff (b.toSeq: Seq[T]).toSet
-    }
   given removeMap[A, B, X <: A]: Sequence[Map[A, B], Seq[X], X] =
-    new Sequence[Map[A, B], Seq[X], X] {
+    new Sequence[Map[A, B], Seq[X], X]:
       def removeValue(a: Map[A, B], b: X): Map[A, B] = a - b
       def removeValues(a: Map[A, B], b: Seq[X]): Map[A, B] = a -- b
-    }
-}
+end Remove
diff --git a/main-settings/src/main/scala/sbt/Scope.scala b/main-settings/src/main/scala/sbt/Scope.scala
index 5596f7d87..b5964cf67 100644
--- a/main-settings/src/main/scala/sbt/Scope.scala
+++ b/main-settings/src/main/scala/sbt/Scope.scala
@@ -87,7 +87,7 @@ object Scope:
       )
 
   def subThis[T](sub: ScopeAxis[T], into: ScopeAxis[T]): ScopeAxis[T] =
-    if (into == This) sub else into
+    if into == This then sub else into
 
   /**
    * `Select(ThisProject)` cannot be resolved by [[resolveProject]] (it doesn't know what to replace it with), so we
@@ -99,10 +99,9 @@ object Scope:
   }
 
   def fillTaskAxis(scope: Scope, key: AttributeKey[?]): Scope =
-    scope.task match {
+    scope.task match
       case _: Select[?] => scope
       case _            => scope.copy(task = Select(key))
-    }
 
   def mapReference(f: Reference => Reference): Scope => Scope = {
     case Scope(Select(ref), a, b, c) => Scope(Select(f(ref)), a, b, c)
@@ -114,58 +113,51 @@ object Scope:
     mapReference(ref => resolveBuildOnly(uri, ref))
 
   def resolveBuildOnly(current: URI, ref: Reference): Reference =
-    ref match {
+    ref match
       case br: BuildReference   => resolveBuild(current, br)
       case pr: ProjectReference => resolveProjectBuild(current, pr)
-    }
   def resolveBuild(current: URI, ref: BuildReference): BuildReference =
-    ref match {
+    ref match
       case ThisBuild     => BuildRef(current)
       case BuildRef(uri) => BuildRef(resolveBuild(current, uri))
-    }
   def resolveProjectBuild(current: URI, ref: ProjectReference): ProjectReference =
-    ref match {
+    ref match
       case LocalRootProject    => RootProject(current)
       case LocalProject(id)    => ProjectRef(current, id)
       case RootProject(uri)    => RootProject(resolveBuild(current, uri))
       case ProjectRef(uri, id) => ProjectRef(resolveBuild(current, uri), id)
       case ThisProject         => ThisProject // haven't exactly "resolved" anything..
       case LocalAggregate      => LocalAggregate
-    }
   def resolveBuild(current: URI, uri: URI): URI =
-    if (!uri.isAbsolute && current.isOpaque && uri.getSchemeSpecificPart == ".")
+    if !uri.isAbsolute && current.isOpaque && uri.getSchemeSpecificPart == "." then
       current // this handles the shortcut of referring to the current build using "."
-    else
-      IO.directoryURI(current.resolve(uri))
+    else IO.directoryURI(current.resolve(uri))
 
   def resolveReference(
       current: URI,
       rootProject: URI => String,
       ref: Reference
   ): ResolvedReference =
-    ref match {
+    ref match
       case br: BuildReference   => resolveBuildRef(current, br)
       case pr: ProjectReference => resolveProjectRef(current, rootProject, pr)
-    }
 
   def resolveProjectRef(
       current: URI,
       rootProject: URI => String,
       ref: ProjectReference
   ): ProjectRef =
-    ref match {
+    ref match
       case LocalRootProject    => ProjectRef(current, rootProject(current))
       case LocalProject(id)    => ProjectRef(current, id)
       case RootProject(uri)    => val u = resolveBuild(current, uri); ProjectRef(u, rootProject(u))
       case ProjectRef(uri, id) => ProjectRef(resolveBuild(current, uri), id)
       case ThisProject         => sys.error("Cannot resolve ThisProject w/o the current project")
       case LocalAggregate      => sys.error("Cannot resolve LocalAggregate")
-    }
   def resolveBuildRef(current: URI, ref: BuildReference): BuildRef =
-    ref match {
+    ref match
       case ThisBuild     => BuildRef(current)
       case BuildRef(uri) => BuildRef(resolveBuild(current, uri))
-    }
 
   def display(config: ConfigKey): String = guessConfigIdent(config.name) + " /"
 
@@ -277,9 +269,10 @@ object Scope:
             sep,
             postfix
           )
+  end displayMasked
 
   private[sbt] def appendSpace(s: String): String =
-    if (s == "") ""
+    if s == "" then ""
     else s + " "
 
   def equal(a: Scope, b: Scope, mask: ScopeMask): Boolean =
@@ -313,27 +306,25 @@ object Scope:
       projectInherit: ProjectRef => Seq[ProjectRef],
       configInherit: (ResolvedReference, ConfigKey) => Seq[ConfigKey],
       taskInherit: AttributeKey[?] => Seq[AttributeKey[?]],
-  ): Scope => Seq[Scope] = {
+  ): Scope => Seq[Scope] =
     val index = delegates(refs, configurations, projectInherit, configInherit)
     scope => indexedDelegates(resolve, index, rootProject, taskInherit)(scope)
-  }
 
   private def indexedDelegates(
       resolve: Reference => ResolvedReference,
       index: DelegateIndex,
       rootProject: URI => String,
       taskInherit: AttributeKey[?] => Seq[AttributeKey[?]],
-  )(rawScope: Scope): Seq[Scope] = {
+  )(rawScope: Scope): Seq[Scope] =
     val scope = Scope.replaceThis(GlobalScope)(rawScope)
 
     // This is a hot method that gets called many times
     def expandDelegateScopes(
         resolvedProj: ResolvedReference
-    )(pLin: Seq[ScopeAxis[ResolvedReference]]): Vector[Scope] = {
-      val tLin = scope.task match {
+    )(pLin: Seq[ScopeAxis[ResolvedReference]]): Vector[Scope] =
+      val tLin = scope.task match
         case t @ Select(_) => linearize(t)(taskInherit)
         case _             => withZeroAxis(scope.task)
-      }
       // val eLin = withZeroAxis(scope.extra)
       // The following while loops handroll the nested for-expression + flatMap
       // projAxes flatMap nonProjectScopes(resolvedProj)
@@ -341,87 +332,76 @@ object Scope:
       //   for (c <- cLin; t <- tLin; e <- eLin) yield Scope(px, c, t, e)
       val res = Vector.newBuilder[Scope]
       val pIt = pLin.iterator
-      while (pIt.hasNext) {
+      while pIt.hasNext do
         val px = pIt.next()
         val p = px.toOption getOrElse resolvedProj
-        val configProj = p match {
+        val configProj = p match
           case pr: ProjectRef => pr
           case br: BuildRef   => ProjectRef(br.build, rootProject(br.build))
-        }
-        val cLin = scope.config match {
+        val cLin = scope.config match
           case Select(conf) => index.config(configProj, conf)
           case _            => withZeroAxis(scope.config)
-        }
         val cLinIt = cLin.iterator
-        while (cLinIt.hasNext) {
+        while cLinIt.hasNext do
           val c = cLinIt.next()
           val tLinIt = tLin.iterator
-          while (tLinIt.hasNext) {
+          while tLinIt.hasNext do
             val t = tLinIt.next()
-            if (scope.extra.isSelect) {
+            if scope.extra.isSelect then
               res += Scope(px, c, t, scope.extra)
               ()
-            }
             res += Scope(px, c, t, Zero)
-          }
-        }
-      }
       res.result()
-    }
+    end expandDelegateScopes
 
-    scope.project match {
+    scope.project match
       case Zero | This  => globalProjectDelegates(scope)
       case Select(proj) =>
         val resolvedProj = resolve(proj)
         val projAxes: Seq[ScopeAxis[ResolvedReference]] =
-          resolvedProj match {
+          resolvedProj match
             case pr: ProjectRef => index.project(pr)
             case br: BuildRef   =>
               List(Select(br): ScopeAxis[ResolvedReference], Zero: ScopeAxis[ResolvedReference])
-          }
         expandDelegateScopes(resolvedProj)(projAxes)
-    }
-  }
+  end indexedDelegates
 
   private val zeroL = List(Zero)
   private val globalL = List(GlobalScope)
 
   def withZeroAxis[T](base: ScopeAxis[T]): Seq[ScopeAxis[T]] =
-    if (base.isSelect) base :: zeroL else zeroL
+    if base.isSelect then base :: zeroL else zeroL
 
   def withGlobalScope(base: Scope): Seq[Scope] =
-    if (base == GlobalScope) globalL else base :: globalL
+    if base == GlobalScope then globalL else base :: globalL
 
   def withRawBuilds(ps: Seq[ScopeAxis[ProjectRef]]): Seq[ScopeAxis[ResolvedReference]] =
     ps ++ ps.flatMap(rawBuild).distinct :+ Zero
 
-  def rawBuild(ps: ScopeAxis[ProjectRef]): Seq[ScopeAxis[BuildRef]] = ps match {
+  def rawBuild(ps: ScopeAxis[ProjectRef]): Seq[ScopeAxis[BuildRef]] = ps match
     case Select(ref) => Select(BuildRef(ref.build)) :: Nil
     case _           => Nil
-  }
 
   def delegates[Proj](
       refs: Seq[(ProjectRef, Proj)],
       configurations: Proj => Seq[ConfigKey],
       projectInherit: ProjectRef => Seq[ProjectRef],
       configInherit: (ResolvedReference, ConfigKey) => Seq[ConfigKey]
-  ): DelegateIndex = {
+  ): DelegateIndex =
     val pDelegates = refs
       .map: (ref, project) =>
         (ref, delegateIndex(ref, configurations(project))(projectInherit, configInherit))
       .toMap
     new DelegateIndex0(pDelegates)
-  }
   private def delegateIndex(ref: ProjectRef, confs: Seq[ConfigKey])(
       projectInherit: ProjectRef => Seq[ProjectRef],
       configInherit: (ResolvedReference, ConfigKey) => Seq[ConfigKey]
-  ): ProjectDelegates = {
+  ): ProjectDelegates =
     val refDelegates = withRawBuilds(linearize(Select(ref), false)(projectInherit))
     val configs = confs map { c =>
       axisDelegates(configInherit, ref, c)
     }
     new ProjectDelegates(ref, refDelegates, configs.toMap)
-  }
   def axisDelegates[T](
       direct: (ResolvedReference, T) => Seq[T],
       ref: ResolvedReference,
@@ -432,25 +412,23 @@ object Scope:
   def linearize[T](axis: ScopeAxis[T], appendZero: Boolean = true)(
       inherit: T => Seq[T]
   ): Seq[ScopeAxis[T]] =
-    axis match {
+    axis match
       case Select(x)   => topologicalSort[T](x, appendZero)(inherit)
-      case Zero | This => if (appendZero) zeroL else Nil
-    }
+      case Zero | This => if appendZero then zeroL else Nil
 
   def topologicalSort[T](node: T, appendZero: Boolean)(
       dependencies: T => Seq[T]
-  ): Seq[ScopeAxis[T]] = {
+  ): Seq[ScopeAxis[T]] =
     val o = Dag.topologicalSortUnchecked(node)(dependencies).map(x => Select(x): ScopeAxis[T])
-    if (appendZero) o ::: zeroL else o
-  }
+    if appendZero then o ::: zeroL else o
   def globalProjectDelegates(scope: Scope): Seq[Scope] =
-    if (scope == GlobalScope) globalL
+    if scope == GlobalScope then globalL
     else
-      for {
+      for
         c <- withZeroAxis(scope.config)
         t <- withZeroAxis(scope.task)
         e <- withZeroAxis(scope.extra)
-      } yield Scope(Zero, c, t, e)
+      yield Scope(Zero, c, t, e)
 
   /**
    * Temporary data structure to capture first two axis using slash syntax.
diff --git a/main-settings/src/main/scala/sbt/ScopeMask.scala b/main-settings/src/main/scala/sbt/ScopeMask.scala
index 5133c5f87..2531f10a9 100644
--- a/main-settings/src/main/scala/sbt/ScopeMask.scala
+++ b/main-settings/src/main/scala/sbt/ScopeMask.scala
@@ -14,22 +14,16 @@ final case class ScopeMask(
     config: Boolean = true,
     task: Boolean = true,
     extra: Boolean = true
-) {
-  def concatShow(p: String, c: String, t: String, sep: String, x: String): String = {
+):
+  def concatShow(p: String, c: String, t: String, sep: String, x: String): String =
     val sb = new StringBuilder
-    if (project) {
+    if project then
       sb.append(p); ()
-    }
-    if (config) {
+    if config then
       sb.append(c); ()
-    }
-    if (task) {
+    if task then
       sb.append(t); ()
-    }
     sb.append(sep)
-    if (extra) {
+    if extra then
       sb.append(x); ()
-    }
     sb.toString
-  }
-}
diff --git a/main-settings/src/main/scala/sbt/Structure.scala b/main-settings/src/main/scala/sbt/Structure.scala
index ce80527ca..899834b0a 100644
--- a/main-settings/src/main/scala/sbt/Structure.scala
+++ b/main-settings/src/main/scala/sbt/Structure.scala
@@ -27,10 +27,9 @@ sealed trait Scoped extends Equals:
   val key: AttributeKey[?]
 
   override def equals(that: Any): Boolean =
-    (this eq that.asInstanceOf[AnyRef]) || (that match {
+    (this eq that.asInstanceOf[AnyRef]) || (that match
       case that: Scoped => scope == that.scope && key == that.key && canEqual(that)
-      case _            => false
-    })
+      case _            => false)
 
   override def hashCode(): Int = (scope, key).##
 
@@ -43,15 +42,16 @@ sealed trait Taskable[A]:
   def toTask: Initialize[Task[A]]
 end Taskable
 
-sealed trait TaskableImplicits { self: Taskable.type =>
+sealed trait TaskableImplicits:
+  self: Taskable.type =>
   implicit def fromInit[A](x: Initialize[A]): Taskable[A] =
-    new Taskable[A] { def toTask = Def.toITask(x) }
-}
+    new Taskable[A]:
+      def toTask = Def.toITask(x)
 
-object Taskable extends TaskableImplicits {
+object Taskable extends TaskableImplicits:
   implicit def fromITask[A](x: Initialize[Task[A]]): Taskable[A] =
-    new Taskable[A] { def toTask = x }
-}
+    new Taskable[A]:
+      def toTask = x
 
 /** A common type for SettingKey and TaskKey so that both can be used as inputs to tasks. */
 sealed trait ScopedTaskable[A] extends Scoped with Taskable[A]
@@ -276,18 +276,22 @@ object Scoped:
   end ScopingSetting
 
   def scopedSetting[T](s: Scope, k: AttributeKey[T]): SettingKey[T] =
-    new SettingKey[T] { val scope = s; val key = k }
+    new SettingKey[T]:
+      val scope = s; val key = k
 
   def scopedInput[T](s: Scope, k: AttributeKey[InputTask[T]]): InputKey[T] =
-    new InputKey[T] { val scope = s; val key = k }
+    new InputKey[T]:
+      val scope = s; val key = k
 
   def scopedTask[T](s: Scope, k: AttributeKey[Task[T]]): TaskKey[T] =
-    new TaskKey[T] { val scope = s; val key = k }
+    new TaskKey[T]:
+      val scope = s; val key = k
 
   /**
    * Mixin trait for adding convenience vocabulary associated with applying a setting to a configuration item.
    */
-  sealed trait DefinableSetting[A1] { self =>
+  sealed trait DefinableSetting[A1]:
+    self =>
     def scopedKey: ScopedKey[A1]
 
     private[sbt] final inline def :==(inline app: A1): Setting[A1] =
@@ -336,7 +340,7 @@ object Scoped:
       Def.optional(scopedKey)(_ getOrElse or)
 
     final def ??[A2 >: A1](or: => A2): Initialize[A2] = getOrElse(or)
-  }
+  end DefinableSetting
 
   private[sbt] trait Syntax:
 
@@ -384,6 +388,7 @@ object Scoped:
         Initialize
           .joinAny[Task](coerceToAnyTaskSeq(tasks))
           .zipWith(init)((ts, i) => i.set(key, ts))
+    end extension
 
     extension [A1](init: Initialize[InputTask[A1]])
       @targetName("onTaskInitializeInputTask")
@@ -423,12 +428,14 @@ object Scoped:
         init.zipWith(Initialize.joinAny[Task](coerceToAnyTaskSeq(tasks)))((thisTask, deps) =>
           thisTask.mapTask(_.dependsOn(deps*))
         )
+    end extension
   end Syntax
 
   // Duplicated with ProjectExtra.
   private[sbt] object syntax extends Syntax
 
-  sealed trait DefinableTask[A1] { self: TaskKey[A1] =>
+  sealed trait DefinableTask[A1]:
+    self: TaskKey[A1] =>
 
     /** Internal function for the task macro. */
     inline def taskMacro[A2](inline a: A2): Initialize[Task[A2]] =
@@ -487,7 +494,7 @@ object Scoped:
           oa1.getOrElse(a2)
         }
       }
-  }
+  end DefinableTask
 
   private def coerceToAnyTaskSeq(tasks: Seq[AnyInitTask]): Seq[Def.Initialize[Task[Any]]] =
     tasks.asInstanceOf[Seq[Def.Initialize[Task[Any]]]]
@@ -495,18 +502,16 @@ object Scoped:
   type AnyInitTask = Initialize[Task[?]]
 
   implicit def richTaskSeq[T](in: Seq[Initialize[Task[T]]]): RichTaskSeq[T] = new RichTaskSeq(in)
-  final class RichTaskSeq[T](keys: Seq[Initialize[Task[T]]]) {
+  final class RichTaskSeq[T](keys: Seq[Initialize[Task[T]]]):
     def join: Initialize[Task[Seq[T]]] = tasks(_.join)
     def tasks: Initialize[Seq[Task[T]]] = Initialize.join(keys)
-  }
 
   implicit def richAnyTaskSeq(in: Seq[AnyInitTask]): RichAnyTaskSeq = new RichAnyTaskSeq(in)
-  final class RichAnyTaskSeq(keys: Seq[AnyInitTask]) {
+  final class RichAnyTaskSeq(keys: Seq[AnyInitTask]):
     def dependOn: Initialize[Task[Unit]] =
       Initialize
         .joinAny[Task](coerceToAnyTaskSeq(keys))
         .apply(deps => nop.dependsOn(deps*))
-  }
 
   sealed abstract class RichTaskables[Tup <: Tuple](final val keys: Tuple.Map[Tup, Taskable]):
 
diff --git a/main-settings/src/main/scala/sbt/dsl/LinterLevel.scala b/main-settings/src/main/scala/sbt/dsl/LinterLevel.scala
index a4a6c9066..344d7f226 100644
--- a/main-settings/src/main/scala/sbt/dsl/LinterLevel.scala
+++ b/main-settings/src/main/scala/sbt/dsl/LinterLevel.scala
@@ -45,16 +45,15 @@ package sbt.dsl
  * [[LinterLevel.Ignore]] using the low priority trait pattern.
  */
 sealed trait LinterLevel
-object LinterLevel extends LinterLevelLowPriority {
+object LinterLevel extends LinterLevelLowPriority:
 
   /**
    * Apply the linter but print warnings instead of aborting macro expansion when linter violations
    * are found.
    */
   implicit case object Warn extends LinterLevel
-}
 
-private[dsl] trait LinterLevelLowPriority {
+private[dsl] trait LinterLevelLowPriority:
 
   /**
    * Abort the macro expansion if any linter check fails.
@@ -65,4 +64,3 @@ private[dsl] trait LinterLevelLowPriority {
    * Do not perform any linting.
    */
   implicit case object Ignore extends LinterLevel
-}
diff --git a/main-settings/src/main/scala/sbt/std/InputTaskMacro.scala b/main-settings/src/main/scala/sbt/std/InputTaskMacro.scala
index b5861ec3a..b79f95e61 100644
--- a/main-settings/src/main/scala/sbt/std/InputTaskMacro.scala
+++ b/main-settings/src/main/scala/sbt/std/InputTaskMacro.scala
@@ -101,6 +101,7 @@ object InputTaskMacro:
     val inner: convert1.TermTransform[F1] = (in: Term) => f(in.asExprOf[A1]).asTerm
     val cond = conditionInputTaskTree(tree.asTerm).asExprOf[A1]
     convert1.contMapN[A1, Def.Initialize, F1](cond, convert1.appExpr, None, inner)
+  end iInitializeMacro
 
   private def iParserMacro[F1[_]: Type, A1: Type](tree: Expr[A1])(
       f: Expr[A1] => Expr[F1[A1]]
@@ -157,7 +158,7 @@ object InputTaskMacro:
       val lambda = Lambda(
         owner = Symbol.spliceOwner,
         tpe = tpe,
-        rhsFn = (sym, params) => {
+        rhsFn = (sym, params) =>
           val param = params.head.asInstanceOf[Term]
           val substitute = [a] =>
             (name: String, tpe: Type[a], qual: Term, replace: Term) =>
@@ -169,12 +170,12 @@ object InputTaskMacro:
             convert1
               .transformWrappers(body.changeOwner(sym), substitute, sym)
           modifiedBody
-        }
       )
       val action = expandTask[Arg => Def.Initialize[Task[A1]]](false, lambda)
       '{
         InputTask.createDyn[Arg, A1](p = $param)(action = $action)
       }
+    end genCreateDyn
     val body = convert1.transformWrappers(expr.asTerm, record, Symbol.spliceOwner)
     inputBuf.toList match
       case Nil                           => genCreateFree(body)
@@ -214,7 +215,7 @@ object InputTaskMacro:
       val lambda = Lambda(
         owner = Symbol.spliceOwner,
         tpe = lambdaTpe,
-        rhsFn = (sym, params) => {
+        rhsFn = (sym, params) =>
           val p0 = params.head.asInstanceOf[Ident]
           val body2 =
             convert1
@@ -231,7 +232,6 @@ object InputTaskMacro:
                 case _                              => super.transformTerm(tree)(owner)
           end refTransformer
           refTransformer.transformTerm(body2.changeOwner(sym))(sym)
-        }
       )
       val action = lambda.asExprOf[A1 => Def.Initialize[Task[A2]]]
       '{
@@ -239,6 +239,7 @@ object InputTaskMacro:
           Def.valueStrict(TaskExtra.task[A1 => Def.Initialize[Task[A2]]]($action))
         )
       }
+    end mkInputTask
     tree.asTerm match
       case Lambda(params, body) =>
         mkInputTask(params, body)
@@ -254,4 +255,5 @@ object InputTaskMacro:
             Block(List(), Lambda(params, body)),
           ) =>
         mkInputTask(params, body)
+  end parserGenFlatMapTaskImpl
 end InputTaskMacro
diff --git a/main-settings/src/main/scala/sbt/std/Instances.scala b/main-settings/src/main/scala/sbt/std/Instances.scala
index ddfef2af1..4eb9f4005 100644
--- a/main-settings/src/main/scala/sbt/std/Instances.scala
+++ b/main-settings/src/main/scala/sbt/std/Instances.scala
@@ -76,6 +76,7 @@ object FullInstance:
 
     override def flatten[A1](in: Initialize[Task[Initialize[Task[A1]]]]): Initialize[Task[A1]] =
       FullInstance.flatten[A1](in)
+  end initializeTaskMonad
 
   def flatten[A1](in: Initialize[Task[Initialize[Task[A1]]]]): Initialize[Task[A1]] =
     type Tup = (Task[Initialize[Task[A1]]], Task[SS], [a] => Initialize[a] => Initialize[a])
diff --git a/main-settings/src/main/scala/sbt/std/TaskMacro.scala b/main-settings/src/main/scala/sbt/std/TaskMacro.scala
index da9ec06ad..c3fd87d17 100644
--- a/main-settings/src/main/scala/sbt/std/TaskMacro.scala
+++ b/main-settings/src/main/scala/sbt/std/TaskMacro.scala
@@ -72,8 +72,8 @@ object TaskMacro:
     val cl = cu0.cacheLevels(key.asTerm)
     val cached = ContextUtil.isTaskCacheByDefault && !isUncacheApplied && cl.nonEmpty
     t match
-      case '{ if ($cond) then $thenp else $elsep } => taskIfImpl[A1](t, cached)
-      case _                                       =>
+      case '{ if $cond then $thenp else $elsep } => taskIfImpl[A1](t, cached)
+      case _                                     =>
         val convert1 = new FullConvert(qctx, 0)
         if cached then
           convert1.contMapN[A1, F, Id](
@@ -86,13 +86,14 @@ object TaskMacro:
             })
           )
         else convert1.contMapN[A1, F, Id](t, convert1.appExpr, None)
+  end taskMacroImpl
 
   def taskMacroImpl[A1: Type](t: Expr[A1], cached: Boolean)(using
       qctx: Quotes
   ): Expr[Initialize[Task[A1]]] =
     t match
-      case '{ if ($cond) then $thenp else $elsep } => taskIfImpl[A1](t, cached)
-      case _                                       =>
+      case '{ if $cond then $thenp else $elsep } => taskIfImpl[A1](t, cached)
+      case _                                     =>
         val convert1 = new FullConvert(qctx, 0)
         if cached then
           convert1.contMapN[A1, F, Id](
@@ -112,11 +113,11 @@ object TaskMacro:
     import qctx.reflect.*
     val convert1 = new FullConvert(qctx, 1000)
     expr match
-      case '{ if ($cond) then $thenp else $elsep } =>
+      case '{ if $cond then $thenp else $elsep } =>
         '{
           Def.ifS[A1](Def.task($cond))(Def.task[A1]($thenp))(Def.task[A1]($elsep))
         }
-      case '{ ${ stats }: a; if ($cond) then $thenp else $elsep } =>
+      case '{ ${ stats }: a; if $cond then $thenp else $elsep } =>
         '{
           Def.ifS[A1](Def.task { $stats; $cond })(Def.task[A1]($thenp))(Def.task[A1]($elsep))
         }
@@ -200,6 +201,7 @@ object TaskMacro:
         '{
           $rec.append1[A2]($init)(using $ev)
         }
+  end settingAppend1Impl
 
   private[sbt] def sourcePosition(using qctx: Quotes): Expr[SourcePosition] =
     SourcePositionImpl.fromEnclosingImpl
diff --git a/main-settings/src/test/scala/sbt/AppendSpec.scala b/main-settings/src/test/scala/sbt/AppendSpec.scala
index b3ecb23ae..722d25f2e 100644
--- a/main-settings/src/test/scala/sbt/AppendSpec.scala
+++ b/main-settings/src/test/scala/sbt/AppendSpec.scala
@@ -7,7 +7,7 @@
  */
 package sbt
 
-object AppendSpec {
+object AppendSpec:
   val onLoad = SettingKey[State => State]("onLoad")
 
   import Scope.Global
@@ -27,4 +27,3 @@ object AppendSpec {
   Global / onLoad += (() => doSideEffect())
   Global / onLoad += (() => doSideEffect())
   Global / onLoad += (() => println("foo"))
-}
diff --git a/main-settings/src/test/scala/sbt/BuildSettingsInstances.scala b/main-settings/src/test/scala/sbt/BuildSettingsInstances.scala
index bc0e9df15..1c72e5f06 100644
--- a/main-settings/src/test/scala/sbt/BuildSettingsInstances.scala
+++ b/main-settings/src/test/scala/sbt/BuildSettingsInstances.scala
@@ -44,6 +44,7 @@ object BuildSettingsInstances:
       436 -> genLocalProject.map(x => x: Reference),
       1133 -> genRootProject.map(x => x: Reference),
     )
+  end given
 
   given Gen[ConfigKey] = Gen.frequency1(
     2 -> Gen.constant[ConfigKey](Compile),
diff --git a/main-settings/src/test/scala/sbt/SlashSyntaxTest.scala b/main-settings/src/test/scala/sbt/SlashSyntaxTest.scala
index cb17887d6..f55d317ce 100644
--- a/main-settings/src/test/scala/sbt/SlashSyntaxTest.scala
+++ b/main-settings/src/test/scala/sbt/SlashSyntaxTest.scala
@@ -19,7 +19,7 @@ import sbt.librarymanagement.ModuleID
 import sbt.librarymanagement.syntax.*
 import sbt.{ LocalProject, ProjectReference, ThisBuild }
 
-object SlashSyntaxTest extends sbt.SlashSyntax {
+object SlashSyntaxTest extends sbt.SlashSyntax:
   final case class Proj(id: String)
   implicit def projToRef(p: Proj): ProjectReference = LocalProject(p.id)
 
@@ -65,4 +65,4 @@ object SlashSyntaxTest extends sbt.SlashSyntax {
     foo := (Test / bar).value + 1,
     libraryDependencies += uTest % Test,
   )
-}
+end SlashSyntaxTest
diff --git a/main-settings/src/test/scala/sbt/TupleSyntaxTest.scala b/main-settings/src/test/scala/sbt/TupleSyntaxTest.scala
index 4a6f8d094..e90ef3d4f 100644
--- a/main-settings/src/test/scala/sbt/TupleSyntaxTest.scala
+++ b/main-settings/src/test/scala/sbt/TupleSyntaxTest.scala
@@ -11,12 +11,11 @@ package sbt.test
 import sbt.*
 
 object TupleSyntaxTest:
-  def t1[A](a: SettingKey[A], b: TaskKey[A], c: Def.Initialize[A], d: Def.Initialize[Task[A]]) = {
+  def t1[A](a: SettingKey[A], b: TaskKey[A], c: Def.Initialize[A], d: Def.Initialize[Task[A]]) =
     import sbt.TupleSyntax.*
     (a, b, c.toTaskable, d.toTaskable).mapN { (x: A, y: A, z: A, w: A) =>
       "" + x + y + z + w
     }
-  }
 
   def t2[A](a: SettingKey[A], b: TaskKey[A], c: Def.Initialize[A], d: Def.Initialize[Task[A]]) =
     TupleWrap[(A, A, A, A)]((a, b, c.toTaskable, d)).mapN { case (x: A, y: A, z: A, w: A) =>
diff --git a/main-settings/src/test/scala/sbt/std/TaskPosSpec.scala b/main-settings/src/test/scala/sbt/std/TaskPosSpec.scala
index c82916515..43b80e2d1 100644
--- a/main-settings/src/test/scala/sbt/std/TaskPosSpec.scala
+++ b/main-settings/src/test/scala/sbt/std/TaskPosSpec.scala
@@ -8,7 +8,7 @@
 
 package sbt.std
 
-class TaskPosSpec {
+class TaskPosSpec:
   // Starting sbt 1.4.0, Def.task can have task value lookups inside
   // if branches since tasks with single if-expressions are automatically
   // converted into a conditional task.
@@ -18,7 +18,7 @@ class TaskPosSpec {
     val bar = taskKey[String]("")
     val condition = true
     Def.task[String] {
-      if (condition) foo.value
+      if condition then foo.value
       else bar.value
     }
   }
@@ -30,7 +30,7 @@ class TaskPosSpec {
     val bar = taskKey[String]("")
     val condition = true
     Def.taskDyn[String] {
-      if (condition) foo
+      if condition then foo
       else bar
     }
   }
@@ -42,7 +42,7 @@ class TaskPosSpec {
     val bar = settingKey[String]("")
     val condition = true
     Def.settingDyn[String] {
-      if (condition) foo
+      if condition then foo
       else bar
     }
   }
@@ -53,7 +53,7 @@ class TaskPosSpec {
     val condition = true
     Def.task[String] {
       val fooAnon = () => foo.value: @sbtUnchecked
-      if (condition) fooAnon()
+      if condition then fooAnon()
       else fooAnon()
     }
   }
@@ -64,7 +64,7 @@ class TaskPosSpec {
     val condition = true
     Def.task[String] {
       val fooAnon = () => (foo.value: @sbtUnchecked) + ""
-      if (condition) fooAnon()
+      if condition then fooAnon()
       else fooAnon()
     }
   }
@@ -75,7 +75,7 @@ class TaskPosSpec {
     val bar = taskKey[String]("")
     val condition = true
     Def.task[String] {
-      if (condition) foo.value: @sbtUnchecked
+      if condition then foo.value: @sbtUnchecked
       else bar.value: @sbtUnchecked
     }
   }
@@ -88,7 +88,7 @@ class TaskPosSpec {
     Def.task[String] {
       val fooResult = foo.value
       val anon = () => fooResult + " "
-      if (condition) anon()
+      if condition then anon()
       else ""
     }
   }
@@ -100,9 +100,8 @@ class TaskPosSpec {
     val condition = true
     Def.taskDyn[String] {
       val anon1 = (value: String) => value + " "
-      if (condition) {
-        Def.task(anon1(foo.value))
-      } else Def.task("")
+      if condition then Def.task(anon1(foo.value))
+      else Def.task("")
     }
   }
 
@@ -156,11 +155,11 @@ class TaskPosSpec {
     // In theory, this should be reported, but missing .value analysis is dumb at the cost of speed
     import sbt.*, Def.*
     val foo = taskKey[String]("")
-    def avoidDCE = { println(""); "" }
+    def avoidDCE =
+      println(""); ""
     Def.task[String] {
-      val (_, _) = "" match {
+      val (_, _) = "" match
         case _ => (foo, 1 + 2)
-      }
       avoidDCE
     }
   }
@@ -179,13 +178,11 @@ class TaskPosSpec {
 
   locally {
     import sbt.*, Def.*
-    def withKey(foo: => SettingKey[String]): Def.Initialize[Task[Unit]] = {
+    def withKey(foo: => SettingKey[String]): Def.Initialize[Task[Unit]] =
       Def.task {
-        if (true) {
+        if true then
           Def.unit(foo.value); ()
-        }
       }
-    }
     val foo = settingKey[String]("")
     withKey(foo)
   }
@@ -196,7 +193,7 @@ class TaskPosSpec {
     val condition = true
     Def.task[String] {
       // settings can be evaluated in a condition
-      if (condition) foo.value
+      if condition then foo.value
       else "..."
     }
   }
@@ -211,14 +208,13 @@ class TaskPosSpec {
 
   locally {
     import sbt.*, Def.*
-    def withKey(bar: => SettingKey[Int]) = {
+    def withKey(bar: => SettingKey[Int]) =
       Def.task {
         List(42).map { _ =>
-          if (true) bar.value
+          if true then bar.value
         }
       }
-    }
     val bar = settingKey[Int]("bar")
     withKey(bar)
   }
-}
+end TaskPosSpec
diff --git a/main-settings/src/test/scala/sbt/std/UsageTest.scala b/main-settings/src/test/scala/sbt/std/UsageTest.scala
index eee200def..2c38dc5b4 100644
--- a/main-settings/src/test/scala/sbt/std/UsageTest.scala
+++ b/main-settings/src/test/scala/sbt/std/UsageTest.scala
@@ -20,7 +20,7 @@ object UseTask:
   val set = Def.setting { 23 }
   val x = Def.task { set.value }
   val y = Def.task { true }
-  val z = Def.task { if (y.value) x.value else set.value }
+  val z = Def.task { if y.value then x.value else set.value }
   val a = Def.taskDyn {
     // if y.value then z
     // else x
@@ -53,7 +53,7 @@ object UseHktTypeArgument:
   )
 end UseHktTypeArgument
 
-object Assign {
+object Assign:
   import java.io.File
 
   import Def.{
@@ -195,4 +195,4 @@ object Assign {
   trait HigherKind[B[_]]
   // https://github.com/sbt/sbt/issues/2188
   val issue2188 = settingKey[HigherKind[Option]]("asdf")
-}
+end Assign
diff --git a/main/src/main/scala/sbt/BackgroundJobService.scala b/main/src/main/scala/sbt/BackgroundJobService.scala
index efaa43222..2b8bcba8e 100644
--- a/main/src/main/scala/sbt/BackgroundJobService.scala
+++ b/main/src/main/scala/sbt/BackgroundJobService.scala
@@ -19,7 +19,7 @@ import scala.util.control.NonFatal
 import scala.util.{ Failure, Success, Try }
 import xsbti.FileConverter
 
-abstract class BackgroundJobService extends Closeable {
+abstract class BackgroundJobService extends Closeable:
 
   /**
    * Launch a background job which is a function that runs inside another thread;
@@ -59,15 +59,14 @@ abstract class BackgroundJobService extends Closeable {
    * @param job the job to wait for
    * @return the result of waiting for the job to complete.
    */
-  def waitForTry(job: JobHandle): Try[Unit] = {
+  def waitForTry(job: JobHandle): Try[Unit] =
     try Success(waitFor(job))
-    catch {
+    catch
       case NonFatal(e) =>
         try stop(job)
-        catch { case NonFatal(_) => }
+        catch
+          case NonFatal(_) =>
         Failure(e)
-    }
-  }
 
   def waitFor(job: JobHandle): Unit
 
@@ -90,12 +89,12 @@ abstract class BackgroundJobService extends Closeable {
   ): Classpath = copyClasspath(products, full, workingDirectory, converter)
 
   private[sbt] def pauseChannelDuringJob(state: State, handle: JobHandle): Unit
-}
+end BackgroundJobService
 
-object BackgroundJobService {
-  private[sbt] def jobIdParser: (State, Seq[JobHandle]) => Parser[Seq[JobHandle]] = {
+object BackgroundJobService:
+  private[sbt] def jobIdParser: (State, Seq[JobHandle]) => Parser[Seq[JobHandle]] =
     import DefaultParsers.*
-    (state, handles) => {
+    (state, handles) =>
       val idParser: Parser[Seq[Long]] = Space ~> token(
         LongBasic.examples(handles.map(_.id.toString).toSet),
         description = "<job id>"
@@ -103,16 +102,12 @@ object BackgroundJobService {
       idParser.map { ids =>
         ids.flatMap(id => handles.find(_.id == id))
       }
-    }
-  }
-}
 
-abstract class JobHandle {
+abstract class JobHandle:
   def id: Long
   def humanReadableName: String
   def spawningTask: ScopedKey[?]
   def isAutoCancel: Boolean
-}
 
 /**
  * This datatype is used signal the task engine or the commands
diff --git a/main/src/main/scala/sbt/BuildPaths.scala b/main/src/main/scala/sbt/BuildPaths.scala
index ed4eb116b..0ee83fcd6 100644
--- a/main/src/main/scala/sbt/BuildPaths.scala
+++ b/main/src/main/scala/sbt/BuildPaths.scala
@@ -50,10 +50,9 @@ object BuildPaths:
 
   import sbt.io.syntax.*
 
-  def getGlobalBase(state: State): File = {
+  def getGlobalBase(state: State): File =
     val default = defaultVersionedGlobalBase(binarySbtVersion(state))
     getFileSetting(globalBaseDirectory, GlobalBaseProperty, default)(state)
-  }
 
   def getStagingDirectory(state: State, globalBase: File): File =
     fileSetting(stagingDirectory, StagingProperty, defaultStaging(globalBase))(state)
@@ -86,30 +85,23 @@ object BuildPaths:
 
   def getFileProperty(name: String): Option[File] = Option(System.getProperty(name)) flatMap {
     path =>
-      if (path.isEmpty) None
-      else {
-        if (path.head == '~') {
-          val tildePath = expandTildePrefix(path)
-          Some(new File(tildePath))
-        } else {
-          Some(new File(path).getAbsoluteFile)
-        }
-      }
+      if path.isEmpty then None
+      else if path.head == '~' then
+        val tildePath = expandTildePrefix(path)
+        Some(new File(tildePath))
+      else Some(new File(path).getAbsoluteFile)
   }
 
-  def expandTildePrefix(path: String): String = {
-    val tildePath = path.split("\\/").headOption match {
+  def expandTildePrefix(path: String): String =
+    val tildePath = path.split("\\/").headOption match
       case Some("~")  => sys.env.getOrElse("HOME", "")
       case Some("~+") => sys.env.getOrElse("PWD", "")
       case Some("~-") => sys.env.getOrElse("OLDPWD", "")
       case _          => ""
-    }
 
-    path.indexOf("/") match {
+    path.indexOf("/") match
       case -1 => tildePath
       case _  => tildePath + path.substring(path.indexOf("/"))
-    }
-  }
 
   def defaultVersionedGlobalBase(sbtVersion: String): File = defaultGlobalBase / sbtVersion
   def defaultGlobalBase: File = internal.SysProp.defaultGlobalBaseDirectory
diff --git a/main/src/main/scala/sbt/ClassLoaderLayeringStrategy.scala b/main/src/main/scala/sbt/ClassLoaderLayeringStrategy.scala
index 71a8a9284..454fc7fec 100644
--- a/main/src/main/scala/sbt/ClassLoaderLayeringStrategy.scala
+++ b/main/src/main/scala/sbt/ClassLoaderLayeringStrategy.scala
@@ -69,7 +69,7 @@ sealed trait ClassLoaderLayeringStrategy
  * Provides instances of [[ClassLoaderLayeringStrategy]] that can be used to define the ClassLoader used by
  * [[Keys.run]], [[Keys.test]] or any other task that runs java code inside of the sbt jvm.
  */
-object ClassLoaderLayeringStrategy {
+object ClassLoaderLayeringStrategy:
 
   /**
    * Include all of the dependencies in the loader. The base loader will be the Application
@@ -103,4 +103,4 @@ object ClassLoaderLayeringStrategy {
    * Add a layer on top of the ScalaLibrary layer for all of the jar dependencies.
    */
   case object AllLibraryJars extends AllLibraryJars
-}
+end ClassLoaderLayeringStrategy
diff --git a/main/src/main/scala/sbt/CommandLineUIService.scala b/main/src/main/scala/sbt/CommandLineUIService.scala
index 951150775..c2546061c 100644
--- a/main/src/main/scala/sbt/CommandLineUIService.scala
+++ b/main/src/main/scala/sbt/CommandLineUIService.scala
@@ -10,27 +10,21 @@ package sbt
 
 import sbt.internal.util.{ SimpleReader, Terminal as ITerminal }
 
-trait CommandLineUIService extends InteractionService {
-  override def readLine(prompt: String, mask: Boolean): Option[String] = {
-    val maskChar = if (mask) Some('*') else None
+trait CommandLineUIService extends InteractionService:
+  override def readLine(prompt: String, mask: Boolean): Option[String] =
+    val maskChar = if mask then Some('*') else None
     SimpleReader(ITerminal.get).readLine(prompt, maskChar)
-  }
   // TODO - Implement this better.
-  override def confirm(msg: String): Boolean = {
-    object Assent {
-      def unapply(in: String): Boolean = {
+  override def confirm(msg: String): Boolean =
+    object Assent:
+      def unapply(in: String): Boolean =
         (in == "y" || in == "yes")
-      }
-    }
-    SimpleReader(ITerminal.get).readLine(msg + " (yes/no): ", None) match {
+    SimpleReader(ITerminal.get).readLine(msg + " (yes/no): ", None) match
       case Some(Assent()) => true
       case _              => false
-    }
-  }
 
   override def terminalWidth: Int = ITerminal.get.getWidth
 
   override def terminalHeight: Int = ITerminal.get.getHeight
-}
 
 object CommandLineUIService extends CommandLineUIService
diff --git a/main/src/main/scala/sbt/Cross.scala b/main/src/main/scala/sbt/Cross.scala
index 6719da63d..a76f4c4d7 100644
--- a/main/src/main/scala/sbt/Cross.scala
+++ b/main/src/main/scala/sbt/Cross.scala
@@ -27,36 +27,34 @@ import sbt.librarymanagement.{ SemanticSelector, VersionNumber }
  * Cross implements the Scala cross building commands:
  * + ("cross") command and ++ ("switch") command.
  */
-object Cross {
+object Cross:
 
   private[sbt] def spacedFirst(name: String) = opOrIDSpaced(name) ~ any.+
 
   private case class Switch(version: ScalaVersion, verbose: Boolean, command: Option[String])
-  private trait ScalaVersion {
+  private trait ScalaVersion:
     def force: Boolean
-  }
   private case class NamedScalaVersion(name: String, force: Boolean) extends ScalaVersion
   private case class ScalaHomeVersion(home: File, resolveVersion: Option[String], force: Boolean)
       extends ScalaVersion
 
-  private def switchParser(state: State): Parser[Switch] = {
+  private def switchParser(state: State): Parser[Switch] =
     import DefaultParsers.*
-    def versionAndCommand(commandName: String)(spacePresent: Boolean) = {
+    def versionAndCommand(commandName: String)(spacePresent: Boolean) =
       val x = Project.extract(state)
       import x.*
       val knownVersions = crossVersions(x, currentRef)
       val version = token(StringBasic.examples(knownVersions*)).map { arg =>
         val force = arg.endsWith("!")
-        val versionArg = if (force) arg.dropRight(1) else arg
-        versionArg.split("=", 2) match {
+        val versionArg = if force then arg.dropRight(1) else arg
+        versionArg.split("=", 2) match
           case Array(home) if new File(home).exists() =>
             ScalaHomeVersion(new File(home), None, force)
           case Array(v)       => NamedScalaVersion(v, force)
           case Array(v, home) =>
             ScalaHomeVersion(new File(home), Some(v).filterNot(_.isEmpty), force)
-        }
       }
-      val spacedVersion = if (spacePresent) version else version & spacedFirst(commandName)
+      val spacedVersion = if spacePresent then version else version & spacedFirst(commandName)
       val verboseOpt = Parser.opt(token(Space ~> "-v"))
       // Accept valid commands, or project/command patterns that may reference projects
       // not yet available after version switch (fixes #7574)
@@ -72,18 +70,18 @@ object Cross {
           Switch(v, verbose.isDefined, command)
       }
       switch1 | switch2
-    }
+    end versionAndCommand
 
     def parse(commandName: String) =
       token(commandName ~> OptSpace) flatMap { sp =>
         versionAndCommand(commandName)(sp.nonEmpty)
       }
     parse(SwitchCommand) | parse(SwitchAlias)
-  }
+  end switchParser
 
   private case class CrossArgs(command: String, verbose: Boolean)
 
-  private def crossParser(state: State): Parser[CrossArgs] = {
+  private def crossParser(state: State): Parser[CrossArgs] =
     def parse(commandName: String) =
       token(commandName <~ OptSpace) flatMap { _ =>
         (token(Parser.opt("-v" <~ Space)) ~ token(matched(state.combinedParser))).map {
@@ -91,67 +89,59 @@ object Cross {
         }
       }
     parse(CrossCommand) | parse(CrossAlias)
-  }
 
   private def crossRestoreSessionParser: Parser[String] = token(CrossRestoreSessionCommand)
 
   private[sbt] def requireSession[T](p: State => Parser[T]): State => Parser[T] =
     s => if s.get(sessionSettings).isEmpty then failure("No project loaded") else p(s)
 
-  private def resolveAggregates(extracted: Extracted): Seq[ProjectRef] = {
+  private def resolveAggregates(extracted: Extracted): Seq[ProjectRef] =
 
-    def findAggregates(project: ProjectRef): Seq[ProjectRef] = {
+    def findAggregates(project: ProjectRef): Seq[ProjectRef] =
       project :: (extracted.structure
         .allProjects(project.build)
-        .find(_.id == project.project) match {
+        .find(_.id == project.project) match
         case Some(resolved) => resolved.aggregate.toList.flatMap(findAggregates)
-        case None           => Nil
-      })
-    }
+        case None           => Nil)
 
     (extracted.currentRef +: extracted.currentProject.aggregate.flatMap(findAggregates)).distinct
-  }
 
-  private def crossVersions(extracted: Extracted, proj: ResolvedReference): Seq[String] = {
+  private def crossVersions(extracted: Extracted, proj: ResolvedReference): Seq[String] =
     import extracted.*
     (proj / crossScalaVersions).get(structure.data).getOrElse {
       // reading scalaVersion is a one-time deal
       (proj / scalaVersion).get(structure.data).toSeq
     }
-  }
 
   /**
    * Parse the given command into a list of aggregate projects and command to issue.
    */
   private[sbt] def parseSlashCommand(
       extracted: Extracted
-  )(command: String): (Seq[ProjectRef], String) = {
+  )(command: String): (Seq[ProjectRef], String) =
     import extracted.*
     import DefaultParsers.*
     val parser = ((('{' ~> URIClass <~ '}').? ~ OpOrID <~ charClass(_ == '/', "/")) ~ any.*.string)
       .map { case uri ~ seg1 ~ cmd => (uri, seg1, cmd) }
-    Parser.parse(command, parser) match {
+    Parser.parse(command, parser) match
       case Right((uri, seg1, cmd)) =>
         structure.allProjectRefs.find {
           case p if uri.isDefined => seg1 == p.project && uri.contains(p.build.toString)
           case p                  => seg1 == p.project
-        } match {
+        } match
           case Some(proj) => (Seq(proj), cmd)
           case _          => (resolveAggregates(extracted), command)
-        }
       case _ => (resolveAggregates(extracted), command)
-    }
-  }
 
   def crossBuild: Command =
     Command.arb(requireSession(crossParser), crossHelp)(crossBuildCommandImpl)
 
-  private def crossBuildCommandImpl(state: State, args: CrossArgs): State = {
+  private def crossBuildCommandImpl(state: State, args: CrossArgs): State =
     val extracted = Project.extract(state)
     val parser = Act.aggregatedKeyParser(extracted) ~
       (matched(Space ~ any.*) | Parser.success(""))
-    val verbose = if (args.verbose) "-v" else ""
-    val allCommands = Parser.parse(args.command, parser) match {
+    val verbose = if args.verbose then "-v" else ""
+    val allCommands = Parser.parse(args.command, parser) match
       case Left(_) =>
         val (aggs, aggCommand) = parseSlashCommand(extracted)(args.command)
         val projCrossVersions = aggs map { proj =>
@@ -162,7 +152,7 @@ object Cross {
         val validCommand = Parser.parse(aggCommand, state.combinedParser).isRight
 
         val distinctCrossConfigs = projCrossVersions.map(_._2.toSet).distinct
-        if (validCommand && distinctCrossConfigs.size > 1) {
+        if validCommand && distinctCrossConfigs.size > 1 then
           state.log.warn(
             "Issuing a cross building command, but not all sub projects have the same cross build " +
               "configuration. This could result in subprojects cross building against Scala versions that they are " +
@@ -174,7 +164,6 @@ object Cross {
           projCrossVersions.foreach { (project, versions) =>
             state.log.debug(s"$project: $versions")
           }
-        }
 
         // Execute using a blanket switch
         projCrossVersions.toMap.apply(extracted.currentRef).flatMap { version =>
@@ -182,11 +171,10 @@ object Cross {
           Seq(s"$SwitchCommand $verbose $version!", aggCommand)
         }
       case Right((keys, taskArgs)) =>
-        def project(key: ScopedKey[?]): Option[ProjectRef] = key.scope.project.toOption match {
+        def project(key: ScopedKey[?]): Option[ProjectRef] = key.scope.project.toOption match
           case Some(p: ProjectRef) => Some(p)
           case _                   => None
-        }
-        val fullArgs = if (taskArgs.trim.isEmpty) "" else s" ${taskArgs.trim}"
+        val fullArgs = if taskArgs.trim.isEmpty then "" else s" ${taskArgs.trim}"
         val keysByVersion = keys
           .flatMap { k =>
             project(k).toSeq.flatMap(crossVersions(extracted, _).map(v => v -> k))
@@ -199,14 +187,14 @@ object Cross {
             val projects = keys.flatMap(project)
             keys.toSeq.flatMap { k =>
               project(k).withFilter(projects.contains).flatMap { p =>
-                if (p == extracted.currentRef || !projects.contains(extracted.currentRef)) {
+                if p == extracted.currentRef || !projects.contains(extracted.currentRef) then
                   val parts =
                     project(k).map(p => s"{${p.build}}${p.project}") ++
                       k.scope.config.toOption.map(c => c.name.capitalize) ++
                       k.scope.task.toOption.map(_.label) ++
                       Some(k.key.label)
                   Some(v -> parts.mkString("", "/", fullArgs))
-                } else None
+                else None
               }
             }
           }
@@ -216,100 +204,89 @@ object Cross {
           .toSeq
           .sortBy(_._1)
         commandsByVersion.flatMap { (v, commands) =>
-          commands match {
+          commands match
             case Seq(c)                    => Seq(s"$SwitchCommand $verbose $v $c")
             case Seq()                     => Nil // should be unreachable
             case multi if fullArgs.isEmpty =>
               Seq(s"$SwitchCommand $verbose $v all ${multi.mkString(" ")}")
             case multi => Seq(s"$SwitchCommand $verbose $v") ++ multi
-          }
         }
-    }
     allCommands.toList ::: CrossRestoreSessionCommand :: captureCurrentSession(state, extracted)
-  }
+  end crossBuildCommandImpl
 
   def crossRestoreSession: Command =
     Command.arb(_ => crossRestoreSessionParser, crossRestoreSessionHelp)((s, _) =>
       crossRestoreSessionImpl(s)
     )
 
-  private def crossRestoreSessionImpl(state: State): State = {
+  private def crossRestoreSessionImpl(state: State): State =
     restoreCapturedSession(state, Project.extract(state))
-  }
 
   private val CapturedSession = AttributeKey[Seq[Setting[?]]]("crossCapturedSession")
 
-  private def captureCurrentSession(state: State, extracted: Extracted): State = {
+  private def captureCurrentSession(state: State, extracted: Extracted): State =
     state.put(CapturedSession, extracted.session.rawAppend)
-  }
 
-  private def restoreCapturedSession(state: State, extracted: Extracted): State = {
-    state.get(CapturedSession) match {
+  private def restoreCapturedSession(state: State, extracted: Extracted): State =
+    state.get(CapturedSession) match
       case Some(rawAppend) =>
         val restoredSession = extracted.session.copy(rawAppend = rawAppend)
         BuiltinCommands
           .reapply(restoredSession, extracted.structure, state)
           .remove(CapturedSession)
       case None => state
-    }
-  }
 
   def switchVersion: Command =
     Command.arb(requireSession(switchParser), switchHelp)(switchCommandImpl)
 
-  private def switchCommandImpl(state: State, args: Switch): State = {
+  private def switchCommandImpl(state: State, args: Switch): State =
     val (switchedState, affectedRefs) = switchScalaVersion(args, state)
 
     val strictCmd =
-      if (args.version.force) {
+      if args.version.force then
         // The Scala version was forced on the whole build, run as is
         args.command
-      } else
+      else
         args.command.map { rawCmd =>
           // for now, treat `all` command specially
-          if (rawCmd.startsWith("all ")) rawCmd
-          else {
+          if rawCmd.startsWith("all ") then rawCmd
+          else
             val (aggs, aggCommand) = parseSlashCommand(Project.extract(state))(rawCmd)
             aggs
               .intersect(affectedRefs)
               .map(p => s"{${p.build}}${p.project}/$aggCommand")
               .mkString("all ", " ", "")
-          }
         }
 
     strictCmd.toList ::: switchedState
-  }
 
-  private def switchScalaVersion(switch: Switch, state: State): (State, Seq[ResolvedReference]) = {
+  private def switchScalaVersion(switch: Switch, state: State): (State, Seq[ResolvedReference]) =
     val extracted = Project.extract(state)
     import extracted.*
 
     type ScalaVersion = String
 
-    val (version, instance) = switch.version match {
+    val (version, instance) = switch.version match
       case ScalaHomeVersion(homePath, resolveVersion, _) =>
         val home = IO.resolve(extracted.currentProject.base, homePath)
-        if (home.exists()) {
+        if home.exists() then
           val instance = ScalaInstance(home)(state.classLoaderCache.apply)
           val version = resolveVersion.getOrElse(instance.actualVersion)
           (version, Some((home, instance)))
-        } else {
-          sys.error(s"Scala home directory did not exist: $home")
-        }
+        else sys.error(s"Scala home directory did not exist: $home")
       case NamedScalaVersion(v, _) => (v, None)
-    }
 
     def logSwitchInfo(
         included: Seq[(ResolvedReference, ScalaVersion, Seq[ScalaVersion])],
         excluded: Seq[(ResolvedReference, Seq[ScalaVersion])]
-    ) = {
+    ) =
 
       instance.foreach { (home, instance) =>
         state.log.info(s"Using Scala home $home with actual version ${instance.actualVersion}")
       }
-      if (switch.version.force) {
+      if switch.version.force then
         state.log.info(s"Forcing Scala version to $version on all projects.")
-      } else {
+      else
         included
           .groupBy(_._2)
           .foreachEntry { (selectedVersion, projects) =>
@@ -317,51 +294,44 @@ object Cross {
               s"Setting Scala version to $selectedVersion on ${projects.size} projects."
             )
           }
-      }
-      if (excluded.nonEmpty && !switch.verbose) {
+      if excluded.nonEmpty && !switch.verbose then
         state.log.info(s"Excluded ${excluded.size} projects, run ++ $version -v for more details.")
-      }
 
       def detailedLog(msg: => String) =
-        if (switch.verbose) state.log.info(msg) else state.log.debug(msg)
+        if switch.verbose then state.log.info(msg) else state.log.debug(msg)
 
-      def logProject: (ResolvedReference, Seq[ScalaVersion]) => Unit = (ref, scalaVersions) => {
-        val current = if (ref == currentRef) "*" else " "
-        ref match {
+      def logProject: (ResolvedReference, Seq[ScalaVersion]) => Unit = (ref, scalaVersions) =>
+        val current = if ref == currentRef then "*" else " "
+        ref match
           case proj: ProjectRef =>
             detailedLog(s"  $current ${proj.project} ${scalaVersions.mkString("(", ", ", ")")}")
           case _ => // don't log BuildRefs
-        }
-      }
       detailedLog("Switching Scala version on:")
       included.foreach { case (project, _, versions) => logProject(project, versions) }
       detailedLog("Excluding projects:")
       excluded.foreach(logProject.tupled)
-    }
+    end logSwitchInfo
 
-    val projects: Seq[(ResolvedReference, Option[ScalaVersion], Seq[ScalaVersion])] = {
+    val projects: Seq[(ResolvedReference, Option[ScalaVersion], Seq[ScalaVersion])] =
       val projectScalaVersions =
         structure.allProjectRefs.map(proj => proj -> crossVersions(extracted, proj))
-      if (switch.version.force) {
+      if switch.version.force then
         projectScalaVersions.map { (ref, options) =>
           (ref, Some(version), options)
         } ++ structure.units.keys
           .map(BuildRef.apply)
           .map(proj => (proj, Some(version), crossVersions(extracted, proj)))
-      } else {
+      else
         projectScalaVersions.map { (project, scalaVersions) =>
           val selector = SemanticSelector(version)
-          scalaVersions.filter(v => selector.matches(VersionNumber(v))) match {
+          scalaVersions.filter(v => selector.matches(VersionNumber(v))) match
             case Nil          => (project, None, scalaVersions)
             case Seq(version) => (project, Some(version), scalaVersions)
             case multiple     =>
               sys.error(
                 s"Multiple crossScalaVersions matched query '$version': ${multiple.mkString(", ")}"
               )
-          }
         }
-      }
-    }
 
     val included = projects.collect { case (project, Some(version), scalaVersions) =>
       (project, version, scalaVersions)
@@ -370,8 +340,8 @@ object Cross {
       (project, scalaVersions)
     }
 
-    if (included.isEmpty) {
-      if (isSelector(version))
+    if included.isEmpty then
+      if isSelector(version) then
         throw new MessageOnlyException(
           s"""Switch failed: no subprojects have a version matching "$version" in the crossScalaVersions setting."""
         )
@@ -380,12 +350,11 @@ object Cross {
           s"""Switch failed: no subprojects list "$version" (or compatible version) in crossScalaVersions setting.
              |If you want to force it regardless, call ++ $version!""".stripMargin
         )
-    }
 
     logSwitchInfo(included, excluded)
 
     (setScalaVersionsForProjects(instance, included, state, extracted), included.map(_._1))
-  }
+  end switchScalaVersion
 
   // determine whether this is a 'specific' version or a selector
   // to be passed to SemanticSelector
@@ -402,13 +371,13 @@ object Cross {
       projects: Seq[(ResolvedReference, String, Seq[String])],
       state: State,
       extracted: Extracted
-  ): State = {
+  ): State =
     import extracted.*
 
     val newSettings = projects.flatMap { (project, version, scalaVersions) =>
       val scope = Scope(Select(project), Zero, Zero, Zero)
 
-      instance match {
+      instance match
         case Some((home, inst1)) =>
           Seq(
             scope / scalaVersion := version,
@@ -422,7 +391,6 @@ object Cross {
             scope / crossScalaVersions := scalaVersions,
             scope / scalaHome := None
           )
-      }
     }
 
     val filterKeys: Set[AttributeKey[?]] = Set(scalaVersion, scalaHome, scalaInstance).map(_.key)
@@ -430,16 +398,14 @@ object Cross {
     val projectsContains: Reference => Boolean = projects.map(_._1).toSet.contains
 
     // Filter out any old scala version settings that were added, this is just for hygiene.
-    val filteredRawAppend = session.rawAppend.filter(_.key match {
+    val filteredRawAppend = session.rawAppend.filter(_.key match
       case ScopedKey(Scope(Select(ref), Zero, Zero, Zero), key)
           if filterKeys.contains(key) && projectsContains(ref) =>
         false
-      case _ => true
-    })
+      case _ => true)
 
     val newSession = session.copy(rawAppend = filteredRawAppend ++ newSettings)
 
     BuiltinCommands.reapply(newSession, structure, state)
-  }
-
-}
+  end setScalaVersionsForProjects
+end Cross
diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala
index 9e5be1b9d..b8b493a0b 100644
--- a/main/src/main/scala/sbt/Defaults.scala
+++ b/main/src/main/scala/sbt/Defaults.scala
@@ -114,15 +114,15 @@ import xsbti.compile.{
   TransactionalManagerType
 }
 
-object Defaults extends BuildCommon with DefExtra {
+object Defaults extends BuildCommon with DefExtra:
   final val CacheDirectoryName = "cache"
 
   def configSrcSub(key: SettingKey[File]): Initialize[File] =
     Def.setting {
       (ThisScope.copy(config = Zero) / key).value / nameForSrc(configuration.value.name)
     }
-  def nameForSrc(config: String) = if (config == Configurations.Compile.name) "main" else config
-  def prefix(config: String) = if (config == Configurations.Compile.name) "" else config + "-"
+  def nameForSrc(config: String) = if config == Configurations.Compile.name then "main" else config
+  def prefix(config: String) = if config == Configurations.Compile.name then "" else config + "-"
 
   def lock(app: xsbti.AppConfiguration): xsbti.GlobalLock = LibraryManagement.lock(app)
 
@@ -250,7 +250,7 @@ object Defaults extends BuildCommon with DefExtra {
       scalaArtifacts :== ScalaArtifacts.Artifacts,
       sbtResolver := {
         val v = sbtVersion.value
-        if (v.endsWith("-SNAPSHOT") || v.contains("-bin-")) Classpaths.sbtMavenSnapshots
+        if v.endsWith("-SNAPSHOT") || v.contains("-bin-") then Classpaths.sbtMavenSnapshots
         else Resolver.DefaultMavenRepository
       },
       sbtResolvers := Vector(sbtResolver.value),
@@ -313,7 +313,7 @@ object Defaults extends BuildCommon with DefExtra {
       connectInput :== false,
       cancelable :== true,
       taskCancelStrategy := { (state: State) =>
-        if (cancelable.value) TaskCancellationStrategy.Signal
+        if cancelable.value then TaskCancellationStrategy.Signal
         else TaskCancellationStrategy.Null
       },
       envVars :== Map.empty,
@@ -347,7 +347,7 @@ object Defaults extends BuildCommon with DefExtra {
       turbo :== SysProp.turbo,
       usePipelining :== SysProp.pipelining,
       exportPipelining := usePipelining.value,
-      useSuperShell := { if (insideCI.value) false else ITerminal.console.isSupershellEnabled },
+      useSuperShell := { if insideCI.value then false else ITerminal.console.isSupershellEnabled },
       superShellThreshold :== SysProp.supershellThreshold,
       superShellMaxTasks :== SysProp.supershellMaxTasks,
       superShellSleep :== SysProp.supershellSleep.millis,
@@ -395,7 +395,7 @@ object Defaults extends BuildCommon with DefExtra {
         .## % 1000),
       serverConnectionType := ConnectionType.Local,
       serverAuthentication := {
-        if (serverConnectionType.value == ConnectionType.Tcp) Set(ServerAuthentication.Token)
+        if serverConnectionType.value == ConnectionType.Tcp then Set(ServerAuthentication.Token)
         else Set()
       },
       serverHandlers :== Nil,
@@ -428,13 +428,13 @@ object Defaults extends BuildCommon with DefExtra {
       // BSP has no authentication, so over TCP its handlers would be reachable without the
       // token handshake the other language-server calls require. Disable it there.
       val bspSupported = serverConnectionType.value != ConnectionType.Tcp
-      if (!bspSupported)
+      if !bspSupported then
         sLog.value.warn(
           "BSP is not supported when serverConnectionType is Tcp; disabling the Build Server " +
             "Protocol handler for this session."
         )
       val bspHandler =
-        if (bspSupported)
+        if bspSupported then
           Seq(
             BuildServerProtocol.handler(
               loadedBuild.value,
@@ -459,7 +459,7 @@ object Defaults extends BuildCommon with DefExtra {
       val unmanagedCache = unmanagedFileStampCache.value
       val managedCache = managedFileStampCache.value
       val backing = timeWrappedStamper.value
-      new xsbti.compile.analysis.ReadStamps {
+      new xsbti.compile.analysis.ReadStamps:
         def getAllLibraryStamps()
             : java.util.Map[xsbti.VirtualFileRef, xsbti.compile.analysis.Stamp] =
           backing.getAllLibraryStamps()
@@ -471,34 +471,30 @@ object Defaults extends BuildCommon with DefExtra {
           new java.util.HashMap[xsbti.VirtualFileRef, xsbti.compile.analysis.Stamp]
         def library(fr: xsbti.VirtualFileRef): xsbti.compile.analysis.Stamp = backing.library(fr)
         def product(fr: xsbti.VirtualFileRef): xsbti.compile.analysis.Stamp = backing.product(fr)
-        def source(fr: xsbti.VirtualFile): xsbti.compile.analysis.Stamp = {
+        def source(fr: xsbti.VirtualFile): xsbti.compile.analysis.Stamp =
           val path = converter.toPath(fr)
           unmanagedCache
             .get(path)
             .orElse(managedCache.getOrElseUpdate(path, sbt.nio.FileStamper.Hash))
             .map(_.stamp)
             .getOrElse(backing.source(fr))
-        }
-      }
     },
   )
 
-  private[sbt] def toAbsoluteSource(fc: FileConverter)(pos: Position): Position = {
+  private[sbt] def toAbsoluteSource(fc: FileConverter)(pos: Position): Position =
     val newPath: Option[NioPath] = pos
       .sourcePath()
       .asScala
       .flatMap { path =>
-        try {
-          Some(fc.toPath(VirtualFileRef.of(path)))
-        } catch {
+        try Some(fc.toPath(VirtualFileRef.of(path)))
+        catch
           // catch all to trap wierd path injected by compiler, users, or plugins
           case NonFatal(_) => None
-        }
       }
 
     newPath
       .map { path =>
-        new Position {
+        new Position:
           override def line(): Optional[Integer] = pos.line()
 
           override def lineContent(): String = pos.lineContent()
@@ -512,11 +508,8 @@ object Defaults extends BuildCommon with DefExtra {
           override def sourcePath(): Optional[String] = Optional.of(path.toAbsolutePath.toString)
 
           override def sourceFile(): Optional[File] =
-            (try {
-              Some(path.toFile.getAbsoluteFile)
-            } catch {
-              case NonFatal(_) => None
-            }).toJava
+            (try Some(path.toFile.getAbsoluteFile)
+            catch case NonFatal(_) => None).toJava
 
           override def startOffset(): Optional[Integer] = pos.startOffset()
 
@@ -529,10 +522,9 @@ object Defaults extends BuildCommon with DefExtra {
           override def endLine(): Optional[Integer] = pos.endLine()
 
           override def endColumn(): Optional[Integer] = pos.endColumn()
-        }
       }
       .getOrElse(pos)
-  }
+  end toAbsoluteSource
 
   def defaultTestTasks(key: Scoped): Seq[Setting[?]] =
     inTask(key)(
@@ -562,10 +554,9 @@ object Defaults extends BuildCommon with DefExtra {
     resourceManaged := target.value / "resource_managed",
     // Adds subproject build.sbt files to the global list of build files to monitor
     Scope.Global / checkBuildSources / fileInputs ++= {
-      if ((Scope.Global / onChangedBuildSource).value != IgnoreSourceChanges)
+      if (Scope.Global / onChangedBuildSource).value != IgnoreSourceChanges then
         Seq(baseDirectory.value.toGlob / "*.sbt")
-      else
-        Nil
+      else Nil
     },
   )
 
@@ -596,13 +587,13 @@ object Defaults extends BuildCommon with DefExtra {
     },
     unmanagedSources / fileInputs := {
       val include = (unmanagedSources / includeFilter).value
-      val filter = (unmanagedSources / excludeFilter).value match {
+      val filter = (unmanagedSources / excludeFilter).value match
         // Hidden files are already filtered out by the FileStamps method
         case NothingFilter | HiddenFileFilter => include
         case exclude                          => include -- exclude
-      }
       val baseSources =
-        if (sourcesInBase.value) Globs(baseDirectory.value.toPath, recursive = false, filter) :: Nil
+        if sourcesInBase.value then
+          Globs(baseDirectory.value.toPath, recursive = false, filter) :: Nil
         else Nil
       unmanagedSourceDirectories.value
         .map(d => Globs(d.toPath, recursive = true, filter)) ++ baseSources
@@ -652,11 +643,10 @@ object Defaults extends BuildCommon with DefExtra {
       .value,
     unmanagedResources / fileInputs := {
       val include = (unmanagedResources / includeFilter).value
-      val filter = (unmanagedResources / excludeFilter).value match {
+      val filter = (unmanagedResources / excludeFilter).value match
         // Hidden files are already filtered out by the FileStamps method
         case NothingFilter | HiddenFileFilter => include
         case exclude                          => include -- exclude
-      }
       unmanagedResourceDirectories.value.map(d => Globs(d.toPath, recursive = true, filter))
     },
     unmanagedResources := Def.uncached(
@@ -732,23 +722,22 @@ object Defaults extends BuildCommon with DefExtra {
     ) ++ compileBaseGlobal ++ Seq(
       useScalaReplJLine :== false,
       scalaInstanceTopLoader := {
-        val topLoader = if (!useScalaReplJLine.value) {
+        val topLoader = if !useScalaReplJLine.value then
           // the JLineLoader contains the SbtInterfaceClassLoader
           classOf[org.jline.terminal.Terminal].getClassLoader
-        } else classOf[Compilers].getClassLoader // the SbtInterfaceClassLoader
+        else classOf[Compilers].getClassLoader // the SbtInterfaceClassLoader
         // Scala 2.10 shades jline in the console so we need to make sure that it loads a compatible
         // jansi version. Because of the shading, console does not work with the thin client for 2.10.x.
-        if (scalaVersion.value.startsWith("2.10.")) new ClassLoader(topLoader) {
-          override protected def loadClass(name: String, resolve: Boolean): Class[?] = {
-            if (name.startsWith("org.fusesource")) throw new ClassNotFoundException(name)
-            super.loadClass(name, resolve)
-          }
-        }
+        if scalaVersion.value.startsWith("2.10.") then
+          new ClassLoader(topLoader):
+            override protected def loadClass(name: String, resolve: Boolean): Class[?] =
+              if name.startsWith("org.fusesource") then throw new ClassNotFoundException(name)
+              super.loadClass(name, resolve)
         else topLoader
       },
       scalaInstanceConfig := Def.uncached(Compiler.scalaInstanceConfigTask(None).value),
       scalaInstance := Def.uncached(Compiler.scalaInstanceTask(scalaInstanceConfig).value),
-      crossVersion := (if (crossPaths.value) CrossVersion.binary else CrossVersion.disabled),
+      crossVersion := (if crossPaths.value then CrossVersion.binary else CrossVersion.disabled),
       pluginCrossBuild / sbtBinaryVersion := binarySbtVersion(
         (pluginCrossBuild / sbtVersion).value
       ),
@@ -761,18 +750,17 @@ object Defaults extends BuildCommon with DefExtra {
         val sv = (pluginCrossBuild / sbtVersion).value
         val scalaV = (pluginCrossBuild / scalaVersion).value
         val binVersion = (pluginCrossBuild / scalaBinaryVersion).value
-        val cross = id.crossVersionedValue match {
+        val cross = id.crossVersionedValue match
           case CrossValue.Disabled => Disabled()
           case CrossValue.Full     => CrossVersion.full
           case CrossValue.Binary   => CrossVersion.binary
-        }
         val base = ModuleID(id.groupID, id.name, sv).withCrossVersion(cross).platform(Platform.jvm)
         CrossVersion(scalaV, binVersion)(base).withCrossVersion(Disabled())
       },
       crossSbtVersions := Vector((pluginCrossBuild / sbtVersion).value),
       crossTarget := target.value,
       clean := {
-        try {
+        try
           val store = AnalysisUtil.staticCachedStore(
             analysisFile = (Compile / compileAnalysisFile).value.toPath,
             useTextAnalysis = false,
@@ -780,18 +768,16 @@ object Defaults extends BuildCommon with DefExtra {
           )
           // TODO: Uncomment after Zinc update
           // store.clearCache()
-        } catch {
-          case NonFatal(_) => ()
-        }
+        catch case NonFatal(_) => ()
         clean.value
         (ThisBuild / publish / clean).value
       },
       scalaCompilerBridgeBin := Def.uncached {
-        if {
+        if
           val sv = scalaVersion.value
           val hasSbtBridge = ScalaArtifacts.isScala3(sv) || ScalaArtifacts.hasScala2SbtBridge(sv)
           hasSbtBridge
-        } then Compiler.compilerBridgeFromUpdate.value
+        then Compiler.compilerBridgeFromUpdate.value
         else Vector.empty
       },
       scalaCompilerBridgeJars := (Def.taskDyn {
@@ -803,7 +789,7 @@ object Defaults extends BuildCommon with DefExtra {
       scalaCompilerBridgeSource := ZincLmUtil
         .getDefaultBridgeSourceModule(scalaOrganization.value, scalaVersion.value),
       auxiliaryClassFiles ++= {
-        if (ScalaArtifacts.isScala3(scalaVersion.value)) List(TastyFiles.instance)
+        if ScalaArtifacts.isScala3(scalaVersion.value) then List(TastyFiles.instance)
         else Nil
       },
       consoleProject / scalaCompilerBridgeSource := ZincLmUtil.getDefaultBridgeSourceModule(
@@ -898,40 +884,35 @@ object Defaults extends BuildCommon with DefExtra {
       sv: String,
       epochVersion: String,
       cross: Boolean
-  ): Seq[File] = {
-    if (cross)
+  ): Seq[File] =
+    if cross then
       Seq(
         scalaSrcDir,
         scalaSrcDir.getParentFile / s"${scalaSrcDir.name}-$sv",
         scalaSrcDir.getParentFile / s"${scalaSrcDir.name}-$epochVersion",
         javaSrcDir,
       ).distinct
-    else
-      Seq(scalaSrcDir, javaSrcDir)
-  }
+    else Seq(scalaSrcDir, javaSrcDir)
 
   def makeCrossSources(
       scalaSrcDir: File,
       javaSrcDir: File,
       sv: String,
       cross: Boolean
-  ): Seq[File] = {
-    if (cross)
+  ): Seq[File] =
+    if cross then
       Seq(scalaSrcDir.getParentFile / s"${scalaSrcDir.name}-$sv", scalaSrcDir, javaSrcDir)
-    else
-      Seq(scalaSrcDir, javaSrcDir)
-  }
+    else Seq(scalaSrcDir, javaSrcDir)
 
   def makePluginCrossSources(
       isPlugin: Boolean,
       scalaSrcDir: File,
       sbtBinaryV: String,
       cross: Boolean
-  ): Seq[File] = {
-    if (cross && isPlugin)
+  ): Seq[File] =
+    if cross && isPlugin then
       Vector(scalaSrcDir.getParentFile / s"${scalaSrcDir.name}-sbt-$sbtBinaryV")
     else Vector()
-  }
 
   def makeCrossTarget(
       t: File,
@@ -940,14 +921,13 @@ object Defaults extends BuildCommon with DefExtra {
       sbtv: String,
       plugin: Boolean,
       cross: Boolean
-  ): File = {
+  ): File =
     val scalaSuffix =
-      if (ScalaArtifacts.isScala3(scalaVersion)) scalaVersion else scalaBinaryVersion
-    val scalaBase = if (cross) t / ("scala-" + scalaSuffix) else t
-    if (plugin) scalaBase / ("sbt-" + sbtv) else scalaBase
-  }
+      if ScalaArtifacts.isScala3(scalaVersion) then scalaVersion else scalaBinaryVersion
+    val scalaBase = if cross then t / ("scala-" + scalaSuffix) else t
+    if plugin then scalaBase / ("sbt-" + sbtv) else scalaBase
 
-  def compilersSetting = {
+  def compilersSetting =
     compilers := Def.uncached {
       val st = state.value
       val g = BuildPaths.getGlobalBase(st)
@@ -985,17 +965,14 @@ object Defaults extends BuildCommon with DefExtra {
         scalac
       )
       val classLoaderCache = state.value.classLoaderCache
-      if (java.lang.Boolean.getBoolean("sbt.disable.interface.classloader.cache")) compilers
-      else {
+      if java.lang.Boolean.getBoolean("sbt.disable.interface.classloader.cache") then compilers
+      else
         compilers.withScalac(
-          compilers.scalac match {
+          compilers.scalac match
             case x: AnalyzingCompiler => x.withClassLoaderCache(classLoaderCache)
             case x                    => x
-          }
         )
-      }
     }
-  }
 
   lazy val configTasks: Seq[Setting[?]] = docTaskSettings(doc) ++
     inTask(compile)(compileInputsSettings) ++
@@ -1045,13 +1022,13 @@ object Defaults extends BuildCommon with DefExtra {
       },
       compileOutputs := Def.uncached(compileOutputs.triggeredBy(compile).value),
       tastyFiles := Def.taskIf {
-        if (ScalaArtifacts.isScala3(scalaVersion.value)) {
+        if ScalaArtifacts.isScala3(scalaVersion.value) then
           val _ = compile.value
           val c = fileConverter.value
           val dir = c.toPath(backendOutput.value).toFile
           val tastyFiles = dir.**("*.tasty").get()
           tastyFiles.map(_.getAbsoluteFile)
-        } else Nil
+        else Nil
       }.value,
       tastyFilesVF := Def.uncached {
         val conv = fileConverter.value
@@ -1068,13 +1045,11 @@ object Defaults extends BuildCommon with DefExtra {
         val promise = earlyOutputPing.value
         val mn = moduleName.value
         val c = configuration.value
-        new CompileProgress {
-          override def afterEarlyOutput(isSuccess: Boolean): Unit = {
-            if (isSuccess) s.log.debug(s"[$mn / $c] early output is success")
+        new CompileProgress:
+          override def afterEarlyOutput(isSuccess: Boolean): Unit =
+            if isSuccess then s.log.debug(s"[$mn / $c] early output is success")
             else s.log.debug(s"[$mn / $c] early output can't be made because of macros")
             promise.complete(Result.Value(isSuccess))
-          }
-        }
       },
       compileEarly := Def.uncached(compileEarlyTask.value),
       compile := Def.uncached(compileTask.value),
@@ -1082,7 +1057,7 @@ object Defaults extends BuildCommon with DefExtra {
       compileJava := Def.uncached(compileJavaTask.value),
       compileSplit := {
         // conditional task
-        if (incOptions.value.pipelining) Def.uncached(compileJava.value)
+        if incOptions.value.pipelining then Def.uncached(compileJava.value)
         else Def.uncached(compileScalaBackend.value)
       },
       internalDependencyConfigurations := InternalDependencies.configurations.value,
@@ -1093,7 +1068,7 @@ object Defaults extends BuildCommon with DefExtra {
         // to the analysis cache, so we keep the scala versions separated.
         val binVersion = scalaBinaryVersion.value
         val extra =
-          if (crossPaths.value) s"_$binVersion"
+          if crossPaths.value then s"_$binVersion"
           else ""
         s"inc_compile$extra.zip"
       },
@@ -1127,12 +1102,12 @@ object Defaults extends BuildCommon with DefExtra {
       },
       scalacOptions := {
         val old = scalacOptions.value
-        if (exportPipelining.value) {
+        if exportPipelining.value then
           val sv = scalaVersion.value
           val shouldApplyFlags = !ScalaArtifacts.isScala3(sv) || VersionNumber(sv).matchesSemVer(
             SemanticSelector(">=3.5.0")
           )
-          if (shouldApplyFlags)
+          if shouldApplyFlags then
             Def.uncached(
               Vector(
                 "-Ypickle-java",
@@ -1141,7 +1116,7 @@ object Defaults extends BuildCommon with DefExtra {
               ) ++ old
             )
           else Def.uncached(old)
-        } else Def.uncached(old)
+        else Def.uncached(old)
       },
       scalacOptions := {
         val old = scalacOptions.value
@@ -1195,13 +1170,11 @@ object Defaults extends BuildCommon with DefExtra {
           case s if isRunOrTestCommand(s) => true
           case r                          =>
             // Handle both "/" (new syntax like Test/run) and ":" (old syntax like test:run)
-            r.split("[/:]") match {
+            r.split("[/:]") match
               case Array(parts*) =>
-                parts.lastOption match {
+                parts.lastOption match
                   case Some(s) if isRunOrTestCommand(s) => true
                   case _                                => false
-                }
-            }
         })
         pickMainClassOrWarn(discoveredMainClasses.value, streams.value.log, logWarning)
       },
@@ -1232,13 +1205,12 @@ object Defaults extends BuildCommon with DefExtra {
   def generate(generators: SettingKey[Seq[Task[Seq[File]]]]): Initialize[Task[Seq[File]]] =
     generators { _.join.map(_.flatten) }
 
-  def transitiveUpdateTask: Initialize[Task[Seq[UpdateReport]]] = {
+  def transitiveUpdateTask: Initialize[Task[Seq[UpdateReport]]] =
     import ScopeFilter.Make.*
     val selectDeps = ScopeFilter(inDependencies(ThisProject, includeRoot = false))
     val allUpdates = update.?.all(selectDeps)
     // If I am a "build" (a project inside project/) then I have a globalPluginUpdate.
     Def.task { allUpdates.value.flatten ++ globalPluginUpdate.?.value }
-  }
 
   // Returns the ScalaInstance only if it was not constructed via `update`
   //  This is necessary to prevent cycles between `update` and `scalaInstance`
@@ -1345,6 +1317,7 @@ object Defaults extends BuildCommon with DefExtra {
         case e: TestsFailedException if e.taskName.isEmpty =>
           throw new TestsFailedException(taskName, e.testOutput)
       finally close(testLoader.value)
+      end try
     },
     testSelected := {
       try inputTests(testSelected).evaluated
@@ -1361,11 +1334,10 @@ object Defaults extends BuildCommon with DefExtra {
     test := testQuick.evaluated,
   )
 
-  private def close(sbtLoader: ClassLoader): Unit = sbtLoader match {
+  private def close(sbtLoader: ClassLoader): Unit = sbtLoader match
     case u: AutoCloseable   => u.close()
     case c: ClasspathFilter => c.close()
     case _                  =>
-  }
 
   /**
    * A scope whose task axis is set to Zero.
@@ -1430,22 +1402,21 @@ object Defaults extends BuildCommon with DefExtra {
 
   private def closeableTestLogger(manager: Streams, baseKey: Scoped, buffered: Boolean)(
       tdef: TestDefinition
-  ): TestLogger.PerTest = {
+  ): TestLogger.PerTest =
     val scope = baseKey.scope
-    val extra = scope.extra match { case Select(x) => x; case _ => AttributeMap.empty }
+    val extra = scope.extra match
+      case Select(x) => x;
+      case _         => AttributeMap.empty
     val key = ScopedKey(scope.copy(extra = Select(testExtra(extra, tdef))), baseKey.key)
     val s = manager(key)
     new TestLogger.PerTest(s.log, () => s.close(), buffered)
-  }
 
-  def testExtra(extra: AttributeMap, tdef: TestDefinition): AttributeMap = {
-    val mod = tdef.fingerprint match {
+  def testExtra(extra: AttributeMap, tdef: TestDefinition): AttributeMap =
+    val mod = tdef.fingerprint match
       case f: SubclassFingerprint  => f.isModule
       case f: AnnotatedFingerprint => f.isModule
       case _                       => false
-    }
     extra.put(name.key, tdef.name).put(isModule, mod)
-  }
 
   def singleTestGroup(key: Scoped): Initialize[Task[Seq[Tests.Group]]] =
     inTask(key, singleTestGroupDefault)
@@ -1457,7 +1428,7 @@ object Defaults extends BuildCommon with DefExtra {
       new Tests.Group(
         "<default>",
         tests,
-        if (fk) Tests.SubProcess(opts) else Tests.InProcess,
+        if fk then Tests.SubProcess(opts) else Tests.InProcess,
         Seq.empty
       )
     )
@@ -1467,7 +1438,7 @@ object Defaults extends BuildCommon with DefExtra {
     inTask(key, splitTestGroupDefault)
 
   lazy val splitTestGroupDefault: Initialize[Task[Seq[Tests.Group]]] = Def.taskIf {
-    if {
+    if
       val tests = definedTests.value
       val byName = tests.groupBy(_.name).toVector.sortBy(_._1)
       val reqSplit = TestTopology.requestedSplit(testTopology.value)
@@ -1476,7 +1447,7 @@ object Defaults extends BuildCommon with DefExtra {
         math.min(math.min(workerMaxInstances.value, byName.size), reqSplit)
       )
       fork.value && n > 1
-    } then
+    then
       val tests = definedTests.value
       val opts = forkOptions.value
       val byName = tests.groupBy(_.name).toVector.sortBy(_._1)
@@ -1490,8 +1461,7 @@ object Defaults extends BuildCommon with DefExtra {
       buckets.toVector.zipWithIndex.collect {
         case (b, i) if b.result().nonEmpty =>
           new Tests.Group(s"<split-$i>", b.result(), Tests.SubProcess(opts), Seq.empty)
-      }
-    else singleTestGroupDefault.value
+      } else singleTestGroupDefault.value
   }
 
   def forkOptionsTask: Initialize[Task[ForkOptions]] =
@@ -1536,7 +1506,7 @@ object Defaults extends BuildCommon with DefExtra {
   def inputTests(key: InputKey[?]): Initialize[InputTask[TestResult]] =
     inputTests0.mapReferenced(Def.mapScope((s) => s.rescope(key.key)))
 
-  private lazy val inputTests0: Initialize[InputTask[TestResult]] = {
+  private lazy val inputTests0: Initialize[InputTask[TestResult]] =
     val parser =
       loadForParser(definedTestNames)((s, i) => testOnlyParserWithOption(s, i getOrElse Nil))
     ParserGen(parser).flatMapTask { parsed =>
@@ -1616,13 +1586,13 @@ object Defaults extends BuildCommon with DefExtra {
             case e: TestsFailedException if e.taskName.isEmpty =>
               throw new TestsFailedException(taskName, e.testOutput)
     }
-  }
+  end inputTests0
 
   def createTestRunners(
       frameworks: Map[TestFramework, Framework],
       loader: ClassLoader,
       config: Tests.Execution
-  ): Map[TestFramework, Runner] = {
+  ): Map[TestFramework, Runner] =
     import Tests.Argument
     val opts = config.options.toList
     frameworks.map { (tf, f) =>
@@ -1633,7 +1603,6 @@ object Defaults extends BuildCommon with DefExtra {
       val mainRunner = f.runner(args.toArray, Array.empty[String], loader)
       tf -> mainRunner
     }
-  }
 
   private[sbt] def allTestGroupsTask(
       s: TaskStreams,
@@ -1643,7 +1612,7 @@ object Defaults extends BuildCommon with DefExtra {
       config: Tests.Execution,
       cp: Classpath,
       converter: FileConverter,
-  ): Task[Tests.Output] = {
+  ): Task[Tests.Output] =
     allTestGroupsTask(
       s,
       frameworks,
@@ -1658,7 +1627,6 @@ object Defaults extends BuildCommon with DefExtra {
       projectId = "",
       converter = converter,
     )
-  }
 
   private[sbt] def allTestGroupsTask(
       s: TaskStreams,
@@ -1669,7 +1637,7 @@ object Defaults extends BuildCommon with DefExtra {
       cp: Classpath,
       converter: FileConverter,
       forkedParallelExecution: Boolean,
-  ): Task[Tests.Output] = {
+  ): Task[Tests.Output] =
     allTestGroupsTask(
       s,
       frameworks,
@@ -1684,7 +1652,6 @@ object Defaults extends BuildCommon with DefExtra {
       projectId = "",
       converter = converter,
     )
-  }
 
   // Binary compatibility overload for sbt 2.0.0-RC7
   private[sbt] def allTestGroupsTask(
@@ -1699,7 +1666,7 @@ object Defaults extends BuildCommon with DefExtra {
       strategy: ClassLoaderLayeringStrategy,
       projectId: String,
       converter: FileConverter,
-  ): Task[Tests.Output] = {
+  ): Task[Tests.Output] =
     allTestGroupsTask(
       s,
       frameworks,
@@ -1714,7 +1681,6 @@ object Defaults extends BuildCommon with DefExtra {
       projectId,
       converter,
     )
-  }
 
   private[sbt] def allTestGroupsTask(
       s: TaskStreams,
@@ -1729,7 +1695,7 @@ object Defaults extends BuildCommon with DefExtra {
       strategy: ClassLoaderLayeringStrategy,
       projectId: String,
       converter: FileConverter,
-  ): Task[Tests.Output] = {
+  ): Task[Tests.Output] =
     val processedOptions: Map[Tests.Group, Tests.ProcessedOptions] =
       groups
         .map(group => group -> Tests.processOptions(config, group.tests.toVector, s.log))
@@ -1749,7 +1715,7 @@ object Defaults extends BuildCommon with DefExtra {
     val runners = createTestRunners(filteredFrameworks, loader, config)
 
     val groupTasks = groups map { group =>
-      group.runPolicy match {
+      group.runPolicy match
         case Tests.SubProcess(opts) =>
           s.log.debug(s"javaOptions: ${opts.runJVMOptions}")
           val forkedConfig = config.copy(parallel = config.parallel && forkedParallelExecution)
@@ -1769,9 +1735,8 @@ object Defaults extends BuildCommon with DefExtra {
             Vector((Tags.ForkedTestGroup, 1)) ++ config.tags ++ group.tags*
           )
         case Tests.InProcess =>
-          if (javaOptions.nonEmpty) {
+          if javaOptions.nonEmpty then
             s.log.warn("javaOptions will be ignored, fork is set to false")
-          }
           Tests(
             frameworks,
             loader,
@@ -1780,15 +1745,13 @@ object Defaults extends BuildCommon with DefExtra {
             config.copy(tags = config.tags ++ group.tags),
             s.log
           )
-      }
     }
     val output = Tests.foldTasks(groupTasks, config.parallel)
     val result = output map { out =>
       out.events.foreachEntry { (suite, e) =>
-        if (
-          strategy != ClassLoaderLayeringStrategy.Flat ||
+        if strategy != ClassLoaderLayeringStrategy.Flat ||
           strategy != ClassLoaderLayeringStrategy.ScalaLibrary
-        ) {
+        then
           (e.throwables ++ e.throwables.flatMap(t => Option(t.getCause)))
             .find { t =>
               t.isInstanceOf[NoClassDefFoundError] ||
@@ -1823,7 +1786,6 @@ object Defaults extends BuildCommon with DefExtra {
                   + "See ClassLoaderLayeringStrategy.scala for the full list of options."
               )
             }
-        }
       }
       val summaries =
         runners.map: (tf, r) =>
@@ -1832,7 +1794,7 @@ object Defaults extends BuildCommon with DefExtra {
     }
     // Def.value[Task[Tests.Output]] {
     result
-  }
+  end allTestGroupsTask
 
   def detectTests: Initialize[Task[Seq[TestDefinition]]] =
     Def.task {
@@ -1844,7 +1806,7 @@ object Defaults extends BuildCommon with DefExtra {
       val max = EvaluateTask.SystemProcessors
       val maxWorker = workerMaxInstances.value
       if maxWorker < 1 then sys.error("workerMaxInstances must be >= 1")
-      Tags.limitAll(if (par) max else 1) ::
+      Tags.limitAll(if par then max else 1) ::
         Tags.limit(Tags.ForkedTestGroup, maxWorker) ::
         Tags.exclusiveWithin(Tags.ExclusiveTestGroup, Tags.Test) ::
         Tags.exclusiveGroup(Tags.Clean) ::
@@ -2079,17 +2041,15 @@ object Defaults extends BuildCommon with DefExtra {
       }
       val combined = cPart.toList ++ classifier.toList
       val configurations = cOpt.map(c => ConfigRef(c.name)).toVector
-      if (combined.isEmpty) a.withClassifier(None).withConfigurations(configurations)
-      else {
+      if combined.isEmpty then a.withClassifier(None).withConfigurations(configurations)
+      else
         val a1 = a
           .withClassifier(Some(combined.mkString("-")))
           .withConfigurations(configurations)
         // use "source" as opposed to "foo-source" to retrieve the type
-        classifier match {
+        classifier match
           case Some(c) => a1.withType(Artifact.classifierType(c))
           case None    => a1
-        }
-      }
     }
 
   def packageTaskSettings(
@@ -2134,23 +2094,24 @@ object Defaults extends BuildCommon with DefExtra {
 
   def askForMainClass(classes: Seq[String]): Option[String] =
     sbt.SelectMainClass(
-      if (classes.length >= 10) Some(SimpleReader(ITerminal.get).readLine(_))
+      if classes.length >= 10 then Some(SimpleReader(ITerminal.get).readLine(_))
       else
-        Some(s => {
-          def print(st: String) = { scala.Console.out.print(st); scala.Console.out.flush() }
+        Some(s =>
+          def print(st: String) =
+            scala.Console.out.print(st); scala.Console.out.flush()
           print(s)
           ITerminal.get.withRawInput {
             try
-              ITerminal.get.inputStream.read match {
+              ITerminal.get.inputStream.read match
                 case -1 | -2 => None
                 case b       =>
                   val res = b.toChar.toString
                   println(res)
                   Some(res)
-              }
-            catch { case e: InterruptedException => None }
+            catch case e: InterruptedException => None
           }
-        }),
+        )
+      ,
       classes
     )
 
@@ -2161,16 +2122,14 @@ object Defaults extends BuildCommon with DefExtra {
       classes: Seq[String],
       logger: Logger,
       logWarning: Boolean
-  ): Option[String] = {
-    classes match {
+  ): Option[String] =
+    classes match
       case multiple if multiple.size > 1 && logWarning =>
         val msg =
           "multiple main classes detected: run 'show discoveredMainClasses' to see the list"
         logger.warn(msg)
       case _ =>
-    }
     pickMainClass(classes)
-  }
 
   /** Implements `cleanFiles` task. */
   private[sbt] def cleanFilesTask: Initialize[Task[Vector[File]]] = Def.task { Vector.empty[File] }
@@ -2178,7 +2137,7 @@ object Defaults extends BuildCommon with DefExtra {
   def runMainTask(
       classpath: Initialize[Task[Classpath]],
       scalaRun: Initialize[Task[ScalaRun]]
-  ): Initialize[InputTask[Unit]] = {
+  ): Initialize[InputTask[Unit]] =
     val parser =
       loadForParser(discoveredMainClasses)((s, names) => runMainParser(s, names getOrElse Nil))
     Def.inputTask {
@@ -2193,7 +2152,6 @@ object Defaults extends BuildCommon with DefExtra {
         .run(mainClass, cp.files, appArgs, log)
         .get
     }
-  }
 
   def runTask(
       classpath: Initialize[Task[Classpath]],
@@ -2212,17 +2170,15 @@ object Defaults extends BuildCommon with DefExtra {
     val opts = forkOptions.value
     val options = javaOptions.value
     val trap = trapExit.value
-    if (fork.value) {
+    if fork.value then
       s.log.debug(s"javaOptions: $options")
       new ForkRun(opts)
-    } else {
-      new Run(si, trap, tmp)
-    }
+    else new Run(si, trap, tmp)
   }
 
   private def foreachJobTask(
       f: (BackgroundJobService, JobHandle) => Unit
-  ): Initialize[InputTask[Unit]] = {
+  ): Initialize[InputTask[Unit]] =
     val parser: Initialize[State => Parser[Seq[JobHandle]]] = Def.setting { (s: State) =>
       val extracted = Project.extract(s)
       val service = extracted.get(bgJobService)
@@ -2232,11 +2188,8 @@ object Defaults extends BuildCommon with DefExtra {
     }
     Def.inputTask {
       val handles = parser.parsed
-      for (handle <- handles) {
-        f(bgJobService.value, handle)
-      }
+      for handle <- handles do f(bgJobService.value, handle)
     }
-  }
 
   def psTask: Initialize[Task[Seq[JobHandle]]] =
     Def.task {
@@ -2275,10 +2228,10 @@ object Defaults extends BuildCommon with DefExtra {
           val sv = scalaVersion.value
           val config = configuration.value
           val projectName = name.value
-          if (ScalaArtifacts.isScala3(sv)) {
-            val project = if (config == Compile) projectName else s"$projectName-$config"
+          if ScalaArtifacts.isScala3(sv) then
+            val project = if config == Compile then projectName else s"$projectName-$config"
             Seq("-project", project)
-          } else Seq.empty
+          else Seq.empty
         },
         (TaskZero / key) := Def.uncached(Compiler.docTask(key).value),
         (TaskZero / docVF) := Def.uncached {
@@ -2289,10 +2242,9 @@ object Defaults extends BuildCommon with DefExtra {
       ) ++ compilersSetting
     )
 
-  def discoverMainClasses(analysis: CompileAnalysis): Seq[String] = analysis match {
+  def discoverMainClasses(analysis: CompileAnalysis): Seq[String] = analysis match
     case analysis: Analysis =>
       analysis.infos.allInfos.values.map(_.getMainClasses).flatten.toSeq.sorted
-  }
 
   def consoleProjectTask = ConsoleProject.consoleProjectTask
   def consoleTask: Initialize[Task[Unit]] =
@@ -2313,12 +2265,11 @@ object Defaults extends BuildCommon with DefExtra {
     // Save analysis midway if pipelining is enabled
     val store = analysisStore(compileAnalysisFile.value.toPath(), c)
     val contents = store.unsafeGet()
-    if (exportP) {
+    if exportP then
       // this stores the early analysis (again) in case the subproject contains a macro
       setup.earlyAnalysisStore.toScala map { earlyStore =>
         earlyStore.set(contents)
       }
-    }
     CompileResult.of(
       contents.getAnalysis(),
       contents.getMiniSetup(),
@@ -2331,20 +2282,17 @@ object Defaults extends BuildCommon with DefExtra {
    * via `compileProgress` implementation.
    */
   private[sbt] def compileEarlyTask: Initialize[Task[CompileAnalysis]] = Def.task {
-    if ({
+    if
       streams.value.log
         .debug(s"${name.value}: compileEarly: blocking on earlyOutputPing")
       earlyOutputPing.await.value
-    }) {
+    then
       val c = fileConverter.value
       val store = analysisStore(earlyCompileAnalysisFile.value.toPath(), c)
-      store.get.toScala match {
+      store.get.toScala match
         case Some(contents) => contents.getAnalysis
         case _              => Analysis.empty
-      }
-    } else {
-      compile.value
-    }
+    else compile.value
   }
 
   def compileTask: Initialize[Task[CompileAnalysis]] = Def.task {
@@ -2353,10 +2301,9 @@ object Defaults extends BuildCommon with DefExtra {
     val store = analysisStore(compileAnalysisFile.value.toPath(), c)
     // TODO - expose bytecode manipulation phase.
     val analysisResult: CompileResult = manipulateBytecode.value
-    if (analysisResult.hasModified) {
+    if analysisResult.hasModified then
       val contents = AnalysisContents.create(analysisResult.analysis(), analysisResult.setup())
       store.set(contents)
-    }
     val map = managedFileStampCache.value
     val analysis = analysisResult.analysis
     import scala.jdk.CollectionConverters.*
@@ -2400,6 +2347,7 @@ object Defaults extends BuildCommon with DefExtra {
             reporter.sendFailureReport(ci.options.sources, compileFailed)
             bspTask.notifyFailure(compileFailed)
             throw cause
+        end match
       },
     )
   )
@@ -2410,10 +2358,9 @@ object Defaults extends BuildCommon with DefExtra {
       case _           => false
 
   private def projectIdFromScope(s: TaskStreams): String =
-    s.key.scope.project match {
+    s.key.scope.project match
       case Select(ref: ProjectRef) => ref.project
       case _                       => "root"
-    }
 
   private val cachedCompileIncrementalTask = Def
     .cachedTask {
@@ -2456,7 +2403,7 @@ object Defaults extends BuildCommon with DefExtra {
     val reporter = (compile / bspReporter).value
     val inputs = (compileJava / compileInputs).value
     val c = fileConverter.value
-    result match {
+    result match
       case Result.Value(hasModified) =>
         val store = analysisStore(compileAnalysisFile.value.toPath(), c)
         val contents = store.unsafeGet()
@@ -2469,7 +2416,6 @@ object Defaults extends BuildCommon with DefExtra {
       case Result.Inc(cause) =>
         reporter.sendFailureReport(inputs.options.sources)
         throw cause
-    }
   }
 
   private val cachedCompileJavaTask = Def
@@ -2501,7 +2447,7 @@ object Defaults extends BuildCommon with DefExtra {
       ci: Inputs,
       promise: PromiseWrap[Boolean],
       projectId: String
-  ): CompileResult = {
+  ): CompileResult =
     lazy val x = s.text(ExportStream)
     def onArgs(cs: Compilers) =
       cs.withScalac(
@@ -2524,7 +2470,7 @@ object Defaults extends BuildCommon with DefExtra {
           ConcurrentRestrictions.cancelAllSentinels()
         throw e
     finally x.close() // workaround for #937
-  }
+  end compileIncrementalTaskImpl
 
   def compileIncSetupTask = Def.task {
     val cp = dependencyPicklePath.value
@@ -2560,7 +2506,7 @@ object Defaults extends BuildCommon with DefExtra {
 
   def compileInputsSettings: Seq[Setting[?]] =
     compileInputsSettings(dependencyPicklePath)
-  def compileInputsSettings(classpathTask: TaskKey[Classpath]): Seq[Setting[?]] = {
+  def compileInputsSettings(classpathTask: TaskKey[Classpath]): Seq[Setting[?]] =
     Seq(
       compileOptions := Def.uncached {
         val c = fileConverter.value
@@ -2572,7 +2518,7 @@ object Defaults extends BuildCommon with DefExtra {
           c.toVirtualFile(c.toPath(x))
         val eo = CompileOutput(c.toPath(earlyOutput.value))
         val eoOpt =
-          if (exportPipelining.value) Some(eo)
+          if exportPipelining.value then Some(eo)
           else None
         CompileOptions.of(
           cp.toArray,
@@ -2636,25 +2582,21 @@ object Defaults extends BuildCommon with DefExtra {
           )
         )
     )
-  }
 
   private[sbt] def foldMappers(
       mappers: Seq[Position => Option[Position]],
       reportAbsolutePath: Boolean,
       fc: FileConverter
-  ) = {
+  ) =
     def withAbsoluteSource(p: Position): Position =
-      if (reportAbsolutePath) toAbsoluteSource(fc)(p) else p
+      if reportAbsolutePath then toAbsoluteSource(fc)(p) else p
 
     mappers.foldRight({ (p: Position) =>
       withAbsoluteSource(p) // Fallback if sourcePositionMappers is empty
-    }) { (mapper, previousPosition) =>
-      { (p: Position) =>
-        // To each mapper we pass the position with the absolute source (only if reportAbsolutePath = true of course)
-        mapper(withAbsoluteSource(p)).getOrElse(previousPosition(p))
-      }
+    }) { (mapper, previousPosition) => (p: Position) =>
+      // To each mapper we pass the position with the absolute source (only if reportAbsolutePath = true of course)
+      mapper(withAbsoluteSource(p)).getOrElse(previousPosition(p))
     }
-  }
 
   private[sbt] def none[A]: Option[A] = (None: Option[A])
   private[sbt] def jnone[A]: Optional[A] = none[A].toJava
@@ -2663,13 +2605,12 @@ object Defaults extends BuildCommon with DefExtra {
       val setup = compileIncSetup.value
       val c = fileConverter.value
       val store = analysisStore(compileAnalysisFile.value.toPath(), c)
-      val prev = store.get().toScala match {
+      val prev = store.get().toScala match
         case Some(contents) =>
           val analysis = Option(contents.getAnalysis).toJava
           val setup = Option(contents.getMiniSetup).toJava
           PreviousResult.of(analysis, setup)
         case None => PreviousResult.of(jnone[CompileAnalysis], jnone[MiniSetup])
-      }
       prev
     }
   )
@@ -2679,7 +2620,8 @@ object Defaults extends BuildCommon with DefExtra {
 
   def printWarningsTask: Initialize[Task[Unit]] =
     Def.task {
-      val analysis = compile.value match { case a: Analysis => a }
+      val analysis = compile.value match
+        case a: Analysis => a
       val max = maxErrors.value
       val spms = sourcePositionMappers.value
       val problems =
@@ -2733,11 +2675,10 @@ object Defaults extends BuildCommon with DefExtra {
       mappings
     }
 
-  def runMainParser: (State, Seq[String]) => Parser[(String, Seq[String])] = {
+  def runMainParser: (State, Seq[String]) => Parser[(String, Seq[String])] =
     import DefaultParsers.*
     (state, mainClasses) =>
       Space ~> token(NotSpace.examples(mainClasses.toSet)) ~ spaceDelimited("<arg>")
-  }
 
   private def testOnlyParserWithOption
       : (State, Seq[String]) => Parser[(Seq[String], Seq[String], Seq[Tests.AdhocOption])] =
@@ -2750,15 +2691,14 @@ object Defaults extends BuildCommon with DefExtra {
         (t, f, o1.toList ::: o2.toList)
       }
 
-  def testOnlyParser: (State, Seq[String]) => Parser[(Seq[String], Seq[String])] = {
+  def testOnlyParser: (State, Seq[String]) => Parser[(Seq[String], Seq[String])] =
     (state, tests) =>
       import DefaultParsers.*
       val selectTests = distinctParser(tests.toSet, true)
       val options = (token(Space) ~> token("--") ~> spaceDelimited("<option>")) ?? Nil
       selectTests ~ options
-  }
 
-  private def distinctParser(exs: Set[String], raw: Boolean): Parser[Seq[String]] = {
+  private def distinctParser(exs: Set[String], raw: Boolean): Parser[Seq[String]] =
     import DefaultParsers.*
     import Parser.and
     val base = token(Space) ~> token(and(NotSpace, not("--", "Unexpected: ---")).examples(exs))
@@ -2766,11 +2706,10 @@ object Defaults extends BuildCommon with DefExtra {
       val expandedEx = IncrementalTest.expandGlob(ex)
       val (matching, notMatching) = exs.partition(GlobFilter(expandedEx).accept)
       distinctParser(notMatching, raw) map { result =>
-        if (raw) ex +: result else matching.toSeq ++ result
+        if raw then ex +: result else matching.toSeq ++ result
       }
     }
     recurse ?? Nil
-  }
 
   val CompletionsID = "completions"
 
@@ -2814,7 +2753,7 @@ object Defaults extends BuildCommon with DefExtra {
       target := baseDirectory.value / "target",
       bgHashClasspath := !turbo.value,
       classLoaderLayeringStrategy := {
-        if (turbo.value) ClassLoaderLayeringStrategy.AllLibraryJars
+        if turbo.value then ClassLoaderLayeringStrategy.AllLibraryJars
         else ClassLoaderLayeringStrategy.ScalaLibrary
       },
       publishLocal / skip := (publish / skip).value,
@@ -2822,18 +2761,16 @@ object Defaults extends BuildCommon with DefExtra {
       fetchSource := Def.uncached {
         val uri = thisProjectRef.value.build
         val log = streams.value.log
-        RetrieveUnit(uri) match {
+        RetrieveUnit(uri) match
           case None      => ()
           case Some(vcs) =>
             val strategy = repositoryUpdateStrategy.value
             val lb = Project.extract(state.value).get(Keys.loadedBuild)
             val vcsRoot = lb.units.get(uri).map(_.localBase).getOrElse(baseDirectory.value)
-            if (Resolvers.shouldUpdate(vcsRoot, strategy)) {
+            if Resolvers.shouldUpdate(vcsRoot, strategy) then
               log.info(s"Updating remote project: $vcsRoot ...")
-              if (Resolvers.updateRepository(vcsRoot, vcs, log))
+              if Resolvers.updateRepository(vcsRoot, vcs, log) then
                 log.warn("Remote dependencies updated. Run `reload` to pick up changes.")
-            }
-        }
       },
     )
   // build.sbt is treated a Scala source of metabuild, so to enable deprecation flag on build.sbt we set the option here.
@@ -2844,7 +2781,7 @@ object Defaults extends BuildCommon with DefExtra {
           val old = scalacOptions.value
           val existing = old.toSet
           val d = "-deprecation"
-          if (sbtPlugin.value && !existing(d)) d :: old.toList
+          if sbtPlugin.value && !existing(d) then d :: old.toList
           else old
         }
       )
@@ -2867,9 +2804,9 @@ object Defaults extends BuildCommon with DefExtra {
 
   def runLocalTemplate(arguments: Seq[String], log: Logger): Unit =
     TemplateCommandUtil.defaultRunLocalTemplate(arguments.toList, log)
-}
+end Defaults
 
-object Classpaths {
+object Classpaths:
   import Defaults.*
   import Keys.*
 
@@ -3112,7 +3049,7 @@ object Classpaths {
       thisConfig: Configuration,
       delegated: Option[Configuration],
       report: UpdateReport
-  ): Configuration = {
+  ): Configuration =
     val defined = report.allConfigurations.toSet
     val search = map(thisConfig) +: (delegated.toList ++ Seq(Compile, Configurations.Default))
     def notFound =
@@ -3122,7 +3059,6 @@ object Classpaths {
     search find { c =>
       defined contains ConfigRef(c.name)
     } getOrElse notFound
-  }
 
   def packaged(
       pkgTasks: Seq[TaskKey[HashedVirtualFileRef]]
@@ -3171,9 +3107,9 @@ object Classpaths {
     },
     // publishLocal needs legacy artifacts (see https://github.com/sbt/sbt/issues/7285)
     publishLocal / packagedArtifacts ++= {
-      if (sbtPlugin.value && !sbtPluginPublishLegacyMavenStyle.value) {
+      if sbtPlugin.value && !sbtPluginPublishLegacyMavenStyle.value then
         packagedDefaultArtifacts.value
-      } else Map.empty[Artifact, HashedVirtualFileRef]
+      else Map.empty[Artifact, HashedVirtualFileRef]
     }
   )
 
@@ -3185,10 +3121,10 @@ object Classpaths {
   private def mavenArtifactsOfSbtPlugin: Def.Initialize[Task[Map[Artifact, HashedVirtualFileRef]]] =
     Def.task {
       // This is a conditional task. The top-level must be an if expression.
-      if (sbt2Plus.value) {
+      if sbt2Plus.value then
         // Both POMs and JARs are Maven-compatible in sbt 2.x, so ignore the workarounds
         packagedDefaultArtifacts.value
-      } else {
+      else
         val sbtV = (pluginCrossBuild / sbtBinaryVersion).value
         val scalaV = scalaBinaryVersion.value
         val crossVersion = (name: String) => name + s"_${scalaV}_$sbtV"
@@ -3198,13 +3134,12 @@ object Classpaths {
         Map(addSuffix(legacyPomArtifact) -> makeMavenPomOfSbtPlugin(converter, crossVersion)) ++
           pomConsistentArtifactsForLegacySbt(converter, crossVersion) ++
           legacyPackagedArtifacts.value
-      }
     }
 
   private def legacyPackagedArtifacts: Def.Initialize[Task[Map[Artifact, HashedVirtualFileRef]]] =
     Def.task {
       // This is a conditional task. The top-level must be an if expression.
-      if (sbtPluginPublishLegacyMavenStyle.value) packagedDefaultArtifacts.value
+      if sbtPluginPublishLegacyMavenStyle.value then packagedDefaultArtifacts.value
       else Map.empty[Artifact, HashedVirtualFileRef]
     }
 
@@ -3216,14 +3151,13 @@ object Classpaths {
     def copyArtifact(
         artifact: Artifact,
         fileRef: HashedVirtualFileRef
-    ): (Artifact, HashedVirtualFileRef) = {
+    ): (Artifact, HashedVirtualFileRef) =
       val nameWithSuffix = crossVersion(artifact.name)
       val file = converter.toPath(fileRef).toFile
       val targetFile =
         new File(file.getParentFile, file.name.replace(artifact.name, nameWithSuffix))
       IO.copyFile(file, targetFile)
       artifact.withName(nameWithSuffix) -> converter.toVirtualFile(targetFile.toPath)
-    }
     legacyPackages.map { (artifact, file) =>
       copyArtifact(artifact, file);
     }
@@ -3289,7 +3223,7 @@ object Classpaths {
         case d: Credentials.DirectCredentials => d.host == Sona.host
         case _                                => false
       }
-      if (!alreadyContainsCentralCredentials) SysProp.sonatypeCredentalsEnv.toSeq
+      if !alreadyContainsCentralCredentials then SysProp.sonatypeCredentalsEnv.toSeq
       else Nil
     },
     sonaDeploymentName := {
@@ -3323,8 +3257,7 @@ object Classpaths {
         assumedVersionSchemeJava :== VersionScheme.Always,
         excludeDependencies :== Nil,
         ivyLoggingLevel := ( // This will suppress "Resolving..." logs on Jenkins and Travis.
-          if (insideCI.value)
-            UpdateLogging.Quiet
+          if insideCI.value then UpdateLogging.Quiet
           else UpdateLogging.Default
         ),
         ivyXML :== NodeSeq.Empty,
@@ -3350,11 +3283,10 @@ object Classpaths {
           val id = app.provider.id
           val scalaVersion = app.provider.scalaProvider.version
           val binVersion = binaryScalaVersion(scalaVersion)
-          val cross = id.crossVersionedValue match {
+          val cross = id.crossVersionedValue match
             case CrossValue.Disabled => Disabled()
             case CrossValue.Full     => CrossVersion.binary
             case CrossValue.Binary   => CrossVersion.full
-          }
           val base = ModuleID(id.groupID, id.name, sbtVersion.value)
             .withCrossVersion(cross)
             .platform(Platform.jvm)
@@ -3362,10 +3294,9 @@ object Classpaths {
         },
         shellPrompt := sbt.internal.ui.UITask.NoShellPrompt,
         colorShellPrompt := { (c, s) =>
-          shellPrompt.value match {
+          shellPrompt.value match
             case sbt.internal.ui.UITask.NoShellPrompt => shellPromptFromState(c)(s)
             case p                                    => p(s)
-          }
         },
         dynamicDependency := { (): Unit },
         transitiveClasspathDependency := { (): Unit },
@@ -3399,12 +3330,11 @@ object Classpaths {
         externalResolvers.?.value,
         resolvers.value,
         appResolvers.value,
-      ) match {
+      ) match
         case (Some(delegated), Seq(), _) => delegated
         case (_, rs, Some(ars))          => ars ++ rs
         case (_, rs, _)                  =>
           Resolver.combineDefaultResolvers(rs.toVector, mavenCentral = true)
-      }
     ),
     appResolvers := {
       val ac = appConfiguration.value
@@ -3429,17 +3359,16 @@ object Classpaths {
             .resolvers
             .getOrElse(Vector.empty)
         val pr =
-          if (includePluginResolvers.value) pluginResolvers
+          if includePluginResolvers.value then pluginResolvers
           else Vector.empty
-        bootResolvers.value match {
+        bootResolvers.value match
           case Some(repos) if overrideBuildResolvers.value => proj +: repos
           case _                                           =>
-            val base = if (sbtPlugin.value) sbtResolvers.value ++ rs ++ pr else rs ++ pr
+            val base = if sbtPlugin.value then sbtResolvers.value ++ rs ++ pr else rs ++ pr
             (proj +: base).distinct
-        }
       }).value),
     csrSameVersions ++= {
-      partialVersion(scalaVersion.value) match {
+      partialVersion(scalaVersion.value) match
         // See https://github.com/sbt/sbt/issues/8689
         // Scala 2.x should align all Scala 2 artifacts (scala-library, scala-compiler, scala-reflect, etc.)
         case Some((major, _)) if major == 2 =>
@@ -3458,7 +3387,6 @@ object Classpaths {
             .map(a => InclExclRule(scalaOrganization.value, a))
             .toSet :: Nil
         case _ => Nil
-      }
     },
     moduleName := normalizedName.value,
     outputPath := {
@@ -3481,13 +3409,12 @@ object Classpaths {
       val ip = ivyPaths.value
       // if ivyPaths is customized, create coursier-cache directory in it
       val defaultIvyCache = bootIvyHome(ac).map(_.toString)
-      if (old != LMCoursier.defaultCacheLocation) old
-      else if (ip.ivyHome == defaultIvyCache) old
+      if old != LMCoursier.defaultCacheLocation then old
+      else if ip.ivyHome == defaultIvyCache then old
       else
-        ip.ivyHome match {
+        ip.ivyHome match
           case Some(home) => new File(home) / "coursier-cache"
           case _          => old
-        }
     },
     dependencyCacheDirectory := {
       val st = state.value
@@ -3538,7 +3465,7 @@ object Classpaths {
         .withOffline(offline.value)
     },
     retrieveConfiguration := {
-      if (retrieveManaged.value)
+      if retrieveManaged.value then
         Some(
           RetrieveConfiguration()
             .withRetrieveDirectory(managedDirectory.value)
@@ -3552,13 +3479,13 @@ object Classpaths {
     ivyConfiguration := Def.uncached((): Any),
     ivyConfigurations := {
       val confs = thisProject.value.configurations
-      (confs ++ confs.map(internalConfigurationMap.value) ++ (if (autoCompilerPlugins.value)
+      (confs ++ confs.map(internalConfigurationMap.value) ++ (if autoCompilerPlugins.value then
                                                                 CompilerPlugin :: Nil
                                                               else Nil)).distinct
     },
     ivyConfigurations ++= Configurations.auxiliary,
     ivyConfigurations ++= {
-      if (managedScalaInstance.value && scalaHome.value.isEmpty)
+      if managedScalaInstance.value && scalaHome.value.isEmpty then
         Configurations.ScalaTool :: Configurations.ScalaDocTool :: Configurations.ScalaReplTool :: Configurations.ZincTool :: Nil
       else Nil
     },
@@ -3567,8 +3494,7 @@ object Classpaths {
       val confs = ivyConfigurations.value
       val names = confs.map(_.name).toSet
       val extraSources =
-        if (names("sources"))
-          None
+        if names("sources") then None
         else
           Some(
             Configuration.of(
@@ -3582,8 +3508,7 @@ object Classpaths {
           )
 
       val extraDocs =
-        if (names("docs"))
-          None
+        if names("docs") then None
         else
           Some(
             Configuration.of(
@@ -3615,7 +3540,7 @@ object Classpaths {
       makeIvyXmlConfig(
         publishMavenStyle.value,
         sbt.Classpaths.deliverPattern(target.value),
-        if (isSnapshot.value) "integration" else "release",
+        if isSnapshot.value then "integration" else "release",
         ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
         (publish / checksums).value.toVector,
         ivyLoggingLevel.value,
@@ -3625,7 +3550,7 @@ object Classpaths {
     publishConfiguration := Def.uncached {
       val s = streams.value
       val vs = versionScheme.value
-      if (vs.isEmpty)
+      if vs.isEmpty then
         s.log.warn(
           s"""versionScheme setting is empty; set `ThisBuild / versionScheme := Some("early-semver")`, `Some("semver-spec")` or `Some("pvp")`
              |so tooling can use it for eviction errors etc - https://www.scala-sbt.org/1.x/docs/Publishing.html""".stripMargin
@@ -3638,7 +3563,7 @@ object Classpaths {
       publishConfig(
         publishMavenStyle.value,
         deliverPattern(target.value),
-        if (isSnapshot.value) "integration" else "release",
+        if isSnapshot.value then "integration" else "release",
         ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
         artifacts,
         (publish / checksums).value.toVector,
@@ -3651,7 +3576,7 @@ object Classpaths {
       makeIvyXmlConfig(
         false, // publishMavenStyle.value,
         sbt.Classpaths.deliverPattern(target.value),
-        if (isSnapshot.value) "integration" else "release",
+        if isSnapshot.value then "integration" else "release",
         ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
         (publish / checksums).value.toVector,
         ivyLoggingLevel.value,
@@ -3667,7 +3592,7 @@ object Classpaths {
       publishConfig(
         false, // publishMavenStyle.value,
         deliverPattern(target.value),
-        if (isSnapshot.value) "integration" else "release",
+        if isSnapshot.value then "integration" else "release",
         ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
         artifacts,
         (publishLocal / checksums).value.toVector,
@@ -3683,7 +3608,7 @@ object Classpaths {
       publishConfig(
         true,
         deliverPattern(target.value),
-        if (isSnapshot.value) "integration" else "release",
+        if isSnapshot.value then "integration" else "release",
         ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
         artifacts,
         checksums = (publishM2 / checksums).value.toVector,
@@ -3716,7 +3641,7 @@ object Classpaths {
     transitiveUpdate := Def.uncached(transitiveUpdateTask.value),
     updateCacheName := {
       val binVersion = scalaBinaryVersion.value
-      val suffix = if (crossPaths.value) s"_$binVersion" else ""
+      val suffix = if crossPaths.value then s"_$binVersion" else ""
       s"update_cache$suffix"
     },
     dependencyPositions := Def.uncached(dependencyPositionsTask.value),
@@ -3730,7 +3655,7 @@ object Classpaths {
       val thisRef = thisProjectRef.value
       val lb = loadedBuild.value
       val vcsRootRefs = Resolvers.transitiveVcsRootRefs(thisRef, buildDeps, lb)
-      if (vcsRootRefs.isEmpty) Def.task(())
+      if vcsRootRefs.isEmpty then Def.task(())
       else Def.sequential(vcsRootRefs.map(_ / fetchSource).toSeq)
     }.value),
     updateFull := Def.uncached(updateTask.value),
@@ -3812,7 +3737,7 @@ object Classpaths {
       val sbtdeps =
         (pluginCrossBuild / sbtDependency).value.withConfigurations(Some(Provided.name))
       val pluginAdjust =
-        if (isPlugin) sbtdeps +: base
+        if isPlugin then sbtdeps +: base
         else base
       val scalaOrg = scalaOrganization.value
       // Resolve dynamic Scala version (e.g., "3-latest.candidate" -> "3.8.1-RC1")
@@ -3850,7 +3775,7 @@ object Classpaths {
         "org.slf4j" % "slf4j-api",
         "com.typesafe" % "config",
       )
-      if (isMeta && !force) excludes.toVector ++ sbtModulesExcludes
+      if isMeta && !force then excludes.toVector ++ sbtModulesExcludes
       else excludes
     },
     dependencyOverrides ++= {
@@ -3859,34 +3784,26 @@ object Classpaths {
       val id = app.provider.id
       val sv = (pluginCrossBuild / sbtVersion).value
       val base = ModuleID(id.groupID, "scripted-plugin", sv).withCrossVersion(CrossVersion.binary)
-      if (isPlugin) Seq(base)
+      if isPlugin then Seq(base)
       else Seq()
     }
   )
 
-  def warnResolversConflict(resolverList: Seq[Resolver], log: Logger): Unit = {
+  def warnResolversConflict(resolverList: Seq[Resolver], log: Logger): Unit =
     val resolverSet = resolverList.toSet
-    for ((name, r) <- resolverSet groupBy (_.name) if r.size > 1) {
+    for (name, r) <- resolverSet groupBy (_.name) if r.size > 1 do
       log.warn(
         "Multiple resolvers having different access mechanism configured with same name '" + name + "'. To avoid conflict, Remove duplicate project resolvers (`resolvers`) or rename publishing resolver (`publishTo`)."
       )
-    }
-  }
 
-  private[sbt] def errorInsecureProtocol(resolverList: Seq[Resolver], log: Logger): Unit = {
+  private[sbt] def errorInsecureProtocol(resolverList: Seq[Resolver], log: Logger): Unit =
     val bad = !resolverList.forall(!_.validateProtocol(log))
-    if (bad) {
-      sys.error("insecure protocol is unsupported")
-    }
-  }
+    if bad then sys.error("insecure protocol is unsupported")
   // this warns about .from("http:/...") in ModuleID
-  private[sbt] def errorInsecureProtocolInModules(mods: Seq[ModuleID], log: Logger): Unit = {
+  private[sbt] def errorInsecureProtocolInModules(mods: Seq[ModuleID], log: Logger): Unit =
     val artifacts = mods.flatMap(_.explicitArtifacts.toSeq)
     val bad = !artifacts.forall(!_.validateProtocol(log))
-    if (bad) {
-      sys.error("insecure protocol is unsupported")
-    }
-  }
+    if bad then sys.error("insecure protocol is unsupported")
 
   private[sbt] def defaultProjectID: Initialize[ModuleID] = Def.setting {
     val p0 = ModuleID(organization.value, moduleName.value, version.value)
@@ -3909,7 +3826,7 @@ object Classpaths {
   }
   def pluginProjectID: Initialize[ModuleID] =
     Def.setting {
-      if (sbtPlugin.value)
+      if sbtPlugin.value then
         sbtPluginExtra(
           projectID.value,
           (pluginCrossBuild / sbtBinaryVersion).value,
@@ -3959,7 +3876,7 @@ object Classpaths {
           // to fix https://github.com/sbt/sbt/issues/8026
           scalaVersion := {
             val isPlugin = sbtPlugin.value
-            if (isPlugin) (pluginCrossBuild / scalaVersion).value
+            if isPlugin then (pluginCrossBuild / scalaVersion).value
             else appConfiguration.value.provider.scalaProvider.version
           },
           scalaBinaryVersion := binaryScalaVersion(scalaVersion.value),
@@ -4014,10 +3931,9 @@ object Classpaths {
                     ),
                     uwConfig,
                     log
-                  ) match {
+                  ) match
                     case Left(_)   => ???
                     case Right(ur) => ur
-                  }
                 }
               }
               .tag(Tags.Update, Tags.Network))
@@ -4050,12 +3966,11 @@ object Classpaths {
             .resolvers
           val ext = externalResolvers.value.toVector
           // https://github.com/sbt/sbt/issues/4408
-          val xs = (explicit, boot) match {
+          val xs = (explicit, boot) match
             case (Some(ex), Some(b)) => (ex.toVector ++ b.toVector).distinct
             case (Some(ex), None)    => ex
             case (None, Some(b))     => b.toVector
             case _                   => Vector()
-          }
           (xs ++ ext).distinct
         },
         scalaCompilerBridgeDependencyResolution := Def.uncached(
@@ -4064,14 +3979,13 @@ object Classpaths {
       )
 
   val moduleIdJsonKeyFormat: sjsonnew.JsonKeyFormat[ModuleID] =
-    new sjsonnew.JsonKeyFormat[ModuleID] {
+    new sjsonnew.JsonKeyFormat[ModuleID]:
       import sjsonnew.support.scalajson.unsafe.*
       val moduleIdFormat: JsonFormat[ModuleID] = implicitly[JsonFormat[ModuleID]]
       def write(key: ModuleID): String =
         CompactPrinter(Converter.toJsonUnsafe(key)(using moduleIdFormat))
       def read(key: String): ModuleID =
         Converter.fromJsonUnsafe[ModuleID](Parser.parseUnsafe(key))(using moduleIdFormat)
-    }
 
   def classifiersModuleTask: Initialize[Task[GetClassifiersModule]] =
     Def.task {
@@ -4121,12 +4035,11 @@ object Classpaths {
     log.debug(s"Skipping publish* for ${ref.project}")
 
   @deprecated("use publishOrSkip instead", "1.9.1")
-  def publishTask(config: TaskKey[PublishConfiguration]): Initialize[Task[Unit]] = {
+  def publishTask(config: TaskKey[PublishConfiguration]): Initialize[Task[Unit]] =
     val skipKey =
-      if (config.key == publishLocalConfiguration.key) publishLocal / skip
+      if config.key == publishLocalConfiguration.key then publishLocal / skip
       else publish / skip
     publishOrSkip(config, skipKey)
-  }
 
   def publishOrSkip(
       config: TaskKey[PublishConfiguration],
@@ -4160,17 +4073,15 @@ object Classpaths {
    *
    * Equality is weak, that is, no version qualifier is checked.
    */
-  private def unmanagedJarsTask(scalaVersion: String, unmanagedVersion: String, jars: Seq[File]) = {
+  private def unmanagedJarsTask(scalaVersion: String, unmanagedVersion: String, jars: Seq[File]) =
     (subVersion0: String) =>
       val scalaV = partialVersion(scalaVersion)
       val managedV = partialVersion(subVersion0)
       val unmanagedV = partialVersion(unmanagedVersion)
-      (managedV, unmanagedV, scalaV) match {
+      (managedV, unmanagedV, scalaV) match
         case (Some(mv), Some(uv), _) if mv == uv => jars
         case (Some(mv), _, Some(sv)) if mv == sv => jars
         case _                                   => Nil
-      }
-  }
 
   lazy val updateTask: Initialize[Task[UpdateReport]] =
     updateTask0("updateFull", true, true).tag(Tags.Update, Tags.Network)
@@ -4323,11 +4234,10 @@ object Classpaths {
           cwo,
       ) =>
         val cacheDirectory = ct / cacheLabel / ucn
-        val cacheStoreFactory: CacheStoreFactory = {
+        val cacheStoreFactory: CacheStoreFactory =
           val factory =
             state0.get(Keys.cacheStoreFactoryFactory).getOrElse(InMemoryCacheStore.factory(0))
           factory(cacheDirectory.toPath)
-        }
 
         val isRoot = er.contains(rs)
         val shouldForce = isRoot || {
@@ -4341,34 +4251,31 @@ object Classpaths {
               fullUpdateOutput.exists() && elapsedDuration > period
         }
 
-        val providedScalaJars: String => Seq[File] = {
+        val providedScalaJars: String => Seq[File] =
           val scalaProvider = ac.provider.scalaProvider
           usiOnly match
             case Some(instance) =>
               unmanagedJarsTask(sv, instance.version, instance.allJars.toIndexedSeq)
             case None =>
               (subVersion: String) =>
-                if (scalaProvider.version == subVersion) scalaProvider.jars.toIndexedSeq else Nil
-        }
-        val updateConf = {
+                if scalaProvider.version == subVersion then scalaProvider.jars.toIndexedSeq else Nil
+        val updateConf =
           // Log captures log messages at all levels, except ivy logs.
           // Use full level when debug is enabled so that ivy logs are shown.
           import UpdateLogging.{ Default, DownloadOnly, Full }
-          val conf1 = maybeUpdateLevel.orElse(state0.get(logLevel.key)) match {
+          val conf1 = maybeUpdateLevel.orElse(state0.get(logLevel.key)) match
             case Some(Level.Debug) if conf.logging == Default => conf.withLogging(logging = Full)
             case Some(_) if conf.logging == Default => conf.withLogging(logging = DownloadOnly)
             case _                                  => conf
-          }
 
           // logical clock is folded into UpdateConfiguration
           conf1
             .withLogicalClock(LogicalClock(state0.hashCode))
             .withMetadataDirectory(dcd)
-        }
 
         val extracted = Project.extract(state0)
         val label =
-          if (isPlugin) Reference.display(thisRef)
+          if isPlugin then Reference.display(thisRef)
           else Def.displayRelativeReference(extracted.currentRef, thisRef)
 
         LibraryManagement.cachedUpdate(
@@ -4404,7 +4311,7 @@ object Classpaths {
       val cacheStoreFactory = s.cacheStoreFactory.sub(updateCacheName.value)
       import sbt.librarymanagement.LibraryManagementCodec.*
       def modulePositions: Map[ModuleID, SourcePosition] =
-        try {
+        try
           val extracted = Project.extract(st)
           val sk = (projRef / Zero / Zero / libraryDependencies).scopedKey
           val empty = extracted.structure.data.set(sk, Nil)
@@ -4416,9 +4323,7 @@ object Classpaths {
             .asInstanceOf[Seq[Setting[Seq[ModuleID]]]]
             .flatMap(s => s.init.evaluate(empty).map(_ -> s.pos))
             .toMap
-        } catch {
-          case NonFatal(_) => Map()
-        }
+        catch case NonFatal(_) => Map()
 
       val outCacheStore = cacheStoreFactory.make("output_dsp")
       val f = Tracked.inputChanged(cacheStoreFactory.make("input_dsp")) {
@@ -4570,20 +4475,21 @@ object Classpaths {
               // not raw depSBV; sandwich case uses constant(depSBV) so would request wrong artifact.
               case c: sbt.librarymanagement.For3Use2_13 if sbv != depSBV =>
                 val compat =
-                  if (depSBV == "3" || depSBV.startsWith("3.0.0")) "2.13"
+                  if depSBV == "3" || depSBV.startsWith("3.0.0") then "2.13"
                   else depSBV
                 depProjId
                   .withCrossVersion(CrossVersion.constant(c.prefix + compat + c.suffix))
                   .withConfigurations(dep.configuration)
                   .withExplicitArtifacts(Vector.empty)
               case c: sbt.librarymanagement.For2_13Use3 if sbv != depSBV =>
-                val compat = if (depSBV == "2.13") "3" else depSBV
+                val compat = if depSBV == "2.13" then "3" else depSBV
                 depProjId
                   .withCrossVersion(CrossVersion.constant(c.prefix + compat + c.suffix))
                   .withConfigurations(dep.configuration)
                   .withExplicitArtifacts(Vector.empty)
               case _ =>
                 depProjId.withConfigurations(dep.configuration).withExplicitArtifacts(Vector.empty)
+            end match
     }
 
   def projectResolverTask: Initialize[Task[Resolver]] =
@@ -4608,15 +4514,14 @@ object Classpaths {
 
   private[sbt] def makePickleProducts: Initialize[Task[Seq[VirtualFile]]] = Def.task {
     // This is a conditional task.
-    if (earlyOutputPing.await.value) {
+    if earlyOutputPing.await.value then
       // TODO: copyResources.value
       earlyOutput.value :: Nil
-    } else {
+    else
       val c = fileConverter.value
       products.value map { (x: File) =>
         c.toVirtualFile(x.toPath)
       }
-    }
   }
 
   def constructBuildDependencies: Initialize[BuildDependencies] =
@@ -4707,7 +4612,7 @@ object Classpaths {
 
   @deprecated("no longer true for sbt 2.x", "2.0.0")
   def modifyForPlugin(plugin: Boolean, dep: ModuleID): ModuleID =
-    if (plugin) dep.withConfigurations(Some(Provided.name)) else dep
+    if plugin then dep.withConfigurations(Some(Provided.name)) else dep
 
   def autoLibraryDependency(
       auto: Boolean,
@@ -4823,7 +4728,7 @@ object Classpaths {
         ScalaInstance.isDotty(scalaVersion.value)
       )
       val existing = options.toSet
-      if (autoCompilerPlugins.value) options ++ newPlugins.filterNot(existing) else options
+      if autoCompilerPlugins.value then options ++ newPlugins.filterNot(existing) else options
     }
   )
 
@@ -4831,89 +4736,71 @@ object Classpaths {
       scalaJars: String => Seq[File]
   ): UpdateReport =
     report.substitute { (configuration, module, arts) =>
-      if (module.organization == scalaOrg) {
+      if module.organization == scalaOrg then
         val jarName = module.name + ".jar"
         val replaceWith = scalaJars(module.revision).toVector
           .withFilter(_.getName == jarName)
           .map(f => (Artifact(f.getName.stripSuffix(".jar")), f))
-        if (replaceWith.isEmpty) arts else replaceWith
-      } else arts
+        if replaceWith.isEmpty then arts else replaceWith
+      else arts
     }
 
   // try/catch for supporting earlier launchers
   def bootIvyHome(app: xsbti.AppConfiguration): Option[File] =
-    try {
-      Option(app.provider.scalaProvider.launcher.ivyHome)
-    } catch {
-      case _: NoSuchMethodError => None
-    }
+    try Option(app.provider.scalaProvider.launcher.ivyHome)
+    catch case _: NoSuchMethodError => None
 
   def bootChecksums(app: xsbti.AppConfiguration): Vector[String] =
-    try {
-      app.provider.scalaProvider.launcher.checksums.toVector
-    } catch {
-      case _: NoSuchMethodError => Vector("sha1", "md5")
-    }
+    try app.provider.scalaProvider.launcher.checksums.toVector
+    catch case _: NoSuchMethodError => Vector("sha1", "md5")
 
   def isOverrideRepositories(app: xsbti.AppConfiguration): Boolean =
     try app.provider.scalaProvider.launcher.isOverrideRepositories
-    catch { case _: NoSuchMethodError => false }
+    catch case _: NoSuchMethodError => false
 
   def shouldOverrideBuildResolvers(app: xsbti.AppConfiguration): Boolean =
     isOverrideRepositories(app) || SysProp.getOrFalse("sbt.override.build.repos")
 
   /** Loads the `appRepositories` configured for this launcher, if supported. */
   def appRepositories(app: xsbti.AppConfiguration): Option[Vector[Resolver]] =
-    try {
-      Some(app.provider.scalaProvider.launcher.appRepositories.toVector map bootRepository)
-    } catch {
-      case _: NoSuchMethodError => None
-    }
+    try Some(app.provider.scalaProvider.launcher.appRepositories.toVector map bootRepository)
+    catch case _: NoSuchMethodError => None
 
   def bootRepositories(app: xsbti.AppConfiguration): Option[Vector[Resolver]] =
-    try {
-      Some(app.provider.scalaProvider.launcher.ivyRepositories.toVector map bootRepository)
-    } catch {
-      case _: NoSuchMethodError => None
-    }
+    try Some(app.provider.scalaProvider.launcher.ivyRepositories.toVector map bootRepository)
+    catch case _: NoSuchMethodError => None
 
   // This is a place holder in case someone doesn't want to use Coursier
-  private[sbt] def dummyCoursierDirectory(app: xsbti.AppConfiguration): File = {
+  private[sbt] def dummyCoursierDirectory(app: xsbti.AppConfiguration): File =
     val base = app.baseDirectory.getCanonicalFile
     base / "target" / "coursier-temp"
-  }
 
   private def mavenCompatible(ivyRepo: xsbti.IvyRepository): Boolean =
-    try {
-      ivyRepo.mavenCompatible
-    } catch { case _: NoSuchMethodError => false }
+    try ivyRepo.mavenCompatible
+    catch case _: NoSuchMethodError => false
 
   private def skipConsistencyCheck(ivyRepo: xsbti.IvyRepository): Boolean =
-    try {
-      ivyRepo.skipConsistencyCheck
-    } catch { case _: NoSuchMethodError => false }
+    try ivyRepo.skipConsistencyCheck
+    catch case _: NoSuchMethodError => false
 
   private def descriptorOptional(ivyRepo: xsbti.IvyRepository): Boolean =
-    try {
-      ivyRepo.descriptorOptional
-    } catch { case _: NoSuchMethodError => false }
+    try ivyRepo.descriptorOptional
+    catch case _: NoSuchMethodError => false
 
   // for forward-compatibility with launcher.jar prior to 1.3.11
   private def mavenRepoAllowInsecureProtocol(mavenRepo: xsbti.MavenRepository): Boolean =
-    try {
-      mavenRepo.allowInsecureProtocol
-    } catch { case _: NoSuchMethodError => false }
+    try mavenRepo.allowInsecureProtocol
+    catch case _: NoSuchMethodError => false
 
   // for forward-compatibility with launcher.jar prior to 1.3.11
   private def allowInsecureProtocol(ivyRepo: xsbti.IvyRepository): Boolean =
-    try {
-      ivyRepo.allowInsecureProtocol
-    } catch { case _: NoSuchMethodError => false }
+    try ivyRepo.allowInsecureProtocol
+    catch case _: NoSuchMethodError => false
 
   @nowarn
-  private def bootRepository(repo: xsbti.Repository): Resolver = {
+  private def bootRepository(repo: xsbti.Repository): Resolver =
     import xsbti.Predefined
-    repo match {
+    repo match
       case m: xsbti.MavenRepository =>
         MavenRepository(m.id, m.url.toString)
           .withAllowInsecureProtocol(mavenRepoAllowInsecureProtocol(m))
@@ -4925,7 +4812,7 @@ object Classpaths {
           descriptorOptional(i),
           skipConsistencyCheck(i)
         )
-        i.url.getProtocol match {
+        i.url.getProtocol match
           case "file" =>
             // This hackery is to deal suitably with UNC paths on Windows. Once we can assume Java7, Paths should save us from this.
             val file = IO.toFile(i.url)
@@ -4934,9 +4821,8 @@ object Classpaths {
             Resolver
               .url(i.id, i.url)(using patterns)
               .withAllowInsecureProtocol(allowInsecureProtocol(i))
-        }
       case p: xsbti.PredefinedRepository =>
-        p.id match {
+        p.id match
           case Predefined.Local                => Resolver.defaultLocal
           case Predefined.MavenLocal           => Resolver.mavenLocal
           case Predefined.MavenCentral         => Resolver.DefaultMavenRepository
@@ -4948,14 +4834,13 @@ object Classpaths {
             sys.error(
               "Unknown predefined resolver '" + unknown + "'.  This resolver may only be supported in newer sbt versions."
             )
-        }
-    }
-  }
+    end match
+  end bootRepository
 
   def shellPromptFromState: State => String = shellPromptFromState(ITerminal.console.isColorEnabled)
-  def shellPromptFromState(isColorEnabled: Boolean): State => String = { (s: State) =>
+  def shellPromptFromState(isColorEnabled: Boolean): State => String = (s: State) =>
     val extracted = Project.extract(s)
-    (extracted.currentRef / name).get(extracted.structure.data) match {
+    (extracted.currentRef / name).get(extracted.structure.data) match
       case Some(name) =>
         Def.withColor(
           "sbt",
@@ -4967,13 +4852,11 @@ object Classpaths {
           isColorEnabled
         )
       case _ => "> "
-    }
-  }
-}
+end Classpaths
 
 private[sbt] object BuildExtra extends BuildExtra
 
-trait BuildExtra extends BuildCommon with DefExtra {
+trait BuildExtra extends BuildCommon with DefExtra:
   import Defaults.*
 
   /**
@@ -4997,13 +4880,12 @@ trait BuildExtra extends BuildCommon with DefExtra {
    * Names are restricted to be either alphanumeric or completely symbolic.
    * As an exception, '-' and '_' are allowed within an alphanumeric name.
    */
-  def addCommandAlias(name: String, value: String): Seq[Setting[State => State]] = {
+  def addCommandAlias(name: String, value: String): Seq[Setting[State => State]] =
     val add = (s: State) => BasicCommands.addAlias(s, name, value)
     val remove = (s: State) => BasicCommands.removeAlias(s, name)
     def compose(setting: SettingKey[State => State], f: State => State) =
       (GlobalScope / setting) ~= (_ compose f)
     Seq(compose(onLoad, add), compose(onUnload, remove))
-  }
 
   /**
    * Adds dependency tree plugin.
@@ -5085,10 +4967,9 @@ trait BuildExtra extends BuildCommon with DefExtra {
     libraryDependencies += compilerPlugin(dependency)
 
   /** Constructs a setting that declares a new artifact `a` that is generated by `taskDef`. */
-  def addArtifact(a: Artifact, taskDef: TaskKey[HashedVirtualFileRef]): SettingsDefinition = {
+  def addArtifact(a: Artifact, taskDef: TaskKey[HashedVirtualFileRef]): SettingsDefinition =
     val pkgd = packagedArtifacts := Def.uncached(packagedArtifacts.value.updated(a, taskDef.value))
     Seq(artifacts += a, pkgd)
-  }
 
   /** Constructs a setting that declares a new artifact `artifact` that is generated by `taskDef`. */
   def addArtifact(
@@ -5129,7 +5010,7 @@ trait BuildExtra extends BuildCommon with DefExtra {
       config: Configuration,
       mainClass: String,
       baseArguments: String*
-  ): Vector[Setting[?]] = {
+  ): Vector[Setting[?]] =
     Vector(
       scoped := Def.inputTaskDyn {
         val result = Def.spaceDelimited().parsed
@@ -5146,7 +5027,6 @@ trait BuildExtra extends BuildCommon with DefExtra {
         }
       }.evaluated
     ) ++ inTask(scoped)((config / forkOptions) := Def.uncached(runForkOptionsTask.value))
-  }
 
   // public API
   /** Returns a vector of settings that create custom run task. */
@@ -5188,14 +5068,13 @@ trait BuildExtra extends BuildCommon with DefExtra {
 
   implicit def sbtStateToUpperStateOps(s: State): UpperStateOps =
     new UpperStateOps.UpperStateOpsImpl(s)
-}
+end BuildExtra
 
-trait DefExtra {
+trait DefExtra:
   private val ts: TaskSequential = new TaskSequential {}
   implicit def toTaskSequential(@deprecated("unused", "") d: Def.type): TaskSequential = ts
-}
 
-trait BuildCommon {
+trait BuildCommon:
 
   /**
    * Allows a String to be used where a `NameFilter` is expected.
@@ -5220,7 +5099,7 @@ trait BuildCommon {
 
   def overrideConfigs(cs: Configuration*)(
       configurations: Seq[Configuration]
-  ): Seq[Configuration] = {
+  ): Seq[Configuration] =
     val existingName = configurations.map(_.name).toSet
     val newByName = cs.map(c => (c.name, c)).toMap
     val overridden = configurations map { conf =>
@@ -5230,7 +5109,6 @@ trait BuildCommon {
       !existingName(c.name)
     }
     overridden ++ newConfigs
-  }
 
   // these are intended for use in in put tasks for creating parsers
   def getFromContext[T](task: TaskKey[T], context: ScopedKey[?], s: State): Option[T] =
@@ -5272,4 +5150,4 @@ trait BuildCommon {
 
   private[sbt] def derive[T](s: Setting[T]): Setting[T] =
     Def.derive(s, allowDynamic = true, trigger = _ != streams.key, default = true)
-}
+end BuildCommon
diff --git a/main/src/main/scala/sbt/EvaluateTask.scala b/main/src/main/scala/sbt/EvaluateTask.scala
index 208407585..3177de635 100644
--- a/main/src/main/scala/sbt/EvaluateTask.scala
+++ b/main/src/main/scala/sbt/EvaluateTask.scala
@@ -38,11 +38,10 @@ import xsbti.FileConverter
  *  For example, this is implemented by the TaskEngine;
  *  invoking `cancelAndShutdown()` allows you to cancel the current task execution.
  */
-trait RunningTaskEngine {
+trait RunningTaskEngine:
 
   /** Attempts to kill and shutdown the running task engine. */
   def cancelAndShutdown(): Unit
-}
 
 /**
  * A strategy for being able to cancel tasks.
@@ -52,7 +51,7 @@ trait RunningTaskEngine {
  *
  * All methods on this API are expected to be called from the same thread.
  */
-trait TaskCancellationStrategy {
+trait TaskCancellationStrategy:
 
   /** The state used by this task. */
   type State
@@ -67,20 +66,18 @@ trait TaskCancellationStrategy {
 
   /** Called when task evaluation completes, either in success or failure. */
   def onTaskEngineFinish(state: State): Unit
-}
 
-object TaskCancellationStrategy {
+object TaskCancellationStrategy:
 
   /** An empty handler that does not cancel tasks. */
-  object Null extends TaskCancellationStrategy {
+  object Null extends TaskCancellationStrategy:
     type State = Unit
     def onTaskEngineStart(canceller: RunningTaskEngine): Unit = ()
     def onTaskEngineFinish(state: Unit): Unit = ()
     override def toString: String = "Null"
-  }
 
   /** Cancel handler which registers for SIGINT and cancels tasks when it is received. */
-  object Signal extends TaskCancellationStrategy {
+  object Signal extends TaskCancellationStrategy:
     type State = Signals.Registration
 
     def onTaskEngineStart(canceller: RunningTaskEngine): Signals.Registration =
@@ -89,8 +86,6 @@ object TaskCancellationStrategy {
     def onTaskEngineFinish(registration: Signals.Registration): Unit = registration.remove()
 
     override def toString: String = "Signal"
-  }
-}
 
 /**
  * The new API for running tasks.
@@ -99,7 +94,7 @@ object TaskCancellationStrategy {
  * We expose this trait so that we can, in a binary compatible way, modify what is used
  * inside this configuration and how to construct it.
  */
-sealed trait EvaluateTaskConfig {
+sealed trait EvaluateTaskConfig:
   def restrictions: Seq[Tags.Rule]
   def checkCycles: Boolean
   def progressReporter: ExecuteProgress
@@ -110,9 +105,8 @@ sealed trait EvaluateTaskConfig {
 
   /** Interval to force GC. */
   def minForcegcInterval: Duration
-}
 
-object EvaluateTaskConfig {
+object EvaluateTaskConfig:
 
   /** Raw constructor for EvaluateTaskConfig. */
   def apply(
@@ -140,7 +134,7 @@ object EvaluateTaskConfig {
       forceGarbageCollection: Boolean,
       minForcegcInterval: Duration
   ) extends EvaluateTaskConfig
-}
+end EvaluateTaskConfig
 
 /**
  * @param internalDependencyClasspath internal classpath entries from the metabuild that are used to exclude
@@ -160,11 +154,10 @@ final case class PluginData(
     buildTarget: Option[BuildTargetIdentifier],
     converter: FileConverter,
     internalDependencyClasspath: Def.Classpath,
-) {
+):
   val classpath: Def.Classpath = definitionClasspath ++ dependencyClasspath
-}
 
-object PluginData {
+object PluginData:
   private[sbt] def apply(dependencyClasspath: Def.Classpath, converter: FileConverter): PluginData =
     PluginData(
       dependencyClasspath,
@@ -181,44 +174,39 @@ object PluginData {
       converter,
       Nil
     )
-}
 
-object EvaluateTask {
+object EvaluateTask:
   import Keys.state
   import std.Transform
 
   @nowarn
   lazy private val sharedProgress = new TaskTimings(reportOnShutdown = true)
   def taskTimingProgress: Option[ExecuteProgress] =
-    if (SysProp.taskTimingsOnShutdown) Some(sharedProgress)
+    if SysProp.taskTimingsOnShutdown then Some(sharedProgress)
     else None
 
   private val capturedThunk = new AtomicReference[() => Unit]()
-  def onShutdown(): Unit = {
+  def onShutdown(): Unit =
     val thunk = capturedThunk.getAndSet(null)
-    if (thunk != null) thunk()
-  }
+    if thunk != null then thunk()
   // our own implementation of shutdown hook, because the "sbt -timings help" command was not working with the JVM shutdown hook,
   // which is a little hard to control.
-  def addShutdownHandler[A](thunk: () => A): Unit = {
+  def addShutdownHandler[A](thunk: () => A): Unit =
     capturedThunk
       .set(() =>
-        try {
+        try
           thunk()
           ()
-        } catch {
+        catch
           case NonFatal(e) =>
             System.err.println(s"Caught exception running shutdown hook: $e")
             e.printStackTrace(System.err)
-        }
       )
-  }
 
   lazy private val sharedTraceEvent = new TaskTraceEvent()
   def taskTraceEvent: Option[ExecuteProgress] =
-    if (SysProp.traces) {
-      Some(sharedTraceEvent)
-    } else None
+    if SysProp.traces then Some(sharedTraceEvent)
+    else None
 
   val SystemProcessors = Runtime.getRuntime.availableProcessors
 
@@ -226,23 +214,21 @@ object EvaluateTask {
       extracted: Extracted,
       structure: BuildStructure,
       state: State
-  ): EvaluateTaskConfig = {
+  ): EvaluateTaskConfig =
     val rs = restrictions(extracted, structure)
     val canceller = cancelStrategy(extracted, structure, state)
     val progress = executeProgress(extracted, structure, state)
     val fgc = forcegc(extracted, structure)
     val mfi = minForcegcInterval(extracted, structure)
     EvaluateTaskConfig(rs, false, progress, canceller, fgc, mfi)
-  }
 
   def defaultRestrictions(maxWorkers: Int) = Tags.limitAll(maxWorkers) :: Nil
   def defaultRestrictions(extracted: Extracted, structure: BuildStructure): Seq[Tags.Rule] =
     Tags.limitAll(maxWorkers(extracted, structure)) :: Nil
 
-  def restrictions(state: State): Seq[Tags.Rule] = {
+  def restrictions(state: State): Seq[Tags.Rule] =
     val extracted = Project.extract(state)
     restrictions(extracted, extracted.structure)
-  }
 
   def restrictions(extracted: Extracted, structure: BuildStructure): Seq[Tags.Rule] =
     getSetting(
@@ -253,10 +239,8 @@ object EvaluateTask {
     )
 
   def maxWorkers(extracted: Extracted, structure: BuildStructure): Int =
-    if (getSetting(Keys.parallelExecution, true, extracted, structure))
-      SystemProcessors
-    else
-      1
+    if getSetting(Keys.parallelExecution, true, extracted, structure) then SystemProcessors
+    else 1
 
   def cancelable(extracted: Extracted, structure: BuildStructure): Boolean =
     getSetting(Keys.cancelable, false, extracted, structure)
@@ -279,11 +263,11 @@ object EvaluateTask {
       extracted: Extracted,
       structure: BuildStructure,
       state: State
-  ): ExecuteProgress2 = {
+  ): ExecuteProgress2 =
     state
       .get(currentCommandProgress)
       .map { progress =>
-        new ExecuteProgress2 {
+        new ExecuteProgress2:
           override def beforeCommand(cmd: String, state: State): Unit =
             progress.beforeCommand(cmd, state)
           override def afterCommand(cmd: String, result: Either[Throwable, State]): Unit =
@@ -306,7 +290,6 @@ object EvaluateTask {
           override def stop(): Unit = {
             // TODO: this is not a typo, but a questionable decision in 6559c3a0 that is probably obsolete
           }
-        }
       }
       .getOrElse {
         val maker: Seq[Keys.TaskProgress] = getSetting(
@@ -316,17 +299,15 @@ object EvaluateTask {
           structure
         )
         val reporters = maker.map(_.progress) ++ state.get(Keys.taskProgress) ++
-          (if (SysProp.taskTimings)
+          (if SysProp.taskTimings then
              new TaskTimings(reportOnShutdown = false, state.globalLogging.full) :: Nil
            else Nil)
         val cmdProgress = getSetting(Keys.commandProgress, Seq(), extracted, structure)
-        ExecuteProgress2.aggregate(reporters match {
+        ExecuteProgress2.aggregate(reporters match
           case xs if xs.isEmpty   => cmdProgress
           case xs if xs.size == 1 => cmdProgress :+ new ExecuteProgressAdapter(xs.head)
-          case xs => cmdProgress :+ new ExecuteProgressAdapter(ExecuteProgress.aggregate(xs))
-        })
+          case xs => cmdProgress :+ new ExecuteProgressAdapter(ExecuteProgress.aggregate(xs)))
       }
-  }
   // TODO - Should this pull from Global or from the project itself?
   private[sbt] def forcegc(extracted: Extracted, structure: BuildStructure): Boolean =
     getSetting((Global / Keys.forcegc), GCUtil.defaultForceGarbageCollection, extracted, structure)
@@ -353,7 +334,7 @@ object EvaluateTask {
     Global / executionRoots ::= dummyRoots,
   )
 
-  def evalPluginDef(pluginDef: BuildStructure, state: State): PluginData = {
+  def evalPluginDef(pluginDef: BuildStructure, state: State): PluginData =
     val root = ProjectRef(pluginDef.root, Load.getRootProject(pluginDef.units)(pluginDef.root))
     val config = extractedTaskConfig(Project.extract(state), pluginDef, state)
     val evaluated =
@@ -363,7 +344,6 @@ object EvaluateTask {
     )
     Project.runUnloadHooks(newS) // discard states
     processResult2(result)
-  }
 
   /**
    * Evaluates `taskKey` and returns the new State and the result of the task wrapped in Some.
@@ -395,18 +375,17 @@ object EvaluateTask {
       state: State,
       ref: ProjectRef,
       config: EvaluateTaskConfig
-  ): Option[(State, Result[T])] = {
+  ): Option[(State, Result[T])] =
     withStreams(structure, state) { str =>
-      for ((task, toNode) <- getTask(structure, taskKey, state, str, ref))
-        yield runTask(task, state, str, structure.index.triggers, config)(using toNode)
+      for (task, toNode) <- getTask(structure, taskKey, state, str, ref)
+      yield runTask(task, state, str, structure.index.triggers, config)(using toNode)
     }
-  }
 
-  def logIncResult(result: Result[?], state: State, streams: Streams) = result match {
-    case Result.Inc(i) => logIncomplete(i, state, streams); case _ => ()
-  }
+  def logIncResult(result: Result[?], state: State, streams: Streams) = result match
+    case Result.Inc(i) => logIncomplete(i, state, streams);
+    case _             => ()
 
-  def logIncomplete(result: Incomplete, state: State, streams: Streams): Unit = {
+  def logIncomplete(result: Incomplete, state: State, streams: Streams): Unit =
     val all = Incomplete.linearize(result)
     val keyed =
       all collect { case Incomplete(Some(key: ScopedKey[?]), _, msg, _, ex) =>
@@ -417,24 +396,22 @@ object EvaluateTask {
     for case (key, msg, Some(ex)) <- keyed
     do
       def log = getStreams(key, streams).log
-      ExceptionCategory(ex) match {
+      ExceptionCategory(ex) match
         case AlreadyHandled => ()
-        case m: MessageOnly => if (msg.isEmpty) log.error(m.message)
+        case m: MessageOnly => if msg.isEmpty then log.error(m.message)
         case f: Full        => log.trace(f.exception)
-      }
 
-    for ((key, msg, ex) <- keyed if msg.isDefined || ex.isDefined) {
+    for (key, msg, ex) <- keyed if msg.isDefined || ex.isDefined do
       val msgString = (msg.toList ++ ex.toList.map(ErrorHandling.reducedToString)).mkString("\n\t")
       val log = getStreams(key, streams).log
       val display = contextDisplay(state, ITerminal.isColorEnabled)
       val errorMessage = "(" + display.show(key) + ") " + msgString
       state.respondError(ErrorCodes.InternalError, errorMessage)
       log.error(errorMessage)
-    }
-  }
+  end logIncomplete
 
   private def contextDisplay(state: State, highlight: Boolean) =
-    Project.showContextKey(state, if (highlight) Some(RED) else None)
+    Project.showContextKey(state, if highlight then Some(RED) else None)
 
   def suppressedMessage(key: ScopedKey[?])(using display: Show[ScopedKey[?]]): String =
     s"Stack trace suppressed.  Run 'last ${display.show(key)}' for the full log."
@@ -442,14 +419,12 @@ object EvaluateTask {
   def getStreams(key: ScopedKey[?], streams: Streams): TaskStreams =
     streams(ScopedKey(Project.fillTaskAxis(key).scope, Keys.streams.key))
 
-  def withStreams[T](structure: BuildStructure, state: State)(f: Streams => T): T = {
+  def withStreams[T](structure: BuildStructure, state: State)(f: Streams => T): T =
     val str = std.Streams.closeable(structure.streams(state))
-    try {
+    try
       f(str)
-    } finally {
+    finally
       str.close()
-    }
-  }
 
   def getTask[T](
       structure: BuildStructure,
@@ -457,12 +432,11 @@ object EvaluateTask {
       state: State,
       streams: Streams,
       ref: ProjectRef
-  ): Option[(Task[T], NodeView)] = {
+  ): Option[(Task[T], NodeView)] =
     val thisScope = Load.projectScope(ref)
     val subScoped = Project.replaceThis(thisScope)(taskKey.scopedKey)
-    for (t <- structure.data.get(subScoped))
-      yield (t, nodeView(state, streams, taskKey :: Nil))
-  }
+    for t <- structure.data.get(subScoped)
+    yield (t, nodeView(state, streams, taskKey :: Nil))
   def nodeView(
       state: State,
       streams: Streams,
@@ -486,7 +460,7 @@ object EvaluateTask {
       streams: Streams,
       triggers: Triggers,
       config: EvaluateTaskConfig
-  )(using taskToNode: NodeView): (State, Result[T]) = {
+  )(using taskToNode: NodeView): (State, Result[T]) =
     import ConcurrentRestrictions.{ cancellableCompletionService, tagged }
 
     val log = state.log
@@ -501,22 +475,19 @@ object EvaluateTask {
         (t: TaskId[?]) => t.tags.contains(Tags.Sentinel)
       )
 
-    def shutdownImpl(force: Boolean): Unit = {
+    def shutdownImpl(force: Boolean): Unit =
       // First ensure that all threads are stopped for task execution.
       shutdownThreads(force)
       config.progressReporter.stop()
 
       // Now we run the gc cleanup to force finalizers to clear out file handles (yay GC!)
-      if (config.forceGarbageCollection) {
+      if config.forceGarbageCollection then
         GCUtil.forceGcWithInterval(config.minForcegcInterval, log)
-      }
-    }
     def shutdown(): Unit = shutdownImpl(false)
     // propagate the defining key for reporting the origin
-    def overwriteNode(i: Incomplete): Boolean = i.node match {
+    def overwriteNode(i: Incomplete): Boolean = i.node match
       case Some(t: Task[?]) => transformNode(t).isEmpty
       case _                => true
-    }
     def suspendChannel[A1](
         state: State,
         result: Result[A1]
@@ -527,63 +498,57 @@ object EvaluateTask {
             case Nil => service.waitForTry(handle).get
             case _   => service.pauseChannelDuringJob(state, handle)
         case _ => ()
-    def run() = {
+    def run() =
       val x = new Execute(
         Execute.config(config.checkCycles, overwriteNode),
         triggers,
         config.progressReporter
       )
       val (newState, result) =
-        try {
+        try
           given strategy: CompletionService = service
           val results = x.runKeep(root)
           storeValuesForPrevious(results, state, streams)
           applyResults(results, state, root)
-        } catch {
-          case inc: Incomplete => (state, Result.Inc(inc))
-        } finally shutdown()
+        catch case inc: Incomplete => (state, Result.Inc(inc))
+        finally shutdown()
       val replaced = transformInc(result)
       logIncResult(replaced, state, streams)
       suspendChannel(newState, replaced)
       (newState, replaced)
-    }
-    object runningEngine extends RunningTaskEngine {
-      def cancelAndShutdown(): Unit = {
+    object runningEngine extends RunningTaskEngine:
+      def cancelAndShutdown(): Unit =
         println("")
         log.warn("Canceling execution...")
         RunningProcesses.killAll()
         ConcurrentRestrictions.cancelAll()
         DefaultBackgroundJobService.stop()
         shutdownImpl(true)
-      }
-    }
     currentlyRunningTaskEngine.set(runningEngine)
     // Register with our cancel handler we're about to start.
     val strat = config.cancelStrategy
     val cancelState = strat.onTaskEngineStart(runningEngine)
     config.progressReporter.initial()
     try run()
-    finally {
+    finally
       strat.onTaskEngineFinish(cancelState)
       currentlyRunningTaskEngine.set(null)
-    }
-  }
+  end runTask
 
   private def storeValuesForPrevious(
       results: RMap[TaskId, Result],
       state: State,
       streams: Streams
   ): Unit =
-    for (referenced <- (Global / Previous.references).get(Project.structure(state).data))
+    for referenced <- (Global / Previous.references).get(Project.structure(state).data) do
       Previous.complete(referenced, results, streams)
 
   def applyResults[T](
       results: RMap[TaskId, Result],
       state: State,
       root: Task[T]
-  ): (State, Result[T]) = {
+  ): (State, Result[T]) =
     (stateTransform(results)(state), results(root))
-  }
   def stateTransform(results: RMap[TaskId, Result]): State => State =
     Function.chain(
       results.toTypedSeq flatMap {
@@ -616,38 +581,35 @@ object EvaluateTask {
   }
 
   def convertCyclic(c: Execute#CyclicException): String =
-    (c.caller, c.target) match {
+    (c.caller, c.target) match
       case (caller: Task[?], target: Task[?]) =>
-        c.toString + (if (caller eq target) "(task: " + name(caller) + ")"
+        c.toString + (if caller eq target then "(task: " + name(caller) + ")"
                       else "(caller: " + name(caller) + ", target: " + name(target) + ")")
       case _ => c.toString
-    }
 
   def liftAnonymous: Incomplete => Incomplete = {
     case i @ Incomplete(_, _, None, causes, None) =>
       causes.find(inc =>
         inc.node.isEmpty && (inc.message.isDefined || inc.directCause.isDefined)
-      ) match {
+      ) match
         case Some(lift) => i.copy(directCause = lift.directCause, message = lift.message)
         case None       => i
-      }
     case i => i
   }
 
   def processResult2[T](result: Result[T], show: Boolean = false): T =
     onResult(result) { v =>
-      if (show) println("Result: " + v); v
+      if show then println("Result: " + v); v
     }
 
   def onResult[T, S](result: Result[T])(f: T => S): S =
-    result match {
+    result match
       case Result.Value(v) => f(v)
       case Result.Inc(inc) => throw inc
-    }
 
   // if the return type Seq[Setting[_]] is not explicitly given, scalac hangs
   val injectStreams: ScopedKey[?] => Seq[Setting[?]] = scoped =>
-    if (scoped.key == streams.key) {
+    if scoped.key == streams.key then
       Seq(scoped.scope / streams := Def.uncached {
         (streamsManager.map { mgr =>
           val stream = mgr(scoped)
@@ -655,7 +617,5 @@ object EvaluateTask {
           stream
         }).value
       })
-    } else {
-      Nil
-    }
-}
+    else Nil
+end EvaluateTask
diff --git a/main/src/main/scala/sbt/ExecuteProgress2.scala b/main/src/main/scala/sbt/ExecuteProgress2.scala
index fdd167e20..e25e6a418 100644
--- a/main/src/main/scala/sbt/ExecuteProgress2.scala
+++ b/main/src/main/scala/sbt/ExecuteProgress2.scala
@@ -19,7 +19,7 @@ import sbt.internal.util.RMap
  * callback will be called before the `initial` callback from ExecuteProgress, and the
  * `afterCommand` callback will be called after the `stop` callback from ExecuteProgress.
  */
-trait ExecuteProgress2 extends ExecuteProgress {
+trait ExecuteProgress2 extends ExecuteProgress:
 
   /**
    * Called before a command starts processing. The command has not yet been parsed.
@@ -39,9 +39,8 @@ trait ExecuteProgress2 extends ExecuteProgress {
    *               Right with the new state after command execution.
    */
   def afterCommand(cmd: String, result: Either[Throwable, State]): Unit
-}
 
-class ExecuteProgressAdapter(ep: ExecuteProgress) extends ExecuteProgress2 {
+class ExecuteProgressAdapter(ep: ExecuteProgress) extends ExecuteProgress2:
   override def beforeCommand(cmd: String, state: State): Unit = {}
   override def afterCommand(cmd: String, result: Either[Throwable, State]): Unit = {}
   override def initial(): Unit = ep.initial()
@@ -59,10 +58,9 @@ class ExecuteProgressAdapter(ep: ExecuteProgress) extends ExecuteProgress2 {
   override def afterAllCompleted(results: RMap[TaskId, Result]): Unit =
     ep.afterAllCompleted(results)
   override def stop(): Unit = ep.stop()
-}
 
-object ExecuteProgress2 {
-  def aggregate(xs: Seq[ExecuteProgress2]): ExecuteProgress2 = new ExecuteProgress2 {
+object ExecuteProgress2:
+  def aggregate(xs: Seq[ExecuteProgress2]): ExecuteProgress2 = new ExecuteProgress2:
     override def beforeCommand(cmd: String, state: State): Unit =
       xs.foreach(_.beforeCommand(cmd, state))
     override def afterCommand(cmd: String, result: Either[Throwable, State]): Unit =
@@ -82,5 +80,4 @@ object ExecuteProgress2 {
     override def afterAllCompleted(results: RMap[TaskId, Result]): Unit =
       xs.foreach(_.afterAllCompleted(results))
     override def stop(): Unit = xs.foreach(_.stop())
-  }
-}
+end ExecuteProgress2
diff --git a/main/src/main/scala/sbt/Extracted.scala b/main/src/main/scala/sbt/Extracted.scala
index ad866a628..778e9fb6c 100644
--- a/main/src/main/scala/sbt/Extracted.scala
+++ b/main/src/main/scala/sbt/Extracted.scala
@@ -21,7 +21,7 @@ final case class Extracted(
     structure: BuildStructure,
     session: SessionSettings,
     currentRef: ProjectRef
-)(using val showKey: Show[ScopedKey[?]]) {
+)(using val showKey: Show[ScopedKey[?]]):
   def rootProject = structure.rootProject
   lazy val currentUnit = structure units currentRef.build
   lazy val currentProject = currentUnit defined currentRef.project
@@ -56,14 +56,13 @@ final case class Extracted(
    * This method requests execution of only the given task and does not aggregate execution.
    * See `runAggregated` for that.
    */
-  def runTask[T](key: TaskKey[T], state: State): (State, T) = {
+  def runTask[T](key: TaskKey[T], state: State): (State, T) =
     val rkey = resolve(key)
     val config = extractedTaskConfig(this, structure, state)
     val value: Option[(State, Result[T])] =
       EvaluateTask(structure, key.scopedKey, state, currentRef, config)
     val (newS, result) = getOrError(rkey.scopedKey, value)
     (newS, EvaluateTask.processResult2(result))
-  }
 
   /**
    * Runs the task specified by `key` and returns the unhandled direct result of EvaluateTask.
@@ -83,17 +82,16 @@ final case class Extracted(
    *
    * This method requests execution of only the given task and does not aggregate execution.
    */
-  def runInputTask[T](key: InputKey[T], input: String, state: State): (State, T) = {
+  def runInputTask[T](key: InputKey[T], input: String, state: State): (State, T) =
     val key2 = Scoped.scopedSetting(
       Scope.resolveScope(Load.projectScope(currentRef), currentRef.build, rootProject)(key.scope),
       key.key
     )
     val rkey = resolve(key2)
     val inputTask = get(rkey)
-    val task = Parser.parse(input, inputTask.parser(state)) match {
+    val task = Parser.parse(input, inputTask.parser(state)) match
       case Right(t)  => t
       case Left(msg) => sys.error(s"Invalid programmatic input:\n$msg")
-    }
     val config = extractedTaskConfig(this, structure, state)
     EvaluateTask.withStreams(structure, state) { str =>
       val nv = EvaluateTask.nodeView(state, str, rkey.scopedKey :: Nil)
@@ -101,7 +99,6 @@ final case class Extracted(
         EvaluateTask.runTask(task, state, str, structure.index.triggers, config)(using nv)
       (newS, EvaluateTask.processResult2(result))
     }
-  }
 
   /**
    * Runs the tasks selected by aggregating `key` and returns the transformed State.
@@ -156,10 +153,9 @@ final case class Extracted(
       settings: Seq[Setting[?]],
       state: State,
       sessionSettings: Seq[Setting[?]],
-  ): State = {
+  ): State =
     val appendSettings =
       Load.transformSettings(Load.projectScope(currentRef), currentRef.build, rootProject, settings)
     val newStructure = Load.reapply(sessionSettings ++ appendSettings, structure)
     Project.setProject(session, newStructure, state)
-  }
-}
+end Extracted
diff --git a/main/src/main/scala/sbt/InteractionService.scala b/main/src/main/scala/sbt/InteractionService.scala
index 61edd7a34..6d601c8d2 100644
--- a/main/src/main/scala/sbt/InteractionService.scala
+++ b/main/src/main/scala/sbt/InteractionService.scala
@@ -13,7 +13,7 @@ package sbt
  * In the future this could be used to ask for inputs from
  * other forms of sbt clients such as thin clients and IDEs.
  */
-abstract class InteractionService {
+abstract class InteractionService:
 
   /** Prompts the user for input, optionally with a mask for characters. */
   def readLine(prompt: String, mask: Boolean): Option[String]
@@ -26,4 +26,3 @@ abstract class InteractionService {
   def terminalHeight: Int
 
   // TODO - Ask for input with autocomplete?
-}
diff --git a/main/src/main/scala/sbt/Main.scala b/main/src/main/scala/sbt/Main.scala
index fb2017339..ecb78299e 100644
--- a/main/src/main/scala/sbt/Main.scala
+++ b/main/src/main/scala/sbt/Main.scala
@@ -53,15 +53,14 @@ private[sbt] object xMain:
     val dealiasedBase = config.baseDirectory.getCanonicalFile
     if config.baseDirectory == dealiasedBase then config
     else
-      new xsbti.AppConfiguration {
+      new xsbti.AppConfiguration:
         override def arguments: Array[String] = config.arguments()
         override val baseDirectory: File = dealiasedBase
         override def provider: AppProvider = config.provider()
-      }
 
   private[sbt] def run(configuration: xsbti.AppConfiguration): xsbti.MainResult = boundary {
-    try {
-      if (!sys.props.contains("jna.nosys")) sys.props.put("jna.nosys", "true")
+    try
+      if !sys.props.contains("jna.nosys") then sys.props.put("jna.nosys", "true")
       import BasicCommandStrings.{ JavaClient, DashDashClient, DashDashServer, runEarly }
       import BasicCommands.early
       import BuiltinCommands.defaults
@@ -81,36 +80,33 @@ private[sbt] object xMain:
       // keep this lazy to prevent project directory created prematurely
       // Only create boot server socket if server mode is enabled and server autostart is enabled
       lazy val bootServerSocket =
-        if (isServer && SysProp.serverAutoStart) getSocketOrExit(configuration) match {
-          case (_, Some(e)) => boundary.break(e)
-          case (s, _)       => s
-        }
+        if isServer && SysProp.serverAutoStart then
+          getSocketOrExit(configuration) match
+            case (_, Some(e)) => boundary.break(e)
+            case (s, _)       => s
         else None
       lazy val detachStdio = userCommands.exists(_ == BasicCommandStrings.DashDashDetachStdio)
       def withStreams[A](f: => A): A =
-        try {
+        try
           bootServerSocket.foreach(l => ITerminal.setBootStreams(l.inputStream, l.outputStream))
           ITerminal.withStreams(true, isSubProcess = detachStdio) {
             f
           }
-        } finally {
-          if (ITerminal.isAnsiSupported) {
+        finally
+          if ITerminal.isAnsiSupported then
             // Clear any stray progress lines
             System.out.print(ConsoleAppender.ClearScreenAfterCursor)
             System.out.flush()
-          }
-        }
 
-      userCommands match {
+      userCommands match
         case cmds if cmds.exists(isBsp) =>
           BspClient.run(dealiasBaseDirectory(configuration))
         case cmds if cmds.exists(isNew) =>
           IO.withTemporaryDirectory { tempDir =>
-            val rebasedConfig = new xsbti.AppConfiguration {
+            val rebasedConfig = new xsbti.AppConfiguration:
               override def arguments: Array[String] = configuration.arguments()
               override val baseDirectory: File = tempDir / "new"
               override def provider: AppProvider = configuration.provider()
-            }
             val state = StandardMain
               .initialState(
                 rebasedConfig,
@@ -136,22 +132,19 @@ private[sbt] object xMain:
                 runEarly(DefaultsCommand) :: runEarly(InitCommand) :: BootCommand :: Nil
               )
               .put(BasicKeys.detachStdio, detachStdio)
-            val state = bootServerSocket match {
+            val state = bootServerSocket match
               case Some(l) => state0.put(Keys.bootServerSocket, l)
               case _       => state0
-            }
             try StandardMain.runManaged(state)
             finally bootServerSocket.foreach(_.close())
           }
-      }
-    } finally {
-      ShutdownHooks.close()
-    }
+      end match
+    finally ShutdownHooks.close()
   }
 
   private def getSocketOrExit(
       configuration: xsbti.AppConfiguration
-  ): (Option[BootServerSocket], Option[Exit]) = {
+  ): (Option[BootServerSocket], Option[Exit]) =
     val base = configuration.baseDirectory().toPath().toRealPath()
     val target = base.resolve("project").resolve("target")
     val hash = HashUtil.farmHash(target.toString().getBytes("UTF-8"))
@@ -163,7 +156,7 @@ private[sbt] object xMain:
         SysProp.serverUseJni,
       )
     try Some(new BootServerSocket(configuration, hash)) -> None
-    catch {
+    catch
       // No live server and nothing the user can do about a socket failure, so proceed
       // silently without the boot socket, as for UnsatisfiedLinkError below.
       case _: ServerAlreadyBootingException if !liveServerDetected => (None, None)
@@ -171,31 +164,29 @@ private[sbt] object xMain:
         println("another sbt appears to be booting in this build.")
         println("Create a new server? y/n (default y)")
         val exit =
-          if (ITerminal.get.withRawInput(System.in.read) == 'n'.toInt) Some(Exit(1))
+          if ITerminal.get.withRawInput(System.in.read) == 'n'.toInt then Some(Exit(1))
           else None
         (None, exit)
       case _: ServerAlreadyBootingException =>
-        if (SysProp.forceServerStart) (None, None)
-        else {
+        if SysProp.forceServerStart then (None, None)
+        else
           println("another sbt appears to be booting in this build; exiting.")
           println(
             "wait for it to finish, attach to it with --client, or pass -Dsbt.server.forcestart=true to start anyway."
           )
           (None, Some(Exit(2)))
-        }
       case _: IOException                   => (None, None)
       case _: UnsatisfiedLinkError          => (None, None)
       case _: UnsupportedOperationException => (None, None)
-    }
-  }
+    end try
+  end getSocketOrExit
 end xMain
 
-final class ScriptMain extends xsbti.AppMain {
+final class ScriptMain extends xsbti.AppMain:
   def run(configuration: xsbti.AppConfiguration): xsbti.MainResult =
     new XMainConfiguration().run("ScriptMain", configuration)
-}
-private[sbt] object ScriptMain {
-  private[sbt] def run(configuration: xsbti.AppConfiguration): xsbti.MainResult = {
+private[sbt] object ScriptMain:
+  private[sbt] def run(configuration: xsbti.AppConfiguration): xsbti.MainResult =
     import BasicCommandStrings.runEarly
     Plugins.defaultRequires = sbt.plugins.JvmPlugin
     val state = StandardMain.initialState(
@@ -204,25 +195,20 @@ private[sbt] object ScriptMain {
       runEarly(Level.Error.toString) :: Script.Name :: Nil
     )
     StandardMain.runManaged(state)
-  }
-}
 
-final class ConsoleMain extends xsbti.AppMain {
+final class ConsoleMain extends xsbti.AppMain:
   def run(configuration: xsbti.AppConfiguration): xsbti.MainResult =
     new XMainConfiguration().run("ConsoleMain", configuration)
-}
-private[sbt] object ConsoleMain {
-  private[sbt] def run(configuration: xsbti.AppConfiguration): xsbti.MainResult = {
+private[sbt] object ConsoleMain:
+  private[sbt] def run(configuration: xsbti.AppConfiguration): xsbti.MainResult =
     val state = StandardMain.initialState(
       xMain.dealiasBaseDirectory(configuration),
       BuiltinCommands.ConsoleCommands,
       IvyConsole.Name :: Nil
     )
     StandardMain.runManaged(state)
-  }
-}
 
-object StandardMain {
+object StandardMain:
   private[sbt] lazy val exchange = new CommandExchange()
   // The access to the pool should be thread safe because lazy val instantiation is thread safe
   // and pool is only referenced directly in closeRunnable after the executionContext is sure
@@ -234,26 +220,23 @@ object StandardMain {
     p
   })
 
-  private val closeRunnable = () => {
+  private val closeRunnable = () =>
     RunningProcesses.killAll()
     exchange.shutdown()
     pool.foreach(_.shutdownNow())
-  }
 
   private val isShutdown = new AtomicBoolean(false)
-  def runManaged(s: State): xsbti.MainResult = {
+  def runManaged(s: State): xsbti.MainResult =
     val hook = ShutdownHooks.add(closeRunnable)
-    try {
-      MainLoop.runLogged(s)
-    } catch {
+    try MainLoop.runLogged(s)
+    catch
       case _: InterruptedException if isShutdown.get =>
-        new xsbti.Exit { override def code(): Int = 0 }
-    } finally {
+        new xsbti.Exit:
+          override def code(): Int = 0
+    finally
       try DefaultBackgroundJobService.shutdown()
       finally hook.close()
       ()
-    }
-  }
 
   /** The common interface to standard output, used for all built-in ConsoleLoggers. */
   val console: ConsoleOut =
@@ -275,7 +258,7 @@ object StandardMain {
 
   private def initialGlobalLogging(file: Option[File], initialLevel: Level.Value): GlobalLogging =
     def createTemp(prefix: String)(attempt: Int = 0): File = Retry:
-      file.foreach(f => if (!f.exists()) IO.createDirectory(f))
+      file.foreach(f => if !f.exists() then IO.createDirectory(f))
       File.createTempFile(prefix, ".log", file.orNull)
 
     // Call this experimental since we don't want to commit to the log format for now
@@ -300,6 +283,7 @@ object StandardMain {
       .sortBy(f => (f.lastModified, f.getName))
       .lastOption
     logging.copy(backing = logging.backing.copy(last = previousLog))
+  end initialGlobalLogging
 
   private def initialGlobalLogging(file: Option[File]): GlobalLogging =
     initialGlobalLogging(file, Level.Info)
@@ -313,7 +297,7 @@ object StandardMain {
       initialDefinitions: Seq[Command],
       preCommands: Seq[String]
   ): State =
-    if (!sys.props.contains("jna.nosys")) sys.props.put("jna.nosys", "true")
+    if !sys.props.contains("jna.nosys") then sys.props.put("jna.nosys", "true")
 
     import BasicCommandStrings.{ DashDashDetachStdio, DashDashServer, isEarlyCommand }
     val userCommands =
@@ -346,7 +330,7 @@ object StandardMain {
     )
     s.initializeClassLoaderCache
   end initialState
-}
+end StandardMain
 
 import sbt.BasicCommandStrings.*
 import sbt.BasicCommands.*
@@ -355,7 +339,7 @@ import sbt.TemplateCommandUtil.{ templateCommandAlias, templateCommand }
 import sbt.internal.CommandStrings.*
 import sbt.internal.util.complete.DefaultParsers.*
 
-object BuiltinCommands {
+object BuiltinCommands:
   def initialAttributes = AttributeMap.empty
   import BasicCommands.exit
 
@@ -444,25 +428,26 @@ object BuiltinCommands {
     oneOf(Level.values.toSeq.map(v => v.toString ^^^ v))
 
   // This parser schedules the default boot commands unless overridden by an alias
-  def bootParser(s: State) = {
+  def bootParser(s: State) =
     val orElse = () => DefaultBootCommands.toList ::: s
     delegateToAlias(BootCommand, success(orElse))(s)
-  }
 
   def sbtName(s: State): String = s.configuration.provider.id.name
   def sbtVersion(s: State): String = s.configuration.provider.id.version
   def scalaVersion(s: State): String = s.configuration.provider.scalaProvider.version
   def aboutProject(s: State): String =
-    if (Project.isProjectLoaded(s)) {
+    if Project.isProjectLoaded(s) then
       val e = Project.extract(s)
-      val version = e.getOpt(Keys.version) match { case None => ""; case Some(v) => " " + v }
+      val version = e.getOpt(Keys.version) match
+        case None    => "";
+        case Some(v) => " " + v
       val current = "The current project is " + Reference.display(e.currentRef) + version + "\n"
       val sc = aboutScala(s, e)
-      val built = if (sc.isEmpty) "" else "The current project is built against " + sc + "\n"
+      val built = if sc.isEmpty then "" else "The current project is built against " + sc + "\n"
       current + built + aboutPlugins(e)
-    } else "No project is currently loaded"
+    else "No project is currently loaded"
 
-  def aboutPlugins(e: Extracted): String = {
+  def aboutPlugins(e: Extracted): String =
     def plugins(lbu: LoadedBuildUnit) =
       lbu.unit.plugins.detected.autoPlugins
         .map(_.value.label)
@@ -474,42 +459,36 @@ object BuiltinCommands {
         .distinct
         .sorted
 
-    if (allPluginNames.isEmpty)
-      ""
+    if allPluginNames.isEmpty then ""
     else
       ("Available Plugins" +: allPluginNames)
         .mkString("\n - ")
-  }
 
-  def aboutScala(s: State, e: Extracted): String = {
+  def aboutScala(s: State, e: Extracted): String =
     val scalaVersion = e.getOpt(Keys.scalaVersion)
     val scalaHome = e.getOpt(Keys.scalaHome).flatMap(idFun)
     val instance =
       e.getOpt(Keys.scalaInstance).flatMap(_ => quiet(e.runTask(Keys.scalaInstance, s)._2))
-    (scalaVersion, scalaHome, instance) match {
+    (scalaVersion, scalaHome, instance) match
       case (sv, Some(home), Some(si)) =>
         "local Scala version " + selectScalaVersion(sv, si) + " at " + home.getAbsolutePath
       case (_, Some(home), None)  => "a local Scala build at " + home.getAbsolutePath
       case (sv, None, Some(si))   => "Scala " + selectScalaVersion(sv, si)
       case (Some(sv), None, None) => "Scala " + sv
       case (None, None, None)     => ""
-    }
-  }
 
-  def aboutString(s: State): String = {
+  def aboutString(s: State): String =
     val (name, ver, scalaVer, about) =
       (sbtName(s), sbtVersion(s), scalaVersion(s), aboutProject(s))
     """This is %s %s
 			|%s
 			|%s, %s plugins, and build definitions are using Scala %s
 			|""".stripMargin.format(name, ver, about, name, name, scalaVer)
-  }
 
   private def selectScalaVersion(sv: Option[String], si: ScalaInstance): String =
-    sv match {
+    sv match
       case Some(si.version) => si.version
       case _                => si.actualVersion
-    }
 
   private def quiet[T](t: => T): Option[T] =
     try Some(t)
@@ -539,12 +518,12 @@ object BuiltinCommands {
   ): Command =
     Command(command, settingsBrief(command), settingsDetailed(command))(showSettingParser(keep)) {
       case (s: State, (verbosity: Int, selected: Option[String])) =>
-        if (selected.isEmpty) System.out.println(preamble)
+        if selected.isEmpty then System.out.println(preamble)
         val prominentOnly = verbosity <= 1
-        val verboseFilter = if (prominentOnly) highPass(cutoff) else topNRanked(25 * verbosity)
+        val verboseFilter = if prominentOnly then highPass(cutoff) else topNRanked(25 * verbosity)
         System.out.println(tasksHelp(s, keys => verboseFilter(keys filter keep), selected))
         System.out.println()
-        if (prominentOnly) System.out.println(moreAvailableMessage(command, selected.isDefined))
+        if prominentOnly then System.out.println(moreAvailableMessage(command, selected.isDefined))
         s
     }
   def showSettingParser(
@@ -567,7 +546,7 @@ object BuiltinCommands {
   def taskDetail(keys: Seq[AttributeKey[?]]): Seq[(String, String)] =
     taskDetail(keys, false)
 
-  def allTaskAndSettingKeys(s: State): Seq[AttributeKey[?]] = {
+  def allTaskAndSettingKeys(s: State): Seq[AttributeKey[?]] =
     val extracted = Project.extract(s)
     import extracted.*
     val index = structure.index
@@ -576,15 +555,13 @@ object BuiltinCommands {
       .toSeq
       .map { key =>
         try Some(index.keyMap(key))
-        catch {
+        catch
           case NonFatal(ex) =>
             s.log.debug(ex.getMessage)
             None
-        }
       }
       .collect { case Some(s) => s }
       .distinct
-  }
 
   def sortByLabel(keys: Seq[AttributeKey[?]]): Seq[AttributeKey[?]] = keys.sortBy(_.label)
   def sortByRank(keys: Seq[AttributeKey[?]]): Seq[AttributeKey[?]] = keys.sortBy(_.rank)
@@ -600,17 +577,15 @@ object BuiltinCommands {
       s: State,
       filter: Seq[AttributeKey[?]] => Seq[AttributeKey[?]],
       arg: Option[String]
-  ): String = {
+  ): String =
     val commandAndDescription = taskDetail(filter(allTaskAndSettingKeys(s)), true)
-    arg match {
+    arg match
       case Some(selected) => detail(selected, commandAndDescription.toMap)
       case None           => aligned("  ", "   ", commandAndDescription) mkString ("\n", "\n", "")
-    }
-  }
 
   def taskStrings(key: AttributeKey[?], firstOnly: Boolean): Option[(String, String)] =
     key.description map { d =>
-      if (firstOnly) (key.label, d.split("\r?\n")(0)) else (key.label, d)
+      if firstOnly then (key.label, d.split("\r?\n")(0)) else (key.label, d)
     }
 
   def taskStrings(key: AttributeKey[?]): Option[(String, String)] = taskStrings(key, false)
@@ -626,33 +601,31 @@ object BuiltinCommands {
 
   def eval: Command = Command.single(EvalCommand, Help.more(EvalCommand, evalDetailed)) {
     (s, arg) =>
-      if (Project.isProjectLoaded(s)) loadedEval(s, arg) else rawEval(s, arg)
+      if Project.isProjectLoaded(s) then loadedEval(s, arg) else rawEval(s, arg)
       s
   }
 
   def continuous: Command = Continuous.continuous
 
-  private def loadedEval(s: State, arg: String): Unit = {
+  private def loadedEval(s: State, arg: String): Unit =
     val extracted = Project.extract(s)
     import extracted.*
     val result =
       session.currentEval().evalInfer(expression = arg, imports = autoImports(extracted))
     s.log.info(s"ans: ${result.tpe} = ${result.getValue(currentLoader)}")
-  }
 
-  private def rawEval(s: State, arg: String): Unit = {
+  private def rawEval(s: State, arg: String): Unit =
     val app = s.configuration.provider
     val classpath = app.mainClasspath ++ app.scalaProvider.jars
     val result = Load
       .mkEval(classpath.map(_.toPath()).toSeq, s.baseDir, Nil)
       .evalInfer(expression = arg, imports = EvalImports(Nil))
     s.log.info(s"ans: ${result.tpe} = ${result.getValue(app.loader)}")
-  }
 
   def sessionCommand: Command =
     Command.make(SessionCommand, sessionBrief, SessionSettings.Help)(SessionSettings.command)
 
-  def reapply(newSession: SessionSettings, structure: BuildStructure, s: State): State = {
+  def reapply(newSession: SessionSettings, structure: BuildStructure, s: State): State =
     s.log.info("Reapplying settings...")
     // For correct behavior, we also need to re-inject a settings logger, as we'll be re-evaluating settings
     val loggerInject = LogManager.settingsLogger(s)
@@ -660,7 +633,6 @@ object BuiltinCommands {
     val show = Project.showContextKey2(newSession)
     val newStructure = Load.reapply(withLogger.mergeSettings, structure)(using show)
     Project.setProject(newSession, newStructure, s)
-  }
 
   def set: Command = Command(SetCommand, setBrief, setDetailed)(setParser) { case (s, (all, arg)) =>
     val extracted = Project.extract(s)
@@ -679,7 +651,7 @@ object BuiltinCommands {
       LineRange(0, 0)
     )(cl)
     val setResult =
-      if (all) SettingCompletions.setAll(extracted, settings)
+      if all then SettingCompletions.setAll(extracted, settings)
       else SettingCompletions.setThis(extracted, settings, arg)
     s.log.info(setResult.quietSummary)
     s.log.debug(setResult.verboseSummary)
@@ -718,23 +690,19 @@ object BuiltinCommands {
       parser: State => Parser[(String, Option[AnyKeys])]
   ): Command =
     Command(name, briefHelp, detail)(parser) { (s: State, sks: (String, Option[AnyKeys])) =>
-      {
-        (s, sks) match {
-          case (s, (pattern, Some(sks))) =>
-            val (str, _, display) = extractLast(s)
-            Output.lastGrep(sks, str.streams(s), pattern, printLast)(using display)
-            keepLastLog(s)
-          case (s, (pattern, None)) =>
-            for (logFile <- lastLogFile(s)) yield Output.lastGrep(logFile, pattern, printLast)
-            keepLastLog(s)
-        }
-      }
+      (s, sks) match
+        case (s, (pattern, Some(sks))) =>
+          val (str, _, display) = extractLast(s)
+          Output.lastGrep(sks, str.streams(s), pattern, printLast)(using display)
+          keepLastLog(s)
+        case (s, (pattern, None)) =>
+          for logFile <- lastLogFile(s) yield Output.lastGrep(logFile, pattern, printLast)
+          keepLastLog(s)
     }
 
-  def extractLast(s: State): (BuildStructure, Select[ProjectRef], Show[Def.ScopedKey[?]]) = {
+  def extractLast(s: State): (BuildStructure, Select[ProjectRef], Show[Def.ScopedKey[?]]) =
     val ext = Project.extract(s)
     (ext.structure, Select(ext.currentRef), ext.showKey)
-  }
 
   def setParser = (s: State) =>
     Act.requireSession(
@@ -759,7 +727,7 @@ object BuiltinCommands {
   val exportParser: State => Parser[() => State] = (s: State) =>
     Act.requireSession(s, token(Space) ~> exportParser0(s))
 
-  private[sbt] def exportParser0(s: State): Parser[() => State] = {
+  private[sbt] def exportParser0(s: State): Parser[() => State] =
     val extracted = Project.extract(s)
     import extracted.{ showKey, structure }
     val keysParser = token(flag("--last" <~ Space)) ~ Act.aggregatedKeyParser(extracted)
@@ -769,26 +737,23 @@ object BuiltinCommands {
       print = println(_),
       success = false
     )
-    for {
+    for
       lastOnly_keys <- keysParser
       kvs = Act.keyValues(structure)(lastOnly_keys._2)
       f <-
-        if (lastOnly_keys._1) success(() => s)
+        if lastOnly_keys._1 then success(() => s)
         else Aggregation.evaluatingParser(s, show)(kvs)
-    } yield () => {
+    yield () =>
       def export0(s: State): State = lastImpl(s, kvs, Some(ExportStream))
       val newS =
         try f()
-        catch {
+        catch
           case NonFatal(e) =>
             try export0(s)
-            finally {
+            finally
               throw e
-            }
-        }
       export0(newS)
-    }
-  }
+  end exportParser0
 
   def lastGrepParser(s: State): Parser[(String, Option[AnyKeys])] =
     Act.requireSession(
@@ -799,30 +764,28 @@ object BuiltinCommands {
   def last: Command = Command(LastCommand, lastBrief, lastDetailed)(aggregatedKeyValueParser) {
     case (s, Some(sks)) => lastImpl(s, sks, None)
     case (s, None)      =>
-      for (logFile <- lastLogFile(s)) yield Output.last(logFile, printLast)
+      for logFile <- lastLogFile(s) yield Output.last(logFile, printLast)
       keepLastLog(s)
   }
 
   def exportCommand: Command =
     Command(ExportCommand, exportBrief, exportDetailed)(exportParser)((_, f) => f())
 
-  private def lastImpl(s: State, sks: AnyKeys, sid: Option[String]): State = {
+  private def lastImpl(s: State, sks: AnyKeys, sid: Option[String]): State =
     val (str, _, display) = extractLast(s)
     Output.last(sks, str.streams(s), printLast, sid)(using display)
     keepLastLog(s)
-  }
 
   /** Determines the log file that last* commands should operate on.  See also isLastOnly. */
-  def lastLogFile(s: State): Option[File] = {
+  def lastLogFile(s: State): Option[File] =
     val backing = s.globalLogging.backing
-    if (isLastOnly(s)) backing.last else Some(backing.file)
-  }
+    if isLastOnly(s) then backing.last else Some(backing.file)
 
   /**
    * If false, shift the current log file to be the log file that 'last' will operate on.
    * If true, keep the previous log file as the one 'last' operates on because there is nothing useful in the current one.
    */
-  def keepLastLog(s: State): State = if (isLastOnly(s)) s.keepLastLog else s
+  def keepLastLog(s: State): State = if isLastOnly(s) then s.keepLastLog else s
 
   /**
    * The last* commands need to determine whether to read from the current log file or the previous log file
@@ -838,10 +801,9 @@ object BuiltinCommands {
   def autoImports(extracted: Extracted): EvalImports =
     new EvalImports(imports(extracted).map(_._1)) // <auto-imports>
 
-  def imports(extracted: Extracted): Seq[(String, Int)] = {
+  def imports(extracted: Extracted): Seq[(String, Int)] =
     val curi = extracted.currentRef.build
     extracted.structure.units(curi).imports.map(s => (s, -1))
-  }
 
   def listBuild(
       uri: URI,
@@ -849,24 +811,20 @@ object BuiltinCommands {
       current: Boolean,
       currentID: String,
       log: Logger
-  ): Unit = {
+  ): Unit =
     log.info(s"In $uri")
-    def prefix(id: String) = if (currentID != id) "   " else if (current) " * " else "(*)"
-    for (id <- build.defined.keys.toSeq.sorted) log.info("\t" + prefix(id) + id)
-  }
+    def prefix(id: String) = if currentID != id then "   " else if current then " * " else "(*)"
+    for id <- build.defined.keys.toSeq.sorted do log.info("\t" + prefix(id) + id)
 
   def act: Command = Command.customHelp(Act.actParser, actHelp)
 
-  def actHelp: State => Help = { s =>
+  def actHelp: State => Help = s =>
     CommandStrings.showHelp ++ CommandStrings.printHelp ++ CommandStrings.multiTaskHelp ++
       keysHelp(s)
-  }
 
   def keysHelp(s: State): Help =
-    if (Project.isProjectLoaded(s))
-      Help.detailOnly(taskDetail(allTaskAndSettingKeys(s)))
-    else
-      Help.empty
+    if Project.isProjectLoaded(s) then Help.detailOnly(taskDetail(allTaskAndSettingKeys(s)))
+    else Help.empty
 
   def plugins: Command = Command.command(PluginsCommand, pluginsBrief, pluginsDetailed) { s =>
     val helpString = PluginsDebug.helpAll(s)
@@ -874,10 +832,9 @@ object BuiltinCommands {
     s
   }
 
-  val pluginParser: State => Parser[AutoPlugin] = s => {
+  val pluginParser: State => Parser[AutoPlugin] = s =>
     val autoPlugins: Map[String, AutoPlugin] = PluginsDebug.autoPluginMap(s)
     token(Space) ~> Act.knownPluginParser(autoPlugins, "plugin")
-  }
 
   def plugin: Command = Command(PluginCommand)(pluginParser) { (s, plugin) =>
     val helpString = PluginsDebug.help(plugin, s)
@@ -893,31 +850,27 @@ object BuiltinCommands {
       case (s, None)               => showProjects(s); s
     }
 
-  def showProjects(s: State): Unit = {
+  def showProjects(s: State): Unit =
     val extracted = Project.extract(s)
     import extracted.*
     listBuild(currentRef.build, structure.units(currentRef.build), true, currentRef.project, s.log)
-    for ((uri, build) <- structure.units if currentRef.build != uri)
+    for (uri, build) <- structure.units if currentRef.build != uri do
       listBuild(uri, build, false, currentRef.project, s.log)
-  }
 
-  def transformExtraBuilds(s: State, f: List[URI] => List[URI]): State = {
+  def transformExtraBuilds(s: State, f: List[URI] => List[URI]): State =
     val original = Project.extraBuilds(s)
     val extraUpdated = Project.updateExtraBuilds(s, f)
     try doLoadProject(extraUpdated, LoadAction.Current)
-    catch {
+    catch
       case _: Exception =>
         s.log.error("Project loading failed: reverting to previous state.")
         Project.setExtraBuilds(s, original)
-    }
-  }
 
-  def projectsParser(s: State): Parser[List[URI] => List[URI]] = {
+  def projectsParser(s: State): Parser[List[URI] => List[URI]] =
     val addBase = token(Space ~> "add") ~> token(Space ~> basicUri, "<build URI>").+
     val removeBase = token(Space ~> "remove") ~> token(Space ~> Uri(Project.extraBuilds(s).toSet)).+
     addBase.map(toAdd => (xs: List[URI]) => (toAdd.toList ::: xs).distinct) |
       removeBase.map(toRemove => (xs: List[URI]) => xs.filterNot(toRemove.toSet))
-  }
 
   def project: Command =
     Command.make(ProjectCommand, projectBrief, projectDetailed)(ProjectNavigation.command)
@@ -934,38 +887,33 @@ object BuiltinCommands {
       doLoadFailed(s, loadArg)
     }
 
-  private def deprecationWarningText(oldCommand: String, newCommand: String) = {
+  private def deprecationWarningText(oldCommand: String, newCommand: String) =
     s"The `$oldCommand` command is deprecated in favor of `$newCommand` and will be removed in a later version"
-  }
 
   @tailrec
-  private def doLoadFailed(s: State, loadArg: String): State = {
+  private def doLoadFailed(s: State, loadArg: String): State =
     // In batch mode, exit with failure to avoid infinite retry loops on persistent errors
-    if (ITerminal.console.prompt == Prompt.Batch) {
-      s.exit(ok = false)
-    } else {
+    if ITerminal.console.prompt == Prompt.Batch then s.exit(ok = false)
+    else
       s.log.warn("Project loading failed: (r)etry, (q)uit, (l)ast, or (i)gnore? (default: r)")
       val result: Int =
         try
-          ITerminal.get.withRawInput(ITerminal.get.inputStream.read) match {
+          ITerminal.get.withRawInput(ITerminal.get.inputStream.read) match
             case -1 => 'q'.toInt
             case b  => b
-          }
-        catch { case _: ClosedChannelException => 'q' }
+        catch case _: ClosedChannelException => 'q'
       def retry: State = loadProjectCommand(LoadProject, loadArg) :: s.clearGlobalLog
       def ignoreMsg: String =
-        if (Project.isProjectLoaded(s)) "using previously loaded project" else "no project loaded"
+        if Project.isProjectLoaded(s) then "using previously loaded project"
+        else "no project loaded"
 
-      result.toChar match {
+      result.toChar match
         case '\n' | '\r' => retry
         case 'r' | 'R'   => retry
         case 'q' | 'Q'   => s.exit(ok = false)
         case 'i' | 'I'   => s.log.warn(s"Ignoring load failure: $ignoreMsg."); s
         case 'l' | 'L'   => LastCommand :: loadProjectCommand(LoadFailed, loadArg) :: s
         case c           => println(s"Invalid response: '$c'"); doLoadFailed(s, loadArg)
-      }
-    }
-  }
 
   def loadProjectCommands(arg: String): List[String] =
     StashOnFailure ::
@@ -989,7 +937,7 @@ object BuiltinCommands {
   def loadProjectImpl: Command =
     Command(LoadProjectImpl)(_ => Project.loadActionParser)(doLoadProject)
 
-  def checkSBTVersionChanged(state: State): Unit = {
+  def checkSBTVersionChanged(state: State): Unit =
     import sbt.io.syntax.*
     val sbtVersionProperty = "sbt.version"
 
@@ -1000,47 +948,44 @@ object BuiltinCommands {
     // the intention is to warn if build.properties file has changed during current sbt session
     // a `reload` will not respect this change while `reboot` will.
     val buildProps = state.baseDir / "project" / "build.properties"
-    val sbtVersionBuildOpt = if (buildProps.exists) {
+    val sbtVersionBuildOpt = if buildProps.exists then
       val buildProperties = new Properties()
       IO.load(buildProperties, buildProps)
       Option(buildProperties.getProperty(sbtVersionProperty)).map(_.trim)
-    } else None
+    else None
 
     val sbtVersionOpt = sbtVersionSystemOpt.orElse(sbtVersionBuildOpt)
 
     sbtVersionOpt.foreach { version =>
       val appVersion = state.configuration.provider.id.version()
-      if (version != appVersion) {
+      if version != appVersion then
         state.log.warn(
           s"sbt version mismatch, using: $appVersion, " +
             s"""in build.properties: "$version", use 'reboot' to use the new value.""".stripMargin
         )
-      }
     }
-  }
+  end checkSBTVersionChanged
 
-  private def welcomeBanner(state: State): Unit = {
+  private def welcomeBanner(state: State): Unit =
     import scala.util.Properties
     val appVersion = state.configuration.provider.id.version()
     val javaVersion = s"${Properties.javaVendor} Java ${Properties.javaVersion}"
     state.log.info(s"welcome to sbt $appVersion ($javaVersion)")
-  }
 
-  def doLoadProject(s0: State, action: LoadAction): State = {
+  def doLoadProject(s0: State, action: LoadAction): State =
     welcomeBanner(s0)
     checkSBTVersionChanged(s0)
     val (s1, base) = Project.loadAction(SessionVar.clear(s0), action)
     IO.createDirectory(base)
-    val s2 = if (s1 has Keys.stateCompilerCache) s1 else registerCompilerCache(s1)
+    val s2 = if s1 has Keys.stateCompilerCache then s1 else registerCompilerCache(s1)
     val (eval, structure) =
       try Load.defaultLoad(s2, base, s2.log, Project.inPluginProject(s2), Project.extraBuilds(s2))
-      catch {
+      catch
         case ex: sbt.internal.EvalException =>
           s0.log.debug(ex.getMessage)
           ex.getStackTrace map (ste => s"\tat $ste") foreach (s0.log.debug(_))
           ex.setStackTrace(Array.empty)
           throw ex
-      }
 
     val session = Load.initialSession(structure, eval, s0)
     SessionSettings.checkSession(session, s2)
@@ -1055,13 +1000,12 @@ object BuiltinCommands {
         LintUnused.lintScalaVersion(LintUnused.lintUnusedFunc(s3))
       )
     )
-  }
+  end doLoadProject
 
-  private val setupGlobalFileTreeRepository: State => State = { state =>
+  private val setupGlobalFileTreeRepository: State => State = state =>
     state.get(sbt.nio.Keys.globalFileTreeRepository).foreach(_.close())
     state.put(sbt.nio.Keys.globalFileTreeRepository, FileTreeRepository.default)
-  }
-  private val addSuperShellParams: State => State = (s: State) => {
+  private val addSuperShellParams: State => State = (s: State) =>
     val extracted = Project.extract(s)
     import scala.concurrent.duration.*
     val sleep = extracted.getOpt(Keys.superShellSleep).getOrElse(SysProp.supershellSleep.millis)
@@ -1072,7 +1016,6 @@ object BuiltinCommands {
     s.put(Keys.superShellSleep.key, sleep)
       .put(Keys.superShellThreshold.key, threshold)
       .put(Keys.superShellMaxTasks.key, maxItems)
-  }
 
   def registerCompilerCache(s: State): State = Clean.registerCompilerCache(s)
   def clearCaches: Command = Clean.clearCaches
@@ -1085,9 +1028,9 @@ object BuiltinCommands {
         "Force-updates all remote VCS project dependencies."
       )
     ) { s =>
-      if (s.get(BuildPaths.repositoryUpdateCompleted).getOrElse(false)) {
+      if s.get(BuildPaths.repositoryUpdateCompleted).getOrElse(false) then
         s.remove(BuildPaths.repositoryUpdateCompleted)
-      } else {
+      else
         val log = s.log
         val extracted = Project.extract(s)
         val isUpdated = Resolvers.updateLoadedBuild(
@@ -1097,13 +1040,10 @@ object BuiltinCommands {
           force = true
         )
 
-        if (isUpdated) {
+        if isUpdated then
           log.warn("Remote dependencies updated. Reloading...")
           "reload" :: s.put(BuildPaths.repositoryUpdateCompleted, true)
-        } else {
-          s
-        }
-      }
+        else s
     }
 
   private[sbt] def waitCmd: Command =
@@ -1111,48 +1051,43 @@ object BuiltinCommands {
       ContinuousCommands.waitWatch.examples() ~> " ".examples() ~> matched(any.*).examples()
     ) { (s0, channel) =>
       val exchange = StandardMain.exchange
-      exchange.channelForName(channel) match {
+      exchange.channelForName(channel) match
         case Some(c) if ContinuousCommands.isInWatch(s0, c) =>
-          if (c.terminal.prompt != Prompt.Watch) {
+          if c.terminal.prompt != Prompt.Watch then
             c.terminal.setPrompt(Prompt.Watch)
             c.prompt(ConsolePromptEvent(s0))
-          } else if (c.terminal.isSupershellEnabled) {
+          else if c.terminal.isSupershellEnabled then
             c.terminal.printStream.print(ConsoleAppender.ClearScreenAfterCursor)
             c.terminal.printStream.flush()
-          }
 
           val s1 = exchange.run(s0)
           val exec: Exec = getExec(s1, Duration.Inf)
           val wait = s"${ContinuousCommands.waitWatch} $channel"
           val onFailure =
-            s1.onFailure.map(of => if (of.commandLine == Shell) of.withCommandLine(wait) else of)
+            s1.onFailure.map(of => if of.commandLine == Shell then of.withCommandLine(wait) else of)
           val waitExec = Exec(wait, None)
           val remaining: List[Exec] = Exec(FailureWall, None) :: waitExec :: s1.remainingCommands
           val newState = s1.copy(remainingCommands = exec +: remaining, onFailure = onFailure)
-          if (exec.commandLine.trim.isEmpty) newState
+          if exec.commandLine.trim.isEmpty then newState
           else newState.clearGlobalLog
         case _ => s0
-      }
     }
 
   private[sbt] def promptChannel = Command.arb(_ => reportParser(PromptChannel)) {
     (state, channel) =>
-      if (channel == ConsoleChannel.defaultName) {
-        if (!state.remainingCommands.exists(_.commandLine == Shell))
+      if channel == ConsoleChannel.defaultName then
+        if !state.remainingCommands.exists(_.commandLine == Shell) then
           state.copy(remainingCommands = state.remainingCommands ::: (Exec(Shell, None) :: Nil))
         else state
-      } else {
-        StandardMain.exchange.channelForName(channel) match {
+      else
+        StandardMain.exchange.channelForName(channel) match
           case Some(nc: NetworkChannel) => nc.prompt()
           case _                        =>
-        }
         state
-      }
   }
 
-  private def getExec(state: State, interval: Duration): Exec = {
+  private def getExec(state: State, interval: Duration): Exec =
     StandardMain.exchange.blockUntilNextExec(interval, Some(state), state.globalLogging.full)
-  }
 
   def shell: Command = Command.command(Shell, Help.more(Shell, ShellDetailed)) { s0 =>
     import sbt.internal.ConsolePromptEvent
@@ -1164,24 +1099,21 @@ object BuiltinCommands {
      * by a remote client and only one is able to start a server. This seems to
      * happen primarily on windows.
      */
-    if (ITerminal.startedByRemoteClient && !exchange.hasServer) {
-      Exec(Shutdown, None) +: s1
-    } else {
-      if (ITerminal.console.prompt == Prompt.Batch) ITerminal.console.setPrompt(Prompt.Pending)
+    if ITerminal.startedByRemoteClient && !exchange.hasServer then Exec(Shutdown, None) +: s1
+    else
+      if ITerminal.console.prompt == Prompt.Batch then ITerminal.console.setPrompt(Prompt.Pending)
       exchange.prompt(ConsolePromptEvent(s0))
       val minGCInterval = Project
         .extract(s1)
         .getOpt(Keys.minForcegcInterval)
         .getOrElse(GCUtil.defaultMinForcegcInterval)
       val exec: Exec = getExec(s1, minGCInterval)
-      val isInteractive = exec.source match {
+      val isInteractive = exec.source match
         case Some(src) if src.channelName.startsWith("network") =>
-          exchange.channelForName(src.channelName) match {
+          exchange.channelForName(src.channelName) match
             case Some(nc: NetworkChannel) => nc.isInteractive
             case _                        => true
-          }
         case _ => true
-      }
       val newState = s1
         .copy(
           onFailure = Some(Exec(Shell, None)),
@@ -1189,10 +1121,10 @@ object BuiltinCommands {
         )
         .setInteractive(isInteractive)
       val res =
-        if (exec.commandLine.trim.isEmpty) newState
+        if exec.commandLine.trim.isEmpty then newState
         else newState.clearGlobalLog
       res
-    }
+    end if
   }
 
   def rebootNetwork: Command = Command.arb(_ => (RebootNetwork: Parser[String]).examples()) {
@@ -1210,63 +1142,55 @@ object BuiltinCommands {
   private def isSbtVersionLine(s: String) = sbtVersionRegex.pattern.matcher(s).matches()
 
   /** True if baseDir appears to be inside a scripted test directory (sbt#4536). */
-  private def isScriptedTestDirectory(baseDir: File): Boolean = {
+  private def isScriptedTestDirectory(baseDir: File): Boolean =
     val path = baseDir.getAbsolutePath
     path.contains(java.io.File.separator + "sbt-test" + java.io.File.separator) ||
     path.contains("/sbt-test/")
-  }
 
-  private def writeSbtVersionUnconditionally(state: State): Unit = {
+  private def writeSbtVersionUnconditionally(state: State): Unit =
     val baseDir = state.baseDir
-    if (isScriptedTestDirectory(baseDir)) {
+    if isScriptedTestDirectory(baseDir) then {
       // sbt#4536: don't alter scripted test setup
-    } else {
+    } else
       val sbtVersion = BuiltinCommands.sbtVersion(state)
       val projectDir = baseDir / "project"
       val buildProps = projectDir / "build.properties"
 
-      val buildPropsLines = if (buildProps.canRead) IO.readLines(buildProps) else Nil
+      val buildPropsLines = if buildProps.canRead then IO.readLines(buildProps) else Nil
 
       val sbtVersionAbsent = buildPropsLines forall (!isSbtVersionLine(_))
 
-      if (sbtVersionAbsent) {
+      if sbtVersionAbsent then
         val warnMsg = s"No sbt.version set in project/build.properties, base directory: $baseDir"
-        try {
-          if (isSbtBuild(baseDir)) {
+        try
+          if isSbtBuild(baseDir) then
             val line = s"sbt.version=$sbtVersion"
             IO.writeLines(buildProps, line :: buildPropsLines)
             state.log.info(s"Updated file $buildProps: set sbt.version to $sbtVersion")
-          } else state.log.warn(warnMsg)
-        } catch {
-          case _: IOException => state.log.warn(warnMsg)
-        }
-      }
-    }
-  }
+          else state.log.warn(warnMsg)
+        catch case _: IOException => state.log.warn(warnMsg)
+  end writeSbtVersionUnconditionally
 
   private def intendsToInvokeNew(state: State) =
     state.remainingCommands exists (_.commandLine == TemplateCommand)
 
   private def writeSbtVersion(state: State) =
-    if (SysProp.genBuildProps && !intendsToInvokeNew(state)) {
+    if SysProp.genBuildProps && !intendsToInvokeNew(state) then
       writeSbtVersionUnconditionally(state)
-    }
 
   private def checkRoot(state: State): Unit =
-    if (SysProp.allowRootDir) ()
-    else {
+    if SysProp.allowRootDir then ()
+    else
       val baseDir = state.baseDir
       import scala.jdk.CollectionConverters.*
       // this should return / on Unix and C:\ for Windows.
       val rootOpt = FileSystems.getDefault.getRootDirectories.asScala.toList.headOption
       rootOpt foreach { root =>
-        if (baseDir.getAbsolutePath == root.toString) {
+        if baseDir.getAbsolutePath == root.toString then
           throw new IllegalStateException(
             "cannot run sbt from root directory without -Dsbt.rootdir=true; see sbt/sbt#1458"
           )
-        }
       }
-    }
 
   private def WriteSbtVersion = "writeSbtVersion"
 
@@ -1282,15 +1206,14 @@ object BuiltinCommands {
   private def hasRebooted(state: State) =
     state.remainingCommands exists (_.commandLine == StartServer)
 
-  private def notifyUsersAboutShell(state: State): Unit = {
+  private def notifyUsersAboutShell(state: State): Unit =
     val suppress =
       Project
         .extract(state)
         .getOpt(Keys.suppressSbtShellNotification)
         .getOrElse(false)
-    if (!suppress && intendsToInvokeCompile(state) && !hasRebooted(state))
+    if !suppress && intendsToInvokeCompile(state) && !hasRebooted(state) then
       state.log.info("Executing in batch mode. For better performance use sbt's shell")
-  }
 
   private def NotifyUsersAboutShell = "notifyUsersAboutShell"
 
@@ -1299,38 +1222,31 @@ object BuiltinCommands {
       notifyUsersAboutShell(state); state
     }
 
-  private def skipWelcomeFile(state: State, version: String) = {
+  private def skipWelcomeFile(state: State, version: String) =
     val base = BuildPaths.getGlobalBase(state).toPath
     base.resolve("preferences").resolve(version).resolve(SkipBannerFileName)
-  }
-  private def displayWelcomeBanner(state: State): State = {
-    if (!state.get(bannerHasBeenShown).getOrElse(false)) {
-      try {
+  private def displayWelcomeBanner(state: State): State =
+    if !state.get(bannerHasBeenShown).getOrElse(false) then
+      try
         val version = sbtVersion(state)
         val skipFile = skipWelcomeFile(state, version)
         IO.createDirectory(skipFile.getParent.toFile())
         val suppress = !SysProp.banner || Files.exists(skipFile)
-        if (!suppress) {
-          Banner(version).foreach(banner => state.log.info(banner))
-        }
-      } catch {
+        if !suppress then Banner(version).foreach(banner => state.log.info(banner))
+      catch
         case _: IOException => /* Don't let errors in this command prevent startup */
-      }
       state.put(bannerHasBeenShown, true)
-    } else state
-  }
+    else state
   private val bannerHasBeenShown =
     AttributeKey[Boolean]("banner-has-been-shown", Int.MaxValue)
   private val SkipBannerFileName = "skip-banner"
   private val SkipBanner = "skipBanner"
   private def skipBanner: Command = Command.command(SkipBanner)(skipBanner)
-  private def skipBanner(state: State): State = {
+  private def skipBanner(state: State): State =
     val skipFile = skipWelcomeFile(state, sbtVersion(state))
     try Files.createFile(skipFile)
-    catch {
+    catch
       case _: FileAlreadyExistsException =>
       case e: IOException                => state.log.error(s"Couldn't create file $skipFile: $e")
-    }
     state
-  }
-}
+end BuiltinCommands
diff --git a/main/src/main/scala/sbt/MainLoop.scala b/main/src/main/scala/sbt/MainLoop.scala
index 52e5e4717..a7f3be691 100644
--- a/main/src/main/scala/sbt/MainLoop.scala
+++ b/main/src/main/scala/sbt/MainLoop.scala
@@ -97,25 +97,24 @@ private[sbt] object MainLoop:
     logBacking.last.foreach(_.delete())
 
   /** Deletes the current sbt artifacts from boot. */
-  private[sbt] def deleteCurrentArtifacts(state: State): Unit = {
+  private[sbt] def deleteCurrentArtifacts(state: State): Unit =
     val provider = state.configuration.provider
     val appId = provider.id
     // If we can obtain boot directory more accurately it'd be better.
     val defaultBoot = BuildPaths.defaultGlobalBase / "boot"
     val buildProps = state.baseDir / "project" / "build.properties"
     // First try reading the sbt version from build.properties file.
-    val sbtVersionOpt = if (buildProps.exists) {
+    val sbtVersionOpt = if buildProps.exists then
       val buildProperties = new Properties()
       IO.load(buildProperties, buildProps)
       Option(buildProperties.getProperty("sbt.version")).map(_.trim)
-    } else None
+    else None
     val sbtVersion = sbtVersionOpt.getOrElse(appId.version)
     val currentArtDirs = defaultBoot * "*" / appId.groupID / appId.name / sbtVersion
     currentArtDirs.get().foreach { dir =>
       state.log.info(s"deleting $dir")
       IO.delete(dir)
     }
-  }
 
   /** Removes the Zinc compiler bridge secondary cache (`zincDir/org.scala-sbt`). */
   private[sbt] def deleteZincBridgeSecondaryCache(log: Logger, zincDir: File): Unit =
@@ -180,21 +179,20 @@ private[sbt] object MainLoop:
         resolutionProgress,
         Project.configNameToIdent(state)
       )
-    val gcMonitor = if (SysProp.gcMonitor) Some(new sbt.internal.GCMonitor(state.log)) else None
-    try {
+    val gcMonitor = if SysProp.gcMonitor then Some(new sbt.internal.GCMonitor(state.log)) else None
+    try
       ErrorHandling.wideConvert {
         state
           .put(Keys.loggerContext, context)
           .put(Keys.taskProgress, taskProgress)
           .put(Keys.resolutionProgress, resolutionProgress)
           .process(processCommand)
-      } match {
+      } match
         case Right(s)                  => s.remove(Keys.loggerContext)
         case Left(t: xsbti.FullReload) => throw t
         case Left(t: RebootCurrent)    => throw t
         case Left(t)                   => state.remove(Keys.loggerContext).handleError(t)
-      }
-    } catch {
+    catch
       case oom: OutOfMemoryError
           if oom.getMessage != null && oom.getMessage.contains("Metaspace") =>
         System.gc() // Since we're under memory pressure, see if more can be freed with a manual gc.
@@ -205,12 +203,12 @@ private[sbt] object MainLoop:
         val isConsole = state.remainingCommands.exists(_.commandLine == "shell") ||
           (state.remainingCommands.last.commandLine == "iflast shell")
         val testOrRunMessage =
-          if (!isTestOrRun) ""
+          if !isTestOrRun then ""
           else
             " If this error occurred during a test or run evaluation, it can be caused by the " +
               "choice of ClassLoaderLayeringStrategy. Of the available strategies, " +
               "ClassLoaderLayeringStrategy.ScalaLibrary will typically use the least metaspace. " +
-              (if (isConsole)
+              (if isConsole then
                  " To change the layering strategy for this session, run:\n\n" +
                    "set ThisBuild / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy." +
                    "ScalaLibrary"
@@ -221,11 +219,11 @@ private[sbt] object MainLoop:
         state.log.error(msg)
         state.log.error("\n")
         state.handleError(oom)
-    } finally {
+    finally
       gcMonitor.foreach(_.close())
       context.close()
       taskProgress.close()
-    }
+    end try
   end next
 
   /** This is the main function State transfer function of the sbt command processing. */
@@ -236,18 +234,16 @@ private[sbt] object MainLoop:
     exchange.notifyStatus(
       ExecStatusEvent("Processing", channelName, exec.execId, Vector())
     )
-    try {
-      def process(): State = {
-        def getOrSet[T](state: State, key: AttributeKey[T], value: Extracted => T): State = {
-          state.get(key) match {
+    try
+      def process(): State =
+        def getOrSet[T](state: State, key: AttributeKey[T], value: Extracted => T): State =
+          state.get(key) match
             case Some(_) => state
             case _       =>
-              if (state.get(Keys.stateBuildStructure).isDefined) {
+              if state.get(Keys.stateBuildStructure).isDefined then
                 val extracted = Project.extract(state)
                 state.put(key, value(extracted))
-              } else state
-          }
-        }
+              else state
 
         val cmdProgressState =
           getOrSet(
@@ -280,20 +276,19 @@ private[sbt] object MainLoop:
          */
         val prevSessionCurrent = termState.get(Keys.sessionSettings).map(_.current)
         val newState =
-          try {
+          try
             var errorMsg: Option[String] = None
             val res = FastTrackCommands
               .evaluate(termState, exec.commandLine)
               .getOrElse(Command.process(exec.commandLine, termState, m => errorMsg = Some(m)))
-            errorMsg match {
+            errorMsg match
               case Some(msg) =>
                 currentCmdProgress.foreach(
                   _.afterCommand(exec.commandLine, Left(new ParseException(msg, 0)))
                 )
               case None => currentCmdProgress.foreach(_.afterCommand(exec.commandLine, Right(res)))
-            }
             syncChannelCursor(res, prevSessionCurrent, channelName)
-          } catch {
+          catch
             case _: RejectedExecutionException =>
               val cancelled = new Cancelled(exec.commandLine)
               currentCmdProgress
@@ -304,14 +299,13 @@ private[sbt] object MainLoop:
               currentCmdProgress
                 .foreach(_.afterCommand(exec.commandLine, Left(e)))
               throw e
-          } finally
+          finally
             // Flush the terminal output after command evaluation to ensure that all output
             // is displayed in the thin client before we report the command status.
             flushTerminal()
-        if (
-          exec.execId.fold(true)(!_.startsWith(networkExecPrefix)) &&
+        if exec.execId.fold(true)(!_.startsWith(networkExecPrefix)) &&
           !exec.commandLine.startsWith(networkExecPrefix)
-        ) {
+        then
           val doneEvent = ExecStatusEvent(
             "Done",
             channelName,
@@ -320,13 +314,12 @@ private[sbt] object MainLoop:
             exitCode(newState, state),
           )
           exchange.respondStatus(doneEvent)
-        }
         exchange.setExec(None)
         newState.get(sbt.Keys.currentCommandProgress).foreach(_.stop())
         newState
           .remove(Keys.terminalKey)
           .remove(Keys.currentCommandProgress)
-      }
+      end process
 
       val channel = channelName.flatMap(exchange.channelForName)
       val (canReload, useLoadp) = channel match
@@ -334,16 +327,15 @@ private[sbt] object MainLoop:
         case Some(_: ConsoleChannel)  => (true, false)
         case _                        => (false, false)
 
-      state.get(CheckBuildSourcesKey) match {
+      state.get(CheckBuildSourcesKey) match
         case Some(cbs) if canReload && cbs.needsReload(state, exec) =>
           val loadExec =
-            if (useLoadp) Exec("loadp", exec.execId, exec.source)
+            if useLoadp then Exec("loadp", exec.execId, exec.source)
             else Exec("reload", exec.source)
 
           loadExec +: exec +: state.remove(CheckBuildSourcesKey)
         case _ => process()
-      }
-    } catch {
+    catch
       case err: JsonRpcResponseError =>
         exchange.respondError(err, exec.execId, channelName.map(CommandSource(_)))
         throw err
@@ -358,7 +350,7 @@ private[sbt] object MainLoop:
         )
         StandardMain.exchange.respondStatus(errorEvent)
         throw err
-    }
+    end try
   end processCommand
 
   def logFullException(e: Throwable, log: Logger): Unit = State.logFullException(e, log)
@@ -388,7 +380,7 @@ private[sbt] object MainLoop:
           case _: xsbti.Continue => ExitCode.Success
           case _: xsbti.Reboot   => ExitCode.Success
           case x                 =>
-            val clazz = if (x eq null) "" else " (class: " + x.getClass + ")"
+            val clazz = if x eq null then "" else " (class: " + x.getClass + ")"
             state.log.debug(s"Unknown main result: $x$clazz")
             ExitCode.Unknown
 
@@ -419,6 +411,5 @@ private[sbt] object MainLoop:
 end MainLoop
 
 // No stack trace since this is just to notify the user which command they cancelled
-class Cancelled(cmdLine: String) extends Throwable(cmdLine, null, true, false) {
+class Cancelled(cmdLine: String) extends Throwable(cmdLine, null, true, false):
   override def toString: String = s"Cancelled: $cmdLine"
-}
diff --git a/main/src/main/scala/sbt/OptionSyntax.scala b/main/src/main/scala/sbt/OptionSyntax.scala
index 7da4b7e0c..a4f73452b 100644
--- a/main/src/main/scala/sbt/OptionSyntax.scala
+++ b/main/src/main/scala/sbt/OptionSyntax.scala
@@ -11,29 +11,23 @@ package sbt
 import java.util.Optional
 
 // Todo: port this back to Zinc in place of JavaInterfaceUtil.
-trait OptionSyntax {
+trait OptionSyntax:
 
   /** Injects some method. */
-  extension [A](a: A) {
-    def some: Option[A] = Some(a)
-  }
+  extension [A](a: A) def some: Option[A] = Some(a)
 
   /** Injects asScala method. */
-  extension [A](optional: Optional[A]) {
+  extension [A](optional: Optional[A])
     def asScala: Option[A] =
-      if (!optional.isPresent) None
+      if !optional.isPresent then None
       else Some(optional.get())
-  }
 
   /** Injects asJava method. */
-  extension [A](option: Option[A]) {
-    def asJava: Optional[A] = option match {
+  extension [A](option: Option[A])
+    def asJava: Optional[A] = option match
       case Some(value) => Optional.of(value)
       case None        => Optional.empty[A]
-    }
-  }
 
   final def none[A]: Option[A] = None
-}
 
 object OptionSyntax extends OptionSyntax
diff --git a/main/src/main/scala/sbt/Opts.scala b/main/src/main/scala/sbt/Opts.scala
index faa54abfa..c90f62643 100644
--- a/main/src/main/scala/sbt/Opts.scala
+++ b/main/src/main/scala/sbt/Opts.scala
@@ -17,8 +17,8 @@ import sbt.io.Path
 import Path.*
 
 /** Options for well-known tasks. */
-object Opts {
-  object compile {
+object Opts:
+  object compile:
     val deprecation = "-deprecation"
     def encoding(enc: String) = Seq("-encoding", enc)
     val explaintypes = "-explaintypes"
@@ -26,14 +26,13 @@ object Opts {
     val optimise = "-optimise"
     val unchecked = "-unchecked"
     val verbose = "-verbose"
-  }
-  object doc {
+  object doc:
     def generator(g: String): Seq[String] = Seq("-doc-generator", g)
     def sourceUrl(u: String): Seq[String] = Seq("-doc-source-url", u)
     def title(t: String): Seq[String] = Seq("-doc-title", t)
     def version(v: String): Seq[String] = Seq("-doc-version", v)
     def externalAPI(mappings: Iterable[(File, URI)]): Seq[String] =
-      if (mappings.isEmpty) Nil
+      if mappings.isEmpty then Nil
       else
         mappings
           .map { (f, u) => s"${f.getAbsolutePath}#${u.toURL().toExternalForm}" }
@@ -44,7 +43,7 @@ object Opts {
      * Format: -external-mappings:regex::[scaladoc3|scaladoc|javadoc]::url,...
      */
     def externalAPIScala3(mappings: Iterable[(File, URI)]): Seq[String] =
-      if (mappings.isEmpty) Nil
+      if mappings.isEmpty then Nil
       else
         mappings
           .map { (f, u) =>
@@ -54,12 +53,12 @@ object Opts {
             // Use a regex pattern that matches the file anywhere in the classpath
             val regex = s".*$escapedName"
             // Determine if this is javadoc or scaladoc based on the file/URL
-            val docType = if (isJavaDoc(f, u)) "javadoc" else "scaladoc3"
+            val docType = if isJavaDoc(f, u) then "javadoc" else "scaladoc3"
             s"$regex::$docType::${u.toURL().toExternalForm}"
           }
           .mkString("-external-mappings:", ",", "") :: Nil
 
-    private def isJavaDoc(file: File, uri: URI): Boolean = {
+    private def isJavaDoc(file: File, uri: URI): Boolean =
       val name = file.getName.toLowerCase
       val url = uri.toString.toLowerCase
       // Heuristics to detect Java documentation
@@ -68,18 +67,16 @@ object Opts {
       url.contains("docs.oracle.com") ||
       url.contains("javadoc") ||
       url.contains("/java/") && !url.contains("scala")
-    }
-  }
-  object resolver {
+  end doc
+  object resolver:
     import sbt.io.syntax.*
 
     val mavenLocalFile = Resolver.file("Local Repository", userHome / ".m2" / "repository")(using
       Resolver.defaultPatterns
     )
-  }
-}
+end Opts
 
-object DefaultOptions {
+object DefaultOptions:
   import Opts.*
   import sbt.io.syntax.*
   import BuildPaths.{ getGlobalBase, getGlobalSettingsDirectory }
@@ -93,13 +90,11 @@ object DefaultOptions {
   def scaladoc(name: String, version: String): Seq[String] =
     doc.title(name) ++ doc.version(version)
 
-  def resolvers(snapshot: Boolean): Vector[Resolver] = {
+  def resolvers(snapshot: Boolean): Vector[Resolver] =
     Vector.empty
-  }
-  def pluginResolvers(plugin: Boolean, snapshot: Boolean): Vector[Resolver] = {
-    if (plugin && snapshot) Vector.empty
+  def pluginResolvers(plugin: Boolean, snapshot: Boolean): Vector[Resolver] =
+    if plugin && snapshot then Vector.empty
     else Vector.empty
-  }
   def addResolvers: Setting[?] = Keys.resolvers ++= { resolvers(Keys.isSnapshot.value) }
   def addPluginResolvers: Setting[?] =
     Keys.resolvers ++= pluginResolvers(Keys.sbtPlugin.value, Keys.isSnapshot.value)
@@ -111,4 +106,4 @@ object DefaultOptions {
   def shellPrompt(version: String): State => String =
     s => s"${s.configuration.provider.id.name}:${Project.extract(s).currentProject.id}:${version}> "
   def setupShellPrompt: Setting[?] = Keys.shellPrompt := { shellPrompt(Keys.version.value) }
-}
+end DefaultOptions
diff --git a/main/src/main/scala/sbt/PluginCross.scala b/main/src/main/scala/sbt/PluginCross.scala
index c13bfe79b..ca0c26c3d 100644
--- a/main/src/main/scala/sbt/PluginCross.scala
+++ b/main/src/main/scala/sbt/PluginCross.scala
@@ -24,9 +24,9 @@ import ProjectExtra.{ extract, setProject }
 /**
  * Module responsible for plugin cross building.
  */
-private[sbt] object PluginCross extends PluginCrossExtra {
-  lazy val pluginSwitch: Command = {
-    def switchParser(state: State): Parser[(String, String)] = {
+private[sbt] object PluginCross extends PluginCrossExtra:
+  lazy val pluginSwitch: Command =
+    def switchParser(state: State): Parser[(String, String)] =
       lazy val switchArgs = token(NotSpace.examples()) ~ (token(
         Space ~> matched(state.combinedParser)
       ) ?? "")
@@ -34,13 +34,11 @@ private[sbt] object PluginCross extends PluginCrossExtra {
       token(PluginSwitchCommand ~ OptSpace) flatMap { _ =>
         switchArgs & nextSpaced
       }
-    }
 
     def crossExclude(s: Def.Setting[?]): Boolean =
-      s.key match {
+      s.key match
         case ScopedKey(Scope(_, _, pluginCrossBuild.key, _), sbtVersion.key) => true
         case _                                                               => false
-      }
 
     Command.arb(requireSession(switchParser), pluginSwitchHelp) {
       case (state, (version, command)) =>
@@ -56,9 +54,9 @@ private[sbt] object PluginCross extends PluginCrossExtra {
         val newStructure = Load.reapply(cleared ++ add, structure)
         Project.setProject(session, newStructure, command :: state)
     }
-  }
+  end pluginSwitch
 
-  lazy val pluginCross: Command = {
+  lazy val pluginCross: Command =
     def crossParser(state: State): Parser[String] =
       token(PluginCrossCommand <~ OptSpace) flatMap { _ =>
         token(
@@ -68,14 +66,13 @@ private[sbt] object PluginCross extends PluginCrossExtra {
           )
         )
       }
-    def crossVersions(state: State): List[String] = {
+    def crossVersions(state: State): List[String] =
       val x = Project.extract(state)
       import x.*
       (currentRef / crossSbtVersions)
         .get(structure.data)
         .getOrElse(Nil)
         .toList
-    }
     Command.arb(requireSession(crossParser), pluginCrossHelp) { (state, command) =>
       val x = Project.extract(state)
       import x.*
@@ -84,25 +81,24 @@ private[sbt] object PluginCross extends PluginCrossExtra {
         .get(structure.data)
         .map(PluginSwitchCommand + " " + _)
         .toList
-      if (versions.isEmpty) command :: state
+      if versions.isEmpty then command :: state
       else versions.map(PluginSwitchCommand + " " + _ + " " + command) ::: current ::: state
     }
-  }
+  end pluginCross
 
   def scalaVersionSetting: Def.Initialize[String] = Def.setting {
     val scalaV = scalaVersion.value
     val sv = (pluginCrossBuild / sbtBinaryVersion).value
     val isPlugin = sbtPlugin.value
-    if (isPlugin) scalaVersionFromSbtBinaryVersion(sv)
+    if isPlugin then scalaVersionFromSbtBinaryVersion(sv)
     else scalaV
   }
 
   def scalaVersionFromSbtBinaryVersion(sv: String): String =
-    VersionNumber(sv) match {
+    VersionNumber(sv) match
       case VersionNumber(Seq(0, 12, _*), _, _) => "2.9.2"
       case VersionNumber(Seq(0, 13, _*), _, _) => "2.10.7"
       case VersionNumber(Seq(1, 0, _*), _, _)  => "2.12.21"
       case VersionNumber(Seq(2, _*), _, _)     => scala3
       case _                                   => sys.error(s"Unsupported sbt binary version: $sv")
-    }
-}
+end PluginCross
diff --git a/main/src/main/scala/sbt/ProjectExtra.scala b/main/src/main/scala/sbt/ProjectExtra.scala
index 873f34902..5e0ab358a 100755
--- a/main/src/main/scala/sbt/ProjectExtra.scala
+++ b/main/src/main/scala/sbt/ProjectExtra.scala
@@ -289,12 +289,11 @@ trait ProjectExtra extends Scoped.Syntax:
         yield key
         globalKeys ++ projectKeys
 
-    def extract(state: State): Extracted = {
+    def extract(state: State): Extracted =
       val se = Project.session(state)
       val st = Project.structure(state)
       val currentRef = internal.ProjectNavigation.effectiveCurrentRef(state)
       Extracted(st, se, currentRef)(using Project.showContextKey2(se, st.index.keyIndex, None))
-    }
 
     private[sbt] def extract(se: SessionSettings, st: BuildStructure): Extracted =
       Extracted(st, se, se.current)(using Project.showContextKey2(se, st.index.keyIndex, None))
@@ -325,7 +324,7 @@ trait ProjectExtra extends Scoped.Syntax:
         structure: BuildStructure,
         s: State,
         preOnLoad: State => State
-    ): State = {
+    ): State =
       val unloaded = Project.runUnloadHooks(s)
       val (onLoad, onUnload) = getHooks(structure.data)
       val newAttrs = unloaded.attributes
@@ -338,7 +337,6 @@ trait ProjectExtra extends Scoped.Syntax:
           updateCurrent(newState)
         )
       )
-    }
 
     def orIdentity[A](opt: Option[A => A]): A => A =
       opt.getOrElse(identity)
@@ -351,12 +349,12 @@ trait ProjectExtra extends Scoped.Syntax:
 
     def current(state: State): ProjectRef = session(state).current
 
-    def updateCurrent(s: State): State = {
+    def updateCurrent(s: State): State =
       val structure = Project.structure(s)
       val ref = Project.current(s)
       Load.getProject(structure.units, ref.build, ref.project)
       val msg = (ref / Keys.onLoadMessage).get(structure.data).getOrElse("")
-      if (!msg.isEmpty) s.log.info(msg)
+      if !msg.isEmpty then s.log.info(msg)
       def get[T](k: SettingKey[T]): Option[T] = (ref / k).get(structure.data)
       def commandsIn(axis: ResolvedReference) = (axis / commands).get(structure.data).toList
 
@@ -420,7 +418,7 @@ trait ProjectExtra extends Scoped.Syntax:
         attributes = newAttrs,
         definedCommands = newDefinedCommands
       )
-    }
+    end updateCurrent
 
     def setCond[T](key: AttributeKey[T], vopt: Option[T], attributes: AttributeMap): AttributeMap =
       attributes.setCond(key, vopt)
@@ -443,7 +441,7 @@ trait ProjectExtra extends Scoped.Syntax:
 
     def details(structure: BuildStructure, actual: Boolean, key: ScopedKey[?])(using
         display: Show[ScopedKey[?]]
-    ): String = {
+    ): String =
       val data = scopedKeyData(structure, key).map(_.description).getOrElse("No entry for key.")
       val description = key.key.description match
         case Some(desc) => s"Description:\n\t$desc\n"
@@ -468,7 +466,7 @@ trait ProjectExtra extends Scoped.Syntax:
       def derivedDependencies(c: ScopedKey[?]): List[ScopedKey[?]] =
         comp
           .get(c)
-          .map(_.settings.flatMap(s => if (s.isDerived) s.dependencies else Nil))
+          .map(_.settings.flatMap(s => if s.isDerived then s.dependencies else Nil))
           .toList
           .flatten
 
@@ -486,12 +484,11 @@ trait ProjectExtra extends Scoped.Syntax:
           derivedLabel: String,
           scopes: Iterable[ScopedKey[?]],
           derived: Set[ScopedKey[?]]
-      ): String = {
-        val label = s"$baseLabel${if (derived.isEmpty) "" else s" (D=$derivedLabel)"}"
+      ): String =
+        val label = s"$baseLabel${if derived.isEmpty then "" else s" (D=$derivedLabel)"}"
         val prefix: ScopedKey[?] => String =
-          if (derived.isEmpty) const("") else sk => if (derived(sk)) "D " else "  "
+          if derived.isEmpty then const("") else sk => if derived(sk) then "D " else "  "
         printScopes(label, scopes, prefix = prefix)
-      }
 
       def printScopes(
           label: String,
@@ -499,12 +496,11 @@ trait ProjectExtra extends Scoped.Syntax:
           max: Int = Int.MaxValue,
           prefix: ScopedKey[?] => String = const("")
       ) =
-        if (scopes.isEmpty) ""
-        else {
+        if scopes.isEmpty then ""
+        else
           val (limited, more) =
-            if (scopes.size <= max) (scopes, "\n") else (scopes.take(max), "\n...\n")
+            if scopes.size <= max then (scopes, "\n") else (scopes.take(max), "\n...\n")
           limited.map(sk => prefix(sk) + display.show(sk)).mkString(label + ":\n\t", "\n\t", more)
-        }
 
       data + "\n" +
         description +
@@ -514,7 +510,7 @@ trait ProjectExtra extends Scoped.Syntax:
         printDepScopes("Reverse dependencies", "derives", reverse, derivedReverse) +
         printScopes("Delegates", delegates(structure, key.scope, key.key)) +
         printScopes("Related", related, 10)
-    }
+    end details
 
     def settingGraph(structure: BuildStructure, basedir: File, scoped: ScopedKey[?])(using
         display: Show[ScopedKey[?]]
@@ -574,24 +570,24 @@ trait ProjectExtra extends Scoped.Syntax:
         using display: Show[ScopedKey[?]]
     ): Seq[Scope] =
       relation(structure, actual)(using display)._1s.toSeq flatMap { sk =>
-        if (sk.key == key) sk.scope :: Nil else Nil
+        if sk.key == key then sk.scope :: Nil else Nil
       }
 
     private[sbt] def usedBy(structure: BuildStructure, actual: Boolean, key: AttributeKey[?])(using
         display: Show[ScopedKey[?]]
     ): Seq[ScopedKey[?]] =
       relation(structure, actual)(using display).all.toSeq flatMap { (a, b) =>
-        if (b.key == key) List[ScopedKey[?]](a) else Nil
+        if b.key == key then List[ScopedKey[?]](a) else Nil
       }
 
     def reverseDependencies(
         cMap: Map[ScopedKey[?], Flattened],
         scoped: ScopedKey[?]
     ): Iterable[ScopedKey[?]] =
-      for {
+      for
         (key, compiled) <- cMap
         dep <- compiled.dependencies if dep == scoped
-      } yield key
+      yield key
 
     /*
     def setAll(extracted: Extracted, settings: Seq[Def.Setting[_]]): SessionSettings =
@@ -615,23 +611,20 @@ trait ProjectExtra extends Scoped.Syntax:
     private[sbt] def transitiveInterDependencies(
         state: State,
         projectRef: ProjectRef
-    ): Seq[ProjectRef] = {
-      def dependencies(map: Map[ProjectRef, Seq[ProjectRef]], id: ProjectRef): Set[ProjectRef] = {
+    ): Seq[ProjectRef] =
+      def dependencies(map: Map[ProjectRef, Seq[ProjectRef]], id: ProjectRef): Set[ProjectRef] =
         @tailrec
         def helper(map: Map[ProjectRef, Seq[ProjectRef]], acc: Set[ProjectRef]): Set[ProjectRef] =
-          if (acc.exists(map.contains)) {
+          if acc.exists(map.contains) then
             val (kept, rem) = map.partition { case (k, _) => acc(k) }
             helper(rem, acc ++ kept.valuesIterator.flatten)
-          } else acc
+          else acc
         helper(map - id, map.getOrElse(id, Nil).toSet)
-      }
       val allProjectsDeps: Map[ProjectRef, Seq[ProjectRef]] =
-        (for {
-          (p, ref) <- Project.structure(state).allProjectPairs
-        } yield ref -> p.dependencies.map(_.project)).toMap
+        (for (p, ref) <- Project.structure(state).allProjectPairs
+        yield ref -> p.dependencies.map(_.project)).toMap
       val deps = dependencies(allProjectsDeps.toMap, projectRef)
       Project.structure(state).allProjectRefs.filter(p => deps(p))
-    }
 
     def projectReturn(s: State): List[File] = getOrNil(s, projectReturnKey)
     def inPluginProject(s: State): Boolean = projectReturn(s).length > 1
@@ -688,6 +681,7 @@ trait ProjectExtra extends Scoped.Syntax:
     def projectToRef(p: Project): ProjectReference = LocalProject(p.id)
 
      */
+  end extension
 
   given projectToLocalProject: Conversion[Project, LocalProject] =
     (p: Project) => LocalProject(p.id)
@@ -727,6 +721,7 @@ trait ProjectExtra extends Scoped.Syntax:
             SessionVar.set(SessionVar.resolveContext(key, scoped.scope, state), state, value)
         )
       }
+  end extension
 
   /**
    * implicitly injected to tasks that return PromiseWrap.
@@ -740,12 +735,10 @@ trait ProjectExtra extends Scoped.Syntax:
           var result: Option[A1] = None
           if atMost == Duration.Inf then
             while result.isEmpty do
-              try {
+              try
                 result = Some(Await.result(p.underlying.future, Duration("1s")))
                 Thread.sleep(10)
-              } catch {
-                case _: TimeoutException => ()
-              }
+              catch case _: TimeoutException => ()
           else result = Some(Await.result(p.underlying.future, atMost))
           result.get
         })
diff --git a/main/src/main/scala/sbt/ProjectMatrix.scala b/main/src/main/scala/sbt/ProjectMatrix.scala
index 2a8336997..07197dd72 100644
--- a/main/src/main/scala/sbt/ProjectMatrix.scala
+++ b/main/src/main/scala/sbt/ProjectMatrix.scala
@@ -29,7 +29,7 @@ import scala.util.Try
  *    .jvmPlatform(Seq("2.12.6", "2.11.12"))
  *  }}}
  */
-sealed trait ProjectMatrix extends CompositeProject {
+sealed trait ProjectMatrix extends CompositeProject:
   def id: String
 
   /** The base directory for the project matrix. */
@@ -211,22 +211,20 @@ sealed trait ProjectMatrix extends CompositeProject {
 
   // resolve to the closest match for the given row
   private[sbt] def resolveMatch(thatRow: ProjectMatrix.ProjectRow): ProjectReference
-}
+end ProjectMatrix
 
 /**
  * Represents a reference to a project matrix with an optional configuration string.
  */
-sealed trait MatrixClasspathDep[MR <: ProjectMatrixReference] {
+sealed trait MatrixClasspathDep[MR <: ProjectMatrixReference]:
   def matrix: MR; def configuration: Option[String]
-}
 
-trait ProjectFinder {
+trait ProjectFinder:
   def apply(scalaVersion: String): Project
   def apply(autoScalaLibrary: Boolean): Project
   def get: Seq[Project]
-}
 
-object ProjectMatrix {
+object ProjectMatrix:
   import sbt.io.syntax.*
 
   val jvmIdSuffix: String = "JVM"
@@ -245,9 +243,9 @@ object ProjectMatrix {
       val autoScalaLibrary: Boolean,
       val axisValues: Seq[VirtualAxis],
       val process: Project => Project
-  ) {
+  ):
     def scalaVersionOpt: Option[String] =
-      if (autoScalaLibrary)
+      if autoScalaLibrary then
         axisValues collectFirst { case sv: VirtualAxis.ScalaVersionAxis =>
           sv.scalaVersion
         }
@@ -271,15 +269,14 @@ object ProjectMatrix {
         VirtualAxis.isPartialVersionEquals(da, a)
 
     override def toString: String = s"ProjectRow($autoScalaLibrary, $axisValues)"
-  }
+  end ProjectRow
 
-  final class ProjectMatrixReferenceSyntax(m: ProjectMatrixReference) {
+  final class ProjectMatrixReferenceSyntax(m: ProjectMatrixReference):
     def %(conf: String): ProjectMatrix.MatrixClasspathDependency =
       ProjectMatrix.MatrixClasspathDependency(m, Some(conf))
 
     def %(conf: Configuration): ProjectMatrix.MatrixClasspathDependency =
       ProjectMatrix.MatrixClasspathDependency(m, Some(conf.name))
-  }
 
   final case class MatrixClasspathDependency(
       matrix: ProjectMatrixReference,
@@ -301,15 +298,16 @@ object ProjectMatrix {
       val transforms: Seq[Project => Project],
       val defAxes: Seq[VirtualAxis],
       val pluginClassLoader: ClassLoader
-  ) extends ProjectMatrix { self =>
+  ) extends ProjectMatrix:
+    self =>
     lazy val resolvedMappings: ListMap[ProjectRow, Project] = resolveMappings
-    private def resolveProjectIds: Map[ProjectRow, String] = {
-      Map((for {
-        r <- rows
-      } yield r -> (self.id + r.idSuffix(defAxes)))*)
-    }
+    private def resolveProjectIds: Map[ProjectRow, String] =
+      Map(
+        (for r <- rows
+        yield r -> (self.id + r.idSuffix(defAxes)))*
+      )
 
-    private def resolveMappings: ListMap[ProjectRow, Project] = {
+    private def resolveMappings: ListMap[ProjectRow, Project] =
       val projectIds = resolveProjectIds
       val projects =
         rows.map { r =>
@@ -332,7 +330,7 @@ object ProjectMatrix {
           r -> r.process(p)
         }
       ListMap(projects*)
-    }
+    end resolveMappings
 
     override lazy val componentProjects: Seq[Project] = resolvedMappings.values.toList
 
@@ -345,21 +343,18 @@ object ProjectMatrix {
         val data = settingsData.value
         val deps = buildDependencies.value
         deps.classpath(ref) flatMap { dep =>
-          for {
+          for
             depProjId <- (dep.project / projectID).get(data)
             depSBV <- (dep.project / scalaBinaryVersion).get(data)
             depCross <- (dep.project / crossVersion).get(data)
-          } yield {
-            depCross match {
-              case b: CrossVersion.Binary if VirtualAxis.isScala2Scala3Sandwich(sbv, depSBV) =>
-                depProjId
-                  .withCrossVersion(CrossVersion.constant(depSBV))
-                  .withConfigurations(dep.configuration)
-                  .withExplicitArtifacts(Vector.empty)
-              case _ =>
-                depProjId.withConfigurations(dep.configuration).withExplicitArtifacts(Vector.empty)
-            }
-          }
+          yield depCross match
+            case b: CrossVersion.Binary if VirtualAxis.isScala2Scala3Sandwich(sbv, depSBV) =>
+              depProjId
+                .withCrossVersion(CrossVersion.constant(depSBV))
+                .withConfigurations(dep.configuration)
+                .withExplicitArtifacts(Vector.empty)
+            case _ =>
+              depProjId.withConfigurations(dep.configuration).withExplicitArtifacts(Vector.empty)
         }
       }
 
@@ -386,10 +381,10 @@ object ProjectMatrix {
         axes.filterNot(_.isInstanceOf[ScalaVersionAxis | PlatformAxis])
       )
       Def.settings(
-        r.scalaVersionOpt match {
+        r.scalaVersionOpt match
           case Some(sv) => Seq(scalaVersion := sv)
           case _        => noScalaLibrary
-        },
+        ,
         if nonScalaNorPlatformDirSuffix.nonEmpty then
           Seq(outputPath ~= (o => s"$o/$nonScalaNorPlatformDirSuffix"))
         else Seq.empty,
@@ -397,6 +392,7 @@ object ProjectMatrix {
         ProjectExtra.inConfig(Test)(makeSources(nonScalaDirSuffix, scalaDirSuffix)),
         virtualAxes := axes,
       )
+    end rowSettings
 
     private def resolveMatrixAggregate(
         other: ProjectMatrix,
@@ -407,27 +403,24 @@ object ProjectMatrix {
         dep: MatrixClasspathDep[ProjectMatrixReference],
         thisRow: ProjectRow
     ): ClasspathDep[ProjectReference] =
-      dep match {
+      dep match
         case MatrixClasspathDependency(matrix0: LocalProjectMatrix, configuration) =>
           val other = lookupMatrix(matrix0)
           ClasspathDep.ClasspathDependency(other.resolveMatch(thisRow), configuration)
-      }
 
     // resolve to the closest match for the given row
     private[sbt] def resolveMatch(thatRow: ProjectRow): ProjectReference =
       (rows.find(r => r.isMatch(thatRow)) orElse
-        rows.find(r => r.isSecondaryMatch(thatRow))) match {
+        rows.find(r => r.isSecondaryMatch(thatRow))) match
         case Some(r) => LocalProject(resolveProjectIds(r))
         case _       => sys.error(s"no rows were found in $id matching $thatRow: $rows")
-      }
 
-    private def makeSources(dirSuffix: String, svDirSuffix: String): Def.Setting[?] = {
+    private def makeSources(dirSuffix: String, svDirSuffix: String): Def.Setting[?] =
       unmanagedSourceDirectories ++= Seq(
         scalaSource.value.getParentFile / s"scala${dirSuffix}",
         scalaSource.value.getParentFile / s"scala$svDirSuffix",
         javaSource.value.getParentFile / s"java${dirSuffix}"
       )
-    }
 
     override def withId(id: String): ProjectMatrix = copy(id = id)
 
@@ -603,12 +596,11 @@ object ProjectMatrix {
     override def defaultAxes(axes: VirtualAxis*): ProjectMatrix =
       copy(defAxes = axes)
 
-    def scalajsPlugin: Try[AutoPlugin] = {
+    def scalajsPlugin: Try[AutoPlugin] =
       import ReflectionUtil.*
       withContextClassloader(pluginClassLoader) { loader =>
         getSingletonObject[AutoPlugin](loader, "org.scalajs.sbtplugin.ScalaJSPlugin$")
       }
-    }
 
     override def js: ProjectFinder = new AxisBaseProjectFinder(Seq(VirtualAxis.js))
 
@@ -687,12 +679,11 @@ object ProjectMatrix {
     override def nativePlatform(scalaVersions: Seq[String]): ProjectMatrix =
       nativePlatform(scalaVersions, Nil)
 
-    def nativePlugin: Try[AutoPlugin] = {
+    def nativePlugin: Try[AutoPlugin] =
       import ReflectionUtil.*
       withContextClassloader(pluginClassLoader) { loader =>
         getSingletonObject[AutoPlugin](loader, "scala.scalanative.sbtplugin.ScalaNativePlugin$")
       }
-    }
 
     override def projectRefs: Seq[ProjectReference] = componentProjects.map(p => LocalProject(p.id))
 
@@ -711,7 +702,7 @@ object ProjectMatrix {
           p
       }
 
-    private final class AxisBaseProjectFinder(axisValues: Seq[VirtualAxis]) extends ProjectFinder {
+    private final class AxisBaseProjectFinder(axisValues: Seq[VirtualAxis]) extends ProjectFinder:
       def get: Seq[Project] = filterProjects(axisValues)
       def apply(sv: String): Project =
         filterProjects(true, axisValues ++ Seq(VirtualAxis.scalaABIVersion(sv))).headOption
@@ -719,7 +710,6 @@ object ProjectMatrix {
       def apply(autoScalaLibrary: Boolean): Project =
         filterProjects(autoScalaLibrary, axisValues).headOption
           .getOrElse(sys.error(s"project matching $axisValues and $autoScalaLibrary was not found"))
-    }
 
     /**
      * If autoScalaLibrary is false, add non-Scala row.
@@ -746,6 +736,7 @@ object ProjectMatrix {
             else VirtualAxis.scalaABIVersion(sv)
           acc.customRow(autoScalaLibrary, axisValues ++ Seq(scalaAxis), process1)
       else customRow(autoScalaLibrary, axisValues ++ Seq(VirtualAxis.jvm), process1)
+    end customRow
 
     override def customRow(
         autoScalaLibrary: Boolean,
@@ -809,7 +800,7 @@ object ProjectMatrix {
         transforms: Seq[Project => Project] = transforms,
         defAxes: Seq[VirtualAxis] = defAxes,
         pluginClassLoader: ClassLoader = pluginClassLoader,
-    ): ProjectMatrix = {
+    ): ProjectMatrix =
       val matrix = unresolved(
         id,
         base,
@@ -828,11 +819,11 @@ object ProjectMatrix {
       )
       allMatrices(id) = matrix
       matrix
-    }
-  }
+    end copy
+  end ProjectMatrixDef
 
   // called by macro
-  def apply(id: String, base: File, pluginClassLoader: ClassLoader): ProjectMatrix = {
+  def apply(id: String, base: File, pluginClassLoader: ClassLoader): ProjectMatrix =
     val defaultDefAxes = Seq(VirtualAxis.jvm, VirtualAxis.scalaABIVersion("3.3.3"))
     val matrix = unresolved(
       id,
@@ -852,7 +843,6 @@ object ProjectMatrix {
     )
     allMatrices(id) = matrix
     matrix
-  }
 
   private[sbt] def unresolved(
       id: String,
@@ -887,9 +877,8 @@ object ProjectMatrix {
       pluginClassLoader
     )
 
-  def lookupMatrix(local: LocalProjectMatrix): ProjectMatrix = {
+  def lookupMatrix(local: LocalProjectMatrix): ProjectMatrix =
     allMatrices.getOrElse(local.id, sys.error(s"${local.id} was not found"))
-  }
 
   implicit def projectMatrixToLocalProjectMatrix(m: ProjectMatrix): LocalProjectMatrix =
     LocalProjectMatrix(m.id)
@@ -899,7 +888,7 @@ object ProjectMatrix {
       Try {
         val clazz = classLoader.loadClass(className)
         val t = implicitly[ClassTag[A]].runtimeClass
-        Option(clazz.getField("MODULE$").get(null)) match {
+        Option(clazz.getField("MODULE$").get(null)) match
           case None =>
             throw new ClassNotFoundException(
               s"Unable to find $className using classloader: $classLoader"
@@ -907,7 +896,6 @@ object ProjectMatrix {
           case Some(c) if !t.isInstance(c) =>
             throw new ClassCastException(s"${clazz.getName} is not a subtype of $t")
           case Some(c) => c.asInstanceOf[A]
-        }
       }
         .recover {
           case i: InvocationTargetException if i.getTargetException != null =>
@@ -915,29 +903,24 @@ object ProjectMatrix {
         }
 
     def objectExists(classLoader: ClassLoader, className: String): Boolean =
-      try {
-        classLoader.loadClass(className).getField("MODULE$").get(null) != null
-      } catch {
-        case _: Throwable => false
-      }
+      try classLoader.loadClass(className).getField("MODULE$").get(null) != null
+      catch case _: Throwable => false
 
-    def withContextClassloader[A](loader: ClassLoader)(body: ClassLoader => A): A = {
+    def withContextClassloader[A](loader: ClassLoader)(body: ClassLoader => A): A =
       val current = Thread.currentThread().getContextClassLoader
-      try {
+      try
         Thread.currentThread().setContextClassLoader(loader)
         body(loader)
-      } finally Thread.currentThread().setContextClassLoader(current)
-    }
+      finally Thread.currentThread().setContextClassLoader(current)
   end ReflectionUtil
 
-  def projectMatrixImpl(using Quotes): Expr[ProjectMatrix] = {
+  def projectMatrixImpl(using Quotes): Expr[ProjectMatrix] =
     val name = std.KeyMacro.definingValName(
       "projectMatrix must be directly assigned to a val, such as `val x = projectMatrix`. Alternatively, you can use `sbt.ProjectMatrix.apply`"
     )
     val callerThis = std.KeyMacro.callerThis
     '{ ProjectMatrix($name, new File($name), $callerThis.getClass.getClassLoader) }
-  }
-}
+end ProjectMatrix
 
 trait ProjectMatrixExtra:
   given Conversion[ProjectMatrix, LocalProjectMatrix] =
diff --git a/main/src/main/scala/sbt/RemoteCache.scala b/main/src/main/scala/sbt/RemoteCache.scala
index ab2f50de1..07c0de1dc 100644
--- a/main/src/main/scala/sbt/RemoteCache.scala
+++ b/main/src/main/scala/sbt/RemoteCache.scala
@@ -18,12 +18,11 @@ import sbt.util.{ CacheImplicits, DiskActionCacheStore }
 import sjsonnew.JsonFormat
 
 object RemoteCache:
-  private[sbt] def artifactToStr(art: Artifact): String = {
+  private[sbt] def artifactToStr(art: Artifact): String =
     import LibraryManagementCodec.given
     import sjsonnew.support.scalajson.unsafe.*
     val format: JsonFormat[Artifact] = summon[JsonFormat[Artifact]]
     CompactPrinter(Converter.toJsonUnsafe(art)(using format))
-  }
 
   lazy val defaultCacheLocation: File = SysProp.globalLocalCache
 
diff --git a/main/src/main/scala/sbt/RepositoryUpdateStrategy.scala b/main/src/main/scala/sbt/RepositoryUpdateStrategy.scala
index 2d8b6b7d1..4286a4aff 100644
--- a/main/src/main/scala/sbt/RepositoryUpdateStrategy.scala
+++ b/main/src/main/scala/sbt/RepositoryUpdateStrategy.scala
@@ -16,7 +16,7 @@ import scala.concurrent.duration.FiniteDuration
  * Used with the `repositoryUpdateStrategy` setting key to control when
  * remote project dependencies are updated from their upstream repositories.
  */
-enum RepositoryUpdateStrategy {
+enum RepositoryUpdateStrategy:
 
   /**
    * Never update automatically.
@@ -29,5 +29,3 @@ enum RepositoryUpdateStrategy {
 
   /** Update at most once per the given interval. */
   case Every(interval: FiniteDuration)
-
-}
diff --git a/main/src/main/scala/sbt/Resolvers.scala b/main/src/main/scala/sbt/Resolvers.scala
index fae053e1a..fd0c2f7a9 100644
--- a/main/src/main/scala/sbt/Resolvers.scala
+++ b/main/src/main/scala/sbt/Resolvers.scala
@@ -25,46 +25,44 @@ import sbt.internal.{ BuildDependencies, LoadedBuild, LoadedBuildUnit }
 import sbt.util.Logger
 import sbt.internal.{ RetrieveUnit, VcsUriFragment }
 
-object Resolvers {
+object Resolvers:
 
   private[sbt] sealed trait RemoteVcs
-  private[sbt] object RemoteVcs {
+  private[sbt] object RemoteVcs:
     case class Git(uri: URI) extends RemoteVcs
     case class Hg(uri: URI) extends RemoteVcs
     case class Svn(uri: URI) extends RemoteVcs
-  }
 
   private val LastUpdatedFileName = ".sbt-last-updated"
 
   type Resolver = BuildLoader.Resolver
 
-  val local: Resolver = (info: ResolveInfo) => {
+  val local: Resolver = (info: ResolveInfo) =>
     val uri = info.uri
     val from = new File(uri)
     val to = uniqueSubdirectoryFor(uri, in = info.staging)
 
-    if (from.isDirectory) Some { () =>
-      if (from.canWrite) from else creates(to) { IO.copyDirectory(from, to) }
-    }
+    if from.isDirectory then
+      Some { () =>
+        if from.canWrite then from else creates(to) { IO.copyDirectory(from, to) }
+      }
     else None
-  }
 
-  val remote: Resolver = (info: ResolveInfo) => {
+  val remote: Resolver = (info: ResolveInfo) =>
     val url = info.uri.toURL
     val to = uniqueSubdirectoryFor(info.uri, in = info.staging)
 
     Some { () =>
       creates(to) { IO.unzipURL(url, to); () }
     }
-  }
 
-  val subversion: Resolver = (info: ResolveInfo) => {
+  val subversion: Resolver = (info: ResolveInfo) =>
     val uri = info.uri.withoutMarkerScheme
     val localCopy = uniqueSubdirectoryFor(uri.copy(scheme = "svn"), in = info.staging)
     val from = uri.withoutFragment.toASCIIString
     val to = localCopy.getAbsolutePath
 
-    if (uri.hasFragment) {
+    if uri.hasFragment then
       val revision = uri.getFragment
       VcsUriFragment.validate(revision)
       Some { () =>
@@ -72,20 +70,19 @@ object Resolvers {
           run(cwd = None, log = None, "svn", "checkout", "-q", "-r", revision, from, to)
         }
       }
-    } else
+    else
       Some { () =>
         creates(localCopy) {
           run(cwd = None, log = None, "svn", "checkout", "-q", from, to)
         }
       }
-  }
 
-  val mercurial: Resolver = (info: ResolveInfo) => {
+  val mercurial: Resolver = (info: ResolveInfo) =>
     val uri = info.uri.withoutMarkerScheme
     val localCopy = uniqueSubdirectoryFor(uri.copy(scheme = "hg"), in = info.staging)
     val from = uri.withoutFragment.toASCIIString
 
-    if (uri.hasFragment) {
+    if uri.hasFragment then
       val branch = uri.getFragment
       VcsUriFragment.validate(branch)
       Some { () =>
@@ -94,20 +91,19 @@ object Resolvers {
           run(Some(localCopy), log = None, "hg", "checkout", "-q", branch)
         }
       }
-    } else
+    else
       Some { () =>
         creates(localCopy) {
           run(cwd = None, log = None, "hg", "clone", "-q", from, localCopy.getAbsolutePath)
         }
       }
-  }
 
-  val git: Resolver = (info: ResolveInfo) => {
+  val git: Resolver = (info: ResolveInfo) =>
     val uri = info.uri.withoutMarkerScheme
     val localCopy = uniqueSubdirectoryFor(uri.copy(scheme = "git"), in = info.staging)
     val from = uri.withoutFragment.toASCIIString
 
-    if (uri.hasFragment) {
+    if uri.hasFragment then
       val branch = uri.getFragment
       VcsUriFragment.validate(branch)
       Some { () =>
@@ -116,7 +112,7 @@ object Resolvers {
           run(Some(localCopy), log = None, "git", "checkout", "-q", branch)
         }
       }
-    } else
+    else
       Some { () =>
         creates(localCopy) {
           run(
@@ -131,42 +127,36 @@ object Resolvers {
           )
         }
       }
-  }
+    end if
 
-  private def run(cwd: Option[File], log: Option[Logger], command: String*): Unit = {
+  private def run(cwd: Option[File], log: Option[Logger], command: String*): Unit =
     val process = Process(command, cwd)
-    val result = (log match {
+    val result = (log match
       case Some(log) =>
         val io = BasicIO(false, log).withInput(_.close())
         process.run(io).exitValue()
       case None =>
         process.run().exitValue()
-    })
+    )
 
-    if (result != 0)
-      sys.error("Nonzero exit code (" + result + "): " + command.mkString(" "))
-  }
+    if result != 0 then sys.error("Nonzero exit code (" + result + "): " + command.mkString(" "))
 
-  private def creates(file: File)(f: => Unit): File = {
-    if (!file.exists)
-      try {
-        f
-      } catch {
+  private def creates(file: File)(f: => Unit): File =
+    if !file.exists then
+      try f
+      catch
         case NonFatal(e) =>
           IO.delete(file)
           throw e
-      }
     file
-  }
 
-  private def uniqueSubdirectoryFor(uri: URI, in: File): File = {
+  private def uniqueSubdirectoryFor(uri: URI, in: File): File =
     in.mkdirs()
     val base = new File(in, Hash.halfHashString(uri.normalize.toASCIIString))
-    val last = shortName(uri) match {
-      case Some(n) => normalizeDirectoryName(n); case None => "root"
-    }
+    val last = shortName(uri) match
+      case Some(n) => normalizeDirectoryName(n);
+      case None    => "root"
     new File(base, last)
-  }
 
   private def shortName(uri: URI): Option[String] =
     Option(uri.withoutMarkerScheme.getPath).flatMap {
@@ -178,49 +168,43 @@ object Resolvers {
 
   private def dropExtensions(name: String): String = name.takeWhile(_ != '.')
 
-  private def markUpdated(dir: File): Unit = {
+  private def markUpdated(dir: File): Unit =
     val marker = new File(dir, LastUpdatedFileName)
     IO.write(marker, System.currentTimeMillis().toString)
-  }
 
   private[sbt] def shouldUpdate(dir: File, strategy: RepositoryUpdateStrategy): Boolean =
-    strategy match {
+    strategy match
       case RepositoryUpdateStrategy.Manual          => false
       case RepositoryUpdateStrategy.Always          => true
       case RepositoryUpdateStrategy.Every(interval) =>
         val marker = new File(dir, LastUpdatedFileName)
-        if (!marker.exists()) true
-        else {
-          try {
+        if !marker.exists() then true
+        else
+          try
             val lastUpdated = IO.read(marker).trim.toLong
             val elapsed = System.currentTimeMillis() - lastUpdated
             elapsed >= interval.toMillis
-          } catch {
-            case NonFatal(_) => true
-          }
-        }
-    }
+          catch case NonFatal(_) => true
 
   private[sbt] def updateLoadedBuild(
       lb: LoadedBuild,
       log: Logger,
       extracted: Extracted,
       force: Boolean
-  ): Boolean = {
-    def needsUpdate(uri: URI, unit: LoadedBuildUnit): Boolean = {
+  ): Boolean =
+    def needsUpdate(uri: URI, unit: LoadedBuildUnit): Boolean =
       val rootProjectId = unit.rootProjects.headOption.getOrElse("root")
       val projectRef = ProjectRef(uri, rootProjectId)
       val strategy = extracted
         .getOpt(projectRef / Keys.repositoryUpdateStrategy)
         .getOrElse(RepositoryUpdateStrategy.Manual)
       shouldUpdate(unit.localBase, strategy)
-    }
 
     log.info("Updating remote repos")
-    val repos = (for {
+    val repos = (for
       (uri, unit) <- lb.units if unit.localBase.exists()
       vcs <- RetrieveUnit(uri) if force || needsUpdate(uri, unit)
-    } yield (unit.localBase, vcs))
+    yield (unit.localBase, vcs))
 
     val isUpdated = repos.foldLeft(false) { case (acc, (repo, vcs)) =>
       log.info(s"Updating remote project: $repo ...")
@@ -228,131 +212,118 @@ object Resolvers {
     }
 
     isUpdated
-  }
+  end updateLoadedBuild
 
   private[sbt] def transitiveVcsRootRefs(
       startRef: ProjectRef,
       buildDependencies: BuildDependencies,
       lb: LoadedBuild
   ): Set[ProjectRef] =
-    for {
+    for
       uri <- collectTransitiveRemoteBuildURIs(startRef, buildDependencies)
       if RetrieveUnit(uri).isDefined
       unit <- lb.units.get(uri)
       rootId = unit.rootProjects.headOption.getOrElse("root")
-    } yield ProjectRef(uri, rootId)
+    yield ProjectRef(uri, rootId)
 
   private def collectTransitiveRemoteBuildURIs(
       startRef: ProjectRef,
       buildDeps: BuildDependencies
-  ): Set[URI] = {
+  ): Set[URI] =
     @annotation.tailrec
     def go(
         queue: List[ProjectRef],
         visited: Set[ProjectRef],
         result: Set[URI]
     ): Set[URI] =
-      queue match {
+      queue match
         case Nil         => result
         case ref :: rest =>
-          if (visited.contains(ref)) go(rest, visited, result)
-          else {
+          if visited.contains(ref) then go(rest, visited, result)
+          else
             val classpathDeps = buildDeps.classpath.getOrElse(ref, Nil).map(_.project)
             val aggregateDeps = buildDeps.aggregate.getOrElse(ref, Nil)
             val allDeps = classpathDeps ++ aggregateDeps
             val newResult = allDeps.foldLeft(result) { (acc, dep) =>
-              if (dep.build != startRef.build) acc + dep.build else acc
+              if dep.build != startRef.build then acc + dep.build else acc
             }
             go(allDeps.toList ::: rest, visited + ref, newResult)
-          }
-      }
     go(List(startRef), Set.empty, Set.empty)
-  }
+  end collectTransitiveRemoteBuildURIs
 
   private[sbt] def updateRepository(localCopy: File, uri: URI, log: Logger): Boolean =
-    RetrieveUnit(uri) match {
+    RetrieveUnit(uri) match
       case Some(vcs) => updateRepository(localCopy, vcs, log)
       case None      => false
-    }
 
   private[sbt] def updateRepository(localCopy: File, vcs: RemoteVcs, log: Logger): Boolean =
-    vcs match {
+    vcs match
       case RemoteVcs.Git(uri) => updateGit(localCopy, uri, log)
       case RemoteVcs.Hg(uri)  => updateMercurial(localCopy, uri, log)
       case RemoteVcs.Svn(uri) => updateSubversion(localCopy, uri, log)
-    }
 
   private def updateGit(localCopy: File, uri: URI, log: Logger): Boolean =
-    try {
+    try
       val status = captureOutput(Some(localCopy), "git", "status", "--porcelain", "-uno")
-      if (status.nonEmpty) {
+      if status.nonEmpty then
         log.warn(
           s"Skipping update of $localCopy: uncommitted changes detected. " +
             "Commit or discard them before updating."
         )
         false
-      } else {
+      else
         val headBefore = captureOutput(Some(localCopy), "git", "rev-parse", "HEAD")
-        val ref = if (fromURI(uri).hasFragment) {
+        val ref = if fromURI(uri).hasFragment then
           val f = uri.getFragment
           VcsUriFragment.validate(f)
           f
-        } else "HEAD"
+        else "HEAD"
         run(Some(localCopy), Some(log), "git", "fetch", "origin", ref)
         run(Some(localCopy), Some(log), "git", "reset", "--hard", "FETCH_HEAD")
         markUpdated(localCopy)
         captureOutput(Some(localCopy), "git", "rev-parse", "HEAD") != headBefore
-      }
-    } catch {
+    catch
       case NonFatal(e) =>
         log.error(
           s"Failed to update git repository at $localCopy: ${e.getMessage}"
         )
         throw e
-    }
 
   private def captureOutput(cwd: Option[File], command: String*): String =
     Process(command, cwd).!!.trim
 
   private def updateMercurial(localCopy: File, uri: URI, log: Logger): Boolean =
-    try {
+    try
       val idBefore = captureOutput(Some(localCopy), "hg", "id", "-i")
-      if (fromURI(uri).hasFragment) {
+      if fromURI(uri).hasFragment then
         val branch = uri.getFragment
         VcsUriFragment.validate(branch)
         run(Some(localCopy), Some(log), "hg", "pull")
         run(Some(localCopy), Some(log), "hg", "update", branch)
-      } else {
-        run(Some(localCopy), Some(log), "hg", "pull", "-u")
-      }
+      else run(Some(localCopy), Some(log), "hg", "pull", "-u")
       markUpdated(localCopy)
       captureOutput(Some(localCopy), "hg", "id", "-i") != idBefore
-    } catch {
+    catch
       case NonFatal(e) =>
         log.error(
           s"Failed to update mercurial repository at $localCopy: ${e.getMessage}"
         )
         throw e
-    }
 
   private def updateSubversion(localCopy: File, uri: URI, log: Logger): Boolean =
-    try {
+    try
       val revBefore = captureOutput(Some(localCopy), "svn", "info", "--show-item", "revision")
-      if (fromURI(uri).hasFragment) {
+      if fromURI(uri).hasFragment then
         val revision = uri.getFragment
         VcsUriFragment.validate(revision)
         run(Some(localCopy), Some(log), "svn", "update", "-q", "-r", revision)
-      } else {
-        run(Some(localCopy), Some(log), "svn", "update", "-q")
-      }
+      else run(Some(localCopy), Some(log), "svn", "update", "-q")
       markUpdated(localCopy)
       captureOutput(Some(localCopy), "svn", "info", "--show-item", "revision") != revBefore
-    } catch {
+    catch
       case NonFatal(e) =>
         log.error(
           s"Failed to update subversion working copy at $localCopy: ${e.getMessage}"
         )
         throw e
-    }
-
-}
+end Resolvers
diff --git a/main/src/main/scala/sbt/RichURI.scala b/main/src/main/scala/sbt/RichURI.scala
index d3260744c..4df031c69 100644
--- a/main/src/main/scala/sbt/RichURI.scala
+++ b/main/src/main/scala/sbt/RichURI.scala
@@ -11,7 +11,7 @@ package sbt
 import java.net.URI
 
 /** Extends `URI` with additional convenience methods. */
-class RichURI(uri: URI) {
+class RichURI(uri: URI):
 
   /**
    * Provides a case-class-like `copy` method for URI.
@@ -34,10 +34,8 @@ class RichURI(uri: URI) {
 
   /** Returns a copy of the URI without the fragment. */
   def withoutFragment =
-    if (hasFragment)
-      new URI(uri.getScheme, uri.getSchemeSpecificPart, null)
-    else
-      uri
+    if hasFragment then new URI(uri.getScheme, uri.getSchemeSpecificPart, null)
+    else uri
 
   /** Returns `true` if the scheme specific part of the URI is also a valid URI. */
   def hasMarkerScheme = new URI(uri.getRawSchemeSpecificPart).getScheme ne null
@@ -47,19 +45,14 @@ class RichURI(uri: URI) {
    * If the URI has a fragment, the fragment is transferred to the wrapped URI.
    * If this URI does not have a marker scheme, it is returned unchanged.
    */
-  def withoutMarkerScheme = {
-    if (hasMarkerScheme)
-      if (hasFragment)
-        new URI(uri.getRawSchemeSpecificPart + "#" + uri.getRawFragment)
-      else
-        new URI(uri.getRawSchemeSpecificPart)
-    else
-      uri
-  }
-}
+  def withoutMarkerScheme =
+    if hasMarkerScheme then
+      if hasFragment then new URI(uri.getRawSchemeSpecificPart + "#" + uri.getRawFragment)
+      else new URI(uri.getRawSchemeSpecificPart)
+    else uri
+end RichURI
 
-object RichURI {
+object RichURI:
 
   /** Provides additional convenience methods for `uri`. */
   implicit def fromURI(uri: URI): RichURI = new RichURI(uri)
-}
diff --git a/main/src/main/scala/sbt/ScopeFilter.scala b/main/src/main/scala/sbt/ScopeFilter.scala
index 28f9c4e80..93cd89f91 100644
--- a/main/src/main/scala/sbt/ScopeFilter.scala
+++ b/main/src/main/scala/sbt/ScopeFilter.scala
@@ -16,7 +16,8 @@ import Def.Initialize
 import sbt.ScopeAxis.{ Select, This, Zero }
 import java.net.URI
 
-sealed abstract class ScopeFilter { self =>
+sealed abstract class ScopeFilter:
+  self =>
 
   /** Implements this filter. */
   private[ScopeFilter] def apply(data: ScopeFilter.Data): Set[Scope]
@@ -41,9 +42,9 @@ sealed abstract class ScopeFilter { self =>
   /** Constructs a filter that selects values that do not match this filter. */
   def unary_- : ScopeFilter = new ScopeFilter:
     def apply(data: ScopeFilter.Data): Set[Scope] = data.allScopes.set -- self(data)
-}
+end ScopeFilter
 
-object ScopeFilter {
+object ScopeFilter:
   type ProjectFilter = AxisFilter[Reference]
   type ConfigurationFilter = AxisFilter[ConfigKey]
   type TaskFilter = AxisFilter[AttributeKey[?]]
@@ -82,12 +83,12 @@ object ScopeFilter {
         val cf = configurations(data)
         val tf = tasks(data)
         val res =
-          for {
+          for
             (project, configs) <- data.allScopes.grouped.iterator if pf(project)
             (config, tasks) <- configs.iterator if cf(config)
             (task, scopes) <- tasks.iterator if tf(task)
             scope <- scopes
-          } yield scope
+          yield scope
         res.toSet
 
       override private[ScopeFilter] def scopeOrdering(data: Data): Scope => Option[Int] =
@@ -213,7 +214,7 @@ object ScopeFilter {
         s"${other.getClass.getName}(${other.toString})"
 
   private[sbt] val Make = new Make {}
-  trait Make {
+  trait Make:
 
     /** Selects Scopes with a Zero task axis. */
     def inZeroTask: TaskFilter = zeroAxis[AttributeKey[?]]
@@ -282,31 +283,27 @@ object ScopeFilter {
       ScopeFilter.inProjects(projects*)
 
     /** Selects Scopes that have a task axis with one of the provided values. */
-    def inTasks(tasks: Scoped*): TaskFilter = {
+    def inTasks(tasks: Scoped*): TaskFilter =
       val ts = tasks.map(_.key).toSet
       selectAxis[AttributeKey[?]](const(ts))
-    }
 
     /** Selects Scopes that have a task axis with one of the provided values. */
-    def inConfigurations(configs: Configuration*): ConfigurationFilter = {
+    def inConfigurations(configs: Configuration*): ConfigurationFilter =
       val cs = configs.map(_.name).toSet
       selectAxis[ConfigKey](const(c => cs(c.name)))
-    }
 
-    def inConfigurationsByKeys(keys: ConfigKey*): ConfigurationFilter = {
+    def inConfigurationsByKeys(keys: ConfigKey*): ConfigurationFilter =
       val cs = keys.toSet
       selectAxis[ConfigKey](const(cs))
-    }
 
-    def inConfigurationsByRefs(refs: ConfigRef*): ConfigurationFilter = {
+    def inConfigurationsByRefs(refs: ConfigRef*): ConfigurationFilter =
       val cs = refs.map(r => ConfigKey(r.name)).toSet
       selectAxis[ConfigKey](const(cs))
-    }
 
     implicit def settingKeyAll[T](key: Initialize[T]): SettingKeyAll[T] =
       new SettingKeyAll[T](key)
     implicit def taskKeyAll[T](key: Initialize[Task[T]]): TaskKeyAll[T] = new TaskKeyAll[T](key)
-  }
+  end Make
 
   private[sbt] final class AllScopes(val set: Set[Scope], val grouped: ScopeMap)
 
@@ -337,16 +334,14 @@ object ScopeFilter {
       val build = Keys.loadedBuild.value
       val scopes = Keys.allScopes.value
       val thisRef = Keys.thisProjectRef.?.value
-      val current = thisRef match {
+      val current = thisRef match
         case Some(ProjectRef(uri, _)) => uri
         case None                     => build.root
-      }
       val rootProject = Load.getRootProject(build.units)
       val resolve: ProjectReference => ProjectRef = p =>
-        (p, thisRef) match {
+        (p, thisRef) match
           case (ThisProject, Some(pref)) => pref
           case _                         => Scope.resolveProjectRef(current, rootProject, p)
-        }
       new Data(build.units, resolve, scopes)
     }
 
@@ -358,8 +353,8 @@ object ScopeFilter {
     ref =>
       import sbt.ProjectExtra.getProject
       Project.getProject(ref, structure).toList flatMap { p =>
-        (if (classpath) p.dependencies.map(_.project) else Nil) ++
-          (if (aggregate) p.aggregate else Nil)
+        (if classpath then p.dependencies.map(_.project) else Nil) ++
+          (if aggregate then p.aggregate else Nil)
       }
 
   private def byDeps(
@@ -372,13 +367,12 @@ object ScopeFilter {
     inResolvedProjects { data =>
       val resolvedRef = data.resolve(ref)
       val direct = getDependencies(data.units, classpath = classpath, aggregate = aggregate)
-      if (transitive) {
+      if transitive then
         val full = Dag.topologicalSort(resolvedRef)(direct)
-        if (includeRoot) full else full dropRight 1
-      } else {
+        if includeRoot then full else full dropRight 1
+      else
         val directDeps = direct(resolvedRef)
-        if (includeRoot) resolvedRef +: directDeps else directDeps
-      }
+        if includeRoot then resolvedRef +: directDeps else directDeps
     }
 
   private def inProjects(projects: ProjectReference*): ProjectFilter =
@@ -400,22 +394,19 @@ object ScopeFilter {
           case Select(ref: ProjectRef) => index.get(ref)
           case _                       => None
 
-  private def zeroAxis[T]: AxisFilter[T] = new AxisFilter[T] {
+  private def zeroAxis[T]: AxisFilter[T] = new AxisFilter[T]:
     private[sbt] def apply(data: Data): ScopeAxis[T] => Boolean = _ == Zero
-  }
   private def selectAny[T]: AxisFilter[T] = selectAxis(const(const(true)))
-  private def selectAxis[T](f: Data => T => Boolean): AxisFilter[T] = new AxisFilter[T] {
-    private[sbt] def apply(data: Data): ScopeAxis[T] => Boolean = {
+  private def selectAxis[T](f: Data => T => Boolean): AxisFilter[T] = new AxisFilter[T]:
+    private[sbt] def apply(data: Data): ScopeAxis[T] => Boolean =
       val g = f(data)
-      _ match {
+      _ match
         case Select(t) => g(t)
         case _         => false
-      }
-    }
-  }
 
   /** Base functionality for filters on axis of type `In` that need access to build data. */
-  sealed abstract class AxisFilter[In] { self =>
+  sealed abstract class AxisFilter[In]:
+    self =>
 
     /** Implements this filter. */
     private[ScopeFilter] def apply(data: Data): ScopeAxis[In] => Boolean
@@ -429,30 +420,23 @@ object ScopeFilter {
     def --(other: AxisFilter[In]): AxisFilter[In] = this && -other
 
     /** Constructs a filter that selects values that match this filter and `other`. */
-    def &&(other: AxisFilter[In]): AxisFilter[In] = new AxisFilter[In] {
-      private[sbt] def apply(data: Data): ScopeAxis[In] => Boolean = {
+    def &&(other: AxisFilter[In]): AxisFilter[In] = new AxisFilter[In]:
+      private[sbt] def apply(data: Data): ScopeAxis[In] => Boolean =
         val a = self(data)
         val b = other(data)
         s => a(s) && b(s)
-      }
-    }
 
     /** Constructs a filter that selects values that match this filter or `other`. */
-    def ||(other: AxisFilter[In]): AxisFilter[In] = new AxisFilter[In] {
-      private[sbt] def apply(data: Data): ScopeAxis[In] => Boolean = {
+    def ||(other: AxisFilter[In]): AxisFilter[In] = new AxisFilter[In]:
+      private[sbt] def apply(data: Data): ScopeAxis[In] => Boolean =
         val a = self(data)
         val b = other(data)
         s => a(s) || b(s)
-      }
-    }
 
     /** Constructs a filter that selects values that do not match this filter. */
-    def unary_- : AxisFilter[In] = new AxisFilter[In] {
-      private[sbt] def apply(data: Data): ScopeAxis[In] => Boolean = {
+    def unary_- : AxisFilter[In] = new AxisFilter[In]:
+      private[sbt] def apply(data: Data): ScopeAxis[In] => Boolean =
         val a = self(data)
         s => !a(s)
-      }
-    }
-  }
-
-}
+  end AxisFilter
+end ScopeFilter
diff --git a/main/src/main/scala/sbt/ScopedKeyData.scala b/main/src/main/scala/sbt/ScopedKeyData.scala
index 4c4d5a48a..f14f01edc 100644
--- a/main/src/main/scala/sbt/ScopedKeyData.scala
+++ b/main/src/main/scala/sbt/ScopedKeyData.scala
@@ -11,7 +11,7 @@ package sbt
 import Def.ScopedKey
 import sbt.internal.util.KeyTag
 
-final case class ScopedKeyData[A](key: ScopedKey[A], definingKey: ScopedKey[A], value: Any) {
+final case class ScopedKeyData[A](key: ScopedKey[A], definingKey: ScopedKey[A], value: Any):
   def typeName: String = key.key.tag.toString
   def settingValue: Option[Any] =
     key.key.tag match
@@ -23,4 +23,3 @@ final case class ScopedKeyData[A](key: ScopedKey[A], definingKey: ScopedKey[A],
       case KeyTag.SeqTask(typeArg)   => s"Task: Seq[$typeArg]"
       case KeyTag.InputTask(typeArg) => s"Input task: $typeArg"
       case KeyTag.Setting(typeArg)   => s"Setting: $typeArg = $value"
-}
diff --git a/main/src/main/scala/sbt/ScriptedPlugin.scala b/main/src/main/scala/sbt/ScriptedPlugin.scala
index 7a0f44853..654127f6d 100644
--- a/main/src/main/scala/sbt/ScriptedPlugin.scala
+++ b/main/src/main/scala/sbt/ScriptedPlugin.scala
@@ -27,9 +27,9 @@ import sbt.librarymanagement.syntax.*
 import sbt.nio.file.{ Glob, RecursiveGlob }
 import scala.jdk.CollectionConverters.*
 
-object ScriptedPlugin extends AutoPlugin {
+object ScriptedPlugin extends AutoPlugin:
 
-  object autoImport {
+  object autoImport:
     val ScriptedConf = Configurations.config("scripted-sbt").hide
     val ScriptedLaunchConf = Configurations.config("scripted-sbt-launch").hide
 
@@ -53,7 +53,7 @@ object ScriptedPlugin extends AutoPlugin {
       )
     val scriptedDependencies = taskKey[Unit]("")
     val scripted = inputKey[Unit]("")
-  }
+  end autoImport
   import autoImport.*
 
   override lazy val globalSettings: Seq[Setting[?]] = Seq(
@@ -84,10 +84,9 @@ object ScriptedPlugin extends AutoPlugin {
       val binVersion = CrossVersionUtil.binarySbtVersion(scriptedSbt.value)
       val versionParts =
         binVersion.split("\\.").flatMap(p => p.takeWhile(_.isDigit).toIntOption).take(2)
-      versionParts match {
+      versionParts match
         case Array(major, minor) => major > 1 || (major == 1 && minor >= 4)
         case _                   => false
-      }
     },
     scriptedRun := Def.uncached(scriptedRunTask.value),
     scriptedDependencies := Def.uncached {
@@ -104,12 +103,10 @@ object ScriptedPlugin extends AutoPlugin {
     Def.task {
       val cp = scriptedClasspath.value.get().map(_.toPath)
       val loader = ClasspathUtil.toLoader(cp, scalaInstance.value.loader)
-      try {
-        ModuleUtilities.getObject("sbt.scriptedtest.ScriptedTests", loader)
-      } catch {
+      try ModuleUtilities.getObject("sbt.scriptedtest.ScriptedTests", loader)
+      catch
         case _: ClassNotFoundException =>
           ModuleUtilities.getObject("sbt.test.ScriptedTests", loader)
-      }
     }
 
   private[sbt] def scriptedRunTask: Initialize[Task[ScriptedRun]] = Def.task {
@@ -118,7 +115,7 @@ object ScriptedPlugin extends AutoPlugin {
 
   private[sbt] final case class ScriptedTestPage(page: Int, total: Int)
 
-  private[sbt] def scriptedParser(scriptedBase: File): Parser[Seq[String]] = {
+  private[sbt] def scriptedParser(scriptedBase: File): Parser[Seq[String]] =
     import DefaultParsers.*
 
     val scriptedFiles: NameFilter =
@@ -135,7 +132,7 @@ object ScriptedPlugin extends AutoPlugin {
 
     // A parser for page definitions
     val pageNumber = (NatBasic & not('0', "zero page number")).flatMap { i =>
-      if (i <= pairs.size) Parser.success(i)
+      if i <= pairs.size then Parser.success(i)
       else Parser.failure(s"$i exceeds the number of tests (${pairs.size})")
     }
     val pageP: Parser[ScriptedTestPage] = ("*" ~> pageNumber ~ ("of" ~> pageNumber)) flatMap {
@@ -144,34 +141,32 @@ object ScriptedPlugin extends AutoPlugin {
     }
 
     // Grabs the filenames from a given test group in the current page definition.
-    def pagedFilenames(group: String, page: ScriptedTestPage): Seq[String] = {
+    def pagedFilenames(group: String, page: ScriptedTestPage): Seq[String] =
       val files = pairMap.get(group).toSeq.flatten.sortBy(_.toLowerCase)
       val pageSize = files.size / page.total
       // The last page may loose some values, so we explicitly keep them
       val dropped = files.drop(pageSize * (page.page - 1))
-      if (page.page == page.total) dropped
+      if page.page == page.total then dropped
       else dropped.take(pageSize)
-    }
 
-    def nameP(group: String) = {
+    def nameP(group: String) =
       token("*".id | id.examples(pairMap.getOrElse(group, Set.empty[String])))
-    }
 
     val PagedIds: Parser[Seq[String]] =
-      for {
+      for
         group <- groupP
         page <- pageP
         files = pagedFilenames(group, page)
-        // TODO -  Fail the parser if we don't have enough files for the given page size
-        // if !files.isEmpty
-      } yield files map (f => s"$group/$f")
+      // TODO -  Fail the parser if we don't have enough files for the given page size
+      // if !files.isEmpty
+      yield files map (f => s"$group/$f")
 
-    val testID = (for (group <- groupP; name <- nameP(group)) yield (group, name))
+    val testID = (for group <- groupP; name <- nameP(group) yield (group, name))
     val testIdAsGroup = matched(testID).map(test => Seq(test))
 
     // (token(Space) ~> matched(testID)).*
     (token(Space) ~> (PagedIds | testIdAsGroup)).*.map(_.flatten)
-  }
+  end scriptedParser
 
   private[sbt] def scriptedTask: Initialize[InputTask[Unit]] =
     Def.inputTask {
@@ -202,4 +197,4 @@ object ScriptedPlugin extends AutoPlugin {
         .map(_.toFile())
     )
   }
-}
+end ScriptedPlugin
diff --git a/main/src/main/scala/sbt/ScriptedRun.scala b/main/src/main/scala/sbt/ScriptedRun.scala
index c92fe57cb..c32b05ae2 100644
--- a/main/src/main/scala/sbt/ScriptedRun.scala
+++ b/main/src/main/scala/sbt/ScriptedRun.scala
@@ -14,7 +14,7 @@ import java.lang.reflect.Method
 import sbt.io.{ AllPassFilter, NothingFilter }
 import scala.jdk.CollectionConverters.*
 
-sealed trait ScriptedRun {
+sealed trait ScriptedRun:
   final def run(
       resourceBaseDirectory: File,
       bufferLog: Boolean,
@@ -24,7 +24,7 @@ sealed trait ScriptedRun {
       launchOpts: Seq[String],
       prescripted: java.util.List[File],
       instances: Int,
-  ): Unit = {
+  ): Unit =
     run(
       resourceBaseDirectory,
       bufferLog,
@@ -36,7 +36,6 @@ sealed trait ScriptedRun {
       instances,
       keepTempDirectory = false,
     )
-  }
 
   final def run(
       resourceBaseDirectory: File,
@@ -48,8 +47,8 @@ sealed trait ScriptedRun {
       prescripted: java.util.List[File],
       instances: Int,
       keepTempDirectory: Boolean,
-  ): Unit = {
-    try {
+  ): Unit =
+    try
       invoke(
         resourceBaseDirectory,
         bufferLog,
@@ -62,8 +61,7 @@ sealed trait ScriptedRun {
         keepTempDirectory,
       )
       ()
-    } catch { case e: java.lang.reflect.InvocationTargetException => throw e.getCause }
-  }
+    catch case e: java.lang.reflect.InvocationTargetException => throw e.getCause
 
   // v4
   final def run(
@@ -78,8 +76,8 @@ sealed trait ScriptedRun {
       keepTempDirectory: Boolean,
       includeFilter: JFileFilter,
       excludeFilter: JFileFilter,
-  ): Unit = {
-    try {
+  ): Unit =
+    try
       invoke(
         resourceBaseDirectory,
         bufferLog,
@@ -94,8 +92,7 @@ sealed trait ScriptedRun {
         excludeFilter,
       )
       ()
-    } catch { case e: java.lang.reflect.InvocationTargetException => throw e.getCause }
-  }
+    catch case e: java.lang.reflect.InvocationTargetException => throw e.getCause
 
   protected def invoke(
       resourceBaseDirectory: File,
@@ -106,7 +103,7 @@ sealed trait ScriptedRun {
       launchOpts: Array[String],
       prescripted: java.util.List[File],
       instances: java.lang.Integer,
-  ): AnyRef = {
+  ): AnyRef =
     invoke(
       resourceBaseDirectory,
       bufferLog,
@@ -118,7 +115,6 @@ sealed trait ScriptedRun {
       instances,
       keepTempDirectory = false,
     )
-  }
 
   protected def invoke(
       resourceBaseDirectory: File,
@@ -145,7 +141,7 @@ sealed trait ScriptedRun {
       keepTempDirectory: java.lang.Boolean,
       includeFilter: JFileFilter,
       excludeFilter: JFileFilter,
-  ): AnyRef = {
+  ): AnyRef =
     invoke(
       resourceBaseDirectory,
       bufferLog,
@@ -157,13 +153,11 @@ sealed trait ScriptedRun {
       instances,
       keepTempDirectory,
     )
-  }
+end ScriptedRun
 
-}
+object ScriptedRun:
 
-object ScriptedRun {
-
-  def of(scriptedTests: AnyRef, batchExecution: Boolean): ScriptedRun = {
+  def of(scriptedTests: AnyRef, batchExecution: Boolean): ScriptedRun =
     val fCls = classOf[File]
     val bCls = classOf[Boolean]
     val asCls = classOf[Array[String]]
@@ -174,7 +168,7 @@ object ScriptedRun {
     val ffCls = classOf[JFileFilter]
 
     val clazz = scriptedTests.getClass
-    if (batchExecution)
+    if batchExecution then
       try
         new RunInParallelV4(
           scriptedTests,
@@ -193,7 +187,7 @@ object ScriptedRun {
             ffCls,
           )
         )
-      catch {
+      catch
         case _: NoSuchMethodException =>
           try
             new RunInParallelV3(
@@ -201,7 +195,7 @@ object ScriptedRun {
               clazz
                 .getMethod("runInParallel", fCls, bCls, asCls, fCls, sCls, asCls, lfCls, iCls, bCls)
             )
-          catch {
+          catch
             case _: NoSuchMethodException =>
               try
                 new RunInParallelV2(
@@ -209,15 +203,12 @@ object ScriptedRun {
                   clazz
                     .getMethod("runInParallel", fCls, bCls, asCls, fCls, sCls, asCls, lfCls, iCls)
                 )
-              catch {
+              catch
                 case _: NoSuchMethodException =>
                   new RunInParallelV1(
                     scriptedTests,
                     clazz.getMethod("runInParallel", fCls, bCls, asCls, fCls, asCls, lfCls, iCls)
                   )
-              }
-          }
-      }
     else
       try
         new RunV4(
@@ -236,32 +227,30 @@ object ScriptedRun {
             ffCls,
           )
         )
-      catch {
+      catch
         case _: NoSuchMethodException =>
           try
             new RunV3(
               scriptedTests,
               clazz.getMethod("run", fCls, bCls, asCls, fCls, sCls, asCls, lfCls, bCls)
             )
-          catch {
+          catch
             case _: NoSuchMethodException =>
               try
                 new RunV2(
                   scriptedTests,
                   clazz.getMethod("run", fCls, bCls, asCls, fCls, sCls, asCls, lfCls)
                 )
-              catch {
+              catch
                 case _: NoSuchMethodException =>
                   new RunV1(
                     scriptedTests,
                     clazz.getMethod("run", fCls, bCls, asCls, fCls, asCls, lfCls)
                   )
-              }
-          }
-      }
-  }
+    end if
+  end of
 
-  private class RunV1(scriptedTests: AnyRef, run: Method) extends ScriptedRun {
+  private class RunV1(scriptedTests: AnyRef, run: Method) extends ScriptedRun:
     override protected def invoke(
         resourceBaseDirectory: File,
         bufferLog: java.lang.Boolean,
@@ -282,9 +271,9 @@ object ScriptedRun {
         launchOpts,
         prescripted,
       )
-  }
+  end RunV1
 
-  private class RunInParallelV1(scriptedTests: AnyRef, runInParallel: Method) extends ScriptedRun {
+  private class RunInParallelV1(scriptedTests: AnyRef, runInParallel: Method) extends ScriptedRun:
     override protected def invoke(
         resourceBaseDirectory: File,
         bufferLog: java.lang.Boolean,
@@ -306,9 +295,9 @@ object ScriptedRun {
         prescripted,
         instances,
       )
-  }
+  end RunInParallelV1
 
-  private class RunV2(scriptedTests: AnyRef, run: Method) extends ScriptedRun {
+  private class RunV2(scriptedTests: AnyRef, run: Method) extends ScriptedRun:
     override protected def invoke(
         resourceBaseDirectory: File,
         bufferLog: java.lang.Boolean,
@@ -330,9 +319,9 @@ object ScriptedRun {
         launchOpts,
         prescripted,
       )
-  }
+  end RunV2
 
-  private class RunInParallelV2(scriptedTests: AnyRef, runInParallel: Method) extends ScriptedRun {
+  private class RunInParallelV2(scriptedTests: AnyRef, runInParallel: Method) extends ScriptedRun:
     override protected def invoke(
         resourceBaseDirectory: File,
         bufferLog: java.lang.Boolean,
@@ -355,9 +344,9 @@ object ScriptedRun {
         prescripted,
         instances,
       )
-  }
+  end RunInParallelV2
 
-  private class RunV3(scriptedTests: AnyRef, run: Method) extends ScriptedRun {
+  private class RunV3(scriptedTests: AnyRef, run: Method) extends ScriptedRun:
     override protected def invoke(
         resourceBaseDirectory: File,
         bufferLog: java.lang.Boolean,
@@ -380,9 +369,9 @@ object ScriptedRun {
         prescripted,
         keepTempDirectory,
       )
-  }
+  end RunV3
 
-  private class RunInParallelV3(scriptedTests: AnyRef, runInParallel: Method) extends ScriptedRun {
+  private class RunInParallelV3(scriptedTests: AnyRef, runInParallel: Method) extends ScriptedRun:
     override protected def invoke(
         resourceBaseDirectory: File,
         bufferLog: java.lang.Boolean,
@@ -406,9 +395,9 @@ object ScriptedRun {
         instances,
         keepTempDirectory,
       )
-  }
+  end RunInParallelV3
 
-  private class RunV4(scriptedTests: AnyRef, run: Method) extends ScriptedRun {
+  private class RunV4(scriptedTests: AnyRef, run: Method) extends ScriptedRun:
     override protected def invoke(
         resourceBaseDirectory: File,
         bufferLog: java.lang.Boolean,
@@ -460,9 +449,9 @@ object ScriptedRun {
         includeFilter,
         excludeFilter,
       )
-  }
+  end RunV4
 
-  private class RunInParallelV4(scriptedTests: AnyRef, runInParallel: Method) extends ScriptedRun {
+  private class RunInParallelV4(scriptedTests: AnyRef, runInParallel: Method) extends ScriptedRun:
     override protected def invoke(
         resourceBaseDirectory: File,
         bufferLog: java.lang.Boolean,
@@ -515,6 +504,5 @@ object ScriptedRun {
         includeFilter,
         excludeFilter,
       )
-  }
-
-}
+  end RunInParallelV4
+end ScriptedRun
diff --git a/main/src/main/scala/sbt/SessionVar.scala b/main/src/main/scala/sbt/SessionVar.scala
index 40e76cb8b..801184b9d 100644
--- a/main/src/main/scala/sbt/SessionVar.scala
+++ b/main/src/main/scala/sbt/SessionVar.scala
@@ -18,23 +18,21 @@ import Keys.sessionVars
 import sjsonnew.JsonFormat
 import sbt.ProjectExtra.*
 
-object SessionVar {
+object SessionVar:
   val DefaultDataID = "data"
 
   // these are required because of inference+manifest limitations
   final case class Key[T](key: ScopedKey[Task[T]])
-  final case class Map(map: IMap[Key, Id]) {
+  final case class Map(map: IMap[Key, Id]):
     def get[T](k: ScopedKey[Task[T]]): Option[T] = map.get(Key(k))
     def put[T](k: ScopedKey[Task[T]], v: T): Map = Map(map.put(Key(k), v))
-  }
   def emptyMap = Map(IMap.empty)
 
   def persistAndSet[T](key: ScopedKey[Task[T]], state: State, value: T)(using
       f: JsonFormat[T]
-  ): State = {
+  ): State =
     persist(key, state, value)(using f)
     set(key, state, value)
-  }
 
   def persist[T](key: ScopedKey[Task[T]], state: State, value: T)(using f: JsonFormat[T]): Unit =
     Project.structure(state).streams(state).use(key)(s => s.getOutput(DefaultDataID).write(value))
@@ -67,9 +65,8 @@ object SessionVar {
 
   def read[T](key: ScopedKey[Task[T]], state: State)(using f: JsonFormat[T]): Option[T] =
     Project.structure(state).streams(state).use(key) { s =>
-      try {
-        Some(s.getInput(key, DefaultDataID).read[T]())
-      } catch { case NonFatal(_) => None }
+      try Some(s.getInput(key, DefaultDataID).read[T]())
+      catch case NonFatal(_) => None
     }
 
   def load[T](key: ScopedKey[Task[T]], state: State)(using f: JsonFormat[T]): Option[T] =
@@ -78,15 +75,13 @@ object SessionVar {
   def loadAndSet[T](key: ScopedKey[Task[T]], state: State, setIfUnset: Boolean = true)(using
       f: JsonFormat[T]
   ): (State, Option[T]) =
-    get(key, state) match {
+    get(key, state) match
       case s: Some[T] => (state, s)
       case None       =>
-        read(key, state)(using f) match {
+        read(key, state)(using f) match
           case s @ Some(t) =>
             val newState =
-              if (setIfUnset && get(key, state).isDefined) state else set(key, state, t)
+              if setIfUnset && get(key, state).isDefined then state else set(key, state, t)
             (newState, s)
           case None => (state, None)
-        }
-    }
-}
+end SessionVar
diff --git a/main/src/main/scala/sbt/Tags.scala b/main/src/main/scala/sbt/Tags.scala
index 5d1b776e8..abdc02e6f 100644
--- a/main/src/main/scala/sbt/Tags.scala
+++ b/main/src/main/scala/sbt/Tags.scala
@@ -10,7 +10,7 @@ package sbt
 
 import annotation.tailrec
 
-object Tags {
+object Tags:
   type Tag = ConcurrentRestrictions.Tag
   type TagMap = ConcurrentRestrictions.TagMap
   def Tag(s: String): Tag = ConcurrentRestrictions.Tag(s)
@@ -36,46 +36,37 @@ object Tags {
    * Describes a restriction on concurrently executing tasks.
    * A Rule is constructed using one of the Tags.limit* methods.
    */
-  abstract class Rule {
+  abstract class Rule:
     def apply(m: TagMap): Boolean
     def ||(r: Rule): Rule = new Or(this, r)
     def &&(r: Rule): Rule = new And(this, r)
     def unary_- : Rule = new Not(this)
-  }
-  private final class Custom(f: TagMap => Boolean) extends Rule {
+  private final class Custom(f: TagMap => Boolean) extends Rule:
     def apply(m: TagMap) = f(m)
-  }
-  private final class Single(tag: Tag, max: Int) extends Rule {
+  private final class Single(tag: Tag, max: Int) extends Rule:
     checkMax(max)
     def apply(m: TagMap) = getInt(m, tag) <= max
     override def toString = "Limit " + tag.name + " to " + max
-  }
-  private final class Sum(tags: Seq[Tag], max: Int) extends Rule {
+  private final class Sum(tags: Seq[Tag], max: Int) extends Rule:
     checkMax(max)
     def apply(m: TagMap) = tags.foldLeft(0)((sum, t) => sum + getInt(m, t)) <= max
     override def toString = tags.mkString("Limit sum of ", ", ", " to " + max)
-  }
-  private final class Or(a: Rule, b: Rule) extends Rule {
+  private final class Or(a: Rule, b: Rule) extends Rule:
     def apply(m: TagMap) = a(m) || b(m)
-  }
-  private final class And(a: Rule, b: Rule) extends Rule {
+  private final class And(a: Rule, b: Rule) extends Rule:
     def apply(m: TagMap) = a(m) && b(m)
-  }
-  private final class Not(a: Rule) extends Rule {
+  private final class Not(a: Rule) extends Rule:
     def apply(m: TagMap) = !a(m)
-  }
 
   private def checkMax(max: Int): Unit = assert(max >= 1, "Limit must be at least 1.")
 
   /** Converts a sequence of rules into a function that identifies whether a set of tasks are allowed to execute concurrently based on their merged tags. */
-  def predicate(rules: Seq[Rule]): TagMap => Boolean = m => {
+  def predicate(rules: Seq[Rule]): TagMap => Boolean = m =>
     @tailrec def loop(rules: List[Rule]): Boolean =
-      rules match {
+      rules match
         case x :: xs => x(m) && loop(xs)
         case Nil     => true
-      }
     loop(rules.toList)
-  }
 
   def getInt(m: TagMap, tag: Tag): Int = m.getOrElse(tag, 0)
 
@@ -140,4 +131,4 @@ object Tags {
       // If there is only one withinTag task, allow it to execute.
       tags.getOrElse(withinTag, 0) == 1
   }
-}
+end Tags
diff --git a/main/src/main/scala/sbt/TemplateCommandUtil.scala b/main/src/main/scala/sbt/TemplateCommandUtil.scala
index ccd8aad99..5733dcdd5 100644
--- a/main/src/main/scala/sbt/TemplateCommandUtil.scala
+++ b/main/src/main/scala/sbt/TemplateCommandUtil.scala
@@ -25,7 +25,7 @@ import sbt.ProjectExtra.*
 
 import scala.annotation.tailrec
 
-private[sbt] object TemplateCommandUtil {
+private[sbt] object TemplateCommandUtil:
   def templateCommand: Command = templateCommand0(TemplateCommand)
   def templateCommandAlias: Command = templateCommand0("init")
   private def templateCommand0(command: String): Command =
@@ -36,7 +36,7 @@ private[sbt] object TemplateCommandUtil {
   private def templateCommandParser: Parser[Seq[String]] =
     (token(Space) ~> repsep(StringBasic, token(Space))) | (token(EOF).map(_ => Nil))
 
-  private def runTemplate(s0: State, inputArg: Seq[String]): State = {
+  private def runTemplate(s0: State, inputArg: Seq[String]): State =
     import BuildPaths.*
     val globalBase = getGlobalBase(s0)
     val infos = s0.get(templateResolverInfos).getOrElse(Nil).toList
@@ -46,23 +46,21 @@ private[sbt] object TemplateCommandUtil {
     val scalaModuleInfo = extracted.get(Keys.updateSbtClassifiers / Keys.scalaModuleInfo)
     val templateDescriptions = extracted.get(Keys.templateDescriptions)
     val args0 = inputArg.toList ++
-      (s0.remainingCommands match {
+      (s0.remainingCommands match
         case exec :: Nil if exec.commandLine == "shell" => Nil
-        case xs                                         => xs map (_.commandLine)
-      })
+        case xs                                         => xs map (_.commandLine))
     def terminate = TerminateAction :: s1.copy(remainingCommands = Nil)
     def reload = "reboot" :: s1.copy(remainingCommands = Nil)
-    if (args0.nonEmpty) {
-      args0 match {
+    if args0.nonEmpty then
+      args0 match
         case arg :: Nil if arg.endsWith(".local") =>
           extracted.runInputTask(Keys.templateRunLocal, " " + arg, s0)
           reload
         case _ =>
           run(infos, args0, s0.configuration, lm, globalBase, scalaModuleInfo, log)
           terminate
-      }
-    } else {
-      fortifyArgs(templateDescriptions.toList) match {
+    else
+      fortifyArgs(templateDescriptions.toList) match
         case Nil                                  => terminate
         case arg :: Nil if arg.endsWith(".local") =>
           extracted.runInputTask(Keys.templateRunLocal, " " + arg, s0)
@@ -70,9 +68,7 @@ private[sbt] object TemplateCommandUtil {
         case args =>
           run(infos, args, s0.configuration, lm, globalBase, scalaModuleInfo, log)
           terminate
-      }
-    }
-  }
+  end runTemplate
 
   private def run(
       infos: List[TemplateResolverInfo],
@@ -86,36 +82,31 @@ private[sbt] object TemplateCommandUtil {
     infos find { info =>
       val loader = infoLoader(info, config, lm, globalBase, scalaModuleInfo, log)
       val hit = tryTemplate(info, arguments, loader)
-      if (hit) {
-        runTemplate(info, arguments, loader)
-      }
+      if hit then runTemplate(info, arguments, loader)
       hit
-    } match {
+    } match
       case Some(_) => // do nothing
       case None    =>
         val error = "Template not found for: " + arguments.mkString(" ")
         throw new IllegalArgumentException(error)
-    }
 
   private def tryTemplate(
       info: TemplateResolverInfo,
       arguments: List[String],
       loader: ClassLoader
-  ): Boolean = {
+  ): Boolean =
     val resultObj = call(info.implementationClass, "isDefined", loader)(
       classOf[Array[String]]
     )(arguments.toArray)
     resultObj.asInstanceOf[Boolean]
-  }
 
   private def runTemplate(
       info: TemplateResolverInfo,
       arguments: List[String],
       loader: ClassLoader
-  ): Unit = {
+  ): Unit =
     call(info.implementationClass, "run", loader)(classOf[Array[String]])(arguments.toArray)
     ()
-  }
 
   private def infoLoader(
       info: TemplateResolverInfo,
@@ -124,25 +115,20 @@ private[sbt] object TemplateCommandUtil {
       globalBase: File,
       scalaModuleInfo: Option[ScalaModuleInfo],
       log: Logger
-  ): ClassLoader = {
+  ): ClassLoader =
     val cp = classpathForInfo(info, lm, globalBase, scalaModuleInfo, log)
     ClasspathUtil.toLoader(cp, config.provider.loader)
-  }
 
   private def call(
       interfaceClassName: String,
       methodName: String,
       loader: ClassLoader
-  )(argTypes: Class[?]*)(args: AnyRef*): AnyRef = {
+  )(argTypes: Class[?]*)(args: AnyRef*): AnyRef =
     val interfaceClass = getInterfaceClass(interfaceClassName, loader)
     val interface = interfaceClass.getDeclaredConstructor().newInstance().asInstanceOf[AnyRef]
     val method = interfaceClass.getMethod(methodName, argTypes*)
-    try {
-      method.invoke(interface, args*)
-    } catch {
-      case e: InvocationTargetException => throw e.getCause
-    }
-  }
+    try method.invoke(interface, args*)
+    catch case e: InvocationTargetException => throw e.getCause
 
   private def getInterfaceClass(name: String, loader: ClassLoader) =
     Class.forName(name, true, loader)
@@ -155,22 +141,19 @@ private[sbt] object TemplateCommandUtil {
       globalBase: File,
       scalaModuleInfo: Option[ScalaModuleInfo],
       log: Logger
-  ): List[Path] = {
+  ): List[Path] =
     val templatesBaseDirectory = new File(globalBase, "templates")
     val templateId = s"${info.module.organization}_${info.module.name}_${info.module.revision}"
     val templateDirectory = new File(templatesBaseDirectory, templateId)
     def jars = (templateDirectory ** -DirectoryFilter).get()
     if !info.module.revision.endsWith("-SNAPSHOT") && jars.nonEmpty then jars.toList.map(_.toPath)
-    else {
+    else
       IO.createDirectory(templateDirectory)
       val m = lm.wrapDependencyInModule(info.module, scalaModuleInfo)
-      val xs = lm.retrieve(m, templateDirectory, log) match {
+      val xs = lm.retrieve(m, templateDirectory, log) match
         case Left(_)      => sys.error(s"Retrieval of ${info.module} failed.")
         case Right(files) => files.toList
-      }
       xs.map(_.toPath)
-    }
-  }
 
   private final val ScalaToolkitSlug = "scala/toolkit.local"
   private final val TypelevelToolkitSlug = "typelevel/toolkit.local"
@@ -193,7 +176,7 @@ private[sbt] object TemplateCommandUtil {
     "disneystreaming/smithy4s.g8" -> "A Smithy4s project",
   )
   private def fortifyArgs(templates: List[(String, String)]): List[String] =
-    if (!hasConsole) Nil
+    if !hasConsole then Nil
     else
       ITerminal.withStreams(true, false) {
         assert(templates.size <= 20, "template list cannot have more than 20 items")
@@ -213,21 +196,20 @@ private[sbt] object TemplateCommandUtil {
     nonMoveLetters(idx).toString
 
   @tailrec
-  private def askTemplate(mappingList: List[(String, (String, String))], focus: Int): String = {
+  private def askTemplate(mappingList: List[(String, (String, String))], focus: Int): String =
     val msg = "Select a template"
     displayMappings(mappingList, focus)
     val focusValue = toLetter(focus)
-    if (!isAnsiSupported) ask(msg, focusValue)
-    else {
+    if !isAnsiSupported then ask(msg, focusValue)
+    else
       val out = term.printStream
       out.print(s"$msg: ")
       val ans0 = term.readArrow
-      def printThenReturn(ans: String): String = {
+      def printThenReturn(ans: String): String =
         out.println(ans) // this is necessary to move the cursor
         out.flush()
         ans
-      }
-      ans0 match {
+      ans0 match
         case '\r' | '\n'                   => printThenReturn(focusValue)
         case 'q' | 'Q' | -1                => printThenReturn("")
         case 'j' | 'J' | ITerminal.VK_DOWN =>
@@ -241,39 +223,31 @@ private[sbt] object TemplateCommandUtil {
         case _ =>
           clearMenu(mappingList)
           askTemplate(mappingList, focus)
-      }
-    }
-  }
+    end if
+  end askTemplate
 
-  private def clearMenu(mappingList: List[(String, (String, String))]): Unit = {
+  private def clearMenu(mappingList: List[(String, (String, String))]): Unit =
     val out = term.printStream
     out.print(ConsoleAppender.CursorLeft1000)
     out.print(ConsoleAppender.cursorUp(mappingList.size + 1))
-  }
 
-  private def displayMappings(mappingList: List[(String, (String, String))], focus: Int): Unit = {
+  private def displayMappings(mappingList: List[(String, (String, String))], focus: Int): Unit =
     import scala.Console.{ RESET, REVERSED }
     val out = term.printStream
     mappingList.zipWithIndex.foreach { case ((k, (slug, desc)), idx) =>
-      if (idx == focus && isAnsiSupported) {
-        out.print(REVERSED)
-      }
+      if idx == focus && isAnsiSupported then out.print(REVERSED)
       out.print(s" $k) ${slug.padTo(33, ' ')} - $desc")
-      if (idx == focus && isAnsiSupported) {
-        out.print(RESET)
-      }
+      if idx == focus && isAnsiSupported then out.print(RESET)
       out.println()
     }
     out.println(" q) quit")
     out.flush()
-  }
 
-  private def ask(question: String, default: String): String = {
+  private def ask(question: String, default: String): String =
     System.out.print(s"$question (default: $default): ")
     val ans0 = System.console.readLine()
-    if (ans0 == "") default
+    if ans0 == "" then default
     else ans0
-  }
 
   // This is used by Defaults.runLocalTemplate, which implements
   // templateRunLocal input task.
@@ -281,17 +255,16 @@ private[sbt] object TemplateCommandUtil {
       arguments: List[String],
       log: Logger
   ): Unit =
-    arguments match {
+    arguments match
       case ScalaToolkitSlug :: Nil     => scalaToolkitTemplate()
       case TypelevelToolkitSlug :: Nil => typelevelToolkitTemplate()
       case SbtCrossPlatformSlug :: Nil => sbtCrossPlatformTemplate()
       case _                           =>
         val error = "Local template not found for: " + arguments.mkString(" ")
         throw new IllegalArgumentException(error)
-    }
 
   private final val defaultScalaV = "3.3.8"
-  private def scalaToolkitTemplate(): Unit = {
+  private def scalaToolkitTemplate(): Unit =
     val defaultScalaToolkitV = "0.9.2"
     val scalaV = ask("Scala version", defaultScalaV)
     val toolkitV = ask("Scala Toolkit version", defaultScalaToolkitV)
@@ -307,9 +280,8 @@ libraryDependencies += (toolkitTest % Test)
     IO.write(new File("build.sbt"), content)
     copyResource("ScalaMain.scala.txt", new File("src/main/scala/example/Main.scala"))
     copyResource("MUnitSuite.scala.txt", new File("src/test/scala/example/ExampleSuite.scala"))
-  }
 
-  private def typelevelToolkitTemplate(): Unit = {
+  private def typelevelToolkitTemplate(): Unit =
     val defaultTypelevelToolkitV = "0.2.0"
     val scalaV = ask("Scala version", defaultScalaV)
     val toolkitV = ask("Typelevel Toolkit version", defaultTypelevelToolkitV)
@@ -328,9 +300,8 @@ libraryDependencies += (toolkitTest % Test)
       "TypelevelExampleSuite.scala.txt",
       new File("src/test/scala/example/ExampleSuite.scala")
     )
-  }
 
-  private def sbtCrossPlatformTemplate(): Unit = {
+  private def sbtCrossPlatformTemplate(): Unit =
     val scalaV = ask("Scala version", defaultScalaV)
     val content = s"""
 ThisBuild / scalaVersion := "$scalaV"
@@ -351,21 +322,15 @@ addSbtPlugin("org.scala-native" % "sbt-scala-native" % "0.5.12")
 """
     IO.write(new File("project/plugins.sbt"), pluginsContent)
     copyResource("ScalaMain.scala.txt", new File("core/src/main/scala/example/Main.scala"))
-  }
+  end sbtCrossPlatformTemplate
 
-  private def copyResource(resourcePath: String, out: File): Unit = {
-    if (out.exists()) {
-      sys.error(s"the file $out already exists!")
-    }
-    if (!out.getParentFile().exists()) {
-      IO.createDirectory(out.getParentFile())
-    }
+  private def copyResource(resourcePath: String, out: File): Unit =
+    if out.exists() then sys.error(s"the file $out already exists!")
+    if !out.getParentFile().exists() then IO.createDirectory(out.getParentFile())
     val is = getClass.getClassLoader().getResourceAsStream(resourcePath)
     require(is ne null, s"Couldn't load '$resourcePath' from classpath.")
-    try {
+    try
       IO.transfer(is, out)
-    } finally {
+    finally
       is.close()
-    }
-  }
-}
+end TemplateCommandUtil
diff --git a/main/src/main/scala/sbt/Terminal.scala b/main/src/main/scala/sbt/Terminal.scala
index a9fb2a8bc..a3fa690a6 100644
--- a/main/src/main/scala/sbt/Terminal.scala
+++ b/main/src/main/scala/sbt/Terminal.scala
@@ -17,7 +17,7 @@ import sbt.internal.util.{ JLine3, Terminal as ITerminal }
  * Terminal is particularly useful whenever an sbt task needs to receive input from
  * the user.
  */
-trait Terminal {
+trait Terminal:
 
   /**
    * Returns the width of the terminal.
@@ -59,15 +59,13 @@ trait Terminal {
    * @param echo toggles whether or not to echo the characters received from the terminal input stream
    */
   def setMode(canonical: Boolean, echo: Boolean): Unit
+end Terminal
 
-}
-private[sbt] object Terminal {
-  private[sbt] def apply(term: ITerminal): Terminal = new Terminal {
+private[sbt] object Terminal:
+  private[sbt] def apply(term: ITerminal): Terminal = new Terminal:
     override def getHeight: Int = term.getHeight
     override def getWidth: Int = term.getWidth
     override def inputStream: InputStream = term.inputStream
     override def printStream: PrintStream = term.printStream
     override def setMode(canonical: Boolean, echo: Boolean): Unit =
       JLine3.setMode(term, canonical, echo)
-  }
-}
diff --git a/main/src/main/scala/sbt/UpperStateOps.scala b/main/src/main/scala/sbt/UpperStateOps.scala
index 265999912..3da4f5642 100644
--- a/main/src/main/scala/sbt/UpperStateOps.scala
+++ b/main/src/main/scala/sbt/UpperStateOps.scala
@@ -16,7 +16,7 @@ import sbt.ProjectExtra.*
 /**
  * Extends State with setting-level knowledge.
  */
-trait UpperStateOps extends Any {
+trait UpperStateOps extends Any:
 
   /**
    * ProjectRef to the current project of the state session that can be change using
@@ -110,12 +110,12 @@ trait UpperStateOps extends Any {
   def respondEvent[A: JsonFormat](event: A): Unit
   def respondError(code: Long, message: String): Unit
   def notifyEvent[A: JsonFormat](method: String, params: A): Unit
-}
+end UpperStateOps
 
-object UpperStateOps {
+object UpperStateOps:
   lazy val exchange = StandardMain.exchange
 
-  implicit class UpperStateOpsImpl(val s: State) extends AnyVal with UpperStateOps {
+  implicit class UpperStateOpsImpl(val s: State) extends AnyVal with UpperStateOps:
     def extract: Extracted = Project.extract(s)
 
     def currentRef = extract.currentRef
@@ -150,14 +150,11 @@ object UpperStateOps {
     def appendWithoutSession(settings: Seq[Setting[?]], state: State): State =
       extract.appendWithoutSession(settings, s)
 
-    def respondEvent[A: JsonFormat](event: A): Unit = {
+    def respondEvent[A: JsonFormat](event: A): Unit =
       exchange.respondEvent(event, s.currentCommand.flatMap(_.execId), s.source)
-    }
-    def respondError(code: Long, message: String): Unit = {
+    def respondError(code: Long, message: String): Unit =
       exchange.respondError(code, message, s.currentCommand.flatMap(_.execId), s.source)
-    }
-    def notifyEvent[A: JsonFormat](method: String, params: A): Unit = {
+    def notifyEvent[A: JsonFormat](method: String, params: A): Unit =
       exchange.notifyEvent(method, params)
-    }
-  }
-}
+  end UpperStateOpsImpl
+end UpperStateOps
diff --git a/main/src/main/scala/sbt/VersionScheme.scala b/main/src/main/scala/sbt/VersionScheme.scala
index 58e84adba..c88817aaf 100644
--- a/main/src/main/scala/sbt/VersionScheme.scala
+++ b/main/src/main/scala/sbt/VersionScheme.scala
@@ -10,10 +10,9 @@ package sbt
 
 import sbt.internal.librarymanagement.VersionSchemes
 
-object VersionScheme {
+object VersionScheme:
   val Always = VersionSchemes.Always
   val EarlySemVer = VersionSchemes.EarlySemVer
   val PVP = VersionSchemes.PackVer
   val SemVerSpec = VersionSchemes.SemVerSpec
   val Strict = VersionSchemes.Strict
-}
diff --git a/main/src/main/scala/sbt/VirtualAxis.scala b/main/src/main/scala/sbt/VirtualAxis.scala
index 53e86765f..8a4d6e4eb 100644
--- a/main/src/main/scala/sbt/VirtualAxis.scala
+++ b/main/src/main/scala/sbt/VirtualAxis.scala
@@ -3,16 +3,15 @@ package sbt
 import sbt.librarymanagement.CrossVersion.{ binaryScalaVersion, partialVersion }
 
 /** Virtual Axis represents a parameter to a project matrix row. */
-sealed abstract class VirtualAxis {
+sealed abstract class VirtualAxis:
   def directorySuffix: String
 
   def idSuffix: String
 
   /* The order to sort the suffixes if there were multiple axes. */
   def suffixOrder: Int = 50
-}
 
-object VirtualAxis {
+object VirtualAxis:
 
   /**
    * WeakAxis allows a row to depend on another row with Zero value.
@@ -27,44 +26,39 @@ object VirtualAxis {
     lhs.forall(isStronglyCompatible(_, rhs)) && rhs.forall(isStronglyCompatible(_, lhs))
 
   private[sbt] def isStronglyCompatible(v: VirtualAxis, stack: Seq[VirtualAxis]): Boolean =
-    v match {
+    v match
       case v: WeakAxis =>
         val clazz = v.getClass
         stack.contains(v) || !stack.exists(_.getClass == clazz)
       case v: StrongAxis =>
         stack.contains(v)
-    }
 
   def isSecondaryMatch(lhs: Seq[VirtualAxis], rhs: Seq[VirtualAxis]): Boolean =
     lhs.forall(isSecondaryCompatible(_, rhs)) && rhs.forall(isSecondaryCompatible(_, lhs))
 
   def isSecondaryCompatible(v: VirtualAxis, stack: Seq[VirtualAxis]): Boolean =
-    v match {
+    v match
       case v: ScalaVersionAxis =>
         val thatSVOpt = stack.collectFirst { case x: ScalaVersionAxis =>
           x
         }
-        thatSVOpt match {
+        thatSVOpt match
           case Some(ScalaVersionAxis(sv, _)) =>
             (v.scalaVersion == sv) ||
             isScala2Scala3Sandwich(partialVersion(v.scalaVersion), partialVersion(sv))
           case _ => true
-        }
       case _ =>
         isStronglyCompatible(v, stack)
-    }
 
   private[sbt] def isScala2Scala3Sandwich(
       sbv1: Option[(Long, Long)],
       sbv2: Option[(Long, Long)]
-  ): Boolean = {
+  ): Boolean =
     def str(x: Option[(Long, Long)]): String =
-      x match {
+      x match
         case Some((a, b)) => s"$a.$b"
         case _            => "0.0"
-      }
     isScala2Scala3Sandwich(str(sbv1), str(sbv2))
-  }
 
   private[sbt] def isScala2Scala3Sandwich(sbv1: String, sbv2: String): Boolean =
     def compare(a: String, b: String): Boolean =
@@ -72,43 +66,35 @@ object VirtualAxis {
     compare(sbv1, sbv2) || compare(sbv2, sbv1)
 
   // This admits partial Scala version
-  private[sbt] def isPartialVersionEquals(ax1: VirtualAxis, ax2: VirtualAxis): Boolean = {
-    (ax1, ax2) match {
+  private[sbt] def isPartialVersionEquals(ax1: VirtualAxis, ax2: VirtualAxis): Boolean =
+    (ax1, ax2) match
       case (ax1: ScalaVersionAxis, ax2: ScalaVersionAxis) =>
         (ax1 == ax2) || (ax1.value == ax2.value)
       case _ => ax1 == ax2
-    }
-  }
 
-  case class ScalaVersionAxis(scalaVersion: String, value: String) extends WeakAxis {
+  case class ScalaVersionAxis(scalaVersion: String, value: String) extends WeakAxis:
     override def idSuffix: String = directorySuffix.replaceAll("""\W+""", "_")
     override val suffixOrder: Int = 100
     override def directorySuffix: String = value
 
     // use only the scalaVersion field for equality
-    override def equals(obj: Any): Boolean = {
-      if (obj.isInstanceOf[AnyRef] && (this eq obj.asInstanceOf[AnyRef])) true
-      else if (!obj.isInstanceOf[ScalaVersionAxis]) false
-      else {
+    override def equals(obj: Any): Boolean =
+      if obj.isInstanceOf[AnyRef] && (this eq obj.asInstanceOf[AnyRef]) then true
+      else if !obj.isInstanceOf[ScalaVersionAxis] then false
+      else
         val o = obj.asInstanceOf[ScalaVersionAxis]
         this.scalaVersion == o.scalaVersion
-      }
-    }
-    override def hashCode: Int = {
+    override def hashCode: Int =
       37 * (17 + "sbt.ScalaVersionAxis".hashCode()) + scalaVersion.hashCode()
-    }
-  }
 
   case class PlatformAxis(value: String, idSuffix: String, directorySuffix: String)
-      extends StrongAxis {
+      extends StrongAxis:
     override val suffixOrder: Int = 80
-  }
 
   def scalaPartialVersion(scalaVersion: String): ScalaVersionAxis =
-    partialVersion(scalaVersion) match {
+    partialVersion(scalaVersion) match
       case Some((m, n)) => scalaVersionAxis(scalaVersion, s"$m.$n")
       case _            => scalaVersionAxis(scalaVersion, scalaVersion)
-    }
   def scalaABIVersion(scalaVersion: String): ScalaVersionAxis =
     scalaVersionAxis(scalaVersion, binaryScalaVersion(scalaVersion))
 
@@ -118,4 +104,4 @@ object VirtualAxis {
   val jvm: PlatformAxis = PlatformAxis("jvm", "JVM", "jvm")
   val js: PlatformAxis = PlatformAxis("js", "JS", "js")
   val native: PlatformAxis = PlatformAxis("native", "Native", "native")
-}
+end VirtualAxis
diff --git a/main/src/main/scala/sbt/coursierint/CoursierArtifactsTasks.scala b/main/src/main/scala/sbt/coursierint/CoursierArtifactsTasks.scala
index a7b5a9064..70e8af5c2 100644
--- a/main/src/main/scala/sbt/coursierint/CoursierArtifactsTasks.scala
+++ b/main/src/main/scala/sbt/coursierint/CoursierArtifactsTasks.scala
@@ -21,7 +21,7 @@ import sbt.Keys.*
 import sbt.ProjectExtra.extract
 import sbt.SlashSyntax0.*
 
-object CoursierArtifactsTasks {
+object CoursierArtifactsTasks:
   def coursierPublicationsTask(
       configsMap: (sbt.librarymanagement.Configuration, CConfiguration)*
   ): Def.Initialize[sbt.Task[Seq[(CConfiguration, CPublication)]]] =
@@ -37,66 +37,56 @@ object CoursierArtifactsTasks {
       import extracted.*
 
       val sourcesConfigOpt =
-        if (ivyConfigurations.value.exists(_.name == "sources"))
-          Some(CConfiguration("sources"))
-        else
-          None
+        if ivyConfigurations.value.exists(_.name == "sources") then Some(CConfiguration("sources"))
+        else None
 
       val docsConfigOpt =
-        if (ivyConfigurations.value.exists(_.name == "docs"))
-          Some(CConfiguration("docs"))
-        else
-          None
+        if ivyConfigurations.value.exists(_.name == "docs") then Some(CConfiguration("docs"))
+        else None
 
       val sbtBinArtifacts =
-        for ((config, targetConfig) <- configsMap) yield {
+        for (config, targetConfig) <- configsMap yield
 
           val publish = getOpt(
             projectRef / config / packageBin / publishArtifact
           ).getOrElse(false)
 
-          if (publish)
+          if publish then
             getOpt(
               projectRef / config / packageBin / artifact
             ).map(targetConfig -> _)
-          else
-            None
-        }
+          else None
 
       val sbtSourceArtifacts =
-        for ((config, targetConfig) <- configsMap) yield {
+        for (config, targetConfig) <- configsMap yield
 
           val publish = getOpt(
             projectRef / config / packageSrc / publishArtifact
           ).getOrElse(false)
 
-          if (publish)
+          if publish then
             getOpt(
               projectRef / config / packageSrc / artifact
             ).map(sourcesConfigOpt.getOrElse(targetConfig) -> _)
-          else
-            None
-        }
+          else None
 
       val sbtDocArtifacts =
-        for ((config, targetConfig) <- configsMap) yield {
+        for (config, targetConfig) <- configsMap yield
 
           val publish =
             getOpt(
               projectRef / config / packageDoc / publishArtifact
             ).getOrElse(false)
 
-          if (publish)
+          if publish then
             getOpt(
               projectRef / config / packageDoc / artifact
             ).map(docsConfigOpt.getOrElse(targetConfig) -> _)
-          else
-            None
-        }
+          else None
 
       val sbtArtifacts = sbtBinArtifacts ++ sbtSourceArtifacts ++ sbtDocArtifacts
 
-      def artifactPublication(artifact: Artifact) = {
+      def artifactPublication(artifact: Artifact) =
 
         // Platform suffix before cross suffix, matching the coordinate
         val base = projId.crossVersion match
@@ -112,7 +102,6 @@ object CoursierArtifactsTasks {
           CExtension(artifact.extension),
           artifact.classifier.fold(CClassifier(""))(CClassifier(_))
         )
-      }
 
       val sbtArtifactsPublication = sbtArtifacts.collect { case Some((config, artifact)) =>
         config -> artifactPublication(artifact)
@@ -132,15 +121,15 @@ object CoursierArtifactsTasks {
       // it puts it in all of them. See for example what happens to
       // the standalone JAR artifact of the coursier cli module.
       def allConfigsIfEmpty(configs: Iterable[ConfigRef]): Iterable[ConfigRef] =
-        if (configs.isEmpty) ivyConfs.withFilter(_.isPublic).map(c => ConfigRef(c.name))
+        if configs.isEmpty then ivyConfs.withFilter(_.isPublic).map(c => ConfigRef(c.name))
         else configs
 
-      val extraSbtArtifactsPublication = for {
+      val extraSbtArtifactsPublication = for
         artifact <- extraSbtArtifacts
         config <- allConfigsIfEmpty(artifact.configurations.map(x => ConfigRef(x.name)))
-        // FIXME If some configurations from artifact.configurations are not public, they may leak here :\
-      } yield CConfiguration(config.name) -> artifactPublication(artifact)
+      // FIXME If some configurations from artifact.configurations are not public, they may leak here :\
+      yield CConfiguration(config.name) -> artifactPublication(artifact)
 
       sbtArtifactsPublication ++ extraSbtArtifactsPublication
     }
-}
+end CoursierArtifactsTasks
diff --git a/main/src/main/scala/sbt/coursierint/CoursierInputsTasks.scala b/main/src/main/scala/sbt/coursierint/CoursierInputsTasks.scala
index 8ad2b9a2d..a46ec45fb 100644
--- a/main/src/main/scala/sbt/coursierint/CoursierInputsTasks.scala
+++ b/main/src/main/scala/sbt/coursierint/CoursierInputsTasks.scala
@@ -20,7 +20,7 @@ import sbt.internal.librarymanagement.mavenint.SbtPomExtraProperties
 import sbt.ProjectExtra.transitiveInterDependencies
 import sbt.ScopeFilter.Make.*
 
-object CoursierInputsTasks {
+object CoursierInputsTasks:
   private def coursierProject0(
       projId: ModuleID,
       dependencies: Seq[ModuleID],
@@ -34,7 +34,7 @@ object CoursierInputsTasks {
       vsOpt: Option[String],
       projectPlatform: Option[String],
       log: Logger
-  ): CProject = {
+  ): CProject =
 
     val configMap = Inputs.configExtendsSeq(configurations).toMap
     val privConfigs = Inputs.privateConfigs(configurations)
@@ -49,27 +49,24 @@ object CoursierInputsTasks {
         projectPlatform,
       )
       .withPrivateConfigs(privConfigs)
-    val proj1 = auOpt match {
+    val proj1 = auOpt match
       case Some(au) =>
         proj0.withProperties(proj0.properties :+ (SbtPomExtraProperties.POM_API_KEY -> au.toString))
       case _ => proj0
-    }
-    val proj2 = vsOpt match {
+    val proj2 = vsOpt match
       case Some(vs) =>
         proj1.withProperties(proj1.properties :+ (SbtPomExtraProperties.VERSION_SCHEME_KEY -> vs))
       case _ => proj1
-    }
-    val proj3 = rnOpt match {
+    val proj3 = rnOpt match
       case Some(rn) =>
         proj2.withProperties(
           proj2.properties :+ (SbtPomExtraProperties.POM_RELEASE_NOTES_KEY -> rn.toString)
         )
       case _ => proj2
-    }
     proj3.withInfo(
       proj3.info.withDescription(description).withHomePage(homepage.fold("")(_.toString))
     )
-  }
+  end coursierProject0
 
   def coursierProjectTask: Def.Initialize[sbt.Task[CProject]] =
     Def.task {
@@ -103,13 +100,12 @@ object CoursierInputsTasks {
         }
       }
 
-  private[sbt] def coursierExtraProjectsTask: Def.Initialize[sbt.Task[Seq[CProject]]] = {
+  private[sbt] def coursierExtraProjectsTask: Def.Initialize[sbt.Task[Seq[CProject]]] =
     Def.task {
       // Coursier handles inter-project dependencies natively via csrInterProjectDependencies.
       // When IvyDependencyPlugin is enabled, it overrides csrExtraProjects with Ivy descriptors.
       Seq.empty[CProject]
     }
-  }
 
   private[sbt] def coursierFallbackDependenciesTask
       : Def.Initialize[sbt.Task[Seq[FallbackDependency]]] =
@@ -139,12 +135,11 @@ object CoursierInputsTasks {
       .flatMap {
         case dc: IvyCredentials.DirectCredentials => List(dc)
         case fc: IvyCredentials.FileCredentials   =>
-          sbt.librarymanagement.CredentialUtils.loadCredentials(fc.path) match {
+          sbt.librarymanagement.CredentialUtils.loadCredentials(fc.path) match
             case Left(err) =>
               log.warn(s"$err, ignoring it")
               Nil
             case Right(dc) => List(dc)
-          }
       }
       .map { c =>
         DirectCredentials()
@@ -162,7 +157,7 @@ object CoursierInputsTasks {
     val cm = conflictManager.value
     val log = streams.value.log
 
-    cm.name match {
+    cm.name match
       case ConflictManager.latestRevision.name =>
         None
       case ConflictManager.strict.name =>
@@ -172,6 +167,5 @@ object CoursierInputsTasks {
       case other =>
         log.warn(s"Unsupported conflict manager $other")
         None
-    }
   }
-}
+end CoursierInputsTasks
diff --git a/main/src/main/scala/sbt/coursierint/CoursierRepositoriesTasks.scala b/main/src/main/scala/sbt/coursierint/CoursierRepositoriesTasks.scala
index f32d9fc55..ab39f1891 100644
--- a/main/src/main/scala/sbt/coursierint/CoursierRepositoriesTasks.scala
+++ b/main/src/main/scala/sbt/coursierint/CoursierRepositoriesTasks.scala
@@ -14,8 +14,8 @@ import sbt.Keys.*
 import sbt.ProjectExtra.transitiveInterDependencies
 import sbt.ScopeFilter.Make.*
 
-object CoursierRepositoriesTasks {
-  private object CResolvers {
+object CoursierRepositoriesTasks:
+  private object CResolvers:
     private val slowReposBase = Seq(
       "https://repo.typesafe.com/",
       "https://repo.scala-sbt.org/",
@@ -29,7 +29,7 @@ object CoursierRepositoriesTasks {
     )
 
     private def url(res: Resolver): Option[String] =
-      res match {
+      res match
         case m: sbt.librarymanagement.MavenRepository =>
           Some(m.root)
         case u: URLRepository =>
@@ -37,7 +37,6 @@ object CoursierRepositoriesTasks {
             .orElse(u.patterns.ivyPatterns.headOption)
         case _ =>
           None
-      }
 
     private def fastRepo(res: Resolver): Boolean =
       url(res).exists(u => fastReposBase.exists(u.startsWith))
@@ -46,11 +45,11 @@ object CoursierRepositoriesTasks {
       url(res).exists(u => slowReposBase.exists(u.startsWith))
 
     def reorderResolvers(resolvers: Seq[Resolver]): Seq[Resolver] =
-      if (resolvers.exists(fastRepo) && resolvers.exists(slowRepo)) {
+      if resolvers.exists(fastRepo) && resolvers.exists(slowRepo) then
         val (slow, other) = resolvers.partition(slowRepo)
         other ++ slow
-      } else resolvers
-  }
+      else resolvers
+  end CResolvers
 
   // local-preloaded-ivy contains dangling ivy.xml without JAR files
   // https://github.com/sbt/sbt/issues/4661
@@ -64,10 +63,10 @@ object CoursierRepositoriesTasks {
 
     val paths = ivyPaths.value
     val result1 =
-      if (reorderResolvers) CResolvers.reorderResolvers(result0)
+      if reorderResolvers then CResolvers.reorderResolvers(result0)
       else result0
     val result2 =
-      paths.ivyHome match {
+      paths.ivyHome match
         case Some(ivyHome) =>
           val ivyHomeUri = ivyHome
           result1 map {
@@ -84,10 +83,8 @@ object CoursierRepositoriesTasks {
             case r => r
           }
         case _ => result1
-      }
 
-    if (keepPreloaded)
-      result2
+    if keepPreloaded then result2
     else
       result2.filter { r =>
         !r.name.startsWith("local-preloaded")
@@ -113,12 +110,10 @@ object CoursierRepositoriesTasks {
     }
 
     val resolvers0 =
-      if (pluginIvySnapshotsFound && !resolvers.contains(Classpaths.sbtPluginReleases))
+      if pluginIvySnapshotsFound && !resolvers.contains(Classpaths.sbtPluginReleases) then
         resolvers :+ Classpaths.sbtPluginReleases
-      else
-        resolvers
-    if (keepPreloaded)
-      resolvers0
+      else resolvers
+    if keepPreloaded then resolvers0
     else
       resolvers0.filter { r =>
         !r.name.startsWith("local-preloaded")
@@ -139,4 +134,4 @@ object CoursierRepositoriesTasks {
           resolvers.flatten
         }
       }
-}
+end CoursierRepositoriesTasks
diff --git a/main/src/main/scala/sbt/coursierint/LMCoursier.scala b/main/src/main/scala/sbt/coursierint/LMCoursier.scala
index 3825617e5..22b50cdee 100644
--- a/main/src/main/scala/sbt/coursierint/LMCoursier.scala
+++ b/main/src/main/scala/sbt/coursierint/LMCoursier.scala
@@ -31,13 +31,13 @@ import sbt.util.Logger
 import sbt.io.syntax.*
 import xsbti.AppConfiguration
 
-object LMCoursier {
+object LMCoursier:
   private val credentialRegistry: ConcurrentHashMap[(String, String), IvyCredentials] =
     new ConcurrentHashMap
 
-  def defaultCacheLocation: File = {
+  def defaultCacheLocation: File =
     def absoluteFile(path: String): File = new File(path).getAbsoluteFile()
-    def windowsCacheDirectory: File = {
+    def windowsCacheDirectory: File =
       // Per discussion in https://github.com/dirs-dev/directories-jvm/issues/43,
       // LOCALAPPDATA environment variable may NOT represent the one-true
       // Known Folders API (https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid)
@@ -53,18 +53,16 @@ object LMCoursier {
           .map(absoluteFile)
           .getOrElse(absoluteFile(sys.props("user.home")) / "AppData" / "Local")
       base / "Coursier" / "Cache" / "v1"
-    }
     sys.props
       .get("sbt.coursier.home")
       .map(home => absoluteFile(home) / "cache")
       .orElse(sys.env.get("COURSIER_CACHE").map(absoluteFile))
-      .orElse(sys.props.get("coursier.cache").map(absoluteFile)) match {
+      .orElse(sys.props.get("coursier.cache").map(absoluteFile)) match
       case Some(dir) => dir
       case _         =>
         if Util.isWindows then windowsCacheDirectory
         else CoursierDependencyResolution.defaultCacheLocation
-    }
-  }
+  end defaultCacheLocation
 
   def relaxedForAllModules: Seq[(ModuleMatchers, Reconciliation)] =
     Vector((ModuleMatchers.all, Reconciliation.Relaxed))
@@ -95,7 +93,7 @@ object LMCoursier {
       localArtifactsShouldBeCached: Boolean,
       lockFile: Option[File],
       log: Logger
-  ): CoursierConfiguration = {
+  ): CoursierConfiguration =
     val coursierExcludeDeps = Inputs
       .exclusions(
         excludeDeps,
@@ -118,10 +116,9 @@ object LMCoursier {
     val userForceVersions = Inputs.forceVersions(depsOverrides, scalaVer, scalaBinaryVer)
     Classpaths.warnResolversConflict(rs, log)
     Classpaths.errorInsecureProtocol(rs, log)
-    val missingOk = updateConfig match {
+    val missingOk = updateConfig match
       case Some(uc) => uc.missingOk
       case _        => false
-    }
     CoursierConfiguration()
       .withResolvers(rs.toVector)
       .withInterProjectDependencies(interProjectDependencies.toVector)
@@ -147,12 +144,12 @@ object LMCoursier {
       .withSameVersions(sameVersions)
       .withLocalArtifactsShouldBeCached(localArtifactsShouldBeCached)
       .withLockFile(lockFile)
-  }
+  end coursierConfiguration
 
   def coursierConfigurationTask: Def.Initialize[Task[CoursierConfiguration]] = Def.task {
     val sv = scalaVersion.value
     val lockFile = dependencyLockFile.value
-    val lockFileOpt = if (lockFile.exists()) Some(lockFile) else None
+    val lockFileOpt = if lockFile.exists() then Some(lockFile) else None
     val ivyHomeOpt = ivyPaths.value.ivyHome.map(new File(_))
     coursierConfiguration(
       csrRecursiveResolvers.value,
@@ -259,7 +256,7 @@ object LMCoursier {
     // resolution run in parallel across modules. Under the super shell we feed the per-command
     // resolution-progress sink (rendered as one task-level line by TaskProgress); otherwise the
     // quiet debug logger.
-    if (progress)
+    if progress then
       Some(
         Keys.state.value
           .get(Keys.resolutionProgress)
@@ -269,37 +266,33 @@ object LMCoursier {
     else Some(new CoursierLogger(st.log))
   }
 
-  class CoursierLogger(logger: Logger) extends CacheLogger {
+  class CoursierLogger(logger: Logger) extends CacheLogger:
     override def downloadedArtifact(url: String, success: Boolean): Unit =
       logger.debug(s"downloaded $url")
-  }
 
-  def publicationsSetting(packageConfigs: Seq[(Configuration, CConfiguration)]): Def.Setting[?] = {
+  def publicationsSetting(packageConfigs: Seq[(Configuration, CConfiguration)]): Def.Setting[?] =
     csrPublications := Def.uncached(
       CoursierArtifactsTasks.coursierPublicationsTask(packageConfigs*).value
     )
-  }
 
   // This emulates Ivy's credential registration which basically keeps mutating global registry
   def allCredentialsTask: Def.Initialize[Task[Seq[IvyCredentials]]] = Def.task {
     val st = streams.value
-    def registerCredentials(creds: IvyCredentials): Unit = {
-      (creds match {
+    def registerCredentials(creds: IvyCredentials): Unit =
+      (creds match
         case dc: IvyCredentials.DirectCredentials =>
           Right[String, IvyCredentials.DirectCredentials](dc)
         case fc: IvyCredentials.FileCredentials =>
           sbt.librarymanagement.CredentialUtils.loadCredentials(fc.path)
-      }) match {
+      ) match
         case Left(err) => st.log.warn(err)
         case Right(d)  =>
           credentialRegistry.put((d.host, d.realm), d)
           ()
-      }
-    }
     import scala.jdk.CollectionConverters.*
     (ThisBuild / Keys.credentials).value foreach registerCredentials
     (LocalRootProject / Keys.credentials).value foreach registerCredentials
     Keys.credentials.value foreach registerCredentials
     credentialRegistry.values.asScala.toVector
   }
-}
+end LMCoursier
diff --git a/main/src/main/scala/sbt/coursierint/ResolutionProgress.scala b/main/src/main/scala/sbt/coursierint/ResolutionProgress.scala
index 5d5f2b592..9b12f17f8 100644
--- a/main/src/main/scala/sbt/coursierint/ResolutionProgress.scala
+++ b/main/src/main/scala/sbt/coursierint/ResolutionProgress.scala
@@ -32,43 +32,38 @@ import lmcoursier.definitions.CacheLogger
  *
  * There is no cross-command reset: the instance is born empty and discarded with the command.
  */
-private[sbt] final class ResolutionProgress {
+private[sbt] final class ResolutionProgress:
   private val inFlight = new AtomicInteger(0)
   private val burstStartNanos = new AtomicLong(System.nanoTime())
   private val files = ConcurrentHashMap.newKeySet[String]
   private val bytes = new AtomicLong(0L)
   private val seen = new ConcurrentHashMap[String, java.lang.Long]
 
-  def onInit(): Unit = {
+  def onInit(): Unit =
     val now = System.nanoTime()
     // 0 -> 1 starts a new burst (e.g. the artifacts phase after an idle gap): restart the clock.
-    if (inFlight.getAndIncrement() == 0) burstStartNanos.set(now)
+    if inFlight.getAndIncrement() == 0 then burstStartNanos.set(now)
     ()
-  }
 
-  def onStop(): Unit = {
+  def onStop(): Unit =
     inFlight.updateAndGet(n => math.max(0, n - 1))
     ()
-  }
 
-  def onFile(url: String): Unit = {
-    if (!ResolutionProgress.isChecksumLike(url)) files.add(url)
+  def onFile(url: String): Unit =
+    if !ResolutionProgress.isChecksumLike(url) then files.add(url)
     ()
-  }
 
-  def onProgress(url: String, downloaded: Long): Unit = {
+  def onProgress(url: String, downloaded: Long): Unit =
     // compute keeps the read-compare-add atomic per url, so concurrent progress callbacks for the
     // same url can neither double-count nor lose a byte delta; `seen` always holds the max seen.
     seen.compute(
       url,
-      (_: String, prev: java.lang.Long) => {
-        val p: Long = if (prev == null) 0L else prev.longValue
-        if (downloaded > p) bytes.addAndGet(downloaded - p)
+      (_: String, prev: java.lang.Long) =>
+        val p: Long = if prev == null then 0L else prev.longValue
+        if downloaded > p then bytes.addAndGet(downloaded - p)
         java.lang.Long.valueOf(math.max(downloaded, p))
-      }
     )
     ()
-  }
 
   /**
    * While at least one resolution is in flight: the render line plus the elapsed micros of the
@@ -76,37 +71,33 @@ private[sbt] final class ResolutionProgress {
    * counter). Else None (the line disappears).
    */
   def snapshot(): Option[(String, Long)] =
-    if (inFlight.get() <= 0) None
-    else {
+    if inFlight.get() <= 0 then None
+    else
       val n = files.size()
       val mib = bytes.get().toDouble / (1024.0 * 1024.0)
-      val label = if (n == 1) "file" else "files"
+      val label = if n == 1 then "file" else "files"
       val elapsedMicros = math.max(0L, (System.nanoTime() - burstStartNanos.get()) / 1000L)
       Some((f"downloading $n $label, $mib%.1f MiB", elapsedMicros))
-    }
-}
+end ResolutionProgress
 
-private[sbt] object ResolutionProgress {
+private[sbt] object ResolutionProgress:
   // Checksum/signature companions go through the same cache callbacks as real files; counting
   // them would roughly double the file count.
   private val checksumLikeSuffixes = Seq(".sha1", ".sha256", ".sha512", ".md5", ".asc", ".sig")
-  private[coursierint] def isChecksumLike(url: String): Boolean = {
+  private[coursierint] def isChecksumLike(url: String): Boolean =
     val lower = url.toLowerCase(java.util.Locale.ROOT)
     checksumLikeSuffixes.exists(s => lower.endsWith(s))
-  }
-}
 
 /**
  * A coursier `CacheLogger` that feeds a per-command [[ResolutionProgress]]. Supplying any logger to
  * lm-coursier suppresses coursier's own per-module progress bar and lets resolution run in parallel
  * across modules; the aggregate is rendered at the sbt task level instead.
  */
-private[sbt] final class ResolutionProgressLogger(sink: ResolutionProgress) extends CacheLogger {
+private[sbt] final class ResolutionProgressLogger(sink: ResolutionProgress) extends CacheLogger:
   override def init(sizeHint: Option[Int]): Unit = sink.onInit()
   override def stop(): Unit = sink.onStop()
   override def foundLocally(url: String): Unit = sink.onFile(url)
   override def downloadedArtifact(url: String, success: Boolean): Unit =
-    if (success) sink.onFile(url)
+    if success then sink.onFile(url)
   override def downloadProgress(url: String, downloaded: Long): Unit =
     sink.onProgress(url, downloaded)
-}
diff --git a/main/src/main/scala/sbt/internal/APIMappings.scala b/main/src/main/scala/sbt/internal/APIMappings.scala
index d6820f495..e2d22827a 100644
--- a/main/src/main/scala/sbt/internal/APIMappings.scala
+++ b/main/src/main/scala/sbt/internal/APIMappings.scala
@@ -17,7 +17,7 @@ import sbt.internal.util.Attributed
 import sbt.util.Logger
 import xsbti.HashedVirtualFileRef
 
-private[sbt] object APIMappings {
+private[sbt] object APIMappings:
   def extract(
       cp: Seq[Attributed[HashedVirtualFileRef]],
       log: Logger
@@ -57,4 +57,4 @@ private[sbt] object APIMappings {
     entryAPI match
       case None    => attr
       case Some(u) => attr.put(Keys.entryApiURL, u.toString)
-}
+end APIMappings
diff --git a/main/src/main/scala/sbt/internal/AbstractTaskExecuteProgress.scala b/main/src/main/scala/sbt/internal/AbstractTaskExecuteProgress.scala
index 20aaaee58..1b66f85d4 100644
--- a/main/src/main/scala/sbt/internal/AbstractTaskExecuteProgress.scala
+++ b/main/src/main/scala/sbt/internal/AbstractTaskExecuteProgress.scala
@@ -19,63 +19,56 @@ import scala.concurrent.duration.*
 
 private[sbt] abstract class AbstractTaskExecuteProgress(
     configNameToIdent: String => String = Scope.guessConfigIdent
-) extends ExecuteProgress {
+) extends ExecuteProgress:
   import AbstractTaskExecuteProgress.Timer
 
   private val showScopedKey = Def.showShortKey(None, configNameToIdent)
   private val anonOwners = new ConcurrentHashMap[TaskId[?], TaskId[?]]
   private val calledBy = new ConcurrentHashMap[TaskId[?], TaskId[?]]
   private val timings = new ConcurrentHashMap[TaskId[?], Timer]
-  private[sbt] def timingsByName: mutable.Map[String, AtomicLong] = {
+  private[sbt] def timingsByName: mutable.Map[String, AtomicLong] =
     val result = new ConcurrentHashMap[String, AtomicLong]
     timings.forEach { (task, timing) =>
       val duration = timing.durationNanos
-      result.putIfAbsent(taskName(task), new AtomicLong(duration)) match {
+      result.putIfAbsent(taskName(task), new AtomicLong(duration)) match
         case null =>
         case t    => t.getAndAdd(duration); ()
-      }
     }
     result.asScala
-  }
   private[sbt] def anyTimings = !timings.isEmpty
   def currentTimings: Iterator[(TaskId[?], Timer)] = timings.asScala.iterator
 
   private[internal] def exceededThreshold(task: TaskId[?], threshold: FiniteDuration): Boolean =
-    timings.get(task) match {
+    timings.get(task) match
       case null => false
       case t    => t.durationMicros > threshold.toMicros
-    }
   private[internal] def timings(
       tasks: java.util.Set[TaskId[?]],
       thresholdMicros: Long
-  ): Vector[(TaskId[?], Long)] = {
+  ): Vector[(TaskId[?], Long)] =
     val result = new VectorBuilder[(TaskId[?], Long)]
     val now = System.nanoTime
     tasks.forEach { t =>
-      timings.get(t) match {
+      timings.get(t) match
         case null   =>
         case timing =>
-          if (timing.isActive) {
+          if timing.isActive then
             val elapsed = (now - timing.startNanos) / 1000
-            if (elapsed > thresholdMicros) result += t -> elapsed
-          }
-      }
+            if elapsed > thresholdMicros then result += t -> elapsed
     }
     result.result()
-  }
-  def activeTasks(now: Long) = {
+  def activeTasks(now: Long) =
     val result = new VectorBuilder[(TaskId[?], FiniteDuration)]
     timings.forEach { (task, timing) =>
-      if (timing.isActive) result += task -> (now - timing.startNanos).nanos
+      if timing.isActive then result += task -> (now - timing.startNanos).nanos
     }
     result.result()
-  }
 
   override def afterRegistered(
       task: TaskId[?],
       allDeps: Iterable[TaskId[?]],
       pendingDeps: Iterable[TaskId[?]]
-  ): Unit = {
+  ): Unit =
     // we need this to infer anonymous task names
     pendingDeps
       .withFilter {
@@ -83,37 +76,32 @@ private[sbt] abstract class AbstractTaskExecuteProgress(
         case _          => true
       }
       .foreach(anonOwners.put(_, task))
-  }
 
-  override def beforeWork(task: TaskId[?]): Unit = {
+  override def beforeWork(task: TaskId[?]): Unit =
     timings.put(task, new Timer)
     ()
-  }
 
   protected def clearTimings: Boolean = false
-  override def afterWork[A](task: TaskId[A], result: Either[TaskId[A], Result[A]]): Unit = {
-    if (clearTimings) timings.remove(task)
+  override def afterWork[A](task: TaskId[A], result: Either[TaskId[A], Result[A]]): Unit =
+    if clearTimings then timings.remove(task)
     else
-      timings.get(task) match {
+      timings.get(task) match
         case null =>
         case t    => t.stop()
-      }
 
     // we need this to infer anonymous task names
     result.left.foreach { t =>
       calledBy.put(t, task)
     }
-  }
 
   private val taskNameCache = new ConcurrentHashMap[TaskId[?], String]
-  protected def taskName(t: TaskId[?]): String = taskNameCache.get(t) match {
+  protected def taskName(t: TaskId[?]): String = taskNameCache.get(t) match
     case null =>
       val name = taskName0(t)
       taskNameCache.putIfAbsent(t, name)
       name
     case name => name
-  }
-  private def taskName0(t: TaskId[?]): String = {
+  private def taskName0(t: TaskId[?]): String =
     def definedName(node: Task[?]): Option[String] =
       node.name.orElse(TaskName.transformNode(node).map(showScopedKey.show))
     def inferredName(t: Task[?]): Option[String] = nameDelegate(t) map taskName
@@ -122,23 +110,19 @@ private[sbt] abstract class AbstractTaskExecuteProgress(
     t match
       case t: Task[?] => definedName(t).orElse(inferredName(t)).getOrElse(TaskName.anonymousName(t))
       case _          => TaskName.anonymousName(t)
-  }
-}
+end AbstractTaskExecuteProgress
 
-object AbstractTaskExecuteProgress {
-  private[sbt] class Timer() {
+object AbstractTaskExecuteProgress:
+  private[sbt] class Timer():
     val startNanos: Long = System.nanoTime()
     val threadName: String = Thread.currentThread().getName
     val threadId: Long = Util.threadId
     var endNanos: Long = 0L
-    def stop(): Unit = {
+    def stop(): Unit =
       endNanos = System.nanoTime()
-    }
     def isActive = endNanos == 0L
     def durationNanos: Long = endNanos - startNanos
     def startMicros: Long = (startNanos.toDouble / 1000).toLong
     def durationMicros: Long = (durationNanos.toDouble / 1000).toLong
     def currentElapsedMicros: Long =
       ((System.nanoTime() - startNanos).toDouble / 1000).toLong
-  }
-}
diff --git a/main/src/main/scala/sbt/internal/Act.scala b/main/src/main/scala/sbt/internal/Act.scala
index 65c49a487..09a31a03e 100644
--- a/main/src/main/scala/sbt/internal/Act.scala
+++ b/main/src/main/scala/sbt/internal/Act.scala
@@ -32,16 +32,14 @@ import scala.collection.mutable
 
 final class ParsedKey(val key: ScopedKey[?], val mask: ScopeMask):
   override def equals(o: Any): Boolean =
-    this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    this.eq(o.asInstanceOf[AnyRef]) || (o match
       case x: ParsedKey => (this.key == x.key) && (this.mask == x.mask)
-      case _            => false
-    })
-  override def hashCode: Int = {
+      case _            => false)
+  override def hashCode: Int =
     37 * (37 * (37 * (17 + "sbt.internal.ParsedKey".##) + this.key.##)) + this.mask.##
-  }
 end ParsedKey
 
-object Act {
+object Act:
   private[sbt] val GlobalIdent = "Global"
   private[sbt] val ZeroIdent = "Zero"
   private[sbt] val ThisBuildIdent = "ThisBuild"
@@ -72,22 +70,20 @@ object Act {
       defaultConfigs: Option[ResolvedReference] => Seq[String],
       structure: BuildStructure
   ): KeysParser =
-    for (
-        selected <- scopedKeySelected(
-          structure.index.aggregateKeyIndex,
-          current,
-          defaultConfigs,
-          structure.index.keyMap,
-          structure.data,
-          askProject = true,
-          structure = Some(structure),
-        )
-      )
-      yield Aggregation.aggregate(
-        selected.key.asInstanceOf[ScopedKey[Any]],
-        selected.mask,
-        structure.extra
+    for selected <- scopedKeySelected(
+        structure.index.aggregateKeyIndex,
+        current,
+        defaultConfigs,
+        structure.index.keyMap,
+        structure.data,
+        askProject = true,
+        structure = Some(structure),
       )
+    yield Aggregation.aggregate(
+      selected.key.asInstanceOf[ScopedKey[Any]],
+      selected.mask,
+      structure.extra
+    )
 
   def scopedKeyAggregatedFilter(
       current: ProjectRef,
@@ -132,7 +128,7 @@ object Act {
       defaultConfigs: Option[ResolvedReference] => Seq[String],
       keyMap: Map[String, AttributeKey[?]],
       askProject: Boolean,
-  ): Parser[Seq[Parser[ParsedKey]]] = {
+  ): Parser[Seq[Parser[ParsedKey]]] =
     val confParserCache: mutable.Map[Option[sbt.ResolvedReference], Parser[ParsedAxis[String]]] =
       mutable.Map.empty
     def fullKey =
@@ -154,9 +150,8 @@ object Act {
 
     val globalIdent = token(GlobalIdent ~ spacedSlash) ^^^ ParsedGlobal
     def globalKey =
-      for {
-        g <- globalIdent
-      } yield taskKeyExtra(
+      for g <- globalIdent
+      yield taskKeyExtra(
         index,
         defaultConfigs,
         keyMap,
@@ -166,7 +161,7 @@ object Act {
       )
 
     globalKey | fullKey
-  }
+  end scopedKeyFull
 
   def taskKeyExtra(
       index: KeyIndex,
@@ -176,18 +171,16 @@ object Act {
       confAmb: ParsedAxis[String],
       baseMask: ScopeMask,
   ): Seq[Parser[ParsedKey]] =
-    for {
-      conf <- configs(confAmb, defaultConfigs, proj, index)
-    } yield
-      for {
+    for conf <- configs(confAmb, defaultConfigs, proj, index)
+    yield
+      for
         taskAmb <- taskAxis(index.tasks(proj, conf), keyMap)
         task = resolveTask(taskAmb)
         key <- key(index, proj, conf, task, keyMap)
         extra <- extraAxis(keyMap, IMap.empty)
-      } yield {
+      yield
         val mask = baseMask.copy(task = taskAmb.isExplicit, extra = true)
         ParsedKey(makeScopedKey(proj, conf, task, extra, key), mask)
-      }
 
   def makeScopedKey(
       proj: Option[ResolvedReference],
@@ -239,30 +232,26 @@ object Act {
   def selectFromValid(ss: Seq[ParsedKey], default: Parser[ParsedKey])(using
       show: Show[ScopedKey[?]]
   ): Parser[ParsedKey] =
-    selectByTask(selectByConfig(ss)) match {
+    selectByTask(selectByConfig(ss)) match
       case Seq()       => default
       case Seq(single) => success(single)
       case multi       => failure("Ambiguous keys: " + showAmbiguous(keys(multi)))
-    }
   private def keys(ss: Seq[ParsedKey]): Seq[ScopedKey[?]] = ss.map(_.key)
   def selectByConfig(ss: Seq[ParsedKey]): Seq[ParsedKey] =
-    ss match {
+    ss match
       case Seq()         => Nil
       case Seq(x, tail*) => // select the first configuration containing a valid key
-        tail.takeWhile(_.key.scope.config == x.key.scope.config) match {
+        tail.takeWhile(_.key.scope.config == x.key.scope.config) match
           case Seq() => x :: Nil
           case xs    => x +: xs
-        }
-    }
-  def selectByTask(ss: Seq[ParsedKey]): Seq[ParsedKey] = {
+  def selectByTask(ss: Seq[ParsedKey]): Seq[ParsedKey] =
     val (selects, zeros) = ss.partition(_.key.scope.task.isSelect)
-    if (zeros.nonEmpty) zeros else selects
-  }
+    if zeros.nonEmpty then zeros else selects
 
   def noValidKeys: Parser[ParsedKey] = failure("No such key.")
 
   def showAmbiguous(keys: Seq[ScopedKey[?]])(using show: Show[ScopedKey[?]]): String =
-    keys.take(3).map(x => show.show(x)).mkString("", ", ", if (keys.size > 3) ", ..." else "")
+    keys.take(3).map(x => show.show(x)).mkString("", ", ", if keys.size > 3 then ", ..." else "")
 
   def isValid(data: Def.Settings)(parsed: ParsedKey): Boolean = data.contains(parsed.key)
 
@@ -278,7 +267,9 @@ object Act {
     }
 
   def toAxis[T](opt: Option[T], ifNone: ScopeAxis[T]): ScopeAxis[T] =
-    opt match { case Some(t) => Select(t); case None => ifNone }
+    opt match
+      case Some(t) => Select(t);
+      case None    => ifNone
 
   // New configuration parser that's able to parse configuration ident trailed by slash.
   private[sbt] def configIdent(
@@ -298,14 +289,13 @@ object Act {
       proj: Option[ResolvedReference],
       index: KeyIndex
   ): Seq[Option[String]] =
-    explicit match {
+    explicit match
       case Omitted =>
         None +: defaultConfigurations(proj, index, defaultConfigs).flatMap(
           nonEmptyConfig(index, proj)
         )
       case ParsedZero | ParsedGlobal => None :: Nil
       case pv: ParsedValue[x]        => Some(pv.value) :: Nil
-    }
 
   def defaultConfigurations(
       proj: Option[ResolvedReference],
@@ -318,7 +308,7 @@ object Act {
       index: KeyIndex,
       proj: Option[ResolvedReference]
   ): String => Seq[Option[String]] =
-    config => if (index.isEmpty(proj, Some(config))) Nil else Some(config) :: Nil
+    config => if index.isEmpty(proj, Some(config)) then Nil else Some(config) :: Nil
 
   def key(
       index: KeyIndex,
@@ -326,7 +316,7 @@ object Act {
       conf: Option[String],
       task: Option[AttributeKey[?]],
       keyMap: Map[String, AttributeKey[?]]
-  ): Parser[AttributeKey[?]] = {
+  ): Parser[AttributeKey[?]] =
     def dropHyphenated(keys: Set[String]): Set[String] = keys.filterNot(Util.hasHyphen)
     def keyParser(keys: Set[String]): Parser[AttributeKey[?]] =
       token((ID !!! "Expected key").examples(dropHyphenated(keys))).flatMap: keyString =>
@@ -336,45 +326,41 @@ object Act {
     // The parser already accepts build-level keys.
     // This queries the key index so tab completion will list the build-level keys.
     val buildKeys: Set[String] =
-      proj match {
+      proj match
         case Some(ProjectRef(uri, _)) => index.keys(Some(BuildRef(uri)), conf, task)
         case _                        => Set()
-      }
     val globalKeys: Set[String] =
-      proj match {
+      proj match
         case Some(_) => index.keys(None, conf, task)
         case _       => Set()
-      }
     val keys: Set[String] = index.keys(proj, conf, task) ++ buildKeys ++ globalKeys
     keyParser(keys)
-  }
+  end key
 
   def getKey[T](
       keyMap: Map[String, AttributeKey[?]],
       keyString: String,
       f: AttributeKey[?] => T
   ): Parser[T] =
-    keyMap.get(keyString) match {
+    keyMap.get(keyString) match
       case Some(k) => success(f(k))
       case None    => failure(Command.invalidValue("key", keyMap.keys)(keyString))
-    }
 
   val spacedComma = token(OptSpace ~ ',' ~ OptSpace)
 
   def extraAxis(
       knownKeys: Map[String, AttributeKey[?]],
       knownValues: IMap[AttributeKey, Set]
-  ): Parser[ScopeAxis[AttributeMap]] = {
+  ): Parser[ScopeAxis[AttributeMap]] =
     val extrasP = extrasParser(knownKeys, knownValues)
     val extras =
       token('(', hide = (x: Int) => x == 1 && knownValues.isEmpty) ~> extrasP <~ token(')')
     optionalAxis(extras, Zero)
-  }
 
   def taskAxis(
       tasks: Set[AttributeKey[?]],
       allKnown: Map[String, AttributeKey[?]],
-  ): Parser[ParsedAxis[AttributeKey[?]]] = {
+  ): Parser[ParsedAxis[AttributeKey[?]]] =
     val taskSeq = tasks.toSeq
     def taskKeys(f: AttributeKey[?] => String): Seq[(String, AttributeKey[?])] =
       taskSeq.map(key => (f(key), key))
@@ -386,13 +372,11 @@ object Act {
     (token(
       value(keyP) | (ZeroIdent ^^^ ParsedZero)
     ) <~ spacedSlash) ?? Omitted
-  }
 
   def resolveTask(task: ParsedAxis[AttributeKey[?]]): Option[AttributeKey[?]] =
-    task match {
+    task match
       case ParsedZero | ParsedGlobal | Omitted        => None
       case t: ParsedValue[AttributeKey[?]] @unchecked => Some(t.value)
-    }
 
   def filterStrings(base: Parser[String], valid: Set[String], label: String): Parser[String] =
     base.filter(valid, Command.invalidValue(label, valid))
@@ -400,18 +384,15 @@ object Act {
   def extrasParser(
       knownKeys: Map[String, AttributeKey[?]],
       knownValues: IMap[AttributeKey, Set]
-  ): Parser[AttributeMap] = {
+  ): Parser[AttributeMap] =
     val validKeys = knownKeys.filter { case (_, key) => knownValues.get(key).exists(_.nonEmpty) }
-    if (validKeys.isEmpty)
-      failure("No valid extra keys.")
-    else
-      rep1sep(extraParser(validKeys, knownValues), spacedComma).map(AttributeMap.apply)
-  }
+    if validKeys.isEmpty then failure("No valid extra keys.")
+    else rep1sep(extraParser(validKeys, knownValues), spacedComma).map(AttributeMap.apply)
 
   def extraParser(
       knownKeys: Map[String, AttributeKey[?]],
       knownValues: IMap[AttributeKey, Set]
-  ): Parser[AttributeEntry[?]] = {
+  ): Parser[AttributeEntry[?]] =
     val keyp = knownIDParser(knownKeys, "Not a valid extra key") <~ token(':' ~ OptSpace)
     keyp flatMap { case key: AttributeKey[t] =>
       val valueMap: Map[String, t] = knownValues(key).map(v => (v.toString, v)).toMap
@@ -419,29 +400,26 @@ object Act {
         AttributeEntry(key, value)
       }
     }
-  }
   def knownIDParser[T](knownKeys: Map[String, T], label: String): Parser[T] =
     token(examplesStrict(ID, knownKeys.keys.toSet, label)).map(knownKeys)
 
-  def knownPluginParser[T](knownPlugins: Map[String, T], label: String): Parser[T] = {
+  def knownPluginParser[T](knownPlugins: Map[String, T], label: String): Parser[T] =
     val pluginLabelParser = rep1sep(ID, '.').map(_.mkString("."))
     token(examplesStrict(pluginLabelParser, knownPlugins.keys.toSet, label)).map(knownPlugins)
-  }
 
-  def projectRef(index: KeyIndex, currentBuild: URI): Parser[ParsedAxis[ResolvedReference]] = {
+  def projectRef(index: KeyIndex, currentBuild: URI): Parser[ParsedAxis[ResolvedReference]] =
     val zeroIdent = token(ZeroIdent ~ spacedSlash) ^^^ ParsedZero
     val thisBuildIdent = value(token(ThisBuildIdent ~ spacedSlash) ^^^ BuildRef(currentBuild))
     val trailing = spacedSlash !!! "Expected '/' (if selecting a project)"
     zeroIdent | thisBuildIdent |
       value(resolvedReferenceIdent(index, currentBuild, trailing)) |
       value(resolvedReference(index, currentBuild, trailing))
-  }
 
   private[sbt] def resolvedReferenceIdent(
       index: KeyIndex,
       currentBuild: URI,
       trailing: Parser[?]
-  ): Parser[ResolvedReference] = {
+  ): Parser[ResolvedReference] =
     def projectID(uri: URI) =
       token(
         DQuoteChar ~> examplesStrict(
@@ -464,13 +442,13 @@ object Act {
     buildRef flatMap { uri =>
       projectRef(uri)
     }
-  }
+  end resolvedReferenceIdent
 
   def resolvedReference(
       index: KeyIndex,
       currentBuild: URI,
       trailing: Parser[?]
-  ): Parser[ResolvedReference] = {
+  ): Parser[ResolvedReference] =
     def projectID(uri: URI) =
       token(examplesStrict(ID, index.projects(uri), "project ID") <~ trailing)
     def projectRef(uri: URI) = projectID(uri) map { id =>
@@ -485,7 +463,6 @@ object Act {
       case None      => projectRef(currentBuild)
       case Some(uri) => projectRef(uri) | token(trailing ^^^ BuildRef(uri))
     }
-  }
   def optProjectRef(index: KeyIndex, current: ProjectRef): Parser[ParsedAxis[ResolvedReference]] =
     projectRef(index, current.build) ?? Omitted
 
@@ -493,12 +470,11 @@ object Act {
       parsed: ParsedAxis[ResolvedReference],
       current: ProjectRef
   ): Option[ResolvedReference] =
-    parsed match {
+    parsed match
       case Omitted             => Some(current)
       case ParsedZero          => None
       case ParsedGlobal        => None
       case pv: ParsedValue[rr] => Some(pv.value)
-    }
 
   def actParser(s: State): Parser[() => State] = requireSession(s, actParser0(s))
 
@@ -622,9 +598,8 @@ object Act {
   def requireSession[T](s: State, p: => Parser[T]): Parser[T] =
     if s.get(sessionSettings).isEmpty then failure("No project loaded") else p
 
-  sealed trait ParsedAxis[+T] {
+  sealed trait ParsedAxis[+T]:
     final def isExplicit = this != Omitted
-  }
   object ParsedGlobal extends ParsedAxis[Nothing]
   object ParsedZero extends ParsedAxis[Nothing]
   object Omitted extends ParsedAxis[Nothing]
@@ -632,4 +607,4 @@ object Act {
   def value[T](t: Parser[T]): Parser[ParsedAxis[T]] = t map { v =>
     new ParsedValue(v)
   }
-}
+end Act
diff --git a/main/src/main/scala/sbt/internal/AddSettings.scala b/main/src/main/scala/sbt/internal/AddSettings.scala
index 09fe71cdc..d1f4f5c61 100644
--- a/main/src/main/scala/sbt/internal/AddSettings.scala
+++ b/main/src/main/scala/sbt/internal/AddSettings.scala
@@ -18,10 +18,9 @@ import xsbti.VirtualFile
  */
 sealed abstract class AddSettings
 
-object AddSettings {
-  private[sbt] final class Sequence(val sequence: Seq[AddSettings]) extends AddSettings {
+object AddSettings:
+  private[sbt] final class Sequence(val sequence: Seq[AddSettings]) extends AddSettings:
     override def toString: String = s"Sequence($sequence)"
-  }
   private[sbt] object User extends AddSettings
   private[sbt] final class AutoPlugins(val include: AutoPlugin => Boolean) extends AddSettings
   private[sbt] final class DefaultSbtFiles(val include: VirtualFile => Boolean) extends AddSettings
@@ -61,12 +60,11 @@ object AddSettings {
   val allDefaults: AddSettings = seq(autoPlugins, buildScalaFiles, userSettings, defaultSbtFiles)
 
   /** Combines two automatic setting configurations. */
-  def append(a: AddSettings, b: AddSettings): AddSettings = (a, b) match {
+  def append(a: AddSettings, b: AddSettings): AddSettings = (a, b) match
     case (sa: Sequence, sb: Sequence) => seq(sa.sequence ++ sb.sequence*)
     case (sa: Sequence, _)            => seq(sa.sequence :+ b*)
     case (_, sb: Sequence)            => seq(a +: sb.sequence*)
     case _                            => seq(a, b)
-  }
 
   def clearSbtFiles(a: AddSettings): AddSettings =
     tx(a) {
@@ -76,15 +74,13 @@ object AddSettings {
     } getOrElse seq()
 
   private[sbt] def tx(a: AddSettings)(f: AddSettings => Option[AddSettings]): Option[AddSettings] =
-    a match {
+    a match
       case s: Sequence =>
         s.sequence.flatMap { b =>
           tx(b)(f)
-        } match {
+        } match
           case Seq()  => None
           case Seq(x) => Some(x)
           case ss     => Some(new Sequence(ss))
-        }
       case x => f(x)
-    }
-}
+end AddSettings
diff --git a/main/src/main/scala/sbt/internal/Aggregation.scala b/main/src/main/scala/sbt/internal/Aggregation.scala
index 0fbd07f4f..8361039ac 100644
--- a/main/src/main/scala/sbt/internal/Aggregation.scala
+++ b/main/src/main/scala/sbt/internal/Aggregation.scala
@@ -23,7 +23,7 @@ import sbt.util.{ Logger, Show }
 import scala.annotation.tailrec
 
 sealed trait Aggregation
-object Aggregation {
+object Aggregation:
   final case class ShowConfig(
       settingValues: Boolean,
       taskValues: Boolean,
@@ -52,22 +52,20 @@ object Aggregation {
   def printSettings(xs: Seq[KeyValue[?]], print: String => Unit)(using
       display: Show[ScopedKey[?]]
   ): Unit =
-    xs match {
+    xs match
       case Seq(KeyValue(_, x: Seq[?])) => print(x.mkString("* ", "\n* ", ""))
       case Seq(KeyValue(_, x))         => print(x.toString)
       case _                           =>
         xs foreach { kv =>
           print(display.show(kv.key))
-          kv.value match {
+          kv.value match
             case seq: Seq[?] if seq.nonEmpty =>
               seq.foreach(item => print("\t* " + item.toString))
             case seq: Seq[?] =>
               print("\t(empty)")
             case x =>
               print("\t" + x.toString)
-          }
         }
-    }
 
   type Values[T] = Seq[KeyValue[T]]
   type AnyKeys = Values[Any]
@@ -133,6 +131,7 @@ object Aggregation {
     val stop = System.currentTimeMillis
     val cacheSummary = Def.cacheEventLog.summary.toString()
     Complete(start, stop, result, cacheSummary, newS)
+  end timedRun
 
   def runTasks[A1](
       s: State,
@@ -166,6 +165,7 @@ object Aggregation {
       case Result.Value(_) =>
         if testEntries.nonEmpty then complete.state.put(TestSummary.entriesKey, testEntries)
         else complete.state
+  end runTasks
 
   def printSuccess(
       start: Long,
@@ -188,6 +188,7 @@ object Aggregation {
         else if Terminal.get.isSuccessEnabled then log.error(msg)
       else if success then log.success("")
     else ()
+  end printSuccess
 
   def timing(startTime: Long, endTime: Long): String =
     NetworkClient.elapsedString(startTime, endTime)
@@ -196,18 +197,17 @@ object Aggregation {
       s: State,
       inputs: Values[InputTask[I]],
       show: ShowConfig
-  )(using display: Show[ScopedKey[?]]): Parser[() => State] = {
+  )(using display: Show[ScopedKey[?]]): Parser[() => State] =
     val parsers =
-      for (KeyValue(k, it) <- inputs)
-        yield it.parser(s).map(v => KeyValue(k, v))
+      for KeyValue(k, it) <- inputs
+      yield it.parser(s).map(v => KeyValue(k, v))
     Command.applyEffect(seq(parsers)) { roots =>
       runTasks(s, roots, DummyTaskMap(Nil), show)
     }
-  }
 
   def evaluatingParser(s: State, show: ShowConfig)(keys: Seq[KeyValue[?]])(using
       display: Show[ScopedKey[?]]
-  ): Parser[() => State] = {
+  ): Parser[() => State] =
 
     // to make the call sites clearer
     def separate[L](in: Seq[KeyValue[?]])(
@@ -216,8 +216,8 @@ object Aggregation {
       Util.separate(in)(f)
 
     val kvs = keys.toList
-    if (kvs.isEmpty) failure("No such setting/task")
-    else {
+    if kvs.isEmpty then failure("No such setting/task")
+    else
       val (inputTasks, other) = separate[InputTask[?]](kvs) {
         case KeyValue(k, v: InputTask[?]) => Left(KeyValue(k, v))
         case kv                           => Right(kv)
@@ -233,30 +233,28 @@ object Aggregation {
       //  tasks, and input tasks in the same call.  The code below allows settings and tasks to be mixed, but not input tasks.
       // One problem with input tasks in `all` is that many input tasks consume all input and would need syntactic delimiters.
       // Once that is addressed, the tasks constructed by the input tasks would need to be combined with the explicit tasks.
-      if (inputTasks.nonEmpty) {
-        if (other.nonEmpty) {
+      if inputTasks.nonEmpty then
+        if other.nonEmpty then
           val inputStrings = inputTasks.map(_.key).mkString("Input task(s):\n\t", "\n\t", "\n")
           val otherStrings = other.map(_.key).mkString("Task(s)/setting(s):\n\t", "\n\t", "\n")
           failure(s"Cannot mix input tasks with plain tasks/settings.  $inputStrings $otherStrings")
-        } else
+        else
           applyDynamicTasks(
             s,
             inputTasks.map { case KeyValue(k, v: InputTask[a]) => KeyValue(k, castToAny(v)) },
             show
           )
-      } else {
+      else
         val base =
-          if (tasks.isEmpty) success(() => s)
-          else
-            applyTasks(s, maps(tasks)(x => success(castToAny(x))), show)
+          if tasks.isEmpty then success(() => s)
+          else applyTasks(s, maps(tasks)(x => success(castToAny(x))), show)
         base.map { res => () =>
           val newState = res()
-          if (show.settingValues && settings.nonEmpty) printSettings(settings, show.print)
+          if show.settingValues && settings.nonEmpty then printSettings(settings, show.print)
           newState
         }
-      }
-    }
-  }
+    end if
+  end evaluatingParser
 
   // this is a hack to avoid duplicating method implementations
   private def castToAny[F[_]]: [a] => F[a] => F[Any] = [a] => (fa: F[a]) => fa.asInstanceOf[F[Any]]
@@ -310,6 +308,7 @@ object Aggregation {
         // recursive because an aggregate project can be aggregated in another aggregate project
         recur(filteredAggKeys, acc ++ filteredAggKeys)
     recur(keys, keys)
+  end reverseAggregate
 
   def aggregate[A1, Proj](
       key: ScopedKey[A1],
@@ -335,4 +334,4 @@ object Aggregation {
     (Scope.fillTaskAxis(key.scope, key.key) / Keys.aggregate).get(data).getOrElse(true)
   private[sbt] val suppressShow =
     AttributeKey[Boolean]("suppress-aggregation-show", Int.MaxValue)
-}
+end Aggregation
diff --git a/main/src/main/scala/sbt/internal/AnalysisUtil.scala b/main/src/main/scala/sbt/internal/AnalysisUtil.scala
index 61216c6e8..d51b5d6ce 100644
--- a/main/src/main/scala/sbt/internal/AnalysisUtil.scala
+++ b/main/src/main/scala/sbt/internal/AnalysisUtil.scala
@@ -14,7 +14,7 @@ import sbt.internal.inc.MixedAnalyzingCompiler
 import xsbti.compile.AnalysisStore as XAnalysisStore
 import xsbti.compile.analysis.ReadWriteMappers
 
-private[sbt] object AnalysisUtil {
+private[sbt] object AnalysisUtil:
   // some machines have many cores.
   // we don't want to occupy them all for analysis serialization.
   lazy val parallelism: Int =
@@ -35,4 +35,4 @@ private[sbt] object AnalysisUtil {
       reproducible = true,
       parallelism = parallelism,
     )
-}
+end AnalysisUtil
diff --git a/main/src/main/scala/sbt/internal/BuildDef.scala b/main/src/main/scala/sbt/internal/BuildDef.scala
index e9cd533a8..840a9a333 100644
--- a/main/src/main/scala/sbt/internal/BuildDef.scala
+++ b/main/src/main/scala/sbt/internal/BuildDef.scala
@@ -33,7 +33,7 @@ import scala.jdk.OptionConverters.*
 import xsbti.{ FileConverter, VirtualFileRef }
 import xsbti.compile.{ AnalysisContents, AnalysisStore, CompileAnalysis }
 
-trait BuildDef {
+trait BuildDef:
   def projectDefinitions(@deprecated("unused", "") baseDirectory: File): Seq[Project] = projects
   def projects: Seq[Project] =
     CompositeProject.expand(ReflectUtilities.allValsC(this, classOf[CompositeProject]).values.toSeq)
@@ -46,19 +46,17 @@ trait BuildDef {
    * If None, the root project is the first project in the build's root directory or just the first project if none are in the root directory.
    */
   def rootProject: Option[Project] = None
-}
 
 private[sbt] object BuildDef:
-  val defaultEmpty: BuildDef = new BuildDef { override def projects = Nil }
+  val defaultEmpty: BuildDef = new BuildDef:
+    override def projects = Nil
 
-  val default: BuildDef = new BuildDef {
+  val default: BuildDef = new BuildDef:
     override def projectDefinitions(base: File) = defaultProject(defaultID(base), base) :: Nil
-  }
 
-  def defaultAggregated(id: String, aggregate: Seq[ProjectRef]): BuildDef = new BuildDef {
+  def defaultAggregated(id: String, aggregate: Seq[ProjectRef]): BuildDef = new BuildDef:
     override def projectDefinitions(base: File): Seq[Project] =
       defaultAggregatedProject(id, base, aggregate) :: Nil
-  }
 
   def defaultID(base: File, prefix: String = "default"): String =
     prefix + "-" + Hash.trimHashString(base.getAbsolutePath, 6)
@@ -86,10 +84,9 @@ private[sbt] object BuildDef:
     // if the user has overridden the name, use the normal organization that is derived from the name.
     organization := {
       def isDefault(o: String) = thisProject.value.id == o
-      organization.?.value match {
+      organization.?.value match
         case Some(o) if !isDefault(o) => o
         case _                        => "default"
-      }
     },
     autoGeneratedProject := true,
   )
@@ -146,6 +143,7 @@ private[sbt] object BuildDef:
       case _ =>
         AnalysisCacheStats.deserialized()
         record(value, contentHash)
+  end getOrElseUpdate
 
   private[sbt] object AnalysisCacheStats:
     private val servedCount = new LongAdder
@@ -183,6 +181,7 @@ private[sbt] object BuildDef:
       ref <- metadata.get(Keys.analysis)
       content <- getContents(VirtualFileRef.of(ref))
     yield content.getAnalysis
+  end extractAnalysis
 
   /**
    * The binary format does not persist [[Compilations]], and `compileScalaBackend` derives
diff --git a/main/src/main/scala/sbt/internal/BuildDependencies.scala b/main/src/main/scala/sbt/internal/BuildDependencies.scala
index 5f7cd044e..502ac6fee 100644
--- a/main/src/main/scala/sbt/internal/BuildDependencies.scala
+++ b/main/src/main/scala/sbt/internal/BuildDependencies.scala
@@ -16,7 +16,7 @@ import BuildDependencies.*
 final class BuildDependencies private (
     val classpath: DependencyMap[ClasspathDep[ProjectRef]],
     val aggregate: DependencyMap[ProjectRef]
-) {
+):
   def classpathRefs(ref: ProjectRef): Seq[ProjectRef] = classpath(ref) map getID
   def classpathTransitiveRefs(ref: ProjectRef): Seq[ProjectRef] = classpathTransitive(ref)
 
@@ -28,8 +28,7 @@ final class BuildDependencies private (
     new BuildDependencies(classpath.updated(ref, deps ++ classpath.getOrElse(ref, Nil)), aggregate)
   def addAggregate(ref: ProjectRef, deps: ProjectRef*): BuildDependencies =
     new BuildDependencies(classpath, aggregate.updated(ref, deps ++ aggregate.getOrElse(ref, Nil)))
-}
-object BuildDependencies {
+object BuildDependencies:
   def apply(
       classpath: DependencyMap[ClasspathDep[ProjectRef]],
       aggregate: DependencyMap[ProjectRef]
@@ -38,9 +37,7 @@ object BuildDependencies {
 
   type DependencyMap[D] = Map[ProjectRef, Seq[D]]
   def transitive[D](deps: DependencyMap[D], extract: D => ProjectRef): DependencyMap[ProjectRef] =
-    for ((ref, _) <- deps) yield {
+    for (ref, _) <- deps yield
       val sorted = Dag.topologicalSort(ref)(d => deps(d) map extract)
       (ref, sorted dropRight 1)
-    }
   val getID: ClasspathDep[ProjectRef] => ProjectRef = _.project
-}
diff --git a/main/src/main/scala/sbt/internal/BuildLoader.scala b/main/src/main/scala/sbt/internal/BuildLoader.scala
index 97ba48d53..ae4cc7733 100644
--- a/main/src/main/scala/sbt/internal/BuildLoader.scala
+++ b/main/src/main/scala/sbt/internal/BuildLoader.scala
@@ -16,11 +16,9 @@ import sbt.internal.util.Types.{ const, idFun }
 import sbt.util.Logger
 import sbt.librarymanagement.ModuleID
 
-private[internal] object Alternatives {
-  extension [A, B](f: A => Option[B]) {
+private[internal] object Alternatives:
+  extension [A, B](f: A => Option[B])
     def |(g: A => Option[B]): A => Option[B] = (a: A) => f(a) orElse g(a)
-  }
-}
 import Alternatives.*
 final class MultiHandler[S, T](
     builtIn: S => Option[T],
@@ -28,13 +26,13 @@ final class MultiHandler[S, T](
     nonRoots: List[(URI, S => Option[T])],
     getURI: S => URI,
     log: S => Logger
-) {
+):
   def applyFun: S => Option[T] = apply
   def apply(info: S): Option[T] =
-    (baseLoader(info), applyNonRoots(info)) match {
+    (baseLoader(info), applyNonRoots(info)) match
       case (None, Nil)                     => None
       case (None, xs @ (_, nr) :: ignored) =>
-        if (ignored.nonEmpty)
+        if ignored.nonEmpty then
           warn(
             "Using first of multiple matching non-root build resolvers for " + getURI(info),
             log(info),
@@ -42,14 +40,13 @@ final class MultiHandler[S, T](
           )
         Some(nr)
       case (Some(b), xs) =>
-        if (xs.nonEmpty)
+        if xs.nonEmpty then
           warn("Ignoring shadowed non-root build resolver(s) for " + getURI(info), log(info), xs)
         Some(b)
-    }
 
-  def baseLoader: S => Option[T] = root match {
-    case Some(rl) => rl | builtIn; case None => builtIn
-  }
+  def baseLoader: S => Option[T] = root match
+    case Some(rl) => rl | builtIn;
+    case None     => builtIn
 
   def addNonRoot(uri: URI, loader: S => Option[T]) =
     new MultiHandler(builtIn, root, (uri, loader) :: nonRoots, getURI, log)
@@ -62,14 +59,13 @@ final class MultiHandler[S, T](
       }
     }
 
-  private def warn(baseMessage: String, log: Logger, matching: Seq[(URI, T)]): Unit = {
+  private def warn(baseMessage: String, log: Logger, matching: Seq[(URI, T)]): Unit =
     log.warn(baseMessage)
     log.debug("Non-root build resolvers defined in:")
     log.debug(matching.map(_._1).mkString("\n\t"))
-  }
-}
+end MultiHandler
 
-object BuildLoader {
+object BuildLoader:
 
   /**
    * in: Build URI and staging directory
@@ -87,7 +83,7 @@ object BuildLoader {
       val transformer: Transformer,
       val full: Loader,
       val transformAll: TransformAll
-  ) {
+  ):
     def |(cs: Components): Components =
       new Components(
         resolver | cs.resolver,
@@ -96,7 +92,6 @@ object BuildLoader {
         full | cs.full,
         transformAll andThen cs.transformAll
       )
-  }
   def transform(t: Transformer): Components = components(transformer = t)
   def resolve(r: Resolver): Components = components(resolver = r)
   def build(b: Builder): Components = components(builder = b)
@@ -113,11 +108,10 @@ object BuildLoader {
 
   def seq(a: Transformer, b: Transformer): Transformer = info => b(info.setUnit(a(info)))
 
-  sealed trait Info {
+  sealed trait Info:
     def uri: URI
     def config: LoadBuildConfiguration
     def state: State
-  }
   final class ResolveInfo(
       val uri: URI,
       val staging: File,
@@ -136,10 +130,9 @@ object BuildLoader {
       val unit: BuildUnit,
       val config: LoadBuildConfiguration,
       val state: State
-  ) extends Info {
+  ) extends Info:
     def setUnit(newUnit: BuildUnit): TransformInfo =
       new TransformInfo(uri, base, newUnit, config, state)
-  }
 
   final class LoadInfo(
       val uri: URI,
@@ -154,7 +147,7 @@ object BuildLoader {
       fail: URI => Nothing,
       s: State,
       config: LoadBuildConfiguration
-  ): BuildLoader = {
+  ): BuildLoader =
     def makeMulti[S <: Info, T](base: S => Option[T]) =
       new MultiHandler[S, T](base, None, Nil, _.uri, _.config.log)
     new BuildLoader(
@@ -167,21 +160,18 @@ object BuildLoader {
       makeMulti(base.full),
       base.transformAll
     )
-  }
 
-  def componentLoader: Loader = (info: LoadInfo) => {
+  def componentLoader: Loader = (info: LoadInfo) =>
     import info.{ config, staging, state, uri }
     val cs = info.components
-    for {
+    for
       resolve <- cs.resolver(new ResolveInfo(uri, staging, config, state))
       base = resolve()
       build <- cs.builder(new BuildInfo(uri, base, config, state))
-    } yield () => {
+    yield () =>
       val unit = build()
       cs.transformer(new TransformInfo(uri, base, unit, config, state))
-    }
-  }
-}
+end BuildLoader
 
 /**
  * Defines the responsible for loading builds.
@@ -204,7 +194,7 @@ final class BuildLoader(
     val transformer: Transformer,
     val full: MultiHandler[LoadInfo, () => BuildUnit],
     val transformAll: TransformAll
-) {
+):
   def addNonRoot(uri: URI, loaders: Components): BuildLoader =
     new BuildLoader(
       fail,
@@ -229,20 +219,17 @@ final class BuildLoader(
     )
   def resetPluginDepth: BuildLoader = copyWithNewPM(config.pluginManagement.resetDepth)
 
-  def updatePluginManagement(overrides: Set[ModuleID]): BuildLoader = {
+  def updatePluginManagement(overrides: Set[ModuleID]): BuildLoader =
     val mgmt = config.pluginManagement
     copyWithNewPM(mgmt.copy(overrides = mgmt.overrides ++ overrides))
-  }
-  private def copyWithNewPM(newpm: PluginManagement): BuildLoader = {
+  private def copyWithNewPM(newpm: PluginManagement): BuildLoader =
     val newConfig = config.copy(pluginManagement = newpm)
     new BuildLoader(fail, state, newConfig, resolvers, builders, transformer, full, transformAll)
-  }
 
   def components =
     new Components(resolvers.applyFun, builders.applyFun, transformer, full.applyFun, transformAll)
-  def apply(uri: URI): BuildUnit = {
+  def apply(uri: URI): BuildUnit =
     val info = new LoadInfo(uri, config.stagingDirectory, config, state, components)
     val load = full(info) getOrElse fail(uri)
     load()
-  }
-}
+end BuildLoader
diff --git a/main/src/main/scala/sbt/internal/BuildStructure.scala b/main/src/main/scala/sbt/internal/BuildStructure.scala
index ed43e66f8..07e756726 100644
--- a/main/src/main/scala/sbt/internal/BuildStructure.scala
+++ b/main/src/main/scala/sbt/internal/BuildStructure.scala
@@ -36,7 +36,7 @@ final class BuildStructure(
     val scopeLocal: ScopeLocal,
     private[sbt] val compiledMap: Map[ScopedKey[?], Def.Compiled[?]],
     private[sbt] val converter: MappedFileConverter,
-) {
+):
   val extra: BuildUtil[ResolvedProject] = BuildUtil(root, units, index.keyIndex, data)
 
   /** The root project for the specified build.  Throws if no build or empty build. */
@@ -65,8 +65,7 @@ final class BuildStructure(
   /** Foreach project in the specified build apply the specified function. */
   private def eachProject[A](build: URI, f: ResolvedProject => A): Seq[A] =
     units.get(build).iterator.flatMap(_.projects).map(f).toIndexedSeq
-
-}
+end BuildStructure
 
 // information that is not original, but can be reconstructed from the rest of BuildStructure
 final class StructureIndex(
@@ -89,7 +88,7 @@ final class LoadedBuildUnit(
     val defined: Map[String, ResolvedProject],
     val rootProjects: Seq[String],
     val buildSettings: Seq[Setting[?]]
-) extends BuildUnitBase {
+) extends BuildUnitBase:
 
   /**
    * The project to use as the default when one is not otherwise selected.
@@ -126,7 +125,7 @@ final class LoadedBuildUnit(
   def projects: Iterable[ResolvedProject] = defined.values
 
   override def toString = unit.toString
-}
+end LoadedBuildUnit
 
 // TODO: figure out how to deprecate and drop buildNames
 /**
@@ -151,7 +150,7 @@ final class LoadedDefinitions(
     val projects: Seq[Project],
     val buildNames: Seq[String],
     val dslDefinitions: DefinedSbtValues
-) {
+):
   def this(
       base: File,
       target: Seq[File],
@@ -160,10 +159,9 @@ final class LoadedDefinitions(
       projects: Seq[Project],
       buildNames: Seq[String]
   ) = this(base, target, loader, builds, projects, buildNames, DefinedSbtValues.empty)
-}
 
 /** Auto-detected top-level modules (as in `object X`) of type `T` paired with their source names. */
-final class DetectedModules[T](val modules: Seq[(String, T)]) {
+final class DetectedModules[T](val modules: Seq[(String, T)]):
 
   /**
    * The source names of the modules.  This is "X" in `object X`, as opposed to the implementation class name "X$".
@@ -176,7 +174,6 @@ final class DetectedModules[T](val modules: Seq[(String, T)]) {
    * The values are returned in a stable order such that `names zip values` pairs a name with the actual module.
    */
   def values: Seq[T] = modules.map(_._2)
-}
 
 /** Auto-detected auto plugin. */
 case class DetectedAutoPlugin(name: String, value: AutoPlugin, hasAutoImport: Boolean)
@@ -191,7 +188,7 @@ case class DetectedAutoPlugin(name: String, value: AutoPlugin, hasAutoImport: Bo
 final class DetectedPlugins(
     val autoPlugins: Seq[DetectedAutoPlugin],
     val builds: DetectedModules[BuildDef]
-) {
+):
 
   /**
    * Sequence of import expressions for the build definition.
@@ -206,25 +203,23 @@ final class DetectedPlugins(
   private lazy val (autoPluginAutoImports, topLevelAutoPluginAutoImports) =
     autoPlugins
       .flatMap { case DetectedAutoPlugin(name, _, hasAutoImport) =>
-        if (hasAutoImport) Some(name) else None
+        if hasAutoImport then Some(name) else None
       }
       .partition(nonTopLevelPlugin)
 
   /** Selects the right [[AutoPlugin]]s from a [[Project]]. */
-  def deducePluginsFromProject(p: Project, log: Logger): Seq[AutoPlugin] = {
+  def deducePluginsFromProject(p: Project, log: Logger): Seq[AutoPlugin] =
     val ps0 = p.plugins
     val allDetected = autoPlugins.toList map { _.value }
-    val detected = p match {
+    val detected = p match
       case _: GeneratedRootProject => allDetected filterNot { _ == sbt.plugins.IvyPlugin }
       case _                       => allDetected
-    }
     Plugins.deducer(detected)(ps0, log)
-  }
 
   private def autoImports(pluginNames: Seq[String]) = pluginNames.map(_ + ".autoImport")
 
   private def nonTopLevelPlugin(name: String) = name.contains('.')
-}
+end DetectedPlugins
 
 /**
  * The built and loaded build definition project.
@@ -239,10 +234,9 @@ final class LoadedPlugins(
     val pluginData: PluginData,
     val loader: ClassLoader,
     val detected: DetectedPlugins
-) {
+):
   def fullClasspath: Def.Classpath = pluginData.classpath
   def classpath = data(fullClasspath)
-}
 
 /**
  * The loaded, but unresolved build unit.
@@ -256,13 +250,12 @@ final class BuildUnit(
     val definitions: LoadedDefinitions,
     val plugins: LoadedPlugins,
     val converter: FileConverter,
-) {
+):
   override def toString =
-    if (uri.getScheme == "file") localBase.toString
+    if uri.getScheme == "file" then localBase.toString
     else (uri.toString + " (locally: " + localBase + ")")
-}
 
-final class LoadedBuild(val root: URI, val units: Map[URI, LoadedBuildUnit]) {
+final class LoadedBuild(val root: URI, val units: Map[URI, LoadedBuildUnit]):
   BuildUtil.checkCycles(units)
 
   def allProjectRefs: Seq[(ProjectRef, ResolvedProject)] =
@@ -274,7 +267,6 @@ final class LoadedBuild(val root: URI, val units: Map[URI, LoadedBuildUnit]) {
     BuildUtil(root, units, keyIndex, data)
 
   private[sbt] def autos = GroupedAutoPlugins(units)
-}
 
 final class PartBuild(
     val root: URI,
@@ -282,23 +274,23 @@ final class PartBuild(
     val converter: MappedFileConverter,
 )
 
-sealed trait BuildUnitBase { def rootProjects: Seq[String]; def buildSettings: Seq[Setting[?]] }
+sealed trait BuildUnitBase:
+  def rootProjects: Seq[String]; def buildSettings: Seq[Setting[?]]
 
 final class PartBuildUnit(
     val unit: BuildUnit,
     val defined: Map[String, Project],
     val rootProjects: Seq[String],
     val buildSettings: Seq[Setting[?]]
-) extends BuildUnitBase {
+) extends BuildUnitBase:
 
   def resolve(f: Project => ResolvedProject): LoadedBuildUnit =
     new LoadedBuildUnit(unit, defined.view.mapValues(f).toMap, rootProjects, buildSettings)
 
   def resolveRefs(f: ProjectReference => Seq[ProjectRef]): LoadedBuildUnit =
     resolve(_.resolve(f))
-}
 
-object BuildStreams {
+object BuildStreams:
   type Streams = sbt.std.Streams[ScopedKey[?]]
 
   final val GlobalPath = "_global"
@@ -310,7 +302,7 @@ object BuildStreams {
       units: Map[URI, LoadedBuildUnit],
       root: URI,
       data: Def.Settings
-  ): State => Streams = s => {
+  ): State => Streams = s =>
     s.get(Keys.stateStreams).getOrElse {
       std.Streams(
         path(units, root, data)(_),
@@ -322,7 +314,6 @@ object BuildStreams {
         }
       )
     }
-  }
 
   def path(units: Map[URI, LoadedBuildUnit], root: URI, data: Def.Settings)(
       scoped: ScopedKey[?]
@@ -335,26 +326,24 @@ object BuildStreams {
   def pathComponent[T](axis: ScopeAxis[T], scoped: ScopedKey[?], label: String)(
       show: T => String
   ): String =
-    axis match {
+    axis match
       case Zero      => GlobalPath
       case This      => sys.error(s"Unresolved This reference for $label in ${displayFull(scoped)}")
       case Select(t) => show(t)
-    }
 
-  def nonProjectPath[T](scoped: ScopedKey[T]): Seq[String] = {
+  def nonProjectPath[T](scoped: ScopedKey[T]): Seq[String] =
     val scope = scoped.scope
     pathComponent(scope.config, scoped, "config")(_.name) ::
       pathComponent(scope.task, scoped, "task")(_.label) ::
       pathComponent(scope.extra, scoped, "extra")(showAMap) ::
       scoped.key.label :: previousComponent(scope.extra)
-  }
 
   private def previousComponent(value: ScopeAxis[AttributeMap]): List[String] =
-    value match {
+    value match
       case Select(am) =>
-        am.get(Previous.scopedKeyAttribute) match {
+        am.get(Previous.scopedKeyAttribute) match
           case Some(sk) =>
-            val project = sk.scope.project match {
+            val project = sk.scope.project match
               case Zero                                           => GlobalPath
               case Select(BuildRef(_))                            => BuildUnitPath
               case Select(ProjectRef(_, id))                      => id
@@ -365,12 +354,9 @@ object BuildStreams {
               case Select(ThisBuild) | Select(ThisProject) | This =>
                 // Don't want to crash if somehow an unresolved key makes it in here.
                 This.toString
-            }
             List(Previous.DependencyDirectory, project) ++ nonProjectPath(sk)
           case _ => Nil
-        }
       case _ => Nil
-    }
   def showAMap(a: AttributeMap): String =
     a.entries
       .to(LazyList)
@@ -389,18 +375,17 @@ object BuildStreams {
       scoped: ScopedKey[?],
       data: Def.Settings
   ): File =
-    scoped.scope.project match {
+    scoped.scope.project match
       case Zero => refTarget(GlobalScope, units(root).localBase, data) / GlobalPath
       case Select(br @ BuildRef(uri)) => refTarget(br, units(uri).localBase, data) / BuildUnitPath
       case Select(pr @ ProjectRef(uri, id)) => refTarget(pr, units(uri).defined(id).base, data)
       case Select(pr)                       =>
         sys.error("Unresolved project reference (" + pr + ") in " + displayFull(scoped))
       case This => sys.error("Unresolved project reference (This) in " + displayFull(scoped))
-    }
 
   def refTarget(ref: ResolvedReference, fallbackBase: File, data: Def.Settings): File =
     refTarget(GlobalScope.copy(project = Select(ref)), fallbackBase, data)
 
   def refTarget(scope: Scope, fallbackBase: File, data: Def.Settings): File =
     ((scope / Keys.target).get(data) getOrElse outputDirectory(fallbackBase)) / StreamsDirectory
-}
+end BuildStreams
diff --git a/main/src/main/scala/sbt/internal/BuildUtil.scala b/main/src/main/scala/sbt/internal/BuildUtil.scala
index 3e1c673a6..16e9537a9 100644
--- a/main/src/main/scala/sbt/internal/BuildUtil.scala
+++ b/main/src/main/scala/sbt/internal/BuildUtil.scala
@@ -21,7 +21,7 @@ final class BuildUtil[Proj](
     val project: (URI, String) => Proj,
     val configurations: Proj => Seq[ConfigKey],
     val aggregates: Relation[ProjectRef, ProjectRef]
-) {
+):
 
   def thisRootProject: Proj = rootProject(root)
 
@@ -30,15 +30,13 @@ final class BuildUtil[Proj](
   def resolveRef(ref: Reference): ResolvedReference =
     Scope.resolveReference(root, rootProjectID, ref)
 
-  def projectFor(ref: ResolvedReference): Proj = ref match {
+  def projectFor(ref: ResolvedReference): Proj = ref match
     case ProjectRef(uri, id) => project(uri, id)
     case BuildRef(uri)       => rootProject(uri)
-  }
 
-  def projectRefFor(ref: ResolvedReference): ProjectRef = ref match {
+  def projectRefFor(ref: ResolvedReference): ProjectRef = ref match
     case p: ProjectRef => p
     case BuildRef(uri) => ProjectRef(uri, rootProjectID(uri))
-  }
 
   def projectForAxis(ref: Option[ResolvedReference]): Proj = ref.fold(thisRootProject)(projectFor)
 
@@ -49,46 +47,40 @@ final class BuildUtil[Proj](
 
   val configurationsForAxis: Option[ResolvedReference] => Seq[String] =
     refOpt => configurations(projectForAxis(refOpt)).map(_.name)
+end BuildUtil
 
-}
-
-object BuildUtil {
+object BuildUtil:
   def apply(
       root: URI,
       units: Map[URI, LoadedBuildUnit],
       keyIndex: KeyIndex,
       data: Def.Settings
-  ): BuildUtil[ResolvedProject] = {
+  ): BuildUtil[ResolvedProject] =
     val getp = (build: URI, project: String) => Load.getProject(units, build, project)
     val configs = (_: ResolvedProject).configurations.map(c => ConfigKey(c.name))
     val aggregates = aggregationRelation(units)
     new BuildUtil(keyIndex, data, root, Load.getRootProject(units), getp, configs, aggregates)
-  }
 
-  def dependencies(units: Map[URI, LoadedBuildUnit]): BuildDependencies = {
+  def dependencies(units: Map[URI, LoadedBuildUnit]): BuildDependencies =
     import scala.collection.mutable
     val agg = new mutable.HashMap[ProjectRef, Seq[ProjectRef]]
     val cp = new mutable.HashMap[ProjectRef, Seq[ClasspathDep[ProjectRef]]]
-    for (lbu <- units.values; rp <- lbu.projects) {
+    for lbu <- units.values; rp <- lbu.projects do
       val ref = ProjectRef(lbu.unit.uri, rp.id)
       cp(ref) = rp.dependencies
       agg(ref) = rp.aggregate
-    }
     BuildDependencies(cp.toMap, agg.toMap)
-  }
 
-  def checkCycles(units: Map[URI, LoadedBuildUnit]): Unit = {
+  def checkCycles(units: Map[URI, LoadedBuildUnit]): Unit =
     def getRef(pref: ProjectRef) = units(pref.build).defined(pref.project)
     def deps(
         proj: ResolvedProject
     )(base: ResolvedProject => Seq[ProjectRef]): Seq[ResolvedProject] =
       Dag.topologicalSort(proj)(p => base(p) map getRef)
     // check for cycles
-    for ((_, lbu) <- units; proj <- lbu.projects) {
+    for (_, lbu) <- units; proj <- lbu.projects do
       deps(proj)(_.dependencies.map(_.project))
       deps(proj)(_.aggregate)
-    }
-  }
 
   def baseImports: Seq[String] =
     ("import _root_.scala.xml.{TopScope=>$scope}"
@@ -109,7 +101,7 @@ object BuildUtil {
 
   /** Import just the names. */
   def importNames(names: Seq[String]): Seq[String] =
-    if (names.isEmpty) Nil else names.mkString("import ", ", ", "") :: Nil
+    if names.isEmpty then Nil else names.mkString("import ", ", ", "") :: Nil
 
   /** Prepend `_root_` and import just the names. */
   def importNamesRoot(names: Seq[String]): Seq[String] = importNames(names map rootedName)
@@ -119,17 +111,16 @@ object BuildUtil {
     Seq(s"$x.*", s"$x.given")
   })
   def importAllRoot(values: Seq[String]): Seq[String] = importAll(values map rootedName)
-  def rootedName(s: String): String = if (s contains '.') "_root_." + s else s
+  def rootedName(s: String): String = if s contains '.' then "_root_." + s else s
 
-  def aggregationRelation(units: Map[URI, LoadedBuildUnit]): Relation[ProjectRef, ProjectRef] = {
+  def aggregationRelation(units: Map[URI, LoadedBuildUnit]): Relation[ProjectRef, ProjectRef] =
     val depPairs =
-      for {
+      for
         (uri, unit) <-
           units.toSeq // don't lose this toSeq, doing so breaks actions/cross-multiproject & actions/update-state-fail
         project <- unit.projects
         ref = ProjectRef(uri, project.id)
         agg <- project.aggregate
-      } yield (ref, agg)
+      yield (ref, agg)
     Relation.empty ++ depPairs
-  }
-}
+end BuildUtil
diff --git a/main/src/main/scala/sbt/internal/ClassLoaderWarmup.scala b/main/src/main/scala/sbt/internal/ClassLoaderWarmup.scala
index 806551f2b..110464d03 100644
--- a/main/src/main/scala/sbt/internal/ClassLoaderWarmup.scala
+++ b/main/src/main/scala/sbt/internal/ClassLoaderWarmup.scala
@@ -11,25 +11,19 @@ package sbt.internal
 import java.util.concurrent.{ ExecutorService, Executors }
 import sbt.plugins.{ CorePlugin, IvyPlugin, JvmPlugin }
 
-private[internal] object ClassLoaderWarmup {
-  def warmup(): Unit = {
-    if (Runtime.getRuntime.availableProcessors > 1) {
+private[internal] object ClassLoaderWarmup:
+  def warmup(): Unit =
+    if Runtime.getRuntime.availableProcessors > 1 then
       val executorService: ExecutorService =
         Executors.newFixedThreadPool(Runtime.getRuntime.availableProcessors - 1)
-      def submit[R](f: => R): Unit = {
-        executorService.submit(new Runnable {
-          override def run(): Unit = { f; () }
-        })
+      def submit[R](f: => R): Unit =
+        executorService.submit(new Runnable:
+          override def run(): Unit =
+            f; ())
         ()
-      }
 
       submit(Class.forName("sbt.internal.parser.SbtParserInit").getConstructor().newInstance())
       submit(CorePlugin.projectSettings)
       submit(IvyPlugin.projectSettings)
       submit(JvmPlugin.projectSettings)
-      submit(() => {
-        executorService.shutdown()
-      })
-    }
-  }
-}
+      submit(() => executorService.shutdown())
diff --git a/main/src/main/scala/sbt/internal/ClassLoaders.scala b/main/src/main/scala/sbt/internal/ClassLoaders.scala
index 60d04f79d..8ef479211 100644
--- a/main/src/main/scala/sbt/internal/ClassLoaders.scala
+++ b/main/src/main/scala/sbt/internal/ClassLoaders.scala
@@ -28,7 +28,7 @@ import sbt.util.Logger
 import xsbti.ArtifactInfo
 import xsbti.HashedVirtualFileRef
 
-private[sbt] object ClassLoaders {
+private[sbt] object ClassLoaders:
 
   /**
    * https://github.com/sbt/sbt/issues/9468
@@ -43,9 +43,7 @@ private[sbt] object ClassLoaders {
     catch case _: IOException => f
     real.toURI.toURL
 
-  extension (files: Seq[File]) {
-    def urls: Array[URL] = files.toArray.map(toRealURL)
-  }
+  extension (files: Seq[File]) def urls: Array[URL] = files.toArray.map(toRealURL)
   private val interfaceLoader = classOf[sbt.testing.Framework].getClassLoader
   /*
    * Get the class loader for a test task. The configuration could be Test.
@@ -102,7 +100,7 @@ private[sbt] object ClassLoaders {
         s.log.debug(s"javaOptions: $options")
         val opts = forkOptions.value
         new ForkRun(opts)
-      else {
+      else
         val converter = fileConverter.value
         val resolvedScope = resolvedScoped.value.scope
         val instance = scalaInstance.value
@@ -121,7 +119,7 @@ private[sbt] object ClassLoaders {
         val allowZombies = allowZombieClassLoaders.value
         val close = closeClassLoaders.value
         val newLoader =
-          (cp: Seq[Path]) => {
+          (cp: Seq[Path]) =>
             val mappings = cp.map(_.toFile()).map(f => f.getName -> f).toMap
             val transformedDependencies = allDeps.map(f => mappings.getOrElse(f.getName, f))
             buildLayers(
@@ -137,9 +135,7 @@ private[sbt] object ClassLoaders {
               close = close,
               allowZombies = allowZombies,
             )
-          }
         new Run(newLoader, trapExit.value)
-      }
     }
 
   private def extendedClassLoaderCache: Def.Initialize[Task[ClassLoaderCache]] = Def.task {
@@ -170,27 +166,26 @@ private[sbt] object ClassLoaders {
       logger: Logger,
       close: Boolean,
       allowZombies: Boolean
-  ): ClassLoader = {
+  ): ClassLoader =
     val cpFiles = fullCP.map(_._1)
-    strategy match {
+    strategy match
       case Flat | Raw =>
         new FlatLoader(cpFiles.urls, interfaceLoader, tmp, close, allowZombies, logger)
       case _ =>
-        val layerDependencies = strategy match {
+        val layerDependencies = strategy match
           case _: AllLibraryJars => true
           case _                 => false
-        }
         val cpFiles = fullCP.map(_._1)
-        val scalaLibraryLayer = {
+        val scalaLibraryLayer =
           val jars =
-            if (ScalaArtifacts.isScala3(si.version) || Classpaths.isScala213(si.version))
+            if ScalaArtifacts.isScala3(si.version) || Classpaths.isScala213(si.version) then
               cpFiles
-                .filter(f => {
+                .filter(f =>
                   val name = f.getName
                   name == s"${ArtifactInfo.ScalaLibraryID}.jar" ||
                   name.startsWith(s"${ArtifactInfo.ScalaLibraryID}-") ||
                   si.libraryJars.exists(_.getName == name)
-                })
+                )
                 .toArray
             else si.libraryJars
           cache.apply(
@@ -198,7 +193,6 @@ private[sbt] object ClassLoaders {
             interfaceLoader,
             () => new ScalaLibraryClassLoader(jars.map(_.toURI.toURL), interfaceLoader)
           )
-        }
 
         val allDependencies = cpFiles.filter(allDependenciesSet)
         def isReflectJar(f: File): Boolean =
@@ -218,7 +212,7 @@ private[sbt] object ClassLoaders {
 
         // layer 2 (optional if in the test config and the runtime layer is not shared)
         val dependencyLayer: ClassLoader =
-          if (layerDependencies && allDependencies.nonEmpty) {
+          if layerDependencies && allDependencies.nonEmpty then
             cache(
               allDependencies.toList.map(f => f -> IO.getModifiedTimeOrZero(f)),
               scalaReflectLayer,
@@ -231,26 +225,24 @@ private[sbt] object ClassLoaders {
                   logger = logger,
                 )
             )
-          } else scalaReflectLayer
+          else scalaReflectLayer
 
         val scalaJarNames = (si.libraryJars ++ scalaReflectJar).map(_.getName).toSet
         // layer 3
         val filteredSet =
-          if (layerDependencies) allDependencies.toSet ++ si.libraryJars ++ scalaReflectJar
+          if layerDependencies then allDependencies.toSet ++ si.libraryJars ++ scalaReflectJar
           else Set(si.libraryJars ++ scalaReflectJar*)
         val dynamicClasspath = cpFiles.filterNot(f => filteredSet(f) || scalaJarNames(f.getName))
-        dependencyLayer match {
+        dependencyLayer match
           case dl: ReverseLookupClassLoaderHolder =>
             dl.checkout(cpFiles, tmp)
           case cl =>
-            cl.getParent match {
+            cl.getParent match
               case dl: ReverseLookupClassLoaderHolder => dl.checkout(cpFiles, tmp)
               case _                                  =>
                 new LayeredClassLoader(dynamicClasspath.urls, cl, tmp, close, allowZombies, logger)
-            }
-        }
-    }
-  }
+    end match
+  end buildLayers
 
   private def dependencyJars(
       key: sbt.TaskKey[Seq[Attributed[HashedVirtualFileRef]]]
@@ -263,4 +255,4 @@ private[sbt] object ClassLoaders {
       val f = p.toFile
       f -> IO.getModifiedTimeOrZero(f)
   }
-}
+end ClassLoaders
diff --git a/main/src/main/scala/sbt/internal/ClasspathImpl.scala b/main/src/main/scala/sbt/internal/ClasspathImpl.scala
index 1135cb1ef..c5dd2762e 100644
--- a/main/src/main/scala/sbt/internal/ClasspathImpl.scala
+++ b/main/src/main/scala/sbt/internal/ClasspathImpl.scala
@@ -32,7 +32,7 @@ import sbt.util.*
 import scala.jdk.CollectionConverters.*
 import xsbti.{ HashedVirtualFileRef, VirtualFile, VirtualFileRef }
 
-private[sbt] object ClasspathImpl {
+private[sbt] object ClasspathImpl:
 
   // Since we can't predict the path for pickleProduct,
   // we can't reduce the track level.
@@ -109,10 +109,10 @@ private[sbt] object ClasspathImpl {
       track: TrackLevel
   ): Initialize[Task[Seq[(HashedVirtualFileRef, VirtualFile)]]] =
     Def.taskIf {
-      if {
+      if
         val _ = (packageBin / dynamicDependency).value
         exportJars.value
-      } then jarProductsForTask(key, track).value
+      then jarProductsForTask(key, track).value
       else trackedNonJarProductsImplTask(track).value
     }
 
@@ -233,7 +233,7 @@ private[sbt] object ClasspathImpl {
         )
     }
 
-  def internalDependencyPicklePathTask: Initialize[Task[Classpath]] = {
+  def internalDependencyPicklePathTask: Initialize[Task[Classpath]] =
     def implTask(
         projectRef: ProjectRef,
         conf: Configuration,
@@ -263,7 +263,7 @@ private[sbt] object ClasspathImpl {
         )
       })
       .flatMapTask(implTask)
-  }
+  end internalDependencyPicklePathTask
 
   def internalDependencyJarsTask: Initialize[Task[Classpath]] =
     (Def
@@ -387,25 +387,22 @@ private[sbt] object ClasspathImpl {
       noTracking: TaskKey[Seq[A]],
       trackIfMissing: TaskKey[Seq[A]],
       trackAlways: TaskKey[Seq[A]]
-  ): Task[Seq[A]] = {
+  ): Task[Seq[A]] =
     val interDepConfigs = interSort(projectRef, conf, data, deps) filter { (dep, c) =>
       includeSelf || (dep != projectRef) || (conf.name != c && self.name != c)
     }
     val tasks = (new LinkedHashSet[Task[Seq[A]]]).asScala
-    for {
-      (dep, c) <- interDepConfigs
-    } {
-      tasks += (track match {
+    for (dep, c) <- interDepConfigs
+    do
+      tasks += (track match
         case TrackLevel.NoTracking =>
           getClasspath(noTracking, dep, c, data)
         case TrackLevel.TrackIfMissing =>
           getClasspath(trackIfMissing, dep, c, data)
         case TrackLevel.TrackAlways =>
-          getClasspath(trackAlways, dep, c, data)
-      })
-    }
+          getClasspath(trackAlways, dep, c, data))
     (tasks.toSeq.join).map(_.flatten.distinct)
-  }
+  end interDependencies
 
   def interSort(
       projectRef: ProjectRef,
@@ -438,6 +435,8 @@ private[sbt] object ClasspathImpl {
           do
             for depConf <- confOpt(configurations, depConfName) do
               if !visited((dep, depConfName)) then visit(dep, depConf)
+      end for
+    end visit
     visit(projectRef, conf)
     visited.toSeq
   end interSort
@@ -448,10 +447,9 @@ private[sbt] object ClasspathImpl {
       depConfs: Seq[String],
       default: String,
       defaultMapping: String
-  ): String => Seq[String] = {
+  ): String => Seq[String] =
     lazy val defaultMap = parseMapping(defaultMapping, masterConfs, depConfs, _ :: Nil)
     parseMapping(confString getOrElse default, masterConfs, depConfs, defaultMap)
-  }
 
   def parseMapping(
       confString: String,
@@ -465,18 +463,16 @@ private[sbt] object ClasspathImpl {
       masterConfs: Seq[String],
       depConfs: Seq[String],
       default: String => Seq[String]
-  )(confString: String): String => Seq[String] = {
+  )(confString: String): String => Seq[String] =
     val ms: Seq[(String, Seq[String])] =
-      trim(confString.split("->", 2)) match {
-        case x :: Nil      => for (a <- parseList(x, masterConfs)) yield (a, default(a))
+      trim(confString.split("->", 2)) match
+        case x :: Nil      => for a <- parseList(x, masterConfs) yield (a, default(a))
         case x :: y :: Nil =>
           val target = parseList(y, depConfs);
-          for (a <- parseList(x, masterConfs)) yield (a, target)
+          for a <- parseList(x, masterConfs) yield (a, target)
         case _ => sys.error("Invalid configuration '" + confString + "'") // shouldn't get here
-      }
     val m = ms.toMap
     s => m.getOrElse(s, Nil)
-  }
 
   def union[A, B](maps: Seq[A => Seq[B]]): A => Seq[B] =
     a => maps.foldLeft(Seq[B]()) { _ ++ _(a) }.distinct
@@ -484,11 +480,10 @@ private[sbt] object ClasspathImpl {
   def parseList(s: String, allConfs: Seq[String]): Seq[String] =
     trim(s.split(",")).flatMap(replaceWildcard(allConfs)).distinct
 
-  def replaceWildcard(allConfs: Seq[String])(conf: String): Seq[String] = conf match {
+  def replaceWildcard(allConfs: Seq[String])(conf: String): Seq[String] = conf match
     case ""  => Nil
     case "*" => allConfs
     case _   => conf :: Nil
-  }
 
   private def trim(a: Array[String]): List[String] = a.toList.map(_.trim)
 
@@ -514,10 +509,9 @@ private[sbt] object ClasspathImpl {
       conf: String,
       data: Def.Settings
   ): Task[Seq[A]] =
-    (dep / ConfigKey(conf) / key).get(data) match {
+    (dep / ConfigKey(conf) / key).get(data) match
       case Some(x) => x
       case _       => constant(Nil)
-    }
 
   // -- dependencyMode filtering --
 
@@ -589,6 +583,8 @@ private[sbt] object ClasspathImpl {
               allowedKeys.contains((mid.organization, mid.name)) ||
               isScalaLibraryModule(mid)
             case None => true
+    end match
+  end filterByPlusOne
 
   /**
    * Apply dependencyMode filtering to a classpath. Entries without moduleIDStr metadata
@@ -655,5 +651,5 @@ private[sbt] object ClasspathImpl {
       case DependencyMode.Transitive => Set.empty
     refs.flatMap: pr =>
       (pr / projectID).get(data).map(mid => (mid.organization, mid.name))
-
-}
+  end allowedInternalKeys
+end ClasspathImpl
diff --git a/main/src/main/scala/sbt/internal/Clean.scala b/main/src/main/scala/sbt/internal/Clean.scala
index 18250aa90..a72d8c3a4 100644
--- a/main/src/main/scala/sbt/internal/Clean.scala
+++ b/main/src/main/scala/sbt/internal/Clean.scala
@@ -30,7 +30,7 @@ import sjsonnew.JsonFormat
 import xsbti.{ PathBasedFile, VirtualFileRef }
 import xsbti.compile.CompilerCache
 
-private[sbt] object Clean {
+private[sbt] object Clean:
 
   private[sbt] def deleteContents(file: File, exclude: File => Boolean): Unit =
     deleteContents(
@@ -44,8 +44,8 @@ private[sbt] object Clean {
       exclude: Path => Boolean,
       view: FileTreeView.Nio[FileAttributes],
       delete: Path => Unit
-  ): Unit = {
-    def deleteRecursive(path: Path): Unit = {
+  ): Unit =
+    def deleteRecursive(path: Path): Unit =
       view
         .list(Glob(path, AnyPath))
         .filterNot { case (p, _) => exclude(p) }
@@ -55,9 +55,7 @@ private[sbt] object Clean {
             delete(dir)
           case (file, _) => delete(file)
         }
-    }
     deleteRecursive(path)
-  }
 
   private def cleanFilter(scope: Scope): Def.Initialize[Task[Path => Boolean]] = Def.task {
     val excludes = (scope / cleanKeepFiles).value.map {
@@ -69,12 +67,11 @@ private[sbt] object Clean {
   }
   private def cleanDelete(scope: Scope): Def.Initialize[Task[Path => Unit]] = Def.task {
     // Don't use a regular logger because the logger actually writes to the target directory.
-    val debug = (scope / logLevel).?.value.orElse(state.value.get(logLevel.key)) match {
+    val debug = (scope / logLevel).?.value.orElse(state.value.get(logLevel.key)) match
       case Some(Level.Debug) =>
         (string: String) => println(s"[debug] $string")
       case _ =>
         (_: String) => {}
-    }
     tryDelete(debug)
   }
 
@@ -110,7 +107,7 @@ private[sbt] object Clean {
 
           targetDir.withFilter(_ => full).foreach(deleteContents(_, excludeFilter, view, delete))
           (scope / cleanFiles).?.value.getOrElse(Nil).foreach { x =>
-            if (x.isDirectory) deleteContents(x.toPath, excludeFilter, view, delete)
+            if x.isDirectory then deleteContents(x.toPath, excludeFilter, view, delete)
             else delete(x.toPath)
           }
 
@@ -127,9 +124,7 @@ private[sbt] object Clean {
             targetDir.fold(true)(g.base.startsWith)
           } ++ streamsGlobs)
             .foreach { g =>
-              val filter: Path => Boolean = { path =>
-                !g.matches(path) || excludeFilter(path)
-              }
+              val filter: Path => Boolean = path => !g.matches(path) || excludeFilter(path)
               deleteContents(g.base, filter, FileTreeView.default, delete)
               delete(g.base)
             }
@@ -154,9 +149,7 @@ private[sbt] object Clean {
       case _                => Nil
   end ToSeqPath
 
-  extension [T](t: T) {
-    private def toSeqPath(using toSeqPath: ToSeqPath[T]): Seq[Path] = toSeqPath(t)
-  }
+  extension [T](t: T) private def toSeqPath(using toSeqPath: ToSeqPath[T]): Seq[Path] = toSeqPath(t)
 
   private[sbt] def cleanFileOutputTask[T: JsonFormat: ToSeqPath](
       taskKey: TaskKey[T]
@@ -173,24 +166,22 @@ private[sbt] object Clean {
           val excludeFilter: Path => Boolean = path => !path.startsWith(targetDir) || filter(path)
           val delete = cleanDelete(scope).value
           val st = (scope / streams).value
-          taskKey.previous.foreach(_.toSeqPath.foreach(p => if (!excludeFilter(p)) delete(p)))
+          taskKey.previous.foreach(_.toSeqPath.foreach(p => if !excludeFilter(p) then delete(p)))
           delete(st.cacheDirectory.toPath / Previous.DependencyDirectory)
         }
       }
       .tag(Tags.Clean)
 
-  private def tryDelete(debug: String => Unit): Path => Unit = path => {
-    try {
+  private def tryDelete(debug: String => Unit): Path => Unit = path =>
+    try
       debug(s"clean -- deleting file $path")
       Files.deleteIfExists(path)
       ()
-    } catch {
+    catch
       case _: DirectoryNotEmptyException =>
         debug(s"clean -- unable to delete non-empty directory $path")
       case e: IOException =>
         debug(s"Caught unexpected exception $e deleting $path")
-    }
-  }
 
   val registerCompilerCache: State => State = (s: State) =>
     s.get(Keys.stateCompilerCache).foreach(_.clear())
@@ -237,4 +228,5 @@ private[sbt] object Clean {
         )
         s
     Command.command(CleanFull, h)(expunge andThen clearCachesFun)
-}
+  end cleanFull
+end Clean
diff --git a/main/src/main/scala/sbt/internal/CommandExchange.scala b/main/src/main/scala/sbt/internal/CommandExchange.scala
index 7f79ee8c3..bdb9da718 100644
--- a/main/src/main/scala/sbt/internal/CommandExchange.scala
+++ b/main/src/main/scala/sbt/internal/CommandExchange.scala
@@ -49,7 +49,7 @@ import scala.util.{ Failure, Success, Try }
  * Instead of blocking on JLine.readLine, the server command will block on
  * this exchange, which could serve command request from either of the channel.
  */
-private[sbt] final class CommandExchange {
+private[sbt] final class CommandExchange:
   private val autoStartServerSysProp =
     sys.props get "sbt.server.autostart" forall (_.toLowerCase == "true")
   private var server: Option[ServerInstance] = None
@@ -86,72 +86,63 @@ private[sbt] final class CommandExchange {
       interval: Duration,
       state: Option[State],
       logger: Logger
-  ): Exec = {
+  ): Exec =
     val idleDeadline = state.flatMap { s =>
       lastState.set(s)
-      s.get(BasicKeys.serverIdleTimeout) match {
+      s.get(BasicKeys.serverIdleTimeout) match
         case Some(Some(d)) => Some(d.fromNow)
         case _             => None
-      }
     }
-    @tailrec def impl(gcDeadline: Option[Deadline], idleDeadline: Option[Deadline]): Exec = {
+    @tailrec def impl(gcDeadline: Option[Deadline], idleDeadline: Option[Deadline]): Exec =
       state.foreach(s => prompt(ConsolePromptEvent(s)))
-      def poll: Option[Exec] = {
-        val deadline = gcDeadline.toSeq ++ idleDeadline match {
+      def poll: Option[Exec] =
+        val deadline = gcDeadline.toSeq ++ idleDeadline match
           case s @ Seq(_, _) => Some(s.min)
           case s             => s.headOption
-        }
         try
-          Option(deadline match {
+          Option(deadline match
             case Some(d: Deadline) =>
-              commandQueue.poll(d.timeLeft.toMillis + 1, TimeUnit.MILLISECONDS) match {
+              commandQueue.poll(d.timeLeft.toMillis + 1, TimeUnit.MILLISECONDS) match
                 case null if idleDeadline.fold(false)(_.isOverdue()) =>
                   state.foreach { s =>
-                    s.get(BasicKeys.serverIdleTimeout) match {
+                    s.get(BasicKeys.serverIdleTimeout) match
                       case Some(Some(d)) => s.log.info(s"sbt idle timeout of $d expired")
                       case _             =>
-                    }
                   }
                   Exec(TerminateAction, Some(CommandSource(ConsoleChannel.defaultName)))
                 case x => x
-              }
-            case _ => commandQueue.take
-          })
-        catch { case _: InterruptedException => None }
-      }
-      poll match {
+            case _ => commandQueue.take)
+        catch case _: InterruptedException => None
+      poll match
         case Some(exec) if exec.source.fold(true)(s => channels.exists(_.name == s.channelName)) =>
-          exec.commandLine match {
+          exec.commandLine match
             case `TerminateAction`
                 if exec.source.fold(false)(_.channelName.startsWith("network")) =>
               channels.collectFirst {
                 case c: NetworkChannel if exec.source.fold(false)(_.channelName == c.name) => c
-              } match {
+              } match
                 case Some(c) if c.isAttached =>
                   c.shutdown(false)
                   impl(gcDeadline, idleDeadline)
                 case _ => exec
-              }
             case _ => exec
-          }
         case Some(e) => e
         case None    =>
-          val newDeadline = if (gcDeadline.fold(false)(_.isOverdue())) {
+          val newDeadline = if gcDeadline.fold(false)(_.isOverdue()) then
             GCUtil.forceGcWithInterval(interval, logger)
             None
-          } else gcDeadline
+          else gcDeadline
           impl(newDeadline, idleDeadline)
-      }
-    }
+    end impl
     // Do not manually run GC until the user has been idling for at least the min gc interval.
     impl(
-      interval match {
+      interval match
         case d: FiniteDuration => Some(d.fromNow)
         case _                 => None
-      },
+      ,
       idleDeadline
     )
-  }
+  end blockUntilNextExec
 
   private def addConsoleChannel(): Unit =
     if Terminal.startedByRemoteClient then ()
@@ -160,46 +151,43 @@ private[sbt] final class CommandExchange {
       subscribe(new ConsoleChannel(name, mkAskUser(name)))
 
   def run(s: State): State = run(s, s.get(autoStartServer).getOrElse(true))
-  def run(s: State, autoStart: Boolean): State = {
+  def run(s: State, autoStart: Boolean): State =
     val startedByRemote = Terminal.startedByRemoteClient
-    if (autoStartServerSysProp && (autoStart || startedByRemote)) runServer(s)
+    if autoStartServerSysProp && (autoStart || startedByRemote) then runServer(s)
     else s
-  }
   private[sbt] def setState(s: State): Unit = lastState.set(s)
 
   private def newNetworkName: String = s"network-${nextChannelId.incrementAndGet()}"
 
-  private[sbt] def removeChannel(c: CommandChannel): Unit = {
-    val wasInitialized = c match {
+  private[sbt] def removeChannel(c: CommandChannel): Unit =
+    val wasInitialized = c match
       case nc: NetworkChannel => nc.isInitialized
       case _                  => false
-    }
     channelBufferLock.synchronized {
       Util.ignoreResult(channelBuffer -= c)
     }
     def isFromChannel(e: Exec): Boolean = e.source.exists(_.channelName == c.name)
     commandQueue.removeIf { e => isFromChannel(e) && e.commandLine != Shutdown }
-    currentExec.foreach { e => if (isFromChannel(e)) doCancel(e, force = false) }
+    currentExec.foreach { e => if isFromChannel(e) then doCancel(e, force = false) }
     try commandQueue.put(Exec(s"${ContinuousCommands.stopWatch} ${c.name}", None))
-    catch { case _: InterruptedException => }
+    catch
+      case _: InterruptedException =>
     // Notify other servers to drop if idle when a real client disconnects
-    if (wasInitialized && !isShuttingDown) notifyOtherServers()
-  }
+    if wasInitialized && !isShuttingDown then notifyOtherServers()
 
   private def mkAskUser(
       name: String,
-  ): (State, CommandChannel) => UITask = { (state, channel) =>
+  ): (State, CommandChannel) => UITask = (state, channel) =>
     ContinuousCommands
       .watchUITaskFor(state, channel)
       .getOrElse(new UITask.AskUserTask(state, channel))
-  }
 
   private[sbt] def currentExec = Option(currentExecRef.get)
 
   /**
    * Check if a server instance is running already, and start one if it isn't.
    */
-  private[sbt] def runServer(s: State): State = {
+  private[sbt] def runServer(s: State): State =
     lazy val port = s.get(serverPort).getOrElse(5001)
     lazy val host = s.get(serverHost).getOrElse("127.0.0.1")
     lazy val auth: Set[ServerAuthentication] =
@@ -211,7 +199,7 @@ private[sbt] final class CommandExchange {
     lazy val enableBsp = s.get(bspEnabled).getOrElse(true)
     lazy val portfile = s.baseDir / "project" / "target" / "active.json"
 
-    def onIncomingSocket(socket: AtomicReference[Socket], instance: ServerInstance): Unit = {
+    def onIncomingSocket(socket: AtomicReference[Socket], instance: ServerInstance): Unit =
       val name = newNetworkName
       Terminal.consoleLog(s"new client connected: $name")
       val channel =
@@ -225,8 +213,7 @@ private[sbt] final class CommandExchange {
         )
       subscribe(channel)
       AtomicCloseable.release(socket) // i took over
-    }
-    if (server.isEmpty && firstInstance.get) {
+    if server.isEmpty && firstInstance.get then
       val h = Hash.halfHashString(IO.toURI(portfile).toString)
       val serverDir =
         sys.env get "SBT_GLOBAL_SERVER_DIR" map file getOrElse BuildPaths.getGlobalBase(
@@ -253,20 +240,21 @@ private[sbt] final class CommandExchange {
       // don't throw exception when it times out
       val d = "10s"
       Try(Await.ready(serverInstance.ready, Duration(d)))
-      serverInstance.ready.value match {
+      serverInstance.ready.value match
         case Some(Success(())) =>
           // remember to shutdown only when the server comes up
           server = Some(serverInstance)
           s.log.debug("started sbt server")
           // register this server in the shared proc directory
-          try {
+          try
             val procDir = SysProp.globalLocalCache / "proc"
             IO.createDirectory(procDir)
             val pid = ProcessHandle.current().pid()
             val pf = procDir / s"$pid.json"
             IO.copyFile(portfile, pf)
             procFile = Some(pf)
-          } catch { case scala.util.control.NonFatal(_) => }
+          catch
+            case scala.util.control.NonFatal(_) =>
         case Some(Failure(_: AlreadyRunningException)) =>
           s.log.warn(
             "sbt server could not start because there's another instance of sbt running on this build."
@@ -281,43 +269,37 @@ private[sbt] final class CommandExchange {
           s.log.warn(s"sbt server could not start in $d")
           server = None
           firstInstance.set(false)
-      }
+      end match
       Terminal.setBootStreams(null, null)
 
-      if (s.get(BasicKeys.detachStdio).getOrElse(false)) {
-        Terminal.close()
-      }
+      if s.get(BasicKeys.detachStdio).getOrElse(false) then Terminal.close()
 
       s.get(Keys.bootServerSocket).foreach(_.close())
-    }
-    if (server.isEmpty && !monitoringActiveJson.get) {
-      s.get(sbt.nio.Keys.globalFileTreeRepository) match {
+    end if
+    if server.isEmpty && !monitoringActiveJson.get then
+      s.get(sbt.nio.Keys.globalFileTreeRepository) match
         case Some(r) =>
-          r.register(sbt.nio.file.Glob(portfile)) match {
+          r.register(sbt.nio.file.Glob(portfile)) match
             case Right(o) =>
               o.addObserver { event =>
-                if (!event.exists) {
+                if !event.exists then
                   firstInstance.set(true)
                   monitoringActiveJson.set(false)
                   // FailureWall is effectively a no-op command that will
                   // cause shell to re-run which should start the server
                   commandQueue.add(Exec(BasicCommandStrings.FailureWall, None))
                   o.close()
-                }
               }
               monitoringActiveJson.set(true)
             case _ =>
-          }
         case _ =>
-      }
-    }
     server.foreach { instance =>
       s.get(sbt.nio.Keys.globalFileTreeRepository).foreach { repo =>
-        if (watchedRepository.get ne repo) watchPortfile(instance, portfile, repo)
+        if watchedRepository.get ne repo then watchPortfile(instance, portfile, repo)
       }
     }
     s.remove(Keys.bootServerSocket)
-  }
+  end runServer
 
   /**
    * Registers a watch on the portfile. A project load closes the file tree repository, so the
@@ -328,42 +310,38 @@ private[sbt] final class CommandExchange {
       instance: ServerInstance,
       portfile: File,
       repo: FileTreeRepository[FileAttributes]
-  ): Unit = {
-    def check(): Unit = Server.serverIdOf(portfile) match {
+  ): Unit =
+    def check(): Unit = Server.serverIdOf(portfile) match
       case Success(id) if !id.contains(instance.serverId) =>
         exitServer("another sbt server took over this build")
       case _ =>
-    }
-    if (replaceWatch(portfile, repo, portfileWatch)(_.addObserver(_ => check())))
+    if replaceWatch(portfile, repo, portfileWatch)(_.addObserver(_ => check())) then
       watchedRepository.set(repo)
     check()
-  }
 
   private def replaceWatch[A](
       portfile: File,
       repo: nio.Registerable[A],
       watch: AtomicCloseable[AutoCloseable]
-  )(setUp: nio.Observable[A] => Unit): Boolean = {
+  )(setUp: nio.Observable[A] => Unit): Boolean =
     watch.close()
     // a repository that a failed load left closed throws instead of returning a Left
-    Try(repo.register(sbt.nio.file.Glob(portfile))).flatMap(_.toTry) match {
+    Try(repo.register(sbt.nio.file.Glob(portfile))).flatMap(_.toTry) match
       case Success(o) => setUp(o); watch.set(o); true
       case Failure(e) =>
         Terminal.consoleLog(s"sbt server cannot watch $portfile: $e")
         false
-    }
-  }
 
-  private def exitServer(reason: String): Unit = {
+  private def exitServer(reason: String): Unit =
     Terminal.consoleLog(s"$reason; exiting")
     shutdown(ConsoleChannel.defaultName)
-  }
 
-  def shutdown(): Unit = {
+  def shutdown(): Unit =
     shuttingDown.set(true)
     procFile.foreach { pf =>
       try IO.delete(pf)
-      catch { case scala.util.control.NonFatal(_) => }
+      catch
+        case scala.util.control.NonFatal(_) =>
     }
     procFile = None
     fastTrackThread.close()
@@ -373,7 +351,6 @@ private[sbt] final class CommandExchange {
     server.foreach(s => Util.ignoreTry(s.shutdown()))
     server = None
     EvaluateTask.onShutdown()
-  }
 
   // This is an interface to directly respond events.
   private[sbt] def respondError(
@@ -381,38 +358,35 @@ private[sbt] final class CommandExchange {
       message: String,
       execId: Option[String],
       source: Option[CommandSource]
-  ): Unit = {
+  ): Unit =
     respondError(JsonRpcResponseError(code, message), execId, source)
-  }
 
   private[sbt] def respondError(
       err: JsonRpcResponseError,
       execId: Option[String],
       source: Option[CommandSource]
-  ): Unit = {
-    for {
+  ): Unit =
+    for
       source <- source.map(_.channelName)
       channel <- channels.collectFirst {
         // broadcast to the source channel only
         case c: NetworkChannel if c.name == source => c
       }
-    } tryTo(_.respondError(err, execId))(channel)
-  }
+    do tryTo(_.respondError(err, execId))(channel)
 
   // This is an interface to directly respond events.
   private[sbt] def respondEvent[A: JsonFormat](
       event: A,
       execId: Option[String],
       source: Option[CommandSource]
-  ): Unit = {
-    for {
+  ): Unit =
+    for
       source <- source.map(_.channelName)
       channel <- channels.collectFirst {
         // broadcast to the source channel only
         case c: NetworkChannel if c.name == source => c
       }
-    } tryTo(_.respondResult(event, execId))(channel)
-  }
+    do tryTo(_.respondResult(event, execId))(channel)
 
   // This is an interface to directly notify events.
   private[sbt] def notifyEvent[A: JsonFormat](method: String, params: A): Unit =
@@ -425,28 +399,23 @@ private[sbt] final class CommandExchange {
       channel: NetworkChannel
   ): Unit =
     try f(channel)
-    catch { case _: IOException => removeChannel(channel) }
+    catch case _: IOException => removeChannel(channel)
 
-  def respondStatus(event: ExecStatusEvent): Unit = {
+  def respondStatus(event: ExecStatusEvent): Unit =
     import sbt.protocol.codec.JsonProtocol.given
-    for {
+    for
       source <- event.channelName
       channel <- channels.collectFirst {
         case c: NetworkChannel if c.name == source => c
       }
-    } {
-      if (event.execId.isEmpty) {
-        tryTo(_.notifyEvent(event))(channel)
-      } else {
-        event.exitCode match {
+    do
+      if event.execId.isEmpty then tryTo(_.notifyEvent(event))(channel)
+      else
+        event.exitCode match
           case None | Some(0) =>
             tryTo(_.respondResult(event, event.execId))(channel)
           case Some(code) =>
             tryTo(_.respondError(code, event.message.getOrElse(""), event.execId))(channel)
-        }
-      }
-    }
-  }
 
   private[sbt] def setExec(exec: Option[Exec]): Unit =
     currentExecRef.set(exec.orNull)
@@ -484,28 +453,24 @@ private[sbt] final class CommandExchange {
   private def isChannelOwner(c: NetworkChannel): Boolean =
     currentExec.exists(_.source.exists(_.channelName == c.name))
 
-  def notifyStatus(event: ExecStatusEvent): Unit = {
-    for {
+  def notifyStatus(event: ExecStatusEvent): Unit =
+    for
       source <- event.channelName
       channel <- channels.collectFirst {
         case c: NetworkChannel if c.name == source => c
       }
-    } tryTo(_.notifyEvent(event))(channel)
-  }
+    do tryTo(_.notifyEvent(event))(channel)
 
-  private[sbt] def killChannel(channel: String): Unit = {
+  private[sbt] def killChannel(channel: String): Unit =
     channels.find(_.name == channel).foreach(_.shutdown(false))
-  }
-  private[sbt] def updateProgress(pe: ProgressEvent): Unit = {
-    val newPE = currentExec match {
+  private[sbt] def updateProgress(pe: ProgressEvent): Unit =
+    val newPE = currentExec match
       case Some(e) if !e.commandLine.startsWith(networkExecPrefix) =>
         pe.withCommand(currentExec.map(_.commandLine))
           .withExecId(currentExec.flatMap(_.execId))
           .withChannelName(currentExec.flatMap(_.source.map(_.channelName)))
       case _ => pe
-    }
     channels.foreach(c => ProgressState.updateProgressState(newPE, c.terminal))
-  }
 
   /**
    * When a reboot is initiated by a network client, we need to communicate
@@ -513,7 +478,7 @@ private[sbt] final class CommandExchange {
    *
    * @param state
    */
-  private[sbt] def reboot(state: State): Unit = state.source match {
+  private[sbt] def reboot(state: State): Unit = state.source match
     case Some(s) if s.channelName.startsWith("network") =>
       channels.foreach {
         case nc: NetworkChannel if nc.name == s.channelName =>
@@ -536,33 +501,27 @@ private[sbt] final class CommandExchange {
         case nc: NetworkChannel => nc.shutdown(true, Some(("", "")))
         case c                  => c.shutdown(false)
       }
-  }
 
-  private[sbt] def shutdown(name: String): Unit = {
+  private[sbt] def shutdown(name: String): Unit =
     Option(currentExecRef.get).foreach(cancel)
     commandQueue.clear()
     val exit = Exec(Shutdown, Some(Exec.newExecId), Some(CommandSource(name)))
     commandQueue.add(exit)
     ()
-  }
-  private def cancel(e: Exec): Unit = {
-    if (e.commandLine.startsWith("console")) {
+  private def cancel(e: Exec): Unit =
+    if e.commandLine.startsWith("console") then
       val terminal = Terminal.get
       terminal.write(13, 13, 13, 4)
       terminal.printStream.println("\nconsole session killed by remote sbt client")
-    } else {
-      doCancel(e, force = true)
-    }
-  }
+    else doCancel(e, force = true)
 
-  private def doCancel(e: Exec, force: Boolean): Unit = {
+  private def doCancel(e: Exec, force: Boolean): Unit =
     Util.ignoreResult(NetworkChannel.cancel(e.execId, e.execId.getOrElse("0"), force = force))
-  }
 
   private def isShuttingDown: Boolean = shuttingDown.get
 
   /** Handle a dropIfIdle notification from another server. */
-  private[sbt] def handleDropIfIdle(): Unit = {
+  private[sbt] def handleDropIfIdle(): Unit =
     val idleSec = idleSeconds
     val threshold = SysProp.secondaryIdleTimeoutSec
     val idle = idleSec >= threshold
@@ -570,29 +529,28 @@ private[sbt] final class CommandExchange {
       case nc: NetworkChannel => nc.isInitialized
       case _                  => false
     }
-    if (idle && !hasClients)
+    if idle && !hasClients then
       exitServer("dropping idle server (requested by another sbt instance)")
-  }
 
   /** Notify other sbt servers to drop if idle. Runs on a daemon thread to avoid blocking. */
-  private def notifyOtherServers(): Unit = {
-    val thread = new Thread("sbt-notify-other-servers") {
+  private def notifyOtherServers(): Unit =
+    val thread = new Thread("sbt-notify-other-servers"):
       setDaemon(true)
 
-      override def run(): Unit = {
+      override def run(): Unit =
         val procDir = SysProp.globalLocalCache / "proc"
-        if (procDir.exists) {
+        if procDir.exists then
           val myPid = ProcessHandle.current().pid()
           val files = Option(procDir.listFiles).toSeq.flatten
-          for (f <- files if f.getName.endsWith(".json")) {
+          for f <- files if f.getName.endsWith(".json") do
             val pidStr = f.getName.stripSuffix(".json")
             val pid =
               try pidStr.toLong
-              catch { case _: NumberFormatException => -1L }
-            if (pid != myPid) {
-              try {
+              catch case _: NumberFormatException => -1L
+            if pid != myPid then
+              try
                 val (socket, _) = sbt.protocol.ClientSocket.socket(f)
-                try {
+                try
                   val notification = sbt.internal.protocol.JsonRpcNotificationMessage(
                     "2.0",
                     sbt.protocol.Serialization.dropIfIdle,
@@ -601,76 +559,65 @@ private[sbt] final class CommandExchange {
                   val bytes = sbt.protocol.Serialization.serializeNotificationMessage(notification)
                   socket.getOutputStream.write(bytes)
                   socket.getOutputStream.flush()
-                } finally {
-                  socket.close()
-                }
-              } catch {
+                finally socket.close()
+              catch
                 case scala.util.control.NonFatal(_) =>
                   // Server unreachable - clean up stale proc file
                   try IO.delete(f)
-                  catch { case scala.util.control.NonFatal(_) => }
-              }
-            }
-          }
-        }
-      }
-    }
+                  catch
+                    case scala.util.control.NonFatal(_) =>
+          end for
+        end if
+      end run
     thread.start()
-  }
+  end notifyOtherServers
 
-  private class FastTrackThread
-      extends Thread("sbt-command-exchange-fastTrack")
-      with AutoCloseable {
+  private class FastTrackThread extends Thread("sbt-command-exchange-fastTrack") with AutoCloseable:
     setDaemon(true)
     start()
     private val isStopped = new AtomicBoolean(false)
-    override def run(): Unit = {
-      def exit(mt: FastTrackTask): Unit = {
+    override def run(): Unit =
+      def exit(mt: FastTrackTask): Unit =
         mt.channel.shutdown(false)
-        if (mt.channel.name.contains("console")) shutdown(mt.channel.name)
-      }
-      @tailrec def impl(): Unit = {
-        fastTrackChannelQueue.take match {
+        if mt.channel.name.contains("console") then shutdown(mt.channel.name)
+      @tailrec def impl(): Unit =
+        fastTrackChannelQueue.take match
           case null              =>
           case mt: FastTrackTask =>
-            mt.task match {
+            mt.task match
               case `attach` | "" => mt.channel.prompt(ConsolePromptEvent(lastState.get))
               case `Cancel`      =>
                 Option(currentExecRef.get).foreach(cancel)
                 mt.channel.prompt(ConsolePromptEvent(lastState.get))
               case t if t.startsWith(ContinuousCommands.stopWatch) =>
-                mt.channel match {
+                mt.channel match
                   case c: NetworkChannel if !c.isInteractive => exit(mt)
                   case _                                     =>
-                }
                 commandQueue.add(Exec(t, None, None))
               case `TerminateAction` => exit(mt)
               case `Shutdown`        =>
                 val console = Terminal.console
                 val needNewLine = console.prompt.isInstanceOf[Prompt.AskUser]
                 console.setPrompt(Prompt.Batch)
-                if (needNewLine) console.printStream.println()
-                channels.find(_.name == mt.channel.name) match {
+                if needNewLine then console.printStream.println()
+                channels.find(_.name == mt.channel.name) match
                   case Some(c: NetworkChannel) => c.shutdown(false)
                   case _                       =>
-                }
                 shutdown(mt.channel.name)
               case _ =>
-            }
-        }
-        if (!isStopped.get) impl()
-      }
+        end match
+        if !isStopped.get then impl()
+      end impl
       try impl()
-      catch { case _: InterruptedException => }
-    }
-    override def close(): Unit = if (isStopped.compareAndSet(false, true)) {
-      interrupt()
-    }
-  }
+      catch
+        case _: InterruptedException =>
+    end run
+    override def close(): Unit = if isStopped.compareAndSet(false, true) then interrupt()
+  end FastTrackThread
   private[sbt] def channelForName(channelName: String): Option[CommandChannel] =
     channels.find(_.name == channelName)
   private val fastTrackThread = new FastTrackThread
-}
+end CommandExchange
 
 private[sbt] object CommandExchange:
   import sbt.protocol.Serialization.dropIfIdle
diff --git a/main/src/main/scala/sbt/internal/CommandStrings.scala b/main/src/main/scala/sbt/internal/CommandStrings.scala
index 08c7e7b74..69baadc9a 100644
--- a/main/src/main/scala/sbt/internal/CommandStrings.scala
+++ b/main/src/main/scala/sbt/internal/CommandStrings.scala
@@ -11,7 +11,7 @@ package internal
 
 import sbt.io.Path
 
-object CommandStrings {
+object CommandStrings:
 
   /** The prefix used to identify a request to execute the remaining input on source changes. */
   val AboutCommand = "about"
@@ -222,10 +222,9 @@ $label
 	settings at once.
 """
 
-  def moreAvailableMessage(label: String, search: Boolean) = {
-    val verb = if (search) "searched" else "viewed"
+  def moreAvailableMessage(label: String, search: Boolean) =
+    val verb = if search then "searched" else "viewed"
     s"More $label may be $verb by increasing verbosity.  See '$HelpCommand $label'\n"
-  }
 
   def aboutBrief = "Displays basic information about sbt and the build."
   def aboutDetailed = aboutBrief
@@ -452,4 +451,4 @@ $SwitchCommand [<scala-version>=]<scala-home>[!] [-v] [<command>]
   reloads the build. If <command> is provided, it is then executed.
   See also `help $JavaSwitchCommand`
 """
-}
+end CommandStrings
diff --git a/main/src/main/scala/sbt/internal/CompileDebugLogger.scala b/main/src/main/scala/sbt/internal/CompileDebugLogger.scala
index a3fc26268..3ae5e9e66 100644
--- a/main/src/main/scala/sbt/internal/CompileDebugLogger.scala
+++ b/main/src/main/scala/sbt/internal/CompileDebugLogger.scala
@@ -16,24 +16,21 @@ import sbt.util.{ Level, Logger }
  * Used so that incremental compiler output (e.g. "compiling X sources", invalidations)
  * can be attributed to a project in multi-project builds (fixes #408).
  */
-private[sbt] object CompileDebugLogger {
+private[sbt] object CompileDebugLogger:
   def apply(prefix: String, delegate: Logger): Logger =
-    new Logger {
+    new Logger:
       private def prefixed(msg: String): String =
-        if (msg == null || msg.isEmpty) s"[$prefix]"
+        if msg == null || msg.isEmpty then s"[$prefix]"
         else s"[$prefix] $msg"
 
       override def log(level: Level.Value, message: => String): Unit =
-        if (level == Level.Debug || level == Level.Info)
-          delegate.log(level, prefixed(message))
+        if level == Level.Debug || level == Level.Info then delegate.log(level, prefixed(message))
         else delegate.log(level, message)
 
       override def log(level: Level.Value, msg: Supplier[String]): Unit =
-        if (level == Level.Debug || level == Level.Info)
+        if level == Level.Debug || level == Level.Info then
           delegate.log(level, () => prefixed(msg.get()))
         else delegate.log(level, msg)
 
       def trace(t: => Throwable): Unit = delegate.trace(t)
       def success(message: => String): Unit = delegate.success(message)
-    }
-}
diff --git a/main/src/main/scala/sbt/internal/Compiler.scala b/main/src/main/scala/sbt/internal/Compiler.scala
index 020f9e7bc..a755ead29 100644
--- a/main/src/main/scala/sbt/internal/Compiler.scala
+++ b/main/src/main/scala/sbt/internal/Compiler.scala
@@ -257,6 +257,7 @@ object Compiler:
            |""".stripMargin
       if err then sys.error(msg)
       else s.log.warn(msg)
+    end reportScalaLibEviction
 
     // For Scala 3, update scala-library.jar in `scala-tool` and `scala-doc-tool` in case a newer version
     // is present in the `compile` configuration. This is needed once forwards binary compatibility is dropped
@@ -264,17 +265,17 @@ object Compiler:
     def updateLibraryToCompileConfiguration(report: ConfigurationReport) =
       if !ScalaArtifacts.isScala3(sv) then report
       else
-        (for {
+        (for
           compileConf <- fullReport.configuration(Configurations.Compile)
           compileLibMod <- compileConf.modules.find(_.module.name == ScalaArtifacts.LibraryID)
           reportLibMod <- report.modules.find(_.module.name == ScalaArtifacts.LibraryID)
           if VersionNumber(reportLibMod.module.revision)
             .matchesSemVer(SemanticSelector(s"<${compileLibMod.module.revision}"))
-        } yield {
+        yield
           val newMods = report.modules
             .filterNot(_.module.name == ScalaArtifacts.LibraryID) :+ compileLibMod
           report.withModules(newMods)
-        }).getOrElse(report)
+        ).getOrElse(report)
 
     val toolReport = updateLibraryToCompileConfiguration(
       fullReport
@@ -329,6 +330,7 @@ object Compiler:
           )
         else ()
     else ()
+    end if
     def file(id: String): Option[File] =
       for
         m <- toolReport.modules.find(_.module.name.startsWith(id))
@@ -385,6 +387,7 @@ object Compiler:
       allJars = allJars,
       explicitActual = Some(version)
     )
+  end makeScalaInstance
 
   private def noToolConfiguration(autoInstance: Boolean): String =
     val pre = "Missing Scala tool configuration from the 'update' report.  "
@@ -565,13 +568,13 @@ object Compiler:
         val rootPaths = Keys.rootPaths.value
         val tFiles = Keys.tastyFiles.value
         val sv = Keys.scalaVersion.value
-        (hasScala, hasJava) match {
+        (hasScala, hasJava) match
           case (true, _) =>
             val xapisFiles = xapis.map { (k, v) =>
               converter.toPath(k).toFile() -> v
             }
             val externalApiOpts =
-              if (ScalaArtifacts.isScala3(sv)) Opts.doc.externalAPIScala3(xapisFiles)
+              if ScalaArtifacts.isScala3(sv) then Opts.doc.externalAPIScala3(xapisFiles)
               else Opts.doc.externalAPI(xapisFiles)
             val options = sOpts ++ externalApiOpts
             val resolvedOptions = resolveVirtualizedScalacOptions(options, rootPaths)
@@ -611,7 +614,7 @@ object Compiler:
               s.log,
             )
           case _ => () // do nothing
-        }
+        end match
         out
     }
 
diff --git a/main/src/main/scala/sbt/internal/ConsoleProject.scala b/main/src/main/scala/sbt/internal/ConsoleProject.scala
index 08a0f588a..d1fb31d39 100644
--- a/main/src/main/scala/sbt/internal/ConsoleProject.scala
+++ b/main/src/main/scala/sbt/internal/ConsoleProject.scala
@@ -50,7 +50,7 @@ object ConsoleProject:
       options: Seq[String] = Nil
   )(using
       log: Logger
-  ): Unit = {
+  ): Unit =
     val extracted = Project.extract(state)
     val cpImports = new Imports(extracted, state)
     // Bindings are ignored by Scala 3 bridge: https://github.com/scala/scala3/issues/5069
@@ -149,7 +149,7 @@ object ConsoleProject:
       )(Some(loader), bindings).get
       ()
     finally ConsoleProjectBindings.clear()
-  }
+  end apply
 
   /**
    * `dotty.tools.repl.AbstractFileClassLoader`'s bytecode interrupt
@@ -203,11 +203,10 @@ object ConsoleProject:
       catch case _: java.io.IOException => false
 
   /** Conveniences for consoleProject that shouldn't normally be used for builds. */
-  final class Imports private[sbt] (extracted: Extracted, state: State) {
+  final class Imports private[sbt] (extracted: Extracted, state: State):
     import extracted.*
     implicit def taskKeyEvaluate[T](t: TaskKey[T]): Evaluate[T] =
       new Evaluate(runTask(t, state)._2)
     implicit def settingKeyEvaluate[T](s: SettingKey[T]): Evaluate[T] = new Evaluate(get(s))
-  }
   final class Evaluate[T] private[sbt] (val eval: T)
 end ConsoleProject
diff --git a/main/src/main/scala/sbt/internal/Continuous.scala b/main/src/main/scala/sbt/internal/Continuous.scala
index a69cb01fd..5647fbe97 100644
--- a/main/src/main/scala/sbt/internal/Continuous.scala
+++ b/main/src/main/scala/sbt/internal/Continuous.scala
@@ -67,7 +67,7 @@ import scala.util.control.NonFatal
  * semantics match previous sbt versions as closely as possible while allowing the user more
  * freedom to adjust the behavior to best suit their use cases.
  */
-private[sbt] object Continuous {
+private[sbt] object Continuous:
   protected type StartMessage =
     Option[(Int, ProjectRef, Seq[String]) => Option[String]]
   protected type TriggerMessage = (Int, Path, Seq[String]) => Option[String]
@@ -92,13 +92,12 @@ private[sbt] object Continuous {
    * @param parser the parser
    * @return the function
    */
-  private def defaultInputHandler(parser: Parser[Watch.Action]): InputStream => Watch.Action = {
+  private def defaultInputHandler(parser: Parser[Watch.Action]): InputStream => Watch.Action =
     val builder = new StringBuilder
     val any = matched(Parsers.any.*)
     val fullParser = any ~> parser ~ any
     ((inputStream: InputStream) => parse(inputStream, builder, fullParser))
       .label("Continuous.defaultInputHandler")
-  }
 
   /**
    * Implements continuous execution. It works by first parsing the command and generating a task to
@@ -110,10 +109,9 @@ private[sbt] object Continuous {
   private[sbt] def continuous: Command =
     Command(ContinuousExecutePrefix, continuousBriefHelp, continuousDetail)(continuousParser) {
       case (s, (initialCount, commands)) =>
-        val (s1, channel) = s.currentCommand.flatMap(_.source.map(_.channelName)) match {
+        val (s1, channel) = s.currentCommand.flatMap(_.source.map(_.channelName)) match
           case Some(c) => s -> c
           case None    => StandardMain.exchange.run(s) -> ConsoleChannel.defaultName
-        }
         val ws = ContinuousCommands.setupWatchState(channel, initialCount, commands, s1)
         s"${ContinuousCommands.runWatch} $channel" :: s"${ContinuousCommands.waitWatch} $channel" :: ws
     }
@@ -136,7 +134,7 @@ private[sbt] object Continuous {
       10000
     )
 
-  private val continuousParser: State => Parser[(Int, Seq[String])] = {
+  private val continuousParser: State => Parser[(Int, Seq[String])] =
     def toInt(s: String): Int = s.toIntOption.getOrElse(0)
 
     // This allows us to re-enter the watch with the previous count.
@@ -150,7 +148,6 @@ private[sbt] object Continuous {
           Parser.success((i.getOrElse(0), commands.filter(_.nonEmpty)))
         case (_, _) => Parser.failure("Couldn't parse any commands")
       }
-  }
 
   /**
    * Gets the [[Config]] necessary to watch a task. It will extract the internal dependency
@@ -171,15 +168,14 @@ private[sbt] object Continuous {
       scopedKey: ScopedKey[?],
       compiledMap: CompiledMap,
       dynamicInputs: mutable.Set[DynamicInput],
-  )(using extracted: Extracted, logger: Logger): Config = {
+  )(using extracted: Extracted, logger: Logger): Config =
 
     // Extract all of the globs that we will monitor during the continuous build.
-    val inputs = {
+    val inputs =
       val configs = scopedKey.get(internalDependencyConfigurations).getOrElse(Nil)
       import WatchTransitiveDependencies.Arguments as DArguments
       val args = new DArguments(scopedKey, extracted, compiledMap, logger, configs, state)
       WatchTransitiveDependencies.transitiveDynamicInputs(args)
-    }
 
     val repository = getRepository(state)
     dynamicInputs ++= inputs
@@ -191,63 +187,54 @@ private[sbt] object Continuous {
       dynamicInputs,
       watchSettings
     )
-  }
+  end getConfig
 
-  private def getRepository(state: State): FileTreeRepository[FileAttributes] = {
+  private def getRepository(state: State): FileTreeRepository[FileAttributes] =
     lazy val exception =
       new IllegalStateException("Tried to access FileTreeRepository for uninitialized state")
     state
       .get(globalFileTreeRepository)
       .getOrElse(throw exception)
-  }
 
-  private[sbt] def validateCommands(state: State, commands: Seq[String]): Unit = {
-    commands.filter(cmd => Parser.parse(cmd, state.combinedParser).isLeft) match {
+  private[sbt] def validateCommands(state: State, commands: Seq[String]): Unit =
+    commands.filter(cmd => Parser.parse(cmd, state.combinedParser).isLeft) match
       case invalid if invalid.isEmpty =>
       case invalid                    =>
         val msg = s"Invalid commands: ${invalid.mkString("'", "', '", ",")}"
         throw new IllegalArgumentException(msg)
-    }
-  }
 
   // This is defined so we can assign a task key to a command to parse the WatchSettings.
   private val globalWatchSettingKey =
     taskKey[Unit]("Internal task key. Not actually used.").withRank(KeyRanks.Invisible)
-  private def parseCommand(command: String, state: State): Seq[ScopedKey[?]] = {
+  private def parseCommand(command: String, state: State): Seq[ScopedKey[?]] =
     // Collect all of the scoped keys that are used to delegate the multi commands. These are
     // necessary to extract all of the transitive globs that we need to monitor during watch.
     // We have to add the <~ Parsers.any.* to ensure that we're able to extract the input key
     // from input tasks.
     val scopedKeyParser: Parser[Seq[ScopedKey[?]]] = Act.aggregatedKeyParser(state) <~ Parsers.any.*
-    @tailrec def impl(current: String): Seq[ScopedKey[?]] = {
-      Parser.parse(current, scopedKeyParser) match {
+    @tailrec def impl(current: String): Seq[ScopedKey[?]] =
+      Parser.parse(current, scopedKeyParser) match
         case Right(scopedKeys: Seq[ScopedKey[?]]) => scopedKeys
         case Left(e)                              =>
           val aliases = BasicCommands.allAliases(state)
-          aliases.collectFirst { case (`command`, aliased) => aliased } match {
+          aliases.collectFirst { case (`command`, aliased) => aliased } match
             case Some(aliased) => impl(aliased)
             case None          =>
-              Parser.parse(command, state.combinedParser) match {
+              Parser.parse(command, state.combinedParser) match
                 case Right(_) => globalWatchSettingKey.scopedKey :: Nil
                 case _        =>
                   val msg = s"Error attempting to extract scope from $command: $e."
                   throw new IllegalStateException(msg)
-              }
-          }
-      }
-    }
     impl(command)
-  }
 
   private def getAllConfigs(
       state: State,
       commands: Seq[String],
       dynamicInputs: mutable.Set[DynamicInput],
-  )(using extracted: Extracted, logger: Logger): Seq[Config] = {
+  )(using extracted: Extracted, logger: Logger): Seq[Config] =
     val commandKeys = commands.map(parseCommand(_, state))
     val compiledMap = WatchTransitiveDependencies.compile(extracted.structure)
     commandKeys.flatMap(_.map(getConfig(state, _, compiledMap, dynamicInputs)))
-  }
 
   private[sbt] class Callbacks(
       val nextEvent: Int => Watch.Action,
@@ -264,7 +251,7 @@ private[sbt] object Continuous {
       fileStampCache: FileStamp.Cache,
       dynamicInputs: mutable.Set[DynamicInput],
       context: LoggerContext
-  ): Callbacks = {
+  ): Callbacks =
     given extracted: Extracted = Project.extract(s)
     given logger: Logger =
       context.logger(channel.name + "-watch", None, None)
@@ -284,7 +271,7 @@ private[sbt] object Continuous {
       commands,
       fileStampCache
     )
-  }
+  end getCallbacks
 
   /**
    * Aggregates a collection of [[Config]] instances into a single instance of [[Callbacks]].
@@ -317,15 +304,14 @@ private[sbt] object Continuous {
       fileStampCache: FileStamp.Cache
   )(using
       extracted: Extracted
-  ): Callbacks = {
+  ): Callbacks =
     val project = extracted.currentRef
     val beforeCommand = () => configs.foreach(_.watchSettings.beforeCommand())
     val onStart: Int => Watch.Action =
       getOnStart(project, commands, configs, logger, extracted)
     val (message, parser, altParser) = getWatchInputOptions(configs, extracted)
-    val nextInputEvent: WatchExecutor => Option[Watch.Action] = {
+    val nextInputEvent: WatchExecutor => Option[Watch.Action] =
       parseInputEvents(parser, altParser, state, channel.terminal, logger)
-    }
     val (nextFileEvent, cleanupFileMonitor) =
       getFileEvents(configs, logger, state, commands, fileStampCache, channel.name)
     val executor = new WatchExecutor(channel.name)
@@ -339,33 +325,30 @@ private[sbt] object Continuous {
         executor,
         channel
       )
-    val onExit = () => {
+    val onExit = () =>
       cleanupFileMonitor()
       Util.ignoreResult(executor.close())
-    }
     val onTermination = getOnTermination(configs, isCommand)
     new Callbacks(nextEvent, beforeCommand, onExit, onStart, onTermination)
-  }
+  end aggregate
 
   private def getOnTermination(
       configs: Seq[Config],
       isCommand: Boolean
-  ): (Watch.Action, String, Int, State) => State = {
-    configs.flatMap(_.watchSettings.onTermination).distinct match {
+  ): (Watch.Action, String, Int, State) => State =
+    configs.flatMap(_.watchSettings.onTermination).distinct match
       case Seq(head, tail*) =>
         tail.foldLeft(head) { (onTermination, configOnTermination) => (action, cmd, count, state) =>
           configOnTermination(action, cmd, count, onTermination(action, cmd, count, state))
         }
       case _ =>
-        if (isCommand) Watch.defaultCommandOnTermination else Watch.defaultTaskOnTermination
-    }
-  }
+        if isCommand then Watch.defaultCommandOnTermination else Watch.defaultTaskOnTermination
 
   private def getWatchInputOptions(
       configs: Seq[Config],
       extracted: Extracted
-  ): (String, Parser[Watch.Action], Option[(TaskKey[InputStream], InputStream => Watch.Action)]) = {
-    configs match {
+  ): (String, Parser[Watch.Action], Option[(TaskKey[InputStream], InputStream => Watch.Action)]) =
+    configs match
       case Seq(h) =>
         val settings = h.watchSettings
         val parser = settings.inputParser
@@ -390,8 +373,6 @@ private[sbt] object Continuous {
               .getOrElse(defaultInputHandler(parser))
           }
         (message, parser, alt)
-    }
-  }
 
   private def getOnStart(
       project: ProjectRef,
@@ -399,32 +380,28 @@ private[sbt] object Continuous {
       configs: Seq[Config],
       logger: Logger,
       extracted: Extracted,
-  ): Int => Watch.Action = {
-    val f: Int => Seq[Watch.Action] = count => {
+  ): Int => Watch.Action =
+    val f: Int => Seq[Watch.Action] = count =>
       configs.map { params =>
         val ws = params.watchSettings
         ws.onIteration.map(_(count, project, commands)).getOrElse {
-          if (configs.size == 1) { // Only allow custom start messages for single tasks
+          if configs.size == 1 then // Only allow custom start messages for single tasks
             ws.startMessage match
               case Some(sm) => sm(count, project, commands).foreach(logger.info(_))
               case None     =>
                 Watch.defaultStartWatch(count, project, commands).foreach(logger.info(_))
-          }
           Watch.Ignore
         }
       }
-    }
-    count => {
+    count =>
       val res = f(count).min
       // Print the default watch message if there are multiple tasks
-      if (configs.size > 1) {
+      if configs.size > 1 then
         val onStartWatch =
           extracted.getOpt((project / watchStartMessage)).getOrElse(Watch.defaultStartWatch)
         onStartWatch(count, project, commands).foreach(logger.info(_))
-      }
       res
-    }
-  }
+  end getOnStart
 
   private def getFileEvents(
       configs: Seq[Config],
@@ -433,19 +410,18 @@ private[sbt] object Continuous {
       commands: Seq[String],
       fileStampCache: FileStamp.Cache,
       channel: String,
-  )(using extracted: Extracted): (Int => Option[(Watch.Event, Watch.Action)], () => Unit) = {
+  )(using extracted: Extracted): (Int => Option[(Watch.Event, Watch.Action)], () => Unit) =
     val trackMetaBuild = configs.forall(_.watchSettings.trackMetaBuild)
     val buildGlobs =
-      if (trackMetaBuild) extracted.getOpt((checkBuildSources / fileInputs)).getOrElse(Nil)
+      if trackMetaBuild then extracted.getOpt((checkBuildSources / fileInputs)).getOrElse(Nil)
       else Nil
 
     val retentionPeriod = configs.map(_.watchSettings.antiEntropyRetentionPeriod).max
     val quarantinePeriod = configs.map(_.watchSettings.deletionQuarantinePeriod).max
-    val monitor: FileEventMonitor[Event] = new FileEventMonitor[Event] {
+    val monitor: FileEventMonitor[Event] = new FileEventMonitor[Event]:
 
-      private implicit class WatchLogger(val l: Logger) extends sbt.internal.nio.WatchLogger {
+      private implicit class WatchLogger(val l: Logger) extends sbt.internal.nio.WatchLogger:
         override def debug(msg: Any): Unit = l.debug(msg.toString)
-      }
 
       private val observers: Observers[Event] = new Observers
       private val repo = getRepository(state)
@@ -457,25 +433,21 @@ private[sbt] object Continuous {
           // We only want to create one event per actual source file event. It doesn't matter
           // which of the config inputs triggers the event because they all will be used in
           // the onEvent callback above.
-          configs.find(_.matches(e.path)) match {
+          configs.find(_.matches(e.path)) match
             case Some(config) =>
               val configLogger = logger.withPrefix(config.command)
               configLogger.debug(s"Accepted event for ${e.path}")
               eventMonitorObservers.onNext(e)
             case None =>
-          }
-          if (trackMetaBuild && buildGlobs.exists(_.matches(e.path))) {
+          if trackMetaBuild && buildGlobs.exists(_.matches(e.path)) then
             val metaLogger = logger.withPrefix("build")
             metaLogger.debug(s"Accepted event for ${e.path}")
             eventMonitorObservers.onNext(e)
-          }
         }
-      if (trackMetaBuild) {
-        state.get(CheckBuildSources.CheckBuildSourcesKey).flatMap(_.fileTreeRepository) match {
+      if trackMetaBuild then
+        state.get(CheckBuildSources.CheckBuildSourcesKey).flatMap(_.fileTreeRepository) match
           case Some(r) => buildGlobs.foreach(r.register(_).foreach(observers.addObservable))
           case _       => buildGlobs.foreach(repo.register(_).foreach(_.close()))
-        }
-      }
 
       private val antiEntropyWindow = configs.map(_.watchSettings.antiEntropy).max
       private val monitor = FileEventMonitor.antiEntropy(
@@ -488,8 +460,8 @@ private[sbt] object Continuous {
 
       private val antiEntropyPollPeriod =
         configs.map(_.watchSettings.antiEntropyPollPeriod).max
-      override def poll(duration: Duration, filter: Event => Boolean): Seq[Event] = {
-        monitor.poll(duration, filter) match {
+      override def poll(duration: Duration, filter: Event => Boolean): Seq[Event] =
+        monitor.poll(duration, filter) match
           case s if s.nonEmpty =>
             val limit = antiEntropyWindow.fromNow
             /*
@@ -501,24 +473,18 @@ private[sbt] object Continuous {
              * increase in latency.
              */
             @tailrec def aggregate(res: Seq[Event]): Seq[Event] =
-              if (limit.isOverdue()) res
-              else {
-                monitor.poll(antiEntropyPollPeriod) match {
+              if limit.isOverdue() then res
+              else
+                monitor.poll(antiEntropyPollPeriod) match
                   case s if s.nonEmpty => aggregate(res ++ s)
                   case _               => res
-                }
-              }
             aggregate(s)
           case s => s
-        }
-      }
 
-      override def close(): Unit = {
+      override def close(): Unit =
         configHandle.close()
         handles.forEach(_.close())
         observers.close()
-      }
-    }
     val watchLogger: WatchLogger = msg => logger.debug(msg.toString)
     val antiEntropy = configs.map(_.watchSettings.antiEntropy).max
     val antiEntropyMonitor = FileEventMonitor.antiEntropy(
@@ -529,52 +495,46 @@ private[sbt] object Continuous {
       retentionPeriod
     )
 
-    val onEvent: (Int, Event) => Seq[(Watch.Event, Watch.Action)] = (count, event) => {
+    val onEvent: (Int, Event) => Seq[(Watch.Event, Watch.Action)] = (count, event) =>
       val path = event.path
 
-      def getWatchEvent(forceTrigger: Boolean): Option[Watch.Event] = {
-        if (!event.exists) {
+      def getWatchEvent(forceTrigger: Boolean): Option[Watch.Event] =
+        if !event.exists then
           Some(Deletion(event))
-          fileStampCache.remove(event.path) match {
+          fileStampCache.remove(event.path) match
             case null => None
             case _    => Some(Deletion(event))
-          }
-        } else {
-          fileStampCache.update(path, FileStamper.Hash) match {
+        else
+          fileStampCache.update(path, FileStamper.Hash) match
             case (None, Some(_))    => Some(Creation(event))
             case (Some(_), None)    => Some(Deletion(event))
             case (Some(p), Some(c)) =>
-              if (forceTrigger) {
+              if forceTrigger then
                 val msg =
                   s"Creating forced update event for path $path (previous stamp: $p, current stamp: $c)"
                 logger.debug(msg)
                 Some(Update(event))
-              } else if (p == c) {
+              else if p == c then
                 logger.debug(s"Dropping event for unmodified path $path")
                 None
-              } else {
+              else
                 val msg =
                   s"Creating update event for modified $path (previous stamp: $p, current stamp: $c)"
                 logger.debug(msg)
                 Some(Update(event))
-              }
             case _ => None
-          }
-        }
-      }
 
-      if (buildGlobs.exists(_.matches(path))) {
+      if buildGlobs.exists(_.matches(path)) then
         getWatchEvent(forceTrigger = false).flatMap { e =>
-          state.get(CheckBuildSources.CheckBuildSourcesKey) match {
+          state.get(CheckBuildSources.CheckBuildSourcesKey) match
             case Some(cbs) =>
-              if (cbs.needsReload(state, Exec("", Some(CommandSource(channel)))))
+              if cbs.needsReload(state, Exec("", Some(CommandSource(channel)))) then
                 Some(e -> Watch.Reload)
               else None
             case None =>
               Some(e -> Watch.Reload)
-          }
         }.toSeq
-      } else {
+      else
         val acceptedConfigParameters = configs.flatMap { config =>
           config.dynamicInputs.iterator.flatMap {
             case i if i.glob.matches(path) =>
@@ -582,52 +542,47 @@ private[sbt] object Continuous {
             case _ => None
           }
         }
-        if (acceptedConfigParameters.nonEmpty) {
+        if acceptedConfigParameters.nonEmpty then
           val useHash = acceptedConfigParameters.exists(_._2 == FileStamper.Hash)
           val forceTrigger = acceptedConfigParameters.exists(_._1)
           val watchEvent =
-            if (useHash) getWatchEvent(forceTrigger)
-            else {
+            if useHash then getWatchEvent(forceTrigger)
+            else
               logger.debug(s"Trigger path detected $path")
               Some(
-                if (!event.exists) Deletion(event)
-                else if (fileStampCache.get(path).isDefined) Creation(event)
+                if !event.exists then Deletion(event)
+                else if fileStampCache.get(path).isDefined then Creation(event)
                 else Update(event)
               )
-            }
           acceptedConfigParameters.flatMap { case (_, _, callback) =>
             watchEvent.map(e => e -> callback(count, e))
           }
-        } else Nil
-      }
-    }
+        else Nil
+      end if
     /*
      * This is a callback that will be invoked whenever onEvent returns a Trigger action. The
      * motivation is to allow the user to specify this callback via setting so that, for example,
      * they can clear the screen when the build triggers.
      */
-    val onTrigger: (Int, Watch.Event) => Unit = { (count: Int, event: Watch.Event) =>
-      if (configs.size == 1) {
+    val onTrigger: (Int, Watch.Event) => Unit = (count: Int, event: Watch.Event) =>
+      if configs.size == 1 then
         val config = configs.head
         val tm = config.watchSettings.triggerMessage
         tm(count, event.path, commands).foreach(logger.info(_))
-      } else {
-        Watch.defaultOnTriggerMessage(count, event.path, commands).foreach(logger.info(_))
-      }
-    }
+      else Watch.defaultOnTriggerMessage(count, event.path, commands).foreach(logger.info(_))
 
     (
-      (count: Int) => {
+      (count: Int) =>
         val interrupted = new AtomicBoolean(false)
-        def getEvent: Option[(Watch.Event, Watch.Action)] = {
+        def getEvent: Option[(Watch.Event, Watch.Action)] =
           val events =
             try antiEntropyMonitor.poll(Duration.Inf)
-            catch { case _: InterruptedException => interrupted.set(true); Nil }
+            catch case _: InterruptedException => interrupted.set(true); Nil
           val actions = events.flatMap(onEvent(count, _))
-          if (actions.exists(_._2 != Watch.Ignore)) {
+          if actions.exists(_._2 != Watch.Ignore) then
             val builder = new StringBuilder
             val min = actions.minBy { (e, a) =>
-              if (builder.nonEmpty) builder.append(", ")
+              if builder.nonEmpty then builder.append(", ")
               val path = e.path
               builder.append(path)
               builder.append(" -> ")
@@ -635,89 +590,79 @@ private[sbt] object Continuous {
               a
             }
             logger.debug(s"Received file event actions: $builder. Returning: $min")
-            if (min._2 == Watch.Trigger) onTrigger(count, min._1)
-            if (min._2 == Watch.ShowOptions) None else Some(min)
-          } else None
-        }
+            if min._2 == Watch.Trigger then onTrigger(count, min._1)
+            if min._2 == Watch.ShowOptions then None else Some(min)
+          else None
 
-        @tailrec def impl(): Option[(Watch.Event, Watch.Action)] = getEvent match {
+        @tailrec def impl(): Option[(Watch.Event, Watch.Action)] = getEvent match
           case None =>
-            if (interrupted.get || Thread.interrupted) None
+            if interrupted.get || Thread.interrupted then None
             else impl()
           case r => r
-        }
 
         impl()
-      },
+      ,
       () => monitor.close()
     )
-  }
+  end getFileEvents
 
-  private class WatchExecutor(name: String) extends AutoCloseable {
+  private class WatchExecutor(name: String) extends AutoCloseable:
     val id = new AtomicInteger(0)
     val threads = new java.util.Vector[Thread]
     val closed = new AtomicBoolean(false)
-    def submit[R](tag: String, f: => R): WatchExecutor.Future[R] = {
-      if (closed.get) new WatchExecutor.FutureFailed(new IllegalStateException("closed executor"))
-      else {
+    def submit[R](tag: String, f: => R): WatchExecutor.Future[R] =
+      if closed.get then
+        new WatchExecutor.FutureFailed(new IllegalStateException("closed executor"))
+      else
         val queue = new LinkedBlockingQueue[Either[Unit, R]]
         val latch = new CountDownLatch(1)
-        val runnable: Runnable = () => {
-          try {
+        val runnable: Runnable = () =>
+          try
             latch.countDown()
-            Util.ignoreResult(queue.offer(if (closed.get) Left(()) else Right(f)))
-          } catch { case _: Exception => Util.ignoreResult(queue.offer(Left(()))) }
-        }
+            Util.ignoreResult(queue.offer(if closed.get then Left(()) else Right(f)))
+          catch case _: Exception => Util.ignoreResult(queue.offer(Left(())))
         val thread = new Thread(runnable, s"sbt-watch-$name-$tag")
         thread.setDaemon(true)
         thread.start()
         threads.add(thread)
         new WatchExecutor.FutureImpl(thread, queue, this, latch)
-      }
-    }
     def removeThread(thread: Thread): Unit = Util.ignoreResult(threads.remove(thread))
-    def close(): Unit = if (closed.compareAndSet(false, true)) {
+    def close(): Unit = if closed.compareAndSet(false, true) then
       var exception: Option[InterruptedException] = None
       threads.forEach { thread =>
         try thread.joinFor(1.second)
-        catch { case e: InterruptedException => exception = Some(e) }
+        catch case e: InterruptedException => exception = Some(e)
       }
       threads.clear()
       exception.foreach(throw _)
-    }
-  }
-  private object WatchExecutor {
-    sealed trait Future[R] extends Any {
+  end WatchExecutor
+  private object WatchExecutor:
+    sealed trait Future[R] extends Any:
       def waitUntilStart(duration: FiniteDuration): Boolean
       def cancel(): Unit
       def result: Try[R]
-    }
-    final class FutureFailed[R](t: Throwable) extends Future[R] {
+    final class FutureFailed[R](t: Throwable) extends Future[R]:
       override def waitUntilStart(duration: FiniteDuration): Boolean = false
       def cancel(): Unit = {}
       def result: Try[R] = Failure(t)
-    }
     final class FutureImpl[R](
         thread: Thread,
         queue: LinkedBlockingQueue[Either[Unit, R]],
         executor: WatchExecutor,
         latch: CountDownLatch,
-    ) extends Future[R] {
+    ) extends Future[R]:
       override def waitUntilStart(duration: FiniteDuration): Boolean =
         latch.await(duration.toMillis, TimeUnit.MILLISECONDS)
-      def cancel(): Unit = {
+      def cancel(): Unit =
         executor.removeThread(thread)
         thread.joinFor(1.second)
-      }
       def result: Try[R] =
         try
-          queue.take match {
+          queue.take match
             case Right(r) => Success(r)
             case Left(_)  => Failure(new NullPointerException)
-          }
-        catch { case t: InterruptedException => Failure(t) }
-    }
-  }
+        catch case t: InterruptedException => Failure(t)
+  end WatchExecutor
 
   /**
    * Each task has its own input parser that can be used to modify the watch based on the input
@@ -740,7 +685,7 @@ private[sbt] object Continuous {
       state: State,
       terminal: Terminal,
       logger: Logger,
-  )(using extracted: Extracted): WatchExecutor => Option[Watch.Action] = {
+  )(using extracted: Extracted): WatchExecutor => Option[Watch.Action] =
     /*
      * This parses the buffer until all possible actions are extracted. By draining the input
      * to a state where it does not parse an action, we can wait until we receive new input
@@ -755,7 +700,7 @@ private[sbt] object Continuous {
     // If the Config.watchSettings.inputStream is set, the same process is applied except that
     // instead of passing in the wrapped InputStream for the input string, we directly pass
     // in the inputStream provided by Config.watchSettings.inputStream.
-    val inputHandler: String => Watch.Action = {
+    val inputHandler: String => Watch.Action =
       val any = Parsers.any.*
       val fullParser = any ~> parser ~ matched(any)
       // Each parser gets its own copy of System.in that it can modify while parsing.
@@ -773,45 +718,37 @@ private[sbt] object Continuous {
         }
         .getOrElse(() => Watch.Ignore)
       (string: String) =>
-        ((if (string.nonEmpty) default(string) else Watch.Ignore) :: alt() :: Nil).min
-    }
-    executor => {
+        ((if string.nonEmpty then default(string) else Watch.Ignore) :: alt() :: Nil).min
+    executor =>
       val interrupted = new AtomicBoolean(false)
-      @tailrec def read(): Int = {
-        if (terminal.name.startsWith("network")) terminal.inputStream.read
-        else if (Terminal.canPollSystemIn || terminal.inputStream.available > 0)
+      @tailrec def read(): Int =
+        if terminal.name.startsWith("network") then terminal.inputStream.read
+        else if Terminal.canPollSystemIn || terminal.inputStream.available > 0 then
           terminal.inputStream.read
-        else {
+        else
           Thread.sleep(50)
           read()
-        }
-      }
-      @tailrec def impl(): Option[Watch.Action] = {
+      @tailrec def impl(): Option[Watch.Action] =
         val action =
-          try {
+          try
             interrupted.set(false)
-            read() match {
+            read() match
               case -1   => throw new InterruptedException
               case 3    => Watch.CancelWatch // ctrl+c on windows
               case byte => inputHandler(byte.toChar.toString)
-            }
-          } catch {
+          catch
             case _: InterruptedException =>
               interrupted.set(true)
               Watch.Ignore
-          }
-        action match {
+        action match
           case Watch.Ignore =>
             val stop = interrupted.get || Thread.interrupted
-            if (!stop) impl()
+            if !stop then impl()
             else None
           case r => Some(r)
-        }
-      }
 
       terminal.withRawInput(impl())
-    }
-  }
+  end parseInputEvents
 
   private def combineInputAndFileEvents(
       nextInputAction: WatchExecutor => Option[Watch.Action],
@@ -821,7 +758,7 @@ private[sbt] object Continuous {
       rawLogger: Logger,
       executor: WatchExecutor,
       channel: CommandChannel
-  ): Int => Watch.Action = count => {
+  ): Int => Watch.Action = count =>
     val events = new LinkedBlockingQueue[Either[Watch.Action, (Watch.Event, Watch.Action)]]
 
     val inputJob =
@@ -830,64 +767,57 @@ private[sbt] object Continuous {
     val fileJob =
       executor
         .submit(s"get-file-events-$count", nextFileEvent(count).foreach(e => events.put(Right(e))))
-    val signalRegistration = channel match {
+    val signalRegistration = channel match
       case _: ConsoleChannel => Some(Signals.register(() => events.put(Left(Watch.CancelWatch))))
       case _                 => None
-    }
-    try {
-      if (!inputJob.waitUntilStart(1.second) || !fileJob.waitUntilStart(1.second)) {
+    try
+      if !inputJob.waitUntilStart(1.second) || !fileJob.waitUntilStart(1.second) then
         inputJob.cancel()
         fileJob.cancel()
         new Watch.HandleError(new TimeoutException)
-      } else {
+      else
         val (inputAction: Watch.Action, fileEvent: Option[(Watch.Event, Watch.Action)]) =
-          events.take() match {
+          events.take() match
             case Left(a)  => (a, None)
             case Right(e) => (Watch.Ignore, Some(e))
-          }
         val min: Watch.Action = (fileEvent.map(_._2).toSeq :+ inputAction).min
         lazy val inputMessage =
           s"Received input event: $inputAction." +
-            (if (inputAction != min) s" Dropping in favor of file event: $min" else "")
-        if (inputAction != Watch.Ignore) logger.info(inputMessage)
+            (if inputAction != min then s" Dropping in favor of file event: $min" else "")
+        if inputAction != Watch.Ignore then logger.info(inputMessage)
         fileEvent
           .collect {
             case (event, action) if action != Watch.Ignore =>
               s"Received file event $action for $event." +
-                (if (action != min) s" Dropping in favor of input event: $min" else "")
+                (if action != min then s" Dropping in favor of input event: $min" else "")
           }
           .foreach(logger.debug(_))
-        min match {
+        min match
           case ShowOptions =>
             rawLogger.info(options)
             Watch.Ignore
           case m => m
-        }
-      }
-    } finally {
+    finally
       signalRegistration.foreach(_.remove())
       inputJob.cancel()
       fileJob.cancel()
       ()
-    }
-  }
+    end try
 
   @tailrec
   private final def parse(
       is: InputStream,
       builder: StringBuilder,
       parser: Parser[(Watch.Action, String)]
-  ): Watch.Action = {
-    if (is.available > 0) builder += is.read().toChar
-    Parser.parse(builder.toString, parser) match {
+  ): Watch.Action =
+    if is.available > 0 then builder += is.read().toChar
+    Parser.parse(builder.toString, parser) match
       case Right((action, rest)) =>
         builder.clear()
         builder ++= rest
         action
       case _ if is.available > 0 => parse(is, builder, parser)
       case _                     => Watch.Ignore
-    }
-  }
 
   private type WatchOnEvent = (Int, Watch.Event) => Watch.Action
 
@@ -918,7 +848,7 @@ private[sbt] object Continuous {
    */
   private final class WatchSettings private[Continuous] (val key: ScopedKey[?])(implicit
       extracted: Extracted
-  ) {
+  ):
     val antiEntropy: FiniteDuration =
       key.get(watchAntiEntropy).getOrElse(Watch.defaultAntiEntropy)
     val antiEntropyRetentionPeriod: FiniteDuration =
@@ -955,7 +885,7 @@ private[sbt] object Continuous {
     val inputStream: Option[TaskKey[InputStream]] = key.get(watchInputStream)
     val antiEntropyPollPeriod: FiniteDuration =
       key.get(watchAntiEntropyPollPeriod).getOrElse(Watch.defaultAntiEntropyPollPeriod)
-  }
+  end WatchSettings
 
   /**
    * Container class for all of the components we need to setup a watch for a particular task or
@@ -982,13 +912,12 @@ private[sbt] object Continuous {
 
   private def getTriggerMessage(
       key: ScopedKey[?]
-  )(using Extracted): TriggerMessage = {
+  )(using Extracted): TriggerMessage =
     lazy val default =
       key.get(watchTriggeredMessage).getOrElse(Watch.defaultOnTriggerMessage)
     default
-  }
 
-  extension (scope: Scope) {
+  extension (scope: Scope)
 
     /**
      * This shows the [[Scope]] in the format that a user would likely type it in a build
@@ -999,7 +928,7 @@ private[sbt] object Continuous {
      *
      * @return the pretty printed output.
      */
-    private def show: String = {
+    private def show: String =
       val mask = ScopeMask(
         config = scope.config.toOption.isDefined,
         task = scope.task.toOption.isDefined,
@@ -1009,18 +938,17 @@ private[sbt] object Continuous {
         .displayMasked(
           scope,
           " ",
-          (_: Reference) match {
+          (_: Reference) match
             case p: ProjectRef => s"${p.project.trim} /"
             case _             => "Global /"
-          },
+          ,
           mask
         )
         .dropRight(3) // delete trailing "/"
         .trim
-    }
-  }
+  end extension
 
-  extension (scopedKey: ScopedKey[?]) {
+  extension (scopedKey: ScopedKey[?])
 
     /**
      * Gets the value for a setting key scoped to the wrapped [[ScopedKey]]. If the task axis is not
@@ -1034,15 +962,13 @@ private[sbt] object Continuous {
      * @return the optional value of the [[SettingKey]] if it is defined at the input
      *         [[ScopedKey]] instance's scope or task scope.
      */
-    private def get[T](settingKey: SettingKey[T])(using extracted: Extracted): Option[T] = {
+    private def get[T](settingKey: SettingKey[T])(using extracted: Extracted): Option[T] =
       lazy val taskScope = Project.fillTaskAxis(scopedKey).scope
-      scopedKey.scope match {
+      scopedKey.scope match
         case scope if scope.task.toOption.isDefined =>
           extracted.getOpt((scope / settingKey)) orElse extracted.getOpt((taskScope / settingKey))
         case scope =>
           extracted.getOpt((taskScope / settingKey)) orElse extracted.getOpt((scope / settingKey))
-      }
-    }
 
     /**
      * Gets the [[ScopedKey]] for a task scoped to the wrapped [[ScopedKey]]. If the task axis is
@@ -1056,19 +982,17 @@ private[sbt] object Continuous {
      * @return the optional value of the [[SettingKey]] if it is defined at the input
      *         [[ScopedKey]] instance's scope or task scope.
      */
-    private def get[T](taskKey: TaskKey[T])(using extracted: Extracted): Option[TaskKey[T]] = {
+    private def get[T](taskKey: TaskKey[T])(using extracted: Extracted): Option[TaskKey[T]] =
       lazy val taskScope = Project.fillTaskAxis(scopedKey).scope
-      scopedKey.scope match {
+      scopedKey.scope match
         case scope if scope.task.toOption.isDefined =>
-          if (extracted.getOpt((scope / taskKey)).isDefined) Some((scope / taskKey))
-          else if (extracted.getOpt((taskScope / taskKey)).isDefined) Some((taskScope / taskKey))
+          if extracted.getOpt((scope / taskKey)).isDefined then Some((scope / taskKey))
+          else if extracted.getOpt((taskScope / taskKey)).isDefined then Some((taskScope / taskKey))
           else None
         case scope =>
-          if (extracted.getOpt((taskScope / taskKey)).isDefined) Some((taskScope / taskKey))
-          else if (extracted.getOpt((scope / taskKey)).isDefined) Some((scope / taskKey))
+          if extracted.getOpt((taskScope / taskKey)).isDefined then Some((taskScope / taskKey))
+          else if extracted.getOpt((scope / taskKey)).isDefined then Some((scope / taskKey))
           else None
-      }
-    }
 
     /**
      * This shows the [[ScopedKey[_]] in the format that a user would likely type it in a build
@@ -1080,9 +1004,9 @@ private[sbt] object Continuous {
      * @return the pretty printed output.
      */
     private def show: String = s"${scopedKey.scope.show} / ${scopedKey.key}"
-  }
+  end extension
 
-  extension (logger: Logger) {
+  extension (logger: Logger)
 
     /**
      * Creates a logger that adds a prefix to the messages that it logs. The motivation is so that
@@ -1091,20 +1015,18 @@ private[sbt] object Continuous {
      * @param prefix the string to prefix the message with
      * @return the wrapped Logger.
      */
-    private def withPrefix(prefix: String): Logger = new Logger {
+    private def withPrefix(prefix: String): Logger = new Logger:
       override def trace(t: => Throwable): Unit = logger.trace(t)
 
       override def success(message: => String): Unit = logger.success(message)
 
       override def log(level: Level.Value, message: => String): Unit =
         logger.log(level, s"$prefix - $message")
-    }
-  }
 
   private[sbt] class FileStampRepository(
       fileStampCache: FileStamp.Cache,
       underlying: FileTreeRepository[FileAttributes]
-  ) extends FileTreeRepository[FileAttributes] {
+  ) extends FileTreeRepository[FileAttributes]:
     def putIfAbsent(path: Path, stamper: FileStamper): (Option[FileStamp], Option[FileStamp]) =
       fileStampCache.putIfAbsent(path, stamper)
     override def list(path: Path): Seq[(Path, FileAttributes)] = underlying.list(path)
@@ -1113,7 +1035,6 @@ private[sbt] object Continuous {
     override def register(glob: Glob): Either[IOException, Observable[FileEvent[FileAttributes]]] =
       underlying.register(glob)
     override def close(): Unit = underlying.close()
-  }
 
   private[sbt] final class ContinuousState(
       val count: Int,
@@ -1125,7 +1046,7 @@ private[sbt] object Continuous {
       val dynamicInputs: mutable.Set[DynamicInput],
       val pending: Boolean,
       var terminationAction: Option[Watch.Action],
-  ) {
+  ):
     def this(
         count: Int,
         commands: Seq[String],
@@ -1172,10 +1093,10 @@ private[sbt] object Continuous {
         pending,
         terminationAction,
       )
-  }
-}
+  end ContinuousState
+end Continuous
 
-private[sbt] object ContinuousCommands {
+private[sbt] object ContinuousCommands:
   private[sbt] def value: Seq[Command] = Vector(
     failWatchCommand,
     preWatchCommand,
@@ -1209,20 +1130,19 @@ private[sbt] object ContinuousCommands {
     Int.MaxValue
   )
   private[sbt] val setupWatchState: (String, Int, Seq[String], State) => State =
-    (channelName, count, commands, state) => {
-      state.get(watchStates).flatMap(_.get(channelName)) match {
+    (channelName, count, commands, state) =>
+      state.get(watchStates).flatMap(_.get(channelName)) match
         case None =>
           val extracted = Project.extract(state)
-          val repo = state.get(globalFileTreeRepository) match {
+          val repo = state.get(globalFileTreeRepository) match
             case Some(r) => localRepo(r)
             case _       =>
               throw new IllegalStateException(s"No file tree repository was found for $state")
-          }
           val cache = new FileStamp.Cache
           repo.addObserver(t => cache.invalidate(t.path))
           val persistFileStamps = extracted.get(watchPersistFileStamps)
           val cachingRepo: FileTreeRepository[FileAttributes] =
-            if (persistFileStamps) repo else new FileStampRepository(cache, repo)
+            if persistFileStamps then repo else new FileStampRepository(cache, repo)
           val channel = StandardMain.exchange
             .channelForName(channelName)
             .getOrElse(throw new IllegalStateException(s"No channel with name $channelName"))
@@ -1234,7 +1154,7 @@ private[sbt] object ContinuousCommands {
           val s = new ContinuousState(
             count = count,
             commands = commands,
-            beforeCommandImpl = (state, dynamicInputs) => {
+            beforeCommandImpl = (state, dynamicInputs) =>
               val original = state
                 .get(globalFileTreeRepository)
                 .getOrElse(
@@ -1245,49 +1165,42 @@ private[sbt] object ContinuousCommands {
               val stateWithRepo =
                 state.put(globalFileTreeRepository, cachingRepo).put(stashedRepo, original)
               val stateWithCache =
-                if (persistFileStamps) stateWithRepo.put(persistentFileStampCache, cache)
+                if persistFileStamps then stateWithRepo.put(persistentFileStampCache, cache)
                 else stateWithRepo
               stateWithCache.put(Continuous.DynamicInputs, dynamicInputs)
-            },
-            afterCommand = state => {
-              val newWatchState = state.get(watchStates) match {
+            ,
+            afterCommand = state =>
+              val newWatchState = state.get(watchStates) match
                 case None     => state
                 case Some(ws) =>
-                  ws.get(channelName) match {
+                  ws.get(channelName) match
                     case None     => state
                     case Some(cs) => state.put(watchStates, ws + (channelName -> cs.incremented))
-                  }
-              }
-              val restoredState = newWatchState.get(stashedRepo) match {
+              val restoredState = newWatchState.get(stashedRepo) match
                 case None    => throw new IllegalStateException(s"No stashed repository for $state")
                 case Some(r) => newWatchState.put(globalFileTreeRepository, r)
-              }
               restoredState.remove(persistentFileStampCache).remove(Continuous.DynamicInputs)
-            },
-            afterWatch = state => {
+            ,
+            afterWatch = state =>
               context.clearAppenders(channelName + "-watch")
               repo.close()
               context.close()
-              state.get(watchStates) match {
+              state.get(watchStates) match
                 case None     => state
                 case Some(ws) => state.put(watchStates, ws - channelName)
-              }
-            },
+            ,
             callbacks = cb,
             dynamicInputs = dynamicInputs,
             pending = false,
           )
-          state.get(watchStates) match {
+          state.get(watchStates) match
             case None     => state.put(watchStates, Map(channelName -> s))
             case Some(ws) => state.put(watchStates, ws + (channelName -> s))
-          }
         case Some(cs) =>
           val cmd = cs.commands.mkString("; ")
           val msg =
             s"Tried to start new watch while channel, '$channelName', was already watching '$cmd'"
           throw new IllegalStateException(msg)
-      }
-    }
   private def watchCommand(
       name: String
   )(updateState: (String, State) => State): Command =
@@ -1295,13 +1208,12 @@ private[sbt] object ContinuousCommands {
       (cmdParser(name) ~> channelParser).map(channel => () => updateState(channel, state))
     } { case (_, newState) => newState() }
   private[sbt] val runWatchCommand = watchCommand(runWatch) { (channel, state) =>
-    state.get(watchStates).flatMap(_.get(channel)) match {
+    state.get(watchStates).flatMap(_.get(channel)) match
       case None     => state
       case Some(cs) =>
         val pre = StashOnFailure :: s"$preWatch $channel" :: Nil
         val post = FailureWall :: PopOnFailure :: s"$postWatch $channel" :: Nil
         pre ::: cs.commands.toList ::: post ::: state
-    }
   }
   private[sbt] def watchUITaskFor(state: State, channel: CommandChannel): Option[UITask] =
     state.get(watchStates).flatMap(_.get(channel.name)).map(new WatchUITask(channel, _, state))
@@ -1314,10 +1226,10 @@ private[sbt] object ContinuousCommands {
       cs: ContinuousState,
       state: State
   ) extends Thread(s"sbt-${channel.name}-watch-ui-thread")
-      with UITask {
-    override private[sbt] lazy val reader: UITask.Reader = () => {
+      with UITask:
+    override private[sbt] lazy val reader: UITask.Reader = () =>
       def stop = Right(s"${ContinuousCommands.stopWatch} ${channel.name}")
-      val exitAction: Watch.Action = {
+      val exitAction: Watch.Action =
         Watch.apply(
           cs.count,
           _ => (),
@@ -1325,14 +1237,12 @@ private[sbt] object ContinuousCommands {
           cs.callbacks.nextEvent,
           recursive = false
         )
-      }
-      val ws = state.get(watchStates) match {
+      val ws = state.get(watchStates) match
         case None     => throw new IllegalStateException("no watch states")
         case Some(ws) =>
           ws.get(channel.name)
             .getOrElse(throw new IllegalStateException(s"no watch state for ${channel.name}"))
-      }
-      exitAction match {
+      exitAction match
         // Use a Left so that the client can immediately exit watch via <enter>
         case Watch.CancelWatch => Left(s"$stopWatch ${channel.name}")
         case Watch.Trigger     => Right(s"$runWatch ${channel.name}")
@@ -1347,15 +1257,12 @@ private[sbt] object ContinuousCommands {
           cs.terminationAction = Some(a)
           stop.map(_ :: s"$failWatch ${channel.name}" :: Nil mkString "; ")
         case _ => stop
-      }
-    }
-  }
+  end WatchUITask
   @inline
   private def watchState(state: State, channel: String): ContinuousState =
-    state.get(watchStates).flatMap(_.get(channel)) match {
+    state.get(watchStates).flatMap(_.get(channel)) match
       case None    => throw new IllegalStateException(s"no watch state for $channel")
       case Some(s) => s
-    }
 
   private[sbt] val preWatchCommand = watchCommand(preWatch) { (channel, state) =>
     val ws = watchState(state, channel)
@@ -1368,15 +1275,14 @@ private[sbt] object ContinuousCommands {
     StandardMain.exchange.channelForName(channel).foreach { c =>
       c.terminal.setPrompt(Prompt.Pending)
     }
-    val postState = state.get(watchStates) match {
+    val postState = state.get(watchStates) match
       case None     => state
       case Some(ws) => state.put(watchStates, ws + (channel -> cs.withPending(false)))
-    }
     cs.afterCommand(postState)
   }
   private val exitWatchShared = (error: Boolean) =>
     (channel: String, state: State) =>
-      state.get(watchStates).flatMap(_.get(channel)) match {
+      state.get(watchStates).flatMap(_.get(channel)) match
         case Some(cs) =>
           val afterWatchState = cs.afterWatch(state)
           cs.callbacks.onExit()
@@ -1386,17 +1292,15 @@ private[sbt] object ContinuousCommands {
               c.terminal.setPrompt(Prompt.Pending)
               c.unprompt(ConsoleUnpromptEvent(Some(CommandSource(channel))))
             }
-          val newState = afterWatchState.get(watchStates) match {
+          val newState = afterWatchState.get(watchStates) match
             case None    => afterWatchState
             case Some(w) => afterWatchState.put(watchStates, w - channel)
-          }
           val commands = cs.commands.mkString("; ")
           val count = cs.count
           val action = cs.terminationAction.getOrElse(Watch.CancelWatch)
           val st = cs.callbacks.onTermination(action, commands, count, newState)
-          if (error) st.fail else st
-        case _ => if (error) state.fail else state
-      }
+          if error then st.fail else st
+        case _ => if error then state.fail else state
   private[sbt] val stopWatchCommand = watchCommand(stopWatch)(exitWatchShared(false))
   private[sbt] val failWatchCommand = watchCommand(failWatch)(exitWatchShared(true))
   /*
@@ -1404,27 +1308,25 @@ private[sbt] object ContinuousCommands {
    * still active watches.
    */
   private def localRepo[T](r: FileTreeRepository[T]): FileTreeRepository[T] =
-    new FileTreeRepository[T] {
+    new FileTreeRepository[T]:
       private val closeables = ConcurrentHashMap.newKeySet[AutoCloseable]
-      override def addObserver(observer: Observer[FileEvent[T]]): AutoCloseable = {
+      override def addObserver(observer: Observer[FileEvent[T]]): AutoCloseable =
         val ac = r.addObserver(observer)
         val safeCloseable: AutoCloseable = () =>
           try ac.close()
-          catch { case NonFatal(_) => }
+          catch
+            case NonFatal(_) =>
         closeables.add(safeCloseable)
-        () => {
+        () =>
           closeables.remove(safeCloseable)
           safeCloseable.close()
-        }
-      }
 
       override def register(glob: Glob): Either[IOException, Observable[FileEvent[T]]] =
         r.register(glob)
       override def close(): Unit = closeables.forEach { c =>
         try c.close()
-        catch { case NonFatal(_) => }
+        catch
+          case NonFatal(_) =>
       }
       override def list(path: Path): Seq[(Path, T)] = r.list(path)
-    }
-
-}
+end ContinuousCommands
diff --git a/main/src/main/scala/sbt/internal/CrossJava.scala b/main/src/main/scala/sbt/internal/CrossJava.scala
index 8e6a2d58d..87eaf488e 100644
--- a/main/src/main/scala/sbt/internal/CrossJava.scala
+++ b/main/src/main/scala/sbt/internal/CrossJava.scala
@@ -29,50 +29,47 @@ import sbt.internal.CommandStrings.{
   javaSwitchHelp
 }
 
-private[sbt] object CrossJava {
+private[sbt] object CrossJava:
   // parses jabba style version number adopt@1.8
-  def parseJavaVersion(version: String): JavaVersion = {
+  def parseJavaVersion(version: String): JavaVersion =
     val Num = """([0-9]+)""".r
     def splitDot(s: String): Vector[Long] =
-      Option(s) match {
+      Option(s) match
         case Some(x) =>
           x.split('.').toVector collect { case Num(n) =>
             n.toLong
           }
         case _ => Vector()
-      }
     def splitDash(str: String): Vector[String] =
       Option(str).fold(Vector.empty[String])(_.split('-').toVector)
     def splitAt(s: String): Vector[String] =
       Option(s).fold(Vector.empty[String])(_.split('@').toVector)
     def parse0(str: String): JavaVersion =
-      splitDash(str) match {
+      splitDash(str) match
         case Vector()  => sys.error(s"Invalid JavaVersion: $version")
         case Vector(h) => JavaVersion(splitDot(h), Vector(), None)
         case xs        => JavaVersion(splitDot(xs.head), xs.tail, None)
-      }
-    splitAt(version) match {
+    splitAt(version) match
       case Vector(vendor, rest) => parse0(rest).withVendor(vendor)
       case Vector(rest)         => parse0(rest)
       case _                    => sys.error(s"Invalid JavaVersion: $version")
-    }
-  }
+  end parseJavaVersion
 
   def parseSdkmanString(version: String): Try[JavaVersion] = Try {
     val Num = """([0-9]+)""".r
     def splitDash(str: String): Vector[String] =
       Option(str).fold(Vector.empty[String])(_.split('-').toVector)
     def splitDot(str: String): Vector[String] =
-      Option(str) match {
+      Option(str) match
         case Some(x) => x.split('.').toVector.filterNot(_ == "")
         case _       => Vector()
-      }
-    splitDash(version) match {
+    splitDash(version) match
       case xs if xs.size < 2 => sys.error(s"Invalid SDKMAN Java version: $version")
       case xs                =>
         val first = xs.init.head
         val ds =
-          if (!first.contains(".") && first.contains("u")) splitDot(first.replaceFirst("u", ".0."))
+          if !first.contains(".") && first.contains("u") then
+            splitDot(first.replaceFirst("u", ".0."))
           else splitDot(first)
         val nums = ds
           .takeWhile {
@@ -80,37 +77,32 @@ private[sbt] object CrossJava {
             case _      => false
           }
           .map { _.toLong }
-        if (nums.isEmpty) {
-          sys.error(s"Invalid SDKMAN Java version: $version")
-        }
+        if nums.isEmpty then sys.error(s"Invalid SDKMAN Java version: $version")
         val nonNum = ds.drop(nums.size).mkString("")
         // last dash indicates vendor code
-        val (vnd0, tag0) = (xs.last, nonNum) match {
+        val (vnd0, tag0) = (xs.last, nonNum) match
           case ("adpt", "hs") => ("adpt", "")
           case ("adpt", "j9") => ("adopt-openj9", "")
           case (v, t)         => (v, t)
-        }
-        val vnd = vnd0 match {
+        val vnd = vnd0 match
           case "adpt" => "adopt"
           case "open" => "openjdk"
           case "grl"  => "graalvm"
           case "amzn" => "corretto"
           case _      => vnd0
-        }
         val tag1: String = xs.init.tail.mkString("")
-        val tags = (if (tag0 == "") Vector.empty[String] else Vector(tag0)) ++
-          (if (tag1 == "") Vector.empty[String] else Vector(tag1))
+        val tags = (if tag0 == "" then Vector.empty[String] else Vector(tag0)) ++
+          (if tag1 == "" then Vector.empty[String] else Vector(tag1))
         JavaVersion().withNumbers(nums).withVendor(vnd).withTags(tags)
-    }
+    end match
   }
 
-  def lookupJavaHome(jv: String, mappings: Map[String, File]): File = {
+  def lookupJavaHome(jv: String, mappings: Map[String, File]): File =
     val ms = mappings map { (k, v) => (JavaVersion(k), v) }
     lookupJavaHome(JavaVersion(jv), ms)
-  }
 
-  def lookupJavaHome(jv: JavaVersion, mappings: Map[JavaVersion, File]): File = {
-    mappings.get(jv) match {
+  def lookupJavaHome(jv: JavaVersion, mappings: Map[JavaVersion, File]): File =
+    mappings.get(jv) match
       case Some(dir) => dir
 
       // when looking for "10" it should match "openjdk@10"
@@ -120,14 +112,11 @@ private[sbt] object CrossJava {
         }
         noVendors.get(jv).getOrElse(javaHomeNotFound(jv, mappings))
       case _ => javaHomeNotFound(jv, mappings)
-    }
-  }
 
-  private def javaHomeNotFound(version: JavaVersion, mappings: Map[JavaVersion, File]): Nothing = {
+  private def javaHomeNotFound(version: JavaVersion, mappings: Map[JavaVersion, File]): Nothing =
     sys.error(s"""Java home for $version was not found in $mappings
                  |
                  |use Global / javaHomes += JavaVersion("$version") -> file(...)""".stripMargin)
-  }
 
   private case class SwitchTarget(version: Option[JavaVersion], home: Option[File], force: Boolean)
   private case class SwitchJavaHome(target: SwitchTarget, verbose: Boolean, command: Option[String])
@@ -135,9 +124,9 @@ private[sbt] object CrossJava {
   private[sbt] val JavaSwitchCommandCompletions =
     Vector("-v", "compile", "test", "run", "clean", "console", "package")
 
-  private def switchParser(state: State): Parser[SwitchJavaHome] = {
+  private def switchParser(state: State): Parser[SwitchJavaHome] =
     import DefaultParsers.*
-    def versionAndCommand(spacePresent: Boolean) = {
+    def versionAndCommand(spacePresent: Boolean) =
       val x = Project.extract(state)
       import x.*
       val javaHomes = getJavaHomesTyped(x, currentRef)
@@ -156,7 +145,7 @@ private[sbt] object CrossJava {
               SwitchTarget(None, Option(new File(home)), true)
           }
       val spacedVersion =
-        if (spacePresent) version
+        if spacePresent then version
         else version & spacedFirst(JavaSwitchCommand)
       val verbose = Parser.opt(token(Space ~> "-v"))
       val optionalCommand =
@@ -166,37 +155,34 @@ private[sbt] object CrossJava {
       (spacedVersion ~ verbose ~ optionalCommand).map { case v ~ verbose ~ command =>
         SwitchJavaHome(v, verbose.isDefined, command)
       }
-    }
+    end versionAndCommand
     token(JavaSwitchCommand ~> OptSpace) flatMap { sp =>
       versionAndCommand(sp.nonEmpty)
     }
-  }
+  end switchParser
 
   private def getJavaHomes(
       extracted: Extracted,
       proj: ResolvedReference
-  ): Map[String, File] = {
+  ): Map[String, File] =
     import extracted.*
     (proj / Keys.fullJavaHomes).get(structure.data).get
-  }
 
   private def getJavaHomesTyped(
       extracted: Extracted,
       proj: ResolvedReference
-  ): Map[JavaVersion, File] = {
+  ): Map[JavaVersion, File] =
     getJavaHomes(extracted, proj) map { (k, v) => (JavaVersion(k), v) }
-  }
 
   private def getCrossJavaVersions(
       extracted: Extracted,
       proj: ResolvedReference
-  ): Seq[String] = {
+  ): Seq[String] =
     import extracted.*
     import Keys.*
     (proj / crossJavaVersions).get(structure.data).getOrElse(Nil)
-  }
 
-  private def getCrossJavaHomes(extracted: Extracted, proj: ResolvedReference): Seq[File] = {
+  private def getCrossJavaHomes(extracted: Extracted, proj: ResolvedReference): Seq[File] =
     import extracted.*
     import Keys.*
     val fjh = (proj / fullJavaHomes).get(structure.data).get
@@ -205,9 +191,8 @@ private[sbt] object CrossJava {
         lookupJavaHome(jv, fjh)
       }
     } getOrElse Vector()
-  }
 
-  private def switchCommandImpl(state: State, switch: SwitchJavaHome): State = {
+  private def switchCommandImpl(state: State, switch: SwitchJavaHome): State =
     val extracted = Project.extract(state)
     import extracted.*
     import Keys.javaHome
@@ -215,30 +200,27 @@ private[sbt] object CrossJava {
     // filter out subprojects based on switch target e.g. "10" vs what's in crossJavaVersions
     // for the subproject. Only if crossJavaVersions is non-empty, and does NOT include "10"
     // it will skip the subproject.
-    val projects: Seq[(ResolvedReference, Seq[String])] = {
+    val projects: Seq[(ResolvedReference, Seq[String])] =
       val projectJavaVersions =
         structure.allProjectRefs.map(proj => proj -> getCrossJavaVersions(extracted, proj))
-      if (switch.target.force) projectJavaVersions
+      if switch.target.force then projectJavaVersions
       else
-        switch.target.version match {
+        switch.target.version match
           case None    => projectJavaVersions
           case Some(v) =>
             projectJavaVersions flatMap { (proj, versions) =>
-              if (versions.isEmpty || versions.contains[String](v.toString))
+              if versions.isEmpty || versions.contains[String](v.toString) then
                 Vector(proj -> versions)
               else Vector()
             }
-        }
-    }
 
-    def setJavaHomeForProjects: State = {
+    def setJavaHomeForProjects: State =
       val newSettings = projects.flatMap { (proj, javaVersions) =>
         val fjh = getJavaHomesTyped(extracted, proj)
-        val home = switch.target match {
+        val home = switch.target match
           case SwitchTarget(Some(v), _, _) => lookupJavaHome(v, fjh)
           case SwitchTarget(_, Some(h), _) => h
           case _                           => sys.error(s"unexpected ${switch.target}")
-        }
         val scope = Scope(Select(proj), Zero, Zero, Zero)
         Seq(
           (scope / javaHome) := Some(home)
@@ -250,20 +232,19 @@ private[sbt] object CrossJava {
       val projectsContains: Reference => Boolean = projects.map(_._1).toSet[Reference].contains(_)
 
       // Filter out any old javaHome version settings that were added, this is just for hygiene.
-      val filteredRawAppend = session.rawAppend.filter(_.key match {
+      val filteredRawAppend = session.rawAppend.filter(_.key match
         case ScopedKey(Scope(Select(ref), Zero, Zero, Zero), key)
             if filterKeys.contains(key) && projectsContains(ref) =>
           false
-        case _ => true
-      })
+        case _ => true)
 
       val newSession = session.copy(rawAppend = filteredRawAppend ++ newSettings)
 
       BuiltinCommands.reapply(newSession, structure, state)
-    }
+    end setJavaHomeForProjects
 
     setJavaHomeForProjects
-  }
+  end switchCommandImpl
 
   def switchJavaHome: Command =
     Command.arb(requireSession(switchParser), javaSwitchHelp)(switchCommandImpl)
@@ -283,7 +264,7 @@ private[sbt] object CrossJava {
       } & spacedFirst(JavaCrossCommand)
     }
 
-  private def crossJavaHomeCommandImpl(state: State, args: CrossArgs): State = {
+  private def crossJavaHomeCommandImpl(state: State, args: CrossArgs): State =
     val x = Project.extract(state)
     import x.*
     val (aggs, aggCommand) = Cross.parseSlashCommand(x)(args.command)
@@ -299,18 +280,17 @@ private[sbt] object CrossJava {
     val verbose = ""
     // println(s"projVersions $projVersions")
 
-    if (projVersions.isEmpty) {
-      state
-    } else {
+    if projVersions.isEmpty then state
+    else
       // Detect whether a task or command has been issued
-      val allCommands = Parser.parse(aggCommand, Act.aggregatedKeyParser(x)) match {
+      val allCommands = Parser.parse(aggCommand, Act.aggregatedKeyParser(x)) match
         case Left(_) =>
           // It's definitely not a task, check if it's a valid command, because we don't want to emit the warning
           // message below for typos.
           val validCommand = Parser.parse(aggCommand, state.combinedParser).isRight
 
           val distinctCrossConfigs = projCrossVersions.map(_._2.toSet).distinct
-          if (validCommand && distinctCrossConfigs.size > 1) {
+          if validCommand && distinctCrossConfigs.size > 1 then
             state.log.warn(
               "Issuing a Java cross building command, but not all sub projects have the same cross build " +
                 "configuration. This could result in subprojects cross building against Java versions that they are " +
@@ -322,7 +302,6 @@ private[sbt] object CrossJava {
             projCrossVersions.foreach { (project, versions) =>
               state.log.debug(s"$project: $versions")
             }
-          }
 
           // Execute using a blanket switch
           projCrossVersions.toMap.apply(currentRef).flatMap { version =>
@@ -350,60 +329,50 @@ private[sbt] object CrossJava {
                 projects.map(_ + "/" + aggCommand).mkString("all ", " ", "")
               )
           }
-      }
 
       allCommands.toList ::: captureCurrentSession(state, x)
-    }
-  }
+    end if
+  end crossJavaHomeCommandImpl
 
   private val JavaCapturedSession = AttributeKey[Seq[Setting[?]]]("javaCrossCapturedSession")
 
-  private def captureCurrentSession(state: State, extracted: Extracted): State = {
+  private def captureCurrentSession(state: State, extracted: Extracted): State =
     state.put(JavaCapturedSession, extracted.session.rawAppend)
-  }
 
-  def discoverJavaHomes: ListMap[String, File] = {
+  def discoverJavaHomes: ListMap[String, File] =
     ListMap(JavaDiscoverConfig.configs flatMap { _.javaHomes } sortWith (versionOrder)*)
-  }
 
-  sealed trait JavaDiscoverConf {
+  sealed trait JavaDiscoverConf:
     def javaHomes: Vector[(String, File)]
-  }
 
   def versionOrder(left: (?, File), right: (?, File)): Boolean =
     versionOrder(left._2.getName, right._2.getName)
 
   // Sort version strings, considering 1.8.0 < 1.8.0_45 < 1.8.0_212
   @tailrec
-  def versionOrder(left: String, right: String): Boolean = {
+  def versionOrder(left: String, right: String): Boolean =
     val Pattern = """.*?([0-9]+)(.*)""".r
-    left match {
+    left match
       case Pattern(leftNumber, leftRest) =>
-        right match {
+        right match
           case Pattern(rightNumber, rightRest) =>
-            if (Integer.parseInt(leftNumber) < Integer.parseInt(rightNumber)) true
-            else if (Integer.parseInt(leftNumber) > Integer.parseInt(rightNumber)) false
+            if Integer.parseInt(leftNumber) < Integer.parseInt(rightNumber) then true
+            else if Integer.parseInt(leftNumber) > Integer.parseInt(rightNumber) then false
             else versionOrder(leftRest, rightRest)
           case _ =>
             false
-        }
       case _ =>
         true
-    }
-  }
 
-  object JavaDiscoverConfig {
-    object JavaHomeDir {
+  object JavaDiscoverConfig:
+    object JavaHomeDir:
       private val regex = """(\w+-)??(java-|(?:adoptopen)?jdk-?)?(bin-)?(1\.)?([0-9]+).*""".r
-      def unapply(s: CharSequence): Option[String] = {
-        s match {
+      def unapply(s: CharSequence): Option[String] =
+        s match
           case regex(vendor, _, _, m, n) => Some(JavaVersion(nullBlank(m) + n).toString)
           case _                         => None
-        }
-      }
-    }
 
-    class LinuxDiscoverConfig(base: File) extends JavaDiscoverConf {
+    class LinuxDiscoverConfig(base: File) extends JavaDiscoverConf:
       def candidates() = wrapNull(base.list())
 
       def javaHomes: Vector[(String, File)] =
@@ -411,9 +380,8 @@ private[sbt] object CrossJava {
           .collect { case dir @ JavaHomeDir(version) =>
             version -> (base / dir)
           }
-    }
 
-    class MacOsDiscoverConfig extends JavaDiscoverConf {
+    class MacOsDiscoverConfig extends JavaDiscoverConf:
       val base: File = file("/Library") / "Java" / "JavaVirtualMachines"
       // User-specific JDKs are installed, for example, by IntelliJ IDEA
       private val baseInUserHome: File = Path.userHome / "Library" / "Java" / "JavaVirtualMachines"
@@ -422,14 +390,12 @@ private[sbt] object CrossJava {
         findAllHomes(base) ++
           findAllHomes(baseInUserHome)
 
-      private def findAllHomes(root: File): Vector[(String, File)] = {
+      private def findAllHomes(root: File): Vector[(String, File)] =
         wrapNull(root.list()).collect { case dir @ JavaHomeDir(version) =>
           version -> (root / dir / "Contents" / "Home")
         }
-      }
-    }
 
-    class JabbaDiscoverConfig extends JavaDiscoverConf {
+    class JabbaDiscoverConfig extends JavaDiscoverConf:
       val base: File = Path.userHome / ".jabba" / "jdk"
       val JabbaJavaHomeDir = """([\w\-]+)\@(1\.)?([0-9]+).*""".r
 
@@ -437,26 +403,24 @@ private[sbt] object CrossJava {
         wrapNull(base.list())
           .collect { case dir @ JabbaJavaHomeDir(vendor, m, n) =>
             val v = JavaVersion(nullBlank(m) + n).withVendor(vendor).toString
-            if ((base / dir / "Contents" / "Home").exists) v -> (base / dir / "Contents" / "Home")
+            if (base / dir / "Contents" / "Home").exists then
+              v -> (base / dir / "Contents" / "Home")
             else v -> (base / dir)
           }
-    }
 
-    class SdkmanDiscoverConfig extends JavaDiscoverConf {
+    class SdkmanDiscoverConfig extends JavaDiscoverConf:
       val base: File = Path.userHome / ".sdkman" / "candidates" / "java"
       def candidates(): Vector[String] = wrapNull(base.list())
       def javaHomes: Vector[(String, File)] =
         candidates().collect {
           case dir if dir.contains("-") =>
-            CrossJava.parseSdkmanString(dir) match {
+            CrossJava.parseSdkmanString(dir) match
               case Success(v) => Some(v.toString -> (base / dir))
               case Failure(_) => None
-            }
         }.flatten
-    }
 
     class WindowsDiscoverConfig(base: File, vendors: Seq[String] = Seq.empty)
-        extends JavaDiscoverConf {
+        extends JavaDiscoverConf:
 
       def candidates() = wrapNull(base.list())
 
@@ -471,9 +435,8 @@ private[sbt] object CrossJava {
               val jv = JavaVersion(version)
               vendors.map(jv.withVendor(_).toString -> home)
           }
-    }
 
-    class JavaHomeDiscoverConfig extends JavaDiscoverConf {
+    class JavaHomeDiscoverConfig extends JavaDiscoverConf:
       def home() = sys.env.get("JAVA_HOME")
 
       def javaHomes: Vector[(String, File)] =
@@ -481,25 +444,22 @@ private[sbt] object CrossJava {
           .map(new java.io.File(_))
           .flatMap { javaHome =>
             val base = javaHome.getParentFile
-            javaHome.getName match {
+            javaHome.getName match
               case dir @ JavaHomeDir(version) =>
                 Some(version -> (base / dir))
               case _ => None
-            }
           }
           .toVector
-    }
 
-    class SetupJavaDiscoverConfig(base: File) extends JavaDiscoverConf {
+    class SetupJavaDiscoverConfig(base: File) extends JavaDiscoverConf:
       private val SetupJavaVendorDir =
         """Java_(Zulu|Temurin-Hotspot|Temurin|Adopt|Corretto|Liberica|Microsoft|Semeru)_jdk""".r
       private val SetupJavaVersionDir = """([0-9]+)\.([0-9]+)\.([0-9]+)(-[0-9]+)?""".r
 
-      private def normalizeVendor(vendor: String): String = vendor.toLowerCase match {
+      private def normalizeVendor(vendor: String): String = vendor.toLowerCase match
         case "temurin-hotspot" => "temurin"
         case "adopt"           => "temurin"
         case other             => other
-      }
 
       def candidates(): Vector[String] = wrapNull(base.list())
 
@@ -522,7 +482,7 @@ private[sbt] object CrossJava {
             }
           case _ => Vector.empty
         }
-    }
+    end SetupJavaDiscoverConfig
 
     val configs = Vector(
       new JabbaDiscoverConfig,
@@ -533,7 +493,7 @@ private[sbt] object CrossJava {
       new MacOsDiscoverConfig,
       new JavaHomeDiscoverConfig,
     ) ++ {
-      if (IO.isWindows) {
+      if IO.isWindows then
         def discover(dir: String, vendors: String*) = new WindowsDiscoverConfig(file(dir), vendors)
         Vector(
           new SetupJavaDiscoverConfig(file("C:") / "hostedtoolcache" / "windows"),
@@ -548,25 +508,25 @@ private[sbt] object CrossJava {
           discover("C://Program Files (x86)/Eclipse Foundation", "temurin", "adopt"),
           discover("C://Program Files (x86)/Semeru", "semeru", "adopt-openj9"),
         )
-      } else Vector.empty
+      else Vector.empty
     }
-  }
+  end JavaDiscoverConfig
 
   def nullBlank(s: String): String =
-    if (s eq null) ""
+    if s eq null then ""
     else s
 
-  def expandJavaHomes(hs: Map[String, File]): Map[String, File] = {
+  def expandJavaHomes(hs: Map[String, File]): Map[String, File] =
     val parsed = hs map { (k, v) =>
       JavaVersion(k) -> v
     }
     // first ignore vnd
     val withAndWithoutVnd = parsed flatMap { (k, v) =>
-      if (k.vendor.isDefined) Vector(k -> v, k.withVendor(None) -> v)
+      if k.vendor.isDefined then Vector(k -> v, k.withVendor(None) -> v)
       else Vector(k -> v)
     }
     val normalizeNumbers = withAndWithoutVnd flatMap { (k, v) =>
-      k.numbers match {
+      k.numbers match
         case Vector(1L, minor, _*) =>
           Vector(k -> v, k.withNumbers(Vector(minor)) -> v)
         case Vector(major) if major > 1 =>
@@ -575,15 +535,14 @@ private[sbt] object CrossJava {
           Vector(k -> v, k.withNumbers(Vector(major)) -> v, k.withNumbers(Vector(1L, major)) -> v)
         case _ =>
           Vector(k -> v)
-      }
     }
     val result: Map[String, File] = normalizeNumbers map { (k, v) =>
       (k.toString -> v)
     }
     result
-  }
+  end expandJavaHomes
 
   def wrapNull(a: Array[String]): Vector[String] =
-    if (a eq null) Vector()
+    if a eq null then Vector()
     else a.toVector
-}
+end CrossJava
diff --git a/main/src/main/scala/sbt/internal/DefaultBackgroundJobService.scala b/main/src/main/scala/sbt/internal/DefaultBackgroundJobService.scala
index f25c1770f..6f5b3fb83 100644
--- a/main/src/main/scala/sbt/internal/DefaultBackgroundJobService.scala
+++ b/main/src/main/scala/sbt/internal/DefaultBackgroundJobService.scala
@@ -37,7 +37,7 @@ import xsbti.HashedVirtualFileRef
 /**
  * Interface between sbt and a thing running in the background.
  */
-private[sbt] abstract class BackgroundJob {
+private[sbt] abstract class BackgroundJob:
   def humanReadableName: String
   @deprecated("Use awaitTermination that takes a duration argument", "1.4.0")
   final def awaitTermination(): Unit = awaitTermination(Duration.Inf)
@@ -45,16 +45,14 @@ private[sbt] abstract class BackgroundJob {
 
   /** This waits till the job ends, and returns inner error via `Try`. */
   @deprecated("Use awaitTerminationTry that takes a duration argument", "1.4.0")
-  final def awaitTerminationTry(): Try[Unit] = {
+  final def awaitTerminationTry(): Try[Unit] =
     // This implementation is provided only for backward compatibility.
     Try(awaitTermination(Duration.Inf))
-  }
 
   /** This waits till the job ends, and returns inner error via `Try`. */
-  def awaitTerminationTry(duration: Duration): Try[Unit] = {
+  def awaitTerminationTry(duration: Duration): Try[Unit] =
     // This implementation is provided only for backward compatibility.
     Try(awaitTermination(duration))
-  }
 
   def shutdown(): Unit
 
@@ -68,14 +66,13 @@ private[sbt] abstract class BackgroundJob {
 
   // do we need this or is the spawning task good enough?
   // def tags: SomeType
-}
+end BackgroundJob
 
-private[sbt] abstract class AbstractJobHandle extends JobHandle {
+private[sbt] abstract class AbstractJobHandle extends JobHandle:
   override def toString =
     s"JobHandle(${id}, ${humanReadableName}, ${Def.showFullKey.show(spawningTask)})"
-}
 
-private[sbt] abstract class AbstractBackgroundJobService extends BackgroundJobService {
+private[sbt] abstract class AbstractBackgroundJobService extends BackgroundJobService:
   private val nextId = new AtomicLong(1)
   private val pool = new BackgroundThreadPool()
   private val context = LoggerContext()
@@ -88,13 +85,12 @@ private[sbt] abstract class AbstractBackgroundJobService extends BackgroundJobSe
   private[sbt] def useLog4J: Boolean
   private val serviceTempDirRef = new AtomicReference[File]
   private def serviceTempDir: File = serviceTempDirRef.synchronized {
-    serviceTempDirRef.get match {
+    serviceTempDirRef.get match
       case null =>
         val dir = IO.createUniqueDirectory(serviceTempDirBase)
         serviceTempDirRef.set(dir)
         dir
       case s => s
-    }
   }
   // hooks for sending start/stop events
   protected def onAddJob(@deprecated("unused", "") job: JobHandle): Unit = ()
@@ -123,7 +119,7 @@ private[sbt] abstract class AbstractBackgroundJobService extends BackgroundJobSe
       val workingDirectory: File,
       val job: BackgroundJob,
       @volatile var isAutoCancel: Boolean = false,
-  ) extends AbstractJobHandle {
+  ) extends AbstractJobHandle:
     def humanReadableName: String = job.humanReadableName
 
     job.onStop { () =>
@@ -132,89 +128,75 @@ private[sbt] abstract class AbstractBackgroundJobService extends BackgroundJobSe
       context.clearAppenders(logger.name)
     }
     addJob(this)
-    override final def equals(other: Any): Boolean = other match {
+    override final def equals(other: Any): Boolean = other match
       case handle: JobHandle if handle.id == id => true
       case _                                    => false
-    }
     override final def hashCode(): Int = id.hashCode
-  }
 
   private val unknownTask = TaskKey[Unit]("unknownTask", "Dummy value")
   // we use this if we deserialize a handle for a job that no longer exists
   private final class DeadHandle(override val id: Long, override val humanReadableName: String)
-      extends AbstractJobHandle {
+      extends AbstractJobHandle:
     override val spawningTask: ScopedKey[?] = unknownTask
     override val isAutoCancel = false
-  }
 
-  private[sbt] def createWorkingDirectory: File = {
+  private[sbt] def createWorkingDirectory: File =
     val id = nextId.getAndIncrement()
     createWorkingDirectory(id)
-  }
-  private[sbt] def createWorkingDirectory(id: Long): File = {
+  private[sbt] def createWorkingDirectory(id: Long): File =
     val workingDir = serviceTempDir / s"job-$id"
     IO.createDirectory(workingDir)
     workingDir
-  }
 
   def doRunInBackground(
       spawningTask: ScopedKey[?],
       state: State,
       start: (Logger, File) => BackgroundJob
-  ): JobHandle = {
+  ): JobHandle =
     val id = nextId.getAndIncrement()
     val extracted = Project.extract(state)
     val logger =
       LogManager.constructBackgroundLog(extracted.structure.data, state, context)(spawningTask)
     val workingDir = createWorkingDirectory(id)
     val job =
-      try {
-        new ThreadJobHandle(id, spawningTask, logger, workingDir, start(logger, workingDir))
-      } catch {
+      try new ThreadJobHandle(id, spawningTask, logger, workingDir, start(logger, workingDir))
+      catch
         case e: Throwable =>
           // TODO: Fix this
           // logger.close()
           throw e
-      }
     job
-  }
 
   override def runInBackground(spawningTask: ScopedKey[?], state: State)(
       start: (Logger, File) => Unit
-  ): JobHandle = {
+  ): JobHandle =
     pool.run(this, spawningTask, state)(start)
-  }
 
   override private[sbt] def runInBackgroundWithLoader(spawningTask: ScopedKey[?], state: State)(
       start: (Logger, File) => (Option[ClassLoader], () => Unit)
-  ): JobHandle = {
+  ): JobHandle =
     pool.runWithLoader(this, spawningTask, state)(start)
-  }
 
   override final def close(): Unit = shutdown()
-  override def shutdown(): Unit = {
+  override def shutdown(): Unit =
     val deadline = 10.seconds.fromNow
-    while (jobSet.nonEmpty && !deadline.isOverdue()) {
+    while jobSet.nonEmpty && !deadline.isOverdue() do
       jobSet.headOption.foreach { handle =>
-        if (handle.job.isRunning()) {
+        if handle.job.isRunning() then
           handle.job.shutdown()
           handle.job.awaitTerminationTry(10.seconds)
-        }
         jobSet = jobSet - handle
       }
-    }
     pool.close()
     Option(serviceTempDirRef.get).foreach(IO.delete)
-  }
 
-  private def withHandle(job: JobHandle)(f: ThreadJobHandle => Unit): Unit = job match {
+  private def withHandle(job: JobHandle)(f: ThreadJobHandle => Unit): Unit = job match
     case handle: ThreadJobHandle @unchecked => f(handle)
     case _: DeadHandle @unchecked           => () // nothing to stop or wait for
     case other                              =>
       sys.error(
         s"BackgroundJobHandle does not originate with the current BackgroundJobService: $other"
       )
-  }
 
   override def stop(job: JobHandle): Unit =
     withHandle(job)(_.job.shutdown())
@@ -246,45 +228,40 @@ private[sbt] abstract class AbstractBackgroundJobService extends BackgroundJobSe
       workingDirectory: File,
       hashFileContents: Boolean,
       converter: FileConverter,
-  ): Classpath = {
+  ): Classpath =
     def syncTo(
         dir: File
-    )(source0: Attributed[HashedVirtualFileRef]): Attributed[HashedVirtualFileRef] = {
+    )(source0: Attributed[HashedVirtualFileRef]): Attributed[HashedVirtualFileRef] =
       val source1 = source0.data
       val source = converter.toPath(source1).toFile()
       val hash8 = Hash.toHex(Hash(source.toString)).take(8)
-      val id: File => String = if (hashFileContents) hash else lastModified
+      val id: File => String = if hashFileContents then hash else lastModified
       val dest = dir / hash8 / id(source) / source.getName
       if !dest.exists then
-        if (source.isDirectory) IO.copyDirectory(source, dest)
+        if source.isDirectory then IO.copyDirectory(source, dest)
         else IO.copyFile(source, dest)
       Attributed.blank(converter.toVirtualFile(dest.toPath))
-    }
     val xs = (products.toVector map { syncTo(workingDirectory / "target") }) ++
       ((full diff products) map { syncTo(serviceTempDir / "target") })
     xs
-  }
+  end copyClasspath
 
   /** An alternative to sbt.io.Hash that handles java.io.File being a directory. */
-  private def hash(f: File): String = {
+  private def hash(f: File): String =
     val digest = MessageDigest.getInstance("SHA")
     val buffer = new Array[Byte](8192)
     Files.walkFileTree(
       f.toPath,
-      new SimpleFileVisitor[Path]() {
-        override def visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult = {
+      new SimpleFileVisitor[Path]():
+        override def visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult =
           val dis = new DigestInputStream(new FileInputStream(file.toFile), digest)
-          try {
-            while (dis.read(buffer) >= 0) ()
+          try
+            while dis.read(buffer) >= 0 do ()
             FileVisitResult.CONTINUE
-          } catch {
-            case _: IOException => FileVisitResult.TERMINATE
-          } finally dis.close()
-        }
-      }
+          catch case _: IOException => FileVisitResult.TERMINATE
+          finally dis.close()
     )
     Hash.toHex(Hash(digest.digest)).take(8)
-  }
 
   /**
    * Computes the last modified time of a file or the maximum last file of the contents of a
@@ -294,20 +271,17 @@ private[sbt] abstract class AbstractBackgroundJobService extends BackgroundJobSe
    * @return the last modified time of the file or the maximum last modified time of the contents
    *         of the directory.
    */
-  private def lastModified(f: File): String = {
+  private def lastModified(f: File): String =
     var lastModified = 0L
     Files.walkFileTree(
       f.toPath,
-      new SimpleFileVisitor[Path]() {
-        override def visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult = {
+      new SimpleFileVisitor[Path]():
+        override def visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult =
           val lm = attrs.lastModifiedTime.toMillis
-          if (lm > lastModified) lastModified = lm
+          if lm > lastModified then lastModified = lm
           FileVisitResult.CONTINUE
-        }
-      }
     )
     lastModified.toString
-  }
 
   /** Copies classpath to temporary directories. */
   override def copyClasspath(
@@ -341,30 +315,27 @@ private[sbt] abstract class AbstractBackgroundJobService extends BackgroundJobSe
         val source = e.source.get
         StandardMain.exchange.channelForName(source.channelName)
       case _ => None
-}
+end AbstractBackgroundJobService
 
-private[sbt] object BackgroundThreadPool {
+private[sbt] object BackgroundThreadPool:
   sealed trait Status
   case object Waiting extends Status
   final case class Running(thread: Thread) extends Status
   // the oldThread is None if we never ran
   final case class Stopped(oldThread: Option[Thread]) extends Status
-}
 
-private[sbt] class BackgroundThreadPool extends java.io.Closeable {
+private[sbt] class BackgroundThreadPool extends java.io.Closeable:
 
   private val nextThreadId = new java.util.concurrent.atomic.AtomicInteger(1)
   private val threadGroup = Thread.currentThread.getThreadGroup()
 
-  private val threadFactory = new java.util.concurrent.ThreadFactory() {
-    override def newThread(runnable: Runnable): Thread = {
+  private val threadFactory = new java.util.concurrent.ThreadFactory():
+    override def newThread(runnable: Runnable): Thread =
       val thread =
         new Thread(threadGroup, runnable, s"sbt-bg-threads-${nextThreadId.getAndIncrement}")
       // Do NOT setDaemon because then the code in TaskExit.scala in sbt will insta-kill
       // the backgrounded process, at least for the case of the run task.
       thread
-    }
-  }
 
   private[internal] val executor = new java.util.concurrent.ThreadPoolExecutor(
     0, /* corePoolSize */
@@ -378,7 +349,7 @@ private[sbt] class BackgroundThreadPool extends java.io.Closeable {
 
   private class BackgroundRunnable(val taskName: String, body: () => Unit)
       extends BackgroundJob
-      with Runnable {
+      with Runnable:
     import BackgroundThreadPool.*
     private val finishedLatch = new java.util.concurrent.CountDownLatch(1)
     // synchronize to read/write this, no sync to just read
@@ -390,9 +361,9 @@ private[sbt] class BackgroundThreadPool extends java.io.Closeable {
 
     // double-finally for extra paranoia that we will finishedLatch.countDown
     override def run() =
-      try {
+      try
         val go = synchronized {
-          status match {
+          status match
             case Waiting =>
               status = Running(Thread.currentThread())
               true
@@ -400,24 +371,19 @@ private[sbt] class BackgroundThreadPool extends java.io.Closeable {
               false
             case Running(_) =>
               throw new RuntimeException("Impossible status of bg thread")
-          }
         }
-        try {
-          if (go) {
-            exitTry = Option(Try(body()))
-          }
-        } finally cleanup()
-      } finally finishedLatch.countDown()
+        try
+          if go then exitTry = Option(Try(body()))
+        finally cleanup()
+      finally finishedLatch.countDown()
 
     private class StopListener(val callback: () => Unit, val executionContext: ExecutionContext)
-        extends Closeable {
+        extends Closeable:
       override def close(): Unit = removeListener(this)
       override def hashCode: Int = System.identityHashCode(this)
-      override def equals(other: Any): Boolean = other match {
+      override def equals(other: Any): Boolean = other match
         case r: AnyRef => this eq r
         case _         => false
-      }
-    }
 
     // access is synchronized
     private var stopListeners = Set.empty[StopListener]
@@ -426,11 +392,11 @@ private[sbt] class BackgroundThreadPool extends java.io.Closeable {
       stopListeners -= listener
     }
 
-    def cleanup(): Unit = {
+    def cleanup(): Unit =
       // avoid holding any lock while invoking callbacks, and
       // handle callbacks being added by other callbacks, just
       // to be all fancy.
-      while (synchronized { stopListeners.nonEmpty }) {
+      while synchronized { stopListeners.nonEmpty } do
         val listeners = synchronized {
           val list = stopListeners.toList
           stopListeners = Set.empty
@@ -440,8 +406,6 @@ private[sbt] class BackgroundThreadPool extends java.io.Closeable {
           try l.executionContext.execute(() => l.callback())
           catch case NonFatal(_) => ()
         }
-      }
-    }
 
     override def onStop(listener: () => Unit)(using ex: ExecutionContext): Closeable =
       synchronized {
@@ -449,25 +413,22 @@ private[sbt] class BackgroundThreadPool extends java.io.Closeable {
         stopListeners += result
         result
       }
-    override def awaitTermination(duration: Duration): Unit = {
-      val finished = duration match {
+    override def awaitTermination(duration: Duration): Unit =
+      val finished = duration match
         case fd: FiniteDuration => finishedLatch.await(fd.toMillis, TimeUnit.MILLISECONDS)
         case _                  => finishedLatch.await(); true
-      }
       exitTry.foreach(_.fold(e => throw e, identity))
-      if (!finished) throw new TimeoutException
-    }
+      if !finished then throw new TimeoutException
 
     override def humanReadableName: String = taskName
     override def isRunning(): Boolean =
-      status match {
+      status match
         case Waiting               => true // we start as running from BackgroundJob perspective
         case Running(thread)       => thread.isAlive()
         case Stopped(threadOption) => threadOption.map(_.isAlive()).getOrElse(false)
-      }
     override def shutdown(): Unit =
       synchronized {
-        status match {
+        status match
           case Waiting =>
             status = Stopped(None) // makes run() not run the body
           case Running(thread) =>
@@ -475,23 +436,20 @@ private[sbt] class BackgroundThreadPool extends java.io.Closeable {
             thread.interrupt()
           case Stopped(threadOption) =>
             // sleep to avoid consuming a lot of CPU
-            try {
-              Thread.sleep(10)
-            } catch {
+            try Thread.sleep(10)
+            catch
               case e: InterruptedException =>
                 Thread.currentThread().interrupt();
-            }
             // try to interrupt again! woot!
             threadOption.foreach(_.interrupt())
-        }
       }
-  }
+  end BackgroundRunnable
   private class BackgroundRunnableWithLoader(
       val loader: Option[ClassLoader],
       taskName: String,
       body: () => Unit
-  ) extends BackgroundRunnable(taskName, body) {
-    override def awaitTermination(duration: Duration): Unit = {
+  ) extends BackgroundRunnable(taskName, body):
+    override def awaitTermination(duration: Duration): Unit =
       try super.awaitTermination(duration)
       finally
         loader.foreach {
@@ -499,13 +457,11 @@ private[sbt] class BackgroundThreadPool extends java.io.Closeable {
           case cp: ClasspathFilter => cp.close()
           case _                   =>
         }
-    }
-  }
 
   def run(manager: AbstractBackgroundJobService, spawningTask: ScopedKey[?], state: State)(
       work: (Logger, File) => Unit
-  ): JobHandle = {
-    def start(logger: Logger, workingDir: File): BackgroundJob = {
+  ): JobHandle =
+    def start(logger: Logger, workingDir: File): BackgroundJob =
       val runnable = new BackgroundRunnable(
         spawningTask.key.label,
         { () =>
@@ -514,9 +470,7 @@ private[sbt] class BackgroundThreadPool extends java.io.Closeable {
       )
       executor.execute(runnable)
       runnable
-    }
     manager.doRunInBackground(spawningTask, state, start)
-  }
 
   private[sbt] def runWithLoader(
       manager: AbstractBackgroundJobService,
@@ -524,56 +478,47 @@ private[sbt] class BackgroundThreadPool extends java.io.Closeable {
       state: State
   )(
       getWork: (Logger, File) => (Option[ClassLoader], () => Unit)
-  ): JobHandle = {
-    def start(logger: Logger, workingDir: File): BackgroundJob = {
+  ): JobHandle =
+    def start(logger: Logger, workingDir: File): BackgroundJob =
       val (loader, work) = getWork(logger, workingDir)
       val runnable = new BackgroundRunnableWithLoader(loader, spawningTask.key.label, work)
       executor.execute(runnable)
       runnable
-    }
     manager.doRunInBackground(spawningTask, state, start)
-  }
 
-  override def close(): Unit = {
+  override def close(): Unit =
     executor.shutdown()
-  }
-}
+end BackgroundThreadPool
 
 private[sbt] class DefaultBackgroundJobService(
     private[sbt] val serviceTempDirBase: File,
     override private[sbt] val useLog4J: Boolean
-) extends AbstractBackgroundJobService {
+) extends AbstractBackgroundJobService:
   def this(serviceTempDirBase: File) = this(serviceTempDirBase, false)
 
   @deprecated("Use the constructor that specifies the background job temporary directory", "1.4.0")
   def this() = this(IO.createTemporaryDirectory, false)
-}
-private[sbt] object DefaultBackgroundJobService {
+private[sbt] object DefaultBackgroundJobService:
 
   private val backgroundJobServices = new ConcurrentHashMap[File, DefaultBackgroundJobService]
-  private[sbt] def shutdown(): Unit = {
+  private[sbt] def shutdown(): Unit =
     backgroundJobServices.values.forEach(_.shutdown())
     backgroundJobServices.clear()
-  }
 
-  private[sbt] def stop(): Unit = {
+  private[sbt] def stop(): Unit =
     backgroundJobServices
       .values()
-      .forEach(jobService => {
-        jobService.jobs.withFilter(_.isAutoCancel).foreach(jobService.stop)
-      })
-  }
+      .forEach(jobService => jobService.jobs.withFilter(_.isAutoCancel).foreach(jobService.stop))
 
   private[sbt] lazy val backgroundJobServiceSetting: Setting[?] =
     (GlobalScope / Keys.bgJobService) := {
       val path = (GlobalScope / sbt.Keys.bgJobServiceDirectory).value
       val newService = new DefaultBackgroundJobService(path)
-      backgroundJobServices.putIfAbsent(path, newService) match {
+      backgroundJobServices.putIfAbsent(path, newService) match
         case null => newService
         case s    =>
           newService.shutdown()
           s
-      }
     }
   private[sbt] lazy val backgroundJobServiceSettings: Seq[Def.Setting[?]] = Def.settings(
     (GlobalScope / Keys.bgJobServiceDirectory) := {
@@ -581,4 +526,4 @@ private[sbt] object DefaultBackgroundJobService {
     },
     backgroundJobServiceSetting
   )
-}
+end DefaultBackgroundJobService
diff --git a/main/src/main/scala/sbt/internal/DefaultRunProfiler.scala b/main/src/main/scala/sbt/internal/DefaultRunProfiler.scala
index cc3f54c64..42ed5df5f 100644
--- a/main/src/main/scala/sbt/internal/DefaultRunProfiler.scala
+++ b/main/src/main/scala/sbt/internal/DefaultRunProfiler.scala
@@ -11,7 +11,7 @@ package sbt.internal
 import xsbti.VirtualFileRef
 import xsbti.compile.{ APIChange, InitialChanges, RunProfiler }
 
-class DefaultRunProfiler(profilers: Seq[RunProfiler]) extends RunProfiler {
+class DefaultRunProfiler(profilers: Seq[RunProfiler]) extends RunProfiler:
   override def timeCompilation(startNanos: Long, durationNanos: Long): Unit =
     profilers.foreach(_.timeCompilation(startNanos, durationNanos))
 
@@ -51,4 +51,4 @@ class DefaultRunProfiler(profilers: Seq[RunProfiler]) extends RunProfiler {
 
   override def registerRun(): Unit =
     profilers.foreach(_.registerRun())
-}
+end DefaultRunProfiler
diff --git a/main/src/main/scala/sbt/internal/DynamicInput.scala b/main/src/main/scala/sbt/internal/DynamicInput.scala
index 92d428644..87514fc58 100644
--- a/main/src/main/scala/sbt/internal/DynamicInput.scala
+++ b/main/src/main/scala/sbt/internal/DynamicInput.scala
@@ -17,27 +17,20 @@ private[sbt] final case class DynamicInput(
     fileStamper: FileStamper,
     forceTrigger: Boolean
 )
-private[sbt] object DynamicInput {
-  given ordering: Ordering[DynamicInput] = new Ordering[DynamicInput] {
+private[sbt] object DynamicInput:
+  given ordering: Ordering[DynamicInput] = new Ordering[DynamicInput]:
     private given globOrdering: Ordering[Glob] = Glob.ordering
     val fileStamperOrdering: Ordering[FileStamper] = (left: FileStamper, right: FileStamper) =>
-      left match {
+      left match
         case FileStamper.Hash =>
-          right match {
+          right match
             case FileStamper.Hash => 0
             case _                => -1
-          }
         case FileStamper.LastModified =>
-          right match {
+          right match
             case FileStamper.LastModified => 0
             case _                        => 1
-          }
-      }
-    override def compare(left: DynamicInput, right: DynamicInput): Int = {
-      globOrdering.compare(left.glob, right.glob) match {
+    override def compare(left: DynamicInput, right: DynamicInput): Int =
+      globOrdering.compare(left.glob, right.glob) match
         case 0 => fileStamperOrdering.compare(left.fileStamper, right.fileStamper)
         case i => i
-      }
-    }
-  }
-}
diff --git a/main/src/main/scala/sbt/internal/FastTrackCommands.scala b/main/src/main/scala/sbt/internal/FastTrackCommands.scala
index 1b8568e96..094a42c9f 100644
--- a/main/src/main/scala/sbt/internal/FastTrackCommands.scala
+++ b/main/src/main/scala/sbt/internal/FastTrackCommands.scala
@@ -17,19 +17,18 @@ import ContinuousCommands.*
 import sbt.internal.util.complete.Parser
 
 /** This is used to speed up command parsing. */
-private[sbt] object FastTrackCommands {
+private[sbt] object FastTrackCommands:
   private def fromCommand(
       cmd: String,
       command: Command,
       arguments: Boolean = true,
   ): (State, String) => Option[State] =
     (s, c) =>
-      Parser.parse(if (arguments) c else "", command.parser(s)) match {
+      Parser.parse(if arguments then c else "", command.parser(s)) match
         case Right(newState) => Some(newState())
         case l               => None
-      }
   private val commands = Map[String, (State, String) => Option[State]](
-    FailureWall -> { (s, c) => if (c == FailureWall) Some(s) else None },
+    FailureWall -> { (s, c) => if c == FailureWall then Some(s) else None },
     StashOnFailure -> fromCommand(StashOnFailure, stashOnFailure, arguments = false),
     PopOnFailure -> fromCommand(PopOnFailure, popOnFailure, arguments = false),
     Shell -> fromCommand(Shell, shell),
@@ -40,14 +39,11 @@ private[sbt] object FastTrackCommands {
     stopWatch -> fromCommand(stopWatch, stopWatchCommand),
     waitWatch -> fromCommand(waitWatch, waitCmd),
   )
-  private[sbt] def evaluate(state: State, cmd: String): Option[State] = {
-    cmd.trim.split(" ") match {
+  private[sbt] def evaluate(state: State, cmd: String): Option[State] =
+    cmd.trim.split(" ") match
       case Array(h, _*) =>
-        commands.get(h) match {
+        commands.get(h) match
           case Some(command) => command(state, cmd)
           case _             => None
-        }
       case _ => None
-    }
-  }
-}
+end FastTrackCommands
diff --git a/main/src/main/scala/sbt/internal/FileChangesMacro.scala b/main/src/main/scala/sbt/internal/FileChangesMacro.scala
index 171948dc9..7ca76036d 100644
--- a/main/src/main/scala/sbt/internal/FileChangesMacro.scala
+++ b/main/src/main/scala/sbt/internal/FileChangesMacro.scala
@@ -49,6 +49,7 @@ object FileChangesMacro:
     )
     inline def outputFiles: Seq[NioPath] =
       ${ FileChangesMacro.outputFilesImpl[A]('in) }
+  end extension
 
   def changedInputFilesImpl[A: Type](in: Expr[TaskKey[A]])(using qctx: Quotes): Expr[FileChanges] =
     impl[A](
diff --git a/main/src/main/scala/sbt/internal/GCMonitor.scala b/main/src/main/scala/sbt/internal/GCMonitor.scala
index 305fda484..f1a099ec2 100644
--- a/main/src/main/scala/sbt/internal/GCMonitor.scala
+++ b/main/src/main/scala/sbt/internal/GCMonitor.scala
@@ -17,7 +17,7 @@ import scala.jdk.CollectionConverters.*
 import scala.util.Try
 import sbt.util.Logger
 
-trait GCMonitorBase {
+trait GCMonitorBase:
   protected def window: FiniteDuration
 
   protected def ratio: Double
@@ -34,7 +34,7 @@ trait GCMonitorBase {
       nowMillis: Long,
       collectionTime: Long,
       collectionTimeStore: AtomicReference[(FiniteDuration, Long)]
-  ): Unit = {
+  ): Unit =
     val now = nowMillis.millis
     val (lastTimestamp, lastCollectionTime) = collectionTimeStore.getAndSet(now -> collectionTime)
     val elapsed = collectionTime - lastCollectionTime
@@ -42,14 +42,12 @@ trait GCMonitorBase {
     queue.add(lastTimestamp -> elapsed)
     val total = queueScala.foldLeft(0L) { case (total, (_, t)) => total + t }
     val over = queueScala.headOption.map(nowMillis - _._1.toMillis)
-    if ((total > window.toMillis * ratio) && (lastWarned.get + window).time <= now) {
+    if (total > window.toMillis * ratio) && (lastWarned.get + window).time <= now then
       lastWarned.set(Deadline(now))
       emitWarning(total, over)
-    }
-  }
-}
+end GCMonitorBase
 
-class GCMonitor(logger: Logger) extends GCMonitorBase with AutoCloseable {
+class GCMonitor(logger: Logger) extends GCMonitorBase with AutoCloseable:
   override protected def window =
     System.getProperty("sbt.gc.monitor.window", "10").toIntOption.getOrElse(10).seconds
 
@@ -60,7 +58,7 @@ class GCMonitor(logger: Logger) extends GCMonitorBase with AutoCloseable {
   val runtime = Runtime.getRuntime
   def gbString(n: Long) = f"${n / GB}%.2fGB"
 
-  override protected def emitWarning(total: Long, over: Option[Long]): Unit = {
+  override protected def emitWarning(total: Long, over: Option[Long]): Unit =
     val totalSeconds = total / 1000.0
     val amountMsg = over.fold(f"$totalSeconds%.3f CPU seconds") { d =>
       val dSeconds = (d / 1000.0).ceil.toInt
@@ -74,7 +72,6 @@ class GCMonitor(logger: Logger) extends GCMonitorBase with AutoCloseable {
       "Consider increasing the JVM heap using `-Xmx` or try " +
       "a different collector, e.g. `-XX:+UseG1GC`, for better performance."
     logger.warn(msg)
-  }
 
   val removers = ManagementFactory.getGarbageCollectorMXBeans.asScala.flatMap {
     case bean: NotificationEmitter =>
@@ -91,7 +88,6 @@ class GCMonitor(logger: Logger) extends GCMonitorBase with AutoCloseable {
       Some(() => bean.removeNotificationListener(listener))
     case _ => None
   }
-  override def close(): Unit = {
+  override def close(): Unit =
     removers.foreach(_.apply())
-  }
-}
+end GCMonitor
diff --git a/main/src/main/scala/sbt/internal/GCUtil.scala b/main/src/main/scala/sbt/internal/GCUtil.scala
index a315008cf..b04a2d668 100644
--- a/main/src/main/scala/sbt/internal/GCUtil.scala
+++ b/main/src/main/scala/sbt/internal/GCUtil.scala
@@ -14,29 +14,26 @@ import scala.concurrent.duration.*
 import scala.util.control.NonFatal
 import sbt.util.Logger
 
-private[sbt] object GCUtil {
+private[sbt] object GCUtil:
   // Returns the default force garbage collection flag,
   // as specified by system properties.
   val defaultForceGarbageCollection: Boolean = true
   val defaultMinForcegcInterval: Duration = 10.minutes
   val lastGcCheck: AtomicLong = new AtomicLong(System.currentTimeMillis)
 
-  def forceGcWithInterval(minForcegcInterval: Duration, log: Logger): Unit = {
+  def forceGcWithInterval(minForcegcInterval: Duration, log: Logger): Unit =
     val now = System.currentTimeMillis
     val last = lastGcCheck.get
     // This throttles System.gc calls to interval
-    if (now - last > minForcegcInterval.toMillis) {
+    if now - last > minForcegcInterval.toMillis then
       lastGcCheck.lazySet(now)
       forceGc(log)
-    }
-  }
 
   def forceGc(log: Logger): Unit =
-    try {
+    try
       log.debug(s"Forcing garbage collection...")
       // Force the detection of finalizers for scala.reflect weakhashsets
       System.gc()
-    } catch {
+    catch
       case NonFatal(_) => // gotta catch em all
-    }
-}
+end GCUtil
diff --git a/main/src/main/scala/sbt/internal/GlobalPlugin.scala b/main/src/main/scala/sbt/internal/GlobalPlugin.scala
index 7a178feaa..885d094c6 100644
--- a/main/src/main/scala/sbt/internal/GlobalPlugin.scala
+++ b/main/src/main/scala/sbt/internal/GlobalPlugin.scala
@@ -26,7 +26,7 @@ import sbt.ProjectExtra.{ extract, runUnloadHooks, setProject }
 import sbt.SlashSyntax0.*
 import sbt.librarymanagement.LibraryManagementCodec.given
 
-object GlobalPlugin {
+object GlobalPlugin:
   // constructs a sequence of settings that may be appended to a project's settings to
   //  statically add the global plugin as a classpath dependency.
   //  static here meaning that the relevant tasks for the global plugin have already been evaluated
@@ -51,7 +51,7 @@ object GlobalPlugin {
       (prev ++ cp).distinct
     }
 
-  def build(base: File, s: State, config: LoadBuildConfiguration): (BuildStructure, State) = {
+  def build(base: File, s: State, config: LoadBuildConfiguration): (BuildStructure, State) =
     val newInject =
       config.injectSettings.copy(global = config.injectSettings.global ++ globalPluginSettings)
     val globalConfig = config.copy(
@@ -61,15 +61,13 @@ object GlobalPlugin {
     val (eval, structure) = Load(base, s, globalConfig)
     val session = Load.initialSession(structure, eval)
     (structure, Project.setProject(session, structure, s))
-  }
-  def load(base: File, s: State, config: LoadBuildConfiguration): GlobalPlugin = {
+  def load(base: File, s: State, config: LoadBuildConfiguration): GlobalPlugin =
     val (structure, state) = build(base, s, config)
     val (newS, data) = extract(state, structure)
     Project.runUnloadHooks(newS) // discard state
     GlobalPlugin(data, structure, inject(data), base)
-  }
 
-  def extract(state: State, structure: BuildStructure): (State, GlobalPluginData) = {
+  def extract(state: State, structure: BuildStructure): (State, GlobalPluginData) =
     import structure.{ data, root, rootProject }
     val p: Scope = Scope.GlobalScope.rescope(ProjectRef(root, rootProject(root)))
 
@@ -94,13 +92,13 @@ object GlobalPlugin {
     val task = resolvedTaskInit.evaluate(data)
     val roots = resolvedTaskInit.dependencies
     evaluate(state, structure, task, roots)
-  }
+  end extract
   def evaluate[T](
       state: State,
       structure: BuildStructure,
       t: Task[T],
       roots: Seq[ScopedKey[?]]
-  ): (State, T) = {
+  ): (State, T) =
     import EvaluateTask.*
     withStreams(structure, state) { str =>
       val nv = nodeView(state, str, roots)
@@ -108,7 +106,6 @@ object GlobalPlugin {
       val (newS, result) = runTask(t, state, str, structure.index.triggers, config)(using nv)
       (newS, processResult2(result))
     }
-  }
 
   val globalPluginSettings = Project.inScope(Scope.GlobalScope.rescope(LocalRootProject))(
     Seq(
@@ -119,7 +116,7 @@ object GlobalPlugin {
       version := "0.0"
     )
   )
-}
+end GlobalPlugin
 final case class GlobalPluginData(
     projectID: ModuleID,
     dependencies: Seq[ModuleID],
diff --git a/main/src/main/scala/sbt/internal/GroupedAutoPlugins.scala b/main/src/main/scala/sbt/internal/GroupedAutoPlugins.scala
index 423e1b6df..e4d09ceca 100644
--- a/main/src/main/scala/sbt/internal/GroupedAutoPlugins.scala
+++ b/main/src/main/scala/sbt/internal/GroupedAutoPlugins.scala
@@ -15,19 +15,16 @@ import java.net.URI
 private[sbt] final class GroupedAutoPlugins(
     val all: Seq[AutoPlugin],
     val byBuild: Map[URI, Seq[AutoPlugin]]
-) {
+):
   lazy val globalSettings: Seq[Setting[?]] = all.flatMap(_.globalSettings)
   private lazy val buildSettingsMap: Map[URI, Seq[Setting[?]]] =
     byBuild.view.mapValues(_.flatMap(_.buildSettings)).toMap
   def buildSettings(uri: URI): Seq[Setting[?]] =
     buildSettingsMap.getOrElse(uri, Nil)
-}
 
-private[sbt] object GroupedAutoPlugins {
-  private[sbt] def apply(units: Map[URI, LoadedBuildUnit]): GroupedAutoPlugins = {
+private[sbt] object GroupedAutoPlugins:
+  private[sbt] def apply(units: Map[URI, LoadedBuildUnit]): GroupedAutoPlugins =
     val byBuild: Map[URI, Seq[AutoPlugin]] =
       units.view.mapValues(unit => unit.projects.flatMap(_.autoPlugins).toSeq.distinct).toMap
     val all: Seq[AutoPlugin] = byBuild.values.toSeq.flatten.distinct
     new GroupedAutoPlugins(all, byBuild)
-  }
-}
diff --git a/main/src/main/scala/sbt/internal/InMemoryCacheStore.scala b/main/src/main/scala/sbt/internal/InMemoryCacheStore.scala
index 7e567245f..590902f23 100644
--- a/main/src/main/scala/sbt/internal/InMemoryCacheStore.scala
+++ b/main/src/main/scala/sbt/internal/InMemoryCacheStore.scala
@@ -18,8 +18,8 @@ import sbt.io.IO
 import sbt.util.{ CacheStore, CacheStoreFactory, DirectoryStoreFactory, GzipFileInput }
 import sjsonnew.{ JsonReader, JsonWriter }
 
-private[sbt] object InMemoryCacheStore {
-  private class InMemoryCacheStore(maxSize: Long) extends AutoCloseable {
+private[sbt] object InMemoryCacheStore:
+  private class InMemoryCacheStore(maxSize: Long) extends AutoCloseable:
     private val weigher: Weigher[Path, (Any, Long, Int)] = { case (_, (_, _, size)) => size }
     private val files: Cache[Path, (Any, Long, Int)] = Caffeine
       .newBuilder()
@@ -30,22 +30,15 @@ private[sbt] object InMemoryCacheStore {
       files.getIfPresent(path) match
         case null                     => None
         case (value, lastModified, _) => Some((value.asInstanceOf[A1], lastModified))
-    def put(path: Path, value: Any, lastModified: Long): Unit = {
-      try {
-        if (lastModified > 0) {
-          files.put(path, (value, lastModified, toIntExact(weightOf(path))))
-        }
-      } catch {
-        case _: IOException | _: ArithmeticException => files.invalidate(path)
-      }
-    }
+    def put(path: Path, value: Any, lastModified: Long): Unit =
+      try
+        if lastModified > 0 then files.put(path, (value, lastModified, toIntExact(weightOf(path))))
+      catch case _: IOException | _: ArithmeticException => files.invalidate(path)
     def remove(path: Path): Unit = files.invalidate(path)
 
-    override def close(): Unit = {
+    override def close(): Unit =
       files.invalidateAll()
       files.cleanUp()
-    }
-  }
 
   /**
    * An entry costs its serialized size, uncompressed -- the unit the budget was denominated in before
@@ -54,24 +47,22 @@ private[sbt] object InMemoryCacheStore {
   private def weightOf(path: Path): Long = GzipFileInput.uncompressedSize(path.toFile)
 
   private class CacheStoreImpl(path: Path, store: InMemoryCacheStore, cacheStore: CacheStore)
-      extends CacheStore {
+      extends CacheStore:
     override def delete(): Unit = cacheStore.delete()
 
     /**
      * A miss populates the cache. `write` is otherwise the only thing that fills it, and a task whose stored
      * output is already up to date never writes -- so it would re-deserialise that output on every invocation.
      */
-    override def read[T]()(using reader: JsonReader[T]): T = {
+    override def read[T]()(using reader: JsonReader[T]): T =
       val lastModified = IO.getModifiedTimeOrZero(path.toFile)
-      store.get[T](path) match {
+      store.get[T](path) match
         case Some((value, `lastModified`)) => value
         case _                             =>
           val value = cacheStore.read[T]()
           store.put(path, value, lastModified)
           value
-      }
-    }
-    override def write[T](value: T)(using writer: JsonWriter[T]): Unit = {
+    override def write[T](value: T)(using writer: JsonWriter[T]): Unit =
       /*
        * This may be inefficient if multiple threads are concurrently modifying the file.
        * There is an assumption that there will be little to no concurrency at the file level
@@ -79,7 +70,7 @@ private[sbt] object InMemoryCacheStore {
        * complicated.
        */
       val lastModified = IO.getModifiedTimeOrZero(path.toFile)
-      store.get[T](path) match {
+      store.get[T](path) match
         case Some((v, `lastModified`)) if v == value => // nothing has changed
         case _                                       =>
           store.remove(path)
@@ -87,20 +78,17 @@ private[sbt] object InMemoryCacheStore {
           val newLastModified = System.currentTimeMillis
           IO.setModifiedTimeOrFalse(path.toFile, newLastModified)
           store.put(path, value, newLastModified)
-      }
-    }
-    override def close(): Unit = {
+    override def close(): Unit =
       store.remove(path)
       cacheStore.close()
-    }
-  }
+  end CacheStoreImpl
 
   private def factory(
       store: InMemoryCacheStore,
       path: Path
-  ): CacheStoreFactory = {
+  ): CacheStoreFactory =
     val delegate = new DirectoryStoreFactory(path.toFile)
-    new CacheStoreFactory {
+    new CacheStoreFactory:
       override def make(identifier: String): CacheStore =
         new CacheStoreImpl(path.resolve(identifier), store, delegate.make(identifier))
       // Without this the inherited default calls `make`, wrapping an uncompressed delegate.
@@ -108,40 +96,32 @@ private[sbt] object InMemoryCacheStore {
         new CacheStoreImpl(path.resolve(identifier), store, delegate.makeCompressed(identifier))
       override def sub(identifier: String): CacheStoreFactory =
         factory(store, path.resolve(identifier))
-    }
-  }
-  private[sbt] trait CacheStoreFactoryFactory extends AutoCloseable {
+  private[sbt] trait CacheStoreFactoryFactory extends AutoCloseable:
     def apply(path: Path): CacheStoreFactory
-  }
-  private class CacheStoreFactoryFactoryImpl(size: Long) extends CacheStoreFactoryFactory {
+  private class CacheStoreFactoryFactoryImpl(size: Long) extends CacheStoreFactoryFactory:
     private val storeRef = new AtomicReference[InMemoryCacheStore]
     override def close(): Unit = Option(storeRef.get).foreach(_.close())
     def apply(
         path: Path,
-    ): CacheStoreFactory = {
-      val store = storeRef.get match {
+    ): CacheStoreFactory =
+      val store = storeRef.get match
         case null =>
           storeRef.synchronized {
-            storeRef.get match {
+            storeRef.get match
               case null =>
                 val s = new InMemoryCacheStore(size)
                 storeRef.set(s)
                 s
               case s => s
-            }
           }
         case s => s
-      }
       factory(store, path)
-    }
-  }
-  private object DirectoryFactory extends CacheStoreFactoryFactory {
+  private object DirectoryFactory extends CacheStoreFactoryFactory:
     override def apply(
         path: Path,
     ): CacheStoreFactory = new DirectoryStoreFactory(path.toFile)
     override def close(): Unit = {}
-  }
   def factory(size: Long): CacheStoreFactoryFactory =
-    if (size > 0) new CacheStoreFactoryFactoryImpl(size)
+    if size > 0 then new CacheStoreFactoryFactoryImpl(size)
     else DirectoryFactory
-}
+end InMemoryCacheStore
diff --git a/main/src/main/scala/sbt/internal/IncrementalTest.scala b/main/src/main/scala/sbt/internal/IncrementalTest.scala
index 1aeb9035a..abd700dc5 100644
--- a/main/src/main/scala/sbt/internal/IncrementalTest.scala
+++ b/main/src/main/scala/sbt/internal/IncrementalTest.scala
@@ -322,6 +322,7 @@ class ClassStamper private[sbt] (
       else ()
 
       builder |= newBuilder
+    end internalStamp0
 
     if alreadySeen.contains(javaClassName) then ()
     else
@@ -332,4 +333,5 @@ class ClassStamper private[sbt] (
           // Note: internalClassDeps uses Scala-encoded class name for companion objects
           val classNames = relations.productClassName.reverse(javaClassName)
           classNames.foreach(internalStamp0)
+  end internalStamp
 end ClassStamper
diff --git a/main/src/main/scala/sbt/internal/Inspect.scala b/main/src/main/scala/sbt/internal/Inspect.scala
index c1a485d1b..5f988541c 100644
--- a/main/src/main/scala/sbt/internal/Inspect.scala
+++ b/main/src/main/scala/sbt/internal/Inspect.scala
@@ -19,12 +19,15 @@ import java.io.File
 import Scope.Global
 import sbt.ProjectExtra.*
 
-object Inspect {
+object Inspect:
   sealed trait Mode
   final case class Details(actual: Boolean) extends Mode
-  private[sbt] case object DependencyTreeMode extends Mode { override def toString = "tree" }
-  private[sbt] case object UsesMode extends Mode { override def toString = "inspect" }
-  private[sbt] case object DefinitionsMode extends Mode { override def toString = "definitions" }
+  private[sbt] case object DependencyTreeMode extends Mode:
+    override def toString = "tree"
+  private[sbt] case object UsesMode extends Mode:
+    override def toString = "inspect"
+  private[sbt] case object DefinitionsMode extends Mode:
+    override def toString = "definitions"
   val DependencyTree: Mode = DependencyTreeMode
   val Uses: Mode = UsesMode
   val Definitions: Mode = DefinitionsMode
@@ -34,20 +37,18 @@ object Inspect {
       spacedModeParser(s) flatMap { mode =>
         commandHandler(s, mode) | keyHandler(s)(mode)
       }
-  val spacedModeParser: State => Parser[Mode] = (_: State) => {
+  val spacedModeParser: State => Parser[Mode] = (_: State) =>
     val default = "-" ^^^ Details(false)
     val actual = "actual" ^^^ Details(true)
     val tree = "tree" ^^^ DependencyTree
     val uses = "uses" ^^^ Uses
     val definitions = "definitions" ^^^ Definitions
     token(Space ~> (default | tree | actual | uses | definitions)) ?? Details(false)
-  }
 
-  def allKeyParser(s: State): Parser[AttributeKey[?]] = {
+  def allKeyParser(s: State): Parser[AttributeKey[?]] =
     val keyMap = Project.structure(s).index.keyMap
     token(Space ~> ((ID !!! "Expected key").examples(keyMap.keySet))).flatMap: key =>
       Act.getKey(keyMap, key, idFun)
-  }
   val spacedKeyParser: State => Parser[ScopedKey[?]] = (s: State) =>
     Act.requireSession(s, token(Space) ~> Act.scopedKeyParser(s))
 
@@ -58,9 +59,9 @@ object Inspect {
       spacedKeyParser(s).map(key => () => keyOutput(s, opt, key))
   }
 
-  def commandHandler(s: State, mode: Mode): Parser[() => String] = {
+  def commandHandler(s: State, mode: Mode): Parser[() => String] =
     Space ~> commandParser(s).flatMap { (name, cmd) =>
-      cmd.tags.get(BasicCommands.CommandAliasKey) match {
+      cmd.tags.get(BasicCommands.CommandAliasKey) match
         case Some((_, aliasFor)) =>
           def header = s"Alias for: $aliasFor"
           Parser
@@ -73,20 +74,17 @@ object Inspect {
             )
         case None =>
           success(() => s"Command: $name")
-      }
     }
-  }
 
-  def commandParser: State => Parser[(String, Command)] = { s =>
+  def commandParser: State => Parser[(String, Command)] = s =>
     oneOf(s.definedCommands.map(cmd => cmd -> cmd.nameOption) collect { case (cmd, Some(name)) =>
       DefaultParsers.literal(name).map(_ -> cmd)
     })
-  }
 
-  def keyOutput(s: State, option: Mode, sk: Def.ScopedKey[?]): String = {
+  def keyOutput(s: State, option: Mode, sk: Def.ScopedKey[?]): String =
     val extracted = Project.extract(s)
     import extracted.{ *, given }
-    option match {
+    option match
       case Details(actual)    => Project.details(extracted.structure, actual, sk)
       case DependencyTreeMode =>
         val basedir = new File(Project.session(s).current.build)
@@ -97,7 +95,4 @@ object Inspect {
         Project.showUses(Project.usedBy(extracted.structure, true, sk.key))
       case DefinitionsMode =>
         Project.showDefinitions(sk.key, Project.definitions(extracted.structure, true, sk.key))
-    }
-  }
-
-}
+end Inspect
diff --git a/main/src/main/scala/sbt/internal/InstallSbtn.scala b/main/src/main/scala/sbt/internal/InstallSbtn.scala
index 7f8a6737f..09e8989eb 100644
--- a/main/src/main/scala/sbt/internal/InstallSbtn.scala
+++ b/main/src/main/scala/sbt/internal/InstallSbtn.scala
@@ -22,7 +22,7 @@ import sbt.io.Path.userHome
 import sbt.io.syntax.*
 import scala.util.{ Properties, Try }
 
-private[sbt] object InstallSbtn {
+private[sbt] object InstallSbtn:
   private[sbt] val installSbtn =
     Def.inputKey[Unit]("install sbtn and tab completions").withRank(KeyRanks.BTask)
   private[sbt] def installSbtnImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
@@ -32,88 +32,79 @@ private[sbt] object InstallSbtn {
     term.setMode(canonical = false, echo = false)
     val baseDirectory = BuildPaths.getGlobalBase(state.value).toPath
     val tmp = Files.createTempFile(s"sbt-$version", "zip")
-    val sbtn = if (Properties.isWin) "sbtn.exe" else "sbtn"
+    val sbtn = if Properties.isWin then "sbtn.exe" else "sbtn"
     try extractSbtn(term, version, tmp, baseDirectory.resolve("bin").resolve(sbtn))
-    finally {
+    finally
       Files.deleteIfExists(tmp)
       ()
-    }
-    val shell = if (hasConsole) getShell(term) else "none"
-    shell match {
+    val shell = if hasConsole then getShell(term) else "none"
+    shell match
       case "none" =>
       case s      =>
         val completion = shellCompletions(s)
         val completionLocation = baseDirectory.resolve("completions").resolve(completion)
         downloadCompletion(completion, version, completionLocation)
-        s match {
+        s match
           case "bash"       => setupBash(baseDirectory, term)
           case "fish"       => setupFish(baseDirectory, term)
           case "zsh"        => setupZsh(baseDirectory, term)
           case "powershell" => setupPowershell(baseDirectory, term)
           case _            => // should be unreachable
-        }
         val msg = s"Successfully installed sbtn for $s. You may need to restart $s for the " +
           "changes to take effect."
         term.printStream.println(msg)
-    }
     ()
   }
 
-  private[sbt] def extractSbtn(term: Terminal, version: String, sbtZip: Path, sbtn: Path): Unit = {
+  private[sbt] def extractSbtn(term: Terminal, version: String, sbtZip: Path, sbtn: Path): Unit =
     downloadRelease(term, version, sbtZip)
     IO.createDirectory(sbtn.getParent().toFile())
     val bin =
-      if (Properties.isWin) "pc-win32.exe"
-      else if (Properties.isLinux) "pc-linux"
+      if Properties.isWin then "pc-win32.exe"
+      else if Properties.isLinux then "pc-linux"
       else "apple-darwin"
-    val isArmArchitecture: Boolean = {
+    val isArmArchitecture: Boolean =
       val prop = sys.props
         .getOrElse("os.arch", "")
         .toLowerCase(java.util.Locale.ROOT)
       prop == "arm64" || prop == "aarch64"
-    }
     val arch =
-      if (Properties.isWin) "x86_64"
-      else if (Properties.isLinux && isArmArchitecture) "aarch64"
+      if Properties.isWin then "x86_64"
+      else if Properties.isLinux && isArmArchitecture then "aarch64"
       else "universal"
     val sbtnName = s"sbt/bin/sbtn-$arch-$bin"
     val fis = new FileInputStream(sbtZip.toFile)
     val zipInputStream = new ZipInputStream(fis)
     var foundBinary = false
-    try {
+    try
       var entry = zipInputStream.getNextEntry
-      while (entry != null) {
-        if (entry.getName == sbtnName) {
+      while entry != null do
+        if entry.getName == sbtnName then
           foundBinary = true
           term.printStream.println(s"extracting $sbtZip!$sbtnName to $sbtn")
           transfer(zipInputStream, sbtn)
           sbtn.toFile.setExecutable(true)
           entry = null
-        } else {
-          entry = zipInputStream.getNextEntry
-        }
-      }
-      if (!foundBinary) throw new IllegalStateException(s"couldn't find $sbtnName in $sbtZip")
-    } finally {
+        else entry = zipInputStream.getNextEntry
+      if !foundBinary then throw new IllegalStateException(s"couldn't find $sbtnName in $sbtZip")
+    finally
       fis.close()
       zipInputStream.close()
-    }
     ()
-  }
-  private def downloadRelease(term: Terminal, version: String, location: Path): Unit = {
+  end extractSbtn
+  private def downloadRelease(term: Terminal, version: String, location: Path): Unit =
     val zip = s"https://github.com/sbt/sbt/releases/download/v$version/sbt-$version.zip"
     val url = new URI(zip).toURL
     term.printStream.println(s"downloading $zip to $location")
     transfer(url.openStream(), location)
-  }
   private def transfer(inputStream: InputStream, path: Path): Unit =
-    try {
+    try
       val os = new FileOutputStream(path.toFile)
-      try {
+      try
         inputStream.transferTo(os)
-      } finally os.close()
-    } finally inputStream.close()
-  private def getShell(term: Terminal): String = {
+      finally os.close()
+    finally inputStream.close()
+  private def getShell(term: Terminal): String =
     term.printStream.print(s"""Setup sbtn for shell:
       | [1] bash
       | [2] fish
@@ -124,19 +115,16 @@ private[sbt] object InstallSbtn {
     term.printStream.flush()
     val key = term.inputStream.read
     term.printStream.println(key.toChar)
-    key match {
+    key match
       case 49 => "bash"
       case 50 => "fish"
       case 51 => "powershell"
       case 52 => "zsh"
       case _  => "none"
-    }
-  }
-  private def downloadCompletion(completion: String, version: String, target: Path): Unit = {
+  private def downloadCompletion(completion: String, version: String, target: Path): Unit =
     IO.createDirectory(target.getParent().toFile())
     val comp = s"https://raw.githubusercontent.com/sbt/sbt/v$version/client/completions/$completion"
     transfer(new URI(comp).toURL.openStream, target)
-  }
   private def setupShell(
       shell: String,
       baseDirectory: Path,
@@ -144,37 +132,35 @@ private[sbt] object InstallSbtn {
       configFile: File,
       setPath: Path => String,
       setCompletions: Path => String,
-  ): Unit = {
+  ): Unit =
     val bin = baseDirectory.resolve("bin")
     val exp = setPath(bin)
     val completions = baseDirectory.resolve("completions")
     val sourceCompletions = setCompletions(completions)
     val contents =
       try IO.read(configFile)
-      catch { case _: IOException => "" }
-    if (!contents.contains(exp)) {
+      catch case _: IOException => ""
+    if !contents.contains(exp) then
       term.printStream.print(s"Add $bin to PATH in $configFile? y/n (y default): ")
       term.printStream.flush()
-      term.inputStream.read() match {
+      term.inputStream.read() match
         case 110 => term.printStream.println()
         case c   =>
           term.printStream.println(c.toChar)
           // put the export at the bottom so that the ~/.sbt/1.0/bin/sbtn is least preferred
           // but still on the path
           IO.write(configFile, s"$contents\n$exp")
-      }
-    }
     val newContents =
       try IO.read(configFile)
-      catch { case _: IOException => "" }
-    if (!newContents.contains(sourceCompletions)) {
+      catch case _: IOException => ""
+    if !newContents.contains(sourceCompletions) then
       term.printStream.print(s"Add tab completions to $configFile? y/n (y default): ")
       term.printStream.flush()
-      term.inputStream.read() match {
+      term.inputStream.read() match
         case 110 =>
         case c   =>
           term.printStream.println(c.toChar)
-          if (shell == "zsh") {
+          if shell == "zsh" then
             // delete the .zcompdump file because it can prevent the new completions from
             // being recognized
             Files.deleteIfExists((userHome / ".zcompdump").toPath)
@@ -182,13 +168,9 @@ private[sbt] object InstallSbtn {
             // so the order in the file doesn't really matter but we want to make sure
             // that we set fpath before any autoload command in zsh
             IO.write(configFile, s"$sourceCompletions\n$newContents")
-          } else {
-            IO.write(configFile, s"$newContents\n$sourceCompletions")
-          }
-      }
+          else IO.write(configFile, s"$newContents\n$sourceCompletions")
       term.printStream.println()
-    }
-  }
+  end setupShell
   private def setupBash(baseDirectory: Path, term: Terminal): Unit =
     setupShell(
       "bash",
@@ -198,20 +180,17 @@ private[sbt] object InstallSbtn {
       bin => s"export PATH=$$PATH:$bin",
       completions => s"source $completions/sbtn.bash"
     )
-  private def setupZsh(baseDirectory: Path, term: Terminal): Unit = {
-    val comp = (completions: Path) => {
+  private def setupZsh(baseDirectory: Path, term: Terminal): Unit =
+    val comp = (completions: Path) =>
       "# The following two lines were added by the sbt installSbtn task:\n" +
         s"fpath=($$fpath $completions)\nautoload -Uz compinit; compinit"
-    }
     setupShell("zsh", baseDirectory, term, userHome / ".zshrc", bin => s"path=($$path $bin)", comp)
-  }
-  private def setupFish(baseDirectory: Path, term: Terminal): Unit = {
+  private def setupFish(baseDirectory: Path, term: Terminal): Unit =
     val comp = (completions: Path) => s"source $completions/sbtn.fish"
     val path = (bin: Path) => s"set PATH $$PATH $bin"
     val config = userHome / ".config" / "fish" / "config.fish"
     setupShell("fish", baseDirectory, term, config, path, comp)
-  }
-  private def setupPowershell(baseDirectory: Path, term: Terminal): Unit = {
+  private def setupPowershell(baseDirectory: Path, term: Terminal): Unit =
     val comp = (completions: Path) => s""". "$completions\\sbtn.ps1""""
     val path = (bin: Path) => s"""$$env:Path += ";$bin""""
     import scala.sys.process.*
@@ -225,11 +204,10 @@ private[sbt] object InstallSbtn {
         setupShell("pwsh", baseDirectory, term, new File(l), path, comp)
       }
     }
-  }
   private val shellCompletions = Map(
     "bash" -> "sbtn.bash",
     "fish" -> "sbtn.fish",
     "powershell" -> "sbtn.ps1",
     "zsh" -> "_sbtn",
   )
-}
+end InstallSbtn
diff --git a/main/src/main/scala/sbt/internal/InternalDependencies.scala b/main/src/main/scala/sbt/internal/InternalDependencies.scala
index ecc2065bd..7b260b2c6 100644
--- a/main/src/main/scala/sbt/internal/InternalDependencies.scala
+++ b/main/src/main/scala/sbt/internal/InternalDependencies.scala
@@ -11,7 +11,7 @@ package internal
 
 import sbt.Keys.*
 
-private[sbt] object InternalDependencies {
+private[sbt] object InternalDependencies:
   def configurations: Def.Initialize[Seq[(ProjectRef, Set[String])]] = Def.setting {
     val configMap = internalConfigurationMap.value
     val config = configMap(configuration.value)
@@ -22,15 +22,14 @@ private[sbt] object InternalDependencies {
     ((ref -> allConfigs) +:
       projectDependencies.flatMap { case ClasspathDep.ResolvedClasspathDependency(p, rawConfigs) =>
         val configs = rawConfigs.getOrElse("*->compile").split(";").flatMap { config =>
-          config.split("->", 2).map(_.trim) match {
+          config.split("->", 2).map(_.trim) match
             case Array(n, c) if c.nonEmpty && applicableConfigs.contains(n) => Some(c)
             case Array(n) if applicableConfigs.contains(n)                  =>
               // "test" is equivalent to "compile->test"
               Some("compile")
             case _ => None
-          }
         }
-        if (configs.isEmpty) None else Some(p -> configs.toSet)
+        if configs.isEmpty then None else Some(p -> configs.toSet)
       }).distinct
   }
-}
+end InternalDependencies
diff --git a/main/src/main/scala/sbt/internal/IvyConsole.scala b/main/src/main/scala/sbt/internal/IvyConsole.scala
index 9cb9a500e..d5b48f59d 100644
--- a/main/src/main/scala/sbt/internal/IvyConsole.scala
+++ b/main/src/main/scala/sbt/internal/IvyConsole.scala
@@ -31,7 +31,7 @@ import sbt.SlashSyntax0.*
 import sbt.io.IO
 import xsbti.HashedVirtualFileRef
 
-object IvyConsole {
+object IvyConsole:
   final val Name = "ivy-console"
   lazy val command =
     Command.command(Name) { state =>
@@ -80,23 +80,20 @@ object IvyConsole {
   def parseDependencies(args: Seq[String], log: Logger): Dependencies =
     args.foldLeft(Dependencies(Nil, Nil, Nil))(parseArgument(log))
   def parseArgument(log: Logger)(acc: Dependencies, arg: String): Dependencies =
-    arg match {
+    arg match
       case _ if arg.contains(" at ") => acc.copy(resolvers = parseResolver(arg) +: acc.resolvers)
       case _ if arg.endsWith(".jar") => acc.copy(unmanaged = new File(arg) +: acc.unmanaged)
       case _                         => acc.copy(managed = parseManaged(arg, log) ++ acc.managed)
-    }
 
-  private def parseResolver(arg: String): MavenRepository = {
+  private def parseResolver(arg: String): MavenRepository =
     val Array(name, url) = arg.split(" at ")
     MavenRepository(name.trim, url.trim)
-  }
 
   val DepPattern = """([^%]+)%(%?)([^%]+)%([^%]+)""".r
   def parseManaged(arg: String, log: Logger): Seq[ModuleID] =
-    arg match {
+    arg match
       case DepPattern(group, cross, name, version) =>
-        val crossV = if (cross.trim.isEmpty) Disabled() else CrossVersion.binary
+        val crossV = if cross.trim.isEmpty then Disabled() else CrossVersion.binary
         ModuleID(group.trim, name.trim, version.trim).withCrossVersion(crossV) :: Nil
       case _ => log.warn("Ignoring invalid argument '" + arg + "'"); Nil
-    }
-}
+end IvyConsole
diff --git a/main/src/main/scala/sbt/internal/JarClassPath.scala b/main/src/main/scala/sbt/internal/JarClassPath.scala
index 6888c1cb1..af69df4d1 100644
--- a/main/src/main/scala/sbt/internal/JarClassPath.scala
+++ b/main/src/main/scala/sbt/internal/JarClassPath.scala
@@ -12,32 +12,28 @@ import java.io.File
 
 import sbt.io.IO
 
-private[internal] object JarClassPath {
+private[internal] object JarClassPath:
   class Snapshot private[internal] (val file: File, val lastModified: Long)
-      extends Comparable[JarClassPath.Snapshot] {
+      extends Comparable[JarClassPath.Snapshot]:
     private val _hash = (file.hashCode * 31) ^ java.lang.Long.valueOf(lastModified).hashCode()
     def this(file: File) = this(file, IO.getModifiedTimeOrZero(file))
-    override def equals(obj: Any): Boolean = obj match {
+    override def equals(obj: Any): Boolean = obj match
       case that: JarClassPath.Snapshot =>
         this.lastModified == that.lastModified && this.file == that.file
       case _ => false
-    }
     override def hashCode: Int = _hash
     override def compareTo(that: JarClassPath.Snapshot): Int = this.file.compareTo(that.file)
     override def toString: String =
       "Snapshot(path = " + file + ", lastModified = " + lastModified + ")"
-  }
-}
-private[internal] final class JarClassPath(val jars: Seq[File]) {
+private[internal] final class JarClassPath(val jars: Seq[File]):
   private def isSnapshot(file: File): Boolean = file.getName.contains("-SNAPSHOT")
   private val jarSet = jars.toSet
   val (snapshotJars, regularJars) = jars.partition(isSnapshot)
   private val snapshots = snapshotJars.map(new JarClassPath.Snapshot(_))
 
-  override def equals(obj: Any): Boolean = obj match {
+  override def equals(obj: Any): Boolean = obj match
     case that: JarClassPath => this.jarSet == that.jarSet
     case _                  => false
-  }
   // The memoization is because codacy isn't smart enough to identify that
   // `override lazy val hashCode: Int = jarSet.hashCode` does actually override hashCode and it
   // complains that equals and hashCode were not implemented together.
@@ -50,7 +46,6 @@ private[internal] final class JarClassPath(val jars: Seq[File]) {
   /*
    * This is a stricter equality requirement than equals that we can use for cache invalidation.
    */
-  private[internal] def strictEquals(that: JarClassPath): Boolean = {
+  private[internal] def strictEquals(that: JarClassPath): Boolean =
     this.equals(that) && !this.snapshots.view.zip(that.snapshots).exists { (l, r) => l != r }
-  }
-}
+end JarClassPath
diff --git a/main/src/main/scala/sbt/internal/KeyIndex.scala b/main/src/main/scala/sbt/internal/KeyIndex.scala
index 1af73f4af..89f694568 100644
--- a/main/src/main/scala/sbt/internal/KeyIndex.scala
+++ b/main/src/main/scala/sbt/internal/KeyIndex.scala
@@ -16,17 +16,16 @@ import sbt.internal.util.Types.some
 import sbt.internal.util.{ AttributeKey, Relation }
 import sbt.librarymanagement.Configuration
 
-object KeyIndex {
+object KeyIndex:
   def empty: ExtendableKeyIndex = new KeyIndex0(emptyBuildIndex)
 
   def apply(
       known: Iterable[ScopedKey[?]],
       projects: Map[URI, Set[String]],
       configurations: Map[String, Seq[Configuration]]
-  ): ExtendableKeyIndex = {
+  ): ExtendableKeyIndex =
     import scala.collection.parallel.CollectionConverters.*
     known.par.foldLeft(base(projects, configurations)) { _.add(_) }
-  }
 
   def aggregate(
       known: Set[ScopedKey[?]],
@@ -41,42 +40,38 @@ object KeyIndex {
   private def base(
       projects: Map[URI, Set[String]],
       configurations: Map[String, Seq[Configuration]]
-  ): ExtendableKeyIndex = {
-    val data = for {
-      (uri, ids) <- projects
-    } yield {
-      val data = ids map { id =>
-        val configs = configurations.getOrElse(id, Seq())
-        val configIdentToName = configs.map(config => config.id -> config.name).toMap
-        val configNameToIdent = configs.map(config => config.name -> config.id).toMap
-        Option(id) -> new ConfigIndex(
-          Map.empty,
-          configIdentToName,
-          configNameToIdent,
-          emptyAKeyIndex
-        )
-      }
-      Option(uri) -> new ProjectIndex(data.toMap)
-    }
+  ): ExtendableKeyIndex =
+    val data =
+      for (uri, ids) <- projects
+      yield
+        val data = ids map { id =>
+          val configs = configurations.getOrElse(id, Seq())
+          val configIdentToName = configs.map(config => config.id -> config.name).toMap
+          val configNameToIdent = configs.map(config => config.name -> config.id).toMap
+          Option(id) -> new ConfigIndex(
+            Map.empty,
+            configIdentToName,
+            configNameToIdent,
+            emptyAKeyIndex
+          )
+        }
+        Option(uri) -> new ProjectIndex(data.toMap)
     new KeyIndex0(new BuildIndex(data))
-  }
 
-  def combine(indices: Seq[KeyIndex]): KeyIndex = new KeyIndex {
+  def combine(indices: Seq[KeyIndex]): KeyIndex = new KeyIndex:
     def buildURIs = concat(_.buildURIs)
     def projects(uri: URI) = concat(_.projects(uri))
     def exists(project: Option[ResolvedReference]): Boolean = indices.exists(_.exists(project))
     def configs(proj: Option[ResolvedReference]) = concat(_.configs(proj))
     private[sbt] def configIdents(proj: Option[ResolvedReference]) = concat(_.configIdents(proj))
     private[sbt] def fromConfigIdent(proj: Option[ResolvedReference])(configIdent: String): String =
-      indices.find(idx => idx.exists(proj)) match {
+      indices.find(idx => idx.exists(proj)) match
         case Some(idx) => idx.fromConfigIdent(proj)(configIdent)
         case _         => Scope.unguessConfigIdent(configIdent)
-      }
     private[sbt] def toConfigIdent(proj: Option[ResolvedReference])(configName: String): String =
-      indices.find(idx => idx.exists(proj)) match {
+      indices.find(idx => idx.exists(proj)) match
         case Some(idx) => idx.toConfigIdent(proj)(configName)
         case _         => Scope.guessConfigIdent(configName)
-      }
     def tasks(proj: Option[ResolvedReference], conf: Option[String]) = concat(_.tasks(proj, conf))
     def tasks(proj: Option[ResolvedReference], conf: Option[String], key: String) =
       concat(_.tasks(proj, conf, key))
@@ -86,7 +81,6 @@ object KeyIndex {
       concat(_.keys(proj, conf, task))
     def concat[T](f: KeyIndex => Set[T]): Set[T] =
       indices.foldLeft(Set.empty[T])((s, k) => s ++ f(k))
-  }
   private[sbt] def getOr[A, B](m: Map[A, B], key: A, or: B): B = m.getOrElse(key, or)
   private[sbt] def keySet[A, B](m: Map[Option[A], B]): Set[A] = m.keys.flatten.toSet
   private[sbt] val emptyAKeyIndex = new AKeyIndex(Relation.empty)
@@ -94,11 +88,11 @@ object KeyIndex {
     new ConfigIndex(Map.empty, Map.empty, Map.empty, emptyAKeyIndex)
   private[sbt] val emptyProjectIndex = new ProjectIndex(Map.empty)
   private[sbt] val emptyBuildIndex = new BuildIndex(Map.empty)
+end KeyIndex
 
-}
 import KeyIndex.*
 
-trait KeyIndex {
+trait KeyIndex:
   // TODO, optimize
   def isEmpty(proj: Option[ResolvedReference], conf: Option[String]): Boolean =
     keys(proj, conf).isEmpty
@@ -128,20 +122,18 @@ trait KeyIndex {
   private[sbt] def configIdents(project: Option[ResolvedReference]): Set[String]
   private[sbt] def fromConfigIdent(proj: Option[ResolvedReference])(configIdent: String): String
   private[sbt] def toConfigIdent(proj: Option[ResolvedReference])(configName: String): String
-}
-trait ExtendableKeyIndex extends KeyIndex {
+end KeyIndex
+trait ExtendableKeyIndex extends KeyIndex:
   def add(scoped: ScopedKey[?]): ExtendableKeyIndex
   def addAggregated(scoped: ScopedKey[?], extra: BuildUtil[?]): ExtendableKeyIndex
-}
 // task axis <-> key
-private[sbt] final class AKeyIndex(val data: Relation[Option[AttributeKey[?]], String]) {
+private[sbt] final class AKeyIndex(val data: Relation[Option[AttributeKey[?]], String]):
   def add(task: Option[AttributeKey[?]], key: AttributeKey[?]): AKeyIndex =
     new AKeyIndex(data + (task, key.label))
   def keys(task: Option[AttributeKey[?]]): Set[String] = data.forward(task)
   def allKeys: Set[String] = data._2s
   def tasks: Set[AttributeKey[?]] = data._1s.flatten
   def tasks(key: String): Set[AttributeKey[?]] = data.reverse(key).flatten
-}
 
 private[sbt] case class IdentifiableConfig(name: String, ident: Option[String])
 
@@ -156,17 +148,15 @@ private[sbt] final class ConfigIndex(
     val configIdentToName: Map[String, String],
     val configNameToIdent: Map[String, String],
     val noConfigKeys: AKeyIndex
-) {
+):
   def add(
       config: Option[IdentifiableConfig],
       task: Option[AttributeKey[?]],
       key: AttributeKey[?]
-  ): ConfigIndex = {
-    config match {
+  ): ConfigIndex =
+    config match
       case Some(c) => addKeyWithConfig(c, task, key)
       case None    => addKeyWithoutConfig(task, key)
-    }
-  }
 
   def addKeyWithConfig(
       config: IdentifiableConfig,
@@ -186,14 +176,12 @@ private[sbt] final class ConfigIndex(
       noConfigKeys
     )
 
-  def addKeyWithoutConfig(task: Option[AttributeKey[?]], key: AttributeKey[?]): ConfigIndex = {
+  def addKeyWithoutConfig(task: Option[AttributeKey[?]], key: AttributeKey[?]): ConfigIndex =
     new ConfigIndex(data, configIdentToName, configNameToIdent, noConfigKeys.add(task, key))
-  }
 
-  def keyIndex(conf: Option[String]): AKeyIndex = conf match {
+  def keyIndex(conf: Option[String]): AKeyIndex = conf match
     case Some(c) => data.get(c).getOrElse(emptyAKeyIndex)
     case None    => noConfigKeys
-  }
 
   def configs: Set[String] = data.keySet
   private[sbt] lazy val idents: Set[String] = configIdentToName.keySet
@@ -207,10 +195,10 @@ private[sbt] final class ConfigIndex(
   // Falls back to guessing if the identifier is not in the index.
   private[sbt] def fromConfigIdent(ident: String): String =
     configIdentToName.getOrElse(ident, Scope.unguessConfigIdent(ident))
-}
+end ConfigIndex
 private[sbt] object ConfigIndex
 
-private[sbt] final class ProjectIndex(val data: Map[Option[String], ConfigIndex]) {
+private[sbt] final class ProjectIndex(val data: Map[Option[String], ConfigIndex]):
   def add(
       id: Option[String],
       config: Option[IdentifiableConfig],
@@ -220,8 +208,7 @@ private[sbt] final class ProjectIndex(val data: Map[Option[String], ConfigIndex]
     new ProjectIndex(data updated (id, confIndex(id).add(config, task, key)))
   def confIndex(id: Option[String]): ConfigIndex = getOr(data, id, emptyConfigIndex)
   def projects: Set[String] = keySet(data)
-}
-private[sbt] final class BuildIndex(val data: Map[Option[URI], ProjectIndex]) {
+private[sbt] final class BuildIndex(val data: Map[Option[URI], ProjectIndex]):
   def add(
       build: Option[URI],
       project: Option[String],
@@ -232,14 +219,12 @@ private[sbt] final class BuildIndex(val data: Map[Option[URI], ProjectIndex]) {
     new BuildIndex(data updated (build, projectIndex(build).add(project, config, task, key)))
   def projectIndex(build: Option[URI]): ProjectIndex = getOr(data, build, emptyProjectIndex)
   def builds: Set[URI] = keySet(data)
-}
-private[sbt] final class KeyIndex0(val data: BuildIndex) extends ExtendableKeyIndex {
+private[sbt] final class KeyIndex0(val data: BuildIndex) extends ExtendableKeyIndex:
   def buildURIs: Set[URI] = data.builds
   def projects(uri: URI): Set[String] = data.projectIndex(Some(uri)).projects
-  def exists(proj: Option[ResolvedReference]): Boolean = {
+  def exists(proj: Option[ResolvedReference]): Boolean =
     val (build, project) = parts(proj)
     data.data.get(build).flatMap(_.data.get(project)).isDefined
-  }
   def configs(project: Option[ResolvedReference]): Set[String] = confIndex(project).configs
 
   private[sbt] def configIdents(project: Option[ResolvedReference]): Set[String] =
@@ -272,39 +257,35 @@ private[sbt] final class KeyIndex0(val data: BuildIndex) extends ExtendableKeyIn
 
   def keyIndex(proj: Option[ResolvedReference], conf: Option[String]): AKeyIndex =
     confIndex(proj).keyIndex(conf)
-  def confIndex(proj: Option[ResolvedReference]): ConfigIndex = {
+  def confIndex(proj: Option[ResolvedReference]): ConfigIndex =
     val (build, project) = parts(proj)
     data.projectIndex(build).confIndex(project)
-  }
   def parts(proj: Option[Reference]): (Option[URI], Option[String]) =
-    proj match {
+    proj match
       case Some(ProjectRef(uri, id)) => (Some(uri), Some(id))
       case Some(BuildRef(uri))       => (Some(uri), None)
       case _                         => (None, None)
-    }
   private def optConfigs(project: Option[ResolvedReference]): Seq[Option[String]] =
     None +: (configs(project).toSeq.map(some[String]))
 
   def addAggregated(scoped: ScopedKey[?], extra: BuildUtil[?]): ExtendableKeyIndex =
-    if (validID(scoped.key.label)) {
+    if validID(scoped.key.label) then
       val aggregateProjects = Aggregation.reverseAggregate(Set(scoped), extra)
       aggregateProjects.foldLeft(this: ExtendableKeyIndex)(_.add(_))
-    } else this
+    else this
 
   def add(scoped: ScopedKey[?]): ExtendableKeyIndex =
-    if (validID(scoped.key.label)) add0(scoped) else this
-  private def add0(scoped: ScopedKey[?]): ExtendableKeyIndex = {
+    if validID(scoped.key.label) then add0(scoped) else this
+  private def add0(scoped: ScopedKey[?]): ExtendableKeyIndex =
     val (build, project) = parts(scoped.scope.project.toOption)
     add1(build, project, scoped.scope.config, scoped.scope.task, scoped.key)
-  }
   private def add1(
       uri: Option[URI],
       id: Option[String],
       config: ScopeAxis[ConfigKey],
       task: ScopeAxis[AttributeKey[?]],
       key: AttributeKey[?]
-  ): ExtendableKeyIndex = {
+  ): ExtendableKeyIndex =
     val keyConfig = config.toOption.map(c => IdentifiableConfig(c.name, None))
     new KeyIndex0(data.add(uri, id, keyConfig, task.toOption, key))
-  }
-}
+end KeyIndex0
diff --git a/main/src/main/scala/sbt/internal/LayeredClassLoaders.scala b/main/src/main/scala/sbt/internal/LayeredClassLoaders.scala
index ee208090e..9db71016e 100644
--- a/main/src/main/scala/sbt/internal/LayeredClassLoaders.scala
+++ b/main/src/main/scala/sbt/internal/LayeredClassLoaders.scala
@@ -56,16 +56,14 @@ private[internal] final class ReverseLookupClassLoaderHolder(
    *
    * @return a ClassLoader
    */
-  def checkout(fullClasspath: Seq[File], tempDir: File): ClassLoader = {
-    if (closed.get()) {
+  def checkout(fullClasspath: Seq[File], tempDir: File): ClassLoader =
+    if closed.get() then
       val msg = "Tried to extract class loader from closed ReverseLookupClassLoaderHolder. " +
         "Try running the `clearCaches` command and re-trying."
       throw new IllegalStateException(msg)
-    }
-    val reverseLookupClassLoader = cached.getAndSet(null) match {
+    val reverseLookupClassLoader = cached.getAndSet(null) match
       case null => new ReverseLookupClassLoader(urls, parent, closeThis, allowZombies, logger)
       case c    => c
-    }
     reverseLookupClassLoader.setup(tempDir)
     new BottomClassLoader(
       ReverseLookupClassLoaderHolder.this,
@@ -76,27 +74,20 @@ private[internal] final class ReverseLookupClassLoaderHolder(
       allowZombies,
       logger
     )
-  }
 
-  private[sbt] def checkin(reverseLookupClassLoader: ReverseLookupClassLoader): Unit = {
-    if (reverseLookupClassLoader.isDirty) reverseLookupClassLoader.close()
-    else {
-      if (closed.get()) reverseLookupClassLoader.close()
-      else
-        cached.getAndSet(reverseLookupClassLoader) match {
-          case null => if (closed.get) reverseLookupClassLoader.close()
-          case c    => c.close()
-        }
-    }
-  }
+  private[sbt] def checkin(reverseLookupClassLoader: ReverseLookupClassLoader): Unit =
+    if reverseLookupClassLoader.isDirty then reverseLookupClassLoader.close()
+    else if closed.get() then reverseLookupClassLoader.close()
+    else
+      cached.getAndSet(reverseLookupClassLoader) match
+        case null => if closed.get then reverseLookupClassLoader.close()
+        case c    => c.close()
 
-  override def close(): Unit = {
+  override def close(): Unit =
     closed.set(true)
-    cached.get() match {
+    cached.get() match
       case null =>
       case c    => c.close()
-    }
-  }
 end ReverseLookupClassLoaderHolder
 
 /**
@@ -105,10 +96,9 @@ end ReverseLookupClassLoaderHolder
  * to be dynamically reset. The explicit mappings feature isn't used by sbt. The dynamic
  * temp directory use case is needed in some layered class loading scenarios.
  */
-private[internal] trait NativeLoader extends AutoCloseable {
+private[internal] trait NativeLoader extends AutoCloseable:
   private[internal] def setTempDir(file: File): Unit = {}
-}
-private[internal] class NativeLookup extends NativeLoader {
+private[internal] class NativeLookup extends NativeLoader:
   private val mapped = new ConcurrentHashMap[String, String]
   private val searchPaths =
     sys.props.get("java.library.path").map(IO.parseClasspath).getOrElse(Nil)
@@ -117,62 +107,52 @@ private[internal] class NativeLookup extends NativeLoader {
   override def close(): Unit = setTempDir(new File("/dev/null"))
 
   def findLibrary(name: String): String = synchronized {
-    mapped.get(name) match {
+    mapped.get(name) match
       case null =>
-        findLibrary0(name) match {
+        findLibrary0(name) match
           case null => null
           case n    =>
             mapped.put(name, n)
             NativeLibs.addNativeLib(n)
             n
-        }
       case n => n
-    }
   }
 
-  private[internal] override def setTempDir(file: File): Unit = {
+  private[internal] override def setTempDir(file: File): Unit =
     deleteNativeLibs()
     tempDir.set(file)
-  }
 
-  private def deleteNativeLibs(): Unit = {
+  private def deleteNativeLibs(): Unit =
     mapped.values().forEach(NativeLibs.delete)
     mapped.clear()
-  }
 
-  private def findLibrary0(name: String): String = {
+  private def findLibrary0(name: String): String =
     val mappedName = System.mapLibraryName(name)
     val search = searchPaths.to(LazyList).flatMap(relativeLibrary(mappedName))
     search.headOption.map(copy).orNull
-  }
 
-  private def relativeLibrary(mappedName: String)(base: File): Seq[File] = {
+  private def relativeLibrary(mappedName: String)(base: File): Seq[File] =
     val f = new File(base, mappedName)
-    if (f.isFile) f :: Nil else Nil
-  }
+    if f.isFile then f :: Nil else Nil
 
-  private def copy(f: File): String = {
+  private def copy(f: File): String =
     val target = new File(tempDir.get(), f.getName)
     IO.copyFile(f, target)
     target.getAbsolutePath
-  }
-}
+end NativeLookup
 
-private[internal] object NativeLibs {
+private[internal] object NativeLibs:
   private val nativeLibs = new java.util.HashSet[File].asScala
-  ShutdownHooks.add(() => {
+  ShutdownHooks.add(() =>
     nativeLibs.foreach(IO.delete)
     IO.deleteIfEmpty(nativeLibs.map(_.getParentFile).toSet)
     nativeLibs.clear()
-  })
-  def addNativeLib(lib: String): Unit = {
+  )
+  def addNativeLib(lib: String): Unit =
     nativeLibs.add(new File(lib))
     ()
-  }
-  def delete(lib: String): Unit = {
+  def delete(lib: String): Unit =
     val file = new File(lib)
     nativeLibs.remove(file)
     file.delete()
     ()
-  }
-}
diff --git a/main/src/main/scala/sbt/internal/LibraryManagement.scala b/main/src/main/scala/sbt/internal/LibraryManagement.scala
index 044b898c3..27889b340 100644
--- a/main/src/main/scala/sbt/internal/LibraryManagement.scala
+++ b/main/src/main/scala/sbt/internal/LibraryManagement.scala
@@ -23,7 +23,7 @@ import sbt.io.syntax.*
 import sbt.ProjectExtra.*
 import sjsonnew.JsonFormat
 
-private[sbt] object LibraryManagement {
+private[sbt] object LibraryManagement:
   given linter: sbt.dsl.LinterLevel.Ignore.type = sbt.dsl.LinterLevel.Ignore
 
   // The fourth element is transitive dependency stamps for cross-command cache invalidation
@@ -51,21 +51,20 @@ private[sbt] object LibraryManagement {
       includeCallers: Boolean,
       includeDetails: Boolean,
       log: Logger
-  ): UpdateReport = {
+  ): UpdateReport =
 
     /* Resolve the module settings from the inputs. */
-    def resolve: UpdateReport = {
+    def resolve: UpdateReport =
       import sbt.util.ShowLines.*
 
       log.debug(s"Updating $label...")
       val reportOrUnresolved: Either[UnresolvedWarning, UpdateReport] =
         lm.update(module, updateConfig, uwConfig, log)
-      val report = reportOrUnresolved match {
+      val report = reportOrUnresolved match
         case Right(report0)          => report0
         case Left(unresolvedWarning) =>
           unresolvedWarning.lines.foreach(log.warn(_))
           throw unresolvedWarning.resolveException
-      }
       log.debug(s"Done updating $label")
       val report1 = transform(report)
 
@@ -84,55 +83,50 @@ private[sbt] object LibraryManagement {
         "this can be overridden using libraryDependencySchemes or evictionErrorLevel"
       )
       val errorLines: Seq[String] =
-        (if (
-           evictionError.incompatibleEvictions.isEmpty
+        (if evictionError.incompatibleEvictions.isEmpty
            || evictionLevel != Level.Error
-         ) Nil
+         then Nil
          else evictionError.lines) ++
-          (if (
-             evictionError.assumedIncompatibleEvictions.isEmpty
+          (if evictionError.assumedIncompatibleEvictions.isEmpty
              || assumedEvictionErrorLevel != Level.Error
-           ) Nil
+           then Nil
            else evictionError.toAssumedLines)
-      if (errorLines.nonEmpty) sys.error((errorLines ++ extraLines).mkString(System.lineSeparator))
-      else {
-        if (evictionError.incompatibleEvictions.isEmpty) ()
+      if errorLines.nonEmpty then
+        sys.error((errorLines ++ extraLines).mkString(System.lineSeparator))
+      else
+        if evictionError.incompatibleEvictions.isEmpty then ()
         else evictionError.lines.foreach(log.log(evictionLevel, _: String))
-        if (evictionError.assumedIncompatibleEvictions.isEmpty) ()
-        else
-          evictionError.toAssumedLines.foreach(log.log(assumedEvictionErrorLevel, _: String))
-      }
+        if evictionError.assumedIncompatibleEvictions.isEmpty then ()
+        else evictionError.toAssumedLines.foreach(log.log(assumedEvictionErrorLevel, _: String))
       CompatibilityWarning.run(compatWarning, module, mavenStyle, log)
       val report2 = transformDetails(report1, includeCallers, includeDetails)
       report2
-    }
+    end resolve
 
     /* Check if a update report is still up to date or we must resolve again. */
-    def upToDate(inChanged: Boolean, out: UpdateReport): Boolean = {
+    def upToDate(inChanged: Boolean, out: UpdateReport): Boolean =
       // Transitive dependency stamps are now part of UpdateInputs, so inChanged
       // will be true if any transitive stamp changed (cross-command invalidation).
       !force &&
-      !inChanged &&
-      out.allFiles.forall(f => fileUptodate(f.toString, out.stamps, log)) &&
-      fileUptodate(out.cachedDescriptor.toString, out.stamps, log)
-    }
+        !inChanged &&
+        out.allFiles.forall(f => fileUptodate(f.toString, out.stamps, log)) &&
+        fileUptodate(out.cachedDescriptor.toString, out.stamps, log)
 
     /* Skip resolve if last output exists, otherwise error. */
-    def skipResolve(cache: CacheStore)(inputs: UpdateInputs): UpdateReport = {
+    def skipResolve(cache: CacheStore)(inputs: UpdateInputs): UpdateReport =
       UpdateReportPersistence.readFrom(cache) match
         case Some(cached) =>
           markAsCached(UpdateReportPersistence.fromCache(cached))
         case None =>
           sys.error("Skipping update requested, but update has not previously run successfully.")
-    }
 
     // Mark UpdateReport#stats as "cached." This is used by the dependers later
     // to determine whether they now need to run update in the above `upToDate`.
     def markAsCached(ur: UpdateReport): UpdateReport =
       ur.withStats(ur.stats.withCached(true))
 
-    def doResolve(cache: CacheStore): UpdateInputs => UpdateReport = {
-      val doCachedResolve = { (inChanged: Boolean, updateInputs: UpdateInputs) =>
+    def doResolve(cache: CacheStore): UpdateInputs => UpdateReport =
+      val doCachedResolve = (inChanged: Boolean, updateInputs: UpdateInputs) =>
         try
           val previous =
             UpdateReportPersistence.readFrom(cache).map(UpdateReportPersistence.fromCache)
@@ -159,10 +153,9 @@ private[sbt] object LibraryManagement {
             resolvedAgain.toString.linesIterator.foreach(log.warn(_))
             log.trace(t)
             resolvedAgain
-      }
       import LibraryManagementCodec.given
       Tracked.inputChanged(cacheStoreFactory.make("inputs"))(doCachedResolve)
-    }
+    end doResolve
 
     def informSandwich(): Unit =
       log.warn("[sbt-8728] Smorrebrod - the end of Scala 2.13-3.x sandwich")
@@ -189,28 +182,25 @@ private[sbt] object LibraryManagement {
     val extraInputHash = module.extraInputHash
     val settings = module.moduleSettings
     val outStore = cacheStoreFactory.makeCompressed("output")
-    val handler = if (skip && !force) skipResolve(outStore)(_) else doResolve(outStore)
+    val handler = if skip && !force then skipResolve(outStore)(_) else doResolve(outStore)
     // Remove clock for caching purpose
     val withoutClock = updateConfig.withLogicalClock(LogicalClock.unknown)
     // Collect transitive stamps for cross-command cache invalidation
     val transitiveStamps = transitiveUpdates.flatMap(_.stats.stamp).toVector
     handler((extraInputHash, settings, withoutClock, transitiveStamps))
-  }
+  end cachedUpdate
 
-  private def fileUptodate(file0: String, stamps: Map[String, Long], log: Logger): Boolean = {
+  private def fileUptodate(file0: String, stamps: Map[String, Long], log: Logger): Boolean =
     val file = File(file0)
     val exists = file.exists
     // https://github.com/sbt/sbt/issues/5292 warn the user that the file is missing since this indicates
     // that UpdateReport was persisted but Coursier cache was not.
-    if (!exists) {
-      log.warn(s"${file.getName} no longer exists at $file")
-    }
+    if !exists then log.warn(s"${file.getName} no longer exists at $file")
     // coursier doesn't populate stamps
     val timeStampIsSame = stamps
       .get(file0)
       .forall(_ == IO.getModifiedTimeOrZero(file))
     exists && timeStampIsSame
-  }
 
   private[sbt] def transitiveScratch(
       lm: DependencyResolution,
@@ -218,16 +208,15 @@ private[sbt] object LibraryManagement {
       config: GetClassifiersConfiguration,
       uwconfig: UnresolvedWarningConfiguration,
       log: Logger
-  ): Either[UnresolvedWarning, UpdateReport] = {
+  ): Either[UnresolvedWarning, UpdateReport] =
     import config.{ updateConfiguration, module }
     import module.{ id, dependencies, scalaModuleInfo }
     val base = restrictedCopy(id, true).withName(id.name + "$" + label)
     val mod = lm.moduleDescriptor(base, dependencies, scalaModuleInfo)
-    val report = lm.update(mod, updateConfiguration, uwconfig, log) match {
+    val report = lm.update(mod, updateConfiguration, uwconfig, log) match
       case Right(r) => r
       case Left(w)  =>
         throw w.resolveException
-    }
     val key = (m: ModuleID) => (m.organization, m.name, m.revision)
     val originalKeys = dependencies.map(key).toSet
     val transitiveOnly = report.allModules.filterNot(m => originalKeys contains key(m))
@@ -235,42 +224,42 @@ private[sbt] object LibraryManagement {
     val newConfig = config
       .withModule(module.withDependencies(mergedDependencies))
     lm.updateClassifiers(newConfig, uwconfig, Vector(), log)
-  }
+  end transitiveScratch
 
   private[sbt] def restrictedCopy(m: ModuleID, confs: Boolean) =
     ModuleID(m.organization, m.name, m.revision)
       .withCrossVersion(m.crossVersion)
       .withExtraAttributes(m.extraAttributes)
-      .withConfigurations(if (confs) m.configurations else None)
+      .withConfigurations(if confs then m.configurations else None)
       .branch(m.branchName)
 
   private def transformDetails(
       ur: UpdateReport,
       includeCallers: Boolean,
       includeDetails: Boolean
-  ): UpdateReport = {
+  ): UpdateReport =
     val crs0 = ur.configurations
     val crs1 =
-      if (includeDetails) crs0
+      if includeDetails then crs0
       else crs0 map { _.withDetails(Vector()) }
     val crs2 =
-      if (includeCallers) crs1
+      if includeCallers then crs1
       else
         crs1 map { cr =>
           val mrs0 = cr.modules
           // Re-intern what stripping rebuilds: dropping the callers is what makes two projects'
           // reports of the same coordinate value-equal, so this is where they collapse to one.
           val mrs1 = mrs0 map { mr =>
-            if (mr.callers.isEmpty) mr
+            if mr.callers.isEmpty then mr
             else UpdateReportInterner.intern(mr.withCallers(Vector()))
           }
           cr.withModules(mrs1)
         }
     ur.withConfigurations(crs2)
-  }
+  end transformDetails
 
   val moduleIdJsonKeyFormat: sjsonnew.JsonKeyFormat[ModuleID] =
-    new sjsonnew.JsonKeyFormat[ModuleID] {
+    new sjsonnew.JsonKeyFormat[ModuleID]:
       import LibraryManagementCodec.given
       import sjsonnew.support.scalajson.unsafe.*
       val moduleIdFormat: JsonFormat[ModuleID] = implicitly[JsonFormat[ModuleID]]
@@ -278,7 +267,6 @@ private[sbt] object LibraryManagement {
         CompactPrinter(Converter.toJsonUnsafe(key)(using moduleIdFormat))
       def read(key: String): ModuleID =
         Converter.fromJsonUnsafe[ModuleID](Parser.parseUnsafe(key))(using moduleIdFormat)
-    }
 
   /**
    * Resolves and optionally retrieves classified artifacts, such as javadocs and sources,
@@ -372,7 +360,7 @@ private[sbt] object LibraryManagement {
               )
               fullUpdateOutput.exists() && elapsedDuration > period
         }
-        val updateConf = {
+        val updateConf =
           import UpdateLogging.{ Full, DownloadOnly, Default }
           val conf1 = maybeUpdateLevel.orElse(state0.get(logLevel.key)) match
             case Some(Level.Debug) if conf.logging == Default => conf.withLogging(logging = Full)
@@ -380,7 +368,6 @@ private[sbt] object LibraryManagement {
             case _                                  => conf
           // logical clock is folded into UpdateConfiguration
           conf1.withLogicalClock(LogicalClock(state0.hashCode))
-        }
         cachedUpdate(
           lm = lm,
           module = lm.moduleDescriptor(ms.asInstanceOf[ModuleDescriptorConfiguration]),
@@ -409,7 +396,7 @@ private[sbt] object LibraryManagement {
   // Used by Defaults.withExcludes
   def withExcludes(out: File, classifiers: Seq[String], lock: xsbti.GlobalLock)(
       f: Map[ModuleID, Vector[ConfigRef]] => UpdateReport
-  ): UpdateReport = {
+  ): UpdateReport =
     import sbt.librarymanagement.LibraryManagementCodec.given
     import sbt.util.FileBasedStore
     val exclName = "exclude_classifiers"
@@ -417,8 +404,8 @@ private[sbt] object LibraryManagement {
     val store = new FileBasedStore(file)
     lock(
       out / (exclName + ".lock"),
-      new Callable[UpdateReport] {
-        def call = {
+      new Callable[UpdateReport]:
+        def call =
           given midJsonKeyFmt: sjsonnew.JsonKeyFormat[ModuleID] = moduleIdJsonKeyFormat
           val excludes =
             store
@@ -438,10 +425,8 @@ private[sbt] object LibraryManagement {
               classifiers.toVector,
               allExcludes.view.mapValues(_.map(_.name).toSet).toMap
             )
-        }
-      }
     )
-  }
+  end withExcludes
 
   def lock(app: xsbti.AppConfiguration): xsbti.GlobalLock =
     app.provider.scalaProvider.launcher.globalLock
@@ -461,10 +446,10 @@ private[sbt] object LibraryManagement {
    * @param log Logger for debug output
    * @return The latest Scala 3 RC version string (e.g., "3.8.1-RC1")
    */
-  def fetchLatestScala3RC(log: Logger): String = {
+  def fetchLatestScala3RC(log: Logger): String =
     scala3RCCacheLock.synchronized {
       val now = System.currentTimeMillis()
-      cachedScala3RC match {
+      cachedScala3RC match
         case Some((version, timestamp)) if (now - timestamp) < cacheTtlMillis =>
           log.debug(s"Using cached Scala 3 RC version: $version")
           version
@@ -473,11 +458,9 @@ private[sbt] object LibraryManagement {
           val version = fetchScala3RCFromMaven(log)
           cachedScala3RC = Some((version, now))
           version
-      }
     }
-  }
 
-  private def fetchScala3RCFromMaven(log: Logger): String = {
+  private def fetchScala3RCFromMaven(log: Logger): String =
     import scala.util.Using
     import java.net.{ HttpURLConnection, URI }
     import scala.xml.XML
@@ -489,7 +472,7 @@ private[sbt] object LibraryManagement {
     conn.setConnectTimeout(10000)
     conn.setReadTimeout(30000)
 
-    try {
+    try
       val xml = Using.resource(conn.getInputStream) { is =>
         XML.load(is)
       }
@@ -497,26 +480,22 @@ private[sbt] object LibraryManagement {
 
       // Filter for RC versions (not nightlies) and sort to get the latest
       val rcVersions = versions.flatMap { v =>
-        v match {
+        v match
           case Scala3RCPattern(major, minor, patch, rc) =>
             Some((major.toInt, minor.toInt, patch.toInt, rc.toInt, v))
           case _ => None
-        }
       }
 
-      if (rcVersions.isEmpty) {
-        sys.error("No Scala 3 release candidates found in Maven Central")
-      }
+      if rcVersions.isEmpty then sys.error("No Scala 3 release candidates found in Maven Central")
 
       // Sort by version components (major, minor, patch, rc) descending
       val latestRC =
         rcVersions.minBy { case (maj, min, pat, rc, _) => (-maj, -min, -pat, -rc) }._5
       log.info(s"Latest Scala 3 release candidate: $latestRC")
       latestRC
-    } finally {
-      conn.disconnect()
-    }
-  }
+    finally conn.disconnect()
+    end try
+  end fetchScala3RCFromMaven
 
   /**
    * Resolves a dynamic Scala version string to a concrete version.
@@ -527,26 +506,21 @@ private[sbt] object LibraryManagement {
    * @param log Logger for debug output
    * @return The resolved concrete version string
    */
-  def resolveDynamicScalaVersion(version: String, log: Logger): String = {
-    version match {
+  def resolveDynamicScalaVersion(version: String, log: Logger): String =
+    version match
       case "3-latest.candidate" => fetchLatestScala3RC(log)
       case other                => other
-    }
-  }
 
   /**
    * Resolves a dynamic Scala version string to a concrete version.
    * Uses a silent logger for background resolution.
    */
-  def resolveDynamicScalaVersion(version: String): String = {
+  def resolveDynamicScalaVersion(version: String): String =
     resolveDynamicScalaVersion(version, Logger.Null)
-  }
 
   /**
    * Checks if a version string is a dynamic version that needs resolution.
    */
-  def isDynamicScalaVersion(version: String): Boolean = {
+  def isDynamicScalaVersion(version: String): Boolean =
     version == "3-latest.candidate"
-  }
-
-}
+end LibraryManagement
diff --git a/main/src/main/scala/sbt/internal/LintUnused.scala b/main/src/main/scala/sbt/internal/LintUnused.scala
index 0e05e6bf6..cbf8ea609 100644
--- a/main/src/main/scala/sbt/internal/LintUnused.scala
+++ b/main/src/main/scala/sbt/internal/LintUnused.scala
@@ -16,7 +16,7 @@ import ProjectExtra.{ extract, scopedKeyData }
 import Scope.Global
 import sbt.Def.*
 
-object LintUnused {
+object LintUnused:
   lazy val lintSettings: Seq[Setting[?]] = Seq(
     lintIncludeFilter := {
       val includes = includeLintKeys.value.map(_.scopedKey.key.label)
@@ -80,33 +80,31 @@ object LintUnused {
     val includeKeys = (Global / lintIncludeFilter).value
     val excludeKeys = (Global / lintExcludeFilter).value
     val result = lintUnused(state, includeKeys, excludeKeys)
-    if (result.isEmpty) log.success("ok")
+    if result.isEmpty then log.success("ok")
     else lintResultLines(result) foreach { log.warn(_) }
   }
 
   // function version of the lintUnused, based on just state
-  def lintUnusedFunc(s: State): State = {
+  def lintUnusedFunc(s: State): State =
     val log = s.log
     val extracted = Project.extract(s)
     val includeKeys = extracted.get((Global / lintIncludeFilter))
     val excludeKeys = extracted.get((Global / lintExcludeFilter))
-    if (extracted.get((Global / lintUnusedKeysOnLoad))) {
+    if extracted.get((Global / lintUnusedKeysOnLoad)) then
       val result = lintUnused(s, includeKeys, excludeKeys)
       lintResultLines(result) foreach { log.warn(_) }
-    }
     s
-  }
 
   def lintResultLines(
       result: Seq[(ScopedKey[?], String, Seq[SourcePosition])]
-  ): Vector[String] = {
+  ): Vector[String] =
     import scala.collection.mutable.ListBuffer
     val buffer = ListBuffer.empty[String]
 
-    if (result.isEmpty) Vector.empty
-    else {
+    if result.isEmpty then Vector.empty
+    else
       val size = result.size
-      if (size == 1) buffer.append("there's a key that's not used by any other settings/tasks:")
+      if size == 1 then buffer.append("there's a key that's not used by any other settings/tasks:")
       else buffer.append(s"there are $size keys that are not used by any other settings/tasks:")
       buffer.append(" ")
       result foreach { case (_, str, positions) =>
@@ -124,14 +122,14 @@ object LintUnused {
         "either append it to `Global / excludeLintKeys` or call .withRank(KeyRanks.Invisible) on the key"
       )
       buffer.toVector
-    }
-  }
+    end if
+  end lintResultLines
 
   def lintUnused(
       state: State,
       includeKeys: String => Boolean,
       excludeKeys: String => Boolean
-  ): Seq[(ScopedKey[?], String, Seq[SourcePosition])] = {
+  ): Seq[(ScopedKey[?], String, Seq[SourcePosition])] =
     val extracted = Project.extract(state)
     val structure = extracted.structure
     val display = Def.showShortKey(None) // extracted.showKey
@@ -149,10 +147,9 @@ object LintUnused {
 
     def isIncludeKey(u: UnusedKey): Boolean = includeKeys(u.scoped.key.label)
     def isExcludeKey(u: UnusedKey): Boolean = excludeKeys(u.scoped.key.label)
-    def isSettingKey(u: UnusedKey): Boolean = u.data match {
+    def isSettingKey(u: UnusedKey): Boolean = u.data match
       case Some(data) => data.settingValue.isDefined
       case _          => false
-    }
     def isLocallyDefined(u: UnusedKey): Boolean = u.positions.exists {
       case pos: FilePosition => pos.path.contains(File.separator)
       case _                 => false
@@ -166,9 +163,9 @@ object LintUnused {
         u
     }
     unusedKeys.map(u => (u.scoped, display.show(u.scoped), u.positions)).sortBy(_._2)
-  }
+  end lintUnused
 
-  def lintScalaVersion(state: State): State = {
+  def lintScalaVersion(state: State): State =
     val log = state.log
     val extracted = Project.extract(state)
     val structure = extracted.structure
@@ -199,8 +196,9 @@ object LintUnused {
             )
           case _ => ()
       else ()
+    end for
     state
-  }
+  end lintScalaVersion
 
   private case class UnusedKey(
       scoped: ScopedKey[?],
@@ -208,12 +206,10 @@ object LintUnused {
       data: Option[ScopedKeyData[?]]
   )
 
-  private def definedAtString(settings: Seq[Setting[?]]): Seq[SourcePosition] = {
+  private def definedAtString(settings: Seq[Setting[?]]): Seq[SourcePosition] =
     settings flatMap { setting =>
-      setting.pos match {
+      setting.pos match
         case NoPosition => Vector.empty
         case pos        => Vector(pos)
-      }
     }
-  }
-}
+end LintUnused
diff --git a/main/src/main/scala/sbt/internal/Load.scala b/main/src/main/scala/sbt/internal/Load.scala
index a7cf2aa31..868e46883 100755
--- a/main/src/main/scala/sbt/internal/Load.scala
+++ b/main/src/main/scala/sbt/internal/Load.scala
@@ -45,7 +45,7 @@ import sbt.internal.util.Util
  * evaluated only once per plugin instance during build loading, regardless of how
  * many subprojects activate the plugin.  See https://github.com/sbt/sbt/issues/5166
  */
-private[sbt] final class AutoPluginCache {
+private[sbt] final class AutoPluginCache:
   private val settingsCache: mutable.HashMap[AutoPlugin, Seq[Def.Setting[?]]] =
     mutable.HashMap.empty
   private val configCache: mutable.HashMap[AutoPlugin, Seq[Configuration]] = mutable.HashMap.empty
@@ -55,9 +55,8 @@ private[sbt] final class AutoPluginCache {
 
   def projectConfigurations(plugin: AutoPlugin): Seq[Configuration] =
     configCache.getOrElseUpdate(plugin, plugin.projectConfigurations)
-}
 
-private[sbt] object Load {
+private[sbt] object Load:
   // note that there is State passed in but not pulled out
   def defaultLoad(
       state: State,
@@ -65,26 +64,25 @@ private[sbt] object Load {
       log: Logger,
       isPlugin: Boolean = false,
       topLevelExtras: List[URI] = Nil
-  ): (() => Eval, BuildStructure) = {
+  ): (() => Eval, BuildStructure) =
     val (base, config) = timed("Load.defaultLoad until apply", log) {
       val globalBase = getGlobalBase(state)
       val base = baseDirectory.getCanonicalFile
       val rawConfig = defaultPreGlobal(state, base, globalBase, log)
       val config0 = defaultWithGlobal(state, base, rawConfig, globalBase)
       val config =
-        if (isPlugin) enableSbtPlugin(config0) else config0.copy(extraBuilds = topLevelExtras)
+        if isPlugin then enableSbtPlugin(config0) else config0.copy(extraBuilds = topLevelExtras)
       (base, config)
     }
     val result = apply(base, state, config)
     result
-  }
 
   def defaultPreGlobal(
       state: State,
       baseDirectory: File,
       globalBase: File,
       log: Logger
-  ): LoadBuildConfiguration = {
+  ): LoadBuildConfiguration =
     val app = state.configuration
     val provider = app.provider
     val scalaProvider = app.provider.scalaProvider
@@ -154,7 +152,7 @@ private[sbt] object Load {
       converter = converter,
       log
     )
-  }
+  end defaultPreGlobal
 
   def injectGlobal(state: State): Seq[Setting[?]] =
     ((GlobalScope / appConfiguration) :== state.configuration) +:
@@ -166,14 +164,13 @@ private[sbt] object Load {
       base: File,
       rawConfig: LoadBuildConfiguration,
       globalBase: File,
-  ): LoadBuildConfiguration = {
+  ): LoadBuildConfiguration =
     val globalPluginsDir = getGlobalPluginsDirectory(state, globalBase)
     val withGlobal = loadGlobal(state, base, globalPluginsDir, rawConfig)
     val globalSettings: Seq[VirtualFile] =
       configurationSources(getGlobalSettingsDirectory(state, globalBase))
         .map(x => rawConfig.converter.toVirtualFile(x.toPath))
     loadGlobalSettings(base, globalBase, globalSettings, withGlobal)
-  }
 
   def loadGlobalSettings(
       base: File,
@@ -182,7 +179,7 @@ private[sbt] object Load {
       config: LoadBuildConfiguration
   ): LoadBuildConfiguration =
     val compiled: ClassLoader => Seq[Setting[?]] =
-      if (files.isEmpty || base == globalBase) const(Nil)
+      if files.isEmpty || base == globalBase then const(Nil)
       else buildGlobalSettings(globalBase, files, config)
     config.copy(injectSettings = config.injectSettings.copy(projectLoaded = compiled))
 
@@ -190,7 +187,7 @@ private[sbt] object Load {
       base: File,
       files: Seq[VirtualFile],
       config: LoadBuildConfiguration,
-  ): ClassLoader => Seq[Setting[?]] = {
+  ): ClassLoader => Seq[Setting[?]] =
     val converter = config.converter
     val eval = mkEval(
       classpath = data(config.globalPluginClasspath).map(converter.toPath),
@@ -202,26 +199,25 @@ private[sbt] object Load {
     val imports =
       BuildUtil.baseImports ++ config.detectedGlobalPlugins.imports
 
-    loader => {
+    loader =>
       val loaded = EvaluateConfigurations(eval, files, imports)(loader)
       // TODO - We have a potential leak of config-classes in the global directory right now.
       // We need to find a way to clean these safely, or at least warn users about
       // unused class files that could be cleaned when multiple sbt instances are not running.
       loaded.settings
-    }
-  }
+  end buildGlobalSettings
   def loadGlobal(
       state: State,
       base: File,
       global: File,
       config: LoadBuildConfiguration
   ): LoadBuildConfiguration =
-    if (base != global && global.exists) {
+    if base != global && global.exists then
       val gp = GlobalPlugin.load(global, state, config)
       config.copy(globalPlugin = Some(gp))
-    } else config
+    else config
 
-  def defaultDelegates: LoadedBuild => Scope => Seq[Scope] = (lb: LoadedBuild) => {
+  def defaultDelegates: LoadedBuild => Scope => Seq[Scope] = (lb: LoadedBuild) =>
     val rootProject = getRootProject(lb.units)
     def resolveRef(project: Reference): ResolvedReference =
       Scope.resolveReference(lb.root, rootProject, project)
@@ -234,7 +230,6 @@ private[sbt] object Load {
       (project, config) => configInherit(lb, project, config, rootProject),
       task => task.extend,
     )
-  }
 
   def configInherit(
       lb: LoadedBuild,
@@ -242,20 +237,18 @@ private[sbt] object Load {
       config: ConfigKey,
       rootProject: URI => String
   ): Seq[ConfigKey] =
-    ref match {
+    ref match
       case pr: ProjectRef => configInheritRef(lb, pr, config)
       case BuildRef(uri)  => configInheritRef(lb, ProjectRef(uri, rootProject(uri)), config)
-    }
 
   def configInheritRef(lb: LoadedBuild, ref: ProjectRef, config: ConfigKey): Seq[ConfigKey] =
     configurationOpt(lb.units, ref.build, ref.project, config).toList
       .flatMap(_.extendsConfigs)
       .map(c => ConfigKey(c.name))
 
-  def projectInherit(lb: LoadedBuild, ref: ProjectRef): Seq[ProjectRef] = {
+  def projectInherit(lb: LoadedBuild, ref: ProjectRef): Seq[ProjectRef] =
     val _ = getProject(lb.units, ref.build, ref.project)
     Nil
-  }
 
   // build, load, and evaluate all units.
   //  1) Compile all plugin definitions
@@ -270,7 +263,7 @@ private[sbt] object Load {
       rootBase: File,
       s: State,
       config: LoadBuildConfiguration
-  ): (() => Eval, BuildStructure) = {
+  ): (() => Eval, BuildStructure) =
     val log = config.log
 
     // load, which includes some resolution, but can't fill in project IDs yet, so follow with full resolution
@@ -293,9 +286,8 @@ private[sbt] object Load {
     }
     val (cMap, data) = timed("Load.apply: Def.make(settings)...", log) {
       // When settings.size is 100000, Def.make takes around 10s.
-      if (settings.size > 10000) {
+      if settings.size > 10000 then
         log.info(s"resolving key references (${settings.size} settings) ...")
-      }
       Def.makeWithCompiledMap(settings)(using
         delegates,
         config.scopeLocal,
@@ -321,22 +313,21 @@ private[sbt] object Load {
       config.converter,
     )
     (rootEval, bs)
-  }
+  end apply
 
   private def checkTargets(data: Def.Settings): Option[String] =
     val dups = overlappingTargets(allTargets(data))
-    if (dups.isEmpty) None
-    else {
+    if dups.isEmpty then None
+    else
       val dupStr = dups.map { (dir, scopes) =>
         s"${dir.getAbsolutePath}:\n\t${scopes.mkString("\n\t")}"
       }.mkString
       Some(s"Overlapping output directories:$dupStr")
-    }
 
   private def overlappingTargets(targets: Seq[(ProjectRef, File)]): Map[File, Seq[ProjectRef]] =
     targets.groupBy(_._2).view.filter(_._2.size > 1).mapValues(_.map(_._1)).toMap
 
-  private def allTargets(data: Def.Settings): Seq[(ProjectRef, File)] = {
+  private def allTargets(data: Def.Settings): Seq[(ProjectRef, File)] =
     import ScopeFilter.*
     val allProjects = ScopeFilter(Make.inAnyProject)
     val targetAndRef = Def.setting { (Keys.thisProjectRef.value, Keys.target.value) }
@@ -344,14 +335,13 @@ private[sbt] object Load {
       .all(allProjects)
       .evaluate(data)
       .flatMap(x => x)
-  }
 
   // map dependencies on the special tasks:
   // 1. the scope of 'streams' is the same as the defining key and has the task axis set to the defining key
   // 2. the defining key is stored on constructed tasks: used for error reporting among other things
   // 3. resolvedScoped is replaced with the defining key as a value
   // Note: this must be idempotent.
-  def finalTransforms(ss: Seq[Setting[?]]): Seq[Setting[?]] = {
+  def finalTransforms(ss: Seq[Setting[?]]): Seq[Setting[?]] =
     def mapSpecial(to: ScopedKey[?]): [a] => ScopedKey[a] => ScopedKey[a] =
       [a] =>
         (key: ScopedKey[a]) =>
@@ -360,11 +350,10 @@ private[sbt] object Load {
           else key
     def setDefining[T] =
       (key: ScopedKey[T], value: T) =>
-        value match {
+        value match
           case tk: Task[t]      => setDefinitionKey(tk, key).asInstanceOf[T]
           case ik: InputTask[t] => ik.mapTask(tk => setDefinitionKey(tk, key)).asInstanceOf[T]
           case _                => value
-        }
     def setResolved(defining: ScopedKey[?]): [a] => ScopedKey[a] => Option[a] =
       [a] =>
         (key: ScopedKey[a]) =>
@@ -376,17 +365,17 @@ private[sbt] object Load {
         .mapReferenced(mapSpecial(s.key))
         .mapInit(setDefining)
     )
-  }
+  end finalTransforms
 
   def setDefinitionKey[T](tk: Task[T], key: ScopedKey[?]): Task[T] =
-    if (isDummy(tk)) tk else tk.set(Keys.taskDefinitionKey, key)
+    if isDummy(tk) then tk else tk.set(Keys.taskDefinitionKey, key)
 
   def structureIndex(
       data: Def.Settings,
       settings: Seq[Setting[?]],
       extra: KeyIndex => BuildUtil[?],
       projects: Map[URI, LoadedBuildUnit]
-  ): StructureIndex = {
+  ): StructureIndex =
     val keys = Index.allKeys(settings)
     val attributeKeys = data.attributeKeys ++ keys.map(_.key)
     val scopedKeys = keys ++ data.keys
@@ -401,12 +390,11 @@ private[sbt] object Load {
       keyIndex,
       aggIndex
     )
-  }
 
   // Reevaluates settings after modifying them.  Does not recompile or reload any build components.
   def reapply(newSettings: Seq[Setting[?]], structure: BuildStructure)(using
       display: Show[ScopedKey[?]]
-  ): BuildStructure = {
+  ): BuildStructure =
     val transformed = finalTransforms(newSettings)
     val (cMap, newData) =
       Def.makeWithCompiledMap(transformed)(using structure.delegates, structure.scopeLocal, display)
@@ -425,13 +413,13 @@ private[sbt] object Load {
       compiledMap = cMap,
       converter = structure.converter,
     )
-  }
+  end reapply
 
   def buildConfigurations(
       loaded: LoadedBuild,
       rootProject: URI => String,
       injectSettings: InjectSettings
-  ): Seq[Setting[?]] = {
+  ): Seq[Setting[?]] =
     (((GlobalScope / loadedBuild) :== loaded) +:
       transformProjectOnly(loaded.root, rootProject, injectSettings.global)) ++
       inScope(GlobalScope)(loaded.autos.globalSettings) ++
@@ -447,18 +435,17 @@ private[sbt] object Load {
           build.defined.toSeq.map { (id, project) =>
             val ref = ProjectRef(uri, id)
             val defineConfig: Seq[Setting[?]] =
-              for (c <- project.configurations)
-                yield ((ref / ConfigKey(c.name) / configuration) :== c)
+              for c <- project.configurations
+              yield ((ref / ConfigKey(c.name) / configuration) :== c)
             val builtin: Seq[Setting[?]] =
               (thisProject :== project) +: (thisProjectRef :== ref) +: defineConfig
             val settings = builtin ++ injectSettings.project ++ project.settings
             // map This to thisScope, Select(p) to mapRef(uri, rootProject, p)
             val transformed = transformSettings(projectScope(ref), uri, rootProject, settings)
             transformed.partition { s =>
-              s.key.scope.project match {
+              s.key.scope.project match
                 case Select(r) => r == ref
                 case _         => true // global scope
-              }
             }
           }.unzip
         val projectSettings = (ownSettingsSeqs ++ crossSettingsSeqs).flatten
@@ -468,7 +455,6 @@ private[sbt] object Load {
         val buildSettings = transformSettings(buildScope, uri, rootProject, settings3)
         buildSettings ++ projectSettings
       }
-  }
 
   def transformProjectOnly(
       uri: URI,
@@ -482,19 +468,17 @@ private[sbt] object Load {
       uri: URI,
       rootProject: URI => String,
       settings: Seq[Setting[?]]
-  ): Seq[Setting[?]] = {
+  ): Seq[Setting[?]] =
     val transformed = Project.transform(Scope.resolveScope(thisScope, uri, rootProject), settings)
     Settings.inject(transformed)
-  }
 
   def projectScope(project: Reference): Scope = Scope(Select(project), Zero, Zero, Zero)
 
-  def lazyEval(unit: BuildUnit): () => Eval = {
+  def lazyEval(unit: BuildUnit): () => Eval =
     lazy val eval = mkEval(unit)
     () => eval
-  }
 
-  def mkEval(unit: BuildUnit): Eval = {
+  def mkEval(unit: BuildUnit): Eval =
     val converter = unit.converter
     val defs = unit.definitions
     mkEval(
@@ -502,7 +486,6 @@ private[sbt] object Load {
       defs.base,
       unit.plugins.pluginData.scalacOptions,
     )
-  }
 
   def mkEval(classpath: Seq[Path], base: File, options: Seq[String]): Eval =
     mkEval(classpath, base, options, () => EvalReporter.console)
@@ -525,14 +508,14 @@ private[sbt] object Load {
    *
    * @param base  The base directory for the build, should match the one passed into `mkEval` method.
    */
-  def cleanEvalClasses(base: File, keep: Seq[Path]): Unit = {
+  def cleanEvalClasses(base: File, keep: Seq[Path]): Unit =
     val baseTarget = evalOutputDirectory(base)
     val keepSet = keep.map(_.toAbsolutePath().normalize()).toSet
     // If there are no keeper files, this may be because cache was up-to-date and
     // the files aren't properly returned, even though they should be.
     // TODO - figure out where the caching of whether or not to generate classfiles occurs, and
     // put cleanups there, perhaps.
-    if (keepSet.nonEmpty) {
+    if keepSet.nonEmpty then
       def keepFile(f: Path) = keepSet(f.toAbsolutePath().normalize())
       import sbt.io.syntax.*
       val existing = (baseTarget.allPaths
@@ -540,11 +523,7 @@ private[sbt] object Load {
         .filterNot(_.isDirectory)
         .map(_.toPath())
       val toDelete = existing.filterNot(keepFile)
-      if (toDelete.nonEmpty) {
-        IO.delete(toDelete.map(_.toFile()))
-      }
-    }
-  }
+      if toDelete.nonEmpty then IO.delete(toDelete.map(_.toFile()))
 
   /**
    * Loads the unresolved build units and computes its settings.
@@ -554,14 +533,13 @@ private[sbt] object Load {
    * @param config The configuration of the loaded build.
    * @return An instance of [[PartBuild]] with all the unresolved build units.
    */
-  def load(root: File, s: State, config: LoadBuildConfiguration): PartBuild = {
+  def load(root: File, s: State, config: LoadBuildConfiguration): PartBuild =
     val manager = config.pluginManagement.shift
     // Forced type ascription, otherwise scalac does not compile it
     val newConfig: LoadBuildConfiguration =
       config.copy(pluginManagement = manager, extraBuilds = Nil)
     val loader = builtinLoader(s, newConfig)
     loadURI(IO.directoryURI(root), loader, config.extraBuilds.toList, newConfig.converter)
-  }
 
   /**
    * Creates a loader for the build.
@@ -570,7 +548,7 @@ private[sbt] object Load {
    * @param config The configuration of the loaded build.
    * @return A [[BuildLoader]].
    */
-  def builtinLoader(s: State, config: LoadBuildConfiguration): BuildLoader = {
+  def builtinLoader(s: State, config: LoadBuildConfiguration): BuildLoader =
     val fail = (uri: URI) => sys.error("Invalid build URI (no handler available): " + uri)
     val resolver = (info: BuildLoader.ResolveInfo) => RetrieveUnit(info)
     val build = (info: BuildLoader.BuildInfo) =>
@@ -578,38 +556,34 @@ private[sbt] object Load {
     val loader = BuildLoader.componentLoader
     val components = BuildLoader.components(resolver, build, full = loader)
     BuildLoader(components, fail, s, config)
-  }
 
   private def loadURI(
       uri: URI,
       loader: BuildLoader,
       extra: List[URI],
       converter: MappedFileConverter,
-  ): PartBuild = {
+  ): PartBuild =
     IO.assertAbsolute(uri)
     val (referenced, map, newLoaders) = loadAll(uri +: extra, Map.empty, loader, Map.empty)
     checkAll(referenced, map)
     val build = PartBuild(uri, map, converter)
     newLoaders.transformAll(build)
-  }
 
   def addOverrides(unit: BuildUnit, loaders: BuildLoader): BuildLoader =
     loaders.updatePluginManagement(PluginManagement.extractOverrides(unit.plugins.fullClasspath))
 
   def addResolvers(unit: BuildUnit, isRoot: Boolean, loaders: BuildLoader): BuildLoader =
-    unit.definitions.builds.flatMap(_.buildLoaders).toList match {
+    unit.definitions.builds.flatMap(_.buildLoaders).toList match
       case Nil     => loaders
       case x :: xs =>
         val resolver = xs.foldLeft(x) { _ | _ }
-        if (isRoot) loaders.setRoot(resolver) else loaders.addNonRoot(unit.uri, resolver)
-    }
+        if isRoot then loaders.setRoot(resolver) else loaders.addNonRoot(unit.uri, resolver)
 
-  def loaded(unit: BuildUnit): (PartBuildUnit, List[ProjectReference]) = {
+  def loaded(unit: BuildUnit): (PartBuildUnit, List[ProjectReference]) =
     val defined = projects(unit)
-    val firstDefined = defined match {
+    val firstDefined = defined match
       case Nil            => sys.error("No projects defined in build unit " + unit)
       case Seq(first, _*) => first
-    }
 
     // since base directories are resolved at this point (after 'projects'),
     //   we can compare Files instead of converting to URIs
@@ -617,8 +591,8 @@ private[sbt] object Load {
 
     val externals = referenced(defined).toList
     val explicitRoots = unit.definitions.builds.flatMap(_.rootProject)
-    val projectsInRoot = if (explicitRoots.isEmpty) defined.filter(isRoot) else explicitRoots
-    val rootProjects = if (projectsInRoot.isEmpty) firstDefined :: Nil else projectsInRoot
+    val projectsInRoot = if explicitRoots.isEmpty then defined.filter(isRoot) else explicitRoots
+    val rootProjects = if projectsInRoot.isEmpty then firstDefined :: Nil else projectsInRoot
     val partBuildUnit = new PartBuildUnit(
       unit,
       defined.map(d => (d.id, d)).toMap,
@@ -626,21 +600,20 @@ private[sbt] object Load {
       buildSettings(unit)
     )
     (partBuildUnit, externals)
-  }
+  end loaded
 
-  def buildSettings(unit: BuildUnit): Seq[Setting[?]] = {
+  def buildSettings(unit: BuildUnit): Seq[Setting[?]] =
     val buildScope = GlobalScope.copy(project = Select(BuildRef(unit.uri)))
     val resolve = Scope.resolveBuildScope(buildScope, unit.uri)
     Project.transform(resolve, unit.definitions.builds.flatMap(_.settings))
-  }
 
   @tailrec private def loadAll(
       bases: List[URI],
       references: Map[URI, List[ProjectReference]],
       loaders: BuildLoader,
       builds: Map[URI, PartBuildUnit]
-  ): (Map[URI, List[ProjectReference]], Map[URI, PartBuildUnit], BuildLoader) = {
-    def loadURI(base: URI, bases: List[URI]) = {
+  ): (Map[URI, List[ProjectReference]], Map[URI, PartBuildUnit], BuildLoader) =
+    def loadURI(base: URI, bases: List[URI]) =
       val (loadedBuild, refs) = loaded(loaders(base))
       val uris = refs.flatMap(Reference.uri)
       val buildUnit = loadedBuild.unit
@@ -651,36 +624,29 @@ private[sbt] object Load {
       val updatedBuilds = builds.updated(base, loadedBuild)
       val sortedRemaining = uris.reverse_:::(bases).sorted
       (sortedRemaining, updatedReferences, updatedLoader, updatedBuilds)
-    }
 
-    bases match {
+    bases match
       case b :: bs =>
-        if (builds contains b) loadAll(bs, references, loaders, builds)
-        else {
+        if builds contains b then loadAll(bs, references, loaders, builds)
+        else
           val (newBases, newReferences, newLoaders, newBuilds) = loadURI(b, bs)
           loadAll(newBases, newReferences, newLoaders, newBuilds)
-        }
       case Nil => (references, builds, loaders)
-    }
-  }
+  end loadAll
 
-  def checkProjectBase(buildBase: File, projectBase: File): Unit = {
+  def checkProjectBase(buildBase: File, projectBase: File): Unit =
     checkDirectory(projectBase)
     assert(
       buildBase == projectBase || IO.relativize(buildBase, projectBase).isDefined,
       s"directory $projectBase is not contained in build root $buildBase"
     )
-  }
 
   def checkBuildBase(base: File) = checkDirectory(base)
 
-  def checkDirectory(base: File): Unit = {
+  def checkDirectory(base: File): Unit =
     assert(base.isAbsolute, "Not absolute: " + base)
-    if (base.isFile)
-      sys.error("Not a directory: " + base)
-    else if (!base.exists)
-      IO.createDirectory(base)
-  }
+    if base.isFile then sys.error("Not a directory: " + base)
+    else if !base.exists then IO.createDirectory(base)
 
   def checkAll(
       referenced: Map[URI, List[ProjectReference]],
@@ -697,11 +663,10 @@ private[sbt] object Load {
         case _              =>
           val ProjectRef(refURI, refID) = Scope.resolveProjectRef(uri, rootProject, ref)
           val loadedUnit = builds(refURI)
-          if (!loadedUnit.defined.contains(refID)) {
+          if !loadedUnit.defined.contains(refID) then
             val projectIDs = loadedUnit.defined.keys.toSeq.sorted
             sys.error(s"""No project '$refID' in '$refURI'.
                         |Valid project IDs: ${projectIDs.mkString(", ")}""".stripMargin)
-          }
 
   /**
    * Returns true when value is the subproject base for root project.
@@ -710,23 +675,20 @@ private[sbt] object Load {
   def isRootPath(value: File, projectBase: File): Boolean =
     projectBase.getCanonicalFile() == IO.resolve(projectBase, value).getCanonicalFile()
 
-  def resolveBase(against: File): Project => Project = {
-    def resolve(f: File) = {
+  def resolveBase(against: File): Project => Project =
+    def resolve(f: File) =
       val fResolved = new File(IO.directoryURI(IO.resolve(against, f)))
       checkProjectBase(against, fResolved)
       fResolved
-    }
     p => p.copy(base = resolve(p.base))
-  }
 
-  def resolveProjects(loaded: PartBuild): LoadedBuild = {
+  def resolveProjects(loaded: PartBuild): LoadedBuild =
     val rootProject = getRootProject(loaded.units)
     val units = loaded.units map { (uri, unit) =>
       IO.assertAbsolute(uri)
       (uri, resolveProjects(uri, unit, rootProject))
     }
     new LoadedBuild(loaded.root, units)
-  }
 
   def resolveProjects(
       uri: URI,
@@ -765,13 +727,12 @@ private[sbt] object Load {
       else if projBase.startsWith(base) then Vector(ProjectRef(uri, p.id))
       else Nil
 
-  def projects(unit: BuildUnit): Seq[Project] = {
+  def projects(unit: BuildUnit): Seq[Project] =
     // we don't have the complete build graph loaded, so we don't have the rootProject function yet.
     //  Therefore, we use resolveProjectBuild instead of resolveProjectRef.  After all builds are loaded, we can fully resolve ProjectReferences.
     val resolveBuild = (_: Project).resolveBuild(ref => Scope.resolveProjectBuild(unit.uri, ref))
     // although the default loader will resolve the project base directory, other loaders may not, so run resolveBase here as well
     unit.definitions.projects.map(resolveBuild compose resolveBase(unit.localBase))
-  }
 
   def getRootProject(map: Map[URI, BuildUnitBase]): URI => String =
     uri => getBuild(map, uri).rootProjects.headOption getOrElse emptyBuild(uri)
@@ -826,11 +787,10 @@ private[sbt] object Load {
 
       // NOTE - because we create an eval here, we need a clean-eval later for this URI.
       lazy val eval = timed("Load.loadUnit: mkEval", log) {
-        def mkReporter(): EvalReporter = plugs.pluginData.buildTarget match {
+        def mkReporter(): EvalReporter = plugs.pluginData.buildTarget match
           case None              => EvalReporter.logging(log)
           case Some(buildTarget) =>
             new BuildServerEvalReporter(buildTarget, EvalReporter.logging(log))
-        }
         mkEval(
           classpath = plugs.classpath.map(converter.toPath),
           defDir,
@@ -882,13 +842,13 @@ private[sbt] object Load {
           _.rootProject.isDefined
         )
       val (loadedProjects0, defaultBuildIfNone, keepClassFiles) =
-        if (hasRoot)
+        if hasRoot then
           (
             loadedProjectsRaw.projects,
             BuildDef.defaultEmpty,
             loadedProjectsRaw.generatedConfigClassFiles
           )
-        else {
+        else
           val existingIDs = loadedProjectsRaw.projects.map(_.id)
           val refs = existingIDs.map(id => ProjectRef(uri, id))
           val defaultID = autoID(normBase, config.pluginManagement.context, existingIDs)
@@ -901,12 +861,11 @@ private[sbt] object Load {
             b,
             defaultProjects.generatedConfigClassFiles ++ loadedProjectsRaw.generatedConfigClassFiles
           )
-        }
       val loadedProjects = processAutoAggregate(loadedProjects0, uri, normBase, !hasRoot)
       timed("Load.loadUnit: cleanEvalClasses", log) {
         cleanEvalClasses(defDir, keepClassFiles)
       }
-      val defs = if (defsScala.isEmpty) defaultBuildIfNone :: Nil else defsScala
+      val defs = if defsScala.isEmpty then defaultBuildIfNone :: Nil else defsScala
       // HERE we pull out the defined vals from memoSettings and unify them all so
       // we can use them later.
       val valDefinitions = memoSettings.values.foldLeft(DefinedSbtValues.empty) { (prev, sbtFile) =>
@@ -971,6 +930,7 @@ private[sbt] object Load {
       else idBase + "-build" * pluginDepth
     if existingIDs.contains(tryID) then BuildDef.defaultID(localBase)
     else tryID
+  end autoID
 
   private def autoIDError(base: File, reason: String): String =
     "Could not derive root project ID from directory " + base.getAbsolutePath + ":\n" +
@@ -1075,7 +1035,7 @@ private[sbt] object Load {
         s.key.scope.project == This || s.key.scope.project == Select(ThisProject)
 
     // load all relevant configuration files (.sbt, as .scala already exists at this point)
-    def discover(base: File): DiscoveredProjects = {
+    def discover(base: File): DiscoveredProjects =
       val auto =
         if isRootPath(base, buildBase) then AddSettings.allDefaults
         else AddSettings.defaultSbtFiles
@@ -1084,7 +1044,6 @@ private[sbt] object Load {
         if isRootPath(base, buildBase) && isMetaBuildContext(context) then extraSbtFiles
         else Nil
       discoverProjects(auto, base, extraFiles, plugins, eval, memoSettings, converter)
-    }
 
     // Step two:
     // a. Apply all the project manipulations from .sbt files in order
@@ -1095,12 +1054,12 @@ private[sbt] object Load {
         files: Seq[VirtualFile],
         extraFiles: Seq[VirtualFile],
         expand: Boolean
-    ): (Project, Seq[Project]) = {
+    ): (Project, Seq[Project]) =
       val configFiles = files.flatMap(f => memoSettings.get(f))
       val p1: Project = Function.chain(configFiles.flatMap(_.manipulations))(p)
       val autoPlugins: Seq[AutoPlugin] =
         try plugins.detected.deducePluginsFromProject(p1, log)
-        catch { case e: AutoPluginException => throw translateAutoPluginException(e, p) }
+        catch case e: AutoPluginException => throw translateAutoPluginException(e, p)
       val p2 =
         resolveProjectSettings(
           p = p1,
@@ -1116,16 +1075,16 @@ private[sbt] object Load {
           pluginCache = pluginCache,
         )
       val projectLevelExtra =
-        if (expand) {
+        if expand then
           autoPlugins.flatMap(
             _.derivedProjects(p2).map(_.setProjectOrigin(ProjectOrigin.DerivedProject))
           )
-        } else Nil
+        else Nil
       (p2, projectLevelExtra)
-    }
+    end processProject
 
     // Discover any new project definition for the base directory of this project, and load all settings.
-    def discoverAndLoad(p: Project, rest: Seq[Project]): LoadedProjects = {
+    def discoverAndLoad(p: Project, rest: Seq[Project]): LoadedProjects =
       val DiscoveredProjects(rootOpt, discovered, files, extraFiles, generated) = discover(
         p.base
       )
@@ -1141,7 +1100,6 @@ private[sbt] object Load {
         if isRootPath(p.base, buildBase) then thisProjectScoped(finalRoot.commonSettings)
         else commonSettings
       loadTransitive1(newProjects, newAcc, newGenerated, cs)
-    }
 
     // Load all config files AND process the project at the root directory, if it exists.
     // Continue loading if we find any more.
@@ -1163,12 +1121,11 @@ private[sbt] object Load {
             case None =>
               log.debug(s"[Loading] Found non-root projects $discoveredIdsStr")
               // Here we do something interesting... We need to create an aggregate root project
-              val root = {
+              val root =
                 val defaultID = autoID(buildBase, context, discovered.map(_.id))
                 if discovered.isEmpty || java.lang.Boolean.getBoolean("sbt.root.ivyplugin") then
                   BuildDef.defaultProject(defaultID, buildBase)
                 else BuildDef.generatedRootSkipPublish(defaultID, buildBase)
-              }
               val otherProjects =
                 loadTransitive1(
                   newProjects = discovered,
@@ -1200,6 +1157,7 @@ private[sbt] object Load {
         val projectIds = acc.map(_.id).mkString("(", ", ", ")")
         log.debug(s"[Loading] Done in $buildBase, returning: $projectIds")
         LoadedProjects(acc, generatedConfigClassFiles)
+    end match
   end loadTransitive
 
   private def translateAutoPluginException(
@@ -1258,7 +1216,7 @@ private[sbt] object Load {
       // 3. Use AddSettings instance to order all Setting[_]s appropriately
       // Settings are ordered as:
       // AutoPlugin settings, common settings, machine-wide settings + project.settings(...)
-      def allAutoPluginSettings: Seq[Setting[?]] = {
+      def allAutoPluginSettings: Seq[Setting[?]] =
         // Filter the AutoPlugin settings we included based on which ones are
         // intended in the AddSettings.AutoPlugins filter.
         def autoPluginSettings(f: AutoPlugins) =
@@ -1273,7 +1231,6 @@ private[sbt] object Load {
               }
             case _ => Nil
         expandPluginSettings(auto)
-      }
       def allProjectSettings: Seq[Setting[?]] =
         // Expand the AddSettings instance into a real Seq[Setting[_]] we'll use on the project
         def expandSettings(auto: AddSettings): Seq[Setting[?]] =
@@ -1342,7 +1299,7 @@ private[sbt] object Load {
       eval: () => Eval,
       memoSettings: mutable.Map[VirtualFile, LoadedSbtFile],
       converter: MappedFileConverter,
-  ): DiscoveredProjects = {
+  ): DiscoveredProjects =
 
     // Default sbt files to read, if needed
     lazy val defaultSbtFiles = configurationSources(projectBase)
@@ -1421,7 +1378,7 @@ private[sbt] object Load {
       extraSbtFiles,
       loadedFiles.generatedFiles
     )
-  }
+  end discoverProjects
 
   def globalPluginClasspath(globalPlugin: Option[GlobalPlugin]): Def.Classpath =
     globalPlugin match
@@ -1485,33 +1442,27 @@ private[sbt] object Load {
     )
 
   def activateGlobalPlugin(config: LoadBuildConfiguration): LoadBuildConfiguration =
-    config.globalPlugin match {
+    config.globalPlugin match
       case Some(gp) =>
         config.copy(injectSettings = config.injectSettings.copy(project = gp.inject))
       case None => config
-    }
 
-  def plugins(dir: File, s: State, config: LoadBuildConfiguration): LoadedPlugins = {
+  def plugins(dir: File, s: State, config: LoadBuildConfiguration): LoadedPlugins =
     val context = config.pluginManagement.context
     val extraSbtFiles: Seq[VirtualFile] =
-      if (isMetaBuildContext(context)) s.get(BasicKeys.extraMetaSbtFiles).getOrElse(Nil)
+      if isMetaBuildContext(context) then s.get(BasicKeys.extraMetaSbtFiles).getOrElse(Nil)
       else Nil
-    if (hasDefinition(dir) || extraSbtFiles.nonEmpty) {
-      if (extraSbtFiles.nonEmpty && !dir.exists()) {
-        IO.createDirectory(dir)
-      }
+    if hasDefinition(dir) || extraSbtFiles.nonEmpty then
+      if extraSbtFiles.nonEmpty && !dir.exists() then IO.createDirectory(dir)
       buildPlugins(dir, s, enableSbtPlugin(activateGlobalPlugin(config)))
-    } else
-      noPlugins(dir, config)
-  }
+    else noPlugins(dir, config)
 
   private def isMetaBuildContext(context: PluginManagement.Context): Boolean =
     !context.globalPluginProject && context.pluginProjectDepth == 1
 
-  def hasDefinition(dir: File): Boolean = {
+  def hasDefinition(dir: File): Boolean =
     import sbt.io.syntax.*
     (dir * -GlobFilter(DefaultTargetName)).get().nonEmpty
-  }
 
   def noPlugins(dir: File, config: LoadBuildConfiguration): LoadedPlugins =
     loadPluginDefinition(
@@ -1535,7 +1486,7 @@ private[sbt] object Load {
       dir: File,
       config: LoadBuildConfiguration,
       pluginData: PluginData
-  ): LoadedPlugins = {
+  ): LoadedPlugins =
     val definitionClasspath = pluginData.definitionClasspath
     val dependencyClasspath = pluginData.dependencyClasspath
     val pluginLoader: ClassLoader =
@@ -1544,7 +1495,6 @@ private[sbt] object Load {
       buildPluginClasspath(config, pluginData.dependencyClasspath)
     val newData = pluginData.copy(dependencyClasspath = fullDependencyClasspath)
     loadPlugins(dir, newData, pluginLoader)
-  }
 
   /**
    * Constructs the classpath required to load plugins, the so-called
@@ -1595,17 +1545,17 @@ private[sbt] object Load {
     else
       val cp = data(definitionClasspath).map(converter.toPath)
       ClasspathUtil.toLoader(cp, parentLoader)
+  end pluginDefinitionLoader
 
-  def buildPluginDefinition(dir: File, s: State, config: LoadBuildConfiguration): PluginData = {
+  def buildPluginDefinition(dir: File, s: State, config: LoadBuildConfiguration): PluginData =
     val (eval, pluginDef) = apply(dir, s, config)
     val pluginState = Project.setProject(Load.initialSession(pluginDef, eval), pluginDef, s)
     config.evalPluginDef(Project.structure(pluginState), pluginState)
-  }
 
   def loadPlugins(dir: File, data: PluginData, loader: ClassLoader): LoadedPlugins =
     new LoadedPlugins(dir, data, loader, PluginDiscovery.discoverAll(data, loader))
 
-  def initialSession(structure: BuildStructure, rootEval: () => Eval, s: State): SessionSettings = {
+  def initialSession(structure: BuildStructure, rootEval: () => Eval, s: State): SessionSettings =
     val session = s.get(Keys.sessionSettings)
     val currentProject = session map (_.currentProject) getOrElse Map.empty
     val currentBuild = session
@@ -1620,7 +1570,6 @@ private[sbt] object Load {
       Nil,
       rootEval
     )
-  }
 
   def initialSession(structure: BuildStructure, rootEval: () => Eval): SessionSettings =
     new SessionSettings(
@@ -1632,19 +1581,17 @@ private[sbt] object Load {
       rootEval
     )
 
-  def projectMap(structure: BuildStructure, current: Map[URI, String]): Map[URI, String] = {
+  def projectMap(structure: BuildStructure, current: Map[URI, String]): Map[URI, String] =
     val units = structure.units
     val getRoot = getRootProject(units)
-    def project(uri: URI) = {
+    def project(uri: URI) =
       current
         .get(uri)
         .filter { p =>
           structure.allProjects(uri).map(_.id).contains(p)
         }
         .getOrElse(getRoot(uri))
-    }
     units.keys.map(uri => (uri, project(uri))).toMap
-  }
 
   def defaultEvalOptions: Seq[String] = Nil
 
@@ -1657,31 +1604,28 @@ private[sbt] object Load {
       global: Seq[Setting[?]],
       project: Seq[Setting[?]],
       projectLoaded: ClassLoader => Seq[Setting[?]]
-  ) {
+  ):
     import java.net.URLClassLoader
     private val cache: mutable.Map[String, Seq[Setting[?]]] = mutable.Map.empty
     // Cache based on the underlying URL values of the classloader
     def cachedProjectLoaded(cl: ClassLoader): Seq[Setting[?]] =
-      cl match {
+      cl match
         case cl: URLClassLoader =>
           cache.getOrElseUpdate(classLoaderToHash(Some(cl)), projectLoaded(cl))
         case _ => projectLoaded(cl)
-      }
     private def classLoaderToHash(o: Option[ClassLoader]): String =
-      o match {
+      o match
         case Some(cl: URLClassLoader) =>
           cl.getURLs.toList.toString + classLoaderToHash(Option(cl.getParent))
         case Some(cl: ClassLoader) =>
           cl.toString + classLoaderToHash(Option(cl.getParent))
         case _ => "null"
-      }
-  }
 
   /** Variable to control the indentation of the timing logs. */
   private var timedIndentation: Int = 0
 
   /** Debugging method to time how long it takes to run various compilation tasks. */
-  private[sbt] def timed[T](label: String, log: Logger)(t: => T): T = {
+  private[sbt] def timed[T](label: String, log: Logger)(t: => T): T =
     timedIndentation += 1
     val start = System.nanoTime
     val result = t
@@ -1690,8 +1634,7 @@ private[sbt] object Load {
     val prefix = " " * 2 * timedIndentation
     log.debug(s"$prefix$label took ${elapsed / 1e6}ms")
     result
-  }
-}
+end Load
 
 final case class LoadBuildConfiguration(
     stagingDirectory: File,
@@ -1707,12 +1650,12 @@ final case class LoadBuildConfiguration(
     extraBuilds: Seq[URI],
     converter: MappedFileConverter,
     log: Logger
-) {
+):
   lazy val globalPluginClasspath: Def.Classpath =
     Load.buildPluginClasspath(this, Load.globalPluginClasspath(globalPlugin))
 
-  lazy val detectedGlobalPlugins: DetectedPlugins = {
-    val pluginData = globalPlugin match {
+  lazy val detectedGlobalPlugins: DetectedPlugins =
+    val pluginData = globalPlugin match
       case Some(info) =>
         val data = info.data
         PluginData(
@@ -1731,15 +1674,13 @@ final case class LoadBuildConfiguration(
           Nil
         )
       case None => PluginData(globalPluginClasspath, converter)
-    }
-    val baseDir = globalPlugin match {
+    val baseDir = globalPlugin match
       case Some(x) => x.base
       case _       => stagingDirectory
-    }
     val globalPlugins = Load.loadPluginDefinition(baseDir, this, pluginData)
     globalPlugins.detected
-  }
-}
+  end detectedGlobalPlugins
+end LoadBuildConfiguration
 
 final class IncompatiblePluginsException(msg: String, cause: Throwable)
     extends Exception(msg, cause)
diff --git a/main/src/main/scala/sbt/internal/LogManager.scala b/main/src/main/scala/sbt/internal/LogManager.scala
index 596bd9e4c..a991990d4 100644
--- a/main/src/main/scala/sbt/internal/LogManager.scala
+++ b/main/src/main/scala/sbt/internal/LogManager.scala
@@ -20,7 +20,7 @@ import sbt.util.{ Level, Logger, LoggerContext }
 
 import java.io.PrintWriter
 
-sealed abstract class LogManager {
+sealed abstract class LogManager:
   def apply(
       data: Def.Settings,
       state: State,
@@ -34,17 +34,15 @@ sealed abstract class LogManager {
       task: ScopedKey[?],
       context: LoggerContext
   ): ManagedLogger
-}
 
 /**
  * A functional interface that allows us to preserve binary compatibility
  * for LogManager.defaults with the old log4j variant.
  */
-trait AppenderSupplier {
+trait AppenderSupplier:
   def apply(s: ScopedKey[?]): Seq[Appender]
-}
 
-object LogManager {
+object LogManager:
   import java.util.concurrent.atomic.AtomicInteger
   private val generateId: AtomicInteger = new AtomicInteger
 
@@ -54,23 +52,21 @@ object LogManager {
       data: Def.Settings,
       state: State
   ): (ScopedKey[?], PrintWriter) => ManagedLogger =
-    (task: ScopedKey[?], to: PrintWriter) => {
+    (task: ScopedKey[?], to: PrintWriter) =>
       val context = state.get(Keys.loggerContext).getOrElse(LoggerContext.globalContext)
       val manager: LogManager =
         (task.scope / logManager).get(data) getOrElse defaultManager(state.globalLogging.console)
       manager(data, state, task, to, context)
-    }
 
   def constructBackgroundLog(
       data: Def.Settings,
       state: State,
       context: LoggerContext
   ): (ScopedKey[?]) => ManagedLogger =
-    (task: ScopedKey[?]) => {
+    (task: ScopedKey[?]) =>
       val manager: LogManager =
         (task.scope / logManager).get(data) getOrElse defaultManager(state.globalLogging.console)
       manager.backgroundLog(data, state, task, context)
-    }
 
   def defaultManager(console: ConsoleOut): LogManager =
     withLoggers((_, _) => defaultScreen(console))
@@ -97,7 +93,7 @@ object LogManager {
       backed: PrintWriter => Appender,
       relay: Unit => Appender,
       extra: AppenderSupplier
-  ) extends LogManager {
+  ) extends LogManager:
     def apply(
         data: Def.Settings,
         state: State,
@@ -121,7 +117,7 @@ object LogManager {
         state: State,
         task: ScopedKey[?],
         context: LoggerContext
-    ): ManagedLogger = {
+    ): ManagedLogger =
       val console = ConsoleAppender.safe("bg-" + ConsoleAppender.generateName(), ITerminal.current)
       // Use a channel-aware relay appender so background job log output reaches
       // the originating client even after the spawning task completes and
@@ -131,8 +127,7 @@ object LogManager {
         case Some(_) => new RelayAppender("bg-Relay" + generateId.incrementAndGet, channelName)
         case None    => relay(())
       LogManager.backgroundLog(data, state, task, console, bgRelay, context)
-    }
-  }
+  end DefaultLogManager
 
   // to change from global being the default to overriding, switch the order of state.get and data.get
   def getOr[T](
@@ -154,7 +149,7 @@ object LogManager {
       relay: Appender,
       extra: List[Appender],
       context: LoggerContext,
-  ): ManagedLogger = {
+  ): ManagedLogger =
     val execOpt = state.currentCommand
     val loggerName: String = s"${task.key.label}-${generateId.incrementAndGet}"
     val channelName: Option[String] = execOpt flatMap (_.source map (_.channelName))
@@ -177,32 +172,30 @@ object LogManager {
       backingTrace
     )
     multiLogger(log, config, context)
-  }
+  end defaultLogger
 
   // Return None if the exec is not from console origin.
   def consoleLocally(state: State, console: Appender): Option[Appender] =
-    state.currentCommand match {
+    state.currentCommand match
       case Some(x: Exec) =>
-        x.source match {
+        x.source match
           // TODO: Fix this stringliness
           case Some(x: CommandSource) if x.channelName == ConsoleChannel.defaultName =>
             Option(console)
           case _ => Option(console)
-        }
       case _ => Option(console)
-    }
 
   def defaultTraceLevel(state: State): Int =
-    if (state.interactive) -1 else Int.MaxValue
+    if state.interactive then -1 else Int.MaxValue
 
   def suppressedMessage(
       key: ScopedKey[?],
       state: State
-  ): SuppressedTraceContext => Option[String] = {
+  ): SuppressedTraceContext => Option[String] =
     val display = Project.showContextKey(state)
     def commandBase = "last " + display.show(unwrapStreamsKey(key))
     def command(useFormat: Boolean) =
-      if (useFormat) s"${scala.Console.MAGENTA}$commandBase${scala.Console.RESET}"
+      if useFormat then s"${scala.Console.MAGENTA}$commandBase${scala.Console.RESET}"
       else s"'$commandBase'"
 
     { context =>
@@ -210,12 +203,10 @@ object LogManager {
         s"stack trace is suppressed; run ${command(context.useFormat)} for the full output"
       )
     }
-  }
 
-  def unwrapStreamsKey(key: ScopedKey[?]): ScopedKey[?] = key.scope.task match {
+  def unwrapStreamsKey(key: ScopedKey[?]): ScopedKey[?] = key.scope.task match
     case Select(task) => ScopedKey(key.scope.copy(task = Zero), task)
     case _            => key // should never get here
-  }
 
   def backgroundLog(
       data: Def.Settings,
@@ -225,7 +216,7 @@ object LogManager {
       /* TODO: backed: Appender,*/
       relay: Appender,
       context: LoggerContext,
-  ): ManagedLogger = {
+  ): ManagedLogger =
     val scope = task.scope
     val screenLevel = getOr(logLevel.key, data, scope, state, Level.Info)
     val backingLevel = getOr(persistLogLevel.key, data, scope, state, Level.Debug)
@@ -243,7 +234,7 @@ object LogManager {
     consoleOpt.foreach(a => context.addAppender(loggerName, a -> screenLevel))
     context.addAppender(loggerName, relay -> backingLevel)
     log
-  }
+  end backgroundLog
 
   // TODO: Fix this
   // if global logging levels are not explicitly set, set them from project settings
@@ -265,7 +256,7 @@ object LogManager {
   //     s
   //   }
 
-  def setGlobalLogLevel(s: State, level: Level.Value): State = {
+  def setGlobalLogLevel(s: State, level: Level.Value): State =
     val s1 = s.put(BasicKeys.explicitGlobalLogLevels, true).put(Keys.logLevel.key, level)
     val gl = s1.globalLogging
     LoggerContext.globalContext.clearAppenders(gl.full.name)
@@ -273,7 +264,6 @@ object LogManager {
     LoggerContext.globalContext.addAppender(gl.full.name, consoleAppender -> level)
     LoggerContext.globalContext.addAppender(gl.full.name, gl.backed -> level)
     s1
-  }
 
   // This is the default implementation for the relay appender
   val defaultRelay: Unit => ConsoleAppender = _ => defaultRelayImpl
@@ -287,7 +277,7 @@ object LogManager {
   // construct a Logger that delegates to the global logger, but only holds a weak reference
   //  this is an approximation to the ideal that would invalidate the delegate after loading completes
   private def globalWrapper(s: State): Logger =
-    new Logger {
+    new Logger:
       private val ref = new java.lang.ref.WeakReference(s.globalLogging.full)
       private def slog: Logger =
         Option(ref.get) getOrElse sys.error("Settings logger used after project was loaded.")
@@ -296,5 +286,4 @@ object LogManager {
       override def trace(t: => Throwable) = slog.trace(t)
       override def success(message: => String) = slog.success(message)
       override def log(level: Level.Value, message: => String) = slog.log(level, message)
-    }
-}
+end LogManager
diff --git a/main/src/main/scala/sbt/internal/Output.scala b/main/src/main/scala/sbt/internal/Output.scala
index 4a0c8c21b..1c93cfc8e 100644
--- a/main/src/main/scala/sbt/internal/Output.scala
+++ b/main/src/main/scala/sbt/internal/Output.scala
@@ -23,7 +23,7 @@ import sbt.internal.util.EscHelpers
 
 import sbt.io.IO
 
-object Output {
+object Output:
   final val DefaultTail = "> "
 
   def last(
@@ -42,7 +42,7 @@ object Output {
       streams: Streams,
       patternString: String,
       printLines: Seq[String] => Unit
-  )(using display: Show[ScopedKey[?]]): Unit = {
+  )(using display: Show[ScopedKey[?]]): Unit =
     val pattern = Pattern.compile(patternString)
     val lines = flatLines(lastLines(keys, streams)) { rawLines =>
       rawLines.flatMap { line =>
@@ -51,7 +51,6 @@ object Output {
       }
     }
     printLines(lines)
-  }
 
   def lastGrep(
       file: File,
@@ -61,34 +60,31 @@ object Output {
   ): Unit =
     printLines(grep(tailLines(file, tailDelim), patternString))
 
-  def grep(lines: Seq[String], patternString: String): Seq[String] = {
+  def grep(lines: Seq[String], patternString: String): Seq[String] =
     val pattern = Pattern.compile(patternString)
     lines.flatMap { line =>
       val stripped = EscHelpers.stripColorsAndMoves(line)
       showMatches(pattern)(stripped)
     }
-  }
 
   def flatLines(outputs: Values[Seq[String]])(f: Seq[String] => Seq[String])(using
       display: Show[ScopedKey[?]]
-  ): Seq[String] = {
+  ): Seq[String] =
     val single = outputs.size == 1
     outputs flatMap { case KeyValue(key, lines) =>
       val flines = f(lines)
-      if (!single) bold(display.show(key)) +: flines else flines
+      if !single then bold(display.show(key)) +: flines else flines
     }
-  }
 
   def lastLines(
       keys: Values[Any],
       streams: Streams,
       sid: Option[String] = None
-  ): Values[Seq[String]] = {
+  ): Values[Seq[String]] =
     val outputs = keys map { (kv: KeyValue[?]) =>
       KeyValue(kv.key, lastLines(kv.key, streams, sid))
     }
     outputs.filterNot(_.value.isEmpty)
-  }
 
   def lastLines(key: ScopedKey[?], mgr: Streams, sid: Option[String]): Seq[String] =
     mgr.use(key) { s =>
@@ -107,11 +103,10 @@ object Output {
     headLines(IO.readLines(file).reverse, tailDelim).reverse
 
   @tailrec def headLines(lines: Seq[String], tailDelim: String): Seq[String] =
-    if (lines.isEmpty) lines
-    else {
+    if lines.isEmpty then lines
+    else
       val (first, tail) = lines.span { line =>
         !line.startsWith(tailDelim)
       }
-      if (first.isEmpty) headLines(tail drop 1, tailDelim) else first
-    }
-}
+      if first.isEmpty then headLines(tail drop 1, tailDelim) else first
+end Output
diff --git a/main/src/main/scala/sbt/internal/PluginDiscovery.scala b/main/src/main/scala/sbt/internal/PluginDiscovery.scala
index 134768678..45a0e6fa1 100644
--- a/main/src/main/scala/sbt/internal/PluginDiscovery.scala
+++ b/main/src/main/scala/sbt/internal/PluginDiscovery.scala
@@ -26,20 +26,18 @@ object PluginDiscovery:
    * Relative paths of resources that list top-level modules that are available.
    * Normally, the classes for those modules will be in the same classpath entry as the resource.
    */
-  object Paths {
+  object Paths:
     final val AutoPlugins = "sbt/sbt.autoplugins"
     final val Builds = "sbt/sbt.builds"
-  }
 
   /** Names of top-level modules that subclass sbt plugin-related classes: [[AutoPlugin]], and [[BuildDef]]. */
-  final class DiscoveredNames(val autoPlugins: Seq[String], val builds: Seq[String]) {
+  final class DiscoveredNames(val autoPlugins: Seq[String], val builds: Seq[String]):
     override def toString: String = s"""DiscoveredNames($autoPlugins, $builds)"""
-  }
 
   def emptyDiscoveredNames: DiscoveredNames = new DiscoveredNames(Nil, Nil)
 
   /** Discovers and loads the sbt-plugin-related top-level modules from the classpath and source analysis in `data` and using the provided class `loader`. */
-  def discoverAll(data: PluginData, loader: ClassLoader): DetectedPlugins = {
+  def discoverAll(data: PluginData, loader: ClassLoader): DetectedPlugins =
     def discover[A1: ClassTag](resource: String) =
       binarySourceModules[A1](data, loader, resource)
     import Paths.*
@@ -60,40 +58,36 @@ object PluginDiscovery:
       DetectedAutoPlugin(name, value, sbt.Plugins.hasAutoImportGetter(value, loader))
     }
     new DetectedPlugins(allAutoPlugins, discover[BuildDef](Builds))
-  }
+  end discoverAll
 
   /** Discovers the sbt-plugin-related top-level modules from the provided source `analysis`. */
-  def discoverSourceAll(analysis: CompileAnalysis): DiscoveredNames = {
+  def discoverSourceAll(analysis: CompileAnalysis): DiscoveredNames =
     def discover[T](using classTag: reflect.ClassTag[T]): Seq[String] =
       sourceModuleNames(analysis, classTag.runtimeClass.getName)
     new DiscoveredNames(discover[AutoPlugin], discover[BuildDef])
-  }
 
   // TODO: consider consolidating into a single file, which would make the classpath search 4x faster
   /** Writes discovered module `names` to zero or more files in `dir` as per [[writeDescriptor]] and returns the list of files written. */
-  def writeDescriptors(names: DiscoveredNames, dir: File): Seq[File] = {
+  def writeDescriptors(names: DiscoveredNames, dir: File): Seq[File] =
     import Paths.*
     val files =
       writeDescriptor(names.autoPlugins, dir, AutoPlugins) ::
         writeDescriptor(names.builds, dir, Builds) ::
         Nil
     files.flatMap(_.toList)
-  }
 
   /** Stores the module `names` in `dir / path`, one per line, unless `names` is empty and then the file is deleted and `None` returned. */
-  def writeDescriptor(names: Seq[String], dir: File, path: String): Option[File] = {
+  def writeDescriptor(names: Seq[String], dir: File, path: String): Option[File] =
     val descriptor: File = new File(dir, path)
-    if (names.isEmpty) {
+    if names.isEmpty then
       IO.delete(descriptor)
       None
-    } else {
+    else
       val lines = names.distinct.sorted
       // Do not invalidate timestamp-based downstream caches when the descriptor content is unchanged.
-      if (!descriptor.exists || IO.readLines(descriptor) != lines)
+      if !descriptor.exists || IO.readLines(descriptor) != lines then
         IO.writeLines(descriptor, lines)
       Some(descriptor)
-    }
-  }
 
   /**
    * Discovers the names of top-level modules listed in resources named `resourceName` as per [[binaryModuleNames]] or
@@ -112,16 +106,15 @@ object PluginDiscovery:
     ).distinct
 
   /** Discovers top-level modules in `analysis` that inherit from any of `subclasses`. */
-  def sourceModuleNames(analysis: CompileAnalysis, subclasses: String*): Seq[String] = {
+  def sourceModuleNames(analysis: CompileAnalysis, subclasses: String*): Seq[String] =
     val subclassSet = subclasses.toSet
     val defs = Tests.allDefs(analysis)
     val ds = Discovery(subclassSet, Set.empty)(defs)
     ds.flatMap {
       case (definition, Discovered(subs, _, _, true)) =>
-        if ((subs & subclassSet).isEmpty) Nil else definition.name :: Nil
+        if (subs & subclassSet).isEmpty then Nil else definition.name :: Nil
       case _ => Nil
     }
-  }
 
   /**
    * Obtains the list of modules identified in all resource files `resourceName` from `loader` that are on `classpath`.
@@ -176,14 +169,13 @@ object PluginDiscovery:
       loader: ClassLoader
   ): Seq[(String, A)] =
     try ModuleUtilities.getCheckedObjects[A](names, loader)
-    catch {
+    catch
       case e: ExceptionInInitializerError =>
         val cause = e.getCause
-        if (cause eq null) throw e else throw cause
+        if cause eq null then throw e else throw cause
       case e: LinkageError => incompatiblePlugins(data, e)
-    }
 
-  private def incompatiblePlugins(data: PluginData, t: LinkageError): Nothing = {
+  private def incompatiblePlugins(data: PluginData, t: LinkageError): Nothing =
     val evicted = data.report.toList.flatMap(_.configurations.flatMap(_.evicted))
     val evictedModules = evicted.map { id =>
       (id.organization, id.name)
@@ -191,11 +183,10 @@ object PluginDiscovery:
     val evictedStrings = evictedModules map { (o, n) => o + ":" + n }
     val msgBase = "Binary incompatibility in plugins detected."
     val msgExtra =
-      if (evictedStrings.isEmpty) ""
+      if evictedStrings.isEmpty then ""
       else
         "\nNote that conflicts were resolved for some dependencies:\n\t" + evictedStrings.mkString(
           "\n\t"
         )
     throw new IncompatiblePluginsException(msgBase + msgExtra, t)
-  }
 end PluginDiscovery
diff --git a/main/src/main/scala/sbt/internal/PluginManagement.scala b/main/src/main/scala/sbt/internal/PluginManagement.scala
index e551b3c44..9fc0db162 100644
--- a/main/src/main/scala/sbt/internal/PluginManagement.scala
+++ b/main/src/main/scala/sbt/internal/PluginManagement.scala
@@ -22,7 +22,7 @@ final case class PluginManagement(
     loader: PluginClassLoader,
     initialLoader: ClassLoader,
     context: Context
-) {
+):
   def shift: PluginManagement =
     PluginManagement(
       Set.empty,
@@ -48,8 +48,8 @@ final case class PluginManagement(
     copy(context = Context(globalPluginProject = true, pluginProjectDepth = 0))
   def forPlugin: PluginManagement =
     copy(context = context.copy(pluginProjectDepth = context.pluginProjectDepth + 1))
-}
-object PluginManagement {
+end PluginManagement
+object PluginManagement:
   final case class Context private[sbt] (globalPluginProject: Boolean, pluginProjectDepth: Int)
   val emptyContext: Context = Context(false, 0)
 
@@ -77,13 +77,10 @@ object PluginManagement {
   def keepOverrideInfo(m: ModuleID): ModuleID =
     ModuleID(m.organization, m.name, m.revision).withCrossVersion(m.crossVersion)
 
-  final class PluginClassLoader(p: ClassLoader) extends URLClassLoader(Array(), p) {
+  final class PluginClassLoader(p: ClassLoader) extends URLClassLoader(Array(), p):
     private val urlSet =
       new collection.mutable.HashSet[URI] // remember: don't use hashCode/equals on URL
     def add(urls: Seq[URL]): Unit = synchronized {
-      for (url <- urls)
-        if (urlSet.add(url.toURI))
-          addURL(url)
+      for url <- urls do if urlSet.add(url.toURI) then addURL(url)
     }
-  }
-}
+end PluginManagement
diff --git a/main/src/main/scala/sbt/internal/PluginsDebug.scala b/main/src/main/scala/sbt/internal/PluginsDebug.scala
index 21714dde7..34b13f6f1 100644
--- a/main/src/main/scala/sbt/internal/PluginsDebug.scala
+++ b/main/src/main/scala/sbt/internal/PluginsDebug.scala
@@ -22,46 +22,43 @@ private[sbt] class PluginsDebug(
     val available: List[AutoPlugin],
     val nameToKey: Map[String, AttributeKey[?]],
     val provided: Relation[AutoPlugin, AttributeKey[?]]
-) {
+):
 
   /**
    * The set of [[AutoPlugin]]s that might define a key named `keyName`.
    * Because plugins can define keys in different scopes, this should only be used as a guideline.
    */
-  def providers(keyName: String): Set[AutoPlugin] = nameToKey.get(keyName) match {
+  def providers(keyName: String): Set[AutoPlugin] = nameToKey.get(keyName) match
     case None      => Set.empty
     case Some(key) => provided.reverse(key)
-  }
 
   /** Describes alternative approaches for defining key `keyName` in [[Context]]. */
   def toEnable(keyName: String, context: Context): List[PluginEnable] =
     providers(keyName).toList.map(plugin => pluginEnable(context, plugin))
 
   /** Provides text to suggest how `notFoundKey` can be defined in [[Context]]. */
-  def debug(notFoundKey: String, context: Context): String = {
+  def debug(notFoundKey: String, context: Context): String =
     val (activated, deactivated) = Util.separate(toEnable(notFoundKey, context)) {
       case pa: PluginActivated   => Left(pa)
       case pd: EnableDeactivated => Right(pd)
     }
     val activePrefix =
-      if (activated.isEmpty) ""
-      else
-        s"Some already activated plugins define $notFoundKey: ${activated.mkString(", ")}\n"
+      if activated.isEmpty then ""
+      else s"Some already activated plugins define $notFoundKey: ${activated.mkString(", ")}\n"
     activePrefix + debugDeactivated(notFoundKey, deactivated)
-  }
 
   private def debugDeactivated(
       notFoundKey: String,
       deactivated: Seq[EnableDeactivated]
-  ): String = {
+  ): String =
     val (impossible, possible) = Util.separate(deactivated) {
       case pi: PluginImpossible   => Left(pi)
       case pr: PluginRequirements => Right(pr)
     }
-    if (possible.nonEmpty) {
+    if possible.nonEmpty then
       val explained = possible.map(explainPluginEnable)
       val possibleString =
-        if (explained.lengthCompare(1) > 0)
+        if explained.lengthCompare(1) > 0 then
           explained.zipWithIndex
             .map { (s, i) => s"$i. $s" }
             .mkString(s"Multiple plugins are available that can provide $notFoundKey:\n", "\n", "")
@@ -69,57 +66,55 @@ private[sbt] class PluginsDebug(
           s"$notFoundKey is provided by an available (but not activated) plugin:\n${explained.mkString}"
       def impossiblePlugins = impossible.map(_.plugin.label).mkString(", ")
       val imPostfix =
-        if (impossible.isEmpty) ""
+        if impossible.isEmpty then ""
         else
           s"\n\nThere are other available plugins that provide $notFoundKey, but they are " +
             s"impossible to add: $impossiblePlugins"
       possibleString + imPostfix
-    } else if (impossible.isEmpty) s"No available plugin provides key $notFoundKey."
-    else {
+    else if impossible.isEmpty then s"No available plugin provides key $notFoundKey."
+    else
       val explanations = impossible.map(explainPluginEnable)
       val preamble = s"Plugins are available that could provide $notFoundKey"
       explanations.mkString(s"$preamble, but they are impossible to add:\n\t", "\n\t", "")
-    }
-  }
+    end if
+  end debugDeactivated
 
   /** Text that suggests how to activate [[AutoPlugin]] in [[Context]] if possible and if it is not already activated. */
   def help(plugin: AutoPlugin, context: Context): String =
-    if (context.enabled.contains(plugin)) activatedHelp(plugin)
+    if context.enabled.contains(plugin) then activatedHelp(plugin)
     else deactivatedHelp(plugin, context)
 
-  private def activatedHelp(plugin: AutoPlugin): String = {
+  private def activatedHelp(plugin: AutoPlugin): String =
     val prefix = s"${plugin.label} is activated."
     val keys = provided.forward(plugin)
     val keysString =
-      if (keys.isEmpty) "" else s"\nIt may affect these keys: ${multi(keys.toList.map(_.label))}"
+      if keys.isEmpty then "" else s"\nIt may affect these keys: ${multi(keys.toList.map(_.label))}"
     val configs = plugin.projectConfigurations
     val confsString =
-      if (configs.isEmpty) ""
+      if configs.isEmpty then ""
       else s"\nIt defines these configurations: ${multi(configs.map(_.name))}"
     prefix + keysString + confsString
-  }
 
-  private def deactivatedHelp(plugin: AutoPlugin, context: Context): String = {
+  private def deactivatedHelp(plugin: AutoPlugin, context: Context): String =
     val prefix = s"${plugin.label} is NOT activated."
     val keys = provided.forward(plugin)
     val keysString =
-      if (keys.isEmpty) ""
+      if keys.isEmpty then ""
       else s"\nActivating it may affect these keys: ${multi(keys.toList.map(_.label))}"
     val configs = plugin.projectConfigurations
     val confsString =
-      if (configs.isEmpty) ""
+      if configs.isEmpty then ""
       else s"\nActivating it will define these configurations: ${multi(configs.map(_.name))}"
     val toActivate = explainPluginEnable(pluginEnable(context, plugin))
     s"$prefix$keysString$confsString\n$toActivate"
-  }
 
   private def multi(strs: Seq[String]): String =
-    strs.mkString(if (strs.lengthCompare(4) > 0) "\n\t" else ", ")
-}
+    strs.mkString(if strs.lengthCompare(4) > 0 then "\n\t" else ", ")
+end PluginsDebug
 
-private[sbt] object PluginsDebug {
+private[sbt] object PluginsDebug:
   def helpAll(s: State): String =
-    if (Project.isProjectLoaded(s)) {
+    if Project.isProjectLoaded(s) then
       val extracted = Project.extract(s)
       import extracted.*
 
@@ -128,7 +123,7 @@ private[sbt] object PluginsDebug {
           .sortBy(_.id)
           .map { p =>
             import p.autoPlugins
-            val `s?` = if (autoPlugins.length > 1) "s" else ""
+            val `s?` = if autoPlugins.length > 1 then "s" else ""
 
             new StringBuilder()
               .append(s"  Enabled plugin${`s?`} in ${Highlight.bold(p.id)}:\n")
@@ -142,31 +137,30 @@ private[sbt] object PluginsDebug {
             val autoPlugins = availableAutoPlugins(build)
             val notEnabledPlugins =
               autoPlugins.filter(p => build.projects.forall(!_.autoPlugins.contains(p)))
-            if (notEnabledPlugins.nonEmpty) {
+            if notEnabledPlugins.nonEmpty then
               val message = notEnabledPlugins.map(_.label).sorted.mkString("  ", "\n  ", "")
               "\nPlugins that are loaded to the build but not enabled in any subprojects:\n" + message
-            } else ""
+            else ""
           }
 
-      val buildStrings = for {
-        (uri, build) <- structure.units
-      } yield s"In build ${uri.getPath}:\n${helpBuild(build)}"
+      val buildStrings =
+        for (uri, build) <- structure.units
+        yield s"In build ${uri.getPath}:\n${helpBuild(build)}"
       buildStrings.mkString("\n")
-    } else "No project is currently loaded."
+    else "No project is currently loaded."
 
-  def autoPluginMap(s: State): Map[String, AutoPlugin] = {
+  def autoPluginMap(s: State): Map[String, AutoPlugin] =
     val extracted = Project.extract(s)
     import extracted.*
     structure.units.values.toList
       .flatMap(availableAutoPlugins)
       .map(plugin => (plugin.label, plugin))
       .toMap
-  }
 
   private def availableAutoPlugins(build: LoadedBuildUnit): Seq[AutoPlugin] =
     build.unit.plugins.detected.autoPlugins map { _.value }
 
-  def help(plugin: AutoPlugin, s: State): String = {
+  def help(plugin: AutoPlugin, s: State): String =
     val extracted = Project.extract(s)
     import extracted.*
     def definesPlugin(p: ResolvedProject): Boolean = p.autoPlugins.contains(plugin)
@@ -182,44 +176,42 @@ private[sbt] object PluginsDebug {
       s.log
     )
     lazy val debug = PluginsDebug(context.available)
-    if (!pluginsThisBuild.contains(plugin)) {
+    if !pluginsThisBuild.contains(plugin) then
       val availableInBuilds: List[URI] = perBuild.toList.withFilter(_._2(plugin)).map(_._1)
       val s1 = s"Plugin ${plugin.label} is only available in builds:"
       val s2 = availableInBuilds.mkString("\n\t")
       val s3 =
         s"Switch to a project in one of those builds using `project` and rerun this command for more information."
       s"$s1\n\t$s2\n$s3"
-    } else if (definesPlugin(currentProject)) debug.activatedHelp(plugin)
-    else {
+    else if definesPlugin(currentProject) then debug.activatedHelp(plugin)
+    else
       val thisAggregated =
         BuildUtil.dependencies(structure.units).aggregateTransitive.getOrElse(currentRef, Nil)
       val definedInAggregated = thisAggregated.filter(ref => definesPlugin(projectForRef(ref)))
-      if (definedInAggregated.nonEmpty) {
+      if definedInAggregated.nonEmpty then
         val projectNames = definedInAggregated.map(
           _.project
         ) // TODO: usually in this build, but could technically require the build to be qualified
         val s2 = projectNames.mkString("\n\t")
         s"Plugin ${plugin.label} is not activated on this project, but this project aggregates projects where it is activated:\n\t$s2"
-      } else {
+      else
         val base = debug.deactivatedHelp(plugin, context)
         val aggNote =
-          if (thisAggregated.nonEmpty) "Note: This project aggregates other projects and this"
+          if thisAggregated.nonEmpty then "Note: This project aggregates other projects and this"
           else "Note: This"
         val common = " information is for this project only."
         val helpOther =
           "To see how to activate this plugin for another project, change to the project using `project <name>` and rerun this command."
         s"$base\n$aggNote$common\n$helpOther"
-      }
-    }
-  }
+    end if
+  end help
 
   /** Pre-computes information for debugging plugins. */
-  def apply(available: List[AutoPlugin]): PluginsDebug = {
+  def apply(available: List[AutoPlugin]): PluginsDebug =
     val keyR = definedKeys(available)
     val nameToKey: Map[String, AttributeKey[?]] =
       keyR._2s.toList.map(key => (key.label, key)).toMap
     new PluginsDebug(available, nameToKey, keyR)
-  }
 
   /**
    * The context for debugging a plugin (de)activation.
@@ -288,12 +280,10 @@ private[sbt] object PluginsDebug {
 
   /** Determines how to enable [[AutoPlugin]] in [[Context]]. */
   def pluginEnable(context: Context, plugin: AutoPlugin): PluginEnable =
-    if (context.enabled.contains(plugin))
-      PluginActivated(plugin, context)
-    else
-      enableDeactivated(context, plugin)
+    if context.enabled.contains(plugin) then PluginActivated(plugin, context)
+    else enableDeactivated(context, plugin)
 
-  private def enableDeactivated(context: Context, plugin: AutoPlugin): PluginEnable = {
+  private def enableDeactivated(context: Context, plugin: AutoPlugin): PluginEnable =
     // deconstruct the context
     val initialModel = context.enabled.toSet
     val initial = flatten(context.initial)
@@ -329,8 +319,8 @@ private[sbt] object PluginsDebug {
     //  A non-empty list here cannot be satisfied and is an error.
     val contradictions = minAbsentPlugins & minRequiredPlugins
 
-    if (contradictions.nonEmpty) PluginImpossible(plugin, context, contradictions)
-    else {
+    if contradictions.nonEmpty then PluginImpossible(plugin, context, contradictions)
+    else
       // Plugins that the user has to add to the currently selected plugins in order to enable `plugin`.
       val addToExistingPlugins = minRequiredPlugins -- initialPlugins
 
@@ -360,7 +350,7 @@ private[sbt] object PluginsDebug {
       val minDeactivate =
         minAbsentPlugins.filter(p => Plugins.satisfied(p.requires, incrementalModel))
 
-      val deactivate = for (d <- minDeactivate.toList) yield {
+      val deactivate = for d <- minDeactivate.toList yield
         // removing any one of these plugins will deactivate `d`.  TODO: This is not an especially efficient implementation.
         val removeToDeactivate = plugins(minimalModel(d)) -- minRequiredPlugins
         val newlySelected = !initialModel(d)
@@ -368,7 +358,6 @@ private[sbt] object PluginsDebug {
         // b. suggest excluding `d` to directly deactivate it in any case
         // c. note whether d was already activated (in context.enabled) or is newly selected
         DeactivatePlugin(d, removeToDeactivate, newlySelected)
-      }
 
       PluginRequirements(
         plugin,
@@ -379,8 +368,8 @@ private[sbt] object PluginsDebug {
         willRemove,
         deactivate
       )
-    }
-  }
+    end if
+  end enableDeactivated
 
   private def includeAll[T <: Basic](basic: Set[T]): Plugins = And(basic.toList)
   private def excludeAll(plugins: Set[AutoPlugin]): Plugins =
@@ -403,7 +392,7 @@ private[sbt] object PluginsDebug {
 
   /** String representation of [[PluginEnable]], intended for end users. */
   def explainPluginEnable(ps: PluginEnable): String =
-    ps match {
+    ps match
       case PluginRequirements(
             plugin,
             _,
@@ -413,8 +402,8 @@ private[sbt] object PluginsDebug {
             toBeRemoved,
             deactivate
           ) =>
-        def indent(str: String) = if (str.isEmpty) "" else s"\t$str"
-        def note(str: String) = if (str.isEmpty) "" else s"Note: $str"
+        def indent(str: String) = if str.isEmpty then "" else s"\t$str"
+        def note(str: String) = if str.isEmpty then "" else s"Note: $str"
         val parts =
           indent(excludedError(false /* TODO */, blockingExcludes.toList)) ::
             indent(required(enablingPlugins.toList)) ::
@@ -425,20 +414,18 @@ private[sbt] object PluginsDebug {
         parts.filterNot(_.isEmpty).mkString("\n")
       case PluginImpossible(plugin, _, contradictions) => pluginImpossible(plugin, contradictions)
       case PluginActivated(plugin, _) => s"Plugin ${plugin.label} already activated."
-    }
 
   /**
    * Provides a [[Relation]] between plugins and the keys they potentially define.
    * Because plugins can define keys in different scopes and keys can be overridden, this is not definitive.
    */
-  def definedKeys(available: List[AutoPlugin]): Relation[AutoPlugin, AttributeKey[?]] = {
+  def definedKeys(available: List[AutoPlugin]): Relation[AutoPlugin, AttributeKey[?]] =
     def extractDefinedKeys(ss: Seq[Setting[?]]): Seq[AttributeKey[?]] =
       ss.map(_.key.key)
     def allSettings(p: AutoPlugin): Seq[Setting[?]] =
       p.projectSettings ++ p.buildSettings ++ p.globalSettings
     val empty = Relation.empty[AutoPlugin, AttributeKey[?]]
     available.foldLeft(empty)((r, p) => r + (p, extractDefinedKeys(allSettings(p))))
-  }
 
   private def excludedError(transitive: Boolean, dependencies: List[AutoPlugin]): String =
     str(dependencies)(excludedPluginError(transitive), excludedPluginsError(transitive))
@@ -451,7 +438,7 @@ private[sbt] object PluginsDebug {
         .mkString("\n\t")}"
 
   private def transitiveString(transitive: Boolean) =
-    if (transitive) "(transitive) " else ""
+    if transitive then "(transitive) " else ""
 
   private def required(plugins: List[AutoPlugin]): String =
     str(plugins)(requiredPlugin, requiredPlugins)
@@ -463,11 +450,10 @@ private[sbt] object PluginsDebug {
     s"Required plugins not present:\n\t${plugins.map(_.label).mkString("\n\t")}"
 
   private def str[A](list: List[A])(f: A => String, fs: List[A] => String): String =
-    list match {
+    list match
       case Nil           => ""
       case single :: Nil => f(single)
       case _             => fs(list)
-    }
 
   private def willAdd(base: AutoPlugin, plugins: List[AutoPlugin]): String =
     str(plugins)(willAddPlugin(base), willAddPlugins(base))
@@ -499,33 +485,29 @@ private[sbt] object PluginsDebug {
   private def deactivate1(deactivate: DeactivatePlugin): String =
     s"Need to deactivate ${deactivateString(deactivate)}"
 
-  private def deactivateString(d: DeactivatePlugin): String = {
+  private def deactivateString(d: DeactivatePlugin): String =
     val removePluginsString: String =
-      d.removeOneOf.toList match {
+      d.removeOneOf.toList match
         case Nil      => ""
         case x :: Nil => s" or no longer include $x"
         case xs       => s" or remove one of ${xs.mkString(", ")}"
-      }
     s"${d.plugin.label}: directly exclude it${removePluginsString}"
-  }
 
   private def pluginImpossible(plugin: AutoPlugin, contradictions: Set[AutoPlugin]): String =
     str(contradictions.toList)(pluginImpossible1(plugin), pluginImpossibleN(plugin))
 
-  private def pluginImpossible1(plugin: AutoPlugin)(contradiction: AutoPlugin): String = {
+  private def pluginImpossible1(plugin: AutoPlugin)(contradiction: AutoPlugin): String =
     val s1 = s"There is no way to enable plugin ${plugin.label}."
     val s2 =
       s"It (or its dependencies) requires plugin ${contradiction.label} to both be present and absent."
     val s3 = s"Please report the problem to the plugin's author."
     s"$s1  $s2  $s3"
-  }
 
   private def pluginImpossibleN(
       plugin: AutoPlugin
-  )(contradictions: List[AutoPlugin]): String = {
+  )(contradictions: List[AutoPlugin]): String =
     val s1 = s"There is no way to enable plugin ${plugin.label}."
     val s2 = s"It (or its dependencies) requires these plugins to be both present and absent:"
     val s3 = s"Please report the problem to the plugin's author."
     s"$s1  $s2:\n\t${labels(contradictions).mkString("\n\t")}\n$s3"
-  }
-}
+end PluginsDebug
diff --git a/main/src/main/scala/sbt/internal/PomGenerator.scala b/main/src/main/scala/sbt/internal/PomGenerator.scala
index 7d8cc293e..e493226eb 100644
--- a/main/src/main/scala/sbt/internal/PomGenerator.scala
+++ b/main/src/main/scala/sbt/internal/PomGenerator.scala
@@ -58,6 +58,7 @@ private[sbt] object PomGenerator:
       {makeDependencyManagement(bomDeps)}
       {makeDependencies(regularDeps)}
     </project>
+  end makePom
 
   private def crossVersionDep(dep: ModuleID, scalaInfo: Option[ScalaModuleInfo]): ModuleID =
     val crossFn = CrossVersion(dep, scalaInfo)
@@ -258,13 +259,12 @@ private[sbt] object PomGenerator:
       val base = version.stripSuffix("+").stripSuffix(".")
       val parts = base.split('.')
       if parts.nonEmpty then
-        parts.last.toIntOption.map(_ + 1) match {
+        parts.last.toIntOption.map(_ + 1) match
           case Some(last) =>
             val upper = (parts.init :+ last.toString).mkString(".")
             s"[$base,$upper)"
           case None =>
             version
-        }
       else version
     else if version == "latest.integration" || version == "latest.release" then ""
     else version
diff --git a/main/src/main/scala/sbt/internal/PrettyPrint.scala b/main/src/main/scala/sbt/internal/PrettyPrint.scala
index b0e1955e7..9f5e53147 100644
--- a/main/src/main/scala/sbt/internal/PrettyPrint.scala
+++ b/main/src/main/scala/sbt/internal/PrettyPrint.scala
@@ -8,9 +8,7 @@
 
 package sbt.internal
 
-private[sbt] object PrettyPrint {
-  private[sbt] def indent(any: Any, level: Int): String = {
+private[sbt] object PrettyPrint:
+  private[sbt] def indent(any: Any, level: Int): String =
     val i = " " * level
     any.toString.linesIterator.mkString(i, "\n" + i, "")
-  }
-}
diff --git a/main/src/main/scala/sbt/internal/ProjectNavigation.scala b/main/src/main/scala/sbt/internal/ProjectNavigation.scala
index e9c8cdefe..b2a8d9135 100644
--- a/main/src/main/scala/sbt/internal/ProjectNavigation.scala
+++ b/main/src/main/scala/sbt/internal/ProjectNavigation.scala
@@ -14,7 +14,7 @@ import sbt.internal.util.complete, complete.{ DefaultParsers, Parser }, DefaultP
 import Keys.{ channelProjectCursors, sessionSettings }
 import sbt.ProjectExtra.{ extract, updateCurrent }
 
-object ProjectNavigation {
+object ProjectNavigation:
   def command(s: State): Parser[() => State] =
     if s.get(sessionSettings).isEmpty then failure("No project loaded")
     else (new ProjectNavigation(s)).command
@@ -26,77 +26,71 @@ object ProjectNavigation {
       .orElse(StandardMain.exchange.currentExec.flatMap(_.source).map(_.channelName))
 
   def getChannelCursor(s: State): Option[ProjectRef] =
-    for {
+    for
       channelName <- getChannelName(s)
       cursors <- s.get(channelProjectCursors)
       ref <- cursors.get(channelName)
-    } yield ref
+    yield ref
 
   def setChannelCursor(s: State, ref: ProjectRef): State =
-    getChannelName(s) match {
+    getChannelName(s) match
       case Some(channelName) =>
         val cursors = s.get(channelProjectCursors).getOrElse(Map.empty)
         s.put(channelProjectCursors, cursors.updated(channelName, ref))
       case None => s
-    }
 
   def effectiveCurrentRef(s: State): ProjectRef =
     getChannelCursor(s).getOrElse(
       s.get(sessionSettings).map(_.current).getOrElse(sys.error("Session not initialized"))
     )
-}
+end ProjectNavigation
 
-final class ProjectNavigation(s: State) {
+final class ProjectNavigation(s: State):
   val extracted: Extracted = Project.extract(s)
   import extracted.{ structure, session }
 
   def effectiveCurrentRef: ProjectRef = ProjectNavigation.effectiveCurrentRef(s)
 
-  def setProject(nuri: URI, nid: String): State = {
-    val neval = if (effectiveCurrentRef.build == nuri) session.currentEval else mkEval(nuri)
+  def setProject(nuri: URI, nid: String): State =
+    val neval = if effectiveCurrentRef.build == nuri then session.currentEval else mkEval(nuri)
     Project.updateCurrent(s.put(sessionSettings, session.setCurrent(nuri, nid, neval)))
-  }
 
   def mkEval(nuri: URI): () => Eval = Load.lazyEval(structure.units(nuri).unit)
   def getRoot(uri: URI): String = Load.getRootProject(structure.units)(uri)
 
   def apply(action: Option[ResolvedReference]): State =
-    action match {
+    action match
       case None =>
         show(); s
       case Some(BuildRef(uri))       => changeBuild(uri)
       case Some(ProjectRef(uri, id)) => selectProject(uri, id)
-    }
 
   def show(): Unit =
     s.log.info(s"${effectiveCurrentRef.project} (in build ${effectiveCurrentRef.build})")
 
   def selectProject(uri: URI, to: String): State =
-    if (structure.units(uri).defined.contains(to))
-      setProject(uri, to)
+    if structure.units(uri).defined.contains(to) then setProject(uri, to)
     else
       fail(
         s"Invalid project name '$to' in build $uri (type 'projects' to list available projects)."
       )
 
   def changeBuild(newBuild: URI): State =
-    if (structure.units contains newBuild)
-      setProject(newBuild, getRoot(newBuild))
-    else
-      fail("Invalid build unit '" + newBuild + "' (type 'projects' to list available builds).")
+    if structure.units contains newBuild then setProject(newBuild, getRoot(newBuild))
+    else fail("Invalid build unit '" + newBuild + "' (type 'projects' to list available builds).")
 
-  def fail(msg: String): State = { s.log.error(msg); s.fail }
+  def fail(msg: String): State =
+    s.log.error(msg); s.fail
 
   import Parser.*, complete.Parsers.*
 
-  val parser: Parser[Option[ResolvedReference]] = {
+  val parser: Parser[Option[ResolvedReference]] =
     val reference =
       Act.resolvedReference(structure.index.keyIndex, effectiveCurrentRef.build, success(()))
     val root = token('/' ^^^ rootRef)
     success(None) | some(token(Space) ~> (root | reference))
-  }
 
   def rootRef = ProjectRef(effectiveCurrentRef.build, getRoot(effectiveCurrentRef.build))
 
   val command: Parser[() => State] = Command.applyEffect(parser)(apply)
-}
+end ProjectNavigation
diff --git a/main/src/main/scala/sbt/internal/RelayAppender.scala b/main/src/main/scala/sbt/internal/RelayAppender.scala
index 035ced89b..6042d38ae 100644
--- a/main/src/main/scala/sbt/internal/RelayAppender.scala
+++ b/main/src/main/scala/sbt/internal/RelayAppender.scala
@@ -18,14 +18,12 @@ class RelayAppender(override val name: String, targetChannel: Option[String] = N
       name,
       ConsoleAppender.Properties.from(ConsoleOut.NullConsoleOut, true, true),
       _ => None
-    ) {
+    ):
   def this(name: String) = this(name, None)
 
   lazy val exchange = StandardMain.exchange
-  override def appendLog(level: Level.Value, message: => String): Unit = {
+  override def appendLog(level: Level.Value, message: => String): Unit =
     val event = LogEvent(level = level.toString, message = message)
     targetChannel match
       case Some(ch) => exchange.logMessage(ch, event)
       case None     => exchange.logMessage(event)
-  }
-}
diff --git a/main/src/main/scala/sbt/internal/Resolve.scala b/main/src/main/scala/sbt/internal/Resolve.scala
index df003c76d..4653dcc17 100644
--- a/main/src/main/scala/sbt/internal/Resolve.scala
+++ b/main/src/main/scala/sbt/internal/Resolve.scala
@@ -12,13 +12,13 @@ package internal
 import sbt.internal.util.AttributeKey
 import sbt.ScopeAxis.{ Select, This, Zero }
 
-object Resolve {
+object Resolve:
   def apply(
       index: BuildUtil[?],
       current: ScopeAxis[Reference],
       key: AttributeKey[?],
       mask: ScopeMask,
-  ): Scope => Scope = {
+  ): Scope => Scope =
     val rs = (
       resolveProject(current, mask)
         :: resolveExtra(mask)
@@ -27,31 +27,29 @@ object Resolve {
         :: Nil
     )
     scope => rs.foldLeft(scope)((s, f) => f(s))
-  }
 
   def resolveTask(mask: ScopeMask)(scope: Scope): Scope =
-    if (mask.task) scope
+    if mask.task then scope
     else scope.copy(task = Zero)
 
   def resolveProject(current: ScopeAxis[Reference], mask: ScopeMask)(scope: Scope): Scope =
-    if (mask.project) scope
+    if mask.project then scope
     else scope.copy(project = current)
 
   def resolveExtra(mask: ScopeMask)(scope: Scope): Scope =
-    if (mask.extra) scope
+    if mask.extra then scope
     else scope.copy(extra = Zero)
 
   def resolveConfig[P](index: BuildUtil[P], key: AttributeKey[?], mask: ScopeMask)(
       scope: Scope,
   ): Scope =
-    if (mask.config) scope
-    else {
-      val (resolvedRef, proj) = scope.project match {
+    if mask.config then scope
+    else
+      val (resolvedRef, proj) = scope.project match
         case Zero | This => (None, index.thisRootProject)
         case Select(ref) =>
           val r = index.resolveRef(ref)
           (Some(r), index.projectFor(r))
-      }
       val task = scope.task.toOption
       val keyIndex = index.keyIndex
       val definesKey = (c: ScopeAxis[ConfigKey]) =>
@@ -59,5 +57,4 @@ object Resolve {
       val projectConfigs = index.configurations(proj).map(ck => Select(ck))
       val config: ScopeAxis[ConfigKey] = (Zero +: projectConfigs) find definesKey getOrElse Zero
       scope.copy(config = config)
-    }
-}
+end Resolve
diff --git a/main/src/main/scala/sbt/internal/RetrieveUnit.scala b/main/src/main/scala/sbt/internal/RetrieveUnit.scala
index 28afa476e..29a7fa4fd 100644
--- a/main/src/main/scala/sbt/internal/RetrieveUnit.scala
+++ b/main/src/main/scala/sbt/internal/RetrieveUnit.scala
@@ -14,38 +14,31 @@ import java.net.URI
 import sbt.internal.BuildLoader.ResolveInfo
 import sbt.Resolvers.RemoteVcs
 
-object RetrieveUnit {
-  def apply(info: ResolveInfo): Option[() => File] = {
-    apply(info.uri) match {
+object RetrieveUnit:
+  def apply(info: ResolveInfo): Option[() => File] =
+    apply(info.uri) match
       case Some(RemoteVcs.Svn(_)) => Resolvers.subversion(info)
       case Some(RemoteVcs.Hg(_))  => Resolvers.mercurial(info)
       case Some(RemoteVcs.Git(_)) => Resolvers.git(info)
       case _                      =>
-        info.uri match {
+        info.uri match
           case Scheme("http") | Scheme("https") | Scheme("ftp") => Resolvers.remote(info)
           case Scheme("file")                                   => Resolvers.local(info)
           case _                                                => None
-        }
-    }
-  }
 
-  def apply(uri: URI): Option[RemoteVcs] = {
-    uri match {
+  def apply(uri: URI): Option[RemoteVcs] =
+    uri match
       case Scheme("svn") | Scheme("svn+ssh")   => Some(RemoteVcs.Svn(uri))
       case Scheme("hg")                        => Some(RemoteVcs.Hg(uri))
       case Scheme("git")                       => Some(RemoteVcs.Git(uri))
       case Path(path) if path.endsWith(".git") => Some(RemoteVcs.Git(uri))
       case _                                   => None
-    }
-  }
 
-  object Scheme {
+  object Scheme:
     def unapply(uri: URI) = Option(uri.getScheme)
-  }
 
-  object Path {
+  object Path:
     import RichURI.fromURI
 
     def unapply(uri: URI) = Option(uri.withoutMarkerScheme.getPath)
-  }
-}
+end RetrieveUnit
diff --git a/main/src/main/scala/sbt/internal/RunUtil.scala b/main/src/main/scala/sbt/internal/RunUtil.scala
index fdcb1d51b..a696a5cf8 100644
--- a/main/src/main/scala/sbt/internal/RunUtil.scala
+++ b/main/src/main/scala/sbt/internal/RunUtil.scala
@@ -112,18 +112,16 @@ object RunUtil:
 
   private def termWrapper(canonical: Boolean, echo: Boolean): (() => Unit) => (() => Unit) =
     (f: () => Unit) =>
-      () => {
+      () =>
         val term = ITerminal.get
-        if (!canonical) {
+        if !canonical then
           term.enterRawMode()
-          if (echo) term.setEchoEnabled(echo)
-        } else if (!echo) term.setEchoEnabled(false)
+          if echo then term.setEchoEnabled(echo)
+        else if !echo then term.setEchoEnabled(false)
         try f()
-        finally {
-          if (!canonical) term.exitRawMode()
-          if (!echo) term.setEchoEnabled(true)
-        }
-      }
+        finally
+          if !canonical then term.exitRawMode()
+          if !echo then term.setEchoEnabled(true)
 
   private def getMainClass(value: Option[String]): String =
     value.getOrElse(sys.error("no main class detected"))
@@ -156,6 +154,7 @@ object RunUtil:
       nativeRunInfo = None,
       windowTitle = windowTitle,
     )
+  end mkRunInfo
 
   def defaultRunMainTask(
       products: Initialize[Task[Classpath]],
@@ -217,7 +216,9 @@ object RunUtil:
                 (None, wrapper(() => sr.run(mainClass, cp.files, appArgs, logger).get))
         service.waitForTry(handle).get
         ()
+      end if
     }
+  end defaultRunMainTask
 
   def defaultRunTask(
       products: Initialize[Task[Classpath]],
@@ -277,7 +278,9 @@ object RunUtil:
                 (None, wrapper(() => sr.run(mainClass, cp.files, appArgs, logger).get))
         service.waitForTry(handle).get
         ()
+      end if
     }
+  end defaultRunTask
 
   def bgRunMainTask(
       products: Initialize[Task[Classpath]],
@@ -330,6 +333,7 @@ object RunUtil:
               (None, wrapper(() => sr.run(mainClass, cp.files, appArgs, logger).get))
       }
     }
+  end bgRunMainTask
 
   def bgRunTask(
       products: Initialize[Task[Classpath]],
@@ -381,4 +385,5 @@ object RunUtil:
               (None, wrapper(() => sr.run(mainClass, cp.files, appArgs, logger).get))
       }
     }
+  end bgRunTask
 end RunUtil
diff --git a/main/src/main/scala/sbt/internal/Script.scala b/main/src/main/scala/sbt/internal/Script.scala
index ea27e67c2..0d87f2bcf 100644
--- a/main/src/main/scala/sbt/internal/Script.scala
+++ b/main/src/main/scala/sbt/internal/Script.scala
@@ -24,16 +24,16 @@ import sbt.SlashSyntax0.*
 import sbt.io.{ Hash, IO }
 import scala.annotation.tailrec
 
-object Script {
+object Script:
   final val Name = "script"
   // When shebang is stripped, compiler error line numbers may be off by one for the original file;
   // position mapping could be added in a future improvement (see sbt/sbt#6274).
   /** If the first line is a shebang (#!), drop it so the compiler never sees it. */
   private[internal] def stripShebang(lines: Seq[String]): Seq[String] =
-    if (lines.nonEmpty && lines.head.startsWith("#!")) lines.drop(1) else lines
+    if lines.nonEmpty && lines.head.startsWith("#!") then lines.drop(1) else lines
 
   /** Lines that are not inside any /*** ... */ block (i.e. the executable script body). */
-  private[internal] def scriptBodyLines(file: File): Seq[String] = {
+  private[internal] def scriptBodyLines(file: File): Seq[String] =
     val lines = IO.readLines(file).toIndexedSeq
     // Block(offset, lines): offset = index of /*** line, lines = content between /*** and */ (excl. both).
     // Exclude /*** (off), content (off+1..off+ls.size), and */ (off+1+ls.size).
@@ -41,10 +41,9 @@ object Script {
       case Block(off, ls) => (off until off + 2 + ls.size)
     }.toSet
     lines.indices.filterNot(blockSet).map(lines)
-  }
 
   /** Write a Scala 3 compilable file that wraps the script body in object Main { def main(...) = { ... } }. */
-  private def writeWrappedScript(body: Seq[String], out: File): Unit = {
+  private def writeWrappedScript(body: Seq[String], out: File): Unit =
     val indent = "  "
     val inner = body.map(line => indent + line).mkString("\n")
     val content =
@@ -55,7 +54,6 @@ object Script {
          |}
          |""".stripMargin
     IO.write(out, content)
-  }
 
   lazy val command =
     Command.command(Name) { state =>
@@ -69,11 +67,10 @@ object Script {
       val src = new File(base, "src_managed")
       IO.createDirectory(src)
       // handle any script extension or none
-      val scalaFile = {
+      val scalaFile =
         val dotIndex = scriptArg.lastIndexOf(".")
-        if (dotIndex == -1) scriptArg + ".scala"
+        if dotIndex == -1 then scriptArg + ".scala"
         else scriptArg.substring(0, dotIndex) + ".scala"
-      }
       val script = new File(src, scalaFile)
       val linesWithoutShebang = stripShebang(IO.readLines(scriptFile))
       IO.write(script, linesWithoutShebang.mkString("", "\n", "\n"))
@@ -92,16 +89,16 @@ object Script {
       }
       val scriptBaseName = script.getName.stripSuffix(".scala")
       val scriptAsSource = (Compile / sources) := Def.uncached {
-        if (ScalaArtifacts.isScala3(scalaVersion.value)) scriptMain :: Nil else script :: Nil
+        if ScalaArtifacts.isScala3(scalaVersion.value) then scriptMain :: Nil else script :: Nil
       }
       val asScript = scalacOptions := Def.uncached {
         val extra =
-          if (ScalaArtifacts.isScala3(scalaVersion.value)) Nil
+          if ScalaArtifacts.isScala3(scalaVersion.value) then Nil
           else Seq("-Xscript", scriptBaseName)
         scalacOptions.value ++ extra
       }
       val scriptMainClass = (run / mainClass) := Def.uncached {
-        if (ScalaArtifacts.isScala3(scalaVersion.value)) Some("Main") else Some(scriptBaseName)
+        if ScalaArtifacts.isScala3(scalaVersion.value) then Some("Main") else Some(scriptBaseName)
       }
       val scriptSettings = Seq(
         asScript,
@@ -124,12 +121,12 @@ object Script {
     }
 
   final case class Block(offset: Int, lines: Seq[String])
-  def blocks(file: File): Seq[Block] = {
+  def blocks(file: File): Seq[Block] =
     val lines = IO.readLines(file).toIndexedSeq
     @tailrec
     def blocks(b: Block, acc: List[Block]): List[Block] =
-      if (b.lines.isEmpty) acc.reverse
-      else {
+      if b.lines.isEmpty then acc.reverse
+      else
         val (dropped, blockToEnd) = b.lines.span { line =>
           !line.startsWith(BlockStart)
         }
@@ -138,13 +135,10 @@ object Script {
         }
         val offset = b.offset + dropped.length
         blocks(Block(offset + block.length, remaining), Block(offset, block.drop(1)) :: acc)
-      }
     blocks(Block(0, lines), Nil)
-  }
   val BlockStart = "/***"
   val BlockEnd = "*/"
-  def fail(s: State, msg: String): State = {
+  def fail(s: State, msg: String): State =
     System.err.println(msg)
     s.fail
-  }
-}
+end Script
diff --git a/main/src/main/scala/sbt/internal/SessionSettings.scala b/main/src/main/scala/sbt/internal/SessionSettings.scala
index eb5b140f3..05217f973 100755
--- a/main/src/main/scala/sbt/internal/SessionSettings.scala
+++ b/main/src/main/scala/sbt/internal/SessionSettings.scala
@@ -36,7 +36,7 @@ final case class SessionSettings(
     append: SessionMap,
     rawAppend: Seq[Setting[?]],
     currentEval: () => Eval
-) {
+):
 
   assert(
     currentProject contains currentBuild,
@@ -94,11 +94,10 @@ final case class SessionSettings(
   private def modify(
       map: SessionMap,
       onSeq: Seq[SessionSetting] => Seq[SessionSetting],
-  ): SessionMap = {
+  ): SessionMap =
     val cur = current
     map.updated(cur, onSeq(map.getOrElse(cur, Nil)))
-  }
-}
+end SessionSettings
 
 object SessionSettings:
 
@@ -136,30 +135,28 @@ object SessionSettings:
    */
   def withSettings(s: State)(f: SessionSettings => State): State =
     val extracted = Project.extract(s)
-    if (extracted.session.append.isEmpty) {
+    if extracted.session.append.isEmpty then
       s.log.info("No session settings defined.")
       s
-    } else f(extracted.session)
+    else f(extracted.session)
 
   /** Adds `s` to a strings when needed.    Maybe one day we'll care about non-english languages. */
-  def pluralize(size: Int, of: String) = size.toString + (if (size == 1) of else (of + "s"))
+  def pluralize(size: Int, of: String) = size.toString + (if size == 1 then of else (of + "s"))
 
   /** Checks to see if any session settings are being discarded and issues a warning. */
-  def checkSession(newSession: SessionSettings, oldState: State): Unit = {
+  def checkSession(newSession: SessionSettings, oldState: State): Unit =
     val oldSettings = oldState.get(Keys.sessionSettings).toList.flatMap(_.append).flatMap(_._2)
-    if (newSession.append.isEmpty && oldSettings.nonEmpty)
+    if newSession.append.isEmpty && oldSettings.nonEmpty then
       oldState.log.warn(
         "Discarding " + pluralize(
           oldSettings.size,
           " session setting"
         ) + ".  Use 'session save' to persist session settings."
       )
-  }
 
-  def removeRanges[T](in: Seq[T], ranges: Seq[(Int, Int)]): Seq[T] = {
+  def removeRanges[T](in: Seq[T], ranges: Seq[(Int, Int)]): Seq[T] =
     val asSet = ranges.foldLeft(Set.empty[Int]) { case (s, (hi, lo)) => s ++ (hi to lo) }
-    in.zipWithIndex.flatMap { (t, index) => if (asSet(index + 1)) Nil else t :: Nil }
-  }
+    in.zipWithIndex.flatMap { (t, index) => if asSet(index + 1) then Nil else t :: Nil }
 
   /**
    * Removes settings from the current session, by range.
@@ -179,10 +176,9 @@ object SessionSettings:
   def saveAllSettings(s: State): State = saveSomeSettings(s)(_ => true)
 
   /** Saves the session settings to disk for the current project. */
-  def saveSettings(s: State): State = {
+  def saveSettings(s: State): State =
     val current = Project.session(s).current
     saveSomeSettings(s)(_ == current)
-  }
 
   /**
    * Saves session settings to disk if they match the filter.
@@ -193,11 +189,10 @@ object SessionSettings:
   def saveSomeSettings(s: State)(include: ProjectRef => Boolean): State =
     withSettings(s) { session =>
       val newSettings =
-        for ((ref, settings) <- session.append if settings.nonEmpty && include(ref)) yield {
+        for (ref, settings) <- session.append if settings.nonEmpty && include(ref) yield
           val (news, olds) =
             writeSettings(ref, settings.toList, session.original, Project.structure(s))
           (ref -> news, olds)
-        }
       val (newAppend, newOriginal) = newSettings.unzip
       val newSession = session.copy(append = newAppend.toMap, original = newOriginal.flatten.toSeq)
       reapply(newSession.copy(original = newSession.mergeSettings, append = Map.empty), s)
@@ -208,7 +203,7 @@ object SessionSettings:
       settings: List[SessionSetting],
       original: Seq[Setting[?]],
       structure: BuildStructure
-  ): (Seq[SessionSetting], Seq[Setting[?]]) = {
+  ): (Seq[SessionSetting], Seq[Setting[?]]) =
     val project =
       Project.getProject(pref, structure).getOrElse(sys.error("Invalid project reference " + pref))
     val writeTo: File = BuildPaths
@@ -221,16 +216,15 @@ object SessionSettings:
     val (inFile, other, _) =
       original.reverse.foldLeft((List[Setting[?]](), List[Setting[?]](), Set.empty[ScopedKey[?]])) {
         case ((in, oth, keys), s) =>
-          s.pos match {
+          s.pos match
             case RangePosition(`path`, _) if !keys.contains(s.key) => (s :: in, oth, keys + s.key)
             case _                                                 => (in, s :: oth, keys)
-          }
       }
 
     val (_, oldShifted, replace) = inFile.foldLeft((0, List[Setting[?]](), Seq[SessionSetting]())) {
       case ((offs, olds, repl), s) =>
         val RangePosition(_, r @ LineRange(start, end)) = s.pos: @unchecked
-        settings.find(_._1.key == s.key) match {
+        settings.find(_._1.key == s.key) match
           case Some(ss @ (ns, newLines)) if !ns.init.dependencies.contains(ns.key) =>
             val shifted = ns.withPos(
               RangePosition(
@@ -242,12 +236,11 @@ object SessionSettings:
           case _ =>
             val shifted = s.withPos(RangePosition(path, r.shift(-offs)))
             (offs, shifted :: olds, repl)
-        }
     }
     val newSettings = settings diff replace
     val oldContent = IO.readLines(writeTo)
     val exist = SbtRefactorings.applySessionSettings(oldContent, replace)
-    val adjusted = if (newSettings.nonEmpty && needsTrailingBlank(exist)) exist :+ "" else exist
+    val adjusted = if newSettings.nonEmpty && needsTrailingBlank(exist) then exist :+ "" else exist
     val lines = adjusted ++ newSettings.flatMap(x => x._2 :+ "")
     IO.writeLines(writeTo, lines)
     val (newWithPos, _) = newSettings.foldLeft((List[SessionSetting](), adjusted.size + 1)) {
@@ -256,7 +249,7 @@ object SessionSettings:
         ((s.withPos(RangePosition(path, LineRange(line, endLine))), newLines) :: acc, endLine + 1)
     }
     (newWithPos.reverse, other ++ oldShifted)
-  }
+  end writeSettings
 
   def needsTrailingBlank(lines: Seq[String]) =
     lines.nonEmpty && !lines.takeRight(1).exists(_.trim.isEmpty)
@@ -264,10 +257,9 @@ object SessionSettings:
   /** Prints all the user-defined SessionSettings (not raw) to System.out. */
   def printAllSettings(s: State): State =
     withSettings(s) { session =>
-      for ((ref, settings) <- session.append if settings.nonEmpty) {
+      for (ref, settings) <- session.append if settings.nonEmpty do
         println("In " + Reference.display(ref))
         printSettings(settings)
-      }
       s
     }
 
@@ -280,7 +272,7 @@ object SessionSettings:
 
   /** Prints all the passed in session settings */
   def printSettings(settings: Seq[SessionSetting]): Unit =
-    for (((_, stringRep), index) <- settings.zipWithIndex)
+    for ((_, stringRep), index) <- settings.zipWithIndex do
       println("  " + (index + 1) + ". " + stringRep.mkString("\n"))
 
   def Help =
@@ -352,9 +344,9 @@ save, save-all
 
   /** The raw implementation of the session command. */
   def command(s: State): Parser[() => State] = Command.applyEffect(parser) {
-    case p: Print  => if (p.all) printAllSettings(s) else printSettings(s)
-    case v: Save   => if (v.all) saveAllSettings(s) else saveSettings(s)
-    case c: Clear  => if (c.all) clearAllSettings(s) else clearSettings(s)
+    case p: Print  => if p.all then printAllSettings(s) else printSettings(s)
+    case v: Save   => if v.all then saveAllSettings(s) else saveSettings(s)
+    case c: Clear  => if c.all then clearAllSettings(s) else clearSettings(s)
     case r: Remove => removeSettings(s, r.ranges)
   }
 end SessionSettings
diff --git a/main/src/main/scala/sbt/internal/SettingCompletions.scala b/main/src/main/scala/sbt/internal/SettingCompletions.scala
index 0eaa223ac..4f93bc636 100644
--- a/main/src/main/scala/sbt/internal/SettingCompletions.scala
+++ b/main/src/main/scala/sbt/internal/SettingCompletions.scala
@@ -32,14 +32,14 @@ private[sbt] class SetResult(
 )
 
 /** Defines methods for implementing the `set` command. */
-private[sbt] object SettingCompletions {
+private[sbt] object SettingCompletions:
 
   /**
    * Implementation of the `set every` command.  Each setting in the provided `settings` sequence will be applied in all scopes,
    * overriding all previous definitions of the underlying AttributeKey.
    * The settings injected by this method cannot be later persisted by the `session save` command.
    */
-  def setAll(extracted: Extracted, settings: Seq[Setting[?]]): SetResult = {
+  def setAll(extracted: Extracted, settings: Seq[Setting[?]]): SetResult =
     import extracted.{ *, given }
     val r = Project.relation(extracted.structure, true)
     val allDefs = Def
@@ -60,7 +60,7 @@ private[sbt] object SettingCompletions {
         case Zero | This => true
         case Select(_)   => user == existing
 
-    def rescope[T](setting: Setting[T]): Seq[Setting[?]] = {
+    def rescope[T](setting: Setting[T]): Seq[Setting[?]] =
       val akey = setting.key.key
       val userScope = setting.key.scope
       val baseScope = Scope(
@@ -79,17 +79,16 @@ private[sbt] object SettingCompletions {
         then Seq((d.scope / SettingKey(akey)) := global.value)
         else Nil
       }
-    }
     val redefined = settings.flatMap(x => rescope(x))
     val session = extracted.session.appendRaw(redefined)
     setResult(session, r, redefined)
-  }
+  end setAll
 
   /**
    * Implementation of the `set` command that will reload the current project with `settings`
    *  appended to the current settings.
    */
-  def setThis(extracted: Extracted, settings: Seq[Def.Setting[?]], arg: String): SetResult = {
+  def setThis(extracted: Extracted, settings: Seq[Def.Setting[?]], arg: String): SetResult =
     import extracted.{ *, given }
     val append =
       Load.transformSettings(Load.projectScope(currentRef), currentRef.build, rootProject, settings)
@@ -100,50 +99,42 @@ private[sbt] object SettingCompletions {
       summon[Show[ScopedKey[?]]],
     )
     setResult(newSession, r, append)
-  }
 
   private def setResult(
       session: SessionSettings,
       r: Relation[ScopedKey[?], ScopedKey[?]],
       redefined: Seq[Setting[?]],
-  )(using Show[ScopedKey[?]]): SetResult = {
+  )(using Show[ScopedKey[?]]): SetResult =
     val redefinedKeys = redefined.map(_.key).toSet
     val affectedKeys = redefinedKeys.flatMap(r.reverse)
     def summary(verbose: Boolean): String = setSummary(redefinedKeys, affectedKeys, verbose)
     new SetResult(session, summary(true), summary(false))
-  }
 
   private def setSummary(
       redefined: Set[ScopedKey[?]],
       affected: Set[ScopedKey[?]],
       verbose: Boolean,
-  )(using display: Show[ScopedKey[?]]): String = {
+  )(using display: Show[ScopedKey[?]]): String =
     val QuietLimit = 3
     def strings(in: Set[ScopedKey[?]]): Seq[String] = in.toSeq.map(sk => display.show(sk)).sorted
     def lines(in: Seq[String]): (String, Boolean) =
-      if (in.isEmpty)
-        ("no settings or tasks.", false)
-      else if (verbose)
-        (in.mkString("\n\t", "\n\t", "\n"), false)
-      else
-        quietList(in)
-    def quietList(in: Seq[String]): (String, Boolean) = {
+      if in.isEmpty then ("no settings or tasks.", false)
+      else if verbose then (in.mkString("\n\t", "\n\t", "\n"), false)
+      else quietList(in)
+    def quietList(in: Seq[String]): (String, Boolean) =
       val (first, last) = in.splitAt(QuietLimit)
-      if (last.isEmpty) (first.mkString(", "), false)
-      else {
+      if last.isEmpty then (first.mkString(", "), false)
+      else
         val s = first.take(QuietLimit - 1).mkString("", ", ", " and " + last.size + " others.")
         (s, true)
-      }
-    }
-    if (redefined.isEmpty) "No settings or tasks were redefined."
-    else {
+    if redefined.isEmpty then "No settings or tasks were redefined."
+    else
       val (redef, trimR) = lines(strings(redefined))
       val (used, trimU) = lines(strings(affected))
-      val details = if (trimR || trimU) "\n\tRun `last` for details." else ""
-      val valuesString = if (redefined.size == 1) "value" else "values"
+      val details = if trimR || trimU then "\n\tRun `last` for details." else ""
+      val valuesString = if redefined.size == 1 then "value" else "values"
       s"Defining ${redef}\nThe new ${valuesString} will be used by ${used}${details}"
-    }
-  }
+  end setSummary
 
   /**
    * Parser that provides tab completion for the main argument to the `set` command.
@@ -157,33 +148,31 @@ private[sbt] object SettingCompletions {
       settings: Def.Settings,
       rawKeyMap: Map[String, AttributeKey[?]],
       context: ResolvedProject,
-  ): Parser[String] = {
+  ): Parser[String] =
     val keyMap: Map[String, AttributeKey[?]] =
       rawKeyMap.map { (k, v) => (keyScalaID(k), v) }.toMap
-    val full = for {
+    val full = for
       defineKey <- scopedKeyParser(keyMap, settings, context)
       a <- assign(defineKey)
       _ <- valueParser(defineKey, a)
-    } yield () // parser is currently only for completion and the parsed data structures are not used
+    yield () // parser is currently only for completion and the parsed data structures are not used
 
     matched(full) | any.+.string
-  }
 
   /** Parser for a Scope+AttributeKey (ScopedKey). */
   def scopedKeyParser(
       keyMap: Map[String, AttributeKey[?]],
       settings: Def.Settings,
       context: ResolvedProject
-  ): Parser[ScopedKey[?]] = {
+  ): Parser[ScopedKey[?]] =
     val cutoff = KeyRanks.MainCutoff
     val keyCompletions = fixedCompletions { (seen, level) =>
       completeKey(seen, keyMap, level, cutoff, 10).toSet
     }
     val keyID: Parser[AttributeKey[?]] = scalaID(keyMap, "key")
     val keyParser = token(keyID, keyCompletions)
-    for (key <- keyParser; scope <- scopeParser(key, settings, context))
-      yield ScopedKey(scope, key)
-  }
+    for key <- keyParser; scope <- scopeParser(key, settings, context)
+    yield ScopedKey(scope, key)
 
   /** Parser for the `in` method name that slightly augments the naive completion to give a hint of the purpose of `in`. */
   val inParser = tokenDisplay(Space ~> InMethod, s"${InMethod} <scope>")
@@ -192,17 +181,15 @@ private[sbt] object SettingCompletions {
    * Parser for the initialization expression for the assignment method `assign` on the key `sk`.
    * `scopedKeyP` is used to parse and complete the input keys for an initialization that depends on other keys.
    */
-  def valueParser(sk: ScopedKey[?], assign: Assign.Value): Parser[Seq[ScopedKey[?]]] = {
+  def valueParser(sk: ScopedKey[?], assign: Assign.Value): Parser[Seq[ScopedKey[?]]] =
     val fullTypeString = keyTypeString(sk.key)
-    val typeString = if (assignNoAppend(assign)) fullTypeString else "..."
-    if (assign == Assign.Update) {
+    val typeString = if assignNoAppend(assign) then fullTypeString else "..."
+    if assign == Assign.Update then
       val function = "{(prev: " + typeString + ") => /*" + typeString + "*/ }"
       token(OptSpace ~ function) ^^^ Nil
-    } else {
+    else
       val value = "/* value of type " + typeString + " */"
       token(Space ~ value) ^^^ Nil
-    }
-  }
 
   /**
    * Parser for a Scope for a `key` given the current project `context` and evaluated `settings`.
@@ -213,26 +200,24 @@ private[sbt] object SettingCompletions {
       key: AttributeKey[?],
       settings: Def.Settings,
       context: ResolvedProject
-  ): Parser[Scope] = {
+  ): Parser[Scope] =
     val definedScopes = settings.keys.collect { case sk if sk.key == key => sk.scope }
     scope(settings.scopes.toSeq, definedScopes.toSeq, context)
-  }
 
   private def scope(
       allScopes: Seq[Scope],
       definedScopes: Seq[Scope],
       context: ResolvedProject,
-  ): Parser[Scope] = {
+  ): Parser[Scope] =
     def axisParser[T](
         axis: Scope => ScopeAxis[T],
         name: T => String,
         description: T => Option[String],
         label: String,
-    ): Parser[ScopeAxis[T]] = {
-      def getChoice(s: Scope): Seq[(String, T)] = axis(s) match {
+    ): Parser[ScopeAxis[T]] =
+      def getChoice(s: Scope): Seq[(String, T)] = axis(s) match
         case Select(t) => (name(t), t) :: Nil
         case _         => Nil
-      }
       def getChoices(scopes: Seq[Scope]): Map[String, T] = scopes.flatMap(getChoice).toMap
       val definedChoices: Set[String] =
         definedScopes.flatMap(s => axis(s).toOption.map(name)).toSet
@@ -244,7 +229,6 @@ private[sbt] object SettingCompletions {
         inParser ~> token(Space) ~> token(scalaID(fullChoices, label), completions),
         This,
       )
-    }
     val configurations: Map[String, Configuration] =
       context.configurations.map(c => (configScalaID(c.name), c)).toMap
     val configParser = axisParser[ConfigKey](
@@ -258,10 +242,10 @@ private[sbt] object SettingCompletions {
     val nonGlobal = (configParser ~ taskParser) map { (c, t) => Scope(This, c, t, Zero) }
     val global = inParser ~> token((Space ~ GlobalID) ^^^ Global)
     global | nonGlobal
-  }
+  end scope
 
   /** Parser for the assignment method (such as `:=`) for defining `key`. */
-  def assign(key: ScopedKey[?]): Parser[Assign.Value] = {
+  def assign(key: ScopedKey[?]): Parser[Assign.Value] =
     val completions = fixedCompletions { (seen, _) =>
       completeAssign(seen, key).toSet
     }
@@ -274,38 +258,35 @@ private[sbt] object SettingCompletions {
         )
         .map(Assign.withName)
     token(Space) ~> token(optionallyQuoted(identifier), completions)
-  }
 
   private def fixedCompletions(f: (String, Int) => Set[Completion]): TokenCompletions =
     TokenCompletions.fixed((s, l) => Completions(f(s, l)))
 
-  private def scalaID[T](keyMap: Map[String, T], label: String): Parser[T] = {
+  private def scalaID[T](keyMap: Map[String, T], label: String): Parser[T] =
     val identifier = Act
       .filterStrings(ScalaID, keyMap.keySet, label)
       .map(keyMap)
     optionallyQuoted(identifier)
-  }
 
   /** Produce a new parser that allows the input accepted by `p` to be quoted in backticks. */
   def optionallyQuoted[T](p: Parser[T]): Parser[T] =
     (Backtick.? ~ p) flatMap { (quote, id) =>
-      if (quote.isDefined) Backtick.? ^^^ id else success(id)
+      if quote.isDefined then Backtick.? ^^^ id else success(id)
     }
 
   /**
    * Completions for an assignment method for `key` given the tab completion `level` and existing partial string `seen`.
    * This will filter possible assignment methods based on the underlying type of `key`, so that only `<<=` is shown for input tasks, for example.
    */
-  def completeAssign(seen: String, key: ScopedKey[?]): Seq[Completion] = {
+  def completeAssign(seen: String, key: ScopedKey[?]): Seq[Completion] =
     val allowed: Iterable[Assign.Value] =
-      if (appendable(key.key)) Assign.values
+      if appendable(key.key) then Assign.values
       else assignNoAppend
     val applicable = allowed.toSeq.flatMap { a =>
       val s = a.toString
       if s.startsWith(seen) then (s, a) :: Nil else Nil
     }
     completeDescribed(seen, true, applicable)(assignDescription)
-  }
 
   def completeKey(
       seen: String,
@@ -330,31 +311,28 @@ private[sbt] object SettingCompletions {
 
   def completeSelectDescribed[T](seen: String, level: Int, all: Map[String, T], detailLimit: Int)(
       description: T => Option[String]
-  )(prominent: (String, T) => Boolean): Seq[Completion] = {
+  )(prominent: (String, T) => Boolean): Seq[Completion] =
     val applicable = all.toSeq.filter { case (k, _) => k.startsWith(seen) }
     val prominentOnly = applicable filter { (k, v) => prominent(k, v) }
 
     val showAll = (level >= 3) || (level == 2 && prominentOnly.lengthCompare(
       detailLimit
     ) <= 0) || prominentOnly.isEmpty
-    val showKeys = if (showAll) applicable else prominentOnly
+    val showKeys = if showAll then applicable else prominentOnly
     val showDescriptions = (level >= 2) || showKeys.lengthCompare(detailLimit) <= 0
     completeDescribed(seen, showDescriptions, showKeys)(s => description(s).toList.mkString)
-  }
   def completeDescribed[T](seen: String, showDescriptions: Boolean, in: Seq[(String, T)])(
       description: T => String
-  ): Seq[Completion] = {
+  ): Seq[Completion] =
     def appendString(id: String): String = id.stripPrefix(seen) + " "
-    if (in.isEmpty) Nil
-    else if (showDescriptions) {
+    if in.isEmpty then Nil
+    else if showDescriptions then
       val withDescriptions = in map { (id, key) => (id, description(key)) }
       val padded = CommandUtil.aligned("", "   ", withDescriptions)
       padded.lazyZip(in).map { case (line, (id, _)) =>
         Completion.tokenDisplay(append = appendString(id), display = line + "\n")
       }
-    } else
-      in map { case (id, _) => Completion.tokenDisplay(display = id, append = appendString(id)) }
-  }
+    else in map { case (id, _) => Completion.tokenDisplay(display = id, append = appendString(id)) }
 
   /**
    * Transforms the hyphenated key label `k` into camel-case and quotes it with backticks if it is a Scala keyword.
@@ -389,21 +367,19 @@ private[sbt] object SettingCompletions {
   final val InMethod = "in"
 
   /** Assignment methods that may be called on a setting or task. */
-  object Assign extends Enumeration {
+  object Assign extends Enumeration:
     val AppendValue = Value("+=")
     val AppendValues = Value("++=")
     val Define = Value(":=")
     val Update = Value("~=")
-  }
   import Assign.*
 
   /** Returns the description associated with the provided assignment method. */
-  def assignDescription(a: Assign.Value): String = a match {
+  def assignDescription(a: Assign.Value): String = a match
     case AppendValue  => "append value"
     case AppendValues => "append values"
     case Define       => "define value, overwriting any existing value"
     case Update       => "transform existing value"
-  }
 
   /** The assignment methods except for the ones that append. */
   val assignNoAppend: Set[Assign.Value] = Set(Define, Update)
@@ -418,4 +394,4 @@ private[sbt] object SettingCompletions {
     classOf[Long],
     classOf[String]
   )
-}
+end SettingCompletions
diff --git a/main/src/main/scala/sbt/internal/SettingGraph.scala b/main/src/main/scala/sbt/internal/SettingGraph.scala
index 1a7b7a1de..f7cc657d3 100644
--- a/main/src/main/scala/sbt/internal/SettingGraph.scala
+++ b/main/src/main/scala/sbt/internal/SettingGraph.scala
@@ -16,19 +16,19 @@ import Def.{ ScopedKey, compiled, flattenLocals }
 import sbt.ProjectExtra.scopedKeyData
 import sbt.io.IO
 
-object SettingGraph {
+object SettingGraph:
   def apply(structure: BuildStructure, basedir: File, scoped: ScopedKey[?], generation: Int)(using
       display: Show[ScopedKey[?]]
-  ): SettingGraph = {
+  ): SettingGraph =
     val cMap = flattenLocals(
       compiled(structure.settings, false)(using structure.delegates, structure.scopeLocal, display)
     )
-    def loop(scoped: ScopedKey[?], generation: Int): SettingGraph = {
+    def loop(scoped: ScopedKey[?], generation: Int): SettingGraph =
       val data = Project.scopedKeyData(structure, scoped)
       val definedIn = data.map(d => display.show(d.definingKey))
-      val depends = cMap.get(scoped) match {
-        case Some(c) => c.dependencies.toSet; case None => Set.empty
-      }
+      val depends = cMap.get(scoped) match
+        case Some(c) => c.dependencies.toSet;
+        case None    => Set.empty
       // val related = cMap.keys.filter(k => k.key == key && k.scope != scope)
       // val reverse = reverseDependencies(cMap, scoped)
 
@@ -42,10 +42,9 @@ object SettingGraph {
           loop(x, generation + 1)
         }
       )
-    }
     loop(scoped, generation)
-  }
-}
+  end apply
+end SettingGraph
 
 case class SettingGraph(
     name: String,
@@ -54,7 +53,7 @@ case class SettingGraph(
     description: Option[String],
     basedir: File,
     depends: Set[SettingGraph]
-) {
+):
   def dataString: String =
     data map { d =>
       d.settingValue map {
@@ -69,9 +68,9 @@ case class SettingGraph(
     (x: SettingGraph) => s"${x.definedIn getOrElse { "" }} = ${x.dataString}",
     defaultWidth
   )
-}
+end SettingGraph
 
-object Graph {
+object Graph:
   // [info] foo
   // [info]   +-bar
   // [info]   | +-baz
@@ -82,32 +81,31 @@ object Graph {
       children: A => Seq[A],
       display: A => String,
       maxColumn: Int
-  ): String = {
+  ): String =
     val twoSpaces = " " + " " // prevent accidentally being converted into a tab
     def limitLine(s: String): String =
-      if (s.length > maxColumn) s.slice(0, maxColumn - 2) + ".."
+      if s.length > maxColumn then s.slice(0, maxColumn - 2) + ".."
       else s
     def insertBar(s: String, at: Int): String =
-      if (at < s.length)
+      if at < s.length then
         s.slice(0, at) +
-          (s(at).toString match {
+          (s(at).toString match
             case " " => "|"
-            case x   => x
-          }) +
+            case x   => x) +
           s.slice(at + 1, s.length)
       else s
     // Owned by toAsciiLines; grows monotonically over one render.
     import scala.collection.mutable
     val visited = mutable.Set.empty[A]
-    def toAsciiLines(node: A, level: Int, parents: Set[A]): Vector[String] = {
-      val prefix = if (level == 0) "" else "+-"
-      if (parents contains node) // cycle
+    def toAsciiLines(node: A, level: Int, parents: Set[A]): Vector[String] =
+      val prefix = if level == 0 then "" else "+-"
+      if parents contains node then // cycle
         Vector(limitLine((twoSpaces * level) + "#-" + display(node) + " (cycle)"))
-      else if (visited contains node)
+      else if visited contains node then
         // `prefix` is always "+-" here in practice (root can't re-enter),
         // but mirror the level-0 form for symmetry.
         Vector(limitLine((twoSpaces * level) + prefix + display(node) + " (*)"))
-      else {
+      else
         visited += node
         val line = limitLine((twoSpaces * level) + prefix + display(node))
         val cs = Vector(children(node)*)
@@ -120,13 +118,13 @@ object Graph {
               insertBar(_, 2 * (level + 1))
             }
           case (lines, pos) =>
-            if (lines.last.trim != "") lines ++ Vector(twoSpaces * (level + 1))
+            if lines.last.trim != "" then lines ++ Vector(twoSpaces * (level + 1))
             else lines
         }
         line +: withBar
-      }
-    }
+      end if
+    end toAsciiLines
 
     toAsciiLines(top, 0, Set.empty).mkString("\n")
-  }
-}
+  end toAscii
+end Graph
diff --git a/main/src/main/scala/sbt/internal/ShutdownHooks.scala b/main/src/main/scala/sbt/internal/ShutdownHooks.scala
index 6bd53982c..8cff5e91b 100644
--- a/main/src/main/scala/sbt/internal/ShutdownHooks.scala
+++ b/main/src/main/scala/sbt/internal/ShutdownHooks.scala
@@ -13,36 +13,31 @@ import java.util.concurrent.atomic.{ AtomicBoolean, AtomicInteger }
 
 import scala.util.control.NonFatal
 
-private[sbt] object ShutdownHooks extends AutoCloseable {
+private[sbt] object ShutdownHooks extends AutoCloseable:
   private val idGenerator = new AtomicInteger(0)
   private val hooks = new ConcurrentHashMap[Int, () => Unit]
   private val ranHooks = new AtomicBoolean(false)
-  private val thread = new Thread("shutdown-hooks-run-all") {
+  private val thread = new Thread("shutdown-hooks-run-all"):
     override def run(): Unit = runAll()
-  }
   private val runtime = Runtime.getRuntime
   runtime.addShutdownHook(thread)
-  private[sbt] def add[R](task: () => R): AutoCloseable = {
+  private[sbt] def add[R](task: () => R): AutoCloseable =
     val id = idGenerator.getAndIncrement()
     hooks.put(
       id,
       () =>
-        try {
+        try
           task()
           ()
-        } catch {
+        catch
           case NonFatal(e) =>
             System.err.println(s"Caught exception running shutdown hook: $e")
             e.printStackTrace(System.err)
-        }
     )
     () => Option(hooks.remove(id)).foreach(_.apply())
-  }
-  private def runAll(): Unit = if (ranHooks.compareAndSet(false, true)) {
+  private def runAll(): Unit = if ranHooks.compareAndSet(false, true) then
     hooks.forEachValue(runtime.availableProcessors.toLong, (_: () => Unit).apply())
-  }
-  override def close(): Unit = {
+  override def close(): Unit =
     runtime.removeShutdownHook(thread)
     runAll()
-  }
-}
+end ShutdownHooks
diff --git a/main/src/main/scala/sbt/internal/SysProp.scala b/main/src/main/scala/sbt/internal/SysProp.scala
index e8ecea51a..bee4731a0 100644
--- a/main/src/main/scala/sbt/internal/SysProp.scala
+++ b/main/src/main/scala/sbt/internal/SysProp.scala
@@ -29,12 +29,11 @@ object SysProp:
   def booleanOpt(name: String): Option[Boolean] =
     strOpt(name).flatMap(parseBoolean)
   private def parseBoolean(value: String): Option[Boolean] =
-    value.toLowerCase(Locale.ENGLISH) match {
+    value.toLowerCase(Locale.ENGLISH) match
       case "1" | "always" | "true" => Some(true)
       case "0" | "never" | "false" => Some(false)
       case "auto"                  => None
       case _                       => None
-    }
 
   def getOrFalse(name: String): Boolean = booleanOpt(name).getOrElse(false)
   def getOrTrue(name: String): Boolean = booleanOpt(name).getOrElse(true)
@@ -45,37 +44,25 @@ object SysProp:
       .orElse(sys.env.get(name.toUpperCase(Locale.ENGLISH).replace('.', '_')))
 
   def long(name: String, default: Long): Long =
-    sys.props.get(name) match {
+    sys.props.get(name) match
       case Some(str) =>
-        try {
-          str.toLong
-        } catch {
-          case NonFatal(_) => default
-        }
+        try str.toLong
+        catch case NonFatal(_) => default
       case _ => default
-    }
 
   def int(name: String, default: Int): Int =
-    sys.props.get(name) match {
+    sys.props.get(name) match
       case Some(str) =>
-        try {
-          str.toInt
-        } catch {
-          case NonFatal(_) => default
-        }
+        try str.toInt
+        catch case NonFatal(_) => default
       case _ => default
-    }
 
   def double(name: String, default: Double): Double =
-    sys.props.get(name) match {
+    sys.props.get(name) match
       case Some(str) =>
-        try {
-          str.toDouble
-        } catch {
-          case NonFatal(_) => default
-        }
+        try str.toDouble
+        catch case NonFatal(_) => default
       case _ => default
-    }
 
   // System property style:
   //   1. use sbt. prefix
@@ -150,12 +137,11 @@ object SysProp:
   def supershellThreshold: FiniteDuration = long("sbt.supershell.threshold", 100L).millis
   def supershellBlankZone: Int = int("sbt.supershell.blankzone", 1)
 
-  def defaultUseCoursier: Boolean = {
+  def defaultUseCoursier: Boolean =
     val coursierOpt = booleanOpt("sbt.coursier")
     val ivyOpt = booleanOpt("sbt.ivy")
     val notIvyOpt = ivyOpt map { !_ }
     coursierOpt.orElse(notIvyOpt).getOrElse(true)
-  }
 
   def banner: Boolean = getOrTrue("sbt.banner")
 
@@ -169,7 +155,7 @@ object SysProp:
   def taskTimingsThreshold: Long = long("sbt.task.timings.threshold", 0L)
   def taskTimingsOmitPaths: Boolean = getOrFalse("sbt.task.timings.omit.paths")
   def taskTimingsUnit: (String, Int) =
-    System.getProperty("sbt.task.timings.unit", "ms") match {
+    System.getProperty("sbt.task.timings.unit", "ms") match
       case "ns" => ("ns", 0)
       case "us" => ("µs", 3)
       case "ms" => ("ms", 6)
@@ -177,7 +163,6 @@ object SysProp:
       case x    =>
         System.err.println(s"Unknown sbt.task.timings.unit: $x.\nUsing milliseconds.")
         ("ms", 6)
-    }
 
   def gcMonitor: Boolean = getOrTrue("sbt.gc.monitor")
   def gcWindow: FiniteDuration = int("sbt.gc.monitor.window", 10).seconds
@@ -185,14 +170,12 @@ object SysProp:
 
   /** Generate build.properties if missing. */
   def genBuildProps: Boolean =
-    booleanOpt("sbt.genbuildprops") match {
+    booleanOpt("sbt.genbuildprops") match
       case Some(x) => x
       case None    =>
-        booleanOpt("sbt.skip.version.write") match {
+        booleanOpt("sbt.skip.version.write") match
           case Some(skip) => !skip
           case None       => true
-        }
-    }
 
   def onChangedBuildSource: WatchBuildSourceOption =
     val sysPropKey = "sbt.build.onchange"
@@ -233,28 +216,25 @@ object SysProp:
   /**
    * Operating system specific cache directory, similar to Coursier cache.
    */
-  def globalLocalCache: File = {
+  def globalLocalCache: File =
     val appName = "sbt"
     def propCacheDir: Option[File] = sys.props.get("sbt.global.localcache").map(file)
     def propCacheDir2: Option[File] =
-      sys.props.get(BuildPaths.GlobalBaseProperty) match {
+      sys.props.get(BuildPaths.GlobalBaseProperty) match
         case Some(base) => Some(file(base) / "cache")
         case _          => None
-      }
     def envCacheDir: Option[File] = sys.env.get("SBT_LOCAL_CACHE").map(file)
     def windowsCacheDir: Option[File] =
-      sys.env.get("LOCALAPPDATA") match {
+      sys.env.get("LOCALAPPDATA") match
         case Some(app) if Util.isWindows => Some(file(app) / appName)
         case _                           => None
-      }
     def macCacheDir: Option[File] =
-      if (Util.isMac) Some(home / "Library" / "Caches" / appName)
+      if Util.isMac then Some(home / "Library" / "Caches" / appName)
       else None
     def linuxCache: File =
-      sys.env.get("XDG_CACHE_HOME") match {
+      sys.env.get("XDG_CACHE_HOME") match
         case Some(cache) => file(cache) / appName
         case _           => home / ".cache" / appName
-      }
     def baseCache: File =
       propCacheDir
         .orElse(propCacheDir2)
@@ -263,41 +243,38 @@ object SysProp:
         .orElse(macCacheDir)
         .getOrElse(linuxCache)
     baseCache.getAbsoluteFile / "v2"
-  }
+  end globalLocalCache
 
   lazy val sbtCredentialsEnv: Option[Credentials] =
     sys.env.get("SBT_CREDENTIALS").map(raw => new Credentials.FileCredentials(new File(raw)))
 
   def sonatypeCredentalsEnv: Option[Credentials] =
-    for {
+    for
       username <- sys.env.get("SONATYPE_USERNAME")
       password <- sys.env.get("SONATYPE_PASSWORD")
-    } yield Credentials(
+    yield Credentials(
       "Sonatype Nexus Repository Manager",
       sona.Sona.host,
       username,
       password
     )
 
-  private[sbt] def setSwovalTempDir(): Unit = {
+  private[sbt] def setSwovalTempDir(): Unit =
     val _ = getOrUpdateSwovalTmpDir(
       runtimeDirectory.resolve("swoval").toString
     )
-  }
-  private[sbt] def setIpcSocketTempDir(): Unit = {
+  private[sbt] def setIpcSocketTempDir(): Unit =
     val _ = getOrUpdateIpcSocketTmpDir(
       runtimeDirectory.resolve("ipcsocket").toString
     )
-  }
   private lazy val getOrUpdateSwovalTmpDir: String => String =
     getOrUpdateSysProp("swoval.tmpdir")(_)
   private lazy val getOrUpdateIpcSocketTmpDir: String => String =
     getOrUpdateSysProp("sbt.ipcsocket.tmpdir")(_)
-  private def getOrUpdateSysProp(key: String)(value: String): String = {
+  private def getOrUpdateSysProp(key: String)(value: String): String =
     val newVal = sys.props.getOrElse(key, value)
     sys.props += (key -> newVal)
     newVal
-  }
 
   /**
    * This returns a temporary directory that is friendly to macOS, Linux,
@@ -307,12 +284,11 @@ object SysProp:
    * A deterministic hash is appended in the directory name as "/tmp/.sbt1234ABCD/"
    * to avoid collision between multiple users in a shared server environment.
    */
-  private def runtimeDirectory: Path = {
+  private def runtimeDirectory: Path =
     val hashValue =
       java.lang.Long.toHexString(HashUtil.farmHash(home.toString.getBytes("UTF-8")))
     val halfhash = hashValue.take(8)
     Paths
       .get(sys.env.getOrElse("XDG_RUNTIME_DIR", sys.props("java.io.tmpdir")))
       .resolve(s".sbt$halfhash")
-  }
 end SysProp
diff --git a/main/src/main/scala/sbt/internal/TaskName.scala b/main/src/main/scala/sbt/internal/TaskName.scala
index 840c0bcca..d06d5d66f 100644
--- a/main/src/main/scala/sbt/internal/TaskName.scala
+++ b/main/src/main/scala/sbt/internal/TaskName.scala
@@ -12,7 +12,7 @@ package internal
 import Def.{ displayFull, ScopedKey }
 import Keys.taskDefinitionKey
 
-private[sbt] object TaskName {
+private[sbt] object TaskName:
   def name(node: Task[?]): String = definedName(node).getOrElse(anonymousName(node))
   def definedName(node: Task[?]): Option[String] =
     node.name.orElse(transformNode(node).map(displayFull))
@@ -20,4 +20,3 @@ private[sbt] object TaskName {
     "<anon-" + System.identityHashCode(node).toHexString + ">"
   def transformNode(node: Task[?]): Option[ScopedKey[?]] =
     node.get(taskDefinitionKey)
-}
diff --git a/main/src/main/scala/sbt/internal/TaskProgress.scala b/main/src/main/scala/sbt/internal/TaskProgress.scala
index c1f54c733..ea4f0fdb4 100644
--- a/main/src/main/scala/sbt/internal/TaskProgress.scala
+++ b/main/src/main/scala/sbt/internal/TaskProgress.scala
@@ -31,7 +31,7 @@ private[sbt] class TaskProgress(
     configNameToIdent: String => String = Scope.guessConfigIdent
 ) extends AbstractTaskExecuteProgress(configNameToIdent)
     with ExecuteProgress
-    with AutoCloseable {
+    with AutoCloseable:
   private val lastTaskCount = new AtomicInteger(0)
   private val reportLoop = AtomicCloseable[AutoCloseable]()
   private val active = new ConcurrentHashMap[TaskId[?], AutoCloseable]
@@ -41,96 +41,87 @@ private[sbt] class TaskProgress(
   private val pending = new java.util.Vector[java.util.concurrent.Future[?]]
   private val closed = new AtomicBoolean(false)
   private def schedule[R](duration: FiniteDuration, recurring: Boolean)(f: => R): AutoCloseable =
-    if (!closed.get) {
+    if !closed.get then
       val cancelled = new AtomicBoolean(false)
-      val runnable: Runnable = () => {
-        if (!cancelled.get) {
+      val runnable: Runnable = () =>
+        if !cancelled.get then
           try Util.ignoreResult(f)
-          catch { case _: InterruptedException => }
-        }
-      }
+          catch
+            case _: InterruptedException =>
       val delay = duration.toMillis
-      try {
+      try
         val future =
-          if (recurring)
+          if recurring then
             scheduler.scheduleAtFixedRate(runnable, delay, delay, TimeUnit.MILLISECONDS)
           else scheduler.schedule(runnable, delay, TimeUnit.MILLISECONDS)
         pending.add(future)
         () => Util.ignoreResult(future.cancel(true))
-      } catch {
+      catch
         case e: RejectedExecutionException =>
           logger.trace(e)
           () => ()
-      }
-    } else {
+    else
       logger.debug("tried to call schedule on closed TaskProgress")
       () => ()
-    }
   private val executor =
     Executors.newSingleThreadExecutor(r => new Thread(r, "sbt-task-progress-report-thread"))
-  override def close(): Unit = if (closed.compareAndSet(false, true)) {
+  override def close(): Unit = if closed.compareAndSet(false, true) then
     reportLoop.close()
     pending.forEach(f => Util.ignoreResult(f.cancel(true)))
     pending.clear()
     scheduler.shutdownNow()
     executor.shutdownNow()
-    if (
-      !executor.awaitTermination(30, TimeUnit.SECONDS) ||
+    if !executor.awaitTermination(30, TimeUnit.SECONDS) ||
       !scheduler.awaitTermination(30, TimeUnit.SECONDS)
-    ) {
+    then
       scala.Console.err.println("timed out closing the executor of supershell")
       throw new TimeoutException
-    }
-  }
 
   override protected def clearTimings: Boolean = true
   override def initial(): Unit = ()
 
-  private def doReport(): Unit = {
-    val runnable: Runnable = () => {
-      if (nextReport.get.isOverdue()) {
-        report()
-      }
-    }
+  private def doReport(): Unit =
+    val runnable: Runnable = () => if nextReport.get.isOverdue() then report()
     Util.ignoreResult(pending.add(executor.submit(runnable)))
-  }
   override def beforeWork(task: TaskId[?]): Unit =
-    if (!closed.get) {
+    if !closed.get then
       super.beforeWork(task)
       reportLoop.setIfEmpty(schedule(sleepDuration, recurring = true)(doReport()))
-    } else {
-      logger.debug(s"called beforeWork for ${taskName(task)} after task progress was closed")
-    }
+    else logger.debug(s"called beforeWork for ${taskName(task)} after task progress was closed")
 
   override def afterReady(task: TaskId[?]): Unit =
-    if (!closed.get) {
-      try {
-        Util.ignoreResult(executor.submit((() => {
-          if (skipReportTasks.contains(getShortName(task))) {
-            lastTaskCount.set(-1) // force a report for remote clients
-            report()
-          } else
-            Util.ignoreResult(active.put(task, schedule(threshold, recurring = false)(doReport())))
-        }): Runnable))
-      } catch { case _: RejectedExecutionException => }
-    } else {
-      logger.debug(s"called afterReady for ${taskName(task)} after task progress was closed")
-    }
+    if !closed.get then
+      try
+        Util.ignoreResult(
+          executor.submit(
+            (
+                () =>
+                  if skipReportTasks.contains(getShortName(task)) then
+                    lastTaskCount.set(-1) // force a report for remote clients
+                    report()
+                  else
+                    Util.ignoreResult(
+                      active.put(task, schedule(threshold, recurring = false)(doReport()))
+                    )
+            ): Runnable
+          )
+        )
+      catch
+        case _: RejectedExecutionException =>
+    else logger.debug(s"called afterReady for ${taskName(task)} after task progress was closed")
   override def stop(): Unit = {}
 
   override def afterCompleted[A](task: TaskId[A], result: Result[A]): Unit =
-    active.remove(task) match {
+    active.remove(task) match
       case null =>
       case a    =>
         a.close()
-        if (exceededThreshold(task, threshold)) report()
-    }
+        if exceededThreshold(task, threshold) then report()
 
-  override def afterAllCompleted(results: RMap[TaskId, Result]): Unit = {
+  override def afterAllCompleted(results: RMap[TaskId, Result]): Unit =
     reportLoop.close()
     // send an empty progress report to clear out the previous report
     appendProgress(ProgressEvent("Info", Vector(), Some(lastTaskCount.get), None, None))
-  }
   private val skipReportTasks =
     Set(
       "installSbtn",
@@ -152,13 +143,13 @@ private[sbt] class TaskProgress(
   )
   private def appendProgress(event: ProgressEvent): Unit =
     StandardMain.exchange.updateProgress(event)
-  private def report(): Unit = {
+  private def report(): Unit =
     val (currentTasks, skip) = filter(timings(active.keySet, threshold.toMicros))
     val ltc = lastTaskCount.get
-    if (currentTasks.nonEmpty || ltc != 0) {
+    if currentTasks.nonEmpty || ltc != 0 then
       val currentTasksCount = currentTasks.size
-      def event(tasks: Vector[(TaskId[?], Long)]): ProgressEvent = {
-        if (tasks.nonEmpty) nextReport.set(Deadline.now + sleepDuration)
+      def event(tasks: Vector[(TaskId[?], Long)]): ProgressEvent =
+        if tasks.nonEmpty then nextReport.set(Deadline.now + sleepDuration)
         // Sort by elapsed seconds (rounded down), then by name for stability.
         // Without rounding, microsecond jitter causes tasks with similar start times
         // to swap positions on every refresh, making the display hard to read. See #5466.
@@ -185,31 +176,28 @@ private[sbt] class TaskProgress(
           None,
           Some(skip)
         )
-      }
+      end event
       lastTaskCount.set(currentTasksCount)
       appendProgress(event(currentTasks))
-    }
-  }
+    end if
+  end report
 
-  private def getShortName(task: TaskId[?]): String = {
+  private def getShortName(task: TaskId[?]): String =
     val name = taskName(task)
-    name.lastIndexOf('/') match {
+    name.lastIndexOf('/') match
       case -1 => name
       case i  =>
         var j = i + 1
-        while (name(j) == ' ') j += 1
+        while name(j) == ' ' do j += 1
         name.substring(j)
-    }
 
-  }
   private def filter(
       tasks: Vector[(TaskId[?], Long)]
-  ): (Vector[(TaskId[?], Long)], Boolean) = {
+  ): (Vector[(TaskId[?], Long)], Boolean) =
     tasks.foldLeft((Vector.empty[(TaskId[?], Long)], false)) {
       case ((tasks, skip), pair @ (t, _)) =>
         val shortName = getShortName(t)
         val newSkip = skip || skipReportTasks.contains(shortName)
-        if (hiddenTasks.contains(shortName)) (tasks, newSkip) else (tasks :+ pair, newSkip)
+        if hiddenTasks.contains(shortName) then (tasks, newSkip) else (tasks :+ pair, newSkip)
     }
-  }
-}
+end TaskProgress
diff --git a/main/src/main/scala/sbt/internal/TaskSequential.scala b/main/src/main/scala/sbt/internal/TaskSequential.scala
index 1cfab1155..110c63d5d 100644
--- a/main/src/main/scala/sbt/internal/TaskSequential.scala
+++ b/main/src/main/scala/sbt/internal/TaskSequential.scala
@@ -14,7 +14,7 @@ import Def.*
 /**
  * This trait injected to `Def` object to provide `sequential` functions for tasks.
  */
-trait TaskSequential {
+trait TaskSequential:
   def sequential[B](last: Initialize[Task[B]]): Initialize[Task[B]] =
     sequential(Nil, last)
   def sequential[A0, B](
@@ -758,26 +758,24 @@ trait TaskSequential {
       last
     )
 
-  def sequential[B](tasks: Seq[Initialize[Task[B]]]): Initialize[Task[B]] = {
+  def sequential[B](tasks: Seq[Initialize[Task[B]]]): Initialize[Task[B]] =
     val initTasks: Seq[Initialize[Task[B]]] = tasks.init
     val lastTask: Initialize[Task[B]] = tasks.last
     sequential(initTasks.map(unitTask), lastTask)
-  }
 
   def sequential[B](
       tasks: Seq[Initialize[Task[Unit]]],
       last: Initialize[Task[B]]
   ): Initialize[Task[B]] =
-    tasks.toList match {
+    tasks.toList match
       case Nil     => Def.task { last.value }
       case x :: xs =>
         Def.task { Def.unit(x.value) }.flatMapTask { case _ =>
           sequential(xs, last)
         }
-    }
   private def unitTask[A](task: Initialize[Task[A]]): Initialize[Task[Unit]] =
     Def.task {
       Def.unit(task.value)
       ()
     }
-}
+end TaskSequential
diff --git a/main/src/main/scala/sbt/internal/TaskTimings.scala b/main/src/main/scala/sbt/internal/TaskTimings.scala
index e405d679c..fae3a20d2 100644
--- a/main/src/main/scala/sbt/internal/TaskTimings.scala
+++ b/main/src/main/scala/sbt/internal/TaskTimings.scala
@@ -24,65 +24,57 @@ import sbt.util.{ Level, Logger }
  */
 private[sbt] final class TaskTimings(reportOnShutdown: Boolean, logger: Logger)
     extends AbstractTaskExecuteProgress
-    with ExecuteProgress {
+    with ExecuteProgress:
   @deprecated("Use the constructor that takes an sbt.util.Logger parameter.", "1.3.3")
   def this(reportOnShutdown: Boolean) =
     this(
       reportOnShutdown,
-      new Logger {
+      new Logger:
         override def trace(t: => Throwable): Unit = {}
         override def success(message: => String): Unit = {}
         override def log(level: Level.Value, message: => String): Unit =
           ConsoleOut.systemOut.println(message)
-      }
     )
   private var start = 0L
   private val threshold = SysProp.taskTimingsThreshold
   private val omitPaths = SysProp.taskTimingsOmitPaths
   private val (unit, divider) = SysProp.taskTimingsUnit
 
-  if (reportOnShutdown) {
+  if reportOnShutdown then
     start = System.nanoTime
     addShutdownHandler(() => report())
-  }
 
-  override def initial(): Unit = {
-    if (!reportOnShutdown)
-      start = System.nanoTime
-  }
+  override def initial(): Unit =
+    if !reportOnShutdown then start = System.nanoTime
 
   override def afterReady(task: TaskId[?]): Unit = ()
   override def afterCompleted[T](task: TaskId[T], result: Result[T]): Unit = ()
   override def afterAllCompleted(results: RMap[TaskId, Result]): Unit =
-    if (!reportOnShutdown) {
-      report()
-    }
+    if !reportOnShutdown then report()
 
   override def stop(): Unit = ()
 
   private val reFilePath = raw"\{[^}]+\}".r
 
-  private def report() = {
+  private def report() =
     val total = divide(System.nanoTime - start)
     logger.info(s"Total time: $total $unit")
     val times = timingsByName.toSeq
       .sortBy(_._2.get)
       .reverse
       .map { (name, time) =>
-        (if (omitPaths) reFilePath.replaceFirstIn(name, "") else name, divide(time.get))
+        (if omitPaths then reFilePath.replaceFirstIn(name, "") else name, divide(time.get))
       }
       .filter { _._2 > threshold }
-    if (times.size > 0) {
+    if times.size > 0 then
       val maxTaskNameLength = times.map { _._1.length }.max
       val maxTime = times.map { _._2 }.max.toString.length
       times.foreach { (taskName, time) =>
         logger.info(s"  ${taskName.padTo(maxTaskNameLength, ' ')}: ${""
             .padTo(maxTime - time.toString.length, ' ')}$time $unit")
       }
-    }
-  }
 
   private def divide(time: Long) = (1L to divider.toLong).fold(time) { (a, b) =>
     a / 10L
   }
-}
+end TaskTimings
diff --git a/main/src/main/scala/sbt/internal/TaskTraceEvent.scala b/main/src/main/scala/sbt/internal/TaskTraceEvent.scala
index ef591f939..3ff023a6d 100644
--- a/main/src/main/scala/sbt/internal/TaskTraceEvent.scala
+++ b/main/src/main/scala/sbt/internal/TaskTraceEvent.scala
@@ -22,7 +22,7 @@ import sjsonnew.support.scalajson.unsafe.CompactPrinter
  * as Chrome Trace Event Format.
  * This class is activated by adding -Dsbt.traces=true to the JVM options.
  */
-private[sbt] final class TaskTraceEvent extends AbstractTaskExecuteProgress with ExecuteProgress {
+private[sbt] final class TaskTraceEvent extends AbstractTaskExecuteProgress with ExecuteProgress:
   import AbstractTaskExecuteProgress.Timer
   private var start = 0L
   private val console = ConsoleOut.systemOut
@@ -36,13 +36,10 @@ private[sbt] final class TaskTraceEvent extends AbstractTaskExecuteProgress with
   start = System.nanoTime
   ShutdownHooks.add(() => report())
 
-  private def report() = {
-    if (anyTimings) {
-      writeTraceEvent()
-    }
-  }
+  private def report() =
+    if anyTimings then writeTraceEvent()
 
-  private def writeTraceEvent(): Unit = {
+  private def writeTraceEvent(): Unit =
     // import java.time.{ ZonedDateTime, ZoneOffset }
     // import java.time.format.DateTimeFormatter
     // val fileName = "build-" + ZonedDateTime
@@ -50,29 +47,27 @@ private[sbt] final class TaskTraceEvent extends AbstractTaskExecuteProgress with
     //   .format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HHmmss")) + ".trace"
     val fileName = "build.trace"
     val tracesDirectory = (new File("target").getAbsoluteFile) / "traces"
-    if (!tracesDirectory.exists) IO.createDirectory(tracesDirectory)
+    if !tracesDirectory.exists then IO.createDirectory(tracesDirectory)
     else ()
     val outFile = tracesDirectory / fileName
     val trace = Files.newBufferedWriter(outFile.toPath)
-    try {
+    try
       trace.append("""{"traceEvents": [""")
-      def durationEvent(name: String, cat: String, t: Timer): String = {
+      def durationEvent(name: String, cat: String, t: Timer): String =
         val sb = new java.lang.StringBuilder(name.length + 2)
         CompactPrinter.print(new JString(name), sb)
         s"""{"name": ${sb.toString}, "cat": "$cat", "ph": "X", "ts": ${(t.startMicros)}, "dur": ${(t.durationMicros)}, "pid": 0, "tid": "${t.threadId}"}"""
-      }
       val entryIterator = currentTimings
-      while (entryIterator.hasNext) {
+      while entryIterator.hasNext do
         val (key, value) = entryIterator.next()
         trace.append(durationEvent(taskName(key), "task", value))
-        if (entryIterator.hasNext) trace.append(",")
-      }
+        if entryIterator.hasNext then trace.append(",")
       trace.append("]}")
       ()
-    } finally {
+    finally
       trace.close()
       try console.println(s"wrote $outFile")
-      catch { case _: java.nio.channels.ClosedChannelException => }
-    }
-  }
-}
+      catch
+        case _: java.nio.channels.ClosedChannelException =>
+  end writeTraceEvent
+end TaskTraceEvent
diff --git a/main/src/main/scala/sbt/internal/TestCommand.scala b/main/src/main/scala/sbt/internal/TestCommand.scala
index 59daf172c..45f3d9871 100644
--- a/main/src/main/scala/sbt/internal/TestCommand.scala
+++ b/main/src/main/scala/sbt/internal/TestCommand.scala
@@ -143,5 +143,8 @@ object TestCommand:
           patterns ++ (if frameworkOptions.nonEmpty then Seq("--") ++ frameworkOptions else Nil)
         val taskStr = s"testSelected ${testSelectedArgs.mkString(" ")}"
         taskStr :: state
+      end if
+    end if
+  end runTestOnly
 
 end TestCommand
diff --git a/main/src/main/scala/sbt/internal/VcsUriFragment.scala b/main/src/main/scala/sbt/internal/VcsUriFragment.scala
index 4443dc0d3..3b93d97b9 100644
--- a/main/src/main/scala/sbt/internal/VcsUriFragment.scala
+++ b/main/src/main/scala/sbt/internal/VcsUriFragment.scala
@@ -9,24 +9,21 @@
 package sbt
 package internal
 
-private[sbt] object VcsUriFragment {
+private[sbt] object VcsUriFragment:
 
-  def validate(fragment: String): Unit = {
-    if (fragment == null)
-      throw new IllegalArgumentException("VCS URI fragment must not be null")
-    if (fragment.isEmpty)
+  def validate(fragment: String): Unit =
+    if fragment == null then throw new IllegalArgumentException("VCS URI fragment must not be null")
+    if fragment.isEmpty then
       throw new IllegalArgumentException("VCS URI fragment must not be empty")
     fragment.foreach { c =>
-      if (!isAllowed(c))
+      if !isAllowed(c) then
         throw new IllegalArgumentException(
           "Invalid character in VCS URI fragment (only ASCII letters, digits, and - _ . / + are allowed)"
         )
     }
-  }
 
   private def isAllowed(c: Char): Boolean =
     (c >= 'a' && c <= 'z') ||
       (c >= 'A' && c <= 'Z') ||
       (c >= '0' && c <= '9') ||
       c == '-' || c == '_' || c == '.' || c == '/' || c == '+'
-}
diff --git a/main/src/main/scala/sbt/internal/VirtualFileValueCache.scala b/main/src/main/scala/sbt/internal/VirtualFileValueCache.scala
index 41d65f594..552fe45aa 100644
--- a/main/src/main/scala/sbt/internal/VirtualFileValueCache.scala
+++ b/main/src/main/scala/sbt/internal/VirtualFileValueCache.scala
@@ -19,19 +19,17 @@ import sbt.internal.inc.Locate
 /**
  * Cache based on path and its stamp.
  */
-sealed trait VirtualFileValueCache[A] {
+sealed trait VirtualFileValueCache[A]:
   def clear(): Unit
   def get: VirtualFile => A
-}
 
-object VirtualFileValueCache {
-  def definesClassCache(converter: FileConverter): VirtualFileValueCache[DefinesClass] = {
+object VirtualFileValueCache:
+  def definesClassCache(converter: FileConverter): VirtualFileValueCache[DefinesClass] =
     apply(converter) { (x: VirtualFile) =>
-      if (x.name != "rt.jar") Locate.definesClass(x)
+      if x.name != "rt.jar" then Locate.definesClass(x)
       else (_: String) => false
     }
-  }
-  def apply[A](converter: FileConverter)(f: VirtualFile => A): VirtualFileValueCache[A] = {
+  def apply[A](converter: FileConverter)(f: VirtualFile => A): VirtualFileValueCache[A] =
     import collection.concurrent.Map
     import java.util.concurrent.ConcurrentHashMap
     import scala.jdk.CollectionConverters.*
@@ -45,40 +43,35 @@ object VirtualFileValueCache {
         }
       )
     )(f)
-  }
   def make[A](stamp: VirtualFile => XStamp)(f: VirtualFile => A): VirtualFileValueCache[A] =
     new VirtualFileValueCache0[A](stamp, f)(using Equiv.universal)
-}
+end VirtualFileValueCache
 
 private final class VirtualFileValueCache0[A](
     getStamp: VirtualFile => XStamp,
     make: VirtualFile => A
 )(using
     equiv: Equiv[XStamp]
-) extends VirtualFileValueCache[A] {
+) extends VirtualFileValueCache[A]:
   private val backing = new ConcurrentHashMap[VirtualFile, VirtualFileCache]
 
   def clear(): Unit = backing.clear()
-  def get = file => {
+  def get = file =>
     val ifAbsent = new VirtualFileCache(file)
     val cache = backing.putIfAbsent(file, ifAbsent)
-    (if (cache eq null) ifAbsent else cache).get()
-  }
+    (if cache eq null then ifAbsent else cache).get()
 
-  private final class VirtualFileCache(file: VirtualFile) {
+  private final class VirtualFileCache(file: VirtualFile):
     private var stampedValue: Option[(XStamp, A)] = None
     def get(): A = synchronized {
       val latest = getStamp(file)
-      stampedValue match {
+      stampedValue match
         case Some((stamp, value)) if (equiv.equiv(latest, stamp)) => value
         case _                                                    => update(latest)
-      }
     }
 
-    private def update(stamp: XStamp): A = {
+    private def update(stamp: XStamp): A =
       val value = make(file)
       stampedValue = Some((stamp, value))
       value
-    }
-  }
-}
+end VirtualFileValueCache0
diff --git a/main/src/main/scala/sbt/internal/WatchTransitiveDependencies.scala b/main/src/main/scala/sbt/internal/WatchTransitiveDependencies.scala
index 6fba19689..bd86cc2a8 100644
--- a/main/src/main/scala/sbt/internal/WatchTransitiveDependencies.scala
+++ b/main/src/main/scala/sbt/internal/WatchTransitiveDependencies.scala
@@ -23,13 +23,11 @@ import sbt.nio.file.Glob
 
 import scala.annotation.{ nowarn, tailrec }
 
-private[sbt] object WatchTransitiveDependencies {
-  extension (source: Source) {
-    private def toGlob: Glob = {
+private[sbt] object WatchTransitiveDependencies:
+  extension (source: Source)
+    private def toGlob: Glob =
       val filter = source.includeFilter -- source.excludeFilter
       Globs.apply(source.base.toPath, source.recursive, filter)
-    }
-  }
   private[sbt] def task: Def.Initialize[Task[Seq[DynamicInput]]] =
     Def.task(transitiveDynamicInputs(arguments.value))
   private[sbt] def task(
@@ -51,10 +49,9 @@ private[sbt] object WatchTransitiveDependencies {
       val log: sbt.util.Logger,
       val dependencyConfigurations: Seq[(ProjectRef, Set[String])],
       val state: State
-  ) {
+  ):
     def structure: BuildStructure = extracted.structure
     def data: Settings = extracted.structure.data
-  }
 
   private def argumentsImpl(
       scopedKey: ScopedKey[?],
@@ -80,6 +77,7 @@ private[sbt] object WatchTransitiveDependencies {
         st
       )
     }
+  end argumentsImpl
   private val ShowTransitive = "(?:show)?(?:[ ]*)(.*)/(?:[ ]*)transitive(?:Inputs|Globs|Triggers)".r
   private def arguments: Def.Initialize[Task[Arguments]] =
     Def
@@ -99,7 +97,7 @@ private[sbt] object WatchTransitiveDependencies {
           case _ => argumentsImpl(rs, extracted, compiledMap)
       }
 
-  private[sbt] def transitiveDynamicInputs(args: Arguments): Seq[DynamicInput] = {
+  private[sbt] def transitiveDynamicInputs(args: Arguments): Seq[DynamicInput] =
     import args.*
     val taskScope = Project.fillTaskAxis(scopedKey).scope
     def delegates(sk: ScopedKey[?]): Seq[ScopedKey[?]] =
@@ -110,11 +108,11 @@ private[sbt] object WatchTransitiveDependencies {
     val allKeys: Seq[ScopedKey[?]] =
       (delegates(scopedKey).toSet ++ delegates(ScopedKey(taskScope, watchTriggers.key))).toSeq
     val keys = collectKeys(args, allKeys, Set.empty, Set.empty)
-    def getDynamicInputs(scopedKey: ScopedKey[Seq[Glob]], trigger: Boolean): Seq[DynamicInput] = {
+    def getDynamicInputs(scopedKey: ScopedKey[Seq[Glob]], trigger: Boolean): Seq[DynamicInput] =
       data
         .getDirect(scopedKey)
         .map { globs =>
-          if (!trigger) {
+          if !trigger then
             val stamper =
               data.getDirect(scopedKey.copy(key = inputFileStamper.key)).getOrElse(FileStamper.Hash)
             val forceTrigger =
@@ -122,30 +120,23 @@ private[sbt] object WatchTransitiveDependencies {
                 .getDirect(scopedKey.copy(key = watchForceTriggerOnAnyChange.key))
                 .getOrElse(false)
             globs.map(g => DynamicInput(g, stamper, forceTrigger))
-          } else {
-            globs.map(g => DynamicInput(g, FileStamper.LastModified, forceTrigger = true))
-          }
+          else globs.map(g => DynamicInput(g, FileStamper.LastModified, forceTrigger = true))
         }
         .getOrElse(Nil)
-    }
-    val (inputGlobs, triggerGlobs) = keys.partition(_.key == fileInputs.key) match {
+    val (inputGlobs, triggerGlobs) = keys.partition(_.key == fileInputs.key) match
       case (inputs, triggers) =>
         (
           inputs.flatMap(getDynamicInputs(_, trigger = false)),
           triggers.flatMap(getDynamicInputs(_, trigger = true))
         )
-    }
     // If watchTriggers is explicitly set (non-empty), use only watchTriggers instead of combining with fileInputs
     // This allows users to control what triggers the watch by setting watchTriggers
-    val result = if (triggerGlobs.nonEmpty) {
-      triggerGlobs ++ legacy(keys :+ scopedKey, args)
-    } else {
-      inputGlobs ++ triggerGlobs ++ legacy(keys :+ scopedKey, args)
-    }
+    val result = if triggerGlobs.nonEmpty then triggerGlobs ++ legacy(keys :+ scopedKey, args)
+    else inputGlobs ++ triggerGlobs ++ legacy(keys :+ scopedKey, args)
     result.distinct.sorted
-  }
+  end transitiveDynamicInputs
 
-  private def legacy(keys: Seq[ScopedKey[?]], args: Arguments): Seq[DynamicInput] = {
+  private def legacy(keys: Seq[ScopedKey[?]], args: Arguments): Seq[DynamicInput] =
     import args.*
     val projectScopes =
       keys.view
@@ -173,7 +164,7 @@ private[sbt] object WatchTransitiveDependencies {
           .map(s => toDynamicInput(s.toGlob))
       case Right(globs) => globs.map(toDynamicInput)
     }
-  }
+  end legacy
 
   private def legacyWatchSourcesScopedKey(
       scope: Scope
@@ -189,17 +180,16 @@ private[sbt] object WatchTransitiveDependencies {
       dependencies: Seq[ScopedKey[?]],
       accumulator: Set[ScopedKey[Seq[Glob]]],
       visited: Set[ScopedKey[?]]
-  ): Seq[ScopedKey[Seq[Glob]]] = dependencies match {
+  ): Seq[ScopedKey[Seq[Glob]]] = dependencies match
     // Iterates until the dependency list is empty. The visited parameter prevents the graph
     // traversal from getting stuck in a cycle.
     case Seq(dependency, rest*) =>
-      (if (!visited(dependency)) arguments.compiledMap.get(dependency) else None) match {
+      (if !visited(dependency) then arguments.compiledMap.get(dependency) else None) match
         case Some(compiled) =>
           val newVisited = visited + compiled.key
-          val baseGlobs: Seq[ScopedKey[Seq[Glob]]] = compiled.key match {
+          val baseGlobs: Seq[ScopedKey[Seq[Glob]]] = compiled.key match
             case key: ScopedKey[Seq[Glob]] @unchecked if isGlobKey(key) => key :: Nil
             case _                                                      => Nil
-          }
           val base: (Seq[ScopedKey[?]], Seq[ScopedKey[Seq[Glob]]]) = (Nil, baseGlobs)
           val (newDependencies, newScopes) =
             (compiled.dependencies.filterNot(newVisited) ++ compiled.settings.map(_.key))
@@ -211,7 +201,7 @@ private[sbt] object WatchTransitiveDependencies {
                   key.scope.task.toOption
                     .map { k =>
                       val newKey = ScopedKey(key.scope.copy(task = Zero), k)
-                      if (newVisited(newKey)) (d, s) else (d :+ newKey, s)
+                      if newVisited(newKey) then (d, s) else (d :+ newKey, s)
                     }
                     .getOrElse((d, s))
                 case ((d, s), key) if key.key == transitiveClasspathDependency.key =>
@@ -229,23 +219,19 @@ private[sbt] object WatchTransitiveDependencies {
                     }
                     .getOrElse((d, s))
                 case ((d, s), key) =>
-                  (d ++ (if (!newVisited(key)) Some(key) else None), s)
+                  (d ++ (if !newVisited(key) then Some(key) else None), s)
               }
           // Append the Keys.triggers key in case there are no other references to Keys.triggers.
-          val transitiveTrigger = compiled.key.scope.task.toOption match {
+          val transitiveTrigger = compiled.key.scope.task.toOption match
             case _: Some[?] => ScopedKey(compiled.key.scope, watchTriggers.key)
             case None => ScopedKey(Project.fillTaskAxis(compiled.key).scope, watchTriggers.key)
-          }
-          val newRest = rest ++ newDependencies ++ (if (newVisited(transitiveTrigger)) Nil
+          val newRest = rest ++ newDependencies ++ (if newVisited(transitiveTrigger) then Nil
                                                     else Some(transitiveTrigger))
           collectKeys(arguments, newRest, accumulator ++ newScopes, newVisited)
         case _ if rest.nonEmpty => collectKeys(arguments, rest, accumulator, visited)
         case _                  => accumulator.toIndexedSeq
-      }
     case _ => accumulator.toIndexedSeq
-  }
-  private def isGlobKey(key: ScopedKey[?]): Boolean = key.key match {
+  private def isGlobKey(key: ScopedKey[?]): Boolean = key.key match
     case fileInputs.key | watchTriggers.key => true
     case _                                  => false
-  }
-}
+end WatchTransitiveDependencies
diff --git a/main/src/main/scala/sbt/internal/graph/GraphTransformations.scala b/main/src/main/scala/sbt/internal/graph/GraphTransformations.scala
index b80dd1b97..19824be03 100644
--- a/main/src/main/scala/sbt/internal/graph/GraphTransformations.scala
+++ b/main/src/main/scala/sbt/internal/graph/GraphTransformations.scala
@@ -10,24 +10,22 @@ package sbt
 package internal
 package graph
 
-object GraphTransformations {
-  def reverseGraphStartingAt(graph: ModuleGraph, root: GraphModuleId): ModuleGraph = {
+object GraphTransformations:
+  def reverseGraphStartingAt(graph: ModuleGraph, root: GraphModuleId): ModuleGraph =
     val deps = graph.reverseDependencyMap
 
     def visit(
         module: GraphModuleId,
         visited: Set[GraphModuleId]
     ): Seq[(GraphModuleId, GraphModuleId)] =
-      if (visited(module))
-        Nil
+      if visited(module) then Nil
       else
-        deps.get(module) match {
+        deps.get(module) match
           case Some(deps) =>
             deps.flatMap { to =>
               (module, to.id) +: visit(to.id, visited + module)
             }
           case None => Nil
-        }
 
     val edges = visit(root, Set.empty)
     val nodes =
@@ -35,9 +33,9 @@ object GraphTransformations {
         .foldLeft(Set.empty[GraphModuleId])((set, edge) => set + edge._1 + edge._2)
         .flatMap(graph.module)
     ModuleGraph(nodes.toSeq, edges)
-  }
+  end reverseGraphStartingAt
 
-  def ignoreScalaLibrary(scalaVersion: String, graph: ModuleGraph): ModuleGraph = {
+  def ignoreScalaLibrary(scalaVersion: String, graph: ModuleGraph): ModuleGraph =
     def isScalaLibrary(m: Module) = isScalaLibraryId(m.id)
     def isScalaLibraryId(id: GraphModuleId) =
       id.organization == "org.scala-lang" && id.name == "scala-library"
@@ -45,15 +43,11 @@ object GraphTransformations {
     def dependsOnScalaLibrary(m: Module): Boolean =
       graph.dependencyMap(m.id).exists(isScalaLibrary)
 
-    def addScalaLibraryAnnotation(m: Module): Module = {
-      if (dependsOnScalaLibrary(m))
-        m.copy(extraInfo = m.extraInfo + " [S]")
-      else
-        m
-    }
+    def addScalaLibraryAnnotation(m: Module): Module =
+      if dependsOnScalaLibrary(m) then m.copy(extraInfo = m.extraInfo + " [S]")
+      else m
 
     val newNodes = graph.nodes.map(addScalaLibraryAnnotation).filterNot(isScalaLibrary)
     val newEdges = graph.edges.filterNot(e => isScalaLibraryId(e._2))
     ModuleGraph(newNodes, newEdges)
-  }
-}
+end GraphTransformations
diff --git a/main/src/main/scala/sbt/internal/graph/backend/SbtUpdateReport.scala b/main/src/main/scala/sbt/internal/graph/backend/SbtUpdateReport.scala
index 194f79c39..75f422287 100644
--- a/main/src/main/scala/sbt/internal/graph/backend/SbtUpdateReport.scala
+++ b/main/src/main/scala/sbt/internal/graph/backend/SbtUpdateReport.scala
@@ -19,19 +19,18 @@ import sbt.librarymanagement.{
   OrganizationArtifactReport
 }
 
-object SbtUpdateReport {
+object SbtUpdateReport:
 
-  def fromConfigurationReport(report: ConfigurationReport, rootInfo: ModuleID): ModuleGraph = {
+  def fromConfigurationReport(report: ConfigurationReport, rootInfo: ModuleID): ModuleGraph =
     implicit def id(sbtId: ModuleID): GraphModuleId =
       GraphModuleId(sbtId.organization, sbtId.name, sbtId.revision)
 
-    def moduleEdges(orgArt: OrganizationArtifactReport): Seq[(Module, Seq[Edge])] = {
+    def moduleEdges(orgArt: OrganizationArtifactReport): Seq[(Module, Seq[Edge])] =
       val chosenVersion = orgArt.modules.find(!_.evicted).map(_.module.revision)
       orgArt.modules.map(moduleEdge(chosenVersion))
-    }
 
-    def moduleEdge(chosenVersion: Option[String])(report: ModuleReport): (Module, Seq[Edge]) = {
-      val evictedByVersion = if (report.evicted) chosenVersion else None
+    def moduleEdge(chosenVersion: Option[String])(report: ModuleReport): (Module, Seq[Edge]) =
+      val evictedByVersion = if report.evicted then chosenVersion else None
       val jarFile = report.artifacts
         .find(_._1.`type` == "jar")
         .orElse(report.artifacts.find(_._1.extension == "jar"))
@@ -46,7 +45,6 @@ object SbtUpdateReport {
         ),
         report.callers.map(caller => Edge(caller.caller, report.module))
       )
-    }
 
     val (nodes, edges) = report.details.flatMap(moduleEdges).unzip
     val root = Module(rootInfo)
@@ -56,16 +54,15 @@ object SbtUpdateReport {
 
     // Handle relocated dependencies where the caller node doesn't exist (#8400)
     val fixedEdges = flatEdges.flatMap { case edge @ (from, to) =>
-      if (existingNodeIds.contains(from)) Seq(edge)
-      else {
+      if existingNodeIds.contains(from) then Seq(edge)
+      else
         val callersOfMissing = flatEdges.collect {
           case (caller, target) if target == from => caller
         }
-        if (callersOfMissing.isEmpty) Seq(Edge(root.id, to))
+        if callersOfMissing.isEmpty then Seq(Edge(root.id, to))
         else callersOfMissing.map(caller => Edge(caller, to))
-      }
     }
 
     ModuleGraph(allNodes, fixedEdges.distinct)
-  }
-}
+  end fromConfigurationReport
+end SbtUpdateReport
diff --git a/main/src/main/scala/sbt/internal/graph/model.scala b/main/src/main/scala/sbt/internal/graph/model.scala
index c3e755dbc..5d78cf61e 100644
--- a/main/src/main/scala/sbt/internal/graph/model.scala
+++ b/main/src/main/scala/sbt/internal/graph/model.scala
@@ -18,9 +18,8 @@ private[sbt] case class GraphModuleId(
     organization: String,
     name: String,
     version: String,
-) {
+):
   def idString: String = organization + ":" + name + ":" + version
-}
 
 private[sbt] object GraphModuleId:
   import sjsonnew.BasicJsonProtocol.StringJsonFormat
@@ -83,7 +82,7 @@ private[sbt] object Module:
   )
 end Module
 
-private[sbt] case class ModuleGraph(nodes: Seq[Module], edges: Seq[Edge]) {
+private[sbt] case class ModuleGraph(nodes: Seq[Module], edges: Seq[Edge]):
   lazy val modules: Map[GraphModuleId, Module] =
     nodes.map(n => (n.id, n)).toMap
 
@@ -97,18 +96,17 @@ private[sbt] case class ModuleGraph(nodes: Seq[Module], edges: Seq[Edge]) {
 
   def createMap(
       bindingFor: ((GraphModuleId, GraphModuleId)) => (GraphModuleId, GraphModuleId)
-  ): Map[GraphModuleId, Seq[Module]] = {
+  ): Map[GraphModuleId, Seq[Module]] =
     val map = mutable.Map.empty[GraphModuleId, mutable.Set[Module]]
     edges.foreach { entry =>
       val (f, t) = bindingFor(entry)
       module(t).foreach { m => map.getOrElseUpdate(f, mutable.Set.empty) += m }
     }
     map.view.mapValues(_.toSeq.sortBy(_.id.idString)).toMap.withDefaultValue(Nil)
-  }
 
   def roots: Seq[Module] =
     nodes.filter(n => !edges.exists(_._2 == n.id)).sortBy(_.id.idString)
-}
+end ModuleGraph
 
 private[sbt] object ModuleGraph:
   val empty = ModuleGraph(Seq.empty, Seq.empty)
diff --git a/main/src/main/scala/sbt/internal/graph/package.scala b/main/src/main/scala/sbt/internal/graph/package.scala
index 50ef7036e..8c78e54b6 100644
--- a/main/src/main/scala/sbt/internal/graph/package.scala
+++ b/main/src/main/scala/sbt/internal/graph/package.scala
@@ -9,7 +9,6 @@
 package sbt
 package internal
 
-package object graph {
+package object graph:
   type Edge = (GraphModuleId, GraphModuleId)
   def Edge(from: GraphModuleId, to: GraphModuleId): Edge = from -> to
-}
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/AsciiTree.scala b/main/src/main/scala/sbt/internal/graph/rendering/AsciiTree.scala
index d40230bed..360425b83 100644
--- a/main/src/main/scala/sbt/internal/graph/rendering/AsciiTree.scala
+++ b/main/src/main/scala/sbt/internal/graph/rendering/AsciiTree.scala
@@ -13,8 +13,8 @@ package rendering
 
 import sbt.internal.util.Terminal.red
 
-object AsciiTree {
-  def asciiTree(graph: ModuleGraph, graphWidth: Int): String = {
+object AsciiTree:
+  def asciiTree(graph: ModuleGraph, graphWidth: Int): String =
     val deps = graph.dependencyMap
 
     // there should only be one root node (the project itself)
@@ -30,7 +30,6 @@ object AsciiTree {
           )
       }
       .mkString("\n")
-  }
 
   def displayModule(module: Module): String =
     red(
@@ -40,4 +39,4 @@ object AsciiTree {
         module.evictedByVersion.map(v => s" (evicted by: $v)").getOrElse(""),
       module.hadError
     )
-}
+end AsciiTree
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/DOT.scala b/main/src/main/scala/sbt/internal/graph/rendering/DOT.scala
index 817347c2d..b03e81a12 100644
--- a/main/src/main/scala/sbt/internal/graph/rendering/DOT.scala
+++ b/main/src/main/scala/sbt/internal/graph/rendering/DOT.scala
@@ -22,11 +22,11 @@ object DOT:
       colors: Boolean,
   ): String =
     val nodes = {
-      for (n <- graph.nodes) yield {
+      for n <- graph.nodes yield
         val label = nodeFormation(n.id.organization, n.id.name, n.id.version)
-        val style = if (n.isEvicted) EvictedStyle else ""
-        val penwidth = if (n.isEvicted) "3" else "5"
-        val color = if (colors) {
+        val style = if n.isEvicted then EvictedStyle else ""
+        val penwidth = if n.isEvicted then "3" else "5"
+        val color = if colors then
           val orgHash = n.id.organization.hashCode
           val r = (orgHash >> 16) & 0xff
           val g = (orgHash >> 8) & 0xff
@@ -35,7 +35,7 @@ object DOT:
           val g1 = (g * 0.90).toInt
           val b1 = (b * 0.90).toInt
           (r1 << 16) | (g1 << 8) | (b1 << 0)
-        } else 0
+        else 0
         s"""    "%s"[shape=box %s style="%s" penwidth="%s" color="%s"]"""
           .format(
             n.id.idString,
@@ -44,7 +44,6 @@ object DOT:
             penwidth,
             f"#$color%06X",
           )
-      }
     }.sorted.mkString("\n")
 
     def originWasEvicted(edge: Edge): Boolean = graph.module(edge._1).exists(_.isEvicted)
@@ -70,16 +69,16 @@ object DOT:
         .filterNot(e => originWasEvicted(e) || evictionTargetEdges(e)) ++ evictedByEdges
 
     val edges = {
-      for (e <- filteredEdges) yield {
+      for e <- filteredEdges yield
         val extra =
-          if (graph.module(e._1).exists(_.isEvicted))
+          if graph.module(e._1).exists(_.isEvicted) then
             s""" [label="Evicted By" style="$EvictedStyle"]"""
           else ""
         s"""    "${e._1.idString}" -> "${e._2.idString}"${extra}"""
-      }
     }.sorted.mkString("\n")
 
     s"$dotHead\n$nodes\n$edges\n}"
+  end dotGraph
 
   enum HTMLLabelRendering:
     case AngleBrackets
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/DagreHTML.scala b/main/src/main/scala/sbt/internal/graph/rendering/DagreHTML.scala
index 696788aa0..85dbf954d 100644
--- a/main/src/main/scala/sbt/internal/graph/rendering/DagreHTML.scala
+++ b/main/src/main/scala/sbt/internal/graph/rendering/DagreHTML.scala
@@ -16,13 +16,12 @@ import java.net.{ URLEncoder, URI }
 
 import sbt.io.IO
 
-object DagreHTML {
-  def createLink(dotGraph: String, targetDirectory: File): URI = {
+object DagreHTML:
+  def createLink(dotGraph: String, targetDirectory: File): URI =
     val graphHTML = createFile(dotGraph, targetDirectory)
     new URI(graphHTML.toURI.toString)
-  }
 
-  def createFile(dotGraph: String, targetDirectory: File): File = {
+  def createFile(dotGraph: String, targetDirectory: File): File =
     targetDirectory.mkdirs()
     val graphHTML = new File(targetDirectory, "graph.html")
     TreeView.saveResource("graph.html", graphHTML)
@@ -39,5 +38,4 @@ object DagreHTML {
       IO.utf8
     )
     graphHTML
-  }
-}
+end DagreHTML
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/FlatList.scala b/main/src/main/scala/sbt/internal/graph/rendering/FlatList.scala
index cad3be0c3..52f153676 100644
--- a/main/src/main/scala/sbt/internal/graph/rendering/FlatList.scala
+++ b/main/src/main/scala/sbt/internal/graph/rendering/FlatList.scala
@@ -11,11 +11,10 @@ package internal
 package graph
 package rendering
 
-object FlatList {
+object FlatList:
   def render(display: Module => String)(graph: ModuleGraph): String =
     graph.modules.values.toSeq.distinct
       .filterNot(_.isEvicted)
       .sortBy(m => (m.id.organization, m.id.name))
       .map(display)
       .mkString("\n")
-}
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/GraphML.scala b/main/src/main/scala/sbt/internal/graph/rendering/GraphML.scala
index e12af5d40..84d579447 100644
--- a/main/src/main/scala/sbt/internal/graph/rendering/GraphML.scala
+++ b/main/src/main/scala/sbt/internal/graph/rendering/GraphML.scala
@@ -38,6 +38,7 @@ object GraphML:
         </graph>
       </graphml>
     r
+  end graphML
 
   def graphMLAsString(graph: ModuleGraph): String =
     val w = StringWriter()
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/LicenseInfo.scala b/main/src/main/scala/sbt/internal/graph/rendering/LicenseInfo.scala
index b98942488..daef143c6 100644
--- a/main/src/main/scala/sbt/internal/graph/rendering/LicenseInfo.scala
+++ b/main/src/main/scala/sbt/internal/graph/rendering/LicenseInfo.scala
@@ -13,7 +13,7 @@ package rendering
 
 import sbt.internal.graph.*
 
-object LicenseInfo {
+object LicenseInfo:
   def render(graph: ModuleGraph): String =
     graph.nodes
       .filter(_.isUsed)
@@ -26,7 +26,7 @@ object LicenseInfo {
       }
       .mkString("\n\n")
 
-  def renderJson(graph: ModuleGraph): String = {
+  def renderJson(graph: ModuleGraph): String =
     // Create JSON array manually: [{license: "...", modules: [...]}, ...]
     def escapeJson(str: String): String =
       str.replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n").replace("\r", "\\r")
@@ -46,5 +46,4 @@ object LicenseInfo {
       }
 
     groups.mkString("[", ",", "]")
-  }
-}
+end LicenseInfo
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/Statistics.scala b/main/src/main/scala/sbt/internal/graph/rendering/Statistics.scala
index dea431c3b..f994394a7 100644
--- a/main/src/main/scala/sbt/internal/graph/rendering/Statistics.scala
+++ b/main/src/main/scala/sbt/internal/graph/rendering/Statistics.scala
@@ -11,8 +11,8 @@ package internal
 package graph
 package rendering
 
-object Statistics {
-  def renderModuleStatsList(graph: ModuleGraph): String = {
+object Statistics:
+  def renderModuleStatsList(graph: ModuleGraph): String =
     case class ModuleStats(
         id: GraphModuleId,
         numDirectDependencies: Int,
@@ -20,12 +20,11 @@ object Statistics {
         selfSize: Option[Long],
         transitiveSize: Long,
         transitiveDependencyStats: Map[GraphModuleId, ModuleStats]
-    ) {
+    ):
       def transitiveStatsWithSelf: Map[GraphModuleId, ModuleStats] =
         transitiveDependencyStats + (id -> this)
-    }
 
-    def statsFor(moduleId: GraphModuleId): ModuleStats = {
+    def statsFor(moduleId: GraphModuleId): ModuleStats =
       val directDependencies = graph.dependencyMap(moduleId).filterNot(_.isEvicted).map(_.id)
       val dependencyStats =
         directDependencies.map(statsFor).flatMap(_.transitiveStatsWithSelf).toMap
@@ -44,24 +43,21 @@ object Statistics {
         transitiveSize,
         dependencyStats
       )
-    }
 
-    def format(stats: ModuleStats): String = {
+    def format(stats: ModuleStats): String =
       import java.util.Locale
       val dl = Locale.getDefault
       Locale.setDefault(Locale.US)
       import stats.*
       def mb(bytes: Long): Double = bytes.toDouble / 1000000
       val selfSize =
-        stats.selfSize match {
+        stats.selfSize match
           case Some(size) => f"${mb(size)}%7.3f"
           case None       => "-------"
-        }
       val r =
         f"${mb(transitiveSize)}%7.3f MB $selfSize MB $numTransitiveDependencies%4d $numDirectDependencies%4d ${id.idString}%s"
       Locale.setDefault(dl)
       r
-    }
 
     val allStats =
       graph.roots
@@ -83,5 +79,5 @@ object Statistics {
         | - Number of transitive dependencies
         | - Number of direct dependencies
         | - ModuleID""".stripMargin
-  }
-}
+  end renderModuleStatsList
+end Statistics
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/TreeView.scala b/main/src/main/scala/sbt/internal/graph/rendering/TreeView.scala
index eed759139..4d901306d 100644
--- a/main/src/main/scala/sbt/internal/graph/rendering/TreeView.scala
+++ b/main/src/main/scala/sbt/internal/graph/rendering/TreeView.scala
@@ -20,26 +20,23 @@ import java.net.URI
 import scala.collection.mutable
 import scala.util.Using
 
-object TreeView {
-  def createJson(graph: ModuleGraph): String = {
+object TreeView:
+  def createJson(graph: ModuleGraph): String =
     val moduleModels = graph.roots.map(module => processSubtree(graph, module))
     val js = moduleModels.map(Converter.toJsonUnsafe(_))
     js.map(CompactPrinter).mkString("[", ",", "]")
-  }
 
-  def createLink(graphJson: String, targetDirectory: File): URI = {
+  def createLink(graphJson: String, targetDirectory: File): URI =
     val graphHTML = createFile(graphJson, targetDirectory)
     new URI(graphHTML.toURI.toString)
-  }
 
-  def createFile(graphJson: String, targetDirectory: File): File = {
+  def createFile(graphJson: String, targetDirectory: File): File =
     targetDirectory.mkdirs()
     val graphHTML = new File(targetDirectory, "tree.html")
     saveResource("tree.html", graphHTML)
     IO.write(new File(targetDirectory, "tree.json"), graphJson, IO.utf8)
     IO.write(new File(targetDirectory, "tree.data.js"), s"tree_data = $graphJson;", IO.utf8)
     graphHTML
-  }
 
   private[rendering] def processSubtree(
       graph: ModuleGraph,
@@ -54,46 +51,41 @@ object TreeView {
       module: Module,
       parents: Set[GraphModuleId],
       visited: mutable.Set[GraphModuleId]
-  ): ModuleModel = {
+  ): ModuleModel =
     val cycle = parents.contains(module.id)
     val duplicate = !cycle && visited.contains(module.id)
     val dependencies =
-      if (cycle || duplicate) List()
-      else {
+      if cycle || duplicate then List()
+      else
         visited += module.id
         graph.dependencyMap.getOrElse(module.id, List())
-      }
     val children =
       dependencies
         .map(dependency => processSubtreeImpl(graph, dependency, parents + module.id, visited))
         .toVector
     ModuleModel(displayText(module, cycle, duplicate), children)
-  }
 
   // Suffix order is pinned by TreeViewTest "concatenate marker suffixes
   // in a stable order"; change here means change the test.
-  private def displayText(module: Module, isCycle: Boolean, isDuplicate: Boolean): String = {
+  private def displayText(module: Module, isCycle: Boolean, isDuplicate: Boolean): String =
     val suffixes = Vector(
       module.evictedByVersion.map(v => s" (evicted by $v)"),
       module.error.map(err => s" (errors: $err)"),
-      if (isCycle) Some(" (cycle)") else None,
-      if (isDuplicate) Some(" (*)") else None,
+      if isCycle then Some(" (cycle)") else None,
+      if isDuplicate then Some(" (*)") else None,
     ).flatten
     module.id.idString + suffixes.mkString
-  }
 
-  def saveResource(resourcePath: String, to: File): Unit = {
+  def saveResource(resourcePath: String, to: File): Unit =
     val is = getClass.getClassLoader.getResourceAsStream(resourcePath)
     require(is ne null, s"Couldn't load '$resourcePath' from classpath.")
 
     Using.resource(new FileOutputStream(to)) { fos =>
       try copy(is, fos)
-      finally {
+      finally
         is.close()
-      }
     }
-  }
 
   def copy(from: InputStream, to: OutputStream): Unit =
     from.transferTo(to)
-}
+end TreeView
diff --git a/main/src/main/scala/sbt/internal/librarymanagement/DependencyLockManager.scala b/main/src/main/scala/sbt/internal/librarymanagement/DependencyLockManager.scala
index df87f3f34..e2b94b37a 100644
--- a/main/src/main/scala/sbt/internal/librarymanagement/DependencyLockManager.scala
+++ b/main/src/main/scala/sbt/internal/librarymanagement/DependencyLockManager.scala
@@ -117,6 +117,7 @@ object DependencyLockManager:
       configurations = configurations,
       metadata = metadata
     )
+  end createFromUpdateReport
 
   def getLockedVersions(
       lock: LockFileData
@@ -126,3 +127,4 @@ object DependencyLockManager:
         (dep.organization, dep.name) -> dep.version
       }
     }.toMap
+end DependencyLockManager
diff --git a/main/src/main/scala/sbt/internal/librarymanagement/GenericPublisher.scala b/main/src/main/scala/sbt/internal/librarymanagement/GenericPublisher.scala
index 4094c8838..0f6086966 100644
--- a/main/src/main/scala/sbt/internal/librarymanagement/GenericPublisher.scala
+++ b/main/src/main/scala/sbt/internal/librarymanagement/GenericPublisher.scala
@@ -73,6 +73,7 @@ class GenericPublisher private[sbt] (
     scala.xml.XML.save(file.getAbsolutePath, formatted, "UTF-8", xmlDecl = true)
     log.info("Wrote " + file.getAbsolutePath)
     file
+  end makePomFile
 
   override def publish(
       module: ModuleDescriptor,
@@ -111,7 +112,7 @@ class GenericPublisher private[sbt] (
         val baseStr =
           pat.substring(0, pat.indexOf("[organisation]")).replace('\\', '/').stripSuffix("/")
         val repoDir =
-          (if (baseStr.startsWith("file:")) new File(new java.net.URI(baseStr))
+          (if baseStr.startsWith("file:") then new File(new java.net.URI(baseStr))
            else new File(baseStr)).getAbsoluteFile
         if pbr.patterns.isMavenCompatible then
           log.info(s"Ivyless publish (Maven layout) to file repo: $repoDir")
@@ -162,10 +163,12 @@ class GenericPublisher private[sbt] (
           sys.error(
             s"ivyless Maven publish: unsupported root '$root'; use a supported repository (http/https/file)."
           )
+        end if
       case other =>
         sys.error(
           s"ivyless publish does not support ${other.getClass.getName}; use URLRepository, FileRepository, or MavenRepository."
         )
+    end match
   end publish
 
   private def pluginCrossPath: Seq[String] =
@@ -254,7 +257,7 @@ class GenericPublisher private[sbt] (
       artifactName: String,
       classifier: String,
       ext: String
-  ): String = {
+  ): String =
     var s = pattern
     s = s.replace("[organisation]", org)
     s = s.replace("[module]", moduleName)
@@ -262,7 +265,7 @@ class GenericPublisher private[sbt] (
     s = s.replace("[type]s", typeFolder)
     s = s.replace("[artifact]", artifactName)
     s = s.replace("[ext]", ext)
-    if (classifier.nonEmpty) s = s.replace("(-[classifier])", s"-$classifier")
+    if classifier.nonEmpty then s = s.replace("(-[classifier])", s"-$classifier")
     else s = s.replace("(-[classifier])", "")
     // Substitute or drop optional Ivy pattern parts (scala/sbt version), remove branch for ivyless layout
     val attrs = project.module.attributes
@@ -278,7 +281,7 @@ class GenericPublisher private[sbt] (
     )
     s = s.replaceAll("\\(\\[branch\\]/\\)", "")
     s
-  }
+  end substituteIvyArtifactPattern
 
   /**
    * Picks credentials for a URL. Matches host; when realm is given, prefers credential with matching realm (per Publishing docs).
@@ -326,7 +329,7 @@ class GenericPublisher private[sbt] (
       urlRepo: URLRepository,
       overwrite: Boolean,
       log: Logger
-  ): Unit = {
+  ): Unit =
     val org = project.module.organization.value
     val moduleName = project.module.name.value
     val version = project.version
@@ -376,7 +379,7 @@ class GenericPublisher private[sbt] (
     )
     val ivyUrl = URI.create(ivyPathPattern).toURL()
     val ivyTmp = File.createTempFile("ivy", ".xml")
-    try {
+    try
       IO.write(ivyTmp, ivyXmlContent)
       httpPut(ivyUrl, ivyTmp, credentialFor(ivyUrl, directCreds, None), log)
       val checksums = writeChecksumsToTempFiles(ivyTmp, checksumAlgorithms)
@@ -385,8 +388,8 @@ class GenericPublisher private[sbt] (
         try httpPut(checksumUrl, cf, credentialFor(checksumUrl, directCreds, None), log)
         finally cf.delete()
       }
-    } finally ivyTmp.delete()
-  }
+    finally ivyTmp.delete()
+  end ivylessPublish
 
   /**
    * Publishes artifacts to a local file repo (FileRepository) without using Apache Ivy.
@@ -398,17 +401,17 @@ class GenericPublisher private[sbt] (
       fileRepo: FileRepository,
       overwrite: Boolean,
       log: Logger
-  ): Unit = {
+  ): Unit =
     val pattern = fileRepo.patterns.artifactPatterns.headOption.getOrElse(
       sys.error("FileRepository has no artifact pattern")
     )
     val baseStr =
-      if (pattern.contains("[organisation]"))
+      if pattern.contains("[organisation]") then
         pattern.substring(0, pattern.indexOf("[organisation]"))
       else pattern
     val normalized = baseStr.replace('\\', '/').stripSuffix("/")
     val localRepoBase =
-      if (normalized.startsWith("file:")) new File(new java.net.URI(normalized))
+      if normalized.startsWith("file:") then new File(new java.net.URI(normalized))
       else new File(normalized)
     val repoDir = localRepoBase.getAbsoluteFile
     val isMavenLayout = fileRepo.patterns.isMavenCompatible
@@ -418,7 +421,7 @@ class GenericPublisher private[sbt] (
     else
       log.info(s"Ivyless publish (Ivy layout) to file repo: $repoDir")
       ivylessPublishLocal(artifacts, checksumAlgorithms, repoDir, overwrite, log)
-  }
+  end ivylessPublishToFile
 
   /**
    * Maven layout path: groupId/artifactId/version/artifactId-version[-classifier].ext
@@ -510,6 +513,7 @@ class GenericPublisher private[sbt] (
 
     if version.endsWith("-SNAPSHOT") then
       writeMavenMetadataLocal(versionDir, groupId, artifactId, version, log)
+  end ivylessPublishMavenToFile
 
   private def writeMavenMetadataLocal(
       versionDir: File,
@@ -536,6 +540,7 @@ class GenericPublisher private[sbt] (
     val metadataFile = new File(versionDir, "maven-metadata-local.xml")
     IO.write(metadataFile, metadata)
     log.info(s"published $metadataFile")
+  end writeMavenMetadataLocal
 
   /**
    * Publishes artifacts to a remote Maven repo (HTTP) without using Apache Ivy.
@@ -579,6 +584,7 @@ class GenericPublisher private[sbt] (
         catch
           case e: IOException =>
             throw new IOException(s"Failed to publish $path: ${e.getMessage}", e)
+  end ivylessPublishMavenToUrl
 end GenericPublisher
 
 object GenericPublisher:
diff --git a/main/src/main/scala/sbt/internal/librarymanagement/Publishing.scala b/main/src/main/scala/sbt/internal/librarymanagement/Publishing.scala
index 3e067de98..825e7f091 100644
--- a/main/src/main/scala/sbt/internal/librarymanagement/Publishing.scala
+++ b/main/src/main/scala/sbt/internal/librarymanagement/Publishing.scala
@@ -20,54 +20,46 @@ import sona.{ PublishingType, Sona }
 
 import scala.concurrent.duration.FiniteDuration
 
-object Publishing {
+object Publishing:
   val sonaRelease: Command =
     Command.command("sonaRelease")(sonatypeReleaseAction(PublishingType.Automatic))
 
   val sonaUpload: Command =
     Command.command("sonaUpload")(sonatypeReleaseAction(PublishingType.UserManaged))
 
-  def makeBundle(stagingDir: Path, bundlePath: Path): Path = {
-    if (bundlePath.toFile().exists()) {
-      IO.delete(bundlePath.toFile())
-    }
+  def makeBundle(stagingDir: Path, bundlePath: Path): Path =
+    if bundlePath.toFile().exists() then IO.delete(bundlePath.toFile())
     IO.zip(
       sources = contentOf(stagingDir.toFile()),
       outputZip = bundlePath.toFile(),
       time = Some(0L),
     )
     bundlePath
-  }
 
-  private def sonatypeReleaseAction(publishingType: PublishingType)(s0: State): State = {
+  private def sonatypeReleaseAction(publishingType: PublishingType)(s0: State): State =
     import sbt.ProjectExtra.extract
     val extracted = Project.extract(s0)
     val log = extracted.get(Keys.sLog)
     val version = extracted.get(Keys.version)
-    if (version.endsWith("-SNAPSHOT")) {
+    if version.endsWith("-SNAPSHOT") then
       log.error("""SNAPSHOTs are not supported on the Central Portal;
 configure ThisBuild / publishTo to publish directly to the central-snapshots.
 see https://www.scala-sbt.org/1.x/docs/Using-Sonatype.html for details.""")
       s0.fail
-    } else {
+    else
       val deploymentName = extracted.get(Keys.sonaDeploymentName)
       val uploadRequestTimeout = extracted.get(Keys.sonaUploadRequestTimeout)
       val (s1, bundle) = extracted.runTask(Keys.sonaBundle, s0)
       val (s2, creds) = extracted.runTask(Keys.credentials, s1)
       val client = fromCreds(creds, uploadRequestTimeout)
-      try {
+      try
         client.uploadBundle(bundle.toPath(), deploymentName, publishingType, log)
         s2
-      } finally {
-        client.close()
-      }
-    }
-  }
+      finally client.close()
 
-  private def fromCreds(creds: Seq[Credentials], uploadRequestTimeout: FiniteDuration): Sona = {
+  private def fromCreds(creds: Seq[Credentials], uploadRequestTimeout: FiniteDuration): Sona =
     val cred = CredentialUtils
       .forHost(creds, Sona.host)
       .getOrElse(throw new MessageOnlyException(s"no credentials are found for ${Sona.host}"))
     Sona.oauthClient(cred.userName, cred.passwd, uploadRequestTimeout)
-  }
-}
+end Publishing
diff --git a/main/src/main/scala/sbt/internal/server/BspCompileProgress.scala b/main/src/main/scala/sbt/internal/server/BspCompileProgress.scala
index b5ccae255..3e45372a7 100644
--- a/main/src/main/scala/sbt/internal/server/BspCompileProgress.scala
+++ b/main/src/main/scala/sbt/internal/server/BspCompileProgress.scala
@@ -13,27 +13,22 @@ import xsbti.compile.CompileProgress
 private[sbt] final class BspCompileProgress(
     task: BspCompileTask,
     underlying: Option[CompileProgress]
-) extends CompileProgress {
+) extends CompileProgress:
   override def advance(
       current: Int,
       total: Int,
       prevPhase: String,
       nextPhase: String
-  ): Boolean = {
+  ): Boolean =
     val percentage = current * 100 / total
     // Report percentages every 5% increments
     val shouldReportPercentage = percentage % 5 == 0
-    if (shouldReportPercentage) {
-      task.notifyProgress(percentage, total)
-    }
+    if shouldReportPercentage then task.notifyProgress(percentage, total)
     underlying.fold(true)(_.advance(current, total, prevPhase, nextPhase))
-  }
 
-  override def startUnit(phase: String, unitPath: String): Unit = {
+  override def startUnit(phase: String, unitPath: String): Unit =
     underlying.foreach(_.startUnit(phase, unitPath))
-  }
 
-  override def afterEarlyOutput(success: Boolean): Unit = {
+  override def afterEarlyOutput(success: Boolean): Unit =
     underlying.foreach(_.afterEarlyOutput(success))
-  }
-}
+end BspCompileProgress
diff --git a/main/src/main/scala/sbt/internal/server/BspCompileTask.scala b/main/src/main/scala/sbt/internal/server/BspCompileTask.scala
index d0afe4d9d..1155f5d47 100644
--- a/main/src/main/scala/sbt/internal/server/BspCompileTask.scala
+++ b/main/src/main/scala/sbt/internal/server/BspCompileTask.scala
@@ -25,13 +25,12 @@ object BspCompileTask:
       project: ProjectRef,
       config: Configuration,
       inputs: Inputs
-  ): BspCompileTask = {
+  ): BspCompileTask =
     val taskId = TaskId(BuildServerTasks.uniqueId, Vector())
     val targetName = BuildTargetName.fromScope(project.project, config.name)
     val task = BspCompileTask(targetId, targetName, taskId, inputs, System.currentTimeMillis())
     task.notifyStart()
     task
-  }
 end BspCompileTask
 
 case class BspCompileTask private (
@@ -40,17 +39,16 @@ case class BspCompileTask private (
     id: sbt.internal.bsp.TaskId,
     inputs: Inputs,
     startTimeMillis: Long
-) {
+):
   import sbt.internal.bsp.codec.JsonProtocol.given
 
-  private[sbt] def notifyStart(): Unit = {
+  private[sbt] def notifyStart(): Unit =
     val message = s"Compiling $targetName"
     val data = Converter.toJsonUnsafe(CompileTask(targetId))
     val params = TaskStartParams(id, startTimeMillis, message, "compile-task", data)
     StandardMain.exchange.notifyEvent("build/taskStart", params)
-  }
 
-  private[sbt] def notifySuccess(analysis: CompileAnalysis): Unit = {
+  private[sbt] def notifySuccess(analysis: CompileAnalysis): Unit =
     import scala.jdk.CollectionConverters.*
     val endTimeMillis = System.currentTimeMillis()
     val elapsedTimeMillis = endTimeMillis - startTimeMillis
@@ -67,9 +65,8 @@ case class BspCompileTask private (
       Converter.toJsonUnsafe(report)
     )
     StandardMain.exchange.notifyEvent("build/taskFinish", params)
-  }
 
-  private[sbt] def notifyProgress(percentage: Int, total: Int): Unit = {
+  private[sbt] def notifyProgress(percentage: Int, total: Int): Unit =
     val data = Converter.toJsonUnsafe(CompileTask(targetId))
     val message = s"Compiling $targetName ($percentage%)"
     val currentMillis = System.currentTimeMillis()
@@ -84,9 +81,8 @@ case class BspCompileTask private (
       Some(data)
     )
     StandardMain.exchange.notifyEvent("build/taskProgress", params)
-  }
 
-  private[sbt] def notifyFailure(cause: Option[CompileFailed]): Unit = {
+  private[sbt] def notifyFailure(cause: Option[CompileFailed]): Unit =
     val endTimeMillis = System.currentTimeMillis()
     val elapsedTimeMillis = endTimeMillis - startTimeMillis
     val problems = cause.map(_.problems().toSeq).getOrElse(Seq.empty[Problem])
@@ -100,16 +96,14 @@ case class BspCompileTask private (
       Converter.toJsonUnsafe(report)
     )
     StandardMain.exchange.notifyEvent("build/taskFinish", params)
-  }
 
   private def compileReport(
       problems: Seq[Problem],
       elapsedTimeMillis: Long,
       isNoOp: Option[Boolean]
-  ): CompileReport = {
+  ): CompileReport =
     val countBySeverity = problems.groupBy(_.severity()).view.mapValues(_.size).toMap
     val warnings = countBySeverity.getOrElse(Severity.Warn, 0)
     val errors = countBySeverity.getOrElse(Severity.Error, 0)
     CompileReport(targetId, None, errors, warnings, Some(elapsedTimeMillis.toInt), isNoOp)
-  }
-}
+end BspCompileTask
diff --git a/main/src/main/scala/sbt/internal/server/BuildServerEvalReporter.scala b/main/src/main/scala/sbt/internal/server/BuildServerEvalReporter.scala
index 99a99af29..0bf90bf18 100644
--- a/main/src/main/scala/sbt/internal/server/BuildServerEvalReporter.scala
+++ b/main/src/main/scala/sbt/internal/server/BuildServerEvalReporter.scala
@@ -31,8 +31,8 @@ class BuildServerEvalReporter(buildTarget: BuildTargetIdentifier, delegate: Repo
     extends EvalReporter:
   private val problemsByFile = mutable.Map[Path, Vector[Diagnostic]]()
 
-  override def doReport(dia: ScalaDiagnostic)(using Context): Unit = {
-    if (dia.pos.exists) {
+  override def doReport(dia: ScalaDiagnostic)(using Context): Unit =
+    if dia.pos.exists then
       val filePath = Paths.get(dia.pos.source.file.path)
       val range = convertToRange(dia.pos)
       val bspSeverity = convertToBsp(dia.level)
@@ -47,10 +47,8 @@ class BuildServerEvalReporter(buildTarget: BuildTargetIdentifier, delegate: Repo
       )
       exchange.notifyEvent("build/publishDiagnostics", params)
       delegate.doReport(dia)
-    }
-  }
 
-  override def finalReport(sourceName: String): Unit = {
+  override def finalReport(sourceName: String): Unit =
     val filePath = Paths.get(sourceName)
     val diagnostics = problemsByFile.getOrElse(filePath, Vector())
     val params = PublishDiagnosticsParams(
@@ -61,18 +59,15 @@ class BuildServerEvalReporter(buildTarget: BuildTargetIdentifier, delegate: Repo
       reset = true
     )
     exchange.notifyEvent("build/publishDiagnostics", params)
-  }
 
-  private def convertToBsp(severity: Int): Option[Long] = {
-    val result = severity match {
+  private def convertToBsp(severity: Int): Option[Long] =
+    val result = severity match
       case dotty.tools.dotc.interfaces.Diagnostic.INFO    => DiagnosticSeverity.Information
       case dotty.tools.dotc.interfaces.Diagnostic.WARNING => DiagnosticSeverity.Warning
       case dotty.tools.dotc.interfaces.Diagnostic.ERROR   => DiagnosticSeverity.Error
-    }
     Some(result)
-  }
 
-  private def convertToRange(pos: SourcePosition): Range = {
+  private def convertToRange(pos: SourcePosition): Range =
     val startLine = pos.source.offsetToLine(pos.start)
     val startChar = pos.start - pos.source.lineToOffset(startLine)
     val endLine = pos.source.offsetToLine(pos.end)
@@ -81,5 +76,4 @@ class BuildServerEvalReporter(buildTarget: BuildTargetIdentifier, delegate: Repo
       bsp.Position(startLine.toLong, startChar.toLong),
       bsp.Position(endLine.toLong, endChar.toLong)
     )
-  }
 end BuildServerEvalReporter
diff --git a/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala b/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala
index ab8ee63aa..d70165974 100644
--- a/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala
+++ b/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala
@@ -43,7 +43,7 @@ import scala.collection.immutable.ListSet
 import xsbti.VirtualFileRef
 import java.util.concurrent.atomic.AtomicReference
 
-object BuildServerProtocol {
+object BuildServerProtocol:
   import sbt.internal.bsp.codec.JsonProtocol.given
 
   private val capabilities = BuildServerCapabilities(
@@ -68,31 +68,29 @@ object BuildServerProtocol {
 
   lazy val commands: Seq[Command] = Seq(
     Command.single(bspReload) { (state, reqId) =>
-      try {
+      try
         val newState = BuiltinCommands.doLoadProject(state, Project.LoadAction.Current)
         exchange.respondEvent(JNull, Some(reqId), state.source)
         newState
-      } catch {
+      catch
         case NonFatal(e) =>
           val msg = ErrorHandling.reducedToString(e)
           exchange.respondError(ErrorCodes.InternalError, msg, Some(reqId), state.source)
           state.fail
-      }
     }
   )
 
   lazy val globalSettings: Seq[Def.Setting[?]] = Seq(
     bspConfig := {
-      if (bspEnabled.value) {
+      if bspEnabled.value then
         BuildServerConnection.writeConnectionFile(
           sbtVersion.value,
           (ThisBuild / baseDirectory).value
         )
-      } else {
+      else
         val logger = streams.value.log
         logger.warn("BSP is disabled for this build")
         logger.info("add 'Global / bspEnabled := true' to enable BSP")
-      }
     },
     bspEnabled := true,
     bspSbtEnabled := true,
@@ -184,10 +182,9 @@ object BuildServerProtocol {
       val s = state.value
       workspace.warnIfBuildsNonEmpty(Method.Compile, s.log)
       val statusCodes = Keys.bspBuildTargetCompileItem.result.all(filter).value
-      val aggregatedStatusCode = allOrThrow(statusCodes) match {
+      val aggregatedStatusCode = allOrThrow(statusCodes) match
         case Seq() => StatusCode.Success
         case codes => codes.max
-      }
       s.respondEvent(BspCompileResult(None, aggregatedStatusCode))
     }.evaluated,
     bspBuildTargetOutputPaths := bspInputTask { (_, filter) =>
@@ -368,7 +365,7 @@ object BuildServerProtocol {
       val logger = streams.value.log
       val meta = isMetaBuild.value
       val spms = sourcePositionMappers.value
-      if (bspEnabled.value) {
+      if bspEnabled.value then
         new BuildServerReporterImpl(
           targetId,
           bspCompileStateInstance,
@@ -378,12 +375,10 @@ object BuildServerProtocol {
           logger,
           underlying
         )
-      } else {
-        new BuildServerForwarder(meta, logger, underlying)
-      }
+      else new BuildServerForwarder(meta, logger, underlying)
     },
   )
-  private[sbt] object Method {
+  private[sbt] object Method:
     final val Initialize = "build/initialize"
     final val BuildTargets = "workspace/buildTargets"
     final val Reload = "workspace/reload"
@@ -403,7 +398,6 @@ object BuildServerProtocol {
     final val ScalaTestClasses = "buildTarget/scalaTestClasses"
     final val ScalaMainClasses = "buildTarget/scalaMainClasses"
     final val Exit = "build/exit"
-  }
   identity(
     Method
   ) // silence spurious "private object Method in object BuildServerProtocol is never used" warning!
@@ -414,7 +408,7 @@ object BuildServerProtocol {
       sbtVersion: String,
       semanticdbEnabled: Boolean,
       semanticdbVersion: String
-  ): ServerHandler = {
+  ): ServerHandler =
     val configurationMap: Map[ConfigKey, Configuration] =
       loadedBuild.allProjectRefs
         .flatMap { case (_, p) => p.configurations }
@@ -549,16 +543,15 @@ object BuildServerProtocol {
         },
       )
     }
-  }
+  end handler
 
   private def getStandaloneSourceFiles(
       sourceFiles: Seq[File],
       sourceDirs: Seq[File]
-  ): Seq[File] = {
+  ): Seq[File] =
     sourceFiles.filterNot { f =>
       sourceDirs.exists(dir => f.toPath.startsWith(dir.toPath))
     }
-  }
 
   private def toSourceItem(itemKind: Int, generated: Boolean)(file: File): SourceItem =
     SourceItem(file.toURI, itemKind, generated)
@@ -568,33 +561,29 @@ object BuildServerProtocol {
       semanticdbVersion: String,
       params: InitializeBuildParams,
       log: Logger
-  ): Unit = {
-    for {
+  ): Unit =
+    for
       data <- params.data
       // try parse metadata as MetalsMetadata
       metalsMetadata <- Converter.fromJson[MetalsMetadata](data).toOption
-    } {
-      if (metalsMetadata.semanticdbVersion.nonEmpty && !semanticdbEnabled) {
+    do
+      if metalsMetadata.semanticdbVersion.nonEmpty && !semanticdbEnabled then
         log.warn(s"${params.displayName} requires the semanticdb compiler plugin")
         log.warn(
           s"consider setting 'Global / semanticdbEnabled := true' in your global sbt settings ($$HOME/.sbt/1.0)"
         )
-      }
 
-      for {
+      for
         requiredVersion <- SemanticVersion.tryParse(metalsMetadata.semanticdbVersion)
         currentVersion <- SemanticVersion.tryParse(semanticdbVersion)
         if requiredVersion > currentVersion
-      } {
+      do
         log.warn(
           s"${params.displayName} requires semanticdb version ${metalsMetadata.semanticdbVersion}, current version is $semanticdbVersion"
         )
         log.warn(
           s"""consider setting 'Global / semanticdbVersion := "${metalsMetadata.semanticdbVersion}"' in your global sbt settings ($$HOME/.sbt/1.0)"""
         )
-      }
-    }
-  }
 
   private def json(r: JsonRpcRequestMessage): JValue =
     r.params.getOrElse(
@@ -609,11 +598,11 @@ object BuildServerProtocol {
       val loadedBuild = Keys.loadedBuild.value
 
       // list all defined scopes for setting bspTargetIdentifier for all projects
-      val scopes: Seq[Scope] = for {
+      val scopes: Seq[Scope] = for
         (ref, project) <- loadedBuild.allProjectRefs
         setting <- project.settings
         if setting.key.key.label == Keys.bspTargetIdentifier.key.label
-      } yield Scope.replaceThis(Scope.Global.rescope(ref))(setting.key.scope)
+      yield Scope.replaceThis(Scope.Global.rescope(ref))(setting.key.scope)
 
       import sbt.TupleSyntax.*
       t2ToApp2(
@@ -625,28 +614,23 @@ object BuildServerProtocol {
         val buildsMap =
           mutable.HashMap[BuildTargetIdentifier, mutable.ListBuffer[BuildTargetIdentifier]]()
 
-        val scopeMap = for {
+        val scopeMap = for
           (targetId, scope, bspEnabled) <- targetIds.lazyZip(scopes).lazyZip(bspEnabled)
           if bspEnabled
-        } yield {
-          (scope.project.toOption: @unchecked) match {
+        yield
+          (scope.project.toOption: @unchecked) match
             case Some(ProjectRef(buildUri, _)) =>
               val loadedBuildUnit = loadedBuild.units(buildUri)
               buildsMap.getOrElseUpdate(
                 toSbtTargetId(loadedBuildUnit),
                 new mutable.ListBuffer
               ) += targetId
-          }
           targetId -> scope
-        }
-        val buildMap = if (bspSbtEnabled.value) {
-          for (loadedBuildUnit <- loadedBuild.units.values) yield {
+        val buildMap = if bspSbtEnabled.value then
+          for loadedBuildUnit <- loadedBuild.units.values yield
             val rootProjectId = loadedBuildUnit.root
             toSbtTargetId(loadedBuildUnit) -> loadedBuildUnit
-          }
-        } else {
-          Nil
-        }
+        else Nil
         BspFullWorkspace(scopeMap.toMap, buildMap.toMap, buildsMap.view.mapValues(_.result()).toMap)
       }
     }
@@ -675,11 +659,11 @@ object BuildServerProtocol {
         val configuration = Keys.configuration.value
         val displayName = BuildTargetName.fromScope(thisProject.id, configuration.name)
         val baseDirectory = Keys.baseDirectory.value.toURI
-        val projectDependencies = for {
+        val projectDependencies = for
           (dep, configs) <- Keys.bspInternalDependencyConfigurations.value
           config <- configs
           if dep != thisProjectRef || config.name != thisConfig.name
-        } yield (dep / config / Keys.bspTargetIdentifier)
+        yield (dep / config / Keys.bspTargetIdentifier)
         val capabilities =
           BuildTargetCapabilities(
             canCompile = true,
@@ -773,7 +757,7 @@ object BuildServerProtocol {
       sbtJars: Array[File],
       targetId: BuildTargetIdentifier,
       build: LoadedBuildUnit
-  ): JavacOptionsItem = {
+  ): JavacOptionsItem =
     val plugins: LoadedPlugins = build.unit.plugins
     val javacOptions = plugins.pluginData.javacOptions.toVector
     val converter = plugins.pluginData.converter
@@ -783,7 +767,6 @@ object BuildServerProtocol {
     val classDirectory = new File(build.localBase, "project/target").toURI
     val item = JavacOptionsItem(targetId, javacOptions, classpath, classDirectory)
     item
-  }
 
   private inline def bspInputTask[T](
       inline taskImpl: (BspFullWorkspace, ScopeFilter) => T
@@ -826,10 +809,10 @@ object BuildServerProtocol {
     val converter = fileConverter.value
     val externalDependencyClasspath = Keys.externalDependencyClasspath.value
       .map(f => converter.toPath(f.data).toFile.toURI)
-    val internalDependencyClasspath = for {
+    val internalDependencyClasspath = for
       (ref, configs) <- bspInternalDependencyConfigurations.value
       config <- configs
-    } yield ref / config / Keys.classDirectory
+    yield ref / config / Keys.classDirectory
     Def.task {
       internalDependencyClasspath.join.value.distinct.map(_.toURI).toVector ++
         externalDependencyClasspath
@@ -853,24 +836,23 @@ object BuildServerProtocol {
   private def getDependencySourceItem(
       targetId: BuildTargetIdentifier,
       updateReport: UpdateReport
-  ): DependencySourcesItem = {
-    val sources = for {
+  ): DependencySourcesItem =
+    val sources = for
       configuration <- updateReport.configurations.view
       module <- configuration.modules.view
       (artifact, file) <- module.artifacts
       classifier <- artifact.classifier if classifier == "sources"
-    } yield file.toURI
+    yield file.toURI
     DependencySourcesItem(targetId, sources.toVector.distinct)
-  }
 
   private def getDependencyModulesItem(
       targetId: BuildTargetIdentifier,
       updateReport: UpdateReport
-  ): DependencyModulesItem = {
-    val modules = for {
+  ): DependencyModulesItem =
+    val modules = for
       configuration <- updateReport.configurations.view
       module <- configuration.modules.view
-    } yield {
+    yield
       val moduleId = module.module
       DependencyModule(
         name = s"${moduleId.organization}:${moduleId.name}",
@@ -878,19 +860,17 @@ object BuildServerProtocol {
         dataKind = None,
         data = None,
       )
-    }
     DependencyModulesItem(targetId, modules.toVector.distinct)
-  }
 
   private def bspCompileState: Initialize[BuildServerProtocol.BspCompileState] = Def.setting {
     new BuildServerProtocol.BspCompileState()
   }
 
   private def bspCompileTask: Def.Initialize[Task[Int]] = Def.task {
-    Keys.compile.result.value match {
+    Keys.compile.result.value match
       case Result.Value(_)   => StatusCode.Success
       case Result.Inc(cause) =>
-        cause.getCause match {
+        cause.getCause match
           case _: InterruptedException => StatusCode.Cancelled
           case _: MessageOnlyException =>
             // Rethrow so task failure path sends JSON-RPC error (e.g. respondError project)
@@ -899,8 +879,6 @@ object BuildServerProtocol {
             // Return Error for any compile failure (CompileFailed or other Incomplete)
             // so BSP returns a proper BspCompileResult instead of a JSON-RPC error (#8104)
             StatusCode.Error
-        }
-    }
   }
 
   private val jsonParser: Parser[Try[JValue]] = Parsers.any.*.map(_.mkString)
@@ -914,10 +892,10 @@ object BuildServerProtocol {
       val defaultOpts = (run / forkOptions).value
       val defaultEnv = bspEnvironmentVariables(defaultOpts)
 
-      val mainClass = runParams.dataKind match {
+      val mainClass = runParams.dataKind match
         case Some("scala-main-class") =>
           val data = runParams.data.getOrElse(JNull)
-          Converter.fromJson[ScalaMainClass](data) match {
+          Converter.fromJson[ScalaMainClass](data) match
             case Failure(e) =>
               throw LangServerError(
                 ErrorCodes.ParseError,
@@ -925,7 +903,6 @@ object BuildServerProtocol {
               )
             case Success(value) =>
               value.withEnvironmentVariables(defaultEnv ++ value.environmentVariables)
-          }
 
         case Some(dataKind) =>
           throw LangServerError(
@@ -945,7 +922,6 @@ object BuildServerProtocol {
             defaultOpts.runJVMOptions,
             defaultEnv
           )
-      }
       runMainClassTask(mainClass, runParams.originId)
     }
 
@@ -955,23 +931,21 @@ object BuildServerProtocol {
       val testParams = json.flatMap(Converter.fromJson[TestParams]).get
       val workspace = bspFullWorkspace.value
 
-      val resultTask: Def.Initialize[Task[Result[Seq[Unit]]]] = testParams.dataKind match {
+      val resultTask: Def.Initialize[Task[Result[Seq[Unit]]]] = testParams.dataKind match
         case Some("scala-test") =>
           val data = testParams.data.getOrElse(JNull)
-          val items = Converter.fromJson[ScalaTestParams](data) match {
+          val items = Converter.fromJson[ScalaTestParams](data) match
             case Failure(e) =>
               throw LangServerError(ErrorCodes.ParseError, e.getMessage)
             case Success(value) => value.testClasses
-          }
           val testTasks: Seq[Def.Initialize[Task[Unit]]] = items.map { item =>
             val scope = workspace.scopes(item.target)
-            item.classes.toList match {
+            item.classes.toList match
               case Nil     => Def.task(())
               case classes =>
                 (scope / testOnly)
                   .toTask(" " + classes.mkString(" "))
                   .map(r => ())
-            }
           }
           testTasks.joinWith(ts => TaskExtra.joinTasks(ts).join).result
 
@@ -985,14 +959,12 @@ object BuildServerProtocol {
           // run allTests in testParams.targets
           val filter = ScopeFilter.in(testParams.targets.map(workspace.scopes))
           test.toTask("").map(r => ()).all(filter).result
-      }
 
       Def.task {
         val state = Keys.state.value
-        val statusCode = resultTask.value match {
+        val statusCode = resultTask.value match
           case Result.Value(_) => StatusCode.Success
           case Result.Inc(_)   => StatusCode.Error
-        }
         val _ = state.respondEvent(TestResult(testParams.originId, statusCode))
       }
     }
@@ -1007,10 +979,9 @@ object BuildServerProtocol {
       .withRunJVMOptions(mainClass.jvmOptions)
       .withEnvVars(
         mainClass.environmentVariables
-          .flatMap(_.split("=", 2).toList match {
+          .flatMap(_.split("=", 2).toList match
             case key :: value :: Nil => Some(key -> value)
-            case _                   => None
-          })
+            case _                   => None)
           .toMap
       )
     val runner = new ForkRun(forkOpts)
@@ -1043,10 +1014,10 @@ object BuildServerProtocol {
       }
     val ref = Keys.thisProjectRef.value
     val thisConfig = Keys.configuration.value
-    val transitiveDependencies = for {
+    val transitiveDependencies = for
       (dep, configs) <- directDependencies
       config <- configs if dep != ref || config.name != thisConfig.name
-    } yield dep / config / Keys.bspInternalDependencyConfigurations
+    yield dep / config / Keys.bspInternalDependencyConfigurations
     Def.setting {
       val allDependencies = directDependencies ++
         transitiveDependencies.join.value.flatten
@@ -1062,7 +1033,7 @@ object BuildServerProtocol {
   }
 
   private def scalaTestClassesTask: Initialize[Task[Seq[ScalaTestClassesItem]]] = Def.task {
-    Keys.definedTests.?.value match {
+    Keys.definedTests.?.value match
       case None              => Vector.empty
       case Some(definitions) =>
         val frameworks: Seq[Framework] = Keys.loadedTestFrameworks.?.value
@@ -1078,7 +1049,6 @@ object BuildServerProtocol {
             framework.name()
           )
         }.toSeq
-    }
   }
 
   private def scalaMainClassesTask: Initialize[Task[ScalaMainClassesItem]] = Def.task {
@@ -1101,12 +1071,11 @@ object BuildServerProtocol {
   private def extractJavaVersion(
       javacOptions: Seq[String],
       isForkedJava: Boolean
-  ): Option[String] = {
-    def getVersionAfterFlag(flag: String): Option[String] = {
+  ): Option[String] =
+    def getVersionAfterFlag(flag: String): Option[String] =
       val index = javacOptions.indexOf(flag)
-      if (index >= 0) javacOptions.lift(index + 1)
+      if index >= 0 then javacOptions.lift(index + 1)
       else None
-    }
 
     val versionFromJavacOption = getVersionAfterFlag("--release")
       .orElse(getVersionAfterFlag("--target"))
@@ -1114,90 +1083,73 @@ object BuildServerProtocol {
 
     versionFromJavacOption.orElse {
       // TODO: extract java version from forked javac
-      if (isForkedJava) None else sys.props.get("java.version")
+      if isForkedJava then None else sys.props.get("java.version")
     }
-  }
 
   // naming convention still seems like the only reliable way to get IntelliJ to import this correctly
   // https://github.com/JetBrains/intellij-scala/blob/a54c2a7c157236f35957049cbfd8c10587c9e60c/scala/scala-impl/src/org/jetbrains/sbt/language/SbtFileImpl.scala#L82-L84
-  private def toSbtTargetIdName(ref: LoadedBuildUnit): String = {
+  private def toSbtTargetIdName(ref: LoadedBuildUnit): String =
     ref.root + "-build"
-  }
-  private def toSbtTargetId(ref: LoadedBuildUnit): BuildTargetIdentifier = {
+  private def toSbtTargetId(ref: LoadedBuildUnit): BuildTargetIdentifier =
     val name = toSbtTargetIdName(ref)
     val build = ref.unit.uri
-    val sanitized = build.toString.indexOf("#") match {
+    val sanitized = build.toString.indexOf("#") match
       case i if i > 0 => build.toString.take(i)
       case _          => build.toString
-    }
     BuildTargetIdentifier(new URI(sanitized + "#" + name))
-  }
   private def toId(ref: ProjectReference, config: Configuration): BuildTargetIdentifier =
-    ref match {
+    ref match
       case ProjectRef(build, project) =>
-        val sanitized = build.toString.indexOf("#") match {
+        val sanitized = build.toString.indexOf("#") match
           case i if i > 0 => build.toString.take(i)
           case _          => build.toString
-        }
         BuildTargetIdentifier(new URI(s"$sanitized#$project/${config.id}"))
       case _ => sys.error(s"unexpected $ref")
-    }
 
-  private def anyOrThrow[T](results: Seq[Result[T]]): Seq[T] = {
+  private def anyOrThrow[T](results: Seq[Result[T]]): Seq[T] =
     val successes = results.collect { case Result.Value(v) => v }
     val errors = results.collect { case Result.Inc(cause) => cause }
-    if (successes.nonEmpty || errors.isEmpty) successes
+    if successes.nonEmpty || errors.isEmpty then successes
     else throw Incomplete(None, causes = errors)
-  }
 
-  private def allOrThrow[T](results: Seq[Result[T]]): Seq[T] = {
+  private def allOrThrow[T](results: Seq[Result[T]]): Seq[T] =
     val successes = results.collect { case Result.Value(v) => v }
     val errors = results.collect { case Result.Inc(cause) => cause }
-    if (errors.isEmpty) successes
+    if errors.isEmpty then successes
     else throw Incomplete(None, causes = errors)
-  }
 
-  private case class SemanticVersion(major: Int, minor: Int) extends Ordered[SemanticVersion] {
-    override def compare(that: SemanticVersion): Int = {
-      if (that.major != major) major.compare(that.major)
+  private case class SemanticVersion(major: Int, minor: Int) extends Ordered[SemanticVersion]:
+    override def compare(that: SemanticVersion): Int =
+      if that.major != major then major.compare(that.major)
       else minor.compare(minor)
-    }
-  }
 
-  private object SemanticVersion {
-    def tryParse(versionStr: String): Option[SemanticVersion] = {
-      try {
+  private object SemanticVersion:
+    def tryParse(versionStr: String): Option[SemanticVersion] =
+      try
         val parts = versionStr.split('.')
         Some(SemanticVersion(parts(0).toInt, parts(1).toInt))
-      } catch {
-        case NonFatal(_) => None
-      }
-    }
-  }
+      catch case NonFatal(_) => None
 
   /** The regular targets for each scope and meta-targets for the SBT build. */
   private[sbt] final case class BspFullWorkspace(
       scopes: Map[BuildTargetIdentifier, Scope],
       builds: Map[BuildTargetIdentifier, LoadedBuildUnit],
       buildToScope: Map[BuildTargetIdentifier, Seq[BuildTargetIdentifier]]
-  ) {
-    def filter(targets: Seq[BuildTargetIdentifier]): BspFullWorkspace = {
+  ):
+    def filter(targets: Seq[BuildTargetIdentifier]): BspFullWorkspace =
       val set = targets.toSet
       def filterMap[T](map: Map[BuildTargetIdentifier, T]) = map.filter(x => set.contains(x._1))
       BspFullWorkspace(filterMap(scopes), filterMap(builds), buildToScope)
-    }
-    def warnIfBuildsNonEmpty(method: String, log: Logger): Unit = {
-      if (builds.nonEmpty)
+    def warnIfBuildsNonEmpty(method: String, log: Logger): Unit =
+      if builds.nonEmpty then
         log.warn(
           s"$method is a no-op for build.sbt targets: ${builds.keys.mkString("[", ",", "]")}"
         )
-    }
-  }
 
   /**
    * Additional information about compilation status for given build target.
    */
-  private[server] final class BspCompileState {
+  private[server] final class BspCompileState:
 
     /**
      * keeps track of problems in a given file in a map of virtual source file to text documents.
@@ -1216,5 +1168,4 @@ object BuildServerProtocol {
      * see: https://github.com/scalacenter/bloop/issues/726
      */
     val isFirstReport: AtomicBoolean = new AtomicBoolean(true)
-  }
-}
+end BuildServerProtocol
diff --git a/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala b/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala
index b959c8231..7fb2eedf8 100644
--- a/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala
+++ b/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala
@@ -32,7 +32,7 @@ import java.nio.file.Path
 /**
  * Provides methods for sending success and failure reports and publishing diagnostics.
  */
-sealed trait BuildServerReporter extends Reporter {
+sealed trait BuildServerReporter extends Reporter:
   private final val sigFilesWritten = "[sig files written]"
   private final val pureExpression = "a pure expression does nothing in statement position"
 
@@ -63,20 +63,17 @@ sealed trait BuildServerReporter extends Reporter {
 
   override def problems(): Array[Problem] = underlying.problems()
 
-  override def log(problem: Problem): Unit = {
-    if (problem.message == sigFilesWritten) {
-      logger.debug(sigFilesWritten)
-    } else if (isMetaBuild && problem.message.startsWith(pureExpression)) {
+  override def log(problem: Problem): Unit =
+    if problem.message == sigFilesWritten then logger.debug(sigFilesWritten)
+    else if isMetaBuild && problem.message.startsWith(pureExpression) then
       // work around https://github.com/scala/bug/issues/12112 by ignoring it in the reporter
       logger.debug(problem.message)
-    } else {
+    else
       publishDiagnostic(problem)
       underlying.log(problem)
-    }
-  }
 
   override def comment(pos: XPosition, msg: String): Unit = underlying.comment(pos, msg)
-}
+end BuildServerReporter
 
 /**
  * @param bspCompileState what has already been reported in previous compilation.
@@ -91,7 +88,7 @@ final class BuildServerReporterImpl(
     protected override val isMetaBuild: Boolean,
     protected override val logger: ManagedLogger,
     protected override val underlying: Reporter
-) extends BuildServerReporter {
+) extends BuildServerReporter:
   import sbt.internal.bsp.codec.JsonProtocol.given
 
   private lazy val exchange = StandardMain.exchange
@@ -111,13 +108,11 @@ final class BuildServerReporterImpl(
    *
    * @param analysis current compile analysis
    */
-  override def sendSuccessReport(analysis: CompileAnalysis): Unit = {
-    for ((source, infos) <- analysis.readSourceInfos.getAllSourceInfos.asScala) {
+  override def sendSuccessReport(analysis: CompileAnalysis): Unit =
+    for (source, infos) <- analysis.readSourceInfos.getAllSourceInfos.asScala do
       val problems = infos.getReportedProblems.toVector
       sendReport(source, problems)
-    }
     notifyFirstReport()
-  }
 
   override def sendFailureReport(sources: Array[VirtualFile]): Unit =
     sendFailureReport(sources, None)
@@ -125,7 +120,7 @@ final class BuildServerReporterImpl(
   override def sendFailureReport(
       sources: Array[VirtualFile],
       failure: Option[CompileFailed]
-  ): Unit = {
+  ): Unit =
     val fallbackByFile: Map[Path, Vector[Problem]] = failure match
       case Some(failed) =>
         failed
@@ -140,22 +135,21 @@ final class BuildServerReporterImpl(
       case None =>
         Map.empty
 
-    for (source <- sources) {
+    for source <- sources do
       val path = converter.toPath(source)
       val problems = problemsByFile.getOrElse(path, fallbackByFile.getOrElse(path, Vector.empty))
       sendReport(source, problems)
-    }
     notifyFirstReport()
-  }
+  end sendFailureReport
 
-  private def sendReport(source: VirtualFileRef, problems: Vector[Problem]): Unit = {
+  private def sendReport(source: VirtualFileRef, problems: Vector[Problem]): Unit =
     val oldDocuments = getAndClearPreviousDocuments(source)
 
     // publish diagnostics if:
     // 1. file had any problems previously: update them with new ones
     // 2. file has fresh problems: report them
     // 3. build project is compiled for the first time: send success report
-    if (oldDocuments.nonEmpty || problems.nonEmpty || isFirstReport) {
+    if oldDocuments.nonEmpty || problems.nonEmpty || isFirstReport then
       val diagsByDocuments = problems
         .flatMap(mapProblemToDiagnostic)
         .groupMap((document, _) => document)((_, diag) => diag)
@@ -173,14 +167,13 @@ final class BuildServerReporterImpl(
         )
         exchange.notifyEvent("build/publishDiagnostics", params)
       }
-    }
-  }
+  end sendReport
 
-  protected override def publishDiagnostic(problem: Problem): Unit = {
-    for {
+  protected override def publishDiagnostic(problem: Problem): Unit =
+    for
       id <- problem.position.sourcePath.toScala
       (document, diagnostic) <- mapProblemToDiagnostic(problem)
-    } {
+    do
       // Note: We're putting the real path in `fileRef` because the `id` String can take
       // two forms, either a ${something}/relativePath, or the absolute path of the source.
       // But where we query this, we always have _only_ a ${something}/relativePath available.
@@ -196,8 +189,6 @@ final class BuildServerReporterImpl(
         reset = false
       )
       exchange.notifyEvent("build/publishDiagnostics", params)
-    }
-  }
 
   private def getAndClearPreviousDocuments(source: VirtualFileRef): Seq[TextDocumentIdentifier] =
     bspCompileState.problemsBySourceFiles.getAndUpdate(_ - source).getOrElse(source, Seq.empty)
@@ -205,14 +196,12 @@ final class BuildServerReporterImpl(
   private def updateNewDocuments(
       source: VirtualFileRef,
       documents: Vector[TextDocumentIdentifier]
-  ): Unit = {
+  ): Unit =
     val _ = bspCompileState.problemsBySourceFiles.updateAndGet(_ + (source -> documents))
-  }
 
   private def isFirstReport: Boolean = bspCompileState.isFirstReport.get
-  private def notifyFirstReport(): Unit = {
+  private def notifyFirstReport(): Unit =
     val _ = bspCompileState.isFirstReport.set(false)
-  }
 
   /**
    * Map a given problem, in a Scala source file, to a Diagnostic in an user-facing source file.
@@ -220,12 +209,12 @@ final class BuildServerReporterImpl(
    */
   private def mapProblemToDiagnostic(
       problem: Problem
-  ): Option[(TextDocumentIdentifier, Diagnostic)] = {
+  ): Option[(TextDocumentIdentifier, Diagnostic)] =
     val mappedPosition = sourcePositionMapper(problem.position)
-    for {
+    for
       mappedSource <- mappedPosition.sourcePath.toScala
       document <- toDocument(VirtualFileRef.of(mappedSource))
-    } yield {
+    yield
       val diagnostic = Diagnostic(
         toRange(mappedPosition),
         Option(toDiagnosticSeverity(problem.severity)),
@@ -234,10 +223,8 @@ final class BuildServerReporterImpl(
         problem.message
       )
       (document, diagnostic)
-    }
-  }
 
-  private def toRange(position: xsbti.Position): Range = {
+  private def toRange(position: xsbti.Position): Range =
     val startLineOpt = position.startLine.toScala.map(_.toLong - 1)
     val startColumnOpt = position.startColumn.toScala.map(_.toLong)
     val endLineOpt = position.endLine.toScala.map(_.toLong - 1)
@@ -253,20 +240,18 @@ final class BuildServerReporterImpl(
       .getOrElse(Position(0L, 0L))
     val endPosOpt = toPosition(endLineOpt, endColumnOpt)
     Range(startPos, endPosOpt.getOrElse(startPos))
-  }
 
-  private def toDiagnosticSeverity(severity: Severity): Long = severity match {
+  private def toDiagnosticSeverity(severity: Severity): Long = severity match
     case Severity.Info  => DiagnosticSeverity.Information
     case Severity.Warn  => DiagnosticSeverity.Warning
     case Severity.Error => DiagnosticSeverity.Error
-  }
-}
+end BuildServerReporterImpl
 
 final class BuildServerForwarder(
     protected override val isMetaBuild: Boolean,
     protected override val logger: ManagedLogger,
     protected override val underlying: Reporter
-) extends BuildServerReporter {
+) extends BuildServerReporter:
 
   override def sendSuccessReport(
       analysis: CompileAnalysis,
@@ -281,4 +266,3 @@ final class BuildServerForwarder(
   ): Unit = ()
 
   protected override def publishDiagnostic(problem: Problem): Unit = ()
-}
diff --git a/main/src/main/scala/sbt/internal/server/CoalescingFlusher.scala b/main/src/main/scala/sbt/internal/server/CoalescingFlusher.scala
index 6254164a1..b9bdf16b1 100644
--- a/main/src/main/scala/sbt/internal/server/CoalescingFlusher.scala
+++ b/main/src/main/scala/sbt/internal/server/CoalescingFlusher.scala
@@ -41,7 +41,9 @@ private[server] final class CoalescingFlusher(
         try
           pending.set(
             executor.schedule(
-              (() => { pending.set(null); drain() }): Runnable,
+              (() =>
+                pending.set(null); drain()
+              ): Runnable,
               delayMillis,
               TimeUnit.MILLISECONDS
             )
diff --git a/main/src/main/scala/sbt/internal/server/Definition.scala b/main/src/main/scala/sbt/internal/server/Definition.scala
index 641b59057..61eb1d5b2 100644
--- a/main/src/main/scala/sbt/internal/server/Definition.scala
+++ b/main/src/main/scala/sbt/internal/server/Definition.scala
@@ -36,21 +36,17 @@ import scala.concurrent.Promise
 import scala.jdk.OptionConverters.*
 import com.github.benmanes.caffeine.cache.Caffeine
 
-private[sbt] object Definition {
-  def send[A: JsonFormat](source: CommandSource, execId: String)(params: A): Unit = {
-    for {
-      channel <- StandardMain.exchange.channels.collectFirst {
+private[sbt] object Definition:
+  def send[A: JsonFormat](source: CommandSource, execId: String)(params: A): Unit =
+    for channel <- StandardMain.exchange.channels.collectFirst {
         case c: NetworkChannel if c.name == source.channelName => c
       }
-    } {
-      channel.respond(params, Option(execId))
-    }
-  }
+    do channel.respond(params, Option(execId))
 
-  object textProcessor {
+  object textProcessor:
     private val isIdentifier: String => Boolean = SbtParser.isIdentifier
 
-    private def findInBackticks(line: String, point: Int): Option[String] = {
+    private def findInBackticks(line: String, point: Int): Option[String] =
       val (even, odd) = line.zipWithIndex
         .collect { case (char, backtickIndex) if char == '`' => backtickIndex }
         .zipWithIndex
@@ -64,7 +60,6 @@ private[sbt] object Definition {
         .collectFirst {
           case (from, to) if from <= point && point < to => line.slice(from, to)
         }
-    }
 
     def identifier(line: String, point: Int): Option[String] = findInBackticks(line, point).orElse {
       val whiteSpaceReg = "(\\s|\\.)+".r
@@ -74,27 +69,26 @@ private[sbt] object Definition {
           (ind, ind + white.length)
         }
         .fold((0, line.length)) { case ((left, right), (from, to)) =>
-          val zero = if (to > left && to <= point) to else left
-          val end = if (from < right && from >= point) from else right
+          val zero = if to > left && to <= point then to else left
+          val end = if from < right && from >= point then from else right
           (zero, end)
         }
 
-      val ranges = for {
+      val ranges = for
         from <- zero to point
         to <- point to end
-      } yield (from -> to)
+      yield (from -> to)
 
       ranges
         .sortBy { (from, to) => -(to - from) }
         .foldLeft(List.empty[String]) { case (z, (from, to)) =>
           val fragment = line.slice(from, to).trim
-          if (isIdentifier(fragment))
-            z match {
+          if isIdentifier(fragment) then
+            z match
               case Nil if fragment.nonEmpty              => fragment :: z
               case h :: _ if h.length < fragment.length  => fragment :: Nil
               case h :: _ if h.length == fragment.length => fragment :: z
               case _                                     => z
-            }
           else z
         }
         .headOption
@@ -103,11 +97,10 @@ private[sbt] object Definition {
     private def asClassObjectIdentifier(sym: String) =
       Seq(s".$sym", s".$sym$$", s"$$$sym", s"$$$sym$$")
 
-    def potentialClsOrTraitOrObj(sym: String): PartialFunction[String, String] = {
-      val encodedSym = NameTransformer.encode(sym.toSeq match {
+    def potentialClsOrTraitOrObj(sym: String): PartialFunction[String, String] =
+      val encodedSym = NameTransformer.encode(sym.toSeq match
         case '`' +: body :+ '`' => body.mkString
-        case noBackticked       => noBackticked.mkString
-      })
+        case noBackticked       => noBackticked.mkString)
       val action: PartialFunction[String, String] = {
         case potentialClassOrTraitOrObject
             if asClassObjectIdentifier(encodedSym).exists(potentialClassOrTraitOrObject.endsWith) ||
@@ -116,15 +109,13 @@ private[sbt] object Definition {
           potentialClassOrTraitOrObject
       }
       action
-    }
 
     @tailrec
-    private def fold(z: Seq[(String, Int)])(it: Regex.MatchIterator): Seq[(String, Int)] = {
-      if (!it.hasNext) z
+    private def fold(z: Seq[(String, Int)])(it: Regex.MatchIterator): Seq[(String, Int)] =
+      if !it.hasNext then z
       else fold(z :+ (it.next() -> it.start))(it)
-    }
 
-    def classTraitObjectInLine(sym: String)(line: String): Seq[(String, Int)] = {
+    def classTraitObjectInLine(sym: String)(line: String): Seq[(String, Int)] =
       val potentials = Seq(
         s"object\\s+${Regex quote sym}".r,
         s"trait\\s+${Regex quote sym} *\\[?".r,
@@ -135,11 +126,10 @@ private[sbt] object Definition {
           fold(Seq.empty)(reg.findAllIn(line))
         }
         .collect { (name, pos) =>
-          (if (name.endsWith("[")) name.init.trim else name.trim) -> pos
+          (if name.endsWith("[") then name.init.trim else name.trim) -> pos
         }
-    }
 
-    def markPosition(file: Path, sym: String): Seq[(URI, Long, Long, Long)] = {
+    def markPosition(file: Path, sym: String): Seq[(URI, Long, Long, Long)] =
       val findInLine = classTraitObjectInLine(sym)(_)
       Files
         .lines(file)
@@ -154,13 +144,11 @@ private[sbt] object Definition {
         }
         .toSeq
         .distinct
-    }
-  }
+  end textProcessor
 
-  private def getDefinition(jsonDefinition: JValue): Option[TextDocumentPositionParams] = {
+  private def getDefinition(jsonDefinition: JValue): Option[TextDocumentPositionParams] =
     import langserver.codec.JsonProtocol.given
     Converter.fromJson[TextDocumentPositionParams](jsonDefinition).toOption
-  }
 
   private val AnalysesKey = "lsp.definition.analyses.key"
   private[server] type Analyses = Set[((String, Boolean, Boolean), Option[Analysis])]
@@ -183,29 +171,24 @@ private[sbt] object Definition {
 
   private[sbt] def updateCache(
       cache: Cache[String, Analyses]
-  )(cacheFile: String, useBinary: Boolean, useConsistent: Boolean): Any = {
-    cache.get(AnalysesKey, k => Set((cacheFile, useBinary, useConsistent) -> None)) match {
+  )(cacheFile: String, useBinary: Boolean, useConsistent: Boolean): Any =
+    cache.get(AnalysesKey, k => Set((cacheFile, useBinary, useConsistent) -> None)) match
       case null => new AnyRef
       case set  =>
         val newSet = set
           .filterNot { case ((file, _, _), _) => file == cacheFile }
           .+((cacheFile, useBinary, useConsistent) -> None)
         cache.put(AnalysesKey, newSet)
-    }
-  }
-  private[sbt] object AnalysesAccess {
+  private[sbt] object AnalysesAccess:
     private[sbt] lazy val cache: Cache[String, Analyses] = Caffeine.newBuilder.build()
-    ShutdownHooks.add(() => {
+    ShutdownHooks.add(() =>
       cache.invalidateAll()
       cache.cleanUp()
-    })
-    private[sbt] def getFrom(cache: Cache[String, Analyses]): Option[Analyses] = {
-      cache.getIfPresent(AnalysesKey) match {
+    )
+    private[sbt] def getFrom(cache: Cache[String, Analyses]): Option[Analyses] =
+      cache.getIfPresent(AnalysesKey) match
         case null => None
         case a    => Some(a)
-      }
-    }
-  }
 
   def collectAnalysesTask = Def.task {
     val cacheFile: String = compileAnalysisFile.value.getAbsolutePath
@@ -218,15 +201,15 @@ private[sbt] object Definition {
     )
   }
 
-  private[sbt] def getAnalyses: Future[Seq[Analysis]] = {
+  private[sbt] def getAnalyses: Future[Seq[Analysis]] =
     val result = Promise[Seq[Analysis]]()
 
-    new Thread("sbt-get-analysis-thread") {
+    new Thread("sbt-get-analysis-thread"):
       setDaemon(true)
       start()
       override def run(): Unit =
-        try {
-          AnalysesAccess.cache.getIfPresent(AnalysesKey) match {
+        try
+          AnalysesAccess.cache.getIfPresent(AnalysesKey) match
             case null   => result.success(Nil)
             case caches =>
               val (working, uninitialized) = caches.partition {
@@ -239,17 +222,14 @@ private[sbt] object Definition {
                   (title, storeAnalysis(Paths.get(file), !useBinary, useConsistent))
               }
               val validCaches = working ++ addToCache
-              if (addToCache.nonEmpty) {
-                AnalysesAccess.cache.put(AnalysesKey, validCaches)
-              }
+              if addToCache.nonEmpty then AnalysesAccess.cache.put(AnalysesKey, validCaches)
               result.success(validCaches.toSeq.collect { case (_, Some(analysis)) =>
                 analysis
               })
-          }
-        } catch { case scala.util.control.NonFatal(e) => result.failure(e) }
-    }
+        catch case scala.util.control.NonFatal(e) => result.failure(e)
+    end new
     result.future
-  }
+  end getAnalyses
 
   def lspDefinition(
       jsonDefinition: JValue,
@@ -274,7 +254,7 @@ private[sbt] object Definition {
             log.debug(s"$LspDefinitionLogHead found line: $line")
             textProcessor.identifier(line, definition.position.character.toInt)
           }
-      } match {
+      } match
       case Some(sym) =>
         log.debug(s"symbol $sym")
         analyses
@@ -321,6 +301,6 @@ private[sbt] object Definition {
         log.info(s"Symbol not found in definition request $jsonDefinitionString")
         import langserver.codec.JsonProtocol.given
         send(commandSource, requestId)(Array.empty[Location])
-    }
+    end match
   }
-}
+end Definition
diff --git a/main/src/main/scala/sbt/internal/server/LanguageServerProtocol.scala b/main/src/main/scala/sbt/internal/server/LanguageServerProtocol.scala
index 77f79d1d1..197b9d94b 100644
--- a/main/src/main/scala/sbt/internal/server/LanguageServerProtocol.scala
+++ b/main/src/main/scala/sbt/internal/server/LanguageServerProtocol.scala
@@ -21,7 +21,7 @@ import xsbti.FileConverter
 private[sbt] final case class LangServerError(code: Long, message: String)
     extends Throwable(message)
 
-private[sbt] object LanguageServerProtocol {
+private[sbt] object LanguageServerProtocol:
   private val internalJsonProtocol = new sbt.internal.langserver.codec.JsonProtocol
     with sbt.protocol.codec.JsonProtocol
     with sjsonnew.BasicJsonProtocol
@@ -37,13 +37,12 @@ private[sbt] object LanguageServerProtocol {
       )
     )
 
-  lazy val serverCapabilities: ServerCapabilities = {
+  lazy val serverCapabilities: ServerCapabilities =
     ServerCapabilities(
       textDocumentSync = TextDocumentSyncOptions(true, 0, false, false, SaveOptions(false)),
       hoverProvider = false,
       definitionProvider = false
     )
-  }
 
   def handler(converter: FileConverter): ServerHandler = ServerHandler { callback =>
     import callback.*
@@ -69,13 +68,13 @@ private[sbt] object LanguageServerProtocol {
           )
           val opt = Converter.fromJson[InitializeOption](optionJson).get
           setInitializeOption(opt)
-          if (authOptions(ServerAuthentication.Token)) {
+          if authOptions(ServerAuthentication.Token) then
             val token = opt.token.getOrElse(sys.error("'token' is missing."))
-            if (authenticate(token)) ()
+            if authenticate(token) then ()
             else throw LangServerError(ErrorCodes.InvalidRequest, "invalid token")
-          } else ()
+          else ()
           setInitialized(true)
-          if (!opt.skipAnalysis.getOrElse(false)) appendExec("collectAnalyses", None)
+          if !opt.skipAnalysis.getOrElse(false) then appendExec("collectAnalyses", None)
           jsonRpcRespond(InitializeResult(serverCapabilities), Some(r.id))
 
         case r: JsonRpcRequestMessage if r.method == "sbt/exec" =>
@@ -106,10 +105,10 @@ private[sbt] object LanguageServerProtocol {
       onResponse = PartialFunction.empty,
       onNotification = {
         case n: JsonRpcNotificationMessage if n.method == "textDocument/didSave" =>
-          if (isAuthenticated) {
+          if isAuthenticated then
             val _ = appendExec(";Test/compile; collectAnalyses", None)
-          } else log.warn(s"ignoring '${n.method}' before authentication")
+          else log.warn(s"ignoring '${n.method}' before authentication")
       }
     )
   }
-}
+end LanguageServerProtocol
diff --git a/main/src/main/scala/sbt/internal/server/NetworkChannel.scala b/main/src/main/scala/sbt/internal/server/NetworkChannel.scala
index 272b6e763..1bfd66356 100644
--- a/main/src/main/scala/sbt/internal/server/NetworkChannel.scala
+++ b/main/src/main/scala/sbt/internal/server/NetworkChannel.scala
@@ -56,7 +56,8 @@ final class NetworkChannel(
     instance: ServerInstance,
     handlers: Seq[ServerHandler],
     mkUIThreadImpl: (State, CommandChannel) => UITask,
-) extends CommandChannel { self =>
+) extends CommandChannel:
+  self =>
   def this(
       name: String,
       connection: Socket,
@@ -96,33 +97,29 @@ final class NetworkChannel(
   private val isCanceled = new AtomicBoolean(false)
   private[sbt] def isInteractive = interactive.get
   private val interactive = new AtomicBoolean(false)
-  private[sbt] def setInteractive(id: String, value: Boolean) = {
-    terminalHolder.getAndSet(new NetworkTerminal) match {
+  private[sbt] def setInteractive(id: String, value: Boolean) =
+    terminalHolder.getAndSet(new NetworkTerminal) match
       case null =>
       case t    => t.close()
-    }
     interactive.set(value)
-    if (isInteractive) terminal.setPrompt(Prompt.Pending)
+    if isInteractive then terminal.setPrompt(Prompt.Pending)
     attached.set(true)
     pendingRequests.remove(id)
     jsonRpcRespond("", id)
     addFastTrackTask(attach)
-  }
-  private[sbt] def prompt(): Unit = {
+  private[sbt] def prompt(): Unit =
     interactive.set(true)
     jsonRpcNotify(promptChannel, "")
-  }
-  override def prompt(e: ConsolePromptEvent): Unit = {
+  override def prompt(e: ConsolePromptEvent): Unit =
     isCanceled.set(false)
     super.prompt(e)
-  }
   private[sbt] def write(byte: Byte) = inputBuffer.add(byte.toInt)
 
   private val terminalHolder = new AtomicReference[Terminal](Terminal.NullTerminal)
   override private[sbt] def terminal: Terminal = terminalHolder.get
   override val userThread: UserThread = new UserThread(this)
 
-  private lazy val callback: ServerCallback = new ServerCallback {
+  private lazy val callback: ServerCallback = new ServerCallback:
     def jsonRpcRespond[A: JsonFormat](event: A, execId: Option[String]): Unit =
       self.respondResult(event, execId)
 
@@ -132,15 +129,13 @@ final class NetworkChannel(
     def jsonRpcNotify[A: JsonFormat](method: String, params: A): Unit =
       self.jsonRpcNotify(method, params)
 
-    def appendExec(commandLine: String, execId: Option[String]): Boolean = {
+    def appendExec(commandLine: String, execId: Option[String]): Boolean =
       self.notifyIfQueued(execId)
       self.appendExec(commandLine, execId)
-    }
 
-    def appendExec(exec: Exec): Boolean = {
+    def appendExec(exec: Exec): Boolean =
       self.notifyIfQueued(exec.execId)
       self.append(exec)
-    }
 
     def log: Logger = self.log
     def name: String = self.name
@@ -156,26 +151,23 @@ final class NetworkChannel(
       self.onCompletionRequest(execId, cp)
     private[sbt] def onCancellationRequest(execId: Option[String], crp: CancelRequestParams): Unit =
       self.onCancellationRequest(execId, crp)
-  }
 
   protected def setInitializeOption(opts: InitializeOption): Unit = initializeOption.set(opts)
 
   // Returns true if sbtn has declared with canWork: true
   protected def clientCanWork: Boolean =
-    Option(initializeOption.get) match {
+    Option(initializeOption.get) match
       case Some(opts) => opts.canWork.getOrElse(false)
       case _          => false
-    }
 
   /** True if this channel should receive broadcast events (logMessage, notifyEvent). Default true for backward compatibility. */
   private[sbt] def subscribeToAll: Boolean =
     Option(initializeOption.get).flatMap(_.subscribeToAll).getOrElse(false)
 
-  protected def authenticate(token: String): Boolean = {
+  protected def authenticate(token: String): Boolean =
     val result = instance.authenticate(token)
     if result then authenticated = true
     result
-  }
 
   private[sbt] def isAuthenticated: Boolean =
     authenticated || authOptions.isEmpty
@@ -185,7 +177,7 @@ final class NetworkChannel(
   protected def authOptions: Set[ServerAuthentication] = auth
 
   private def notifyIfQueued(execId: Option[String]): Unit =
-    StandardMain.exchange.currentExec match {
+    StandardMain.exchange.currentExec match
       case Some(currentExec) =>
         val event = ExecStatusEvent(
           "Queued",
@@ -193,64 +185,51 @@ final class NetworkChannel(
           execId,
           Vector.empty,
           None,
-          currentExec.commandLine match {
+          currentExec.commandLine match
             case cmd if cmd.length > 50 => Some(s"waiting for: ${cmd.take(50)}...")
             case cmd                    => Some(s"waiting for: $cmd")
-          }
         )
         jsonRpcNotify("sbt/exec", event)
       case None =>
-    }
 
-  override def mkUIThread: (State, CommandChannel) => UITask = (state, command) => {
-    if (interactive.get || ContinuousCommands.isInWatch(state, this)) mkUIThreadImpl(state, command)
+  override def mkUIThread: (State, CommandChannel) => UITask = (state, command) =>
+    if interactive.get || ContinuousCommands.isInWatch(state, this) then
+      mkUIThreadImpl(state, command)
     else
-      new UITask {
+      new UITask:
         override private[sbt] val channel = NetworkChannel.this
-        override private[sbt] lazy val reader: UITask.Reader = () => {
-          try {
+        override private[sbt] lazy val reader: UITask.Reader = () =>
+          try
             this.synchronized((this.wait()))
             Left(TerminateAction)
-          } catch {
-            case _: InterruptedException => Right("")
-          }
-        }
-      }
-  }
+          catch case _: InterruptedException => Right("")
 
-  private val thread = new Thread(s"sbt-networkchannel-${connection.getPort}") {
+  private val thread = new Thread(s"sbt-networkchannel-${connection.getPort}"):
     private val ct = "Content-Type: "
     private val x1 = "application/sbt-x1"
-    override def run(): Unit = {
-      try {
+    override def run(): Unit =
+      try
         connection.setSoTimeout(5000)
 
         val in = connection.getInputStream
         // keep going unless the socket has closed
-        while (running.get) {
-          try {
-            val onHeader: String => Unit = line => {
-              if (line.startsWith(ct) && line.contains(x1)) {
+        while running.get do
+          try
+            val onHeader: String => Unit = line =>
+              if line.startsWith(ct) && line.contains(x1) then
                 logMessage("error", s"server protocol $x1 is no longer supported")
-              }
-            }
             val content = JsonRpcReader.read(in, running, Some(onHeader))
-            if (content.nonEmpty) handleBody(content)
-          } catch {
+            if content.nonEmpty then handleBody(content)
+          catch
             case _: SocketTimeoutException                => // its ok
             case _: IOException | _: InterruptedException => running.set(false)
-          }
-        } // while
-      } finally {
-        shutdown(false)
-      }
-    }
+          // while
+      finally shutdown(false)
 
-    private lazy val intents = {
+    private lazy val intents =
       handlers.toVector map { h =>
         h.handler(callback)
       }
-    }
 
     lazy val onRequestMessage: PartialFunction[JsonRpcRequestMessage, Unit] =
       intents.foldLeft(PartialFunction.empty[JsonRpcRequestMessage, Unit]) { (f, i) =>
@@ -267,9 +246,9 @@ final class NetworkChannel(
       }
 
     def handleBody(chunk: Seq[Byte]): Unit =
-      Serialization.deserializeJsonMessage(chunk) match {
+      Serialization.deserializeJsonMessage(chunk) match
         case Right(req: JsonRpcRequestMessage) =>
-          if (!isAuthenticated && !NetworkChannel.isPreAuthRequestAllowed(req.method))
+          if !isAuthenticated && !NetworkChannel.isPreAuthRequestAllowed(req.method) then
             jsonRpcRespondError(
               req.id,
               JsonRpcResponseError(
@@ -278,26 +257,22 @@ final class NetworkChannel(
               )
             )
           else
-            try {
+            try
               registerRequest(req)
               onRequestMessage(req)
-            } catch {
+            catch
               case LangServerError(code, message) =>
                 log.debug(s"sending error: $code: $message")
                 respondError(code, message, Some(req.id))
-            }
         case Right(res: JsonRpcResponseMessage) =>
           onResponseMessage(res)
         case Right(ntf: JsonRpcNotificationMessage) =>
-          if (!isAuthenticated)
-            log.debug(s"ignoring '${ntf.method}' before authentication")
+          if !isAuthenticated then log.debug(s"ignoring '${ntf.method}' before authentication")
           else
-            try {
-              onNotification(ntf)
-            } catch {
+            try onNotification(ntf)
+            catch
               case LangServerError(code, message) =>
                 logMessage("error", s"error $code while handling notification: $message")
-            }
         case Right(msg) =>
           log.debug(s"unhandled message: $msg")
         case Left(errorDesc) =>
@@ -305,23 +280,20 @@ final class NetworkChannel(
             s"got invalid chunk from client (${new String(chunk.toArray, "UTF-8")}): $errorDesc"
           log.error(msg)
           logMessage("error", msg)
-      }
-  }
 
   private[sbt] def isLanguageServerProtocol: Boolean = true
 
-  private def registerRequest(request: JsonRpcRequestMessage): Unit = {
+  private def registerRequest(request: JsonRpcRequestMessage): Unit =
     this.synchronized {
       pendingRequests += (request.id -> request)
       ()
     }
-  }
 
   private[sbt] def respondError(
       err: JsonRpcResponseError,
       execId: Option[String]
   ): Unit = this.synchronized {
-    getPendingRequest(execId) match {
+    getPendingRequest(execId) match
       case Some(request) =>
         pendingRequests -= request.id
         jsonRpcRespondError(request.id, err)
@@ -330,10 +302,9 @@ final class NetworkChannel(
         val msg =
           s"unmatched json error for requestId $execId: ${CompactPrinter(Converter.toJsonUnsafe(err))}"
         log.debug(msg)
-    }
   }
 
-  private[sbt] def getPendingRequest(execId: Option[String]): Option[JsonRpcRequestMessage] = {
+  private[sbt] def getPendingRequest(execId: Option[String]): Option[JsonRpcRequestMessage] =
     execId.flatMap {
       // This handles multi commands from the network that were remapped to a different
       // exec id for reporting purposes.
@@ -345,21 +316,19 @@ final class NetworkChannel(
         }
       case id => pendingRequests.get(id)
     }
-  }
 
   private[sbt] def respondError(
       code: Long,
       message: String,
       execId: Option[String]
-  ): Unit = {
+  ): Unit =
     respondError(JsonRpcResponseError(code, message), execId)
-  }
 
   private[sbt] def respondResult[A: JsonFormat](
       event: A,
       execId: Option[String]
   ): Unit = this.synchronized {
-    getPendingRequest(execId) match {
+    getPendingRequest(execId) match
       case Some(request) =>
         pendingRequests -= request.id
         jsonRpcRespond(event, request.id)
@@ -367,34 +336,28 @@ final class NetworkChannel(
         val msg =
           s"unmatched json response for requestId $execId: ${CompactPrinter(Converter.toJsonUnsafe(event))}"
         log.debug(msg)
-    }
   }
 
-  private[sbt] def notifyEvent[A: JsonFormat](method: String, params: A): Unit = {
+  private[sbt] def notifyEvent[A: JsonFormat](method: String, params: A): Unit =
     jsonRpcNotify(method, params)
-  }
 
   def respond[A: JsonFormat](event: A): Unit = respond(event, None)
 
-  def respond[A: JsonFormat](event: A, execId: Option[String]): Unit = if (alive.get) {
-    respondResult(event, execId)
-  }
+  def respond[A: JsonFormat](event: A, execId: Option[String]): Unit =
+    if alive.get then respondResult(event, execId)
 
-  def notifyEvent(event: EventMessage): Unit = {
-    event match {
+  def notifyEvent(event: EventMessage): Unit =
+    event match
       case entry: LogEvent        => logMessage(entry.level, entry.message)
       case entry: ExecStatusEvent =>
-        getPendingRequest(entry.execId) match {
+        getPendingRequest(entry.execId) match
           case Some(request) =>
             logMessage("debug", s"${entry.status} ${request.method}")
           case None =>
             log.debug(
               s"unmatched ${entry.status} event for requestId ${entry.execId}: ${entry.message}"
             )
-        }
       case _ => ()
-    }
-  }
 
   def publishBytes(event: Array[Byte]): Unit = publishBytes(event, false)
 
@@ -402,74 +365,64 @@ final class NetworkChannel(
    * Do writes on a background thread because otherwise the client socket can get blocked.
    */
   private val writeThread = new Thread(
-    () => {
-      @tailrec def impl(): Unit = {
+    () =>
+      @tailrec def impl(): Unit =
         val (event, delimit) =
           try pendingWrites.take
-          catch {
+          catch
             case _: InterruptedException =>
               alive.set(false)
               (Array.empty[Byte], false)
-          }
-        if (alive.get) {
-          try {
+        if alive.get then
+          try
             out.write(event)
-            if (delimit) {
-              out.write(delimiter.toInt)
-            }
+            if delimit then out.write(delimiter.toInt)
             out.flush()
-          } catch {
+          catch
             case _: IOException =>
               alive.set(false)
               shutdown(true)
             case _: InterruptedException =>
               alive.set(false)
-          }
           impl()
-        }
-      }
       impl()
-    },
+    ,
     s"sbt-$name-write-thread"
   )
   writeThread.setDaemon(true)
 
   def publishBytes(event: Array[Byte], delimit: Boolean): Unit =
     try pendingWrites.put(event -> delimit)
-    catch { case _: InterruptedException => }
+    catch
+      case _: InterruptedException =>
 
-  protected def onSettingQuery(execId: Option[String], req: SettingQuery) = {
-    if (initialized) {
+  protected def onSettingQuery(execId: Option[String], req: SettingQuery) =
+    if initialized then
       StandardMain.exchange.withState { s =>
         val structure = Project.extract(s).structure
-        sbt.internal.server.SettingQuery.handleSettingQueryEither(req, structure) match {
+        sbt.internal.server.SettingQuery.handleSettingQueryEither(req, structure) match
           case Right(x) => respondResult(x, execId)
           case Left(s)  => respondError(ErrorCodes.InvalidParams, s, execId)
-        }
       }
-    } else {
-      log.warn(s"ignoring query $req before initialization")
-    }
-  }
+    else log.warn(s"ignoring query $req before initialization")
 
-  protected def onCompletionRequest(execId: Option[String], cp: CompletionParams) = {
-    if (initialized) {
-      try {
+  protected def onCompletionRequest(execId: Option[String], cp: CompletionParams) =
+    if initialized then
+      try
         StandardMain.exchange.withState { sstate =>
-          def completionItems(s: State) = {
+          def completionItems(s: State) =
             Parser
               .completions(s.combinedParser, cp.query, cp.level.getOrElse(9))
               .get
               .flatMap { c =>
-                if (!c.isEmpty) Some(c.append.replaceAll("\n", " "))
+                if !c.isEmpty then Some(c.append.replaceAll("\n", " "))
                 else None
               }
               .map(c => cp.query + c)
-          }
-          val (items, cachedMainClassNames, cachedTestNames) = {
+          val (items, cachedMainClassNames, cachedTestNames) =
             val scopedKeyParser: Parser[Seq[Def.ScopedKey[?]]] =
               Act.aggregatedKeyParser(sstate) <~ Parsers.any.*
-            Parser.parse(cp.query, scopedKeyParser) match {
+            Parser.parse(cp.query, scopedKeyParser) match
               case Right(keys) =>
                 val testKeys =
                   keys.filter(k => k.key.label == "testOnly" || k.key.label == "testQuick")
@@ -479,9 +432,8 @@ final class NetworkChannel(
                       (k.scope / Keys.definedTestNames).scopedKey,
                       st,
                       true
-                    ) match {
+                    ) match
                       case (nst, d) => (nst, allCached && d.isDefined)
-                    }
                 }
                 val runKeys = keys.filter(_.key.label == "runMain")
                 val (runState, cachedMainClassNames) = runKeys.foldLeft((testState, true)) {
@@ -490,14 +442,13 @@ final class NetworkChannel(
                       (k.scope / Keys.discoveredMainClasses).scopedKey,
                       st,
                       true
-                    ) match {
+                    ) match
                       case (nst, d) => (nst, allCached && d.isDefined)
-                    }
                 }
                 (completionItems(runState), cachedMainClassNames, cachedTestNames)
               case _ => (completionItems(sstate), true, true)
-            }
-          }
+            end match
+          end val
           respondResult(
             CompletionResponse(
               items = items.toVector,
@@ -507,21 +458,17 @@ final class NetworkChannel(
             execId
           )
         }
-      } catch {
+      catch
         case NonFatal(_) =>
           respondError(
             ErrorCodes.UnknownError,
             "Completions request failed",
             execId
           )
-      }
-    } else {
-      log.warn(s"ignoring completion request $cp before initialization")
-    }
-  }
+    else log.warn(s"ignoring completion request $cp before initialization")
 
-  protected def onCancellationRequest(execId: Option[String], crp: CancelRequestParams) = {
-    if (initialized) {
+  protected def onCancellationRequest(execId: Option[String], crp: CancelRequestParams) =
+    if initialized then
 
       def errorRespond(msg: String) = respondError(
         ErrorCodes.RequestCancelled,
@@ -529,8 +476,8 @@ final class NetworkChannel(
         execId
       )
 
-      try {
-        Option(EvaluateTask.currentlyRunningTaskEngine.get) match {
+      try
+        Option(EvaluateTask.currentlyRunningTaskEngine.get) match
           case Some(runningEngine) =>
             val runningExecId =
               StandardMain.exchange.withState(_.currentCommand.flatMap(_.execId).getOrElse(""))
@@ -540,24 +487,21 @@ final class NetworkChannel(
                 .getOrElse(crp.id)
             )
 
-            def checkId(): Boolean = {
-              if (runningExecId.startsWith("\u2668")) {
+            def checkId(): Boolean =
+              if runningExecId.startsWith("\u2668") then
                 (
                   Try { crp.id.toLong }.toOption,
                   Try { runningExecId.substring(1).toLong }.toOption
-                ) match {
+                ) match
                   case (Some(id), Some(eid)) => id == eid
                   case _                     => false
-                }
-              } else runningExecId == expected
-            }
+              else runningExecId == expected
 
             // direct comparison on strings and
             // remove hotspring unicode added character for numbers
-            if (
-              checkId() || (crp.id == Serialization.CancelAll &&
+            if checkId() || (crp.id == Serialization.CancelAll &&
                 StandardMain.exchange.currentExec.exists(_.source.exists(_.channelName == name)))
-            ) {
+            then
               runningEngine.cancelAndShutdown()
               isCanceled.set(true)
               discardPending()
@@ -572,26 +516,19 @@ final class NetworkChannel(
                 ),
                 execId
               )
-            } else {
-              errorRespond("Task ID not matched")
-            }
+            else errorRespond("Task ID not matched")
 
           case None =>
             errorRespond("No tasks under execution")
-        }
-      } catch {
+      catch
         case NonFatal(_) =>
           errorRespond("Cancel request failed")
-      }
-    } else {
-      log.warn(s"ignoring cancellation request $crp before initialization")
-    }
-  }
+      end try
+    else log.warn(s"ignoring cancellation request $crp before initialization")
 
   @deprecated("Use variant that takes logShutdown parameter", "1.4.0")
-  override def shutdown(): Unit = {
+  override def shutdown(): Unit =
     shutdown(true)
-  }
 
   override def shutdown(logShutdown: Boolean): Unit =
     shutdown(logShutdown, remainingCommands = None)
@@ -607,30 +544,29 @@ final class NetworkChannel(
   private[sbt] def shutdown(
       logShutdown: Boolean,
       remainingCommands: Option[(String, String)]
-  ): Unit = {
+  ): Unit =
     doFlush()
     flusher.close()
     terminal.close()
     StandardMain.exchange.removeChannel(this)
     super.shutdown(logShutdown)
-    if (logShutdown) Terminal.consoleLog(s"shutting down client connection $name")
+    if logShutdown then Terminal.consoleLog(s"shutting down client connection $name")
     VirtualTerminal.cancelRequests(name)
     try jsonRpcNotify(Shutdown, (logShutdown, remainingCommands))
-    catch { case _: IOException => }
+    catch
+      case _: IOException =>
     running.set(false)
     out.close()
     outputStream.close()
     thread.interrupt()
     writeThread.interrupt()
-  }
 
   /** Respond back to Language Server's client. */
-  private[sbt] def jsonRpcRespond[A: JsonFormat](event: A, execId: String): Unit = {
+  private[sbt] def jsonRpcRespond[A: JsonFormat](event: A, execId: String): Unit =
     val m =
       JsonRpcResponseMessage("2.0", execId, Option(Converter.toJson[A](event).get), None)
     val bytes = Serialization.serializeResponseMessage(m)
     publishBytes(bytes)
-  }
 
   /** Respond back to Language Server's client. */
   private[sbt] def jsonRpcRespondError[A: JsonFormat](
@@ -638,79 +574,69 @@ final class NetworkChannel(
       code: Long,
       message: String,
       data: A,
-  ): Unit = {
+  ): Unit =
     val err = JsonRpcResponseError(code, message, Converter.toJson[A](data).get)
     jsonRpcRespondError(execId, err)
-  }
 
   private[sbt] def jsonRpcRespondError(
       execId: String,
       err: JsonRpcResponseError
-  ): Unit = {
+  ): Unit =
     forceFlush()
     val m = JsonRpcResponseMessage("2.0", execId, None, Option(err))
     val bytes = Serialization.serializeResponseMessage(m)
     publishBytes(bytes)
-  }
 
   /** Notify to Language Server's client. */
   private[sbt] def jsonRpcNotify[A: JsonFormat](method: String, params: A): Unit =
-    if (isCanceled.get && NetworkChannel.isCanceledOutput(method))
-      ()
-    else {
+    if isCanceled.get && NetworkChannel.isCanceledOutput(method) then ()
+    else
       val m =
         JsonRpcNotificationMessage("2.0", method, Option(Converter.toJson[A](params).get))
-      if (method != Serialization.systemOut) {
+      if method != Serialization.systemOut then
         forceFlush()
         log.debug(s"jsonRpcNotify: $m")
-      }
       val bytes = Serialization.serializeNotificationMessage(m)
       publishBytes(bytes)
-    }
 
   /** Notify to Language Server's client. */
-  private[sbt] def jsonRpcRequest[A: JsonFormat](id: String, method: String, params: A): Unit = {
+  private[sbt] def jsonRpcRequest[A: JsonFormat](id: String, method: String, params: A): Unit =
     forceFlush()
     val m =
       JsonRpcRequestMessage("2.0", id, method, Option(Converter.toJson[A](params).get))
     log.debug(s"jsonRpcRequest: $m")
     val bytes = Serialization.serializeRequestMessage(m)
     publishBytes(bytes)
-  }
 
-  def logMessage(level: String, message: String): Unit = {
+  def logMessage(level: String, message: String): Unit =
     import sbt.internal.langserver.codec.JsonProtocol.given
     jsonRpcNotify(
       "build/logMessage",
       LogMessageParams(MessageType.fromLevelString(level), message)
     )
-  }
 
-  private lazy val inputStream: InputStream = new Terminal.SimpleInputStream {
-    override def read(): Int = {
+  private lazy val inputStream: InputStream = new Terminal.SimpleInputStream:
+    override def read(): Int =
       import sjsonnew.BasicJsonProtocol.*
-      try {
+      try
         jsonRpcNotify(readSystemIn, "")
         inputBuffer.take
-      } catch {
+      catch
         case e: IOException =>
           try jsonRpcNotify(cancelReadSystemIn, "")
-          catch { case _: IOException => }
+          catch
+            case _: IOException =>
           -1
-      }
-    }
     override def available(): Int = inputBuffer.size
-  }
   private lazy val writeableInputStream: Terminal.WriteableInputStream =
     new Terminal.WriteableInputStream(inputStream, name)
   import sjsonnew.BasicJsonProtocol.*
 
   import scala.jdk.CollectionConverters.*
   private val outputBuffer = new LinkedBlockingQueue[Byte]
-  private def discardPending(): Unit = {
+  private def discardPending(): Unit =
     pendingWrites.clear()
     outputBuffer.synchronized(outputBuffer.clear())
-  }
 
   // Batches writes to the client at most once per 20ms to cut terminal flicker (see
   // CoalescingFlusher). forceFlush drains now while leaving the timer live.
@@ -726,14 +652,12 @@ final class NetworkChannel(
   private def doFlush(): Unit = flushLock.synchronized {
     val list = new java.util.ArrayList[Byte]
     outputBuffer.synchronized(outputBuffer.drainTo(list))
-    if (!list.isEmpty) jsonRpcNotify(Serialization.systemOut, list.asScala.toSeq)
+    if !list.isEmpty then jsonRpcNotify(Serialization.systemOut, list.asScala.toSeq)
   }
 
-  private lazy val outputStream: OutputStream & AutoCloseable = new OutputStream
-    with AutoCloseable {
-    override def close(): Unit = {
+  private lazy val outputStream: OutputStream & AutoCloseable = new OutputStream with AutoCloseable:
+    override def close(): Unit =
       forceFlush()
-    }
     override def write(b: Int): Unit = outputBuffer.synchronized {
       outputBuffer.put(b.toByte)
     }
@@ -741,80 +665,67 @@ final class NetworkChannel(
     override def write(b: Array[Byte]): Unit = outputBuffer.synchronized {
       b.foreach(outputBuffer.put)
     }
-    override def write(b: Array[Byte], off: Int, len: Int): Unit = {
+    override def write(b: Array[Byte], off: Int, len: Int): Unit =
       write(java.util.Arrays.copyOfRange(b, off, off + len))
-    }
-  }
-  private lazy val errorStream: OutputStream = new OutputStream {
+  private lazy val errorStream: OutputStream = new OutputStream:
     private val buffer = new LinkedBlockingQueue[Byte]
     override def write(b: Int): Unit = buffer.synchronized {
       buffer.put(b.toByte)
     }
-    override def flush(): Unit = {
+    override def flush(): Unit =
       val list = new java.util.ArrayList[Byte]
       buffer.synchronized(buffer.drainTo(list))
-      if (!list.isEmpty) jsonRpcNotify(Serialization.systemErr, list.asScala.toSeq)
-    }
+      if !list.isEmpty then jsonRpcNotify(Serialization.systemErr, list.asScala.toSeq)
     override def write(b: Array[Byte]): Unit = buffer.synchronized {
       b.foreach(buffer.put)
     }
-    override def write(b: Array[Byte], off: Int, len: Int): Unit = {
+    override def write(b: Array[Byte], off: Int, len: Int): Unit =
       write(java.util.Arrays.copyOfRange(b, off, off + len))
-    }
-  }
   private class NetworkTerminal
-      extends TerminalImpl(writeableInputStream, outputStream, errorStream, name) { term =>
+      extends TerminalImpl(writeableInputStream, outputStream, errorStream, name):
+    term =>
     private val pending = new AtomicBoolean(false)
     private val closed = new AtomicBoolean(false)
     private val properties = new AtomicReference[TerminalPropertiesResponse]
     private val lastUpdate = new AtomicReference[Deadline]
     private def empty = TerminalPropertiesResponse(0, 0, false, false, false, false)
-    def getProperties(block: Boolean): Unit = {
-      if (alive.get) {
-        if (!pending.get && Option(lastUpdate.get).fold(true)(d => (d + 1.second).isOverdue())) {
+    def getProperties(block: Boolean): Unit =
+      if alive.get then
+        if !pending.get && Option(lastUpdate.get).fold(true)(d => (d + 1.second).isOverdue()) then
           pending.set(true)
           val queue = VirtualTerminal.sendTerminalPropertiesQuery(term.name, jsonRpcRequest)
-          val update: Runnable = () => {
-            try {
-              queue.poll(5, java.util.concurrent.TimeUnit.SECONDS) match {
+          val update: Runnable = () =>
+            try
+              queue.poll(5, java.util.concurrent.TimeUnit.SECONDS) match
                 case null =>
-                  VirtualTerminal.expireTerminalPropertiesQuery(term.name, queue) match {
+                  VirtualTerminal.expireTerminalPropertiesQuery(term.name, queue) match
                     case Some(late) => properties.set(late)
                     case None       => Util.ignoreResult(properties.compareAndSet(null, empty))
-                  }
                 case t => properties.set(t)
-              }
-            } finally {
+            finally
               pending.synchronized {
                 lastUpdate.set(Deadline.now)
                 pending.set(false)
                 pending.notifyAll()
               }
-            }
-          }
-          new Thread(update, s"network-terminal-${term.name}-update") {
+          new Thread(update, s"network-terminal-${term.name}-update"):
             setDaemon(true)
-          }.start()
-        }
+          .start()
         // The updater clears pending inside this monitor before notifying.
         pending.synchronized {
-          while (block && properties.get == null && pending.get) pending.wait()
+          while block && properties.get == null && pending.get do pending.wait()
         }
         ()
-      } else throw new InterruptedException
-    }
-    private def withThread[R](f: => R, default: R): R = {
+      else throw new InterruptedException
+    private def withThread[R](f: => R, default: R): R =
       val t = Thread.currentThread
-      try {
+      try
         blockedThreads.synchronized(blockedThreads.add(t))
         f
-      } catch { case _: InterruptedException => default }
-      finally {
-        Util.ignoreResult(blockedThreads.synchronized(blockedThreads.remove(t)))
-      }
-    }
-    def getProperty[T](f: TerminalPropertiesResponse => T, default: T): Option[T] = {
-      if (closed.get || !isAttached) None
+      catch case _: InterruptedException => default
+      finally Util.ignoreResult(blockedThreads.synchronized(blockedThreads.remove(t)))
+    def getProperty[T](f: TerminalPropertiesResponse => T, default: T): Option[T] =
+      if closed.get || !isAttached then None
       else
         withThread(
           {
@@ -823,18 +734,16 @@ final class NetworkChannel(
           },
           None
         )
-    }
-    private def waitForPending(f: TerminalPropertiesResponse => Boolean): Boolean = {
-      if (closed.get || !isAttached) false
+    private def waitForPending(f: TerminalPropertiesResponse => Boolean): Boolean =
+      if closed.get || !isAttached then false
       else
         withThread(
           {
-            pending.synchronized { while (pending.get) pending.wait() }
+            pending.synchronized { while pending.get do pending.wait() }
             Option(properties.get).map(f).getOrElse(false)
           },
           false
         )
-    }
     private val blockedThreads = ConcurrentHashMap.newKeySet[Thread]
     override private[sbt] val progressState: ProgressState = new ProgressState(
       1,
@@ -895,13 +804,13 @@ final class NetworkChannel(
       ).getOrElse("")
 
     override private[sbt] def getAttributes: Map[String, String] =
-      if (closed.get) Map.empty
-      else {
+      if closed.get then Map.empty
+      else
         val queue = VirtualTerminal.sendTerminalAttributesQuery(
           term.name,
           jsonRpcRequest[TerminalAttributesQuery]
         )
-        try {
+        try
           val a = queue.take
           Map(
             "iflag" -> a.iflag,
@@ -910,10 +819,9 @@ final class NetworkChannel(
             "lflag" -> a.lflag,
             "cchars" -> a.cchars
           )
-        } catch { case _: InterruptedException => Map.empty }
-      }
+        catch case _: InterruptedException => Map.empty
     override private[sbt] def setAttributes(attributes: Map[String, String]): Unit =
-      if (!closed.get) {
+      if !closed.get then
         val attrs = TerminalSetAttributesCommand(
           iflag = attributes.getOrElse("iflag", ""),
           oflag = attributes.getOrElse("oflag", ""),
@@ -927,27 +835,27 @@ final class NetworkChannel(
           attrs
         )
         try queue.take
-        catch { case _: InterruptedException => }
-      }
+        catch
+          case _: InterruptedException =>
     override private[sbt] def getSizeImpl: (Int, Int) =
-      if (!closed.get) {
+      if !closed.get then
         val queue =
           VirtualTerminal.getTerminalSize(term.name, jsonRpcRequest[TerminalGetSizeQuery])
         val res =
           try queue.take
-          catch { case _: InterruptedException => TerminalGetSizeResponse(1, 1) }
+          catch case _: InterruptedException => TerminalGetSizeResponse(1, 1)
         (res.width, res.height)
-      } else (1, 1)
+      else (1, 1)
     override def setSize(width: Int, height: Int): Unit =
-      if (!closed.get) {
+      if !closed.get then
         val size = TerminalSetSizeCommand(width, height)
         val queue =
           VirtualTerminal.setTerminalSize(term.name, jsonRpcRequest[TerminalSetSizeCommand], size)
         try queue.take
-        catch { case _: InterruptedException => }
-      }
-    private def setRawMode(toggle: Boolean): Unit = {
-      if (!closed.get || false) {
+        catch
+          case _: InterruptedException =>
+    private def setRawMode(toggle: Boolean): Unit =
+      if !closed.get || false then
         val raw = TerminalSetRawModeCommand(toggle)
         val queue = VirtualTerminal.setTerminalRawMode(
           term.name,
@@ -955,23 +863,21 @@ final class NetworkChannel(
           raw
         )
         try queue.take
-        catch { case _: InterruptedException => }
-      }
-    }
+        catch
+          case _: InterruptedException =>
     override private[sbt] def enterRawMode(): Unit = setRawMode(true)
     override private[sbt] def exitRawMode(): Unit = setRawMode(false)
     override def setEchoEnabled(toggle: Boolean): Unit =
-      if (!closed.get) {
+      if !closed.get then
         val echo = TerminalSetEchoCommand(toggle)
         val queue =
           VirtualTerminal.setTerminalEcho(term.name, jsonRpcRequest[TerminalSetEchoCommand], echo)
         try queue.take
-        catch { case _: InterruptedException => () }
-      }
+        catch case _: InterruptedException => ()
 
     override def flush(): Unit = doFlush()
     override def toString: String = s"NetworkTerminal(${term.name})"
-    override def close(): Unit = if (closed.compareAndSet(false, true)) {
+    override def close(): Unit = if closed.compareAndSet(false, true) then
       val threads = blockedThreads.synchronized {
         val t = blockedThreads.asScala.toVector
         blockedThreads.clear()
@@ -979,16 +885,15 @@ final class NetworkChannel(
       }
       threads.foreach(_.interrupt())
       super.close()
-    }
-  }
+  end NetworkTerminal
   private[sbt] def isAttached: Boolean = attached.get
   private[sbt] def isInitialized: Boolean = initialized
 
   thread.start()
   writeThread.start()
-}
+end NetworkChannel
 
-object NetworkChannel {
+object NetworkChannel:
   private[server] def isCanceledOutput(method: String): Boolean =
     method == Serialization.systemOut || method == Serialization.systemErr
 
@@ -1003,38 +908,32 @@ object NetworkChannel {
       execID: Option[String],
       id: String,
       force: Boolean
-  ): Either[String, String] = {
+  ): Either[String, String] =
 
-    Option(EvaluateTask.currentlyRunningTaskEngine.get) match {
+    Option(EvaluateTask.currentlyRunningTaskEngine.get) match
       case Some(runningEngine) =>
         val runningExecId =
           StandardMain.exchange.withState(_.currentCommand.flatMap(_.execId).getOrElse(""))
 
-        def checkId(): Boolean = {
-          if (runningExecId.startsWith("\u2668")) {
+        def checkId(): Boolean =
+          if runningExecId.startsWith("\u2668") then
             (
               Try { id.toLong }.toOption,
               Try { runningExecId.substring(1).toLong }.toOption
-            ) match {
+            ) match
               case (Some(id), Some(eid)) => id == eid
               case _                     => false
-            }
-          } else runningExecId == id
-        }
+          else runningExecId == id
 
         // direct comparison on strings and
         // remove hotspring unicode added character for numbers
-        if (checkId() || force) {
+        if checkId() || force then
           runningEngine.cancelAndShutdown()
           Right(runningExecId)
-        } else {
-          Left("Task ID not matched")
-        }
+        else Left("Task ID not matched")
 
       case None =>
         Left("No tasks under execution")
-    }
-  }
 
   private[sbt] val disconnect: Command =
     Command.arb { s =>
@@ -1044,4 +943,4 @@ object NetworkChannel {
       StandardMain.exchange.killChannel(channel.mkString)
       st
     }
-}
+end NetworkChannel
diff --git a/main/src/main/scala/sbt/internal/server/SettingQuery.scala b/main/src/main/scala/sbt/internal/server/SettingQuery.scala
index dea9054e8..d63a25e5b 100644
--- a/main/src/main/scala/sbt/internal/server/SettingQuery.scala
+++ b/main/src/main/scala/sbt/internal/server/SettingQuery.scala
@@ -18,7 +18,7 @@ import sbt.protocol.*
 import sjsonnew.*
 import sjsonnew.support.scalajson.unsafe.*
 
-object SettingQuery {
+object SettingQuery:
   import sbt.internal.util.AttributeKey
   import sbt.internal.util.complete.{ DefaultParsers, Parser }, DefaultParsers.*
   import sbt.Def.{ showBuildRelativeKey2, ScopedKey }
@@ -35,25 +35,23 @@ object SettingQuery {
   def projectRef(
       index: KeyIndex,
       currentBuild: URI
-  ): Parser[ParsedExplicitAxis[ResolvedReference]] = {
+  ): Parser[ParsedExplicitAxis[ResolvedReference]] =
     val global = token(Act.GlobalIdent ~ '/') ^^^ ParsedExplicitGlobal
     val trailing = '/' !!! "Expected '/' (if selecting a project)"
     global | explicitValue(Act.resolvedReference(index, currentBuild, trailing))
-  }
 
   def resolveProject(parsed: ParsedExplicitAxis[ResolvedReference]): Option[ResolvedReference] =
-    parsed match {
+    parsed match
       case ParsedExplicitGlobal       => None
       case pv: ParsedExplicitValue[?] => Some(pv.value)
-    }
 
   def scopedKeyFull(
       index: KeyIndex,
       currentBuild: URI,
       defaultConfigs: Option[ResolvedReference] => Seq[String],
       keyMap: Map[String, AttributeKey[?]]
-  ): Parser[Seq[Parser[ParsedKey]]] = {
-    for {
+  ): Parser[Seq[Parser[ParsedKey]]] =
+    for
       rawProject <- projectRef(index, currentBuild)
       proj = resolveProject(rawProject)
       confAmb <- Act.configIdent(
@@ -62,8 +60,7 @@ object SettingQuery {
         index.fromConfigIdent(proj)
       )
       partialMask = ScopeMask(true, confAmb.isExplicit, false, false)
-    } yield Act.taskKeyExtra(index, defaultConfigs, keyMap, proj, confAmb, partialMask)
-  }
+    yield Act.taskKeyExtra(index, defaultConfigs, keyMap, proj, confAmb, partialMask)
 
   def scopedKeySelected(
       index: KeyIndex,
@@ -106,10 +103,9 @@ object SettingQuery {
       }
 
   def getJsonWriter[A](key: AttributeKey[A]): Either[String, JsonWriter[A]] =
-    key.optJsonWriter match {
+    key.optJsonWriter match
       case SomeJsonWriter(jw) => Right(jw)
       case NoJsonWriter()     => Left(s"JsonWriter for ${key.tag} not found")
-    }
 
   def toJson[A: JsonWriter](x: A): JValue = Converter.toJsonUnsafe(x)
 
@@ -126,18 +122,16 @@ object SettingQuery {
   def handleSettingQueryEither(
       req: SettingQuery,
       structure: BuildStructure
-  ): Either[String, SettingQuerySuccess] = {
+  ): Either[String, SettingQuerySuccess] =
     val key = Parser.parse(req.setting, scopedKeyParser(structure))
 
-    for {
+    for
       key <- key
       json <- getSettingJsonValue(structure, key)
-    } yield SettingQuerySuccess(json, key.key.tag.toString)
-  }
+    yield SettingQuerySuccess(json, key.key.tag.toString)
 
   def handleSettingQuery(req: SettingQuery, structure: BuildStructure): SettingQueryResponse =
-    handleSettingQueryEither(req, structure) match {
+    handleSettingQueryEither(req, structure) match
       case Right(x) => x
       case Left(s)  => SettingQueryFailure(s)
-    }
-}
+end SettingQuery
diff --git a/main/src/main/scala/sbt/internal/server/VirtualTerminal.scala b/main/src/main/scala/sbt/internal/server/VirtualTerminal.scala
index 6f124dc40..60003a7f9 100644
--- a/main/src/main/scala/sbt/internal/server/VirtualTerminal.scala
+++ b/main/src/main/scala/sbt/internal/server/VirtualTerminal.scala
@@ -48,7 +48,7 @@ import sbt.protocol.{
 }
 import sbt.protocol.codec.JsonProtocol.given
 
-object VirtualTerminal {
+object VirtualTerminal:
   private val pendingTerminalProperties =
     new ConcurrentHashMap[(String, String), ArrayBlockingQueue[TerminalPropertiesResponse]]()
   private val pendingTerminalCapabilities =
@@ -68,38 +68,34 @@ object VirtualTerminal {
   private[sbt] def sendTerminalPropertiesQuery(
       channelName: String,
       jsonRpcRequest: (String, String, String) => Unit
-  ): ArrayBlockingQueue[TerminalPropertiesResponse] = {
+  ): ArrayBlockingQueue[TerminalPropertiesResponse] =
     val id = UUID.randomUUID.toString
     val queue = new ArrayBlockingQueue[TerminalPropertiesResponse](1)
     pendingTerminalProperties.put((channelName, id), queue)
     jsonRpcRequest(id, terminalPropertiesQuery, "")
     queue
-  }
   private[sbt] def sendTerminalCapabilitiesQuery(
       channelName: String,
       jsonRpcRequest: (String, String, TerminalCapabilitiesQuery) => Unit,
       query: TerminalCapabilitiesQuery,
-  ): ArrayBlockingQueue[TerminalCapabilitiesResponse] = {
+  ): ArrayBlockingQueue[TerminalCapabilitiesResponse] =
     val id = UUID.randomUUID.toString
     val queue = new ArrayBlockingQueue[TerminalCapabilitiesResponse](1)
     pendingTerminalCapabilities.put((channelName, id), queue)
     jsonRpcRequest(id, terminalCapabilities, query)
     queue
-  }
   private[sbt] def expireTerminalPropertiesQuery(
       channelName: String,
       queue: ArrayBlockingQueue[TerminalPropertiesResponse],
-  ): Option[TerminalPropertiesResponse] = {
+  ): Option[TerminalPropertiesResponse] =
     import scala.jdk.CollectionConverters.*
     pendingTerminalProperties.asScala.collectFirst {
       case (k @ (`channelName`, _), q) if q eq queue => k
-    } match {
+    } match
       case Some(k) if pendingTerminalProperties.remove(k) != null => Option(queue.poll())
       // The response handler won the removal: its put is imminent, wait it out briefly.
       case _ => Option(queue.poll(100, java.util.concurrent.TimeUnit.MILLISECONDS))
-    }
-  }
-  private[sbt] def cancelRequests(name: String): Unit = {
+  private[sbt] def cancelRequests(name: String): Unit =
     import scala.jdk.CollectionConverters.*
     def drain[A](
         map: ConcurrentHashMap[(String, String), ArrayBlockingQueue[A]],
@@ -119,76 +115,69 @@ object VirtualTerminal {
     drain(pendingTerminalGetSize, TerminalGetSizeResponse(1, 1))
     drain(pendingTerminalSetEcho, ())
     drain(pendingTerminalSetRawMode, ())
-  }
   private[sbt] def sendTerminalAttributesQuery(
       channelName: String,
       jsonRpcRequest: (String, String, TerminalAttributesQuery) => Unit,
-  ): ArrayBlockingQueue[TerminalAttributesResponse] = {
+  ): ArrayBlockingQueue[TerminalAttributesResponse] =
     val id = UUID.randomUUID.toString
     val queue = new ArrayBlockingQueue[TerminalAttributesResponse](1)
     pendingTerminalAttributes.put((channelName, id), queue)
     jsonRpcRequest(id, getTerminalAttributes, TerminalAttributesQuery())
     queue
-  }
   private[sbt] def setTerminalAttributesCommand(
       channelName: String,
       jsonRpcRequest: (String, String, TerminalSetAttributesCommand) => Unit,
       query: TerminalSetAttributesCommand
-  ): ArrayBlockingQueue[Unit] = {
+  ): ArrayBlockingQueue[Unit] =
     val id = UUID.randomUUID.toString
     val queue = new ArrayBlockingQueue[Unit](1)
     pendingTerminalSetAttributes.put((channelName, id), queue)
     jsonRpcRequest(id, setTerminalAttributes, query)
     queue
-  }
 
   private[sbt] def setTerminalSize(
       channelName: String,
       jsonRpcRequest: (String, String, TerminalSetSizeCommand) => Unit,
       query: TerminalSetSizeCommand
-  ): ArrayBlockingQueue[Unit] = {
+  ): ArrayBlockingQueue[Unit] =
     val id = UUID.randomUUID.toString
     val queue = new ArrayBlockingQueue[Unit](1)
     pendingTerminalSetSize.put((channelName, id), queue)
     jsonRpcRequest(id, terminalSetSize, query)
     queue
-  }
 
   private[sbt] def getTerminalSize(
       channelName: String,
       jsonRpcRequest: (String, String, TerminalGetSizeQuery) => Unit,
-  ): ArrayBlockingQueue[TerminalGetSizeResponse] = {
+  ): ArrayBlockingQueue[TerminalGetSizeResponse] =
     val id = UUID.randomUUID.toString
     val query = TerminalGetSizeQuery()
     val queue = new ArrayBlockingQueue[TerminalGetSizeResponse](1)
     pendingTerminalGetSize.put((channelName, id), queue)
     jsonRpcRequest(id, terminalGetSize, query)
     queue
-  }
 
   private[sbt] def setTerminalEcho(
       channelName: String,
       jsonRpcRequest: (String, String, TerminalSetEchoCommand) => Unit,
       query: TerminalSetEchoCommand
-  ): ArrayBlockingQueue[Unit] = {
+  ): ArrayBlockingQueue[Unit] =
     val id = UUID.randomUUID.toString
     val queue = new ArrayBlockingQueue[Unit](1)
     pendingTerminalSetEcho.put((channelName, id), queue)
     jsonRpcRequest(id, terminalSetEcho, query)
     queue
-  }
 
   private[sbt] def setTerminalRawMode(
       channelName: String,
       jsonRpcRequest: (String, String, TerminalSetRawModeCommand) => Unit,
       query: TerminalSetRawModeCommand
-  ): ArrayBlockingQueue[Unit] = {
+  ): ArrayBlockingQueue[Unit] =
     val id = UUID.randomUUID.toString
     val queue = new ArrayBlockingQueue[Unit](1)
     pendingTerminalSetRawMode.put((channelName, id), queue)
     jsonRpcRequest(id, terminalSetRawMode, query)
     queue
-  }
 
   val handler = ServerHandler { cb =>
     ServerIntent(requestHandler(cb), responseHandler(cb), notificationHandler(cb))
@@ -197,15 +186,14 @@ object VirtualTerminal {
   private val requestHandler: Handler[JsonRpcRequestMessage] =
     callback => {
       case r if r.method == attach =>
-        if (callback.isAuthenticated) {
+        if callback.isAuthenticated then
           val isInteractive = r.params
             .flatMap(Converter.fromJson[Attach](_).toOption.map(_.interactive))
             .exists(identity)
-          StandardMain.exchange.channelForName(callback.name) match {
+          StandardMain.exchange.channelForName(callback.name) match
             case Some(nc: NetworkChannel) => nc.setInteractive(r.id, isInteractive)
             case _                        =>
-          }
-        } else
+        else
           callback.jsonRpcRespondError(
             Some(r.id),
             ErrorCodes.InvalidRequest,
@@ -217,70 +205,61 @@ object VirtualTerminal {
       case r if pendingTerminalProperties.get((callback.name, r.id)) != null =>
         val response =
           r.result.flatMap(Converter.fromJson[TerminalPropertiesResponse](_).toOption)
-        pendingTerminalProperties.remove((callback.name, r.id)) match {
+        pendingTerminalProperties.remove((callback.name, r.id)) match
           case null   =>
           case buffer =>
             buffer.put(
               response.getOrElse(TerminalPropertiesResponse(0, 0, false, false, false, false))
             )
-        }
       case r if pendingTerminalCapabilities.get((callback.name, r.id)) != null =>
         val response =
           r.result.flatMap(
             Converter.fromJson[TerminalCapabilitiesResponse](_).toOption
           )
-        pendingTerminalCapabilities.remove((callback.name, r.id)) match {
+        pendingTerminalCapabilities.remove((callback.name, r.id)) match
           case null   =>
           case buffer =>
             buffer.put(response.getOrElse(TerminalCapabilitiesResponse(None, None, None)))
-        }
       case r if pendingTerminalAttributes.get((callback.name, r.id)) != null =>
         val response =
           r.result.flatMap(Converter.fromJson[TerminalAttributesResponse](_).toOption)
-        pendingTerminalAttributes.remove((callback.name, r.id)) match {
+        pendingTerminalAttributes.remove((callback.name, r.id)) match
           case null   =>
           case buffer =>
             buffer.put(response.getOrElse(TerminalAttributesResponse("", "", "", "", "")))
-        }
       case r if pendingTerminalSetAttributes.get((callback.name, r.id)) != null =>
-        pendingTerminalSetAttributes.remove((callback.name, r.id)) match {
+        pendingTerminalSetAttributes.remove((callback.name, r.id)) match
           case null   =>
           case buffer => buffer.put(())
-        }
       case r if pendingTerminalSetSize.get((callback.name, r.id)) != null =>
-        pendingTerminalSetSize.remove((callback.name, r.id)) match {
+        pendingTerminalSetSize.remove((callback.name, r.id)) match
           case null   =>
           case buffer => buffer.put(())
-        }
       case r if pendingTerminalGetSize.get((callback.name, r.id)) != null =>
         val response =
           r.result.flatMap(Converter.fromJson[TerminalGetSizeResponse](_).toOption)
-        pendingTerminalGetSize.remove((callback.name, r.id)) match {
+        pendingTerminalGetSize.remove((callback.name, r.id)) match
           case null   =>
           case buffer => buffer.put(response.getOrElse(TerminalGetSizeResponse(1, 1)))
-        }
       case r if pendingTerminalSetEcho.get((callback.name, r.id)) != null =>
-        pendingTerminalSetEcho.remove((callback.name, r.id)) match {
+        pendingTerminalSetEcho.remove((callback.name, r.id)) match
           case null   =>
           case buffer => buffer.put(())
-        }
       case r if pendingTerminalSetRawMode.get((callback.name, r.id)) != null =>
-        pendingTerminalSetRawMode.remove((callback.name, r.id)) match {
+        pendingTerminalSetRawMode.remove((callback.name, r.id)) match
           case null   =>
           case buffer => buffer.put(())
-        }
     }
   private val notificationHandler: Handler[JsonRpcNotificationMessage] =
     callback => {
       case n if n.method == systemIn =>
-        if (callback.isAuthenticated) {
+        if callback.isAuthenticated then
           import sjsonnew.BasicJsonProtocol.*
           n.params.flatMap(Converter.fromJson[Byte](_).toOption).foreach { byte =>
-            StandardMain.exchange.channelForName(callback.name) match {
+            StandardMain.exchange.channelForName(callback.name) match
               case Some(nc: NetworkChannel) => nc.write(byte)
               case _                        =>
-            }
           }
-        } else callback.log.warn(s"ignoring '$systemIn' before authentication")
+        else callback.log.warn(s"ignoring '$systemIn' before authentication")
     }
-}
+end VirtualTerminal
diff --git a/main/src/main/scala/sbt/nio/CheckBuildSources.scala b/main/src/main/scala/sbt/nio/CheckBuildSources.scala
index 5c952c88f..08945efd5 100644
--- a/main/src/main/scala/sbt/nio/CheckBuildSources.scala
+++ b/main/src/main/scala/sbt/nio/CheckBuildSources.scala
@@ -46,7 +46,7 @@ import scala.io.AnsiColor
  * 0.seconds, then it will poll every time. Otherwise, it will only repoll
  * the build files if the poll interval has elapsed.
  */
-private[sbt] class CheckBuildSources extends AutoCloseable {
+private[sbt] class CheckBuildSources extends AutoCloseable:
   private val repository = AtomicCloseable[FileTreeRepository[FileAttributes]]()
   private val pollingPeriod = new AtomicReference[FiniteDuration]
   private val sources = new AtomicReference[Seq[Glob]](Nil)
@@ -55,43 +55,39 @@ private[sbt] class CheckBuildSources extends AutoCloseable {
   private val previousStamps = new AtomicReference[Seq[(Path, FileStamp)]](Nil)
   private[sbt] def fileTreeRepository: Option[FileTreeRepository[FileAttributes]] =
     Option(repository.get)
-  private def getStamps(force: Boolean) = {
+  private def getStamps(force: Boolean) =
     val now = SDeadline.now
     val lp = lastPolled.getAndSet(now)
-    if (force || lp + pollingPeriod.get <= now) {
+    if force || lp + pollingPeriod.get <= now then
       FileTreeView.default.list(sources.get) flatMap {
         case (p, a) if a.isRegularFile => FileStamp.hash(p).map(p -> _)
         case _                         => None
       }
-    } else previousStamps.get
-  }
-  private def reset(state: State): Unit = {
+    else previousStamps.get
+  private def reset(state: State): Unit =
     val extracted = Project.extract(state)
     val interval = extracted
       .getOpt(checkBuildSources / pollInterval)
       .getOrElse(CheckBuildSources.defaultPollInterval)
     val newSources = extracted.get(Global / checkBuildSources / fileInputs).distinct
-    if (interval >= 0.seconds || "polling" == SysProp.watchMode) {
+    if interval >= 0.seconds || "polling" == SysProp.watchMode then
       repository.close()
       pollingPeriod.set(interval)
-    } else {
+    else
       pollingPeriod.set(0.seconds)
-      repository.get match {
+      repository.get match
         case null =>
           val repo = FileTreeRepository.default
           repo.addObserver(_ => needUpdate.set(true))
           repository.set(repo)
           newSources.foreach(g => repo.register(g).foreach(_.close()))
         case r =>
-      }
-    }
     val previousSources = sources.getAndSet(newSources)
-    if (previousSources != newSources) {
+    if previousSources != newSources then
       fileTreeRepository.foreach(r => newSources.foreach(g => r.register(g).foreach(_.close())))
       previousStamps.set(getStamps(force = true))
-    }
-  }
-  private def needCheck(state: State, cmd: String): Boolean = {
+  end reset
+  private def needCheck(state: State, cmd: String): Boolean =
     val allCmds = state.remainingCommands
       .map(_.commandLine)
       .dropWhile(!_.startsWith(BasicCommandStrings.MapExec)) :+ cmd
@@ -101,58 +97,51 @@ private[sbt] class CheckBuildSources extends AutoCloseable {
       c == LoadProject || c == BuildServerProtocol.bspReload || c == RebootCommand || c == TerminateAction || c == Shutdown ||
         c.startsWith("sbtReboot")
     val resetState = commands.exists(filter)
-    if (resetState) {
+    if resetState then
       previousStamps.set(getStamps(force = true))
       needUpdate.set(false)
-    }
     // We don't need to do a check since we just updated the stamps since
     // we are about to perform a reload or reboot.
     !resetState
-  }
   @inline private def forceCheck = fileTreeRepository.isEmpty
   private[sbt] def needsReload(
       state: State,
       exec: Exec
-  ): Boolean = {
+  ): Boolean =
     val name = exec.source.map(_.channelName)
     val loggerOrTerminal =
-      name.flatMap(StandardMain.exchange.channelForName(_).map(_.terminal)) match {
+      name.flatMap(StandardMain.exchange.channelForName(_).map(_.terminal)) match
         case Some(t) => Right(t)
         case _       => Left(state.globalLogging.full)
-      }
 
     needsReload(state, loggerOrTerminal, exec.commandLine)
-  }
   private def needsReload(
       state: State,
       loggerOrTerminal: Either[Logger, Terminal],
       cmd: String
-  ): Boolean = {
+  ): Boolean =
     (needCheck(state, cmd) && (forceCheck || needUpdate.compareAndSet(true, false))) && {
       val extracted = Project.extract(state)
       val onChanges = extracted.get(Global / onChangedBuildSource)
       val current = getStamps(force = false)
       val previous = previousStamps.getAndSet(current)
-      Settings.changedFiles(previous, current) match {
+      Settings.changedFiles(previous, current) match
         case fileChanges @ FileChanges(created, deleted, modified, _) if fileChanges.hasChanges =>
           val rawPrefix = s"build source files have changed\n" +
-            (if (created.nonEmpty) s"new files: ${created.mkString("\n  ", "\n  ", "\n")}"
+            (if created.nonEmpty then s"new files: ${created.mkString("\n  ", "\n  ", "\n")}"
              else "") +
-            (if (deleted.nonEmpty)
-               s"deleted files: ${deleted.mkString("\n  ", "\n  ", "\n")}"
+            (if deleted.nonEmpty then s"deleted files: ${deleted.mkString("\n  ", "\n  ", "\n")}"
              else "") +
-            (if (modified.nonEmpty)
-               s"modified files: ${modified.mkString("\n  ", "\n  ", "\n")}"
+            (if modified.nonEmpty then s"modified files: ${modified.mkString("\n  ", "\n  ", "\n")}"
              else "")
           val prefix = rawPrefix.linesIterator.filterNot(_.trim.isEmpty).mkString("\n")
 
-          onChanges match {
+          onChanges match
             case ReloadOnSourceChanges =>
               val msg = s"$prefix\nReloading sbt..."
-              loggerOrTerminal match {
+              loggerOrTerminal match
                 case Right(t) => msg.linesIterator.foreach(l => t.printStream.println(s"[info] $l"))
                 case Left(l)  => l.info(msg)
-              }
               true
             case WarnOnSourceChanges =>
               val tail = "Apply these changes by running `reload`.\nAutomatically reload the " +
@@ -160,23 +149,21 @@ private[sbt] class CheckBuildSources extends AutoCloseable {
                 "`Global / onChangedBuildSource := ReloadOnSourceChanges`.\nDisable this " +
                 "warning by setting `Global / onChangedBuildSource := IgnoreSourceChanges`."
               val msg = s"$prefix\n$tail"
-              loggerOrTerminal match {
+              loggerOrTerminal match
                 case Right(t) =>
                   val prefix =
                     s"[${Def.withColor("warn", Some(AnsiColor.YELLOW), t.isColorEnabled)}]"
                   msg.linesIterator.foreach(l => t.printStream.println(s"$prefix $l"))
                 case Left(l) => l.warn(msg)
-              }
               false
             case IgnoreSourceChanges =>
               false
-          }
+          end match
         case _ => false
-      }
+      end match
     }
-  }
   override def close(): Unit = {}
-}
+end CheckBuildSources
 
 private[sbt] object CheckBuildSources:
   val defaultPollInterval: FiniteDuration = FiniteDuration(Int.MinValue, TimeUnit.MILLISECONDS)
@@ -189,7 +176,7 @@ private[sbt] object CheckBuildSources:
    * checkBuildSources / pollInterval. The latter makes it possible to switch between
    * the asynchronous and polling implementations during the same sbt session.
    */
-  private[sbt] def init(state: State): State = state.get(CheckBuildSourcesKey) match {
+  private[sbt] def init(state: State): State = state.get(CheckBuildSourcesKey) match
     case Some(cbs) =>
       cbs.reset(state)
       state
@@ -197,21 +184,19 @@ private[sbt] object CheckBuildSources:
       val cbs = new CheckBuildSources
       cbs.reset(state)
       state.put(CheckBuildSourcesKey, cbs)
-  }
   private[sbt] def needReloadImpl: Def.Initialize[Task[StateTransform]] = Def.task {
     val st = state.value
-    st.get(CheckBuildSourcesKey) match {
+    st.get(CheckBuildSourcesKey) match
       case Some(cbs) if (cbs.needsReload(st, Exec("", None))) =>
         StateTransform("reload" :: (_: State))
       case _ => StateTransform(identity)
-    }
   }
   private[sbt] def buildSourceFileInputs: Def.Initialize[Seq[Glob]] = Def.setting {
-    if (onChangedBuildSource.value != IgnoreSourceChanges) {
+    if onChangedBuildSource.value != IgnoreSourceChanges then
       val baseDir = (LocalRootProject / baseDirectory).value
       val projectDir = baseDir / "project"
       @tailrec
-      def projectGlobs(projectDir: File, globs: Seq[Glob]): Seq[Glob] = {
+      def projectGlobs(projectDir: File, globs: Seq[Glob]): Seq[Glob] =
         val glob = projectDir.toGlob
         val updatedGlobs = globs ++ Seq(
           glob / "*.{sbt,scala,java}",
@@ -220,9 +205,8 @@ private[sbt] object CheckBuildSources:
           glob / "src" / ** / "*.{scala,java}"
         )
         val nextLevel = projectDir / "project"
-        if (nextLevel.exists) projectGlobs(nextLevel, updatedGlobs) else updatedGlobs
-      }
+        if nextLevel.exists then projectGlobs(nextLevel, updatedGlobs) else updatedGlobs
       projectGlobs(projectDir, baseDir.toGlob / "*.sbt" :: Nil)
-    } else Nil
+    else Nil
   }
 end CheckBuildSources
diff --git a/main/src/main/scala/sbt/nio/FileChanges.scala b/main/src/main/scala/sbt/nio/FileChanges.scala
index a35139f26..3eb3b92b3 100644
--- a/main/src/main/scala/sbt/nio/FileChanges.scala
+++ b/main/src/main/scala/sbt/nio/FileChanges.scala
@@ -30,16 +30,15 @@ final case class FileChanges(
     deleted: Seq[Path],
     modified: Seq[Path],
     unmodified: Seq[Path]
-) {
+):
 
   /**
    * Return true either if there is no previous information or
    * @return true if there are no changes.
    */
   lazy val hasChanges: Boolean = created.nonEmpty || deleted.nonEmpty || modified.nonEmpty
-}
 
-object FileChanges {
+object FileChanges:
 
   /**
    * Creates an instance of [[FileChanges]] for a collection of files for which there were no
@@ -58,4 +57,3 @@ object FileChanges {
    */
   def unmodified(files: Seq[Path]): FileChanges =
     FileChanges(created = Nil, deleted = Nil, modified = Nil, unmodified = files)
-}
diff --git a/main/src/main/scala/sbt/nio/FileStamp.scala b/main/src/main/scala/sbt/nio/FileStamp.scala
index 8c04f69cf..08c63a53b 100644
--- a/main/src/main/scala/sbt/nio/FileStamp.scala
+++ b/main/src/main/scala/sbt/nio/FileStamp.scala
@@ -25,7 +25,7 @@ import scala.jdk.OptionConverters.*
  * A trait that indicates what file stamping implementation should be used to track the state of
  * a given file. The two choices are [[FileStamper.Hash]] and [[FileStamper.LastModified]].
  */
-enum FileStamper {
+enum FileStamper:
 
   /**
    * Track files using a hash.
@@ -36,7 +36,6 @@ enum FileStamper {
    * Track files using the last modified time.
    */
   case LastModified
-}
 
 /**
  * Represents the state of a file. This representation is either a hash of the file contents or
@@ -47,7 +46,7 @@ sealed trait FileStamp
 /**
  * Provides json formatters for [[FileStamp]].
  */
-object FileStamp {
+object FileStamp:
   private[sbt] type Id[A] = A
 
   extension (fileStamp: FileStamp)
@@ -58,43 +57,33 @@ object FileStamp {
         case _                  => EmptyStamp
 
   private[sbt] def apply(path: Path, fileStamper: FileStamper): Option[FileStamp] =
-    fileStamper match {
+    fileStamper match
       case FileStamper.Hash         => hash(path)
       case FileStamper.LastModified => lastModified(path)
-    }
-  private[sbt] def apply(stamp: XStamp): Option[FileStamp] = stamp match {
+  private[sbt] def apply(stamp: XStamp): Option[FileStamp] = stamp match
     case lm: IncLastModified => Some(new LastModified(lm.value))
     case s: IncHash          => Some(fromZincStamp(s))
     case _                   => None
-  }
   private[sbt] def apply(path: Path, fileAttributes: FileAttributes): Option[FileStamp] =
-    try {
-      if (fileAttributes.isDirectory) lastModified(path)
+    try
+      if fileAttributes.isDirectory then lastModified(path)
       else
-        path.toString match {
+        path.toString match
           case s if s.endsWith(".jar")   => lastModified(path)
           case s if s.endsWith(".class") => lastModified(path)
           case _                         => hash(path)
-        }
-    } catch {
-      case e: IOException => Some(Error(e))
-    }
+    catch case e: IOException => Some(Error(e))
   private[sbt] def hash(string: String): Hash =
-    new FileHashImpl(try {
-      sbt.internal.inc.Stamp.fromString(string)
-    } catch {
-      case _: Throwable => EmptyStamp
-    })
-  private[sbt] def hash(path: Path): Option[Hash] = Stamper.forFarmHashP(path) match {
+    new FileHashImpl(try sbt.internal.inc.Stamp.fromString(string)
+    catch case _: Throwable => EmptyStamp)
+  private[sbt] def hash(path: Path): Option[Hash] = Stamper.forFarmHashP(path) match
     case EmptyStamp => None
     case s          => Some(new FileHashImpl(s))
-  }
   private[sbt] def fromZincStamp(stamp: XStamp): Hash = new FileHashImpl(stamp)
   private[sbt] def lastModified(path: Path): Option[LastModified] =
-    IO.getModifiedTimeOrZero(path.toFile) match {
+    IO.getModifiedTimeOrZero(path.toFile) match
       case 0 => None
       case l => Some(LastModified(l))
-    }
   private class FileHashImpl(val xstamp: XStamp) extends Hash(xstamp.toString)
   private[sbt] sealed abstract case class Hash private[sbt] (hex: String) extends FileStamp
   private[sbt] final case class LastModified private[sbt] (time: Long) extends FileStamp
@@ -109,7 +98,7 @@ object FileStamp {
     case FileStamp.Error(_)        => Digest.zero
     case FileStamp.LastModified(_) => Digest.sha256Hash(path)
 
-  object Formats {
+  object Formats:
     given seqPathJsonFormatter: JsonFormat[Seq[Path]] =
       asStringArray(_.toString, Paths.get(_))
     given seqFileJsonFormatter: JsonFormat[Seq[File]] =
@@ -123,15 +112,14 @@ object FileStamp {
       fromSeqJsonFormat[VirtualFileRef]
 
     private def asStringArray[T](toStr: T => String, fromStr: String => T): JsonFormat[Seq[T]] =
-      new JsonFormat[Seq[T]] {
-        override def write[J](obj: Seq[T], builder: Builder[J]): Unit = {
+      new JsonFormat[Seq[T]]:
+        override def write[J](obj: Seq[T], builder: Builder[J]): Unit =
           builder.beginArray()
           obj.foreach { x => builder.writeString(toStr(x)) }
           builder.endArray()
-        }
 
         override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Seq[T] =
-          jsOpt match {
+          jsOpt match
             case Some(js) =>
               val size = unbuilder.beginArray(js)
               val res = (1 to size) map { _ =>
@@ -141,21 +129,18 @@ object FileStamp {
               res
             case None =>
               deserializationError("Expected JsArray but found None")
-          }
-      }
 
     private def fromSeqJsonFormat[T](using seqJsonFormat: JsonFormat[Seq[T]]): JsonFormat[T] =
-      new JsonFormat[T] {
+      new JsonFormat[T]:
         override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): T =
           seqJsonFormat.read(jsOpt, unbuilder).head
 
         override def write[J](obj: T, builder: Builder[J]): Unit =
           seqJsonFormat.write(obj :: Nil, builder)
-      }
 
     given seqPathFileStampJsonFormatter: JsonFormat[Seq[(Path, FileStamp)]] =
-      new JsonFormat[Seq[(Path, FileStamp)]] {
-        override def write[J](obj: Seq[(Path, FileStamp)], builder: Builder[J]): Unit = {
+      new JsonFormat[Seq[(Path, FileStamp)]]:
+        override def write[J](obj: Seq[(Path, FileStamp)], builder: Builder[J]): Unit =
           val (hashes, lastModifiedTimes) = obj.partition(_._2.isInstanceOf[Hash])
           builder.beginObject()
           builder.addField("hashes", hashes.asInstanceOf[Seq[(Path, Hash)]])(using
@@ -166,10 +151,9 @@ object FileStamp {
             lastModifiedTimes.asInstanceOf[Seq[(Path, LastModified)]]
           )(using seqPathLastModifiedJsonFormatter)
           builder.endObject()
-        }
 
         override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Seq[(Path, FileStamp)] =
-          jsOpt match {
+          jsOpt match
             case Some(js) =>
               unbuilder.beginObject(js)
               val hashes = unbuilder.readField("hashes")(using seqPathHashJsonFormatter)
@@ -179,11 +163,9 @@ object FileStamp {
               hashes ++ lastModifiedTimes
             case None =>
               deserializationError("Expected JsObject but found None")
-          }
-      }
     private[sbt] val seqPathHashJsonFormatter: JsonFormat[Seq[(Path, Hash)]] =
-      new JsonFormat[Seq[(Path, Hash)]] {
-        override def write[J](obj: Seq[(Path, Hash)], builder: Builder[J]): Unit = {
+      new JsonFormat[Seq[(Path, Hash)]]:
+        override def write[J](obj: Seq[(Path, Hash)], builder: Builder[J]): Unit =
           builder.beginArray()
           obj.foreach { (p, h) =>
             builder.beginArray()
@@ -192,10 +174,9 @@ object FileStamp {
             builder.endArray()
           }
           builder.endArray()
-        }
 
         override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Seq[(Path, Hash)] =
-          jsOpt match {
+          jsOpt match
             case Some(js) =>
               val size = unbuilder.beginArray(js)
               val res = (1 to size) map { _ =>
@@ -209,11 +190,9 @@ object FileStamp {
               res
             case None =>
               deserializationError("Expected JsArray but found None")
-          }
-      }
     private[sbt] val seqPathLastModifiedJsonFormatter: JsonFormat[Seq[(Path, LastModified)]] =
-      new JsonFormat[Seq[(Path, LastModified)]] {
-        override def write[J](obj: Seq[(Path, LastModified)], builder: Builder[J]): Unit = {
+      new JsonFormat[Seq[(Path, LastModified)]]:
+        override def write[J](obj: Seq[(Path, LastModified)], builder: Builder[J]): Unit =
           builder.beginArray()
           obj.foreach { (p, lm) =>
             builder.beginArray()
@@ -222,10 +201,9 @@ object FileStamp {
             builder.endArray()
           }
           builder.endArray()
-        }
 
         override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Seq[(Path, LastModified)] =
-          jsOpt match {
+          jsOpt match
             case Some(js) =>
               val size = unbuilder.beginArray(js)
               val res = (1 to size) map { _ =>
@@ -239,15 +217,13 @@ object FileStamp {
               res
             case None =>
               deserializationError("Expected JsArray but found None")
-          }
-      }
-  }
+  end Formats
 
-  extension (e: Either[FileStamp, FileStamp]) {
-    private def value: Option[FileStamp] = if (e == null) None else Some(e.fold(identity, identity))
-  }
+  extension (e: Either[FileStamp, FileStamp])
+    private def value: Option[FileStamp] =
+      if e == null then None else Some(e.fold(identity, identity))
 
-  private[sbt] class Cache {
+  private[sbt] class Cache:
     private val underlying = new ConcurrentHashMap[Path, Either[FileStamp, FileStamp]]
 
     /**
@@ -256,60 +232,47 @@ object FileStamp {
      *
      * @param path the file whose stamp we are invalidating
      */
-    def invalidate(path: Path): Unit = underlying.get(path) match {
+    def invalidate(path: Path): Unit = underlying.get(path) match
       case Right(s) =>
         underlying.put(path, Left(s))
         ()
       case _ => ()
-    }
     def get(path: Path): Option[FileStamp] =
-      underlying.get(path) match {
+      underlying.get(path) match
         case null     => None
         case Left(v)  => updateImpl(path, fileStampToStamper(v))
         case Right(v) => Some(v)
-      }
     def getOrElseUpdate(path: Path, stamper: FileStamper): Option[FileStamp] =
-      underlying.get(path) match {
+      underlying.get(path) match
         case null     => updateImpl(path, stamper)
         case Left(_)  => updateImpl(path, stamper)
         case Right(v) => Some(v)
-      }
-    def remove(key: Path): Option[FileStamp] = {
+    def remove(key: Path): Option[FileStamp] =
       underlying.remove(key).value
-    }
     def put(key: Path, fileStamp: FileStamp): Option[FileStamp] =
-      underlying.put(key, Right(fileStamp)) match {
+      underlying.put(key, Right(fileStamp)) match
         case null => None
         case e    => e.value
-      }
 
-    def putIfAbsent(key: Path, stamper: FileStamper): (Option[FileStamp], Option[FileStamp]) = {
-      underlying.get(key) match {
+    def putIfAbsent(key: Path, stamper: FileStamper): (Option[FileStamp], Option[FileStamp]) =
+      underlying.get(key) match
         case null     => (None, updateImpl(key, stamper))
         case Right(s) => (Some(s), None)
         case Left(_)  => (None, None)
-      }
-    }
-    def update(key: Path, stamper: FileStamper): (Option[FileStamp], Option[FileStamp]) = {
-      underlying.get(key) match {
+    def update(key: Path, stamper: FileStamper): (Option[FileStamp], Option[FileStamp]) =
+      underlying.get(key) match
         case null => (None, updateImpl(key, stamper))
         case v    => (v.value, updateImpl(key, stamper))
-      }
-    }
 
-    private def fileStampToStamper(stamp: FileStamp): FileStamper = stamp match {
+    private def fileStampToStamper(stamp: FileStamp): FileStamper = stamp match
       case _: Hash => FileStamper.Hash
       case _       => FileStamper.LastModified
-    }
 
-    private def updateImpl(path: Path, stamper: FileStamper): Option[FileStamp] = {
+    private def updateImpl(path: Path, stamper: FileStamper): Option[FileStamp] =
       val stamp = FileStamp(path, stamper)
-      stamp match {
+      stamp match
         case None    => underlying.remove(path)
         case Some(s) => underlying.put(path, Right(s))
-      }
       stamp
-    }
-
-  }
-}
+  end Cache
+end FileStamp
diff --git a/main/src/main/scala/sbt/nio/Keys.scala b/main/src/main/scala/sbt/nio/Keys.scala
index 948450f49..22f035d3e 100644
--- a/main/src/main/scala/sbt/nio/Keys.scala
+++ b/main/src/main/scala/sbt/nio/Keys.scala
@@ -23,7 +23,7 @@ import sbt.*
 
 import scala.concurrent.duration.FiniteDuration
 
-object Keys {
+object Keys:
   sealed trait WatchBuildSourceOption
   case object IgnoreSourceChanges extends WatchBuildSourceOption
   case object WarnOnSourceChanges extends WatchBuildSourceOption
@@ -206,4 +206,4 @@ object Keys {
       " new meta build sources so we should neither warn the user nor automatically restart the build"
   private[sbt] val hasCheckedMetaBuild =
     AttributeKey[AtomicBoolean]("has-checked-meta-build", hasCheckedMetaBuildMsg, Int.MaxValue)
-}
+end Keys
diff --git a/main/src/main/scala/sbt/nio/Settings.scala b/main/src/main/scala/sbt/nio/Settings.scala
index e08b9787a..3d64ab4ae 100644
--- a/main/src/main/scala/sbt/nio/Settings.scala
+++ b/main/src/main/scala/sbt/nio/Settings.scala
@@ -29,30 +29,29 @@ import scala.collection.immutable.VectorBuilder
 import java.io.File
 import xsbti.VirtualFileRef
 
-private[sbt] object Settings {
-  private[sbt] def inject(transformed: Seq[Def.Setting[?]]): Seq[Def.Setting[?]] = {
+private[sbt] object Settings:
+  private[sbt] def inject(transformed: Seq[Def.Setting[?]]): Seq[Def.Setting[?]] =
     val definedSettings = new java.util.HashMap[Def.ScopedKey[?], VectorBuilder[Def.Setting[?]]]
     val fileOutputScopes = transformed.flatMap { s =>
       val list = new VectorBuilder[Def.Setting[?]]
-      definedSettings.putIfAbsent(s.key, list) match {
+      definedSettings.putIfAbsent(s.key, list) match
         case null => list += s
         case l    => l += s
-      }
-      if (s.key.key == fileOutputs.key && s.key.scope.task.toOption.isDefined) Some(s.key.scope)
+      if s.key.key == fileOutputs.key && s.key.scope.task.toOption.isDefined then Some(s.key.scope)
       else None
     }.toSet
     transformed.flatMap { s =>
       val inject =
-        if (s.key.key == fileInputs.key) inputPathSettings(s)
+        if s.key.key == fileInputs.key then inputPathSettings(s)
         else maybeAddOutputsAndFileStamps(s, fileOutputScopes)
       s +: inject.flatMap { setting =>
-        (definedSettings.get(setting.key) match {
+        (definedSettings.get(setting.key) match
           case null => Vector(setting)
           case set  => setting +: set.result()
-        }): Seq[Def.Setting[?]]
+        ): Seq[Def.Setting[?]]
       }
     }
-  }
+  end inject
 
   /**
    * This method checks if the setting is for a task with a return type in:
@@ -69,8 +68,8 @@ private[sbt] object Settings {
   private def maybeAddOutputsAndFileStamps(
       setting: Def.Setting[?],
       fileOutputScopes: Set[Scope]
-  ): List[Def.Setting[?]] = {
-    setting.key.key.tag match {
+  ): List[Def.Setting[?]] =
+    setting.key.key.tag match
       case tag: KeyTag.Task[?] =>
         if pathClass.isAssignableFrom(tag.typeArg) then addOutputAndStampTasks[Path](setting)
         else if fileClass.isAssignableFrom(tag.typeArg) then addOutputAndStampTasks[File](setting)
@@ -85,26 +84,23 @@ private[sbt] object Settings {
           addOutputAndStampTasks[Seq[VirtualFileRef]](setting)
         else addDefaultTasks(setting, fileOutputScopes)
       case _ => Nil
-    }
-  }
 
   private def addDefaultTasks(
       setting: Def.Setting[?],
       fileOutputScopes: Set[Scope]
-  ): List[Def.Setting[?]] = {
+  ): List[Def.Setting[?]] =
     val scope = setting.key.scope.copy(task = Select(setting.key.key))
-    if (fileOutputScopes.contains(scope)) {
+    if fileOutputScopes.contains(scope) then
       val sk = setting.asInstanceOf[Def.Setting[Task[Any]]].key
       val scopedKey = Keys.dynamicFileOutputs.rescope(sk.scope.rescope(sk.key))
       val init: Def.Initialize[Task[Seq[Path]]] = sk(_.map(_ => Nil))
       addTaskDefinition(Def.setting[Task[Seq[Path]]](scopedKey, init, setting.pos)) ::
         allOutputPathsImpl(scope) :: outputFileStampsImpl(scope) :: cleanImpl(scope) :: Nil
-    } else Nil
-  }
+    else Nil
 
   private def addOutputAndStampTasks[T: JsonFormat: ToSeqPath](
       setting: Def.Setting[?]
-  ): List[Def.Setting[?]] = {
+  ): List[Def.Setting[?]] =
     val sk = setting.asInstanceOf[Def.Setting[Task[T]]].key
     val taskKey = sk.scope / TaskKey(sk.key)
     // We create a previous reference so that clean automatically works without the
@@ -115,10 +111,9 @@ private[sbt] object Settings {
     val key = Def.ScopedKey(taskKey.scope.rescope(taskKey.key), Keys.dynamicFileOutputs.key)
     addTaskDefinition(Def.setting[Task[Seq[Path]]](key, init, setting.pos)) ::
       outputsAndStamps(taskKey)
-  }
 
   private[sbt] val inject: Def.ScopedKey[?] => Seq[Def.Setting[?]] = scopedKey =>
-    scopedKey.key match {
+    scopedKey.key match
       case transitiveDynamicInputs.key =>
         scopedKey.scope.task.toOption.toSeq.map { key =>
           val updatedKey = Def.ScopedKey(scopedKey.scope.copy(task = Zero), key)
@@ -129,7 +124,6 @@ private[sbt] object Settings {
       case transitiveClasspathDependency.key =>
         (scopedKey.scope / transitiveClasspathDependency := { () }) :: Nil
       case _ => Nil
-    }
 
   /**
    * This adds the [[taskDefinitionKey]] to the work for each [[Task]]. Without
@@ -151,7 +145,7 @@ private[sbt] object Settings {
    * @return a task definition that retrieves the file input files and their attributes scoped
    *         to a particular task.
    */
-  private[sbt] def inputPathSettings(setting: Def.Setting[?]): Seq[Def.Setting[?]] = {
+  private[sbt] def inputPathSettings(setting: Def.Setting[?]): Seq[Def.Setting[?]] =
     val scopedKey = setting.key
     val scope = scopedKey.scope
     (scope / Keys.allInputPathsAndAttributes := Def.uncached {
@@ -168,7 +162,6 @@ private[sbt] object Settings {
       dynamicInputs.foreach(_ ++= inputs.map(g => DynamicInput(g, stamper, forceTrigger)))
       view.list(inputs)
     }) :: fileStamps(scopedKey) :: allFilesImpl(scope) :: changedInputFilesImpl(scope)
-  }
 
   private val pathClass = classOf[Path]
   private val fileClass = classOf[File]
@@ -181,7 +174,7 @@ private[sbt] object Settings {
    * @param scope the key whose file inputs we are seeking
    * @return a task definition that retrieves all of the input paths scoped to the input key.
    */
-  private def allFilesImpl(scope: Scope): Def.Setting[?] = {
+  private def allFilesImpl(scope: Scope): Def.Setting[?] =
     addTaskDefinition(scope / Keys.allInputFiles := Def.uncached {
       val filter =
         (scope / fileInputIncludeFilter).value && !(scope / fileInputExcludeFilter).value
@@ -189,7 +182,6 @@ private[sbt] object Settings {
         case (p, a) if filter.accept(p, a) => p
       }
     })
-  }
 
   /**
    * Returns all of the regular files whose stamp has changed since the last time the
@@ -203,10 +195,9 @@ private[sbt] object Settings {
   private def changedInputFilesImpl(scope: Scope): List[Def.Setting[?]] =
     changedFilesImpl(scope, changedInputFiles, inputFileStamps) ::
       (scope / watchForceTriggerOnAnyChange := {
-        (scope / watchForceTriggerOnAnyChange).?.value match {
+        (scope / watchForceTriggerOnAnyChange).?.value match
           case Some(t) => t
           case None    => false
-        }
       }) :: Nil
 
   private def changedFilesImpl(
@@ -221,7 +212,7 @@ private[sbt] object Settings {
   private[sbt] def changedFiles(
       previous: Seq[(Path, FileStamp)],
       current: Seq[(Path, FileStamp)]
-  ): FileChanges = {
+  ): FileChanges =
     val createdBuilder = new VectorBuilder[Path]
     val deletedBuilder = new VectorBuilder[Path]
     val modifiedBuilder = new VectorBuilder[Path]
@@ -232,24 +223,20 @@ private[sbt] object Settings {
       prevMap.put(k, v); ()
     }
     current.foreach { (path, currentStamp) =>
-      if (seen.add(path)) {
-        prevMap.remove(path) match {
+      if seen.add(path) then
+        prevMap.remove(path) match
           case null => createdBuilder += path
-          case old  => (if (old != currentStamp) modifiedBuilder else unmodifiedBuilder) += path
-        }
-      }
+          case old  => (if old != currentStamp then modifiedBuilder else unmodifiedBuilder) += path
     }
     prevMap.forEach((p, _) => deletedBuilder += p)
     val unmodified = unmodifiedBuilder.result()
     val deleted = deletedBuilder.result()
     val created = createdBuilder.result()
     val modified = modifiedBuilder.result()
-    if (created.isEmpty && deleted.isEmpty && modified.isEmpty) {
+    if created.isEmpty && deleted.isEmpty && modified.isEmpty then
       FileChanges.unmodified(unmodifiedBuilder.result())
-    } else {
-      FileChanges(created, deleted, modified, unmodified)
-    }
-  }
+    else FileChanges(created, deleted, modified, unmodified)
+  end changedFiles
 
   /**
    * Provides an automatically generated clean method for a task that provides fileOutputs.
@@ -267,7 +254,7 @@ private[sbt] object Settings {
    * @param taskKey the task for which we add a custom clean implementation
    * @return a task specific clean implementation
    */
-  private[sbt] def cleanImpl[T: JsonFormat: ToSeqPath](taskKey: TaskKey[T]): Def.Setting[?] = {
+  private[sbt] def cleanImpl[T: JsonFormat: ToSeqPath](taskKey: TaskKey[T]): Def.Setting[?] =
     val taskScope = taskKey.scope.rescope(taskKey.key)
     addTaskDefinition(
       taskScope / sbt.Keys.clean := Def.uncached(
@@ -283,7 +270,6 @@ private[sbt] object Settings {
           .value
       )
     )
-  }
 
   /**
    * Returns all of the regular files and the corresponding file stamps for the file inputs
@@ -293,25 +279,23 @@ private[sbt] object Settings {
    * @return a task definition that retrieves the input files and their file stamps scoped to the
    *         input key.
    */
-  private[sbt] def fileStamps(scopedKey: Def.ScopedKey[?]): Def.Setting[?] = {
+  private[sbt] def fileStamps(scopedKey: Def.ScopedKey[?]): Def.Setting[?] =
     import scala.collection.parallel.CollectionConverters.*
     val scope = scopedKey.scope
     addTaskDefinition(scope / Keys.inputFileStamps := Def.uncached {
       val cache = (scope / unmanagedFileStampCache).value
       val stamper = (scope / Keys.inputFileStamper).value
       val stampFile: Path => Option[(Path, FileStamp)] =
-        state.value.get(globalFileTreeRepository) match {
+        state.value.get(globalFileTreeRepository) match
           case Some(repo: FileStampRepository) =>
             (path: Path) =>
-              repo.putIfAbsent(path, stamper) match {
+              repo.putIfAbsent(path, stamper) match
                 case (None, Some(s)) =>
                   cache.put(path, s)
                   Some(path -> s)
                 case _ => cache.getOrElseUpdate(path, stamper).map(path -> _)
-              }
           case _ =>
             (path: Path) => cache.getOrElseUpdate(path, stamper).map(path -> _)
-        }
       val filter =
         (scope / fileInputIncludeFilter).value && !(scope / fileInputExcludeFilter).value
       (scope / Keys.allInputPathsAndAttributes).value.par.flatMap {
@@ -319,15 +303,14 @@ private[sbt] object Settings {
         case _                                   => None
       }.toVector
     })
-  }
+  end fileStamps
 
   private def outputsAndStamps[T: JsonFormat: ToSeqPath](
       taskKey: TaskKey[T]
-  ): List[Def.Setting[?]] = {
+  ): List[Def.Setting[?]] =
     val scope = taskKey.scope.rescope(taskKey.key)
     val changes = changedFilesImpl(scope, changedOutputFiles, outputFileStamps) :: Nil
     allOutputPathsImpl(scope) :: outputFileStampsImpl(scope) :: cleanImpl(taskKey) :: changes
-  }
 
   private def allOutputPathsImpl(scope: Scope): Def.Setting[?] =
     addTaskDefinition(scope / allOutputFiles := Def.uncached {
@@ -346,10 +329,9 @@ private[sbt] object Settings {
        * being filtered (which is the case with the default filters:
        * include = AllPass, exclude = NoPass).
        */
-      val attributeFilter: Path => Boolean = filter match {
+      val attributeFilter: Path => Boolean = filter match
         case AllPass => _ => true
         case f       => p => FileAttributes(p).map(f.accept(p, _)).getOrElse(false)
-      }
       allFileOutputs ++ allDynamicOutputs.filterNot { p =>
         fileOutputGlobs.exists(_.matches(p)) || !attributeFilter(p)
       }
@@ -357,15 +339,13 @@ private[sbt] object Settings {
 
   private def outputFileStampsImpl(scope: Scope): Def.Setting[?] =
     addTaskDefinition(scope / outputFileStamps := Def.uncached {
-      val stamper: Path => Option[FileStamp] = (scope / outputFileStamper).value match {
+      val stamper: Path => Option[FileStamp] = (scope / outputFileStamper).value match
         case LastModified => FileStamp.lastModified
         case Hash         => FileStamp.hash
-      }
       val allFiles = (scope / allOutputFiles).value
       // The cache invalidation is specifically so that source formatters can run before
       // the compile task and the file stamps seen by compile match the post-format stamps.
       allFiles.foreach((scope / unmanagedFileStampCache).value.invalidate)
       allFiles.flatMap(p => stamper(p).map(p -> _))
     })
-
-}
+end Settings
diff --git a/main/src/main/scala/sbt/nio/Watch.scala b/main/src/main/scala/sbt/nio/Watch.scala
index 7d6257f0e..a3de57880 100644
--- a/main/src/main/scala/sbt/nio/Watch.scala
+++ b/main/src/main/scala/sbt/nio/Watch.scala
@@ -29,12 +29,12 @@ import scala.collection.mutable
 import scala.concurrent.duration.*
 import scala.util.control.NonFatal
 
-object Watch {
+object Watch:
 
   /**
    * Represents a file event that has been detected during a continuous build.
    */
-  sealed trait Event {
+  sealed trait Event:
 
     /**
      * The path that triggered the event.
@@ -49,76 +49,61 @@ object Watch {
      * @return the time at which the event occurred.
      */
     def occurredAt: FiniteDuration
-  }
   private val formatter = DateTimeFormatter.ofPattern("yyyy-MMM-dd HH:mm:ss.SSS")
   private val timeZone = ZoneId.systemDefault
   private val timeZoneName = timeZone.getDisplayName(TextStyle.SHORT, Locale.getDefault)
-  extension (d: Duration) {
-    private def finite: FiniteDuration = d match {
+  extension (d: Duration)
+    private def finite: FiniteDuration = d match
       case f: FiniteDuration => f
       case _                 => new FiniteDuration(Long.MaxValue, TimeUnit.MILLISECONDS)
-    }
-    private def toEpochString: String = {
+    private def toEpochString: String =
       val zdt = ZonedDateTime.ofInstant(Instant.ofEpochMilli(d.toMillis), timeZone)
       s"${formatter.format(zdt)} $timeZoneName"
-    }
-  }
-  extension (event: Event) {
-    private[sbt] def toEpochString: String = event.occurredAt.toEpochString
-  }
-  private[sbt] object Event {
-    trait Impl { self: Event =>
+  extension (event: Event) private[sbt] def toEpochString: String = event.occurredAt.toEpochString
+  private[sbt] object Event:
+    trait Impl:
+      self: Event =>
       private val name = self.getClass.getSimpleName
-      override def equals(o: Any): Boolean = o match {
+      override def equals(o: Any): Boolean = o match
         case that: Event => this.path == that.path
         case _           => false
-      }
       override def hashCode: Int = path.hashCode
       override def toString: String = s"$name($path)"
-    }
-    def fromIO(fileEvent: FileEvent[FileAttributes]): Watch.Event = fileEvent match {
+    def fromIO(fileEvent: FileEvent[FileAttributes]): Watch.Event = fileEvent match
       case c @ FileEvent.Creation(p, _)  => new Watch.Creation(p, c.occurredAt.value.finite)
       case d @ FileEvent.Deletion(p, _)  => new Watch.Deletion(p, d.occurredAt.value.finite)
       case u @ FileEvent.Update(p, _, _) =>
         new Watch.Update(p, u.occurredAt.value.finite)
-    }
-  }
   final class Creation private[sbt] (
       override val path: Path,
       override val occurredAt: FiniteDuration
   ) extends Event
-      with Event.Impl {
+      with Event.Impl:
     override def toString: String = s"Creation($path, ${occurredAt.toEpochString})"
-  }
-  object Creation {
+  object Creation:
     def apply(event: FileEvent[FileAttributes]): Creation =
       new Creation(event.path, event.occurredAt.value.finite)
     def unapply(creation: Creation): Option[Path] = Some(creation.path)
-  }
   final class Deletion private[sbt] (
       override val path: Path,
       override val occurredAt: FiniteDuration
   ) extends Event
-      with Event.Impl {
+      with Event.Impl:
     override def toString: String = s"Deletion($path, ${occurredAt.toEpochString})"
-  }
-  object Deletion {
+  object Deletion:
     def apply(event: FileEvent[FileAttributes]): Deletion =
       new Deletion(event.path, event.occurredAt.value.finite)
     def unapply(deletion: Deletion): Option[Path] = Some(deletion.path)
-  }
   final class Update private[sbt] (
       override val path: Path,
       override val occurredAt: FiniteDuration
   ) extends Event
-      with Event.Impl {
+      with Event.Impl:
     override def toString: String = s"Update($path, ${occurredAt.toEpochString})"
-  }
-  object Update {
+  object Update:
     def apply(event: FileEvent[FileAttributes]): Update =
       new Update(event.path, event.occurredAt.value.finite)
     def unapply(update: Update): Option[Path] = Some(update.path)
-  }
 
   /**
    * This trait is used to control the state of Watch. The [[Watch.Trigger]] action
@@ -133,14 +118,13 @@ object Watch {
    * Provides a default `Ordering` for actions. Lower values correspond to higher priority actions.
    * [[CancelWatch]] is higher priority than [[ContinueWatch]].
    */
-  object Action {
+  object Action:
     given ordering: Ordering[Action] = {
       case (a: ContinueWatch, b: ContinueWatch) => ContinueWatch.ordering.compare(a, b)
       case (_: ContinueWatch, _: CancelWatch)   => 1
       case (a: CancelWatch, b: CancelWatch)     => CancelWatch.ordering.compare(a, b)
       case (_: CancelWatch, _: ContinueWatch)   => -1
     }
-  }
 
   /**
    * Action that indicates that the watch should stop.
@@ -156,96 +140,82 @@ object Watch {
    * Provides a default `Ordering` for classes extending [[ContinueWatch]]. [[Trigger]] is higher
    * priority than [[Ignore]].
    */
-  object ContinueWatch {
+  object ContinueWatch:
 
     /**
      * A default `Ordering` for [[ContinueWatch]]. [[Trigger]] is higher priority than [[Ignore]].
      */
     given ordering: Ordering[ContinueWatch] = (left: ContinueWatch, right: ContinueWatch) =>
-      left match {
-        case ShowOptions => if (right == ShowOptions) 0 else -1
-        case Ignore      => if (right == Ignore) 0 else 1
-        case Trigger     => if (right == Trigger) 0 else if (right == ShowOptions) 1 else -1
-      }
-  }
+      left match
+        case ShowOptions => if right == ShowOptions then 0 else -1
+        case Ignore      => if right == Ignore then 0 else 1
+        case Trigger     => if right == Trigger then 0 else if right == ShowOptions then 1 else -1
 
   /**
    * Action that indicates that the watch should stop.
    */
-  case object CancelWatch extends CancelWatch {
+  case object CancelWatch extends CancelWatch:
 
     /**
      * A default `Ordering` for [[ContinueWatch]]. The priority of each type of [[CancelWatch]]
      * is reflected by the ordering of the case statements in the [[ordering.compare]] method,
      * e.g. [[Custom]] is higher priority than [[HandleError]].
      */
-    given ordering: Ordering[CancelWatch] = { (left: CancelWatch, right: CancelWatch) =>
-      left match {
+    given ordering: Ordering[CancelWatch] = (left: CancelWatch, right: CancelWatch) =>
+      left match
         // Note that a negative return value means the left CancelWatch is preferred to the right
         // CancelWatch while the inverse is true for a positive return value. This logic could
         // likely be simplified, but the pattern matching approach makes it very clear what happens
         // for each type of Action.
         case _: Custom =>
-          right match {
+          right match
             case _: Custom => 0
             case _         => -1
-          }
         case _: HandleError =>
-          right match {
+          right match
             case _: Custom      => 1
             case _: HandleError => 0
             case _              => -1
-          }
         case Prompt =>
-          right match {
+          right match
             case Prompt                          => 0
             case CancelWatch | Reload | (_: Run) => -1
             case _                               => 1
-          }
         case _: Run =>
-          right match {
+          right match
             case _: Run               => 0
             case CancelWatch | Reload => -1
             case _                    => 1
-          }
         case CancelWatch =>
-          right match {
+          right match
             case CancelWatch => 0
             case Reload      => -1
             case _           => 1
-          }
-        case Reload => if (right == Reload) 0 else 1
-      }
-    }
-  }
+        case Reload => if right == Reload then 0 else 1
+  end CancelWatch
 
   /**
    * Action that indicates that an error has occurred. The watch will be terminated when this action
    * is produced.
    */
-  sealed class HandleError(val throwable: Throwable) extends CancelWatch {
-    override def equals(o: Any): Boolean = o match {
+  sealed class HandleError(val throwable: Throwable) extends CancelWatch:
+    override def equals(o: Any): Boolean = o match
       case that: HandleError => this.throwable == that.throwable
       case _                 => false
-    }
     override def hashCode: Int = throwable.hashCode
     override def toString: String = s"HandleError($throwable)"
-  }
-  object HandleError {
+  object HandleError:
     def unapply(h: HandleError): Option[Throwable] = Some(h.throwable)
-  }
 
   /**
    * Action that indicates that an error has occurred. The watch will be terminated when this action
    * is produced.
    */
   private[sbt] final class HandleUnexpectedError(override val throwable: Throwable)
-      extends HandleError(throwable) {
+      extends HandleError(throwable):
     override def toString: String = s"HandleUnexpectedError($throwable)"
-  }
-  object HandleUnexpectedError {
+  object HandleUnexpectedError:
     def unapply(h: HandleUnexpectedError): Option[Throwable] = Some(h.throwable)
-  }
 
   /**
    * Action that indicates that the watch should continue as though nothing happened. This may be
@@ -277,15 +247,13 @@ object Watch {
    *
    * @param commands the commands to run after we exit the watch
    */
-  final class Run(val commands: String*) extends CancelWatch {
+  final class Run(val commands: String*) extends CancelWatch:
     override def toString: String = s"Run(${commands.mkString(", ")})"
-  }
   // For now leave this private in case this isn't the best unapply type signature since it can't
   // be evolved in a binary compatible way.
-  object Run {
+  object Run:
     def apply(commands: String*): Run = new Watch.Run(commands*)
     def unapply(r: Run): Option[List[Exec]] = Some(r.commands.toList.map(Exec(_, None)))
-  }
 
   case object Prompt extends CancelWatch
 
@@ -301,23 +269,21 @@ object Watch {
    */
   trait Custom extends CancelWatch
 
-  trait InputOption {
+  trait InputOption:
     private[sbt] def parser: Parser[Watch.Action]
     def input: String
     def display: String
     def description: String
     override def toString: String =
       s"InputOption(input = $input, display = $display, description = $description)"
-  }
-  object InputOption {
+  object InputOption:
     private class impl(
         override val input: String,
         override val display: String,
         override val description: String,
         action: Action
-    ) extends InputOption {
+    ) extends InputOption:
       override private[sbt] def parser: Parser[Watch.Action] = input ^^^ action
-    }
     def apply(key: Char, description: String, action: Action): InputOption =
       new impl(key.toString, s"'$key'", description, action)
     def apply(key: Char, display: String, description: String, action: Action): InputOption =
@@ -328,17 +294,15 @@ object Watch {
         action: Action,
         chars: Char*
     ): InputOption =
-      new impl(chars.mkString("|"), display, description, action) {
-        override private[sbt] def parser: Parser[Watch.Action] = chars match {
+      new impl(chars.mkString("|"), display, description, action):
+        override private[sbt] def parser: Parser[Watch.Action] = chars match
           case Seq(c)        => c ^^^ action
           case Seq(h, rest*) => rest.foldLeft(h: Parser[Char])(_ | _) ^^^ action
-        }
-      }
     def apply(input: String, description: String, action: Action): InputOption =
       new impl(input, s"'$input'", description, action)
     def apply(input: String, display: String, description: String, action: Action): InputOption =
       new impl(input, display, description, action)
-  }
+  end InputOption
 
   private type NextAction = Int => Watch.Action
 
@@ -358,51 +322,43 @@ object Watch {
       onStart: NextAction,
       nextAction: NextAction,
       recursive: Boolean
-  ): Watch.Action = {
+  ): Watch.Action =
     def safeNextAction(count: Int, delegate: NextAction): Watch.Action =
       try delegate(count)
-      catch {
+      catch
         case NonFatal(t) =>
           System.err.println(s"Watch caught unexpected error:")
           t.printStackTrace(System.err)
           new HandleError(t)
-      }
-    @tailrec def next(count: Int): Watch.Action = safeNextAction(count, nextAction) match {
+    @tailrec def next(count: Int): Watch.Action = safeNextAction(count, nextAction) match
       // This should never return Ignore due to this condition.
       case Ignore => next(count)
       case action => action
-    }
-    @tailrec def impl(count: Int): Watch.Action = {
+    @tailrec def impl(count: Int): Watch.Action =
       task(count)
-      safeNextAction(count, onStart) match {
+      safeNextAction(count, onStart) match
         case Ignore =>
-          next(count) match {
+          next(count) match
             case Trigger =>
-              if (recursive) impl(count + 1)
-              else {
+              if recursive then impl(count + 1)
+              else
                 task(count)
                 Watch.Trigger
-              }
             case action => action
-          }
         case Trigger =>
-          if (recursive) impl(count + 1)
-          else {
+          if recursive then impl(count + 1)
+          else
             task(count)
             Watch.Trigger
-          }
         case a => a
-      }
-    }
     try impl(initialCount)
-    catch { case NonFatal(t) => new HandleError(t) }
-  }
+    catch case NonFatal(t) => new HandleError(t)
+  end apply
 
-  private[sbt] object NullLogger extends Logger {
+  private[sbt] object NullLogger extends Logger:
     override def trace(t: => Throwable): Unit = {}
     override def success(message: => String): Unit = {}
     override def log(level: Level.Value, message: => String): Unit = {}
-  }
 
   /**
    * Traverse all of the events and find the one for which we give the highest
@@ -419,11 +375,9 @@ object Watch {
    */
   @inline
   private[sbt] def aggregate(events: Seq[(Action, Event)]): Option[(Action, Event)] =
-    if (events.isEmpty) None else Some(events.minBy(_._1))
+    if events.isEmpty then None else Some(events.minBy(_._1))
 
-  extension (s: String) {
-    private def toExec: Exec = Exec(s, None)
-  }
+  extension (s: String) private def toExec: Exec = Exec(s, None)
 
   /**
    * A constant function that returns [[Trigger]].
@@ -474,10 +428,9 @@ object Watch {
    * 3) new line characters cancel the watch and return to the shell
    */
   final def defaultInputParser(options: Seq[Watch.InputOption]): Parser[Action] =
-    distinctOptions(options) match {
+    distinctOptions(options) match
       case Seq()         => (('\n': Parser[Char]) | '\r' | 4.toChar) ^^^ Run("")
       case Seq(h, rest*) => rest.foldLeft(h.parser)(_ | _.parser)
-    }
   final val defaultInputOptions: Seq[Watch.InputOption] = Seq(
     Watch.InputOption("<enter>", "interrupt (exits sbt in batch mode)", CancelWatch, '\n', '\r'),
     Watch.InputOption(4.toChar, "<ctrl-d>", "interrupt (exits sbt in batch mode)", CancelWatch),
@@ -488,31 +441,28 @@ object Watch {
     Watch.InputOption('?', "print options", ShowOptions)
   )
 
-  def defaultInputOptionsMessage(options: Seq[InputOption]): String = {
+  def defaultInputOptionsMessage(options: Seq[InputOption]): String =
     val opts = distinctOptions(options).sortBy(_.input)
     val alignmentLength = opts.map(_.display.length).max + 1
     val formatted =
       opts.map(o => s"${o.display}${" " * (alignmentLength - o.display.length)}: ${o.description}")
     s"Options:\n${formatted.mkString("  ", "\n  ", "")}"
-  }
-  private def distinctOptions(options: Seq[InputOption]): Seq[InputOption] = {
+  private def distinctOptions(options: Seq[InputOption]): Seq[InputOption] =
     val distinctOpts = mutable.Set.empty[String]
     val opts = new mutable.ArrayBuffer[InputOption]
-    (options match {
+    (options match
       case Seq() => defaultInputOptions.headOption.toSeq
       case s     => s
-    }).reverse.foreach { o =>
-      if (distinctOpts.add(o.input)) opts += o
+    ).reverse.foreach { o =>
+      if distinctOpts.add(o.input) then opts += o
     }
     opts.toSeq.reverse
-  }
-  private def waitMessage(project: ProjectRef, commands: Seq[String]): Seq[String] = {
+  private def waitMessage(project: ProjectRef, commands: Seq[String]): Seq[String] =
     val cmds = commands.map(project.project + "/" + _.trim).mkString("; ")
     Seq(
       s"Monitoring source files for $cmds...",
       s"Press <enter> to interrupt or '?' for more options."
     )
-  }
 
   /**
    * A function that prints out the current iteration count and gives instructions for exiting
@@ -520,11 +470,9 @@ object Watch {
    */
   val defaultStartWatch: (Int, ProjectRef, Seq[String]) => Option[String] = {
     (count: Int, project: ProjectRef, commands: Seq[String]) =>
-      {
-        val countStr = s"$count. "
-        Some(s"$countStr${waitMessage(project, commands)
-            .mkString(s"\n${" " * countStr.length}")}")
-      }
+      val countStr = s"$count. "
+      Some(s"$countStr${waitMessage(project, commands)
+          .mkString(s"\n${" " * countStr.length}")}")
   }.label("Watched.defaultStartWatch")
 
   /**
@@ -549,18 +497,16 @@ object Watch {
    */
   private def onTerminationImpl(
       watchPrefixes: String*
-  ): (Action, String, Int, State) => State = { (action, command, count, state) =>
+  ): (Action, String, Int, State) => State = (action, command, count, state) =>
     val prefix = watchPrefixes.head
     val rc = state.remainingCommands
       .filterNot(c => watchPrefixes.exists(c.commandLine.trim.startsWith))
-    action match {
+    action match
       case Run(commands) => state.copy(remainingCommands = commands ++ rc)
       case Reload        =>
         state.copy(remainingCommands = "reload".toExec :: s"$prefix $count $command".toExec :: rc)
       case _: HandleError => state.copy(remainingCommands = rc).fail
       case _              => state.copy(remainingCommands = rc)
-    }
-  }
 
   /**
    * A constant function that always returns `None`. When
@@ -573,11 +519,10 @@ object Watch {
             _: Int,
             path: Path,
             commands: Seq[String]
-        ) => {
+        ) =>
           val msg = s"Build triggered by $path. " +
             s"Running ${commands.mkString("'", "; ", "'")}."
           Some(msg)
-        }
     ).label("Watched.defaultOnTriggerMessage")
 
   final val noTriggerMessage: (Int, Path, Seq[String]) => Option[String] =
@@ -619,4 +564,4 @@ object Watch {
     watchTriggers :== Nil,
     watchAntiEntropyPollPeriod := Watch.defaultAntiEntropyPollPeriod,
   )
-}
+end Watch
diff --git a/main/src/main/scala/sbt/plugins/CorePlugin.scala b/main/src/main/scala/sbt/plugins/CorePlugin.scala
index f843ea127..e2e5854c8 100644
--- a/main/src/main/scala/sbt/plugins/CorePlugin.scala
+++ b/main/src/main/scala/sbt/plugins/CorePlugin.scala
@@ -16,7 +16,7 @@ import Def.Setting
  *
  * Can control task-level parallelism, logging, etc.
  */
-object CorePlugin extends AutoPlugin {
+object CorePlugin extends AutoPlugin:
   // This is included by default
   override def trigger = allRequirements
   override def requires = empty
@@ -25,4 +25,3 @@ object CorePlugin extends AutoPlugin {
     Defaults.coreDefaultSettings
   override lazy val globalSettings: Seq[Setting[?]] =
     Defaults.globalSbtCore
-}
diff --git a/main/src/main/scala/sbt/plugins/DependencyTreePlugin.scala b/main/src/main/scala/sbt/plugins/DependencyTreePlugin.scala
index 7f61089d6..d0229bff2 100644
--- a/main/src/main/scala/sbt/plugins/DependencyTreePlugin.scala
+++ b/main/src/main/scala/sbt/plugins/DependencyTreePlugin.scala
@@ -13,7 +13,7 @@ import sbt.PluginTrigger.AllRequirements
 import sbt.ProjectExtra.*
 import sbt.librarymanagement.Configurations.{ Compile, Test }
 
-object DependencyTreePlugin extends AutoPlugin {
+object DependencyTreePlugin extends AutoPlugin:
   object autoImport extends DependencyTreeKeys
 
   private val defaultDependencyDotHeader =
@@ -39,4 +39,4 @@ object DependencyTreePlugin extends AutoPlugin {
     DependencyTreeSettings.coreSettings ++
       inConfig(Compile)(DependencyTreeSettings.baseSettings) ++
       inConfig(Test)(DependencyTreeSettings.baseSettings)
-}
+end DependencyTreePlugin
diff --git a/main/src/main/scala/sbt/plugins/DependencyTreeSettings.scala b/main/src/main/scala/sbt/plugins/DependencyTreeSettings.scala
index ed60b2dba..3edb7761d 100644
--- a/main/src/main/scala/sbt/plugins/DependencyTreeSettings.scala
+++ b/main/src/main/scala/sbt/plugins/DependencyTreeSettings.scala
@@ -138,7 +138,7 @@ OPTIONS
             SbtUpdateReport.fromConfigurationReport(report, dependencyTreeCrossProjectId.value)
           )
           .getOrElse(ModuleGraph.empty)
-        if (dependencyTreeIncludeScalaLibrary.value) g
+        if dependencyTreeIncludeScalaLibrary.value then g
         else GraphTransformations.ignoreScalaLibrary(sv, g)
       },
       dependencyTreeModuleGraphStore := dependencyTreeModuleGraph0
@@ -221,16 +221,17 @@ OPTIONS
                   if isBrowse then openBrowser(outputFile.toURI, s.log)
                   outputFile.getAbsolutePath
               }
+          end match
+        end if
       }).evaluated,
       whatDependsOn := {
         val ArtifactPattern(org, name, versionFilter) = artifactPatternParser.parsed
         val graph = dependencyTreeModuleGraph0.value
         val modules =
-          versionFilter match {
+          versionFilter match
             case Some(version) => GraphModuleId(org, name, version) :: Nil
             case None          =>
               graph.nodes.withFilter(m => m.id.organization == org && m.id.name == name).map(_.id)
-          }
         val graphWidth = asciiGraphWidth.value
         val output =
           modules
@@ -271,6 +272,7 @@ OPTIONS
               case _        => rendering.LicenseInfo.render(graph)
             handleOutput(output, outFileOpt, isQuiet, appendToFile = false, s.log)
           }
+        end if
       }).evaluated,
     )
 
@@ -399,20 +401,17 @@ OPTIONS
     val module: ModuleID
   }
   def crossName(module: Any) =
-    module match {
+    module match
       case ic: ModuleDescriptorConfiguration => ic.module.name
       case _                                 =>
         throw new IllegalStateException(
           "sbt-dependency-graph plugin currently only supports ModuleDescriptorConfiguration of ivy settings (the default in sbt)"
         )
-    }
 
   val VersionPattern = """(\d+)\.(\d+)\.(\d+)(?:-(.*))?""".r
-  object Version {
-    def unapply(str: String): Option[(Int, Int, Int, Option[String])] = str match {
+  object Version:
+    def unapply(str: String): Option[(Int, Int, Int, Option[String])] = str match
       case VersionPattern(major, minor, fix, appendix) =>
         Some((major.toInt, minor.toInt, fix.toInt, Option(appendix)))
       case _ => None
-    }
-  }
 end DependencyTreeSettings
diff --git a/main/src/main/scala/sbt/plugins/Giter8TemplatePlugin.scala b/main/src/main/scala/sbt/plugins/Giter8TemplatePlugin.scala
index 49d3f398a..92460e306 100644
--- a/main/src/main/scala/sbt/plugins/Giter8TemplatePlugin.scala
+++ b/main/src/main/scala/sbt/plugins/Giter8TemplatePlugin.scala
@@ -16,7 +16,7 @@ import librarymanagement.*
 /**
  * An experimental plugin that adds the ability for Giter8 templates to be resolved
  */
-object Giter8TemplatePlugin extends AutoPlugin {
+object Giter8TemplatePlugin extends AutoPlugin:
   override def requires = CorePlugin
   override def trigger = allRequirements
 
@@ -32,4 +32,3 @@ object Giter8TemplatePlugin extends AutoPlugin {
           "sbtgiter8resolver.Giter8TemplateResolver"
         )
     )
-}
diff --git a/main/src/main/scala/sbt/plugins/IvyPlugin.scala b/main/src/main/scala/sbt/plugins/IvyPlugin.scala
index 7eb9fad43..afc28c02c 100644
--- a/main/src/main/scala/sbt/plugins/IvyPlugin.scala
+++ b/main/src/main/scala/sbt/plugins/IvyPlugin.scala
@@ -24,7 +24,7 @@ import sbt.io.syntax.*
  * - `artifacts`
  * - `publishedArtifacts`
  */
-object IvyPlugin extends AutoPlugin {
+object IvyPlugin extends AutoPlugin:
   // We are automatically included on everything that has the global module,
   // which is automatically included on everything.
   override def requires = CorePlugin
@@ -41,5 +41,3 @@ object IvyPlugin extends AutoPlugin {
     )
   override lazy val projectSettings: Seq[Setting[?]] =
     Classpaths.ivyPublishSettings ++ Classpaths.ivyBaseSettings
-
-}
diff --git a/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala b/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala
index d70115072..d9fb6723f 100644
--- a/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala
+++ b/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala
@@ -30,12 +30,12 @@ import sbt.librarymanagement.Configurations.Test
  *
  *  Note:  Using AutoPlugins to enable/disable build features is experimental in sbt 0.13.5.
  */
-object JUnitXmlReportPlugin extends AutoPlugin {
+object JUnitXmlReportPlugin extends AutoPlugin:
   // TODO - If testing becomes its own plugin, we only rely on the core settings.
   override def requires = JvmPlugin
   override def trigger = allRequirements
 
-  object autoImport {
+  object autoImport:
     val testReportsDirectory =
       settingKey[File]("Directory for outputting junit test reports.").withRank(AMinusSetting)
 
@@ -49,10 +49,9 @@ object JUnitXmlReportPlugin extends AutoPlugin {
         )
       }
     )
-  }
 
   import autoImport.*
 
   override lazy val projectSettings: Seq[Setting[?]] =
     inConfig(Test)(testReportSettings)
-}
+end JUnitXmlReportPlugin
diff --git a/main/src/main/scala/sbt/plugins/JvmPlugin.scala b/main/src/main/scala/sbt/plugins/JvmPlugin.scala
index 2fd0f4081..a66552677 100644
--- a/main/src/main/scala/sbt/plugins/JvmPlugin.scala
+++ b/main/src/main/scala/sbt/plugins/JvmPlugin.scala
@@ -25,7 +25,7 @@ import Def.Setting
  *  - `Test`
  *  - `Compile`
  */
-object JvmPlugin extends AutoPlugin {
+object JvmPlugin extends AutoPlugin:
   // We are automatically enabled for any IvyModule project.  We also require its settings
   // for ours to work.
   override def requires = IvyPlugin
@@ -48,4 +48,4 @@ object JvmPlugin extends AutoPlugin {
 
   override def projectConfigurations: Seq[Configuration] =
     Configurations.default
-}
+end JvmPlugin
diff --git a/main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala b/main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala
index 1d458968d..b41e4e568 100644
--- a/main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala
+++ b/main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala
@@ -22,7 +22,7 @@ import sbt.ScopeFilter.Make.*
 import sbt.util.CacheImplicits.given
 import xsbti.VirtualFileRef
 
-object SemanticdbPlugin extends AutoPlugin {
+object SemanticdbPlugin extends AutoPlugin:
   override def requires = JvmPlugin
   override def trigger = allRequirements
 
@@ -42,14 +42,14 @@ object SemanticdbPlugin extends AutoPlugin {
       val sdb = semanticdbEnabled.value
       val m = semanticdbCompilerPlugin.value
       val sv = scalaVersion.value
-      if (sdb && !ScalaInstance.isDotty(sv)) List(BuildExtra.compilerPlugin(m))
+      if sdb && !ScalaInstance.isDotty(sv) then List(BuildExtra.compilerPlugin(m))
       else Nil
     },
     semanticdbOptions += {
       val sv = scalaVersion.value
-      if (sv.startsWith("0.") || sv.startsWith("3.0.0-M1") || sv.startsWith("3.0.0-M2"))
+      if sv.startsWith("0.") || sv.startsWith("3.0.0-M1") || sv.startsWith("3.0.0-M2") then
         "-Ysemanticdb"
-      else if (sv.startsWith("3.")) "-Xsemanticdb"
+      else if sv.startsWith("3.") then "-Xsemanticdb"
       else "-Yrangepos"
     }
   ) ++
@@ -61,7 +61,7 @@ object SemanticdbPlugin extends AutoPlugin {
       fileConverter.value.toVirtualFile(semanticdbTargetRoot.value.toPath)
     ),
     compileIncremental := Def.taskIf {
-      if (semanticdbIncludeInJar.value || !semanticdbEnabled.value) compileIncremental.value
+      if semanticdbIncludeInJar.value || !semanticdbEnabled.value then compileIncremental.value
       else compileIncAndCacheSemanticdbTargetRootTask.value
     }.value,
     semanticdbTargetRoot := {
@@ -95,13 +95,9 @@ object SemanticdbPlugin extends AutoPlugin {
     }).value,
   )
 
-  def targetRootOptions(scalaVersion: String, targetRoot: File): Seq[String] = {
-    if (ScalaInstance.isDotty(scalaVersion)) {
-      Seq("-semanticdb-target", targetRoot.toString)
-    } else {
-      Seq(s"-P:semanticdb:targetroot:$targetRoot")
-    }
-  }
+  def targetRootOptions(scalaVersion: String, targetRoot: File): Seq[String] =
+    if ScalaInstance.isDotty(scalaVersion) then Seq("-semanticdb-target", targetRoot.toString)
+    else Seq(s"-P:semanticdb:targetroot:$targetRoot")
 
   private val compileIncAndCacheSemanticdbTargetRootTask = Def.cachedTask {
     val prev = compileIncremental.value
@@ -110,10 +106,9 @@ object SemanticdbPlugin extends AutoPlugin {
     prev
   }
 
-  private def ancestorConfigs(config: Configuration) = {
+  private def ancestorConfigs(config: Configuration) =
     def ancestors(configs: Vector[Configuration]): Vector[Configuration] =
       configs ++ configs.flatMap(conf => ancestors(conf.extendsConfigs))
 
     ScopeFilter(configurations = inConfigurations(ancestors(config.extendsConfigs)*))
-  }
-}
+end SemanticdbPlugin
diff --git a/main/src/test/scala/ClasspathsTest.scala b/main/src/test/scala/ClasspathsTest.scala
index 3df356c35..a62668bad 100644
--- a/main/src/test/scala/ClasspathsTest.scala
+++ b/main/src/test/scala/ClasspathsTest.scala
@@ -17,9 +17,9 @@ class ClasspathsTest[T](
     taskKey: TaskKey[Seq[T]],
     initVal: Initialize[Seq[T]],
     taskVal: Initialize[Task[Seq[T]]],
-) {
+):
 
-  def testConcat() = {
+  def testConcat() =
     concat(settKey, settKey)
     concat(settKey, taskKey)
     concat(settKey, initVal)
@@ -36,12 +36,10 @@ class ClasspathsTest[T](
     concat(taskVal, taskKey)
     concat(taskVal, initVal)
     concat(taskVal, taskVal)
-  }
 
-  def testConcatSettings() = {
+  def testConcatSettings() =
     concatSettings(settKey, settKey)
     concatSettings(settKey, initVal)
     concatSettings(initVal, settKey)
     concatSettings(initVal, initVal)
-  }
-}
+end ClasspathsTest
diff --git a/main/src/test/scala/Delegates.scala b/main/src/test/scala/Delegates.scala
index 2da2a4c96..e50004f03 100644
--- a/main/src/test/scala/Delegates.scala
+++ b/main/src/test/scala/Delegates.scala
@@ -15,7 +15,7 @@ import hedgehog.*
 import hedgehog.Result.{ all, assert, failure, success }
 import hedgehog.runner.*
 
-object Delegates extends Properties {
+object Delegates extends Properties:
 
   override def tests: List[Test] =
     List(
@@ -85,10 +85,10 @@ object Delegates extends Properties {
         "Project axis delegates to BuildRef then Zero",
         keysGen.forAll.map { keys =>
           allDelegates(keys) { (key, ds) =>
-            key.project match {
+            key.project match
               case Zero                          => success // filtering out of testing
               case Select(rr: ResolvedReference) =>
-                rr match {
+                rr match
                   case BuildRef(_) =>
                     assert(ds.indexOf(key) < ds.indexOf(key.copy(project = Zero)))
                   case ProjectRef(uri, _) =>
@@ -102,10 +102,8 @@ object Delegates extends Properties {
                         assert((idxKey < idxB) && (idxB < idxZ))
                           .log(s"idxKey = $idxKey; idxB = $idxB; idxZ = $idxZ")
                       )
-                }
               case Select(_) | This =>
                 failure.log(s"Scope's reference should be resolved, but was ${key.project}")
-            }
           }
         }
       ),
@@ -113,10 +111,10 @@ object Delegates extends Properties {
         "Config axis delegates to parent configuration",
         keysGen.forAll.map { keys =>
           allDelegates(keys) { (key, ds) =>
-            key.config match {
+            key.config match
               case Zero           => success
               case Select(config) =>
-                key.project match {
+                key.project match
                   case Select(p @ ProjectRef(_, _)) =>
                     val r = keys.env.resolve(p)
                     keys.env.inheritConfig(r, config).headOption.fold(success) { parent =>
@@ -127,9 +125,7 @@ object Delegates extends Properties {
                         .log(s"idxKey = $idxKey; a = $a; idxA = $idxA")
                     }
                   case _ => success
-                }
               case _ => success
-            }
           }
         }
       )
@@ -157,7 +153,7 @@ object Delegates extends Properties {
       }.toList)
     )
 
-  def globalCombinations(s: Scope, ds: Seq[Scope]): hedgehog.Result = {
+  def globalCombinations(s: Scope, ds: Seq[Scope]): hedgehog.Result =
     val mods = List[Scope => Scope](
       _.copy(project = Zero),
       _.copy(config = Zero),
@@ -167,14 +163,12 @@ object Delegates extends Properties {
     val modAndIdent = mods.map(_ :: idFun[Scope] :: Nil)
 
     def loop(cur: Scope, acc: List[Scope], rem: List[Seq[Scope => Scope]]): Seq[Scope] =
-      rem match {
+      rem match
         case Nil     => acc
         case x :: xs =>
           x flatMap { mod =>
             val s = mod(cur)
             loop(s, s :: acc, xs)
           }
-      }
     all(loop(s, Nil, modAndIdent).map(x => assert(ds contains x)).toList)
-  }
-}
+end Delegates
diff --git a/main/src/test/scala/ParseKeySpec.scala b/main/src/test/scala/ParseKeySpec.scala
index 249803c59..e00313d4e 100644
--- a/main/src/test/scala/ParseKeySpec.scala
+++ b/main/src/test/scala/ParseKeySpec.scala
@@ -21,7 +21,7 @@ import hedgehog.runner.*
  * Tests that the scoped key parser in Act can correctly parse a ScopedKey converted by Def.show*Key.
  * This includes properly resolving omitted components.
  */
-object ParseKeySpec extends Properties {
+object ParseKeySpec extends Properties:
   val exampleCount = 1000
 
   override def tests: List[Test] = List(
@@ -51,7 +51,7 @@ object ParseKeySpec extends Properties {
     Test(name, result)
       .config(_.copy(testLimit = SuccessCount(n), shrinkLimit = ShrinkLimit(n * 10)))
 
-  def roundtrip(skm: StructureKeyMask) = {
+  def roundtrip(skm: StructureKeyMask) =
     import skm.{ structure, key }
 
     // if the configuration axis == Zero
@@ -61,7 +61,7 @@ object ParseKeySpec extends Properties {
     val hasZeroConfig = key.scope.config == Zero
 
     val showZeroConfig = hasZeroConfig || hasAmbiguousLowercaseAxes(key, structure)
-    val mask = if (showZeroConfig) skm.mask.copy(project = true) else skm.mask
+    val mask = if showZeroConfig then skm.mask.copy(project = true) else skm.mask
 
     val expected = resolve(structure, key, mask)
     parseCheck(structure, key, mask, showZeroConfig)(sk =>
@@ -70,9 +70,8 @@ object ParseKeySpec extends Properties {
         .log(s"$sk.key == $expected.key: ${sk.key == expected.key}")
         .log(s"${sk.scope} == ${expected.scope}: ${Scope.equal(sk.scope, expected.scope, mask)}")
     ).log(s"Expected: ${displayFull(expected)}")
-  }
 
-  def noProject(skm: StructureKeyMask) = {
+  def noProject(skm: StructureKeyMask) =
     import skm.{ structure, key }
     // When task is shown and task name matches a project name, we need to show config
     // to disambiguate (otherwise 'taskName / keyName' could be parsed as 'projectName / keyName')
@@ -87,15 +86,13 @@ object ParseKeySpec extends Properties {
         .log(s"parsed subproject: ${sk.scope.project}")
         .log(s"current subproject: ${structure.current}")
     )
-  }
 
-  def noTask(skm: StructureKeyMask) = {
+  def noTask(skm: StructureKeyMask) =
     import skm.{ structure, key }
     val mask = skm.mask.copy(task = false)
     parseCheck(structure, key, mask)(_.scope.task ==== Zero)
-  }
 
-  def noConfig(skm: StructureKeyMask) = {
+  def noConfig(skm: StructureKeyMask) =
     import skm.{ structure, key }
     val mask = ScopeMask(config = false)
     val resolvedConfig = Resolve.resolveConfig(structure.extra, key.key, mask)(key.scope).config
@@ -103,59 +100,54 @@ object ParseKeySpec extends Properties {
     parseCheck(structure, key, mask, showZeroConfig)(sk =>
       (sk.scope.config ==== resolvedConfig) or (sk.scope ==== Scope.GlobalScope)
     ).log(s"Expected configuration: ${resolvedConfig.map(_.name)}")
-  }
 
   val arbStructure: Gen[Structure] =
-    for {
+    for
       env <- mkEnv
       loadFactor <- Gen.double(Range.linearFrac(0.0, 1.0))
       scopes <- pickN(loadFactor, env.allFullScopes)
       current <- oneOf(env.allProjects.unzip._1)
-    } yield {
+    yield
       val settings = structureSettings(scopes, env)
       TestBuild.structure(env, settings, current)
-    }
 
-  def structureSettings(scopes: Seq[Scope], env: Env): Seq[Def.Setting[String]] = {
-    for {
+  def structureSettings(scopes: Seq[Scope], env: Env): Seq[Def.Setting[String]] =
+    for
       scope <- scopes
       t <- env.tasks
-    } yield Def.setting(ScopedKey(scope, t.key), Def.value(""))
-  }
+    yield Def.setting(ScopedKey(scope, t.key), Def.value(""))
 
   final case class StructureKeyMask(structure: Structure, key: ScopedKey[?], mask: ScopeMask)
 
   val arbStructureKeyMask: Gen[StructureKeyMask] =
-    (for {
+    (for
       structure <- arbStructure
       // NOTE: Generating this after the structure improves shrinking
       mask <- maskGen
       key <-
-        for {
+        for
           scope <- TestBuild.scope(structure.env)
           key <- oneOf(structure.allAttributeKeys.toSeq)
-        } yield ScopedKey(scope, key)
+        yield ScopedKey(scope, key)
       skm = StructureKeyMask(structure, key, mask)
-    } yield skm)
+    yield skm)
       .filter(configExistsInIndex)
 
-  private def configExistsInIndex(skm: StructureKeyMask): Boolean = {
+  private def configExistsInIndex(skm: StructureKeyMask): Boolean =
     import skm.*
     val resolvedKey = resolve(structure, key, mask)
     val proj = resolvedKey.scope.project.toOption
     val maybeResolvedProj = proj.collect { case ref: ResolvedReference =>
       ref
     }
-    val checkName = for {
-      configKey <- resolvedKey.scope.config.toOption
-    } yield {
-      val configID = Scope.display(configKey)
-      // This only works for known configurations or those that were guessed correctly.
-      val name = structure.keyIndex.fromConfigIdent(maybeResolvedProj)(configID)
-      name == configKey.name
-    }
+    val checkName =
+      for configKey <- resolvedKey.scope.config.toOption
+      yield
+        val configID = Scope.display(configKey)
+        // This only works for known configurations or those that were guessed correctly.
+        val name = structure.keyIndex.fromConfigIdent(maybeResolvedProj)(configID)
+        name == configKey.name
     checkName.getOrElse(true)
-  }
 
   def resolve(structure: Structure, key: ScopedKey[?], mask: ScopeMask): ScopedKey[?] =
     ScopedKey(
@@ -168,7 +160,7 @@ object ParseKeySpec extends Properties {
       key: ScopedKey[?],
       mask: ScopeMask,
       showZeroConfig: Boolean = false,
-  )(f: ScopedKey[?] => hedgehog.Result): hedgehog.Result = {
+  )(f: ScopedKey[?] => hedgehog.Result): hedgehog.Result =
     val s = displayMasked(key, mask, showZeroConfig)
     val parser = makeParser(structure)
     val parsed = Parser.result(parser, s).left.map(_().toString)
@@ -181,7 +173,6 @@ object ParseKeySpec extends Properties {
         .log(s"Parsed: ${parsed.map(displayFull)}")
         .log(s"Structure: $structure")
     )
-  }
 
   // pickN is a function that randomly picks load % items from the "from" sequence.
   // The rest of the tests expect at least one item, so I changed it to return 1 in case of 0.
@@ -197,22 +188,20 @@ object ParseKeySpec extends Properties {
   // then a scoped key like `<proj>/<conf>/zv/name` would render as `zv/name`
   // which would be interpreted as `zv/Zero/Zero/name` (project zv)
   // so we also check if the task label matches a project name
-  def hasAmbiguousLowercaseAxes(key: ScopedKey[?], structure: Structure): Boolean = {
+  def hasAmbiguousLowercaseAxes(key: ScopedKey[?], structure: Structure): Boolean =
     val label = key.key.label
     val allProjects = allProjectNames(structure)
     allProjects(label) || hasAmbiguousTaskLabel(key, structure)
-  }
 
   // checks if the task label matches a project name
-  def hasAmbiguousTaskLabel(key: ScopedKey[?], structure: Structure): Boolean = {
+  def hasAmbiguousTaskLabel(key: ScopedKey[?], structure: Structure): Boolean =
     val taskLabel = key.scope.task.toOption.map(_.label)
     val allProjects = allProjectNames(structure)
     taskLabel.exists(allProjects)
-  }
 
   private def allProjectNames(structure: Structure): Set[String] =
-    for {
+    for
       uri <- structure.keyIndex.buildURIs
       project <- structure.keyIndex.projects(uri)
-    } yield project
-}
+    yield project
+end ParseKeySpec
diff --git a/main/src/test/scala/ParserSpec.scala b/main/src/test/scala/ParserSpec.scala
index c16d554f7..8f66cf361 100644
--- a/main/src/test/scala/ParserSpec.scala
+++ b/main/src/test/scala/ParserSpec.scala
@@ -19,7 +19,7 @@ import sbt.librarymanagement.Configuration
 import hedgehog.*
 import hedgehog.runner.*
 
-object ParserSpec extends Properties {
+object ParserSpec extends Properties:
   override def tests: List[Test] =
     List(
       property(
@@ -53,7 +53,7 @@ object ParserSpec extends Properties {
       projectID: String = "p",
       configName: String = "c",
       attributeName: String = "a"
-  ) = {
+  ) =
     val attributeKey = AttributeKey[String](attributeName)
     val scope = Scope(
       Select(BuildRef(buildURI)),
@@ -80,5 +80,5 @@ object ParserSpec extends Properties {
     val resultStr = result.fold(_ => "<parse error>", _.toString)
     (result ==== Right(scopedKey))
       .log(s"$string parsed back to $resultStr rather than $scopedKey")
-  }
-}
+  end parse
+end ParserSpec
diff --git a/main/src/test/scala/PluginCommandTest.scala b/main/src/test/scala/PluginCommandTest.scala
index f1275466d..af2065977 100644
--- a/main/src/test/scala/PluginCommandTest.scala
+++ b/main/src/test/scala/PluginCommandTest.scala
@@ -21,13 +21,15 @@ import sbt.internal.util.{
 }
 import sbt.internal.inc.PlainVirtualFileConverter
 
-object PluginCommandTestPlugin0 extends AutoPlugin { override def requires = empty }
+object PluginCommandTestPlugin0 extends AutoPlugin:
+  override def requires = empty
 
 package subpackage {
-  object PluginCommandTestPlugin1 extends AutoPlugin { override def requires = empty }
+  object PluginCommandTestPlugin1 extends AutoPlugin:
+    override def requires = empty
 }
 
-object PluginCommandTest extends verify.BasicTestSuite {
+object PluginCommandTest extends verify.BasicTestSuite:
   import subpackage.*
   import FakeState.*
 
@@ -62,26 +64,24 @@ object PluginCommandTest extends verify.BasicTestSuite {
       )
     )
   }
-}
+end PluginCommandTest
 
-object FakeState {
+object FakeState:
 
-  def processCommand(input: String, enabledPlugins: AutoPlugin*): String = {
+  def processCommand(input: String, enabledPlugins: AutoPlugin*): String =
     val outBuffer = new ByteArrayOutputStream
     val logFile = File.createTempFile("sbt", ".log")
-    try {
+    try
       val state = FakeState(logFile, enabledPlugins*)
       Terminal.withOut(new PrintStream(outBuffer, true)) {
         MainLoop.processCommand(Exec(input, None), state)
       }
       new String(outBuffer.toByteArray)
-    } finally {
+    finally
       logFile.delete()
       ()
-    }
-  }
 
-  def apply(logFile: File, plugins: AutoPlugin*) = {
+  def apply(logFile: File, plugins: AutoPlugin*) =
 
     val base = new File("").getAbsoluteFile
     val testProject = Project("test-project", base).setAutoPlugins(plugins)
@@ -162,7 +162,5 @@ object FakeState {
       None,
       State.Continue
     )
-
-  }
-
-}
+  end apply
+end FakeState
diff --git a/main/src/test/scala/ProjectMacro.scala b/main/src/test/scala/ProjectMacro.scala
index 7f11808bd..571af7e56 100644
--- a/main/src/test/scala/ProjectMacro.scala
+++ b/main/src/test/scala/ProjectMacro.scala
@@ -14,7 +14,7 @@ import Prop.*
 import sbt.BuildExtra.{ project, rootProject }
 import java.io.File
 
-class ProjectDefs {
+class ProjectDefs:
   lazy val p = project
 
   val x = project
@@ -29,20 +29,17 @@ class ProjectDefs {
   val a: Project = project
 
   lazy val aa: Project = project
-}
 
-object ProjectMacro extends Properties("ProjectMacro") {
+object ProjectMacro extends Properties("ProjectMacro"):
   lazy val pd = new ProjectDefs
   import pd.*
 
   def secure(f: => Prop): Prop =
-    try {
-      Prop.secure(f)
-    } catch {
+    try Prop.secure(f)
+    catch
       case NonFatal(e) =>
         e.printStackTrace
         throw e
-    }
 
   property("Explicit type on lazy val supported") = secure {
     check(aa, "aa", "aa")
@@ -68,12 +65,11 @@ object ProjectMacro extends Properties("ProjectMacro") {
     check(root, "root", ".")
   }
 
-  def check(p: Project, id: String, dir: String): Prop = {
+  def check(p: Project, id: String, dir: String): Prop =
     s"Expected id: $id" |:
       s"Expected dir: $dir" |:
       s"Actual id: ${p.id}" |:
       s"Actual dir: ${p.base}" |:
       (p.id == id) &&
       (p.base.getName == dir)
-  }
-}
+end ProjectMacro
diff --git a/main/src/test/scala/ProjectSpec.scala b/main/src/test/scala/ProjectSpec.scala
index cd8824124..aa62cdb91 100644
--- a/main/src/test/scala/ProjectSpec.scala
+++ b/main/src/test/scala/ProjectSpec.scala
@@ -10,10 +10,9 @@ package sbt
 
 import java.io.File
 
-object ProjectSpec extends verify.BasicTestSuite {
-  object TestPlugin extends AutoPlugin {
+object ProjectSpec extends verify.BasicTestSuite:
+  object TestPlugin extends AutoPlugin:
     override def requires: Plugins = empty
-  }
 
   private val base = new File(".")
 
@@ -34,4 +33,4 @@ object ProjectSpec extends verify.BasicTestSuite {
   }
 
   def emptyFilename = ""
-}
+end ProjectSpec
diff --git a/main/src/test/scala/ScopeFilterOrderingSpec.scala b/main/src/test/scala/ScopeFilterOrderingSpec.scala
index 8ecaec941..7a75959aa 100644
--- a/main/src/test/scala/ScopeFilterOrderingSpec.scala
+++ b/main/src/test/scala/ScopeFilterOrderingSpec.scala
@@ -14,7 +14,7 @@ import hedgehog.runner.*
 
 import java.net.URI
 
-object ScopeFilterOrderingSpec extends Properties {
+object ScopeFilterOrderingSpec extends Properties:
   private val buildUri = new URI("file:///scope-filter-ordering/")
 
   override def tests: List[Test] =
@@ -64,4 +64,4 @@ object ScopeFilterOrderingSpec extends Properties {
       Scope(Select(project), Select(ConfigKey("test")), Zero, Zero),
       Scope(Select(project), Zero, Zero, Zero)
     )
-}
+end ScopeFilterOrderingSpec
diff --git a/main/src/test/scala/SelectedFilterTest.scala b/main/src/test/scala/SelectedFilterTest.scala
index 9f947eaa8..d8c7fa5f9 100644
--- a/main/src/test/scala/SelectedFilterTest.scala
+++ b/main/src/test/scala/SelectedFilterTest.scala
@@ -10,7 +10,7 @@ package sbt
 
 import sbt.internal.IncrementalTest
 
-object DefaultsTest extends verify.BasicTestSuite {
+object DefaultsTest extends verify.BasicTestSuite:
 
   test("`selectedFilter` should return all tests for an empty list") {
     val expected = Map("Test1" -> true, "Test2" -> true)
@@ -129,4 +129,4 @@ object DefaultsTest extends verify.BasicTestSuite {
       ) == expected
     )
   }
-}
+end DefaultsTest
diff --git a/main/src/test/scala/TagsTest.scala b/main/src/test/scala/TagsTest.scala
index 713180f3a..2a0590ff9 100644
--- a/main/src/test/scala/TagsTest.scala
+++ b/main/src/test/scala/TagsTest.scala
@@ -13,15 +13,15 @@ import Gen.listOf
 import Prop.*
 import Tags.*
 
-object TagsTest extends Properties("Tags") {
+object TagsTest extends Properties("Tags"):
   final case class Size(value: Int)
 
-  def tagMap: Gen[TagMap] = for (ts <- listOf(tagAndFrequency)) yield ts.toMap
+  def tagMap: Gen[TagMap] = for ts <- listOf(tagAndFrequency) yield ts.toMap
   def tagAndFrequency: Gen[(Tag, Int)] =
-    for (t <- tag; count <- Gen.choose(0, Int.MaxValue)) yield (t, count)
-  def tag: Gen[Tag] = for (s <- Gen.alphaStr if !s.isEmpty) yield Tag(s)
+    for t <- tag; count <- Gen.choose(0, Int.MaxValue) yield (t, count)
+  def tag: Gen[Tag] = for s <- Gen.alphaStr if !s.isEmpty yield Tag(s)
   def size: Gen[Size] =
-    for (i <- Arbitrary.arbitrary[Int] if i != Int.MinValue) yield Size(math.abs(i))
+    for i <- Arbitrary.arbitrary[Int] if i != Int.MinValue yield Size(math.abs(i))
 
   given aTagMap: Arbitrary[Map[Tag, Int]] = Arbitrary(tagMap)
   given aTagAndFrequency: Arbitrary[(Tag, Int)] = Arbitrary(tagAndFrequency)
@@ -48,5 +48,4 @@ object TagsTest extends Properties("Tags") {
   }
 
   private def excl(tag: Tag): TagMap => Boolean = predicate(exclusive(tag) :: Nil)
-
-}
+end TagsTest
diff --git a/main/src/test/scala/sbt/TemplateCommandUtilTest.scala b/main/src/test/scala/sbt/TemplateCommandUtilTest.scala
index d0b490322..e51aca906 100644
--- a/main/src/test/scala/sbt/TemplateCommandUtilTest.scala
+++ b/main/src/test/scala/sbt/TemplateCommandUtilTest.scala
@@ -26,10 +26,11 @@ object TemplateCommandUtilTest extends verify.BasicTestSuite:
   test("defaultRunLocalTemplate throws for unknown .local slug"):
     val log = Logger.Null
     val ex =
-      try {
+      try
         TemplateCommandUtil.defaultRunLocalTemplate(List("unknown/template.local"), log)
         null
-      } catch { case e: IllegalArgumentException => e }
+      catch case e: IllegalArgumentException => e
     assert(ex ne null)
     assert(ex.getMessage.contains("Local template not found for:"))
     assert(ex.getMessage.contains("unknown/template.local"))
+end TemplateCommandUtilTest
diff --git a/main/src/test/scala/sbt/coursierint/ResolutionProgressSpec.scala b/main/src/test/scala/sbt/coursierint/ResolutionProgressSpec.scala
index cd4f37967..8a3d92296 100644
--- a/main/src/test/scala/sbt/coursierint/ResolutionProgressSpec.scala
+++ b/main/src/test/scala/sbt/coursierint/ResolutionProgressSpec.scala
@@ -43,12 +43,11 @@ object ResolutionProgressSpec extends BasicTestSuite:
     // a module count it cannot know.
     val p = new ResolutionProgress
     val log = new ResolutionProgressLogger(p)
-    for (_ <- 1 to 3) { // e.g. compile, runtime, test sessions of one module's update
+    for _ <- 1 to 3 do // e.g. compile, runtime, test sessions of one module's update
       log.init(None)
       log.foundLocally("x.pom")
       log.foundLocally("x.jar")
       log.stop()
-    }
     log.init(None)
     log.foundLocally("x.jar") // re-checked again in the artifacts run
     val line = p.snapshot().map(_._1)
diff --git a/main/src/test/scala/sbt/internal/AggregationSpec.scala b/main/src/test/scala/sbt/internal/AggregationSpec.scala
index bb4fbed5d..5e033502d 100644
--- a/main/src/test/scala/sbt/internal/AggregationSpec.scala
+++ b/main/src/test/scala/sbt/internal/AggregationSpec.scala
@@ -16,7 +16,7 @@ import sbt.internal.TestBuild.{ Build, Env, Proj, Taskk }
 import sbt.internal.util.AttributeKey
 import sbt.librarymanagement.Configuration
 
-object AggregationSpec extends verify.BasicTestSuite {
+object AggregationSpec extends verify.BasicTestSuite:
   val timing = Aggregation.timing(0, _: Long)
 
   test(
@@ -52,4 +52,4 @@ object AggregationSpec extends verify.BasicTestSuite {
   test("timing should not emit special space characters") {
     assert(!timing(96003099).contains("\u202F"))
   }
-}
+end AggregationSpec
diff --git a/main/src/test/scala/sbt/internal/ClassStamperTest.scala b/main/src/test/scala/sbt/internal/ClassStamperTest.scala
index d1b71d06b..5d840bde7 100644
--- a/main/src/test/scala/sbt/internal/ClassStamperTest.scala
+++ b/main/src/test/scala/sbt/internal/ClassStamperTest.scala
@@ -93,6 +93,7 @@ object ClassStamperTest extends Properties:
           ),
       )
     )
+  end regressionGoldens
 
   // ---------- helpers ----------
 
@@ -156,6 +157,7 @@ object ClassStamperTest extends Properties:
       libraryDeps = libraryDeps.map { case (vf, cn) => (vf, cn, EmptyStamp) },
     )
     Analysis.empty.copy(relations = rels)
+  end analysisOf
 
   private def stamper(analyses: Analysis*): ClassStamper =
     new ClassStamper(analyses.toSeq, StubConverter)
@@ -213,6 +215,7 @@ object ClassStamperTest extends Properties:
         Result.diffNamed("internal dep should change digest", d1, d2)(_ != _),
       )
     )
+  end digestReflectsInternalDeps
 
   def digestReflectsLibraryDeps: Result =
     val a = analysisOf(
@@ -236,6 +239,7 @@ object ClassStamperTest extends Properties:
         Result.diffNamed("digests for different libraries should differ", d1, d2)(_ != _),
       )
     )
+  end digestReflectsLibraryDeps
 
   def externalDepWithoutLibraryIsNoOp: Result =
     // An external dep with no matching library entry contributes nothing
@@ -329,6 +333,7 @@ object ClassStamperTest extends Properties:
         Result.assert(stamp(stamper(a2), "X").isEmpty).log("X must be None without a1"),
       )
     )
+  end multipleAnalysesAreWalked
 
   def cyclesDoNotLoopForever: Result =
     // A -> B and B -> A in internal deps. The `alreadySeen` guard prevents
diff --git a/main/src/test/scala/sbt/internal/CompileDebugLoggerSpec.scala b/main/src/test/scala/sbt/internal/CompileDebugLoggerSpec.scala
index 72b0c85ce..e85e19c17 100644
--- a/main/src/test/scala/sbt/internal/CompileDebugLoggerSpec.scala
+++ b/main/src/test/scala/sbt/internal/CompileDebugLoggerSpec.scala
@@ -12,16 +12,15 @@ import java.util.concurrent.CopyOnWriteArrayList
 import scala.jdk.CollectionConverters.*
 import sbt.util.{ Level, Logger }
 
-object CompileDebugLoggerSpec extends verify.BasicTestSuite {
+object CompileDebugLoggerSpec extends verify.BasicTestSuite:
 
   test("CompileDebugLogger prefixes debug and info messages with project id (#408)") {
     val messages = new CopyOnWriteArrayList[(Level.Value, String)]()
-    val delegate: Logger = new Logger {
+    val delegate: Logger = new Logger:
       def log(level: Level.Value, message: => String): Unit =
-        if (level == Level.Debug || level == Level.Info) messages.add((level, message))
+        if level == Level.Debug || level == Level.Info then messages.add((level, message))
       def trace(t: => Throwable): Unit = ()
       def success(message: => String): Unit = ()
-    }
     val prefixed = CompileDebugLogger("myProject", delegate)
     prefixed.debug("Initial source changes: ")
     prefixed.debug("removed:Set()")
@@ -34,12 +33,11 @@ object CompileDebugLoggerSpec extends verify.BasicTestSuite {
 
   test("CompileDebugLogger does not prefix warn/error") {
     val allMessages = new CopyOnWriteArrayList[(Level.Value, String)]()
-    val delegate: Logger = new Logger {
+    val delegate: Logger = new Logger:
       def log(level: Level.Value, message: => String): Unit =
         allMessages.add((level, message))
       def trace(t: => Throwable): Unit = ()
       def success(message: => String): Unit = ()
-    }
     val prefixed = CompileDebugLogger("p", delegate)
     prefixed.debug("debug msg")
     prefixed.info("info msg")
@@ -51,4 +49,4 @@ object CompileDebugLoggerSpec extends verify.BasicTestSuite {
     assert(prefixedLevels.forall(l => l == Level.Debug || l == Level.Info))
     assert(notPrefixed.map(_._1).forall(l => l == Level.Warn || l == Level.Error))
   }
-}
+end CompileDebugLoggerSpec
diff --git a/main/src/test/scala/sbt/internal/CrossJavaTest.scala b/main/src/test/scala/sbt/internal/CrossJavaTest.scala
index 8b10be51b..6d7377284 100644
--- a/main/src/test/scala/sbt/internal/CrossJavaTest.scala
+++ b/main/src/test/scala/sbt/internal/CrossJavaTest.scala
@@ -17,7 +17,7 @@ import sbt.io.{ IO, syntax }
 import sbt.io.syntax.*
 import scala.collection.immutable.ListMap
 
-class CrossJavaTest extends AnyFunSuite with Diagrams {
+class CrossJavaTest extends AnyFunSuite with Diagrams:
   test("The Java home selector should select the most recent") {
     assert(
       List("jdk1.8.0.jdk", "jdk1.8.0_121.jdk", "jdk1.8.0_45.jdk")
@@ -27,7 +27,7 @@ class CrossJavaTest extends AnyFunSuite with Diagrams {
   }
 
   test("The Linux Java home selector should correctly pick up Fedora Java installations") {
-    val conf = new LinuxDiscoverConfig(sbt.io.syntax.file(".")) {
+    val conf = new LinuxDiscoverConfig(sbt.io.syntax.file(".")):
       override def candidates(): Vector[String] =
         """
             |java-1.8.0-openjdk-1.8.0.162-3.b12.fc28.x86_64
@@ -40,34 +40,30 @@ class CrossJavaTest extends AnyFunSuite with Diagrams {
             |jre-1.8.0-openjdk-1.8.0.172-9.b11.fc28.x86_64
             |jre-openjdk
           """.stripMargin.split("\n").filter(_.nonEmpty).toVector
-    }
     val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
     assert(version == "1.8")
     assert(file.getName == "java-1.8.0-openjdk-1.8.0.172-9.b11.fc28.x86_64")
   }
 
   test("The Linux Java home selector should correctly pick up Oracle RPM installations") {
-    val conf = new LinuxDiscoverConfig(sbt.io.syntax.file(".")) {
+    val conf = new LinuxDiscoverConfig(sbt.io.syntax.file(".")):
       override def candidates(): Vector[String] = Vector("jdk1.8.0_172-amd64")
-    }
     val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
     assert(version == "1.8")
     assert(file.getName == "jdk1.8.0_172-amd64")
   }
 
   test("The Windows Java home selector should correctly pick up a JDK") {
-    val conf = new WindowsDiscoverConfig(sbt.io.syntax.file(".")) {
+    val conf = new WindowsDiscoverConfig(sbt.io.syntax.file(".")):
       override def candidates() = Vector("jdk1.7.0")
-    }
     val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
     assert(version == "1.7")
     assert(file.getName == "jdk1.7.0")
   }
 
   test("The Windows Java home selector should correctly pick up a JDK with vendors") {
-    val conf = new WindowsDiscoverConfig(sbt.io.syntax.file("."), Seq("xxx", "yyy")) {
+    val conf = new WindowsDiscoverConfig(sbt.io.syntax.file("."), Seq("xxx", "yyy")):
       override def candidates() = Vector("jdk1.7.0")
-    }
     val homes = conf.javaHomes
     assert(homes.size == 2)
     assert(homes.map(_._1) == Vector("xxx@1.7", "yyy@1.7"))
@@ -75,36 +71,32 @@ class CrossJavaTest extends AnyFunSuite with Diagrams {
   }
 
   test("The JAVA_HOME selector should correctly pick up a JDK") {
-    val conf = new JavaHomeDiscoverConfig {
+    val conf = new JavaHomeDiscoverConfig:
       override def home() = Some("/opt/jdk8")
-    }
     val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
     assert(version == "8")
     assert(file.getName == "jdk8")
   }
 
   test("The JAVA_HOME selector should correctly pick up an Oracle JDK") {
-    val conf = new JavaHomeDiscoverConfig {
+    val conf = new JavaHomeDiscoverConfig:
       override def home() = Some("/opt/oracle-jdk-bin-1.8.0.181")
-    }
     val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
     assert(version == "1.8")
     assert(file.getName == "oracle-jdk-bin-1.8.0.181")
   }
 
   test("The SDKMAN selector should correctly pick up an AdoptOpenJDK") {
-    val conf = new SdkmanDiscoverConfig {
+    val conf = new SdkmanDiscoverConfig:
       override def candidates() = Vector("11.0.2.hs-adpt")
-    }
     val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
     assert(version == "adopt@11.0.2")
     assert(file.getName == "11.0.2.hs-adpt")
   }
 
   test("expandJavaHomes") {
-    val conf = new SdkmanDiscoverConfig {
+    val conf = new SdkmanDiscoverConfig:
       override def candidates() = Vector("11.0.2.hs-adpt")
-    }
     val hs = CrossJava.expandJavaHomes(ListMap(conf.javaHomes*))
     assert(hs.contains("11"))
   }
@@ -253,4 +245,4 @@ class CrossJavaTest extends AnyFunSuite with Diagrams {
     assert(completions.contains("-v"), "completion list should suggest -v")
     assert(completions.contains("compile"), "completion list should suggest compile")
     assert(completions.contains("test"), "completion list should suggest test")
-}
+end CrossJavaTest
diff --git a/main/src/test/scala/sbt/internal/GCMonitorTest.scala b/main/src/test/scala/sbt/internal/GCMonitorTest.scala
index 563fed172..66d72cc50 100644
--- a/main/src/test/scala/sbt/internal/GCMonitorTest.scala
+++ b/main/src/test/scala/sbt/internal/GCMonitorTest.scala
@@ -15,25 +15,23 @@ import org.scalatest.funsuite.AnyFunSuite
 import scala.collection.mutable.ListBuffer
 import scala.concurrent.duration.*
 
-class GCMonitorTest extends AnyFunSuite {
-  class TestMonitor extends GCMonitorBase {
+class GCMonitorTest extends AnyFunSuite:
+  class TestMonitor extends GCMonitorBase:
     val loggedTotals = ListBuffer.empty[Long]
     override protected val window = 10.seconds
     override protected val ratio = 0.5
 
     override protected def emitWarning(total: Long, over: Option[Long]): Unit =
       loggedTotals += total
-  }
 
   val collectionTimeStore = new AtomicReference(0.millis -> 0L)
 
-  def simulateBy(f: Long => Long): Long => List[Long] = { duration =>
+  def simulateBy(f: Long => Long): Long => List[Long] = duration =>
     collectionTimeStore.set(0.millis -> 0)
     val testMonitor = new TestMonitor
-    for (x <- 0L to duration by 100)
+    for x <- 0L to duration by 100 do
       testMonitor.totalCollectionTimeChanged(x, f(x), collectionTimeStore)
     testMonitor.loggedTotals.toList
-  }
 
   test("GC time = time") {
     val simulate = simulateBy(identity)
@@ -60,4 +58,4 @@ class GCMonitorTest extends AnyFunSuite {
     assertResult(List(5200, 20000, 20000))(simulate(30000))
     assertResult(List(5200, 20000, 20000, 20000))(simulate(40000))
   }
-}
+end GCMonitorTest
diff --git a/main/src/test/scala/sbt/internal/InMemoryCacheStoreTest.scala b/main/src/test/scala/sbt/internal/InMemoryCacheStoreTest.scala
index 7adac79ad..cb1d7c100 100644
--- a/main/src/test/scala/sbt/internal/InMemoryCacheStoreTest.scala
+++ b/main/src/test/scala/sbt/internal/InMemoryCacheStoreTest.scala
@@ -100,3 +100,4 @@ object InMemoryCacheStoreTest extends Properties:
       val value = second("value").read[String]()
       Result.assert(value == "written by the first session").log(s"got '$value'")
     }
+end InMemoryCacheStoreTest
diff --git a/main/src/test/scala/sbt/internal/InstallSbtnSpec.scala b/main/src/test/scala/sbt/internal/InstallSbtnSpec.scala
index 0d7cbd0e8..a437fad61 100644
--- a/main/src/test/scala/sbt/internal/InstallSbtnSpec.scala
+++ b/main/src/test/scala/sbt/internal/InstallSbtnSpec.scala
@@ -17,23 +17,20 @@ import java.util.concurrent.TimeUnit
 import org.scalatest.flatspec.AnyFlatSpec
 import sbt.io.IO
 
-class InstallSbtnSpec extends AnyFlatSpec {
-  private def withTemp[R](ext: String)(f: Path => R): R = {
+class InstallSbtnSpec extends AnyFlatSpec:
+  private def withTemp[R](ext: String)(f: Path => R): R =
     val tmp = Files.createTempFile("sbt-1.4.1-", ext)
     try f(tmp)
-    finally {
+    finally
       Files.deleteIfExists(tmp)
       ()
-    }
-  }
-  private val term = new Terminal {
+  private val term = new Terminal:
     def getHeight: Int = 0
     def getWidth: Int = 0
     def inputStream: InputStream = () => -1
     def printStream: PrintStream = new PrintStream((_ => {}): OutputStream)
     def setMode(canonical: Boolean, echo: Boolean): Unit = {}
 
-  }
   // This test has issues in ci but runs ok locally on all platforms
   "InstallSbtn" should "extract native sbtn" ignore
     withTemp(".zip") { tmp =>
@@ -49,7 +46,7 @@ class InstallSbtnSpec extends AnyFlatSpec {
           tmpDir.resolve("project").resolve("build.properties").toFile,
           "sbt.version=1.9.0"
         )
-        try {
+        try
           val proc =
             new ProcessBuilder(sbtn.toString, "foo;shutdown")
               .redirectInput(Redirect.INHERIT)
@@ -60,9 +57,7 @@ class InstallSbtnSpec extends AnyFlatSpec {
           proc.waitFor(1, TimeUnit.MINUTES)
           assert(proc.exitValue == 0)
           assert(IO.read(foo.toFile) == "foo")
-        } finally {
-          sbt.io.IO.delete(tmpDir.toFile)
-        }
+        finally sbt.io.IO.delete(tmpDir.toFile)
       }
     }
-}
+end InstallSbtnSpec
diff --git a/main/src/test/scala/sbt/internal/OutputSpec.scala b/main/src/test/scala/sbt/internal/OutputSpec.scala
index 3d9597fc0..fa0b38b72 100644
--- a/main/src/test/scala/sbt/internal/OutputSpec.scala
+++ b/main/src/test/scala/sbt/internal/OutputSpec.scala
@@ -12,7 +12,7 @@ import scala.Console.{ RED, RESET }
 import verify.BasicTestSuite
 import sbt.internal.Output.grep
 
-object OutputSpec extends BasicTestSuite {
+object OutputSpec extends BasicTestSuite:
 
   test(
     "grep should match pattern against visible text when lines contain ANSI escape sequences (#4840)"
@@ -32,4 +32,3 @@ object OutputSpec extends BasicTestSuite {
     val result = grep(lines, "error")
     assert(result.isEmpty, s"expected no match, got: $result")
   }
-}
diff --git a/main/src/test/scala/sbt/internal/ScriptTest.scala b/main/src/test/scala/sbt/internal/ScriptTest.scala
index c6dcc972e..f079eaac1 100644
--- a/main/src/test/scala/sbt/internal/ScriptTest.scala
+++ b/main/src/test/scala/sbt/internal/ScriptTest.scala
@@ -12,7 +12,7 @@ import java.io.File
 import verify.BasicTestSuite
 import sbt.io.IO
 
-object ScriptTest extends BasicTestSuite {
+object ScriptTest extends BasicTestSuite:
 
   test("stripShebang returns same lines when first line does not start with #!") {
     val lines = Seq("println(1)", "val x = 2")
@@ -45,18 +45,18 @@ object ScriptTest extends BasicTestSuite {
 
   test("scriptBodyLines returns all lines when file has no blocks") {
     val f = File.createTempFile("script", ".scala")
-    try {
+    try
       IO.write(f, "println(1)\nval x = 2\n")
       val result = Script.scriptBodyLines(f)
       assert(result.contains("println(1)"))
       assert(result.contains("val x = 2"))
       assert(!result.exists(_.startsWith("/***")))
-    } finally f.delete()
+    finally f.delete()
   }
 
   test("scriptBodyLines excludes lines inside /*** */ block") {
     val f = File.createTempFile("script", ".scala")
-    try {
+    try
       IO.write(
         f,
         """println("before")
@@ -74,12 +74,12 @@ object ScriptTest extends BasicTestSuite {
         !result.contains("*/"),
         "closing */ must not appear in script body (would break wrapped Main.scala)"
       )
-    } finally f.delete()
+    finally f.delete()
   }
 
   test("scriptBodyLines excludes block content when file has only a block") {
     val f = File.createTempFile("script", ".scala")
-    try {
+    try
       IO.write(
         f,
         """/***
@@ -92,12 +92,12 @@ object ScriptTest extends BasicTestSuite {
         !result.contains("scalaVersion := \"3.0.0\""),
         s"block content must be excluded, got $result"
       )
-    } finally f.delete()
+    finally f.delete()
   }
 
   test("blocks parses block containing settings") {
     val f = File.createTempFile("script", ".scala")
-    try {
+    try
       IO.write(
         f,
         """line0
@@ -110,6 +110,6 @@ object ScriptTest extends BasicTestSuite {
       val result = Script.blocks(f)
       val settingBlock = result.find(_.lines.contains("scalaVersion := \"3.0.0\""))
       assert(settingBlock.isDefined, s"expected a block with scalaVersion, got $result")
-    } finally f.delete()
+    finally f.delete()
   }
-}
+end ScriptTest
diff --git a/main/src/test/scala/sbt/internal/StressGCMonitor.scala b/main/src/test/scala/sbt/internal/StressGCMonitor.scala
index 6599fb19b..9df234e50 100644
--- a/main/src/test/scala/sbt/internal/StressGCMonitor.scala
+++ b/main/src/test/scala/sbt/internal/StressGCMonitor.scala
@@ -13,19 +13,16 @@ import sbt.internal.util.ConsoleLogger
 import scala.concurrent.duration.*
 import scala.util.Random
 
-object StressGCMonitor {
+object StressGCMonitor:
   var list = List.empty[Int]
 
-  def main(args: Array[String]): Unit = {
+  def main(args: Array[String]): Unit =
     new GCMonitor(ConsoleLogger())
     val deadline = Deadline.now + 10.seconds
-    while (!deadline.isOverdue()) {
+    while !deadline.isOverdue() do
       println(s"${deadline.timeLeft.toSeconds} seconds left...")
       list = List.fill(1000 * 1000 * 100)(Random.nextInt(100))
       System.gc()
       Thread.sleep(10)
-    }
-  }
 
   def print(): Unit = println(s"random number: ${list.sum}")
-}
diff --git a/main/src/test/scala/sbt/internal/TaskProgressSpec.scala b/main/src/test/scala/sbt/internal/TaskProgressSpec.scala
index fb9850052..fc295cce9 100644
--- a/main/src/test/scala/sbt/internal/TaskProgressSpec.scala
+++ b/main/src/test/scala/sbt/internal/TaskProgressSpec.scala
@@ -11,7 +11,7 @@ package sbt.internal
 import sbt.internal.util.ProgressItem
 import verify.BasicTestSuite
 
-object TaskProgressSpec extends BasicTestSuite {
+object TaskProgressSpec extends BasicTestSuite:
 
   // Reproduces the sorting logic from TaskProgress.report() so we can test it in isolation.
   // The real code sorts Vector[(TaskId[?], Long)] then maps to ProgressItem, but the
@@ -87,4 +87,4 @@ object TaskProgressSpec extends BasicTestSuite {
     val items = Vector(ProgressItem("compile", 5_000_000L))
     assert(sortItems(items) == items)
   }
-}
+end TaskProgressSpec
diff --git a/main/src/test/scala/sbt/internal/TestBuild.scala b/main/src/test/scala/sbt/internal/TestBuild.scala
index 549ce4e33..f3b462402 100644
--- a/main/src/test/scala/sbt/internal/TestBuild.scala
+++ b/main/src/test/scala/sbt/internal/TestBuild.scala
@@ -22,7 +22,7 @@ import hedgehog.*
 import hedgehog.predef.sequence
 
 object TestBuild extends TestBuild
-abstract class TestBuild {
+abstract class TestBuild:
   val MaxTasks = 6
   val MaxProjects = 7
   val MaxConfigs = 5
@@ -44,18 +44,17 @@ abstract class TestBuild {
   def alphaNumChar: Gen[Char] =
     Gen.frequency1(8 -> alphaLowerChar, 1 -> alphaUpperChar, 1 -> numChar)
 
-  val nonEmptyId = for {
+  val nonEmptyId = for
     c <- alphaLowerChar
     cs <- Gen.list(alphaNumChar, MaxIDSizeGen)
-  } yield (c :: cs).mkString
+  yield (c :: cs).mkString
 
   def cGen = genConfigs(using nonEmptyId map { _.capitalize }, MaxDepsGen, MaxConfigsGen)
   def tGen = genTasks(using kebabIdGen, MaxDepsGen, MaxTasksGen)
 
-  class TestKeys(val env: Env, val scopes: Seq[Scope]) {
+  class TestKeys(val env: Env, val scopes: Seq[Scope]):
     override def toString = env.toString + "\n" + scopes.mkString("Scopes:\n\t", "\n\t", "")
     lazy val delegated = scopes map env.delegates
-  }
 
   sealed case class Structure(
       env: Env,
@@ -63,18 +62,17 @@ abstract class TestBuild {
       data: Def.Settings,
       keyIndex: KeyIndex,
       keyMap: Map[String, AttributeKey[?]]
-  ) {
+  ):
     override def toString =
       env.toString + "\n" + "current: " + current + "\nSettings:\n\t" + showData + keyMap.keys
         .mkString("All keys:\n\t", ", ", "")
     def showKeys(keys: Iterable[AttributeKey[?]]): String = keys.mkString("\n\t   ", ",", "\n")
-    def showData: String = {
+    def showData: String =
       val scopeStrings =
         for (scope, keys) <- data.keys.groupMap(_.scope)(_.key)
         yield (Scope.display(scope, "<key>"), showKeys(keys))
       scopeStrings.toSeq.sorted.map(t => t._1 + t._2).mkString("\n\t")
-    }
-    val extra: BuildUtil[Proj] = {
+    val extra: BuildUtil[Proj] =
       val getp = (build: URI, project: String) => env.buildMap(build).projectMap(project)
       new BuildUtil(
         keyIndex,
@@ -85,15 +83,11 @@ abstract class TestBuild {
         _.configurations.map(c => ConfigKey(c.name)),
         Relation.empty
       )
-    }
 
-    lazy val allAttributeKeys: Set[AttributeKey[?]] = {
-      if (data.attributeKeys.isEmpty) {
-        sys.error("allAttributeKeys is empty")
-      }
+    lazy val allAttributeKeys: Set[AttributeKey[?]] =
+      if data.attributeKeys.isEmpty then sys.error("allAttributeKeys is empty")
       data.attributeKeys
-    }
-    lazy val (taskAxes, zeroTaskAxis, onlyTaskAxis, multiTaskAxis) = {
+    lazy val (taskAxes, zeroTaskAxis, onlyTaskAxis, multiTaskAxis) =
       import collection.mutable
       import mutable.HashSet
 
@@ -108,42 +102,38 @@ abstract class TestBuild {
       val zero = new HashSet[ScopedKey[?]]
       val single = new HashSet[ScopedKey[?]]
       val multi = new HashSet[ScopedKey[?]]
-      for ((skey, tasks) <- taskAxes.forwardMap) {
+      for (skey, tasks) <- taskAxes.forwardMap do
         def makeKey(task: ScopeAxis[AttributeKey[?]]) =
           ScopedKey(skey.scope.copy(task = task), skey.key)
         val hasGlobal = tasks(Zero)
-        if (hasGlobal) zero += skey
-        else {
+        if hasGlobal then zero += skey
+        else
           val keys = tasks map makeKey
-          keys.size match {
+          keys.size match
             case 0 =>
             case 1 => single ++= keys
             case _ => multi ++= keys
-          }
-        }
-      }
       (taskAxes, zero.toSet, single.toSet, multi.toSet)
-    }
-  }
-  case class Env(builds: Vector[Build], tasks: Vector[Taskk]) {
+    end val
+  end Structure
+  case class Env(builds: Vector[Build], tasks: Vector[Taskk]):
     override def toString =
       "Env:\n  " + "  Tasks:\n    " + tasks.mkString("\n    ") + "\n" + builds.mkString("\n  ")
     val root = builds.head
     val buildMap = mapBy(builds)(_.uri)
     val taskMap = mapBy(tasks)(getKey)
     def project(ref: ProjectRef) = buildMap(ref.build).projectMap(ref.project)
-    def projectFor(ref: ResolvedReference) = ref match {
-      case pr: ProjectRef => project(pr); case BuildRef(uri) => buildMap(uri).root
-    }
+    def projectFor(ref: ResolvedReference) = ref match
+      case pr: ProjectRef => project(pr);
+      case BuildRef(uri)  => buildMap(uri).root
 
     lazy val allProjects = builds.flatMap(_.allProjects)
     def rootProject(uri: URI): String = buildMap(uri).root.id
     def inheritConfig(ref: ResolvedReference, config: ConfigKey) =
       projectFor(ref).confMap(config.name).extendsConfigs map toConfigKey
-    def inheritTask(task: AttributeKey[?]) = taskMap.get(task) match {
+    def inheritTask(task: AttributeKey[?]) = taskMap.get(task) match
       case None    => Vector()
       case Some(t) => t.delegates.toVector map getKey
-    }
     def inheritProject(ref: ProjectRef) = project(ref).delegates.toVector
     def resolve(ref: Reference) = Scope.resolveReference(root.uri, rootProject, ref)
     lazy val delegates: Scope => Seq[Scope] =
@@ -157,49 +147,46 @@ abstract class TestBuild {
         inheritTask,
       )
     lazy val allFullScopes: Seq[Scope] =
-      for {
+      for
         (ref, p) <- (Zero, root.root) +: allProjects.map { (ref, p) => (Select(ref), p) }
         t <- Zero +: tasks.map(t => Select(t.key))
         c <- Zero +: p.configurations.map(c => Select(ConfigKey(c.name)))
-      } yield Scope(project = ref, config = c, task = t, extra = Zero)
-  }
+      yield Scope(project = ref, config = c, task = t, extra = Zero)
+  end Env
   def getKey: Taskk => AttributeKey[?] = _.key
   def toConfigKey: Configuration => ConfigKey = c => ConfigKey(c.name)
-  case class Build(uri: URI, projects: Seq[Proj]) {
+  case class Build(uri: URI, projects: Seq[Proj]):
     override def toString = "Build " + uri.toString + " :\n    " + projects.mkString("\n    ")
     val allProjects = projects map { p =>
       (ProjectRef(uri, p.id), p)
     }
     val root = projects.head
     val projectMap = mapBy(projects)(_.id)
-  }
   case class Proj(
       id: String,
       delegates: Seq[ProjectRef],
       configurations: Seq[Configuration]
-  ) {
+  ):
     override def toString =
       "Project " + id + "\n      Delegates:\n        " + delegates.mkString("\n        ") +
         "\n      Configurations:\n        " + configurations.mkString("\n        ")
     val confMap = mapBy(configurations)(_.name)
-  }
 
-  case class Taskk(key: AttributeKey[String], delegates: Seq[Taskk]) {
+  case class Taskk(key: AttributeKey[String], delegates: Seq[Taskk]):
     override def toString =
       key.label + " (delegates: " + delegates.map(_.key.label).mkString(", ") + ")"
-  }
 
   def mapBy[K, T](s: Seq[T])(f: T => K): Map[K, T] =
     s.map(t => (f(t), t)).toMap
 
   lazy val keysGen: Gen[TestKeys] =
-    for {
+    for
       env <- mkEnv
       keys <- scope(env).list(Range.linear(1, KeysPerEnv))
-    } yield new TestKeys(env, keys)
+    yield new TestKeys(env, keys)
 
   def scope(env: Env): Gen[Scope] =
-    for {
+    for
       build <- oneOf(env.builds)
       project <- oneOf(build.projects)
       cAxis <- oneOrGlobal(project.configurations map toConfigKey)
@@ -210,13 +197,13 @@ abstract class TestBuild {
           (3, Gen.constant[Reference](ProjectRef(build.uri, project.id)))
         )
       )
-    } yield Scope(pAxis, cAxis, tAxis, Zero)
+    yield Scope(pAxis, cAxis, tAxis, Zero)
 
   def orGlobal[T](gen: Gen[T]): Gen[ScopeAxis[T]] =
     Gen.frequency1((1, gen map Select.apply), (1, Gen.constant(Zero)))
   def oneOrGlobal[T](gen: Seq[T]): Gen[ScopeAxis[T]] = orGlobal(oneOf(gen))
 
-  def makeParser(structure: Structure): Parser[ScopedKey[?]] = {
+  def makeParser(structure: Structure): Parser[ScopedKey[?]] =
     import structure.*
     def confs(uri: URI) =
       env.buildMap.get(uri).toList.flatMap { _.root.configurations.map(_.name) }
@@ -226,70 +213,62 @@ abstract class TestBuild {
       case Some(ref: ProjectRef) => env.project(ref).configurations.map(_.name)
     }
     Act.scopedKey(keyIndex, current, defaultConfs, keyMap, data)
-  }
 
-  def structure(env: Env, settings: Seq[Setting[?]], current: ProjectRef): Structure = {
+  def structure(env: Env, settings: Seq[Setting[?]], current: ProjectRef): Structure =
     val display = Def.showRelativeKey2(current)
-    if (settings.isEmpty) {
-      try {
-        sys.error("settings is empty")
-      } catch {
+    if settings.isEmpty then
+      try sys.error("settings is empty")
+      catch
         case e: Throwable =>
           e.printStackTrace
           throw e
-      }
-    }
     val data = Def.makeWithCompiledMap(settings)(using env.delegates, const(Nil), display)._2
     val keyMap = data.keys.map(k => (k.key.label, k.key)).toMap[String, AttributeKey[?]]
     val projectsMap = env.builds.map(b => (b.uri, b.projects.map(_.id).toSet)).toMap
-    val confs = for {
+    val confs = for
       b <- env.builds
       p <- b.projects
-    } yield p.id -> p.configurations
+    yield p.id -> p.configurations
     val confMap = confs.toMap
     Structure(env, current, data, KeyIndex(data.keys, projectsMap, confMap), keyMap)
-  }
 
-  lazy val mkEnv: Gen[Env] = {
+  lazy val mkEnv: Gen[Env] =
     val pGen = (uri: URI) => genProjects(uri)(nonEmptyId, MaxDepsGen, MaxProjectsGen, cGen)
     envGen(buildGen(uriGen, pGen), tGen)
-  }
 
-  def maskGen: Gen[ScopeMask] = {
+  def maskGen: Gen[ScopeMask] =
     val b = Gen.boolean
-    for (p <- b; c <- b; t <- b; x <- b)
-      yield ScopeMask(project = p, config = c, task = t, extra = x)
-  }
+    for p <- b; c <- b; t <- b; x <- b
+    yield ScopeMask(project = p, config = c, task = t, extra = x)
 
-  val kebabIdGen: Gen[String] = for {
+  val kebabIdGen: Gen[String] = for
     c <- alphaLowerChar
     cs <- Gen.list(
       Gen.frequency(MaxIDSize -> alphaNumChar, List(1 -> Gen.constant('-'))),
       Range.linear(0, MaxIDSize - 2)
     )
     end <- alphaNumChar
-  } yield (List(c) ++ cs ++ List(end)).mkString
+  yield (List(c) ++ cs ++ List(end)).mkString
 
   val optIDGen: Gen[Option[String]] =
     Gen.choice1(nonEmptyId.map(some[String]), Gen.constant(None))
 
-  val pathGen = for {
+  val pathGen = for
     c <- alphaLowerChar
     cs <- Gen.list(alphaNumChar, Range.linear(6, MaxIDSize))
-  } yield (c :: cs).mkString
+  yield (c :: cs).mkString
 
-  val uriGen: Gen[URI] = {
-    for {
+  val uriGen: Gen[URI] =
+    for
       ssp <- pathGen
       frag <- optIDGen
-    } yield new URI("file", "///" + ssp + "/", frag.orNull)
-  }
+    yield new URI("file", "///" + ssp + "/", frag.orNull)
 
   def envGen(bGen: Gen[Build], tasks: Gen[Vector[Taskk]]): Gen[Env] =
-    for (bs <- bGen.list(MaxBuildsGen).map(_.toVector); ts <- tasks)
-      yield new Env(bs, ts)
+    for bs <- bGen.list(MaxBuildsGen).map(_.toVector); ts <- tasks
+    yield new Env(bs, ts)
   def buildGen(uGen: Gen[URI], pGen: URI => Gen[Vector[Proj]]): Gen[Build] =
-    for (u <- uGen; ps <- pGen(u)) yield new Build(u, ps)
+    for u <- uGen; ps <- pGen(u) yield new Build(u, ps)
 
   def nGen[T](igen: Gen[Int])(g: Gen[T]): Gen[Vector[T]] = igen flatMap { ig =>
     g.list(Range.linear(ig, ig)).map(_.toVector)
@@ -302,7 +281,8 @@ abstract class TestBuild {
       confs: Gen[Vector[Configuration]]
   ): Gen[Vector[Proj]] =
     genAcyclic(maxDeps, genID, count) { (id: String) =>
-      for (cs <- confs) yield { (deps: Seq[Proj]) =>
+      for cs <- confs
+      yield (deps: Seq[Proj]) =>
         new Proj(
           id,
           deps.map { dep =>
@@ -310,7 +290,6 @@ abstract class TestBuild {
           },
           cs
         )
-      }
     }
 
   def genConfigs(using
@@ -344,19 +323,17 @@ abstract class TestBuild {
 
   def genAcyclic[A, T](maxDeps: Range[Int], keyGen: Gen[T], max: Range[Int])(
       make: T => Gen[Vector[A] => A]
-  ): Gen[Vector[A]] = {
+  ): Gen[Vector[A]] =
     keyGen.list(max) flatMap { keys =>
       genAcyclic(maxDeps, keys.distinct.toVector)(make)
     }
-  }
   def genAcyclic[A, T](maxDeps: Range[Int], keys: Vector[T])(
       make: T => Gen[Vector[A] => A]
   ): Gen[Vector[A]] =
     genAcyclic(maxDeps, keys, Vector()) flatMap { pairs =>
       sequence(pairs.map { (key, deps) => mapMake(key, deps, make) }.toList) map { inputs =>
         val made = new collection.mutable.HashMap[T, A]
-        for ((key, deps, mk) <- inputs)
-          made(key) = mk(deps map made)
+        for (key, deps, mk) <- inputs do made(key) = mk(deps map made)
         keys map made
       }
     }
@@ -371,14 +348,13 @@ abstract class TestBuild {
       names: Vector[T],
       acc: Vector[Gen[(T, Vector[T])]]
   ): Gen[Vector[(T, Vector[T])]] =
-    names match {
+    names match
       case Vector()       => sequence(acc.toList).map(_.toVector)
       case Vector(x, xs*) =>
         val next =
-          for (depCount <- Gen.int(maxDeps); d <- pick(depCount, xs))
-            yield (x, d.toVector)
+          for depCount <- Gen.int(maxDeps); d <- pick(depCount, xs)
+          yield (x, d.toVector)
         genAcyclic(maxDeps, xs.toVector, next +: acc)
-    }
 
   type Inputs[A, T] = (T, Vector[T], Vector[A] => A)
 
@@ -386,17 +362,12 @@ abstract class TestBuild {
     Gen.element(a.head, a.tail.toList)
 
   // TODO Should move to hedgehog possible?
-  def pick[A](n: Int, as: Seq[A]): Gen[Seq[A]] = {
-    if (n >= as.length) {
-      Gen.constant(as)
-    } else {
+  def pick[A](n: Int, as: Seq[A]): Gen[Seq[A]] =
+    if n >= as.length then Gen.constant(as)
+    else
       def go(m: Int, bs: Set[Int], cs: Set[Int]): Gen[Set[Int]] =
-        if (m == 0)
-          Gen.constant(cs)
-        else
-          Gen.element(bs.head, bs.tail.toList).flatMap(a => go(m - 1, bs - a, cs + a))
+        if m == 0 then Gen.constant(cs)
+        else Gen.element(bs.head, bs.tail.toList).flatMap(a => go(m - 1, bs - a, cs + a))
       go(n, as.indices.toSet, Set())
-        .map(is => as.zipWithIndex.flatMap(a => if (is(a._2)) Seq(a._1) else Seq()))
-    }
-  }
-}
+        .map(is => as.zipWithIndex.flatMap(a => if is(a._2) then Seq(a._1) else Seq()))
+end TestBuild
diff --git a/main/src/test/scala/sbt/internal/graph/backend/SbtUpdateReportTest.scala b/main/src/test/scala/sbt/internal/graph/backend/SbtUpdateReportTest.scala
index 7b32c176a..6558ecf74 100644
--- a/main/src/test/scala/sbt/internal/graph/backend/SbtUpdateReportTest.scala
+++ b/main/src/test/scala/sbt/internal/graph/backend/SbtUpdateReportTest.scala
@@ -13,7 +13,7 @@ import org.scalatest.matchers.should.Matchers
 import sbt.internal.graph.GraphModuleId
 import sbt.librarymanagement.*
 
-class SbtUpdateReportTest extends AnyFlatSpec with Matchers {
+class SbtUpdateReportTest extends AnyFlatSpec with Matchers:
 
   def caller(org: String, name: String, version: String): Caller =
     Caller(
@@ -119,4 +119,4 @@ class SbtUpdateReportTest extends AnyFlatSpec with Matchers {
     graph.edges should contain((rootId, depAId))
     graph.edges should contain((rootId, relocatedBId))
   }
-}
+end SbtUpdateReportTest
diff --git a/main/src/test/scala/sbt/internal/graph/rendering/TreeViewTest.scala b/main/src/test/scala/sbt/internal/graph/rendering/TreeViewTest.scala
index c757d4265..2b91decda 100644
--- a/main/src/test/scala/sbt/internal/graph/rendering/TreeViewTest.scala
+++ b/main/src/test/scala/sbt/internal/graph/rendering/TreeViewTest.scala
@@ -13,7 +13,7 @@ import org.scalatest.matchers.should.Matchers
 import sbt.internal.graph.rendering.TreeView.createJson
 import sbt.internal.graph.{ Edge, GraphModuleId, Module, ModuleGraph, ModuleModel }
 
-class TreeViewTest extends AnyFlatSpec with Matchers {
+class TreeViewTest extends AnyFlatSpec with Matchers:
   val modA = GraphModuleId("orgA", "nameA", "1.0")
   val modB = GraphModuleId("orgB", "nameB", "2.0")
   val modC = GraphModuleId("orgC", "nameC", "3.0")
@@ -167,4 +167,4 @@ class TreeViewTest extends AnyFlatSpec with Matchers {
     )
     assert(tree == expected, s"got: $tree")
   }
-}
+end TreeViewTest
diff --git a/main/src/test/scala/sbt/internal/server/CoalescingFlusherSpec.scala b/main/src/test/scala/sbt/internal/server/CoalescingFlusherSpec.scala
index 23463da23..ef91d2dd0 100644
--- a/main/src/test/scala/sbt/internal/server/CoalescingFlusherSpec.scala
+++ b/main/src/test/scala/sbt/internal/server/CoalescingFlusherSpec.scala
@@ -15,20 +15,25 @@ import verify.BasicTestSuite
 object CoalescingFlusherSpec extends BasicTestSuite:
 
   private def newFlusher(count: AtomicInteger, delayMillis: Long = 20L): CoalescingFlusher =
-    new CoalescingFlusher("test-flusher", delayMillis, () => { count.incrementAndGet(); () })
+    new CoalescingFlusher(
+      "test-flusher",
+      delayMillis,
+      () =>
+        count.incrementAndGet(); ()
+    )
 
   private def awaitAtLeast(count: AtomicInteger, n: Int): Unit =
     val deadline = System.nanoTime + TimeUnit.SECONDS.toNanos(5)
-    while (count.get < n && System.nanoTime < deadline) Thread.sleep(2)
+    while count.get < n && System.nanoTime < deadline do Thread.sleep(2)
 
   test("repeated flush calls within the window coalesce into a single drain") {
     val drains = new AtomicInteger(0)
     val flusher = newFlusher(drains)
-    try {
+    try
       (1 to 50).foreach(_ => flusher.flush())
       awaitAtLeast(drains, 1)
       assert(drains.get == 1, s"expected 1 coalesced drain, got ${drains.get}")
-    } finally flusher.close()
+    finally flusher.close()
   }
 
   // The regression this fixes: forceFlush used to shut the timer executor down, so all later
@@ -37,7 +42,7 @@ object CoalescingFlusherSpec extends BasicTestSuite:
   test("forceFlush drains immediately and does not disable coalescing") {
     val drains = new AtomicInteger(0)
     val flusher = newFlusher(drains)
-    try {
+    try
       flusher.forceFlush() // 1 immediate drain
       assert(drains.get == 1)
       (1 to 50).foreach(_ => flusher.flush()) // must still coalesce into 1 scheduled drain
@@ -45,7 +50,7 @@ object CoalescingFlusherSpec extends BasicTestSuite:
       // exactly 2: if forceFlush had torn down the executor, each flush would fall back to an
       // inline drain instead of coalescing, giving 51.
       assert(drains.get == 2, s"expected 2 drains, got ${drains.get}")
-    } finally flusher.close()
+    finally flusher.close()
   }
 
   test("flush after close drains inline") {
diff --git a/main/src/test/scala/testpkg/CompletionSpec.scala b/main/src/test/scala/testpkg/CompletionSpec.scala
index e0d32a029..43e081d83 100644
--- a/main/src/test/scala/testpkg/CompletionSpec.scala
+++ b/main/src/test/scala/testpkg/CompletionSpec.scala
@@ -20,7 +20,7 @@ import hedgehog.*
 import hedgehog.runner.*
 import _root_.sbt.internal.util.complete.Parser
 
-object CompletionSpec extends Properties {
+object CompletionSpec extends Properties:
   override def tests: List[Test] =
     List(
       property(
@@ -54,7 +54,7 @@ object CompletionSpec extends Properties {
       attributeName: String = "a",
       line: String,
       expected: String,
-  ): Result = {
+  ): Result =
     val attributeKey = AttributeKey[String](attributeName)
     val scope = Scope(
       Select(BuildRef(buildURI)),
@@ -86,5 +86,5 @@ object CompletionSpec extends Properties {
       .log(s"line: $line")
       .log(s"completions: ${cs.get.map(_.append)}")
       .log(s"structure: $structure")
-  }
-}
+  end complete
+end CompletionSpec
diff --git a/project/DatatypeConfig.scala b/project/DatatypeConfig.scala
index f643166b2..285bd053f 100644
--- a/project/DatatypeConfig.scala
+++ b/project/DatatypeConfig.scala
@@ -1,85 +1,60 @@
 import sbt.contraband.ast.*
 import sbt.contraband.CodecCodeGen
 
-object DatatypeConfig {
+object DatatypeConfig:
 
   /** Extract the only type parameter from a TpeRef */
-  def oneArg(tpe: Type): Type = {
+  def oneArg(tpe: Type): Type =
     val pat = s"""${tpe.removeTypeParameters.name}[<\\[](.+?)[>\\]]""".r
     val pat(arg0) = tpe.name.runtimeChecked
     NamedType(arg0.split('.').toList)
-  }
 
   /** Extract the two type parameters from a TpeRef */
-  def twoArgs(tpe: Type): List[Type] = {
+  def twoArgs(tpe: Type): List[Type] =
     val pat = s"""${tpe.removeTypeParameters.name}[<\\[](.+?), (.+?)[>\\]]""".r
     val pat(arg0, arg1) = tpe.name.runtimeChecked
     NamedType(arg0.split('.').toList) :: NamedType(arg1.split('.').toList) :: Nil
-  }
 
   /** Codecs that were manually written. */
   val myCodecs: PartialFunction[String, Type => List[String]] = {
-    case "scala.xml.NodeSeq" => { _ =>
-      "sbt.internal.librarymanagement.formats.NodeSeqFormat" :: Nil
-    }
+    case "scala.xml.NodeSeq" => _ => "sbt.internal.librarymanagement.formats.NodeSeqFormat" :: Nil
 
-    case "xsbti.GlobalLock" => { _ =>
-      "sbt.internal.librarymanagement.formats.GlobalLockFormat" :: Nil
-    }
-    case "xsbti.Logger" => { _ =>
-      "sbt.internal.librarymanagement.formats.LoggerFormat" :: Nil
-    }
+    case "xsbti.GlobalLock" => _ => "sbt.internal.librarymanagement.formats.GlobalLockFormat" :: Nil
+    case "xsbti.Logger"     => _ => "sbt.internal.librarymanagement.formats.LoggerFormat" :: Nil
 
-    case "sbt.librarymanagement.IvyPaths" => { _ =>
-      "sbt.librarymanagement.IvyPathsFormats" :: Nil
-    }
+    case "sbt.librarymanagement.IvyPaths" => _ => "sbt.librarymanagement.IvyPathsFormats" :: Nil
 
-    case "sbt.librarymanagement.LogicalClock" => { _ =>
-      "sbt.internal.librarymanagement.formats.LogicalClockFormats" :: Nil
-    }
+    case "sbt.librarymanagement.LogicalClock" =>
+      _ => "sbt.internal.librarymanagement.formats.LogicalClockFormats" :: Nil
 
-    case "sbt.librarymanagement.CrossVersion" => { _ =>
-      "sbt.librarymanagement.CrossVersionFormats" ::
-        "sbt.librarymanagement.DisabledFormats" ::
-        "sbt.librarymanagement.BinaryFormats" ::
-        "sbt.librarymanagement.ConstantFormats" ::
-        "sbt.librarymanagement.PatchFormats" ::
-        "sbt.librarymanagement.FullFormats" ::
-        "sbt.librarymanagement.For3Use2_13Formats" ::
-        "sbt.librarymanagement.For2_13Use3Formats" ::
-        Nil
-    }
+    case "sbt.librarymanagement.CrossVersion" =>
+      _ =>
+        "sbt.librarymanagement.CrossVersionFormats" ::
+          "sbt.librarymanagement.DisabledFormats" ::
+          "sbt.librarymanagement.BinaryFormats" ::
+          "sbt.librarymanagement.ConstantFormats" ::
+          "sbt.librarymanagement.PatchFormats" ::
+          "sbt.librarymanagement.FullFormats" ::
+          "sbt.librarymanagement.For3Use2_13Formats" ::
+          "sbt.librarymanagement.For2_13Use3Formats" ::
+          Nil
 
-    case "sbt.librarymanagement.ConfigRef" => { _ =>
-      "sbt.librarymanagement.ConfigRefFormats" :: Nil
-    }
+    case "sbt.librarymanagement.ConfigRef" => _ => "sbt.librarymanagement.ConfigRefFormats" :: Nil
 
-    case "sbt.testing.Status" => { _ =>
-      "sbt.internal.testing.StatusFormats" :: Nil
-    }
+    case "sbt.testing.Status" => _ => "sbt.internal.testing.StatusFormats" :: Nil
 
-    case "scalajson.ast.unsafe.JValue" | "sjsonnew.shaded.scalajson.ast.unsafe.JValue" => { _ =>
-      "sbt.internal.util.codec.JValueFormats" :: Nil
-    }
+    case "scalajson.ast.unsafe.JValue" | "sjsonnew.shaded.scalajson.ast.unsafe.JValue" =>
+      _ => "sbt.internal.util.codec.JValueFormats" :: Nil
 
-    case "xsbti.HashedVirtualFileRef" => { _ =>
-      "sbt.internal.util.codec.HashedVirtualFileRefFormats" :: Nil
-    }
+    case "xsbti.HashedVirtualFileRef" =>
+      _ => "sbt.internal.util.codec.HashedVirtualFileRefFormats" :: Nil
 
-    case "java.nio.ByteBuffer" => { _ =>
-      "sbt.internal.util.codec.ByteBufferFormats" :: Nil
-    }
+    case "java.nio.ByteBuffer" => _ => "sbt.internal.util.codec.ByteBufferFormats" :: Nil
 
     // TODO: These are handled by BasicJsonProtocol, and sbt-datatype should handle them by default, imo
-    case "Option" | "Set" | "scala.Vector" => { tpe =>
-      getFormats(oneArg(tpe))
-    }
-    case "Map" | "Tuple2" | "scala.Tuple2" => { tpe =>
-      twoArgs(tpe).flatMap(getFormats)
-    }
-    case "Int" | "Long" | "sbt.util.Digest" => { _ =>
-      Nil
-    }
+    case "Option" | "Set" | "scala.Vector"  => tpe => getFormats(oneArg(tpe))
+    case "Map" | "Tuple2" | "scala.Tuple2"  => tpe => twoArgs(tpe).flatMap(getFormats)
+    case "Int" | "Long" | "sbt.util.Digest" => _ => Nil
   }
 
   /** Types for which we don't include the format -- they're just aliases to InclExclRule */
@@ -97,5 +72,4 @@ object DatatypeConfig {
       case other =>
         CodecCodeGen.formatsForType(other)
     }
-
-}
+end DatatypeConfig
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index d21d252cd..ab5e0e538 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -1,7 +1,7 @@
 import sbt.*
 import Keys.*
 
-object Dependencies {
+object Dependencies:
   // WARNING: Please Scala update versions in PluginCross.scala too
   val scala3 = "3.9.0"
   val scala212 = "2.12.21"
@@ -27,13 +27,12 @@ object Dependencies {
   private val zinc = "org.scala-sbt" %% "zinc" % zincVersion
   private val zincCompileCore = "org.scala-sbt" %% "zinc-compile-core" % zincVersion
 
-  def getSbtModulePath(key: String) = {
+  def getSbtModulePath(key: String) =
     val localProps = new java.util.Properties()
     IO.load(localProps, file("project/local.properties"))
     val path = Option(localProps.getProperty(key)).orElse(sys.props.get(key))
     path.foreach(f => println(s"Using $key=$f"))
     path
-  }
 
   lazy val sbtIoPath = getSbtModulePath("sbtio.path")
   lazy val sbtZincPath = getSbtModulePath("sbtzinc.path")
@@ -43,15 +42,13 @@ object Dependencies {
       projectName: String,
       moduleId: ModuleID,
       c: Option[Configuration] = None
-  ) = (p: Project) => {
+  ) = (p: Project) =>
     val m0 = moduleId.withConfigurations(c.map(_.name))
     val m = m0
-    path match {
+    path match
       case Some(f) =>
         p.dependsOn(ClasspathDependency(ProjectRef(file(f), projectName), c.map(_.name)))
       case None => p.settings(libraryDependencies += m, dependencyOverrides += m)
-    }
-  }
 
   def addSbtIO = addSbtModule(sbtIoPath, "io", sbtIO)
   def addSbtIOForTest = addSbtModule(sbtIoPath, "io", sbtIO, Some(Test))
@@ -135,4 +132,4 @@ object Dependencies {
   // FIXME Ideally, we should depend on the same version of io.get-coursier.jniutils:windows-jni-utils that
   // io.get-coursier::coursier depends on.
   val jniUtilsVersion = "0.3.3"
-}
+end Dependencies
diff --git a/project/Docs.scala b/project/Docs.scala
index f399df50a..a6a201a54 100644
--- a/project/Docs.scala
+++ b/project/Docs.scala
@@ -8,7 +8,7 @@ import com.typesafe.sbt.SbtGit, SbtGit.{ git, GitKeys }
 import Sxr.{ sxr, SxrConf }
  */
 
-object Docs {
+object Docs:
   def settings: Seq[Setting[?]] = Nil
 
   /*
@@ -53,4 +53,3 @@ object Docs {
     repo
   }
    */
-}
diff --git a/project/HouseRulesPlugin.scala b/project/HouseRulesPlugin.scala
index 63228435f..f1e6c49e8 100644
--- a/project/HouseRulesPlugin.scala
+++ b/project/HouseRulesPlugin.scala
@@ -2,7 +2,7 @@ import sbt.*
 import Keys.*
 import sbt.util.CacheImplicits.given
 
-object HouseRulesPlugin extends AutoPlugin {
+object HouseRulesPlugin extends AutoPlugin:
   override def requires = plugins.JvmPlugin
   override def trigger = allRequirements
 
@@ -16,12 +16,10 @@ object HouseRulesPlugin extends AutoPlugin {
     scalacOptions ++= "-Xfuture".ifScala213OrMinus.value.toList,
     scalacOptions ++= "-Xlint".ifScala2.value.toList,
     scalacOptions ++= {
-      if (
-        sys.props.get("sbt.build.fatal") match {
+      if sys.props.get("sbt.build.fatal") match
           case Some(_) => java.lang.Boolean.getBoolean("sbt.build.fatal")
           case _       => true
-        }
-      ) List("-Werror")
+      then List("-Werror")
       else Nil
     },
     scalacOptions ++= "-Yinline-warnings".ifScala211OrMinus.value.toList,
@@ -31,11 +29,10 @@ object HouseRulesPlugin extends AutoPlugin {
     scalacOptions ++= "-Ywarn-value-discard".ifScala2.value.toList,
     scalacOptions ++= "-Ywarn-unused-import".ifScala2x(v => 11 <= v && v <= 12).value.toList,
     scalacOptions ++= {
-      scalaPartV.value match {
+      scalaPartV.value match
         case Some((3, _)) => Seq("-Wunused:imports,implicits") // ,nowarn
         case Some((2, _)) => Seq("-Ywarn-unused:-privates,-locals,-explicits")
         case _            => Seq.empty
-      }
     },
     scalacOptions ++= "-Xsource:3".ifScala2.value.toList,
     testFrameworks += TestFramework("verify.runner.Framework"),
@@ -45,7 +42,7 @@ object HouseRulesPlugin extends AutoPlugin {
 
   private def scalaPartV = Def.setting(CrossVersion.partialVersion(scalaVersion.value))
 
-  private implicit final class AnyWithIfScala[A](val __x: A) {
+  private implicit final class AnyWithIfScala[A](val __x: A):
     def ifScala2x(p: Long => Boolean) =
       Def.setting(scalaPartV.value.collect { case (2, y) if p(y) => __x })
     def ifScala3x(p: Long => Boolean) =
@@ -58,8 +55,7 @@ object HouseRulesPlugin extends AutoPlugin {
     def ifScala213OrMinus = ifScalaLte(13)
     def ifScala2 = ifScala2x(_ => true)
     def ifScala3 = Def.setting(
-      if (scalaBinaryVersion.value == "3") Seq(__x)
+      if scalaBinaryVersion.value == "3" then Seq(__x)
       else Nil
     )
-  }
-}
+end HouseRulesPlugin
diff --git a/project/Mima.scala b/project/Mima.scala
index 85a8b455f..f45a28940 100644
--- a/project/Mima.scala
+++ b/project/Mima.scala
@@ -4,7 +4,7 @@ import sbt.*
 import sbt.Keys.*
 import sys.process.*
 
-object Mima {
+object Mima:
 
   private def stable(ver: String): Boolean =
     ver.exists(c => c != '0' && c != '.') &&
@@ -29,14 +29,11 @@ object Mima {
     // }
   )
 
-  lazy val lmCoursierFilters = {
+  lazy val lmCoursierFilters =
     mimaBinaryIssueFilters ++= Seq(
     )
-  }
 
-  lazy val lmCoursierShadedFilters = {
+  lazy val lmCoursierShadedFilters =
     mimaBinaryIssueFilters ++= Seq(
     )
-  }
-
-}
+end Mima
diff --git a/project/NightlyPlugin.scala b/project/NightlyPlugin.scala
index 664ff576a..bc3e8d1bb 100644
--- a/project/NightlyPlugin.scala
+++ b/project/NightlyPlugin.scala
@@ -2,15 +2,15 @@ import sbt.*
 import Keys.*
 import Dependencies.*
 
-object NightlyPlugin extends AutoPlugin {
+object NightlyPlugin extends AutoPlugin:
   override def trigger = allRequirements
   override def requires = plugins.JvmPlugin
 
-  object autoImport {
+  object autoImport:
     val includeTestDependencies = settingKey[Boolean]("Doesn't declare test dependencies.")
 
     def testDependencies = libraryDependencies ++= (
-      if (includeTestDependencies.value)
+      if includeTestDependencies.value then
         Seq(
           scalacheck % Test,
           junit % Test,
@@ -19,7 +19,6 @@ object NightlyPlugin extends AutoPlugin {
         ) ++ scalatest
       else Seq()
     )
-  }
   import autoImport.*
 
   override def buildSettings: Seq[Setting[?]] = Seq(
@@ -28,4 +27,4 @@ object NightlyPlugin extends AutoPlugin {
 
   override def projectSettings: Seq[Setting[?]] = Seq(
   )
-}
+end NightlyPlugin
diff --git a/project/PackageSignerPlugin.scala b/project/PackageSignerPlugin.scala
index d9ed3eb5d..40e5cdbb5 100644
--- a/project/PackageSignerPlugin.scala
+++ b/project/PackageSignerPlugin.scala
@@ -7,7 +7,7 @@ import com.typesafe.sbt.packager.debian.{ DebianPlugin, DebianDeployPlugin }
 import com.typesafe.sbt.packager.rpm.{ RpmPlugin, RpmDeployPlugin }
 import com.jsuereth.sbtpgp.gpgExtension
 
-object PackageSignerPlugin extends sbt.AutoPlugin {
+object PackageSignerPlugin extends sbt.AutoPlugin:
   override def trigger = allRequirements
   override def requires = SbtPgp && UniversalDeployPlugin && DebianDeployPlugin && RpmDeployPlugin
 
@@ -32,7 +32,7 @@ object PackageSignerPlugin extends sbt.AutoPlugin {
       val skipZ = (pgpSigner / skip).value
       val s = streams.value
       val converter = fileConverter.value
-      if (!skipZ) {
+      if !skipZ then
         artifacts flatMap { case (art, virtualFile) =>
           val f = converter.toPath(virtualFile).toFile
           Seq(
@@ -41,7 +41,7 @@ object PackageSignerPlugin extends sbt.AutoPlugin {
               converter.toVirtualFile(r.sign(f, file(f.getAbsolutePath + gpgExtension), s).toPath)
           )
         }
-      } else artifacts
+      else artifacts
     },
     publishSignedConfiguration := Classpaths.publishConfig(
       publishMavenStyle = publishMavenStyle.value,
@@ -49,7 +49,7 @@ object PackageSignerPlugin extends sbt.AutoPlugin {
         .toPath((Compile / packageBin / artifactPath).value)
         .toFile
         .getParent + "/[artifact]-[revision](-[classifier]).[ext]",
-      status = if (isSnapshot.value) "integration" else "release",
+      status = if isSnapshot.value then "integration" else "release",
       configurations = Vector.empty,
       artifacts = signedArtifacts.value.map { (k, v) =>
         k -> fileConverter.value.toPath(v).toFile
@@ -65,7 +65,7 @@ object PackageSignerPlugin extends sbt.AutoPlugin {
         .toPath((Compile / packageBin / artifactPath).value)
         .toFile
         .getParent + "/[artifact]-[revision](-[classifier]).[ext]",
-      status = if (isSnapshot.value) "integration" else "release",
+      status = if isSnapshot.value then "integration" else "release",
       configurations = Vector.empty,
       artifacts = signedArtifacts.value.map { (k, v) =>
         k -> fileConverter.value.toPath(v).toFile
@@ -98,5 +98,4 @@ object PackageSignerPlugin extends sbt.AutoPlugin {
       }
     }.value
   )
-
-}
+end PackageSignerPlugin
diff --git a/project/PublishBinPlugin.scala b/project/PublishBinPlugin.scala
index 3f767c019..b28d599fe 100644
--- a/project/PublishBinPlugin.scala
+++ b/project/PublishBinPlugin.scala
@@ -7,13 +7,12 @@ import sbt.util.CacheImplicits.given
 import sbt.librarymanagement.LibraryManagementCodec.given
 
 /** This local plugin provides ways of publishing just the binary jar. */
-object PublishBinPlugin extends AutoPlugin {
+object PublishBinPlugin extends AutoPlugin:
   override def trigger = allRequirements
 
-  object autoImport {
+  object autoImport:
     val publishLocalBin = taskKey[Unit]("")
     val publishLocalBinConfig = taskKey[PublishConfiguration]("")
-  }
   import autoImport.*
 
   private val dummyDoc = taskKey[HashedVirtualFileRef]("").withRank(Int.MaxValue)
@@ -28,7 +27,7 @@ object PublishBinPlugin extends AutoPlugin {
       Classpaths.publishConfig(
         false, // publishMavenStyle.value,
         Classpaths.deliverPattern(crossTarget.value),
-        if (isSnapshot.value) "integration" else "release",
+        if isSnapshot.value then "integration" else "release",
         ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
         (publishLocalBin / packagedArtifacts).value.map { (k, v) =>
           k -> fileConverter.value.toPath(v).toFile
@@ -41,10 +40,11 @@ object PublishBinPlugin extends AutoPlugin {
     dummyDoc := {
       val _ = projectID.value
       val dummyFile = target.value / "dummy-doc" / "doc.jar"
-      try {
+      try
         Files.createDirectories(dummyFile.toPath.getParent)
         Files.createFile(dummyFile.toPath)
-      } catch { case _: FileAlreadyExistsException => }
+      catch
+        case _: FileAlreadyExistsException =>
       val out = fileConverter.value.toVirtualFile(dummyFile.toPath)
       Def.declareOutput(out)
       (out: HashedVirtualFileRef)
@@ -58,4 +58,4 @@ object PublishBinPlugin extends AutoPlugin {
         .value
     )
   )
-}
+end PublishBinPlugin
diff --git a/project/SbtLauncherPlugin.scala b/project/SbtLauncherPlugin.scala
index 170a1cfaf..26b6dd928 100644
--- a/project/SbtLauncherPlugin.scala
+++ b/project/SbtLauncherPlugin.scala
@@ -3,10 +3,10 @@ import sbt.*
 import sbt.io.CopyOptions
 import sbt.util.CacheImplicits.given
 
-object SbtLauncherPlugin extends AutoPlugin {
+object SbtLauncherPlugin extends AutoPlugin:
   override def requires = plugins.IvyPlugin
 
-  object autoImport {
+  object autoImport:
     val SbtLaunchConfiguration = config("sbt-launch")
     val sbtLaunchJar =
       taskKey[HashedVirtualFileRef]("constructs an sbt-launch.jar for this version of sbt.")
@@ -14,7 +14,6 @@ object SbtLauncherPlugin extends AutoPlugin {
       taskKey[HashedVirtualFileRef](
         "The released version of the sbt-launcher we use to bundle this application."
       )
-  }
   import autoImport.*
 
   override def projectConfigurations: Seq[Configuration] = Seq(SbtLaunchConfiguration)
@@ -24,21 +23,20 @@ object SbtLauncherPlugin extends AutoPlugin {
       val converter = fileConverter.value
       Classpaths
         .managedJars(SbtLaunchConfiguration, Set("jar"), update.value, converter)
-        .headOption match {
+        .headOption match
         case Some(jar) => jar.data
         case None      =>
           sys.error(
             s"Could not resolve sbt launcher!, dependencies := ${libraryDependencies.value}"
           )
-      }
     },
     sbtLaunchJar := Def.uncached {
       val propFiles = (Compile / resources).value
       val propFileLocations =
-        for (file <- propFiles; if file.getName != "resources") yield {
-          if (file.getName == "sbt.boot.properties") "sbt/sbt.boot.properties" -> file
+        for file <- propFiles; if file.getName != "resources"
+        yield
+          if file.getName == "sbt.boot.properties" then "sbt/sbt.boot.properties" -> file
           else file.getName -> file
-        }
       // TODO - We need to inject the appropriate boot.properties file for this version of sbt.
       fileConverter.value.toVirtualFile(
         rebundle(
@@ -50,19 +48,16 @@ object SbtLauncherPlugin extends AutoPlugin {
     }
   )
 
-  def rebundle(jar: File, overrides: Map[String, File], target: File): File = {
+  def rebundle(jar: File, overrides: Map[String, File], target: File): File =
     // TODO - Check if we should rebuild the jar or not....
     IO.withTemporaryDirectory { dir =>
       IO.unzip(jar, dir)
       IO.copy(overrides.map({ case (n, f) => (f, dir / n) }), CopyOptions().withOverwrite(true))
       // TODO - is the ok for creating a jar?
-      val rebase: File => Seq[(File, String)] = {
+      val rebase: File => Seq[(File, String)] =
         val path = dir.toPath
-        f => if (f != dir) f -> path.relativize(f.toPath).toString :: Nil else Nil
-      }
+        f => if f != dir then f -> path.relativize(f.toPath).toString :: Nil else Nil
       IO.zip(dir.allPaths.get().flatMap(rebase), target, None)
     }
     target
-  }
-
-}
+end SbtLauncherPlugin
diff --git a/project/Scripted.scala b/project/Scripted.scala
index 314772696..34648bcce 100644
--- a/project/Scripted.scala
+++ b/project/Scripted.scala
@@ -8,13 +8,12 @@ import sbt.internal.inc.classpath.{ ClasspathUtilities, FilteredLoader }
 import scala.annotation.nowarn
 import scala.jdk.CollectionConverters.*
 
-object LocalScriptedPlugin extends AutoPlugin {
+object LocalScriptedPlugin extends AutoPlugin:
   override def requires = plugins.JvmPlugin
 
   object autoImport extends ScriptedKeys
-}
 
-trait ScriptedKeys {
+trait ScriptedKeys:
   val publishLocalBinAll = taskKey[Unit]("")
   val scriptedUnpublished = inputKey[Unit](
     "Execute scripted without publishing sbt first. " +
@@ -26,18 +25,17 @@ trait ScriptedKeys {
   val scriptedKeepTempDirectory = settingKey[Boolean](
     "If true, keeps the temporary directory after scripted tests complete for debugging."
   )
-}
 
-object Scripted {
+object Scripted:
   // This is to workaround https://github.com/sbt/io/issues/110
-  if (!sys.props.contains("jna.nosys")) sys.props.put("jna.nosys", "true")
+  if !sys.props.contains("jna.nosys") then sys.props.put("jna.nosys", "true")
 
   val RepoOverrideTest = config("repoOverrideTest").extend(Compile)
 
   val sbtWindowsExcludeFilter: FileFilter =
-    if (scala.util.Properties.isWin)
+    if scala.util.Properties.isWin then
       new SimpleFileFilter(f =>
-        (f.getParentFile.getName, f.getName) match {
+        (f.getParentFile.getName, f.getName) match
           case ("classloader-cache", "jni")   => true // no native lib is built for windows
           case ("classloader-cache", "spark") =>
             true // the test spark server is unable to bind to a local socket on Visual Studio 2019
@@ -46,7 +44,6 @@ object Scripted {
           case ("cache", "compile-io-failure") =>
             true // a read-only dir doesn't block writes on windows, so the I/O failure won't reproduce
           case _ => false
-        }
       )
     else NothingFilter
 
@@ -57,7 +54,7 @@ object Scripted {
 
   // FIXME: Duplicated with ScriptedPlugin.scriptedParser, this can be
   // avoided once we upgrade build.properties to 0.13.14
-  def scriptedParser(scriptedBase: File): Parser[Seq[String]] = {
+  def scriptedParser(scriptedBase: File): Parser[Seq[String]] =
     import DefaultParsers.*
 
     val scriptedFiles: NameFilter = ("test": NameFilter) | "pending"
@@ -73,7 +70,7 @@ object Scripted {
 
     // A parser for page definitions
     val pageNumber = (NatBasic & not('0', "zero page number")).flatMap { i =>
-      if (i <= pairs.size) Parser.success(i)
+      if i <= pairs.size then Parser.success(i)
       else Parser.failure(s"$i exceeds the number of tests (${pairs.size})")
     }
     val pageP: Parser[ScriptedTestPage] = ("*" ~> pageNumber ~ ("of" ~> pageNumber)) flatMap {
@@ -82,34 +79,32 @@ object Scripted {
     }
 
     // Grabs the filenames from a given test group in the current page definition.
-    def pagedFilenames(group: String, page: ScriptedTestPage): Seq[String] = {
+    def pagedFilenames(group: String, page: ScriptedTestPage): Seq[String] =
       val files = pairMap.get(group).toSeq.flatten.sortBy(_.toLowerCase)
-      val pageSize = if (page.total == 0) files.size else files.size / page.total
+      val pageSize = if page.total == 0 then files.size else files.size / page.total
       // The last page may loose some values, so we explicitly keep them
       val dropped = files.drop(pageSize * (page.page - 1))
-      if (page.page == page.total) dropped
+      if page.page == page.total then dropped
       else dropped.take(pageSize)
-    }
 
-    def nameP(group: String) = {
+    def nameP(group: String) =
       token("*".id | id.examples(pairMap.getOrElse(group, Set.empty[String])))
-    }
 
     val PagedIds: Parser[Seq[String]] =
-      for {
+      for
         group <- groupP
         page <- pageP
         files = pagedFilenames(group, page)
-        // TODO -  Fail the parser if we don't have enough files for the given page size
-        // if !files.isEmpty
-      } yield files map (f => s"$group/$f")
+      // TODO -  Fail the parser if we don't have enough files for the given page size
+      // if !files.isEmpty
+      yield files map (f => s"$group/$f")
 
-    val testID = (for (group <- groupP; name <- nameP(group)) yield (group, name))
+    val testID = (for group <- groupP; name <- nameP(group) yield (group, name))
     val testIdAsGroup = matched(testID).map(test => Seq(test))
 
     // (token(Space) ~> matched(testID)).*
     (token(Space) ~> (PagedIds | testIdAsGroup)).*.map(_.flatten)
-  }
+  end scriptedParser
 
   @nowarn
   def doScripted(
@@ -127,7 +122,7 @@ object Scripted {
       keepTempDirectory: Boolean,
       includeFilter: java.io.FileFilter,
       excludeFilter: java.io.FileFilter,
-  ): Unit = {
+  ): Unit =
     logger.info(s"Tests selected: ${args.mkString("\n * ", "\n * ", "\n")}")
     logger.info("")
 
@@ -153,24 +148,23 @@ object Scripted {
     }
 
     val initLoader = Thread.currentThread.getContextClassLoader
-    try {
+    try
       Thread.currentThread.setContextClassLoader(loader)
       val bridge =
         bridgeClass.getDeclaredConstructor().newInstance().asInstanceOf[SbtScriptedRunner]
-      try {
+      try
         // Using java.util.List to encode File => Unit.
-        val callback = new java.util.AbstractList[File] {
-          override def add(x: File): Boolean = { prescripted(x); false }
+        val callback = new java.util.AbstractList[File]:
+          override def add(x: File): Boolean =
+            prescripted(x); false
           def get(x: Int): sbt.File = ???
           def size(): Int = 0
-        }
-        val instances: Int = (System.getProperty("sbt.scripted.parallel.instances") match {
+        val instances: Int = (System.getProperty("sbt.scripted.parallel.instances") match
           case null => 1
           case i    => scala.util.Try(i.toInt).getOrElse(1)
-        }) match {
+        ) match
           case i if i > 0 => i
           case _          => 1
-        }
         import scala.reflect.Selectable.reflectiveSelectable
 
         bridge.runInParallel(
@@ -186,9 +180,9 @@ object Scripted {
           includeFilter,
           excludeFilter,
         )
-      } catch { case ite: InvocationTargetException => throw ite.getCause }
-    } finally {
-      Thread.currentThread.setContextClassLoader(initLoader)
-    }
-  }
-}
+      catch case ite: InvocationTargetException => throw ite.getCause
+      end try
+    finally Thread.currentThread.setContextClassLoader(initLoader)
+    end try
+  end doScripted
+end Scripted
diff --git a/project/Transform.scala b/project/Transform.scala
index 92c0f64a3..10169abdf 100644
--- a/project/Transform.scala
+++ b/project/Transform.scala
@@ -1,7 +1,7 @@
 import sbt.*
 import sbt.Keys.*
 
-object Transform {
+object Transform:
 
   def configSettings = Seq(
     resourceGenerators += Def.task {
@@ -19,10 +19,9 @@ object Transform {
       val catcher = scala.util.control.Exception.catching(classOf[java.io.IOException])
       rs.map { case (in, out) =>
         val newString = Property.replaceAllIn(IO.read(in), mtch => get(mtch.group(1)))
-        if (Some(newString) != catcher.opt(IO.read(out)))
-          IO.write(out, newString)
+        if Some(newString) != catcher.opt(IO.read(out)) then IO.write(out, newString)
         out
       }
     }.taskValue,
   )
-}
+end Transform
diff --git a/project/Utils.scala b/project/Utils.scala
index 0a183d50f..482a894e6 100644
--- a/project/Utils.scala
+++ b/project/Utils.scala
@@ -7,7 +7,7 @@ import scalafix.sbt.ScalafixPlugin.autoImport.scalafix
 import PublishBinPlugin.autoImport.publishLocalBin
 import sbt.internal.inc.Analysis
 
-object Utils {
+object Utils:
   val JDK17 = config("jdk17")
 
   val ExclusiveTest: Tags.Tag = Tags.Tag("exclusive-test")
@@ -37,21 +37,19 @@ object Utils {
   )
 
   def projectComponent: Setting[?] =
-    projectID := (componentID.value match {
+    projectID := (componentID.value match
       case Some(id) => projectID.value.extra("e:component" -> id)
-      case None     => projectID.value
-    })
+      case None     => projectID.value)
 
-  def lastCompilationTime(analysis: Analysis): Long = {
+  def lastCompilationTime(analysis: Analysis): Long =
     val lastCompilation = analysis.compilations.allCompilations.lastOption
     lastCompilation.map(_.getStartTime) getOrElse 0L
-  }
   def generateVersionFile(
       version: String,
       dir: File,
       s: TaskStreams,
       analysis: Analysis
-  ): Seq[File] = {
+  ): Seq[File] =
     import java.util.{ Date, TimeZone }
     val formatter = new java.text.SimpleDateFormat("yyyyMMdd'T'HHmmss")
     formatter.setTimeZone(TimeZone.getTimeZone("GMT"))
@@ -60,14 +58,11 @@ object Utils {
     val f = dir / "xsbt.version.properties"
     // TODO: replace lastModified() with sbt.io.IO.getModifiedTimeOrZero(), once the build
     // has been upgraded to a version of sbt that includes that call.
-    if (
-      !f.exists || f.lastModified < lastCompilationTime(analysis) || !containsVersion(f, version)
-    ) {
+    if !f.exists || f.lastModified < lastCompilationTime(analysis) || !containsVersion(f, version)
+    then
       s.log.info("Writing version information to " + f + " :\n" + content)
       IO.write(f, content)
-    }
     f :: Nil
-  }
   def versionLine(version: String): String = "version=" + version
   def containsVersion(propFile: File, version: String): Boolean =
     IO.read(propFile).contains(versionLine(version))
@@ -76,7 +71,7 @@ object Utils {
     pomPostProcess := cleanPom
   )
 
-  def cleanPom(pomNode: scala.xml.Node) = {
+  def cleanPom(pomNode: scala.xml.Node) =
     import scala.xml.*
     def cleanNodes(nodes: Seq[Node]): Seq[Node] = nodes flatMap {
       case elem @ Elem(_, "dependency", _, _, _*) if excludePomDependency(elem) =>
@@ -89,7 +84,6 @@ object Utils {
       case other => other
     }
     cleanNodes(pomNode.theSeq)(0)
-  }
 
   def excludePomDependency(node: scala.xml.Node) = node \ "artifactId" exists { n =>
     excludePomArtifact(n.text)
@@ -106,11 +100,10 @@ object Utils {
     exclusive == 0 || all == 1
   }
 
-  def getScalaKeywords: Set[String] = {
+  def getScalaKeywords: Set[String] =
     dotty.tools.dotc.core.StdNames.nme.keywords.map(_.toString).toSet
-  }
 
-  def writeScalaKeywords(base: File, keywords: Set[String]): File = {
+  def writeScalaKeywords(base: File, keywords: Set[String]): File =
     val init = keywords.map(tn => "\"" + tn + "\"").mkString("Set(", ", ", ")")
     val ObjectName = "ScalaKeywords"
     val PackageName = "sbt.internal.util"
@@ -123,7 +116,6 @@ object Utils {
     val out = base / PackageName.replace('.', '/') / s"$ObjectName.scala"
     IO.write(out, keywordsSrc)
     out
-  }
 
   def keywordsSettings: Seq[Setting[?]] =
     inConfig(Compile)(
@@ -149,18 +141,17 @@ object Utils {
       (to ** "*.scala").get()
     }
   }
-}
+end Utils
 
-object Licensed {
+object Licensed:
   lazy val notice = SettingKey[Option[File]]("notice")
   @transient
   lazy val extractLicenses = TaskKey[Seq[File]]("extract-licenses")
 
   lazy val seeRegex = """\(see (.*?)\)""".r
-  def licensePath(base: File, str: String): File = {
+  def licensePath(base: File, str: String): File =
     val path = base / str;
-    if (path.exists) path else sys.error("Referenced license '" + str + "' not found at " + path)
-  }
+    if path.exists then path else sys.error("Referenced license '" + str + "' not found at " + path)
   def seePaths(base: File, noticeString: String): Seq[File] =
     seeRegex.findAllIn(noticeString).matchData.map(d => licensePath(base, d.group(1))).toList
 
@@ -178,11 +169,8 @@ object Licensed {
       .getOrElse(Nil)
   )
   def extractLicenses0(base: File, note: File, s: TaskStreams): Seq[File] =
-    if (!note.exists) Nil
+    if !note.exists then Nil
     else
-      try {
-        seePaths(base, IO.read(note))
-      } catch {
-        case NonFatal(_) => s.log.warn("Could not read NOTICE"); Nil
-      }
-}
+      try seePaths(base, IO.read(note))
+      catch case NonFatal(_) => s.log.warn("Could not read NOTICE"); Nil
+end Licensed
diff --git a/protocol/src/main/scala/sbt/internal/bsp/BuildServerConnection.scala b/protocol/src/main/scala/sbt/internal/bsp/BuildServerConnection.scala
index f45b4e65e..6eb30b669 100644
--- a/protocol/src/main/scala/sbt/internal/bsp/BuildServerConnection.scala
+++ b/protocol/src/main/scala/sbt/internal/bsp/BuildServerConnection.scala
@@ -17,14 +17,14 @@ import java.io.File
 import java.nio.file.{ Files, Paths }
 import scala.util.Properties
 
-object BuildServerConnection {
+object BuildServerConnection:
   final val name = "sbt"
   final val bspVersion = "2.1.0-M1"
   final val languages = Vector("scala")
 
   private final val SbtLaunchJar = "sbt-launch(-.*)?\\.jar".r
 
-  private[sbt] def writeConnectionFile(sbtVersion: String, baseDir: File): Unit = {
+  private[sbt] def writeConnectionFile(sbtVersion: String, baseDir: File): Unit =
     val bspConnectionFile = new File(baseDir, ".bsp/sbt.json")
 
     val sbtScript = Option(System.getProperty("sbt.script"))
@@ -41,9 +41,8 @@ object BuildServerConnection {
     val details = BspConnectionDetails(name, sbtVersion, bspVersion, languages, argv)
     val json = Converter.toJson(details).get
     IO.write(bspConnectionFile, CompactPrinter(json), append = false)
-  }
 
-  private[sbt] def buildFallbackArgv: Vector[String] = {
+  private[sbt] def buildFallbackArgv: Vector[String] =
     val javaHome = Util.javaHome
     val classPath = System.getProperty("java.class.path")
     val sbtOptsArgs = parseSbtOpts(sys.env.get("SBT_OPTS"))
@@ -65,10 +64,10 @@ object BuildServerConnection {
       ) ++
       Vector("xsbt.boot.Boot", "-bsp") ++
       sbtLaunchJar
-  }
+  end buildFallbackArgv
 
-  private[sbt] def sbtScriptInPath: Option[String] = {
-    val fileName = if (Properties.isWin) "sbt.bat" else "sbt"
+  private[sbt] def sbtScriptInPath: Option[String] =
+    val fileName = if Properties.isWin then "sbt.bat" else "sbt"
     val envPath = sys.env.collectFirst {
       case (k, v) if k.toUpperCase() == "PATH" => v
     }
@@ -79,7 +78,6 @@ object BuildServerConnection {
       .map(_.resolve(fileName))
       .find(file => Files.exists(file) && Files.isExecutable(file))
       .map(_.toString)
-  }
 
   private[sbt] def parseSbtOpts(sbtOpts: Option[String]): Vector[String] =
     sbtOpts match
@@ -87,7 +85,7 @@ object BuildServerConnection {
         opts
           .split("\\s+")
           .filter(arg => arg.startsWith("-D") || arg.startsWith("-X") || arg.startsWith("-J"))
-          .map(arg => if (arg.startsWith("-J")) arg.stripPrefix("-J") else arg)
+          .map(arg => if arg.startsWith("-J") then arg.stripPrefix("-J") else arg)
           .toVector
       case _ => Vector.empty
-}
+end BuildServerConnection
diff --git a/protocol/src/main/scala/sbt/internal/bsp/BuildServerTasks.scala b/protocol/src/main/scala/sbt/internal/bsp/BuildServerTasks.scala
index 9861d116c..7fd1d92ae 100644
--- a/protocol/src/main/scala/sbt/internal/bsp/BuildServerTasks.scala
+++ b/protocol/src/main/scala/sbt/internal/bsp/BuildServerTasks.scala
@@ -10,7 +10,6 @@ package sbt.internal.bsp
 
 import java.util.concurrent.atomic.AtomicInteger
 
-object BuildServerTasks {
+object BuildServerTasks:
   private val idGenerator = new AtomicInteger(0)
   def uniqueId: String = idGenerator.getAndIncrement().toString
-}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/BuildTargetName.scala b/protocol/src/main/scala/sbt/internal/bsp/BuildTargetName.scala
index e17f78581..d29460523 100644
--- a/protocol/src/main/scala/sbt/internal/bsp/BuildTargetName.scala
+++ b/protocol/src/main/scala/sbt/internal/bsp/BuildTargetName.scala
@@ -8,11 +8,8 @@
 
 package sbt.internal.bsp
 
-object BuildTargetName {
-  def fromScope(project: String, config: String): String = {
-    config match {
+object BuildTargetName:
+  def fromScope(project: String, config: String): String =
+    config match
       case "compile" => project
       case _         => s"$project-$config"
-    }
-  }
-}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/BuildTargetTag.scala b/protocol/src/main/scala/sbt/internal/bsp/BuildTargetTag.scala
index 79cab2a67..ff5987968 100644
--- a/protocol/src/main/scala/sbt/internal/bsp/BuildTargetTag.scala
+++ b/protocol/src/main/scala/sbt/internal/bsp/BuildTargetTag.scala
@@ -9,16 +9,14 @@
 package sbt.internal.bsp
 
 // https://build-server-protocol.github.io/docs/specification.html#build-target
-object BuildTargetTag {
+object BuildTargetTag:
   val test: String = "test"
   val application: String = "application"
   val library: String = "library"
   val benchmark: String = "benchmark"
   val noIDE: String = "no-ide"
 
-  def fromConfig(config: String): Vector[String] = config match {
+  def fromConfig(config: String): Vector[String] = config match
     case "test"    => Vector(test)
     case "compile" => Vector(library)
     case _         => Vector.empty
-  }
-}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/DiagnosticSeverity.scala b/protocol/src/main/scala/sbt/internal/bsp/DiagnosticSeverity.scala
index 68358f8de..d507c0e95 100644
--- a/protocol/src/main/scala/sbt/internal/bsp/DiagnosticSeverity.scala
+++ b/protocol/src/main/scala/sbt/internal/bsp/DiagnosticSeverity.scala
@@ -8,7 +8,7 @@
 
 package sbt.internal.bsp
 
-object DiagnosticSeverity {
+object DiagnosticSeverity:
 
   /**
    * Reports an error.
@@ -29,4 +29,4 @@ object DiagnosticSeverity {
    * Reports a hint.
    */
   val Hint = 4L
-}
+end DiagnosticSeverity
diff --git a/protocol/src/main/scala/sbt/internal/bsp/OutputPathItemKind.scala b/protocol/src/main/scala/sbt/internal/bsp/OutputPathItemKind.scala
index 32cb64cf1..14100977d 100644
--- a/protocol/src/main/scala/sbt/internal/bsp/OutputPathItemKind.scala
+++ b/protocol/src/main/scala/sbt/internal/bsp/OutputPathItemKind.scala
@@ -8,11 +8,10 @@
 
 package sbt.internal.bsp
 
-object OutputPathItemKind {
+object OutputPathItemKind:
 
   /** The output path item references a normal file. */
   val File: Int = 1
 
   /** The output path item references a directory. */
   val Directory: Int = 2
-}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/ScalaPlatform.scala b/protocol/src/main/scala/sbt/internal/bsp/ScalaPlatform.scala
index 158bd36d6..76155ceef 100644
--- a/protocol/src/main/scala/sbt/internal/bsp/ScalaPlatform.scala
+++ b/protocol/src/main/scala/sbt/internal/bsp/ScalaPlatform.scala
@@ -10,8 +10,7 @@ package sbt
 package internal
 package bsp
 
-object ScalaPlatform {
+object ScalaPlatform:
   val JVM = 1
   val JS = 2
   val Native = 3
-}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/SourceItemKind.scala b/protocol/src/main/scala/sbt/internal/bsp/SourceItemKind.scala
index 1b59754a6..87cf9a330 100644
--- a/protocol/src/main/scala/sbt/internal/bsp/SourceItemKind.scala
+++ b/protocol/src/main/scala/sbt/internal/bsp/SourceItemKind.scala
@@ -10,11 +10,10 @@ package sbt
 package internal
 package bsp
 
-object SourceItemKind {
+object SourceItemKind:
 
   /** The source item references a normal file. */
   val File: Int = 1
 
   /** The source item references a directory. */
   val Directory: Int = 2
-}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/StatusCode.scala b/protocol/src/main/scala/sbt/internal/bsp/StatusCode.scala
index 65085f7a0..eca3646b2 100644
--- a/protocol/src/main/scala/sbt/internal/bsp/StatusCode.scala
+++ b/protocol/src/main/scala/sbt/internal/bsp/StatusCode.scala
@@ -8,8 +8,7 @@
 
 package sbt.internal.bsp
 
-object StatusCode {
+object StatusCode:
   final val Success: Int = 1
   final val Error: Int = 2
   final val Cancelled: Int = 3
-}
diff --git a/protocol/src/main/scala/sbt/internal/langserver/DiagnosticSeverity.scala b/protocol/src/main/scala/sbt/internal/langserver/DiagnosticSeverity.scala
index 52789d9c7..85577d31a 100644
--- a/protocol/src/main/scala/sbt/internal/langserver/DiagnosticSeverity.scala
+++ b/protocol/src/main/scala/sbt/internal/langserver/DiagnosticSeverity.scala
@@ -10,7 +10,7 @@ package sbt
 package internal
 package langserver
 
-object DiagnosticSeverity {
+object DiagnosticSeverity:
 
   /**
    * Reports an error.
@@ -31,4 +31,4 @@ object DiagnosticSeverity {
    * Reports a hint.
    */
   val Hint = 4L
-}
+end DiagnosticSeverity
diff --git a/protocol/src/main/scala/sbt/internal/langserver/MessageType.scala b/protocol/src/main/scala/sbt/internal/langserver/MessageType.scala
index 4cef17853..a512de543 100644
--- a/protocol/src/main/scala/sbt/internal/langserver/MessageType.scala
+++ b/protocol/src/main/scala/sbt/internal/langserver/MessageType.scala
@@ -10,7 +10,7 @@ package sbt
 package internal
 package langserver
 
-object MessageType {
+object MessageType:
 
   /** An error message. */
   val Error = 1L
@@ -24,12 +24,9 @@ object MessageType {
   /** A log message. */
   val Log = 4L
 
-  def fromLevelString(level: String): Long = {
-    level.toLowerCase match {
+  def fromLevelString(level: String): Long =
+    level.toLowerCase match
       case "info"  => Info
       case "warn"  => Warning
       case "error" => Error
       case _       => Log
-    }
-  }
-}
diff --git a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcNotificationMessageFormats.scala b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcNotificationMessageFormats.scala
index ea7a9b3d2..7a73235db 100644
--- a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcNotificationMessageFormats.scala
+++ b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcNotificationMessageFormats.scala
@@ -11,16 +11,16 @@ package sbt.internal.protocol.codec
 import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
 import sjsonnew.shaded.scalajson.ast.unsafe.JValue
 
-trait JsonRpcNotificationMessageFormats {
+trait JsonRpcNotificationMessageFormats:
   self: sbt.internal.util.codec.JValueFormats & sjsonnew.BasicJsonProtocol =>
   given JsonRpcNotificationMessageFormat
       : JsonFormat[sbt.internal.protocol.JsonRpcNotificationMessage] =
-    new JsonFormat[sbt.internal.protocol.JsonRpcNotificationMessage] {
+    new JsonFormat[sbt.internal.protocol.JsonRpcNotificationMessage]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.internal.protocol.JsonRpcNotificationMessage = {
-        jsOpt match {
+      ): sbt.internal.protocol.JsonRpcNotificationMessage =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
             val jsonrpc = unbuilder.readField[String]("jsonrpc")
@@ -32,17 +32,13 @@ trait JsonRpcNotificationMessageFormats {
             sbt.internal.protocol.JsonRpcNotificationMessage(jsonrpc, method, params)
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
       override def write[J](
           obj: sbt.internal.protocol.JsonRpcNotificationMessage,
           builder: Builder[J]
-      ): Unit = {
+      ): Unit =
         builder.beginObject()
         builder.addField("jsonrpc", obj.jsonrpc)
         builder.addField("method", obj.method)
         builder.addField("params", obj.params)
         builder.endObject()
-      }
-    }
-}
+end JsonRpcNotificationMessageFormats
diff --git a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcRequestMessageFormats.scala b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcRequestMessageFormats.scala
index a25d17ef3..6b80b39a1 100644
--- a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcRequestMessageFormats.scala
+++ b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcRequestMessageFormats.scala
@@ -11,27 +11,24 @@ package sbt.internal.protocol.codec
 import sjsonnew.shaded.scalajson.ast.unsafe.JValue
 import sjsonnew.{ Builder, DeserializationException, JsonFormat, Unbuilder, deserializationError }
 
-trait JsonRpcRequestMessageFormats {
+trait JsonRpcRequestMessageFormats:
   self: sbt.internal.util.codec.JValueFormats & sjsonnew.BasicJsonProtocol =>
   given JsonRpcRequestMessageFormat: JsonFormat[sbt.internal.protocol.JsonRpcRequestMessage] =
-    new JsonFormat[sbt.internal.protocol.JsonRpcRequestMessage] {
+    new JsonFormat[sbt.internal.protocol.JsonRpcRequestMessage]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.internal.protocol.JsonRpcRequestMessage = {
-        jsOpt match {
+      ): sbt.internal.protocol.JsonRpcRequestMessage =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
             val jsonrpc = unbuilder.readField[String]("jsonrpc")
             val id =
-              try {
-                unbuilder.readField[String]("id")
-              } catch {
-                case _: DeserializationException => {
+              try unbuilder.readField[String]("id")
+              catch
+                case _: DeserializationException =>
                   val prefix = "\u2668" // Append prefix to show the original type was Number
                   prefix + unbuilder.readField[Long]("id").toString
-                }
-              }
             val method = unbuilder.readField[String]("method")
             val params = unbuilder.lookupField("params") map { case x: JValue =>
               x
@@ -40,18 +37,14 @@ trait JsonRpcRequestMessageFormats {
             sbt.internal.protocol.JsonRpcRequestMessage(jsonrpc, id, method, params)
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
       override def write[J](
           obj: sbt.internal.protocol.JsonRpcRequestMessage,
           builder: Builder[J]
-      ): Unit = {
+      ): Unit =
         builder.beginObject()
         builder.addField("jsonrpc", obj.jsonrpc)
         builder.addField("id", obj.id)
         builder.addField("method", obj.method)
         builder.addField("params", obj.params)
         builder.endObject()
-      }
-    }
-}
+end JsonRpcRequestMessageFormats
diff --git a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseErrorFormats.scala b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseErrorFormats.scala
index 5d00d4be0..6fe560d49 100644
--- a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseErrorFormats.scala
+++ b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseErrorFormats.scala
@@ -11,15 +11,15 @@ package sbt.internal.protocol.codec
 import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
 import sjsonnew.shaded.scalajson.ast.unsafe.JValue
 
-trait JsonRpcResponseErrorFormats {
+trait JsonRpcResponseErrorFormats:
   self: sbt.internal.util.codec.JValueFormats & sjsonnew.BasicJsonProtocol =>
   given JsonRpcResponseErrorFormat: JsonFormat[sbt.internal.protocol.JsonRpcResponseError] =
-    new JsonFormat[sbt.internal.protocol.JsonRpcResponseError] {
+    new JsonFormat[sbt.internal.protocol.JsonRpcResponseError]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.internal.protocol.JsonRpcResponseError = {
-        jsOpt match {
+      ): sbt.internal.protocol.JsonRpcResponseError =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
             val code = unbuilder.readField[Long]("code")
@@ -31,17 +31,13 @@ trait JsonRpcResponseErrorFormats {
             sbt.internal.protocol.JsonRpcResponseError(code, message, data)
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
       override def write[J](
           obj: sbt.internal.protocol.JsonRpcResponseError,
           builder: Builder[J]
-      ): Unit = {
+      ): Unit =
         builder.beginObject()
         builder.addField("code", obj.code)
         builder.addField("message", obj.message)
         builder.addField("data", obj.data)
         builder.endObject()
-      }
-    }
-}
+end JsonRpcResponseErrorFormats
diff --git a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseMessageFormats.scala b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseMessageFormats.scala
index 9fcb338e4..721fd4219 100644
--- a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseMessageFormats.scala
+++ b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseMessageFormats.scala
@@ -17,26 +17,24 @@ import _root_.sjsonnew.{
 }
 import sjsonnew.shaded.scalajson.ast.unsafe.*
 
-trait JsonRpcResponseMessageFormats {
+trait JsonRpcResponseMessageFormats:
   self: sbt.internal.util.codec.JValueFormats &
     sbt.internal.protocol.codec.JsonRpcResponseErrorFormats & sjsonnew.BasicJsonProtocol =>
   given JsonRpcResponseMessageFormat: JsonFormat[sbt.internal.protocol.JsonRpcResponseMessage] =
-    new JsonFormat[sbt.internal.protocol.JsonRpcResponseMessage] {
+    new JsonFormat[sbt.internal.protocol.JsonRpcResponseMessage]:
       override def read[J](
           jsOpt: Option[J],
           unbuilder: Unbuilder[J]
-      ): sbt.internal.protocol.JsonRpcResponseMessage = {
-        jsOpt match {
+      ): sbt.internal.protocol.JsonRpcResponseMessage =
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
             val jsonrpc = unbuilder.readField[String]("jsonrpc")
             val id =
-              try {
-                unbuilder.readField[String]("id")
-              } catch {
+              try unbuilder.readField[String]("id")
+              catch
                 case _: DeserializationException =>
                   unbuilder.readField[Long]("id").toString
-              }
 
             val result = unbuilder.lookupField("result") map { case x: JValue =>
               x
@@ -49,41 +47,34 @@ trait JsonRpcResponseMessageFormats {
             sbt.internal.protocol.JsonRpcResponseMessage(jsonrpc, id, result, error)
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
-      }
       override def write[J](
           obj: sbt.internal.protocol.JsonRpcResponseMessage,
           builder: Builder[J]
-      ): Unit = {
+      ): Unit =
         // Parse given id to Long or String judging by prefix
-        def parseId(str: String): Either[Long, String] = {
-          if (str.startsWith("\u2668")) Left(str.substring(1).toLong)
+        def parseId(str: String): Either[Long, String] =
+          if str.startsWith("\u2668") then Left(str.substring(1).toLong)
           else Right(str)
-        }
-        def parseResult(jValue: JValue): JValue = jValue match {
+        def parseResult(jValue: JValue): JValue = jValue match
           case JObject(jFields) =>
             val replaced = jFields map {
               case field @ JField("execId", JString(str)) =>
-                parseId(str) match {
+                parseId(str) match
                   case Right(strId) => field.copy(value = JString(strId))
                   case Left(longId) => field.copy(value = JNumber(longId))
-                }
               case other =>
                 other
             }
             JObject(replaced)
           case other =>
             other
-        }
         builder.beginObject()
         builder.addField("jsonrpc", obj.jsonrpc)
-        parseId(obj.id) match {
+        parseId(obj.id) match
           case Right(strId) => builder.addField("id", strId)
           case Left(longId) => builder.addField("id", longId)
-        }
         builder.addField("result", obj.result map parseResult)
         builder.addField("error", obj.error)
         builder.endObject()
-      }
-    }
-}
+      end write
+end JsonRpcResponseMessageFormats
diff --git a/protocol/src/main/scala/sbt/internal/util/JoinThread.scala b/protocol/src/main/scala/sbt/internal/util/JoinThread.scala
index c1789efad..756d310f3 100644
--- a/protocol/src/main/scala/sbt/internal/util/JoinThread.scala
+++ b/protocol/src/main/scala/sbt/internal/util/JoinThread.scala
@@ -12,21 +12,16 @@ import scala.annotation.tailrec
 import scala.concurrent.duration.*
 import java.util.concurrent.TimeoutException
 
-private[sbt] object JoinThread {
-  extension (t: Thread) {
-    def joinFor(duration: FiniteDuration): Unit = {
+private[sbt] object JoinThread:
+  extension (t: Thread)
+    def joinFor(duration: FiniteDuration): Unit =
       val deadline = duration.fromNow
-      @tailrec def impl(): Unit = {
-        try {
+      @tailrec def impl(): Unit =
+        try
           t.interrupt()
           t.join(10)
-        } catch { case e: InterruptedException => }
-        if (t.isAlive && !deadline.isOverdue()) impl()
-      }
+        catch
+          case e: InterruptedException =>
+        if t.isAlive && !deadline.isOverdue() then impl()
       impl()
-      if (t.isAlive) {
-        throw new TimeoutException(s"Unable to join thread $t after $duration")
-      }
-    }
-  }
-}
+      if t.isAlive then throw new TimeoutException(s"Unable to join thread $t after $duration")
diff --git a/protocol/src/main/scala/sbt/protocol/ClientSocket.scala b/protocol/src/main/scala/sbt/protocol/ClientSocket.scala
index f55f224ef..ad1d9a909 100644
--- a/protocol/src/main/scala/sbt/protocol/ClientSocket.scala
+++ b/protocol/src/main/scala/sbt/protocol/ClientSocket.scala
@@ -23,7 +23,7 @@ import org.scalasbt.ipcsocket.*
 
 import scala.util.{ Failure, Success, Try }
 
-object ClientSocket {
+object ClientSocket:
   private lazy val fileFormats = new BasicJsonProtocol with PortFileFormats with TokenFileFormats {}
 
   /** Thrown when a server connection file can't be read or parsed as JSON. */
@@ -33,18 +33,16 @@ object ClientSocket {
   def socket(portfile: File): (Socket, Option[String]) = socket(portfile, false)
 
   /** Parses the connection file written by the server. */
-  private[sbt] def loadPortFile(portfile: File): Try[PortFile] = {
+  private[sbt] def loadPortFile(portfile: File): Try[PortFile] =
     import fileFormats.given
     val parsed = Try(sbt.io.IO.read(portfile)).flatMap(Parser.parseFromString)
     parsed.flatMap(Converter.fromJson[PortFile])
-  }
 
-  def socket(portfile: File, useJNI: Boolean): (Socket, Option[String]) = {
+  def socket(portfile: File, useJNI: Boolean): (Socket, Option[String]) =
     import fileFormats.given
-    val p = loadPortFile(portfile) match {
+    val p = loadPortFile(portfile) match
       case Success(p) => p
       case Failure(e) => throw new ConnectionFileReadException(portfile, e)
-    }
     val uri = new URI(p.uri)
     val token = p.tokenfilePath map { tp =>
       val tokeFile = new File(tp)
@@ -54,14 +52,12 @@ object ClientSocket {
       catch case NonFatal(e) => throw new ConnectionFileReadException(tokeFile, e)
     }
     (connect(uri, useJNI), token)
-  }
 
   private def connect(uri: URI, useJNI: Boolean): Socket =
-    uri.getScheme match {
+    uri.getScheme match
       case "local" => localSocket(uri.getSchemeSpecificPart, useJNI)
       case "tcp"   => new Socket(InetAddress.getByName(uri.getHost), uri.getPort)
       case _       => sys.error(s"Unsupported uri: $uri")
-    }
 
   /** Whether a server still accepts connections on `uri`, as written in its connection file. */
   private[sbt] def reachable(uri: String, useJNI: Boolean): Boolean =
@@ -70,11 +66,11 @@ object ClientSocket {
       true
     catch case NonFatal(_) => false
   def localSocket(name: String, useJNI: Boolean): Socket =
-    if (isWindows) new Win32NamedPipeSocket(s"\\\\.\\pipe\\$name", useJNI)
+    if isWindows then new Win32NamedPipeSocket(s"\\\\.\\pipe\\$name", useJNI)
     else new UnixDomainSocket(name, useJNI)
 
   def bootSocket(path: String): Socket =
     val ch = SocketChannel.open(StandardProtocolFamily.UNIX)
     ch.connect(UnixDomainSocketAddress.of(path))
     DuplexChannels.newSocket(ch)
-}
+end ClientSocket
diff --git a/protocol/src/main/scala/sbt/protocol/JsonRpcReader.scala b/protocol/src/main/scala/sbt/protocol/JsonRpcReader.scala
index 9bbdb655f..a7456ce80 100644
--- a/protocol/src/main/scala/sbt/protocol/JsonRpcReader.scala
+++ b/protocol/src/main/scala/sbt/protocol/JsonRpcReader.scala
@@ -12,13 +12,13 @@ import java.io.InputStream
 import java.nio.channels.ClosedChannelException
 import java.util.concurrent.atomic.AtomicBoolean
 
-object JsonRpcReader {
+object JsonRpcReader:
 
   def read(
       inputStream: InputStream,
       running: AtomicBoolean,
       onHeader: Option[String => Unit]
-  ): Seq[Byte] = {
+  ): Seq[Byte] =
     val newline = '\n'.toInt
     val carriageReturn = '\r'.toInt
     val contentLength = "Content-Length: "
@@ -32,28 +32,26 @@ object JsonRpcReader {
      * with headers, we may need to adjust this buffer size.
      */
     var headerBuffer = new Array[Byte](128)
-    def expandHeaderBuffer(): Unit = {
+    def expandHeaderBuffer(): Unit =
       val newHeaderBuffer = java.util.Arrays.copyOf(headerBuffer, headerBuffer.length * 2)
       headerBuffer = newHeaderBuffer
-    }
-    def getLine(): String = {
+    def getLine(): String =
       val line = new String(headerBuffer, 0, index, "UTF-8")
       index = 0
       onHeader.foreach(oh => oh(line))
       line
-    }
     var content: Seq[Byte] = Seq.empty[Byte]
     var consecutiveLineEndings = 0
     var onCarriageReturn = false
 
     def run(): Unit =
       val byte = inputStream.read
-      byte match {
+      byte match
         case `newline` =>
           val line = getLine()
-          if (onCarriageReturn) consecutiveLineEndings += 1
+          if onCarriageReturn then consecutiveLineEndings += 1
           onCarriageReturn = false
-          if (line.startsWith(contentLength)) {
+          if line.startsWith(contentLength) then
             line.drop(contentLength.length).toIntOption foreach { len =>
               def doDrainHeaders(): Unit =
                 inputStream.read match
@@ -64,12 +62,11 @@ object JsonRpcReader {
                   case `carriageReturn` => onCarriageReturn = true
                   case -1               => running.set(false)
                   case c                =>
-                    if (c == newline) getLine()
-                    else {
-                      if (index >= headerBuffer.length) expandHeaderBuffer()
+                    if c == newline then getLine()
+                    else
+                      if index >= headerBuffer.length then expandHeaderBuffer()
                       headerBuffer(index) = c.toByte
                       index += 1
-                    }
                     onCarriageReturn = false
                     consecutiveLineEndings = 0
 
@@ -78,36 +75,35 @@ object JsonRpcReader {
                 while consecutiveLineEndings < 2 && running.get do doDrainHeaders()
 
               drainHeaders()
-              if (running.get) {
+              if running.get then
                 val buf = new Array[Byte](len)
                 var offset = 0
                 def run1(): Unit = offset += inputStream.read(buf, offset, len - offset)
                 run1()
                 while offset < len && running.get do run1()
-                if (running.get) content = buf.toSeq
-              }
+                if running.get then content = buf.toSeq
             }
-          } else if (line.startsWith("{")) {
+          else if line.startsWith("{") then
             // Assume this is a json object with no headers
             content = line.getBytes.toSeq
-          }
+          end if
         case i if i < 0 =>
           running.set(false)
           throw new ClosedChannelException
         case `carriageReturn` => onCarriageReturn = true
         case c                =>
           onCarriageReturn = false
-          if (index >= headerBuffer.length) expandHeaderBuffer()
+          if index >= headerBuffer.length then expandHeaderBuffer()
           headerBuffer(index) = c.toByte
           index += 1
-
-      }
+      end match
+    end run
 
     run()
     while content.isEmpty && running.get do run()
     content
-  }
+  end read
 
   def readAsString(inputStream: InputStream, running: AtomicBoolean): String =
     new String(read(inputStream, running, onHeader = None).toArray, "UTF-8")
-}
+end JsonRpcReader
diff --git a/protocol/src/main/scala/sbt/protocol/JsonRpcWriter.scala b/protocol/src/main/scala/sbt/protocol/JsonRpcWriter.scala
index c8c4cf75f..734e6fb97 100644
--- a/protocol/src/main/scala/sbt/protocol/JsonRpcWriter.scala
+++ b/protocol/src/main/scala/sbt/protocol/JsonRpcWriter.scala
@@ -10,19 +10,16 @@ package sbt.protocol
 
 import java.io.OutputStream
 
-object JsonRpcWriter {
+object JsonRpcWriter:
 
-  def write(out: OutputStream, message: String): Unit = {
+  def write(out: OutputStream, message: String): Unit =
     val bytes = message.getBytes("UTF-8")
     writeLine(out, s"Content-Length: ${bytes.length + 2}".getBytes("UTF-8"))
     writeLine(out, Array.emptyByteArray)
     writeLine(out, bytes)
-  }
 
-  def writeLine(out: OutputStream, bytes: Array[Byte]): Unit = {
-    if (bytes.nonEmpty) out.write(bytes)
+  def writeLine(out: OutputStream, bytes: Array[Byte]): Unit =
+    if bytes.nonEmpty then out.write(bytes)
     out.write('\r'.toByte.toInt)
     out.write('\n'.toByte.toInt)
     out.flush()
-  }
-}
diff --git a/protocol/src/main/scala/sbt/protocol/Serialization.scala b/protocol/src/main/scala/sbt/protocol/Serialization.scala
index dfc05adbc..7cdf9a0c3 100644
--- a/protocol/src/main/scala/sbt/protocol/Serialization.scala
+++ b/protocol/src/main/scala/sbt/protocol/Serialization.scala
@@ -23,7 +23,7 @@ import sbt.internal.protocol.{
   JsonRpcNotificationMessage
 }
 
-object Serialization {
+object Serialization:
   private[sbt] val VsCode = "application/vscode-jsonrpc; charset=utf-8"
   val readSystemIn = "sbt/readSystemIn"
   val cancelReadSystemIn = "sbt/cancelReadSystemIn"
@@ -51,22 +51,20 @@ object Serialization {
   val CancelAll = "__CancelAll"
 
   @deprecated("unused", since = "1.4.0")
-  def serializeEvent[A: JsonFormat](event: A): Array[Byte] = {
+  def serializeEvent[A: JsonFormat](event: A): Array[Byte] =
     val json: JValue = Converter.toJson[A](event).get
     CompactPrinter(json).getBytes("UTF-8")
-  }
 
   @deprecated("unused", since = "1.4.0")
-  def serializeCommand(command: CommandMessage): Array[Byte] = {
+  def serializeCommand(command: CommandMessage): Array[Byte] =
     import codec.JsonProtocol.given
     val json: JValue = Converter.toJson[CommandMessage](command).get
     CompactPrinter(json).getBytes("UTF-8")
-  }
 
-  private[sbt] def serializeCommandAsJsonMessage(command: CommandMessage): String = {
+  private[sbt] def serializeCommandAsJsonMessage(command: CommandMessage): String =
     import sjsonnew.BasicJsonProtocol.given
 
-    command match {
+    command match
       case x: InitCommand =>
         val execId = x.execId.getOrElse(UUID.randomUUID.toString)
         val opts = x.initializationOptions.getOrElse(sys.error("expected initializationOptions"))
@@ -89,9 +87,8 @@ object Serialization {
         val json: JValue = Converter.toJson[Boolean](x.interactive).get
         val v = CompactPrinter(json)
         s"""{ "jsonrpc": "2.0", "id": "$execId", "method": "$attach", "params": { "interactive": $v } }"""
-
-    }
-  }
+    end match
+  end serializeCommandAsJsonMessage
 
   private[sbt] def serializeJsonRpcRequest(id: String, method: String, params: String): String =
     s"""{ "jsonrpc": "2.0", "id": "$id", "method": "$method", "params": $params }"""
@@ -99,33 +96,29 @@ object Serialization {
   private[sbt] def serializeJsonRpcNotification(method: String, params: String): String =
     s"""{ "jsonrpc": "2.0", "method": "$method", "params": $params }"""
 
-  def serializeEventMessage(event: EventMessage): Array[Byte] = {
+  def serializeEventMessage(event: EventMessage): Array[Byte] =
     import codec.JsonProtocol.given
     val json: JValue = Converter.toJson[EventMessage](event).get
     CompactPrinter(json).getBytes("UTF-8")
-  }
 
   /** This formats the message according to JSON-RPC. https://www.jsonrpc.org/specification */
-  private[sbt] def serializeResponseMessage(message: JsonRpcResponseMessage): Array[Byte] = {
+  private[sbt] def serializeResponseMessage(message: JsonRpcResponseMessage): Array[Byte] =
     import sbt.internal.protocol.codec.JsonRPCProtocol.given
     serializeResponse(message)
-  }
 
   /** This formats the message according to JSON-RPC. https://www.jsonrpc.org/specification */
-  private[sbt] def serializeRequestMessage(message: JsonRpcRequestMessage): Array[Byte] = {
+  private[sbt] def serializeRequestMessage(message: JsonRpcRequestMessage): Array[Byte] =
     import sbt.internal.protocol.codec.JsonRPCProtocol.given
     serializeResponse(message)
-  }
 
   /** This formats the message according to JSON-RPC. https://www.jsonrpc.org/specification */
   private[sbt] def serializeNotificationMessage(
       message: JsonRpcNotificationMessage,
-  ): Array[Byte] = {
+  ): Array[Byte] =
     import sbt.internal.protocol.codec.JsonRPCProtocol.given
     serializeResponse(message)
-  }
 
-  private[sbt] def serializeResponse[A: JsonWriter](message: A): Array[Byte] = {
+  private[sbt] def serializeResponse[A: JsonWriter](message: A): Array[Byte] =
     val json: JValue = Converter.toJson[A](message).get
     val body = CompactPrinter(json)
     val bodyLength = body.getBytes("UTF-8").length
@@ -136,117 +129,98 @@ object Serialization {
       "",
       body
     ).mkString("\r\n").getBytes("UTF-8")
-  }
 
   /**
    * @return
    *   A command or an invalid input description
    */
   @deprecated("unused", since = "1.4.0")
-  def deserializeCommand(bytes: Seq[Byte]): Either[String, CommandMessage] = {
+  def deserializeCommand(bytes: Seq[Byte]): Either[String, CommandMessage] =
     val buffer = ByteBuffer.wrap(bytes.toArray)
-    Parser.parseFromByteBuffer(buffer) match {
+    Parser.parseFromByteBuffer(buffer) match
       case Success(json) =>
         import codec.JsonProtocol.given
-        Converter.fromJson[CommandMessage](json) match {
+        Converter.fromJson[CommandMessage](json) match
           case Success(command) => Right(command)
           case Failure(e)       => Left(e.getMessage)
-        }
       case Failure(e) =>
         Left(s"Parse error: ${e.getMessage}")
-    }
-  }
 
   /**
    * @return
    *   A command or an invalid input description
    */
   @deprecated("unused", since = "1.4.0")
-  def deserializeEvent(bytes: Seq[Byte]): Either[String, Any] = {
+  def deserializeEvent(bytes: Seq[Byte]): Either[String, Any] =
     val buffer = ByteBuffer.wrap(bytes.toArray)
-    Parser.parseFromByteBuffer(buffer) match {
+    Parser.parseFromByteBuffer(buffer) match
       case Success(json) =>
-        detectType(json) match {
+        detectType(json) match
           case Some("StringEvent") =>
             import sbt.internal.util.codec.JsonProtocol.given
-            Converter.fromJson[StringEvent](json) match {
+            Converter.fromJson[StringEvent](json) match
               case Success(event) => Right(event)
               case Failure(e)     => Left(e.getMessage)
-            }
           case _ =>
             import codec.JsonProtocol.given
-            Converter.fromJson[EventMessage](json) match {
+            Converter.fromJson[EventMessage](json) match
               case Success(event) => Right(event)
               case Failure(e)     => Left(e.getMessage)
-            }
-        }
       case Failure(e) =>
         Left(s"Parse error: ${e.getMessage}")
-    }
-  }
 
   def detectType(json: JValue): Option[String] =
-    json match {
+    json match
       case JObject(fields) =>
-        (fields find { _.field == "type" } map { _.value }) match {
+        (fields find { _.field == "type" } map { _.value }) match
           case Some(JString(value)) => Some(value)
           case _                    => None
-        }
       case _ => None
-    }
 
   /**
    * @return
    *   A command or an invalid input description
    */
   @deprecated("unused", since = "1.4.0")
-  def deserializeEventMessage(bytes: Seq[Byte]): Either[String, EventMessage] = {
+  def deserializeEventMessage(bytes: Seq[Byte]): Either[String, EventMessage] =
     val buffer = ByteBuffer.wrap(bytes.toArray)
-    Parser.parseFromByteBuffer(buffer) match {
+    Parser.parseFromByteBuffer(buffer) match
       case Success(json) =>
         import codec.JsonProtocol.given
-        Converter.fromJson[EventMessage](json) match {
+        Converter.fromJson[EventMessage](json) match
           case Success(event) => Right(event)
           case Failure(e)     => Left(e.getMessage)
-        }
       case Failure(e) =>
         Left(s"Parse error: ${e.getMessage}")
-    }
-  }
 
-  private[sbt] def deserializeJsonMessage(bytes: Seq[Byte]): Either[String, JsonRpcMessage] = {
+  private[sbt] def deserializeJsonMessage(bytes: Seq[Byte]): Either[String, JsonRpcMessage] =
     val buffer = ByteBuffer.wrap(bytes.toArray)
-    Parser.parseFromByteBuffer(buffer) match {
+    Parser.parseFromByteBuffer(buffer) match
       case Success(json @ JObject(fields)) =>
         import sbt.internal.protocol.codec.JsonRPCProtocol.given
-        if (fields.exists(_.field == "method")) {
-          if (fields.exists(_.field == "id"))
-            Converter.fromJson[JsonRpcRequestMessage](json) match {
+        if fields.exists(_.field == "method") then
+          if fields.exists(_.field == "id") then
+            Converter.fromJson[JsonRpcRequestMessage](json) match
               case Success(request) => Right(request)
               case Failure(e)       => Left(s"conversion error: ${e.getMessage}")
-            }
           else
-            Converter.fromJson[JsonRpcNotificationMessage](json) match {
+            Converter.fromJson[JsonRpcNotificationMessage](json) match
               case Success(notification) => Right(notification)
               case Failure(e)            => Left(s"conversion error: ${e.getMessage}")
-            }
-        } else if (fields.exists(_.field == "id"))
-          Converter.fromJson[JsonRpcResponseMessage](json) match {
+        else if fields.exists(_.field == "id") then
+          Converter.fromJson[JsonRpcResponseMessage](json) match
             case Success(res) => Right(res)
             case Failure(e)   => Left(s"conversion error: ${e.getMessage}")
-          }
         else Left(s"expected JSON-RPC object but found ${new String(bytes.toArray, "UTF-8")}")
       case Success(json) =>
         Left(s"expected JSON object but found ${new String(bytes.toArray, "UTF-8")}")
       case Failure(e) =>
         Left(s"parse error: ${e.getMessage}")
-    }
-  }
+    end match
+  end deserializeJsonMessage
 
-  private[sbt] def compactPrintJsonOpt(jsonOpt: Option[JValue]): String = {
-    jsonOpt match {
+  private[sbt] def compactPrintJsonOpt(jsonOpt: Option[JValue]): String =
+    jsonOpt match
       case Some(x) => CompactPrinter(x)
       case _       => ""
-    }
-  }
-}
+end Serialization
diff --git a/protocol/src/main/scala/sbt/protocol/ServerSession.scala b/protocol/src/main/scala/sbt/protocol/ServerSession.scala
index d451485b7..edf9427d1 100644
--- a/protocol/src/main/scala/sbt/protocol/ServerSession.scala
+++ b/protocol/src/main/scala/sbt/protocol/ServerSession.scala
@@ -28,7 +28,7 @@ import sjsonnew.{ JsonReader, JsonWriter }
  *   session.shutdown(process.isAlive, () => process.destroy())
  * }}}
  */
-trait ServerSession extends AutoCloseable {
+trait ServerSession extends AutoCloseable:
 
   /** Allocates the next sequential JSON-RPC request ID (as a string). */
   def nextId(): String
@@ -132,18 +132,17 @@ trait ServerSession extends AutoCloseable {
    * @param destroy forcefully terminate the server process
    */
   def shutdown(isAlive: => Boolean, destroy: () => Unit): Try[Unit]
-}
+end ServerSession
 
-object ServerSession {
+object ServerSession:
 
-  trait SendAwaitResult[R] {
+  trait SendAwaitResult[R]:
 
     /** Sends a request and awaits the result using the default timeout. */
     def apply[A: JsonWriter](method: String, params: A): Try[R]
 
     /** Sends a request and awaits the result within the given `timeout`. */
     def apply[A: JsonWriter](method: String, params: A, timeout: FiniteDuration): Try[R]
-  }
 
   private val PortfileTimeout: FiniteDuration = 1.minute
   private val PortfileLogInterval: FiniteDuration = 10.seconds
@@ -154,10 +153,9 @@ object ServerSession {
    * @param portfile the `active.json` portfile created by the sbt server
    * @return a connected [[ServerSession]] ready for `initialize`
    */
-  def connect(portfile: File): ServerSession = {
+  def connect(portfile: File): ServerSession =
     val (socket, _) = ClientSocket.socket(portfile, false)
     new ServerSessionImpl(socket)
-  }
 
   /** Waits for the portfile using the default timeout and no logging. */
   def waitForPortfile(portfile: File, isAlive: => Boolean): Unit =
@@ -182,31 +180,27 @@ object ServerSession {
       isAlive: => Boolean,
       duration: FiniteDuration,
       log: String => Unit
-  ): Unit = {
+  ): Unit =
     def portfileIsEmpty(): Boolean =
       try IO.read(portfile).isEmpty
-      catch { case _: IOException => true }
+      catch case _: IOException => true
 
     log(s"Waiting up to $duration for sbt to be ready ...")
 
     val deadline = duration.fromNow
     var nextLog = PortfileLogInterval.fromNow
 
-    while (portfileIsEmpty() && !deadline.isOverdue() && isAlive) {
-      if (nextLog.isOverdue()) {
+    while portfileIsEmpty() && !deadline.isOverdue() && isAlive do
+      if nextLog.isOverdue() then
         log("Still waiting for sbt ...")
         nextLog = PortfileLogInterval.fromNow
-      }
       Thread.sleep(10)
-    }
 
-    if (deadline.isOverdue())
+    if deadline.isOverdue() then
       throw new TimeoutException(
         s"${portfile.getAbsolutePath} was not created within $duration"
       )
 
-    if (!isAlive)
-      throw new RuntimeException("sbt process unexpectedly terminated")
-  }
-
-}
+    if !isAlive then throw new RuntimeException("sbt process unexpectedly terminated")
+  end waitForPortfile
+end ServerSession
diff --git a/protocol/src/main/scala/sbt/protocol/ServerSessionImpl.scala b/protocol/src/main/scala/sbt/protocol/ServerSessionImpl.scala
index 02c6ff805..9335ebddc 100644
--- a/protocol/src/main/scala/sbt/protocol/ServerSessionImpl.scala
+++ b/protocol/src/main/scala/sbt/protocol/ServerSessionImpl.scala
@@ -47,7 +47,7 @@ import java.util.UUID
 private[sbt] class ServerSessionImpl(
     socket: Socket,
     threadName: String = "sbt-server-session-read-thread"
-) extends ServerSession {
+) extends ServerSession:
 
   /** Controls the read loop; set to `false` to stop reading from the socket. */
   private val running = new AtomicBoolean(true)
@@ -90,16 +90,16 @@ private[sbt] class ServerSessionImpl(
    * Each frame is deserialized and dispatched to [[onRequest]], [[onResponse]],
    * [[onNotification]], or [[onInvalidFrame]].
    */
-  private val readThread = new Thread(threadName) {
+  private val readThread = new Thread(threadName):
     setDaemon(true)
-    override def run(): Unit = {
-      try {
+    override def run(): Unit =
+      try
         val in = socket.getInputStream
         socket.setSoTimeout(ServerSessionImpl.ReadIoTimeout)
-        while (running.get) {
-          try {
+        while running.get do
+          try
             val frame = JsonRpcReader.read(in, running, onHeader = None)
-            if (running.get) {
+            if running.get then
               Serialization
                 .deserializeJsonMessage(frame)
                 .fold(
@@ -110,17 +110,10 @@ private[sbt] class ServerSessionImpl(
                     case msg: JsonRpcNotificationMessage => onNotification(msg)
                   }
                 )
-            }
-          } catch {
+          catch
             case _: SocketTimeoutException => // re-check running
             case _: IOException            => running.set(false)
-          }
-        }
-      } finally {
-        close()
-      }
-    }
-  }
+      finally close()
   readThread.start()
 
   /** Returns `true` if the session is still actively reading from the socket. */
@@ -133,52 +126,51 @@ private[sbt] class ServerSessionImpl(
    * I/O and before joining the read thread. When called from the read thread
    * itself (via the `finally` block), skips the thread join to avoid deadlock.
    */
-  override def close(): Unit = if (closed.compareAndSet(false, true)) {
+  override def close(): Unit = if closed.compareAndSet(false, true) then
     running.set(false)
-    try {
+    try
       // close() cannot deliver EOF while the read thread is parked in a native read
       socket.shutdownInput()
       out.close()
       socket.close()
-    } catch case _: IOException => ()
+    catch case _: IOException => ()
     onClose()
     if Thread.currentThread() != readThread then
       try readThread.joinFor(ServerSessionImpl.ReadThreadDestroyTimeout)
       catch case _: TimeoutException => ()
-  }
 
   override def nextId(): String = UUID.randomUUID.toString
 
   override def sendJsonRpc[A: JsonWriter](id: String, method: String, params: A): Try[Unit] =
-    for {
+    for
       converted <- Converter.toJson(params)
       _ <- sendJsonRpc(JsonRpcRequestMessage("2.0", id, method, converted))
-    } yield ()
+    yield ()
 
   override def sendJsonRpc(message: JsonRpcRequestMessage): Try[Unit] =
-    for {
+    for
       converted <- Converter.toJson(message)
       _ <- sendJsonRpcRaw(CompactPrinter(converted))
-    } yield ()
+    yield ()
 
   override def sendJsonRpcNotification[A: JsonWriter](method: String, params: A): Try[Unit] =
-    for {
+    for
       converted <- Converter.toJson(params)
       _ <- sendJsonRpcRaw(
         CompactPrinter(
           Converter.toJson(JsonRpcNotificationMessage("2.0", method, converted)).get
         )
       )
-    } yield ()
+    yield ()
 
   override def sendJsonRpcResponse[A: JsonWriter](id: String, result: A): Try[Unit] =
-    for {
+    for
       convertedResult <- Converter.toJson(result)
       convertedResponse <- Converter.toJson(
         JsonRpcResponseMessage("2.0", id, Some(convertedResult), None)
       )
       _ <- sendJsonRpcRaw(CompactPrinter(convertedResponse))
-    } yield ()
+    yield ()
 
   override def sendJsonRpcRaw(id: String, method: String, params: String): Try[Unit] =
     sendJsonRpcRaw(Serialization.serializeJsonRpcRequest(id, method, params))
@@ -194,7 +186,7 @@ private[sbt] class ServerSessionImpl(
     Try(JsonRpcWriter.write(out, message))
 
   override def sendJsonRpcAwaitResult[R: JsonReader]: ServerSession.SendAwaitResult[R] =
-    new ServerSession.SendAwaitResult[R] {
+    new ServerSession.SendAwaitResult[R]:
       override def apply[A: JsonWriter](method: String, params: A): Try[R] =
         apply(method, params, ServerSessionImpl.ResponseTimeout)
 
@@ -202,20 +194,18 @@ private[sbt] class ServerSessionImpl(
           method: String,
           params: A,
           timeout: FiniteDuration
-      ): Try[R] = {
+      ): Try[R] =
         val id = nextId()
-        for {
+        for
           _ <- sendJsonRpc(id, method, params)
           result <- waitForResultInResponseMsg[R](timeout, id)
-        } yield result
-      }
-    }
+        yield result
 
   override def initialize(
       timeout: FiniteDuration,
       subscribeToAll: Boolean
   ): Try[InitializeResult] =
-    for {
+    for
       options <- Converter
         .toJson(
           InitializeOption(
@@ -235,7 +225,7 @@ private[sbt] class ServerSessionImpl(
       )
       id = nextId()
       result <- sendJsonRpcAwaitResult[InitializeResult]("initialize", params, timeout)
-    } yield result
+    yield result
 
   /**
    * Polls a typed queue for a message that `f` maps to `Some`, discarding
@@ -252,18 +242,16 @@ private[sbt] class ServerSessionImpl(
     val deadline = duration.fromNow
     @tailrec
     def impl(): B =
-      Option(queue.poll(deadline.timeLeft.toMillis, TimeUnit.MILLISECONDS)) match {
+      Option(queue.poll(deadline.timeLeft.toMillis, TimeUnit.MILLISECONDS)) match
         case None =>
           throw new TimeoutException(s"Timeout waiting for response after $duration")
         case Some(msg) =>
-          f(msg) match {
+          f(msg) match
             case Some(result) => result
             case None         =>
-              if (deadline.isOverdue())
+              if deadline.isOverdue() then
                 throw new TimeoutException(s"Timeout waiting for response after $duration")
               else impl()
-          }
-      }
     impl()
   }
 
@@ -286,11 +274,11 @@ private[sbt] class ServerSessionImpl(
       predicate: T => Boolean
   ): Try[T] =
     pollUntil(responses, duration) { msg =>
-      for {
+      for
         result <- msg.result
         value <- Converter.fromJson[T](result).toOption
         if predicate(value)
-      } yield value
+      yield value
     }
 
   override def waitForResultInResponseMsg[T: JsonReader](
@@ -298,10 +286,9 @@ private[sbt] class ServerSessionImpl(
       id: String
   ): Try[T] =
     waitForResponseMsg(duration, id).flatMap { response =>
-      response.result match {
+      response.result match
         case Some(r) => Converter.fromJson[T](r)
         case None    => Failure(new RuntimeException(s"Response has no result: $response"))
-      }
     }
 
   override def waitForNotificationMsg(
@@ -317,45 +304,38 @@ private[sbt] class ServerSessionImpl(
       predicate: T => Boolean
   ): Try[T] =
     pollUntil(notifications, duration) { msg =>
-      for {
+      for
         params <- msg.params
         value <- Converter.fromJson[T](params).toOption
         if predicate(value)
-      } yield value
+      yield value
     }
 
-  override def shutdown(isAlive: => Boolean, destroy: () => Unit): Try[Unit] = {
-    def waitForExit(isAlive: => Boolean, timeout: FiniteDuration): Unit = {
+  override def shutdown(isAlive: => Boolean, destroy: () => Unit): Try[Unit] =
+    def waitForExit(isAlive: => Boolean, timeout: FiniteDuration): Unit =
       val deadline = timeout.fromNow
-      while (!deadline.isOverdue() && isAlive) Thread.sleep(10)
-    }
+      while !deadline.isOverdue() && isAlive do Thread.sleep(10)
 
-    val result = for {
+    val result = for
       _ <- sendJsonRpc(nextId(), "sbt/exec", SbtExecParams("shutdown"))
       _ = waitForExit(isAlive, ServerSessionImpl.GracefulShutdownTimeout)
-      _ = if (isAlive) {
+      _ = if isAlive then
         destroy()
         waitForExit(isAlive, ServerSessionImpl.DestroyTimeout)
-      }
 
       _ <-
-        if (isAlive) {
-          Failure(new IllegalStateException("sbt process failed to exit"))
-        } else {
-          Success(())
-        }
-    } yield ()
+        if isAlive then Failure(new IllegalStateException("sbt process failed to exit"))
+        else Success(())
+    yield ()
 
     close()
 
     result
-  }
-}
+end ServerSessionImpl
 
-private[sbt] object ServerSessionImpl {
+private[sbt] object ServerSessionImpl:
   val ReadIoTimeout: Int = 5000 // ms
   val ReadThreadDestroyTimeout: FiniteDuration = 1.seconds
   val ResponseTimeout: FiniteDuration = 1.minutes
   val GracefulShutdownTimeout: FiniteDuration = 5.seconds
   val DestroyTimeout: FiniteDuration = 10.seconds
-}
diff --git a/protocol/src/test/scala/sbt/internal/bsp/BuildServerConnectionSpec.scala b/protocol/src/test/scala/sbt/internal/bsp/BuildServerConnectionSpec.scala
index df86b7216..73cefb3f7 100644
--- a/protocol/src/test/scala/sbt/internal/bsp/BuildServerConnectionSpec.scala
+++ b/protocol/src/test/scala/sbt/internal/bsp/BuildServerConnectionSpec.scala
@@ -60,3 +60,4 @@ object BuildServerConnectionSpec extends BasicTestSuite:
     assert(argv.contains("-Xmx100m"), s"argv should contain -Xmx100m, got: $argv")
     assert(argv.contains("-classpath"), s"argv should contain -classpath, got: $argv")
     assert(argv.contains("xsbt.boot.Boot"), s"argv should contain xsbt.boot.Boot, got: $argv")
+end BuildServerConnectionSpec
diff --git a/protocol/src/test/scala/sbt/protocol/ClientSocketDuplexTest.scala b/protocol/src/test/scala/sbt/protocol/ClientSocketDuplexTest.scala
index 604a4d954..77d24bf6e 100644
--- a/protocol/src/test/scala/sbt/protocol/ClientSocketDuplexTest.scala
+++ b/protocol/src/test/scala/sbt/protocol/ClientSocketDuplexTest.scala
@@ -111,6 +111,7 @@ object ClientSocketDuplexTest extends Properties:
                         .log("client received a different payload than the server sent"),
                     )
                   )
+            end if
 
   private def readNBytes(in: InputStream, n: Int): Array[Byte] =
     val buf = new Array[Byte](n)
diff --git a/protocol/src/test/scala/sbt/protocol/ServerSessionImplSpec.scala b/protocol/src/test/scala/sbt/protocol/ServerSessionImplSpec.scala
index 9f0acbc47..7566488c4 100644
--- a/protocol/src/test/scala/sbt/protocol/ServerSessionImplSpec.scala
+++ b/protocol/src/test/scala/sbt/protocol/ServerSessionImplSpec.scala
@@ -22,10 +22,10 @@ object ServerSessionImplSpec extends BasicTestSuite:
       val path = Files.createTempDirectory("session-eof").resolve("sock")
       val server = UnixDomainServerSocket(path.toString, false)
       val peerResult = new LinkedBlockingQueue[Integer]
-      val accepted = new Thread(() => {
+      val accepted = new Thread(() =>
         val conn = server.accept()
         peerResult.put(conn.getInputStream.read())
-      })
+      )
       accepted.setDaemon(true)
       accepted.start()
       val session = new ServerSessionImpl(UnixDomainSocket(path.toString, false))
diff --git a/run/src/main/scala/sbt/Fork.scala b/run/src/main/scala/sbt/Fork.scala
index 1bb934f29..1cf4db4b6 100644
--- a/run/src/main/scala/sbt/Fork.scala
+++ b/run/src/main/scala/sbt/Fork.scala
@@ -27,7 +27,7 @@ import java.util.Locale
  * @param runnerClass
  *   If Some, this will be prepended to the `arguments` passed to the `apply` or `fork` methods.
  */
-final class Fork(val commandName: String, val runnerClass: Option[String]) {
+final class Fork(val commandName: String, val runnerClass: Option[String]):
 
   /**
    * Forks the configured process, waits for it to complete, and returns the exit code. The command
@@ -67,14 +67,11 @@ final class Fork(val commandName: String, val runnerClass: Option[String]) {
     val (classpathEnv, options) = Fork.fitClasspath(preOptions)
     val command = executable +: options
     val jpb =
-      if (
-        config.canUseArgumentsFile.getOrElse(false) &&
+      if config.canUseArgumentsFile.getOrElse(false) &&
         Fork.booleanOpt("sbt.argsfile").getOrElse(true) &&
         Fork.shouldUseArgumentsFile(options)
-      )
-        new JProcessBuilder(executable, Fork.createArgumentsFile(options))
-      else
-        new JProcessBuilder(command.toArray*)
+      then new JProcessBuilder(executable, Fork.createArgumentsFile(options))
+      else new JProcessBuilder(command.toArray*)
     val extraEnv = classpathEnv.toList.map { value =>
       Fork.ClasspathEnvKey -> value
     }
@@ -84,15 +81,14 @@ final class Fork(val commandName: String, val runnerClass: Option[String]) {
       jvmOptions: Seq[String],
       bootJars: Iterable[File],
       arguments: Seq[String]
-  ): Seq[String] = {
+  ): Seq[String] =
     val boot =
-      if (bootJars.isEmpty) none[String]
+      if bootJars.isEmpty then none[String]
       else
         ("-Xbootclasspath/a:" + bootJars.map(_.getAbsolutePath).mkString(File.pathSeparator)).some
     jvmOptions ++ boot.toList ++ runnerClass.toList ++ arguments
-  }
-}
-object Fork {
+end Fork
+object Fork:
   private val ScalacMainClass = "scala.tools.nsc.Main"
   private val ScalaMainClass = "scala.tools.nsc.MainGenericRunner"
   private val JavaCommandName = "java"
@@ -115,45 +111,38 @@ object Fork {
   private val MaxConcatenatedOptionLength = 5000
 
   private def fitClasspath(options: Seq[String]): (Option[String], Seq[String]) =
-    if (Util.isWindows && optionsTooLong(options))
-      convertClasspathToEnv(options)
-    else
-      (None, options)
+    if Util.isWindows && optionsTooLong(options) then convertClasspathToEnv(options)
+    else (None, options)
   private def optionsTooLong(options: Seq[String]): Boolean =
     options.mkString(" ").length > MaxConcatenatedOptionLength
 
-  private def convertClasspathToEnv(options: Seq[String]): (Option[String], Seq[String]) = {
+  private def convertClasspathToEnv(options: Seq[String]): (Option[String], Seq[String]) =
     val (preCP, cpAndPost) = options.span(opt => !isClasspathOption(opt))
     val postCP = cpAndPost.drop(2)
     val classpathOption = cpAndPost.drop(1).headOption
-    val newOptions = if (classpathOption.isDefined) preCP ++ postCP else options
+    val newOptions = if classpathOption.isDefined then preCP ++ postCP else options
     (classpathOption, newOptions)
-  }
 
-  private[sbt] def javaCommand(javaHome: Option[File], name: String): File = {
+  private[sbt] def javaCommand(javaHome: Option[File], name: String): File =
     val home = javaHome.getOrElse(new File(System.getProperty("java.home")))
     new File(new File(home, "bin"), name)
-  }
 
   /* copied from SysProp.scala for consistency while avoiding
    * introducing a circular dependency
    */
   private def parseBoolean(value: String): Option[Boolean] =
-    value.toLowerCase(Locale.ENGLISH) match {
+    value.toLowerCase(Locale.ENGLISH) match
       case "1" | "always" | "true" => Some(true)
       case "0" | "never" | "false" => Some(false)
       case "auto"                  => None
       case _                       => None
-    }
   private def booleanOpt(name: String): Option[Boolean] =
-    sys.props.get(name) match {
+    sys.props.get(name) match
       case Some(x) => parseBoolean(x)
       case _       =>
-        sys.env.get(name.toUpperCase(Locale.ENGLISH).replace('.', '_')) match {
+        sys.env.get(name.toUpperCase(Locale.ENGLISH).replace('.', '_')) match
           case Some(x) => parseBoolean(x)
           case _       => None
-        }
-    }
 
   /**
    * Use an arguments file if:
@@ -171,7 +160,7 @@ object Fork {
    * @param options command line options to write to the args file
    * @return
    */
-  private def createArgumentsFile(options: Seq[String]): String = {
+  private def createArgumentsFile(options: Seq[String]): String =
     val file = File.createTempFile(s"sbt-args", ".tmp")
     file.deleteOnExit()
 
@@ -185,21 +174,19 @@ object Fork {
     pw.flush()
     pw.close()
     s"@${file.getAbsolutePath}"
-  }
 
   private[sbt] def forkInternal(
       config: ForkOptions,
       extraEnv: List[(String, String)],
       jpb: JProcessBuilder
-  ): Process = {
+  ): Process =
     import config.{ envVars as env, * }
     val environment: List[(String, String)] = env.toList ++ extraEnv
     workingDirectory.foreach(jpb.directory(_))
     environment.foreach { case (k, v) => jpb.environment.put(k, v) }
-    if (connectInput) {
+    if connectInput then
       jpb.redirectInput(Redirect.INHERIT)
       ()
-    }
     val process = Process(jpb)
     outputStrategy.getOrElse(StdoutOutput: OutputStrategy) match
       case StdoutOutput        => process.run(connectInput = false)
@@ -208,7 +195,6 @@ object Fork {
       case out: LoggedOutput      => process.run(out.logger, connectInput = false)
       case out: CustomOutput      => (process #> out.output).run(connectInput = false)
       case out: CustomInputOutput => process.run(out.processIO)
-  }
 
   private[sbt] def forkInternalInteractive(
       config: ForkOptions,
@@ -222,23 +208,19 @@ object Fork {
     jpb.inheritIO()
     jpb.start()
 
-  private[sbt] def blockJForExitCode(p: JProcess): Int = {
+  private[sbt] def blockJForExitCode(p: JProcess): Int =
     RunningProcesses.add(p)
     try
       p.waitFor()
       p.exitValue()
-    finally {
-      if (p.isAlive()) p.destroy()
+    finally
+      if p.isAlive() then p.destroy()
       RunningProcesses.remove(p)
-    }
-  }
 
-  private[sbt] def blockForExitCode(p: Process): Int = {
+  private[sbt] def blockForExitCode(p: Process): Int =
     RunningProcesses.add(p)
     try p.exitValue()
-    finally {
-      if (p.isAlive()) p.destroy()
+    finally
+      if p.isAlive() then p.destroy()
       RunningProcesses.remove(p)
-    }
-  }
-}
+end Fork
diff --git a/run/src/main/scala/sbt/OutputStrategy.scala b/run/src/main/scala/sbt/OutputStrategy.scala
index 6d0a6fdf7..0655fe5bb 100644
--- a/run/src/main/scala/sbt/OutputStrategy.scala
+++ b/run/src/main/scala/sbt/OutputStrategy.scala
@@ -15,7 +15,7 @@ import java.io.OutputStream
 /** Configures where the standard output and error streams from a forked process go. */
 sealed abstract class OutputStrategy
 
-object OutputStrategy {
+object OutputStrategy:
 
   /**
    * Configures the forked standard output to go to standard output of this process and for the
@@ -28,53 +28,39 @@ object OutputStrategy {
    * `error` level. The output is buffered until the process completes, at which point the logger
    * flushes it (to the screen, for example).
    */
-  final class BufferedOutput private (val logger: Logger) extends OutputStrategy with Serializable {
-    override def equals(o: Any): Boolean = o match {
+  final class BufferedOutput private (val logger: Logger) extends OutputStrategy with Serializable:
+    override def equals(o: Any): Boolean = o match
       case x: BufferedOutput => (this.logger == x.logger)
       case _                 => false
-    }
-    override def hashCode: Int = {
+    override def hashCode: Int =
       37 * (17 + logger.##) + "BufferedOutput".##
-    }
-    override def toString: String = {
+    override def toString: String =
       "BufferedOutput(" + logger + ")"
-    }
-    private def copy(logger: Logger): BufferedOutput = {
+    private def copy(logger: Logger): BufferedOutput =
       new BufferedOutput(logger)
-    }
-    def withLogger(logger: Logger): BufferedOutput = {
+    def withLogger(logger: Logger): BufferedOutput =
       copy(logger = logger)
-    }
-  }
-  object BufferedOutput {
+  object BufferedOutput:
     def apply(logger: Logger): BufferedOutput = new BufferedOutput(logger)
-  }
 
   /**
    * Logs the forked standard output at the `info` level and the forked standard error at the
    * `error` level.
    */
-  final class LoggedOutput private (val logger: Logger) extends OutputStrategy with Serializable {
-    override def equals(o: Any): Boolean = o match {
+  final class LoggedOutput private (val logger: Logger) extends OutputStrategy with Serializable:
+    override def equals(o: Any): Boolean = o match
       case x: LoggedOutput => (this.logger == x.logger)
       case _               => false
-    }
-    override def hashCode: Int = {
+    override def hashCode: Int =
       37 * (17 + logger.##) + "LoggedOutput".##
-    }
-    override def toString: String = {
+    override def toString: String =
       "LoggedOutput(" + logger + ")"
-    }
-    private def copy(logger: Logger): LoggedOutput = {
+    private def copy(logger: Logger): LoggedOutput =
       new LoggedOutput(logger)
-    }
-    def withLogger(logger: Logger): LoggedOutput = {
+    def withLogger(logger: Logger): LoggedOutput =
       copy(logger = logger)
-    }
-  }
-  object LoggedOutput {
+  object LoggedOutput:
     def apply(logger: Logger): LoggedOutput = new LoggedOutput(logger)
-  }
 
   /**
    * Configures the forked standard output to be sent to `output` and the forked standard error to
@@ -82,27 +68,20 @@ object OutputStrategy {
    */
   final class CustomOutput private (val output: OutputStream)
       extends OutputStrategy
-      with Serializable {
-    override def equals(o: Any): Boolean = o match {
+      with Serializable:
+    override def equals(o: Any): Boolean = o match
       case x: CustomOutput => (this.output == x.output)
       case _               => false
-    }
-    override def hashCode: Int = {
+    override def hashCode: Int =
       37 * (17 + output.##) + "CustomOutput".##
-    }
-    override def toString: String = {
+    override def toString: String =
       "CustomOutput(" + output + ")"
-    }
-    private def copy(output: OutputStream): CustomOutput = {
+    private def copy(output: OutputStream): CustomOutput =
       new CustomOutput(output)
-    }
-    def withOutput(output: OutputStream): CustomOutput = {
+    def withOutput(output: OutputStream): CustomOutput =
       copy(output = output)
-    }
-  }
-  object CustomOutput {
+  object CustomOutput:
     def apply(output: OutputStream): CustomOutput = new CustomOutput(output)
-  }
 
   /**
    * Configures the forked IO.
@@ -127,4 +106,4 @@ object OutputStrategy {
   object CustomInputOutput:
     def apply(processIO: ProcessIO): CustomInputOutput = new CustomInputOutput(processIO)
   end CustomInputOutput
-}
+end OutputStrategy
diff --git a/run/src/main/scala/sbt/Run.scala b/run/src/main/scala/sbt/Run.scala
index 02ea8cd72..4711225e5 100644
--- a/run/src/main/scala/sbt/Run.scala
+++ b/run/src/main/scala/sbt/Run.scala
@@ -25,32 +25,30 @@ import scala.util.{ Failure, Properties, Success, Try }
 sealed trait ScalaRun:
   def run(mainClass: String, classpath: Seq[NioPath], options: Seq[String], log: Logger): Try[Unit]
 
-class ForkRun(config: ForkOptions) extends ScalaRun {
+class ForkRun(config: ForkOptions) extends ScalaRun:
   def run(
       mainClass: String,
       classpath: Seq[NioPath],
       options: Seq[String],
       log: Logger
-  ): Try[Unit] = {
+  ): Try[Unit] =
     log.info(s"running (fork) $mainClass ${Run.runOptionsStr(options)}")
     val c = configLogged(log)
     val scalaOpts = scalaOptions(mainClass, classpath, options)
     val exitCode =
       try Fork.java(c, scalaOpts)
-      catch {
+      catch
         case _: InterruptedException =>
           log.warn("run canceled")
           1
-      }
     Run.processExitCode(exitCode, "runner")
-  }
 
   def fork(
       mainClass: String,
       classpath: Seq[NioPath],
       options: Seq[String],
       log: Logger
-  ): Process = {
+  ): Process =
     log.info(s"running (fork) $mainClass ${Run.runOptionsStr(options)}")
 
     val c = configLogged(log)
@@ -58,12 +56,10 @@ class ForkRun(config: ForkOptions) extends ScalaRun {
 
     // fork with Java because Scala introduces an extra class loader (#702)
     Fork.java.fork(c, scalaOpts)
-  }
 
-  private def configLogged(log: Logger): ForkOptions = {
-    if (config.outputStrategy.isDefined || config.connectInput) config
+  private def configLogged(log: Logger): ForkOptions =
+    if config.outputStrategy.isDefined || config.connectInput then config
     else config.withOutputStrategy(OutputStrategy.LoggedOutput(log))
-  }
 
   private def scalaOptions(
       mainClass: String,
@@ -71,10 +67,10 @@ class ForkRun(config: ForkOptions) extends ScalaRun {
       options: Seq[String],
   ): Seq[String] =
     "-classpath" :: Path.makeString(classpath.map(_.toFile())) :: mainClass :: options.toList
-}
+end ForkRun
 
 class Run(private[sbt] val newLoader: Seq[NioPath] => ClassLoader, trapExit: Boolean)
-    extends ScalaRun {
+    extends ScalaRun:
   def this(instance: ScalaInstance, trapExit: Boolean, nativeTmp: File) =
     this(
       (cp: Seq[NioPath]) => ClasspathUtil.makeLoader(cp, instance, nativeTmp.toPath),
@@ -87,20 +83,20 @@ class Run(private[sbt] val newLoader: Seq[NioPath] => ClassLoader, trapExit: Boo
       mainClass: String,
       options: Seq[String],
       log: Logger
-  ): Try[Unit] = {
+  ): Try[Unit] =
     log.info(s"running $mainClass ${Run.runOptionsStr(options)}")
 
     def execute(): Unit =
-      try {
+      try
         log.debug("  Classpath:\n\t" + classpath.mkString("\n\t"))
         val main = detectMainMethod(mainClass, loader)
         invokeMain(loader, main, options)
-      } catch {
+      catch
         case e: java.lang.reflect.InvocationTargetException =>
-          e.getCause match {
+          e.getCause match
             case ex: ClassNotFoundException =>
               val className = ex.getMessage
-              try {
+              try
                 loader.loadClass(className)
                 val msg =
                   s"$className is on the project classpath but not visible to the ClassLoader " +
@@ -108,11 +104,10 @@ class Run(private[sbt] val newLoader: Seq[NioPath] => ClassLoader, trapExit: Boo
                     "See https://www.scala-sbt.org/1.x/docs/In-Process-Classloaders.html for " +
                     "further information."
                 log.error(msg)
-              } catch { case NonFatal(_) => }
+              catch
+                case NonFatal(_) =>
               throw ex
             case ex => throw ex
-          }
-      }
     def directExecute(): Try[Unit] =
       Try(execute()) recover { case NonFatal(e) =>
         // bgStop should not print out stack trace
@@ -120,9 +115,9 @@ class Run(private[sbt] val newLoader: Seq[NioPath] => ClassLoader, trapExit: Boo
         throw e
       }
 
-    if (trapExit) Run.executeSuccess(execute())
+    if trapExit then Run.executeSuccess(execute())
     else directExecute()
-  }
+  end runWithLoader
 
   /** Runs the class 'mainClass' using the given classpath and options using the scala runner. */
   def run(
@@ -130,7 +125,7 @@ class Run(private[sbt] val newLoader: Seq[NioPath] => ClassLoader, trapExit: Boo
       classpath: Seq[NioPath],
       options: Seq[String],
       log: Logger
-  ): Try[Unit] = {
+  ): Try[Unit] =
     val loader = newLoader(classpath)
     try runWithLoader(loader, classpath, mainClass, options, log)
     finally
@@ -138,35 +133,29 @@ class Run(private[sbt] val newLoader: Seq[NioPath] => ClassLoader, trapExit: Boo
         case ac: AutoCloseable  => ac.close()
         case c: ClasspathFilter => c.close()
         case _                  =>
-  }
   private def invokeMain(
       loader: ClassLoader,
       main: DetectedMain,
       options: Seq[String]
-  ): Unit = {
+  ): Unit =
     val currentThread = Thread.currentThread
     val oldLoader = Thread.currentThread.getContextClassLoader
     currentThread.setContextClassLoader(loader)
-    try {
-      if (main.isStatic) {
-        if (Run.isJava25Plus) {
-          main.method.setAccessible(true)
-        }
-        if (main.parameterCount > 0) main.method.invoke(null, options.toArray[String])
+    try
+      if main.isStatic then
+        if Run.isJava25Plus then main.method.setAccessible(true)
+        if main.parameterCount > 0 then main.method.invoke(null, options.toArray[String])
         else main.method.invoke(null)
-      } else {
+      else
         val constructor = main.mainClass.getDeclaredConstructor()
-        if (Run.isJava25Plus) {
-          constructor.setAccessible(true)
-        }
+        if Run.isJava25Plus then constructor.setAccessible(true)
         val ref = constructor.newInstance().asInstanceOf[AnyRef]
-        if (main.parameterCount > 0) main.method.invoke(ref, options.toArray[String])
+        if main.parameterCount > 0 then main.method.invoke(ref, options.toArray[String])
         else main.method.invoke(ref)
-      }
       ()
-    } catch {
+    catch
       case t: Throwable =>
-        t.getCause match {
+        t.getCause match
           case e: java.lang.IllegalAccessError =>
             val msg = s"Error running $main.\n$e\n" +
               "If using a layered classloader, this can occur if jvm package private classes are " +
@@ -174,60 +163,51 @@ class Run(private[sbt] val newLoader: Seq[NioPath] => ClassLoader, trapExit: Boo
               "ScalaInstance class loader layering strategies."
             throw new IllegalAccessError(msg)
           case _ => throw t
-        }
-    } finally {
-      currentThread.setContextClassLoader(oldLoader)
-    }
-  }
+    finally currentThread.setContextClassLoader(oldLoader)
+    end try
+  end invokeMain
   def getMainMethod(mainClassName: String, loader: ClassLoader): Method =
     detectMainMethod(mainClassName, loader).method
 
-  private def detectMainMethod(mainClassName: String, loader: ClassLoader) = {
+  private def detectMainMethod(mainClassName: String, loader: ClassLoader) =
     val mainClass = Class.forName(mainClassName, true, loader)
-    if (Run.isJava25Plus) {
+    if Run.isJava25Plus then
       val method =
-        try {
-          mainClass.getMethod("main", classOf[Array[String]])
-        } catch {
+        try mainClass.getMethod("main", classOf[Array[String]])
+        catch
           case _: NoSuchMethodException =>
-            try {
-              mainClass.getMethod("main")
-            } catch {
+            try mainClass.getMethod("main")
+            catch
               case _: NoSuchMethodException =>
-                try {
-                  mainClass.getDeclaredMethod("main", classOf[Array[String]])
-                } catch {
+                try mainClass.getDeclaredMethod("main", classOf[Array[String]])
+                catch
                   case _: NoSuchMethodException =>
                     mainClass.getDeclaredMethod("main")
-                }
-            }
-        }
       val modifiers = method.getModifiers
-      if (isPrivate(modifiers)) {
+      if isPrivate(modifiers) then
         throw new NoSuchMethodException(s"${mainClassName}.main is private")
-      }
       method.setAccessible(true)
       DetectedMain(mainClass, method, isStatic(modifiers), method.getParameterCount())
-    } else {
+    else
       val method = mainClass.getMethod("main", classOf[Array[String]])
       // jvm allows the actual main class to be non-public and to run a method in the non-public class,
       //  we need to make it accessible
       method.setAccessible(true)
       val modifiers = method.getModifiers
-      if (!isPublic(modifiers))
+      if !isPublic(modifiers) then
         throw new NoSuchMethodException(mainClassName + ".main is not public")
-      if (!isStatic(modifiers))
+      if !isStatic(modifiers) then
         throw new NoSuchMethodException(mainClassName + ".main is not static")
       DetectedMain(mainClass, method, isStatic = true, method.getParameterCount())
-    }
-  }
+    end if
+  end detectMainMethod
   private case class DetectedMain(
       mainClass: Class[?],
       method: Method,
       isStatic: Boolean,
       parameterCount: Int
   )
-}
+end Run
 
 /** This module is an interface to starting the scala interpreter or runner. */
 object Run:
@@ -236,10 +216,9 @@ object Run:
   ) =
     runner.run(mainClass, classpath, options, log)
 
-  private[sbt] def executeSuccess(f: => Unit): Try[Unit] = {
+  private[sbt] def executeSuccess(f: => Unit): Try[Unit] =
     f
     Success(())
-  }
 
   // quotes the option that includes a whitespace
   // https://github.com/sbt/sbt/issues/4834
@@ -250,7 +229,7 @@ object Run:
     }).mkString(" ")
 
   private[sbt] def processExitCode(exitCode: Int, label: String): Try[Unit] =
-    if (exitCode == 0) Success(())
+    if exitCode == 0 then Success(())
     else
       Failure(
         new MessageOnlyException(
diff --git a/run/src/main/scala/sbt/SelectMainClass.scala b/run/src/main/scala/sbt/SelectMainClass.scala
index 459ff247b..9a5492ebf 100644
--- a/run/src/main/scala/sbt/SelectMainClass.scala
+++ b/run/src/main/scala/sbt/SelectMainClass.scala
@@ -12,18 +12,18 @@ import sbt.internal.util.ConsoleAppender.ClearScreenAfterCursor
 import sbt.internal.util.Util.*
 import scala.annotation.tailrec
 
-object SelectMainClass {
+object SelectMainClass:
   // Some(SimpleReader.readLine _)
   def apply(
       promptIfMultipleChoices: Option[String => Option[String]],
       mainClasses: Seq[String]
-  ): Option[String] = {
-    mainClasses.toList match {
+  ): Option[String] =
+    mainClasses.toList match
       case Nil         => None
       case head :: Nil => Some(head)
       case multiple    =>
         promptIfMultipleChoices.flatMap { prompt =>
-          @tailrec def loop(): Option[String] = {
+          @tailrec def loop(): Option[String] =
             val header = "\nMultiple main classes detected. Select one to run:\n"
             val classes = multiple.zipWithIndex
               .map { (className, index) => s" [${index + 1}] $className" }
@@ -31,29 +31,23 @@ object SelectMainClass {
             println(ClearScreenAfterCursor + header + classes + "\n")
             val line = trim(prompt("Enter number: "))
             // An empty line usually means the user typed <ctrl+c>
-            if (line.nonEmpty) {
-              toInt(line, multiple.length) map multiple.apply match {
+            if line.nonEmpty then
+              toInt(line, multiple.length) map multiple.apply match
                 case None => loop()
                 case r    => r
-              }
-            } else None
-          }
+            else None
           loop()
         }
-    }
-  }
   private def trim(s: Option[String]) = s.getOrElse("")
   private def toInt(s: String, size: Int): Option[Int] =
-    try {
+    try
       val i = s.toInt
-      if (i > 0 && i <= size) (i - 1).some
-      else {
+      if i > 0 && i <= size then (i - 1).some
+      else
         println("Number out of range: was " + i + ", expected number between 1 and " + size)
         none
-      }
-    } catch {
+    catch
       case nfe: NumberFormatException =>
         println(s"Invalid number: '$s'")
         none
-    }
-}
+end SelectMainClass
diff --git a/run/src/main/scala/sbt/TrapExit.scala b/run/src/main/scala/sbt/TrapExit.scala
index 49ef8392a..76e5bfe1e 100644
--- a/run/src/main/scala/sbt/TrapExit.scala
+++ b/run/src/main/scala/sbt/TrapExit.scala
@@ -21,7 +21,7 @@ import sbt.util.Logger
  * concurrent AWT applications are run. This category of code should only be called by forking a new
  * JVM.
  */
-object TrapExit {
+object TrapExit:
 
   /**
    * Run `execute` in a managed context, using `log` for debugging messages. `installManager` must
@@ -43,15 +43,13 @@ object TrapExit {
   @deprecated("TrapExit feature is removed; just call the function instead", "1.6.0")
   def uninstallManager(previous: Any): Unit = ()
 
-  private def runUnmanaged(execute: => Unit, log: Logger): Int = {
+  private def runUnmanaged(execute: => Unit, log: Logger): Int =
     log.warn("Managed execution not possible: security manager not installed.")
-    try {
+    try
       execute; 0
-    } catch {
+    catch
       case e: Exception =>
         log.error("Error during execution: " + e.toString)
         log.trace(e)
         1
-    }
-  }
-}
+end TrapExit
diff --git a/run/src/test/scala/sbt/ForkTest.scala b/run/src/test/scala/sbt/ForkTest.scala
index 68fc24aa4..17d48f6f4 100644
--- a/run/src/test/scala/sbt/ForkTest.scala
+++ b/run/src/test/scala/sbt/ForkTest.scala
@@ -18,7 +18,7 @@ import sbt.io.{ IO, Path }
 import OutputStrategy.*
 import sbt.internal.util.Util.*
 
-object ForkTest extends Properties("Fork") {
+object ForkTest extends Properties("Fork"):
 
   /**
    * Heuristic for limiting the length of the classpath string. Longer than this will hit hard
@@ -52,8 +52,8 @@ object ForkTest extends Properties("Fork") {
             val config = ForkOptions().withOutputStrategy(LoggedOutput(log))
             val exitCode =
               try Fork.java(config, args)
-              catch { case e: Exception => e.printStackTrace; 1 }
-            val expectedCode = if (optionName.isEmpty) 1 else 0
+              catch case e: Exception => e.printStackTrace; 1
+            val expectedCode = if optionName.isEmpty then 1 else 0
             s"temporary directory: ${dir.getAbsolutePath}" |:
               s"required classpath: ${requiredEntries.mkString("\n\t", "\n\t", "")}" |:
               s"main and args: ${mainAndArgs.mkString(" ")}" |:
@@ -64,7 +64,7 @@ object ForkTest extends Properties("Fork") {
         }
     }
 
-  property("Arguments with double quotes preserved in arguments file mode.") = {
+  property("Arguments with double quotes preserved in arguments file mode.") =
     val baos = new java.io.ByteArrayOutputStream()
     val jsonArg = """{"a":1}"""
     // Pad JVM options to exceed MaxConcatenatedOptionLength (5000) and trigger argsfile mode
@@ -76,33 +76,26 @@ object ForkTest extends Properties("Fork") {
       .withCanUseArgumentsFile(true)
     val exitCode =
       try Fork.java(config, args)
-      catch { case e: Exception => e.printStackTrace(); 1 }
+      catch case e: Exception => e.printStackTrace(); 1
     val output = baos.toString("UTF-8").trim
     s"exitCode: $exitCode" |:
       s"output: '$output', expected: '$jsonArg'" |:
       (exitCode == 0) && (output == jsonArg)
-  }
 
   private def trimClasspath(cp: String): String =
-    if (cp.length > MaximumClasspathLength) {
+    if cp.length > MaximumClasspathLength then
       val lastEntryI = cp.lastIndexOf(File.pathSeparatorChar.toInt, MaximumClasspathLength)
-      if (lastEntryI > 0)
-        cp.substring(0, lastEntryI)
-      else
-        cp
-    } else cp
-}
+      if lastEntryI > 0 then cp.substring(0, lastEntryI)
+      else cp
+    else cp
+end ForkTest
 
 // Object used in the tests
-object exit {
-  def main(args: Array[String]): Unit = {
+object exit:
+  def main(args: Array[String]): Unit =
     System.exit(java.lang.Integer.parseInt(args(0)))
-  }
-}
 
 // Echoes each argument on its own line, used to verify argument passing
-object echoArgs {
-  def main(args: Array[String]): Unit = {
+object echoArgs:
+  def main(args: Array[String]): Unit =
     args.foreach(println)
-  }
-}
diff --git a/run/src/test/scala/sbt/TestLogger.scala b/run/src/test/scala/sbt/TestLogger.scala
index 712645269..23d46e775 100644
--- a/run/src/test/scala/sbt/TestLogger.scala
+++ b/run/src/test/scala/sbt/TestLogger.scala
@@ -12,10 +12,8 @@ package internal
 import sbt.internal.util.*
 import sbt.util.*
 
-object TestLogger {
-  def apply[T](f: Logger => T): T = {
+object TestLogger:
+  def apply[T](f: Logger => T): T =
     val log = new BufferedLogger(ConsoleLogger())
     log.setLevel(Level.Debug)
     log.bufferQuietly(f(log))
-  }
-}
diff --git a/sbt-app/src/main/scala/package.scala b/sbt-app/src/main/scala/package.scala
index 4db636e1c..43794256e 100644
--- a/sbt-app/src/main/scala/package.scala
+++ b/sbt-app/src/main/scala/package.scala
@@ -58,11 +58,10 @@ package object sbt
   given singleFileJsonFormatter: JsonFormat[File] = FileStamp.Formats.fileJsonFormatter
   // others
 
-  object CompileOrder {
+  object CompileOrder:
     val JavaThenScala = xsbti.compile.CompileOrder.JavaThenScala
     val ScalaThenJava = xsbti.compile.CompileOrder.ScalaThenJava
     val Mixed = xsbti.compile.CompileOrder.Mixed
-  }
   type CompileOrder = xsbti.compile.CompileOrder
 
   final val ThisScope = Scope.ThisScope
diff --git a/sbt-app/src/main/scala/sbt/AllSyntax.scala b/sbt-app/src/main/scala/sbt/AllSyntax.scala
index 3e25cb4c4..3bc829716 100644
--- a/sbt-app/src/main/scala/sbt/AllSyntax.scala
+++ b/sbt-app/src/main/scala/sbt/AllSyntax.scala
@@ -8,9 +8,7 @@
 
 package sbt
 
-private[sbt] trait IOSyntax0 extends IOSyntax1 {
-  extension [A, B](f: A => Option[B]) {
+private[sbt] trait IOSyntax0 extends IOSyntax1:
+  extension [A, B](f: A => Option[B])
     def |(g: A => Option[B]): A => Option[B] = (a: A) => f(a) orElse g(a)
-  }
-}
 private[sbt] sealed trait IOSyntax1 extends sbt.io.IOSyntax with sbt.nio.file.syntax0
diff --git a/sbt-app/src/main/scala/sbt/Import.scala b/sbt-app/src/main/scala/sbt/Import.scala
index dc3106baa..c4f5816f7 100644
--- a/sbt-app/src/main/scala/sbt/Import.scala
+++ b/sbt-app/src/main/scala/sbt/Import.scala
@@ -8,7 +8,7 @@
 
 package sbt
 
-trait Import {
+trait Import:
   type Settings = Def.Settings
   type Setting[T] = Def.Setting[T]
   type ScopedKey[T] = Def.ScopedKey[T]
@@ -211,7 +211,7 @@ trait Import {
   // type ~>[-K[_], +V[_]] = sbt.internal.util.~>[K, V]
 
   // sbt.internal.util.complete
-  object complete {
+  object complete:
     val Completion = sbt.internal.util.complete.Completion
     type Completion = sbt.internal.util.complete.Completion
     val Completions = sbt.internal.util.complete.Completions
@@ -244,7 +244,7 @@ trait Import {
     type TypeString = sbt.internal.util.complete.TypeString
     val UpperBound = sbt.internal.util.complete.UpperBound
     type UpperBound = sbt.internal.util.complete.UpperBound
-  }
+  end complete
 
   // sbt.librarymanagement
   val Artifact = sbt.librarymanagement.Artifact
@@ -368,4 +368,4 @@ trait Import {
   type FileConverter = xsbti.FileConverter
   type HashedVirtualFileRef = xsbti.HashedVirtualFileRef
   type IncOptions = xsbti.compile.IncOptions
-}
+end Import
diff --git a/sbt-app/src/test/scala/sbt/RunFromSourceMain.scala b/sbt-app/src/test/scala/sbt/RunFromSourceMain.scala
index 4111cc73f..5223497fd 100644
--- a/sbt-app/src/test/scala/sbt/RunFromSourceMain.scala
+++ b/sbt-app/src/test/scala/sbt/RunFromSourceMain.scala
@@ -17,17 +17,16 @@ import scala.annotation.tailrec
 import scala.sys.process.Process
 import scala.util.Using
 
-object RunFromSourceMain {
+object RunFromSourceMain:
   def fork(
       workingDirectory: File,
       scalaVersion: String,
       sbtVersion: String,
       classpath: Seq[File]
-  ): Process = {
+  ): Process =
     val fo = ForkOptions()
       .withOutputStrategy(OutputStrategy.StdoutOutput)
     fork(fo, workingDirectory, scalaVersion, sbtVersion, classpath)
-  }
 
   def fork(
       fo0: ForkOptions,
@@ -35,13 +34,13 @@ object RunFromSourceMain {
       scalaVersion: String,
       sbtVersion: String,
       cp: Seq[File]
-  ): Process = {
+  ): Process =
     val fo = fo0
       .withWorkingDirectory(workingDirectory)
-      .withRunJVMOptions((sys.props.get("sbt.ivy.home") match {
+      .withRunJVMOptions((sys.props.get("sbt.ivy.home") match
         case Some(home) => Vector(s"-Dsbt.ivy.home=$home")
         case _          => Vector()
-      }) ++ fo0.runJVMOptions)
+      ) ++ fo0.runJVMOptions)
     val runner = new ForkRun(fo)
     val options =
       Vector(workingDirectory.toString, scalaVersion, sbtVersion, cp.mkString(pathSeparator))
@@ -49,20 +48,18 @@ object RunFromSourceMain {
     val log = context.logger("RunFromSourceMain.fork", None, None)
     try runner.fork("sbt.RunFromSourceMain", cp.map(_.toPath()), options, log)
     finally context.close()
-  }
 
-  def main(args: Array[String]): Unit = args match {
+  def main(args: Array[String]): Unit = args match
     case Array() =>
       sys.error(
         s"Must specify working directory, scala version and sbt version and classpath as the first three arguments"
       )
     case Array(wd, scalaVersion, sbtVersion, classpath, args*) =>
-      if (System.getProperty("jna.nosys") == null) System.setProperty("jna.nosys", "true")
-      if (args.exists(_.startsWith("<"))) System.setProperty("sbt.io.virtual", "false")
+      if System.getProperty("jna.nosys") == null then System.setProperty("jna.nosys", "true")
+      if args.exists(_.startsWith("<")) then System.setProperty("sbt.io.virtual", "false")
       Using.resource(LoggerContext()) { context =>
         run(file(wd), scalaVersion, sbtVersion, classpath, args, context)
       }
-  }
 
   // this arrangement is because Scala does not always properly optimize away
   // the tail recursion in a catch statement
@@ -74,10 +71,9 @@ object RunFromSourceMain {
       args: Seq[String],
       context: LoggerContext
   ): Unit =
-    runImpl(baseDir, scalaVersion, sbtVersion, classpath, args, context: LoggerContext) match {
+    runImpl(baseDir, scalaVersion, sbtVersion, classpath, args, context: LoggerContext) match
       case Some((baseDir, args)) => run(baseDir, scalaVersion, sbtVersion, classpath, args, context)
       case None                  => ()
-    }
 
   private def runImpl(
       baseDir: File,
@@ -86,7 +82,7 @@ object RunFromSourceMain {
       classpath: String,
       args: Seq[String],
       context: LoggerContext,
-  ): Option[(File, Seq[String])] = {
+  ): Option[(File, Seq[String])] =
     try
       launch(
         defaultBootDirectory,
@@ -97,12 +93,10 @@ object RunFromSourceMain {
         args,
         context
       ) map exit
-    catch {
+    catch
       case r: xsbti.FullReload            => Some((baseDir, r.arguments.toSeq))
       case scala.util.control.NonFatal(e) =>
         e.printStackTrace(); errorAndExit(e.toString)
-    }
-  }
 
   private def launch(
       bootDirectory: File,
@@ -112,7 +106,7 @@ object RunFromSourceMain {
       classpath: String,
       arguments: Seq[String],
       context: LoggerContext,
-  ): Option[Int] = {
+  ): Option[Int] =
     ScriptedLauncher
       .launch(
         scalaHome(bootDirectory, scalaVersion, context),
@@ -123,33 +117,30 @@ object RunFromSourceMain {
         classpath.split(java.io.File.pathSeparator).map(file),
         arguments.toArray
       )
-      .orElse(null) match {
+      .orElse(null) match
       case null                   => None
       case i if i == Int.MaxValue => None
       case i                      => Some(i)
-    }
-  }
 
   private lazy val defaultBootDirectory: File =
     file(sys.props("user.home")) / ".sbt" / "scripted" / "boot"
-  private def scalaHome(bootDirectory: File, scalaVersion: String, context: LoggerContext): File = {
+  private def scalaHome(bootDirectory: File, scalaVersion: String, context: LoggerContext): File =
     val log = context.logger("run-from-source", None, None)
     val scalaHome0 = bootDirectory / s"scala-$scalaVersion"
-    if ((scalaHome0 / "lib" / "scala-library.jar").exists) scalaHome0
-    else {
+    if (scalaHome0 / "lib" / "scala-library.jar").exists then scalaHome0
+    else
       log.info(s"""scalaHome ($scalaHome0) wasn't found""")
       val fakeboot = bootDirectory / "fakeboot"
       val scalaHome1 = fakeboot / s"scala-$scalaVersion"
       val scalaHome1Lib = scalaHome1 / "lib"
       val scalaHome1Temp = scalaHome1 / "temp"
       if scalaHome1Lib.exists then log.info(s"""using $scalaHome1 that was found""")
-      else {
+      else
         log.info(s"""creating $scalaHome1 by downloading scala-compiler $scalaVersion""")
         IO.createDirectories(List(scalaHome1Lib, scalaHome1Temp))
-        val lm = {
+        val lm =
           import lmcoursier.{ CoursierConfiguration, CoursierDependencyResolution }
           CoursierDependencyResolution(CoursierConfiguration())
-        }
         val module = "org.scala-lang" % "scala3-compiler_3" % scalaVersion
         lm.retrieve(module, scalaModuleInfo = None, scalaHome1Temp, log) match
           case Left(w)     => throw w.resolveException
@@ -158,22 +149,21 @@ object RunFromSourceMain {
             jars.foreach: f =>
               val name = jarName(f.getName)
               IO.copyFile(f, scalaHome1Lib / s"$name.jar")
-      }
       scalaHome1
-    }
-  }
+    end if
+  end scalaHome
 
   private val Name = """(.*)(?:\-[\d.]+)\.jar""".r
   private val BinPre = """(.*)(?:\-[\d.]+)-(?:bin|pre)-.*\.jar""".r
   private val RC = """(.*)(?:\-[\d.]+)-(?:RC\d+)\.jar""".r
 
   private[sbt] def jarName(value: String): String =
-    value match {
+    value match
       case Name(name)   => name
       case BinPre(name) => name
       case RC(name)     => name
-    }
 
-  private def errorAndExit(msg: String): Nothing = { System.err.println(msg); exit(1) }
+  private def errorAndExit(msg: String): Nothing =
+    System.err.println(msg); exit(1)
   private def exit(code: Int): Nothing = System.exit(code).asInstanceOf[Nothing]
-}
+end RunFromSourceMain
diff --git a/sbt-app/src/test/scala/sbt/RunFromSourceMainSpec.scala b/sbt-app/src/test/scala/sbt/RunFromSourceMainSpec.scala
index c7d5186d7..acdc6fe9b 100644
--- a/sbt-app/src/test/scala/sbt/RunFromSourceMainSpec.scala
+++ b/sbt-app/src/test/scala/sbt/RunFromSourceMainSpec.scala
@@ -2,11 +2,10 @@ package sbt
 
 import verify.BasicTestSuite
 
-object RunFromSourceMainSpec extends BasicTestSuite {
+object RunFromSourceMainSpec extends BasicTestSuite:
   test("jarName") {
     assert(RunFromSourceMain.jarName("scala3-compiler_3-3.8.4.jar") == "scala3-compiler_3")
     assert(RunFromSourceMain.jarName("scala3-library_3-3.8.4.jar") == "scala3-library_3")
     assert(RunFromSourceMain.jarName("scala3-library_3-3.9.0-RC6.jar") == "scala3-library_3")
     assert(RunFromSourceMain.jarName("scala3-library_3-3.9.0-RC123.jar") == "scala3-library_3")
   }
-}
diff --git a/sbt-remote-cache/src/main/scala/sbt/internal/GrpcActionCacheStore.scala b/sbt-remote-cache/src/main/scala/sbt/internal/GrpcActionCacheStore.scala
index 983945313..7d7123ae1 100644
--- a/sbt-remote-cache/src/main/scala/sbt/internal/GrpcActionCacheStore.scala
+++ b/sbt-remote-cache/src/main/scala/sbt/internal/GrpcActionCacheStore.scala
@@ -98,6 +98,7 @@ object GrpcActionCacheStore:
           case Some(existing) => existing
           case None           => mkStore()
       case _ => mkStore()
+  end apply
 
   private def build(
       uri: URI,
@@ -139,6 +140,7 @@ object GrpcActionCacheStore:
       case Some(x)                      => x
       case None                         => ""
     new GrpcActionCacheStore(channel, instanceName, remoteHeaders, disk, uri)
+  end build
 
   class AuthCallCredentials(remoteHeaders: List[String]) extends CallCredentials:
     val pairs = remoteHeaders.map: h =>
@@ -293,6 +295,8 @@ class GrpcActionCacheStore private (
           val casFile = disk.putBlobInternal(p, digest)
           disk.syncFile(r, casFile, outputDirectory)
         }
+    end if
+  end syncBlobs
 
   /**
    * https://github.com/bazelbuild/remote-apis/blob/9ff14cecffe5287ba337f857731ceadfc2d80de9/build/bazel/remote/execution/v2/remote_execution.proto#L379
@@ -334,6 +338,7 @@ class GrpcActionCacheStore private (
       if lookupResponse.contains(d) then
         Some(HashedVirtualFileRef.of(blob.id(), d.contentHashStr, d.sizeBytes))
       else None
+  end batchUpdateBlobs
 
   def uploadBlobs(blobs: Seq[VirtualFile]): Future[Seq[HashedVirtualFileRef]] =
     Future.sequence(blobs.map(uploadBlob))
@@ -365,6 +370,7 @@ class GrpcActionCacheStore private (
       reqObs.onCompleted()
       p.future.map: _ =>
         HashedVirtualFileRef.of(blob.id(), d.contentHashStr, d.sizeBytes)
+  end uploadBlob
 
   private def downloadBlobs(digests: Seq[Digest], outputDirectory: Path): Future[Seq[Path]] =
     Future.sequence(digests.map: x =>
@@ -391,6 +397,7 @@ class GrpcActionCacheStore private (
     val req = b.build()
     byteStreamStubWithDeadline.read(req, resObs)
     p.future
+  end downloadBlob
 
   // helper function for many-to-one gRPC streaming
   // https://grpc.io/docs/languages/java/basics/#client-side-streaming-rpc-1
diff --git a/sbt-remote-cache/src/main/scala/sbt/plugins/RemoteCachePlugin.scala b/sbt-remote-cache/src/main/scala/sbt/plugins/RemoteCachePlugin.scala
index 36f13fd40..f7594a748 100644
--- a/sbt-remote-cache/src/main/scala/sbt/plugins/RemoteCachePlugin.scala
+++ b/sbt-remote-cache/src/main/scala/sbt/plugins/RemoteCachePlugin.scala
@@ -36,6 +36,7 @@ object RemoteCachePlugin extends AutoPlugin:
           )
           orig ++ Seq(r)
         case _ => orig
+      end match
     },
   )
 end RemoteCachePlugin
diff --git a/sbtw/src/main/scala/sbtw/ArgParser.scala b/sbtw/src/main/scala/sbtw/ArgParser.scala
index d541b4eca..36e95cf95 100644
--- a/sbtw/src/main/scala/sbtw/ArgParser.scala
+++ b/sbtw/src/main/scala/sbtw/ArgParser.scala
@@ -55,10 +55,12 @@ object ArgParser:
           .optional()
           .action((x, c) => c.copy(residual = c.residual :+ x)),
       )
+    end parser
     OParser
       .parse(parser, args, LauncherOptions())
       .map: opts =>
         val sbtNew = opts.residual.contains("new") || opts.residual.contains("init")
         val isScript = opts.residual.exists(_.startsWith("-Dsbt.main.class=sbt.ScriptMain"))
         opts.copy(sbtNew = sbtNew, allowEmpty = opts.allowEmpty || isScript)
+  end parse
 end ArgParser
diff --git a/sbtw/src/main/scala/sbtw/ConfigLoader.scala b/sbtw/src/main/scala/sbtw/ConfigLoader.scala
index 7482cbe1b..733ac4c13 100644
--- a/sbtw/src/main/scala/sbtw/ConfigLoader.scala
+++ b/sbtw/src/main/scala/sbtw/ConfigLoader.scala
@@ -14,7 +14,7 @@ object ConfigLoader:
           val trimmed = line.trim
           if trimmed.isEmpty || trimmed.startsWith("#") then Nil
           else Seq(trimmed))
-      catch { case _: Exception => Nil }
+      catch case _: Exception => Nil
 
   def loadSbtOpts(cwd: File, sbtHome: File): Seq[String] =
     val fromProject = new File(cwd, ".sbtopts")
@@ -41,8 +41,10 @@ object ConfigLoader:
         c match
           case '"'                 => inDouble = true
           case '\''                => inSingle = true
-          case w if w.isWhitespace => if word.nonEmpty then { out += word.toString; word.clear() }
-          case other               => word += other
+          case w if w.isWhitespace =>
+            if word.nonEmpty then
+              out += word.toString; word.clear()
+          case other => word += other
     if word.nonEmpty then out += word.toString
     out.toList
 
@@ -71,7 +73,7 @@ object ConfigLoader:
               val eq = line.indexOf('=')
               if eq >= 0 then Some(line.substring(eq + 1).trim).filter(_.nonEmpty)
               else None
-      catch { case _: Exception => None }
+      catch case _: Exception => None
 
   def isSbtProjectDir(dir: File): Boolean =
     new File(dir, "build.sbt").isFile || new File(dir, "project/build.properties").isFile
diff --git a/sbtw/src/main/scala/sbtw/Main.scala b/sbtw/src/main/scala/sbtw/Main.scala
index 8b6b25bac..415dc80a1 100644
--- a/sbtw/src/main/scala/sbtw/Main.scala
+++ b/sbtw/src/main/scala/sbtw/Main.scala
@@ -114,6 +114,10 @@ object Main:
             bootArgs,
             opts.verbose
           )
+        end if
+      end if
+    end if
+  end launch
 
   private def shouldRunNativeClient(
       opts: LauncherOptions,
@@ -164,7 +168,7 @@ object Main:
               val out = Process(cmd, None, selected.envOverlay*).!!
               println(out.linesIterator.toSeq.lastOption.map(_.trim).getOrElse(""))
               0
-            catch { case _: Exception => 1 }
+            catch case _: Exception => 1
     else 0
 
   private def projectSbtVersion(cwd: File): Option[String] =
@@ -198,4 +202,5 @@ object Main:
       |  -J-X                pass -X to the JVM (-J is stripped)
       |""".stripMargin)
     0
+  end printUsage
 end Main
diff --git a/sbtw/src/main/scala/sbtw/Runner.scala b/sbtw/src/main/scala/sbtw/Runner.scala
index 4a03a9e5b..eec76b1a2 100644
--- a/sbtw/src/main/scala/sbtw/Runner.scala
+++ b/sbtw/src/main/scala/sbtw/Runner.scala
@@ -17,7 +17,7 @@ object Runner:
       if quoted.startsWith("1.") && parts.nonEmpty then
         scala.util.Try(parts(0).toInt).toOption.getOrElse(major)
       else major
-    catch { case _: Exception => 0 }
+    catch case _: Exception => 0
 
   /** Returns the minimum JDK version required for the given sbt version. */
   def minimumJdkVersion(sbtVersion: Option[String]): Int =
@@ -51,6 +51,7 @@ object Runner:
     if opts.noServer then s = s ++ Seq("-Dsbt.io.virtual=false", "-Dsbt.server.autostart=false")
     if opts.jvmClient then s = s :+ "--client"
     s
+  end buildSbtOpts
 
   def runNativeClient(
       sbtBinDir: File,
@@ -73,6 +74,7 @@ object Runner:
       val extraEnv = ("SBT_SCRIPT" -> scriptPath) +: selected.handoffEnv
       val proc = Process(cmd, None, extraEnv*)
       proc.!
+  end runNativeClient
 
   def runJvm(
       selected: SelectedJava,
@@ -99,6 +101,7 @@ object Runner:
       p.waitFor()
       p.exitValue()
     finally if p.isAlive then p.destroy()
+  end runJvm
 
   def shutdownAll(selected: SelectedJava): Int =
     try
@@ -111,10 +114,11 @@ object Runner:
         .toList
       pids.foreach: pid =>
         try Process(Seq("taskkill", "/F", "/PID", pid.toString)).!
-        catch { case _: Exception => }
+        catch
+          case _: Exception =>
       System.err.println(s"shutdown ${pids.size} sbt processes")
       0
-    catch { case _: Exception => 1 }
+    catch case _: Exception => 1
 
   def splitResidual(residual: Seq[String]): (Seq[String], Seq[String]) =
     var javaOpts: Seq[String] = Nil
diff --git a/scripted-sbt/src/main/scala/sbt/scriptedtest/BatchScriptRunner.scala b/scripted-sbt/src/main/scala/sbt/scriptedtest/BatchScriptRunner.scala
index 469db8978..6c759a565 100644
--- a/scripted-sbt/src/main/scala/sbt/scriptedtest/BatchScriptRunner.scala
+++ b/scripted-sbt/src/main/scala/sbt/scriptedtest/BatchScriptRunner.scala
@@ -13,12 +13,11 @@ import scala.collection.mutable
 
 import sbt.internal.scripted.*
 
-private[sbt] object BatchScriptRunner {
+private[sbt] object BatchScriptRunner:
   type States = mutable.HashMap[StatementHandler, StatementHandler#State]
-}
 
 /** Defines an alternative script runner that allows batch execution. */
-private[sbt] class BatchScriptRunner extends ScriptRunner with AutoCloseable {
+private[sbt] class BatchScriptRunner extends ScriptRunner with AutoCloseable:
   import BatchScriptRunner.States
 
   /**
@@ -27,43 +26,34 @@ private[sbt] class BatchScriptRunner extends ScriptRunner with AutoCloseable {
    * @param statements The list of handlers and statements.
    * @param states The states of the runner. In case it's empty, inherited apply is called.
    */
-  def apply(statements: List[(StatementHandler, Statement)], states: States): Unit = {
-    if (states.isEmpty) super.apply(statements)
+  def apply(statements: List[(StatementHandler, Statement)], states: States): Unit =
+    if states.isEmpty then super.apply(statements)
     else statements.foreach(st => processStatement(st._1, st._2, states))
-  }
 
   def initStates(states: States, handlers: Seq[StatementHandler]): Unit =
     handlers.foreach(handler => states(handler) = handler.initialState)
 
-  def cleanUpHandlers(handlers: Seq[StatementHandler], states: States): Unit = {
-    for (handler <- handlers; state <- states.get(handler)) {
+  def cleanUpHandlers(handlers: Seq[StatementHandler], states: States): Unit =
+    for handler <- handlers; state <- states.get(handler) do
       try handler.finish(state.asInstanceOf[handler.State])
-      catch { case _: Exception => () }
-    }
-  }
+      catch case _: Exception => ()
 
-  def processStatement(handler: StatementHandler, statement: Statement, states: States): Unit = {
+  def processStatement(handler: StatementHandler, statement: Statement, states: States): Unit =
     val state = states(handler).asInstanceOf[handler.State]
     val nextState =
       try Right(handler(statement.command, statement.arguments, state))
-      catch { case e: Exception => Left(e) }
-    nextState match {
+      catch case e: Exception => Left(e)
+    nextState match
       case Left(err) =>
-        if (statement.successExpected) {
-          err match {
+        if statement.successExpected then
+          err match
             case t: TestFailed =>
               throw new TestException(statement, "Command failed: " + t.getMessage, null)
             case _ => throw new TestException(statement, "Command failed", err)
-          }
-        } else
-          ()
+        else ()
       case Right(s) =>
-        if (statement.successExpected)
-          states(handler) = s
-        else
-          throw new TestException(statement, "Command succeeded but failure was expected", null)
-    }
-  }
+        if statement.successExpected then states(handler) = s
+        else throw new TestException(statement, "Command succeeded but failure was expected", null)
 
   override def close(): Unit = ()
-}
+end BatchScriptRunner
diff --git a/scripted-sbt/src/main/scala/sbt/scriptedtest/RemoteSbtCreator.scala b/scripted-sbt/src/main/scala/sbt/scriptedtest/RemoteSbtCreator.scala
index 60b2545ae..eab115b96 100644
--- a/scripted-sbt/src/main/scala/sbt/scriptedtest/RemoteSbtCreator.scala
+++ b/scripted-sbt/src/main/scala/sbt/scriptedtest/RemoteSbtCreator.scala
@@ -14,15 +14,13 @@ import xsbt.IPC
 import scala.sys.process.{ BasicIO, Process }
 
 private[sbt] sealed trait RemoteSbtCreatorProp
-private[sbt] object RemoteSbtCreatorProp {
+private[sbt] object RemoteSbtCreatorProp:
   case class LauncherBased(launcherJar: File) extends RemoteSbtCreatorProp
   case class RunFromSourceBased(scalaVersion: String, sbtVersion: String, classpath: Seq[File])
       extends RemoteSbtCreatorProp
-}
 
-abstract class RemoteSbtCreator private[sbt] {
+abstract class RemoteSbtCreator private[sbt]:
   def newRemote(server: IPC.Server): Process
-}
 
 final class LauncherBasedRemoteSbtCreator(
     directory: File,
@@ -30,7 +28,7 @@ final class LauncherBasedRemoteSbtCreator(
     log: Logger,
     javaCommand: String,
     launchOpts: Seq[String],
-) extends RemoteSbtCreator {
+) extends RemoteSbtCreator:
   def this(
       directory: File,
       launcher: File,
@@ -38,7 +36,7 @@ final class LauncherBasedRemoteSbtCreator(
       launchOpts: Seq[String] = Nil,
   ) = this(directory, launcher, log, "java", launchOpts)
 
-  def newRemote(server: IPC.Server): Process = {
+  def newRemote(server: IPC.Server): Process =
     val launcherJar = launcher.getAbsolutePath
     val globalBase = "-Dsbt.global.base=" + (new File(directory, "global")).getAbsolutePath
     val scripted = "-Dsbt.scripted=true"
@@ -47,13 +45,12 @@ final class LauncherBasedRemoteSbtCreator(
       javaCommand :: launchOpts.toList ::: globalBase :: scripted :: "-jar" :: launcherJar :: args ::: Nil
     val io = BasicIO(false, log).withInput(_.close())
     val p = Process(cmd, directory).run(io)
-    val thread = new Thread() {
-      override def run(): Unit = { p.exitValue(); server.close() }
-    }
+    val thread = new Thread():
+      override def run(): Unit =
+        p.exitValue(); server.close()
     thread.start()
     p
-  }
-}
+end LauncherBasedRemoteSbtCreator
 
 final class RunFromSourceBasedRemoteSbtCreator(
     directory: File,
@@ -63,7 +60,7 @@ final class RunFromSourceBasedRemoteSbtCreator(
     scalaVersion: String,
     sbtVersion: String,
     classpath: Seq[File],
-) extends RemoteSbtCreator {
+) extends RemoteSbtCreator:
   def this(
       directory: File,
       log: Logger,
@@ -73,7 +70,7 @@ final class RunFromSourceBasedRemoteSbtCreator(
       classpath: Seq[File],
   ) = this(directory, log, "java", launchOpts, scalaVersion, sbtVersion, classpath)
 
-  def newRemote(server: IPC.Server): Process = {
+  def newRemote(server: IPC.Server): Process =
     val globalBase = "-Dsbt.global.base=" + new File(directory, "global").getAbsolutePath
     val scripted = "-Dsbt.scripted=true"
     val mainClassName = "sbt.RunFromSourceMain"
@@ -84,8 +81,9 @@ final class RunFromSourceBasedRemoteSbtCreator(
       javaCommand :: launchOpts.toList ::: globalBase :: scripted :: "-cp" :: cpString :: args ::: Nil
     val io = BasicIO(false, log).withInput(_.close())
     val p = Process(cmd, directory) run (io)
-    val thread = new Thread() { override def run() = { p.exitValue(); server.close() } }
+    val thread = new Thread():
+      override def run() =
+        p.exitValue(); server.close()
     thread.start()
     p
-  }
-}
+end RunFromSourceBasedRemoteSbtCreator
diff --git a/scripted-sbt/src/main/scala/sbt/scriptedtest/SbtHandler.scala b/scripted-sbt/src/main/scala/sbt/scriptedtest/SbtHandler.scala
index 31e146de3..310bed4f0 100644
--- a/scripted-sbt/src/main/scala/sbt/scriptedtest/SbtHandler.scala
+++ b/scripted-sbt/src/main/scala/sbt/scriptedtest/SbtHandler.scala
@@ -21,7 +21,7 @@ import xsbt.IPC
 
 final case class SbtInstance(process: Process, server: IPC.Server)
 
-final class SbtHandler(remoteSbtCreator: RemoteSbtCreator) extends StatementHandler {
+final class SbtHandler(remoteSbtCreator: RemoteSbtCreator) extends StatementHandler:
   Signals.register(() => RunningProcesses.killAll())
 
   type State = Option[SbtInstance]
@@ -35,56 +35,52 @@ final class SbtHandler(remoteSbtCreator: RemoteSbtCreator) extends StatementHand
     }
 
   def onSbtInstance(i: Option[SbtInstance])(f: (Process, IPC.Server) => Unit): Option[SbtInstance] =
-    i match {
+    i match
       case Some(SbtInstance(_, server)) if server.isClosed => finish(i); onNewSbtInstance(f)
       case Some(SbtInstance(process, server))              => f(process, server); i
       case None                                            => onNewSbtInstance(f)
-    }
 
-  private def onNewSbtInstance(f: (Process, IPC.Server) => Unit): Option[SbtInstance] = {
+  private def onNewSbtInstance(f: (Process, IPC.Server) => Unit): Option[SbtInstance] =
     val server = IPC.unmanagedServer
     val p =
       try newRemote(server)
-      catch { case e: Throwable => server.close(); throw e }
+      catch
+        case e: Throwable =>
+          server.close()
+          throw e
     val i = Some(SbtInstance(p, server))
     try f(p, server)
-    catch {
+    catch
       case e: Throwable =>
         // TODO: closing is necessary only because StatementHandler uses exceptions for signaling errors
         finish(i)
         throw e
-    }
     i
-  }
 
-  def finish(state: State) = state match {
+  def finish(state: State) = state match
     case None                               =>
     case Some(SbtInstance(process, server)) =>
-      try {
+      try
         send("exit", server)
         process.exitValue()
         ()
-      } catch {
-        case _: IOException => process.destroy()
-      } finally {
-        if (process.isAlive()) process.destroy()
+      catch case _: IOException => process.destroy()
+      finally
+        if process.isAlive() then process.destroy()
         RunningProcesses.remove(process)
-      }
-  }
 
   def send(message: String, server: IPC.Server) = server.connection(_.send(message))
 
   def receive(errorMessage: String, server: IPC.Server) =
     server.connection { ipc =>
       val resultMessage = ipc.receive
-      if (!resultMessage.toBoolean) throw new TestFailed(errorMessage)
+      if !resultMessage.toBoolean then throw new TestFailed(errorMessage)
     }
 
-  def newRemote(server: IPC.Server): Process = {
+  def newRemote(server: IPC.Server): Process =
     val p = remoteSbtCreator.newRemote(server)
     RunningProcesses.add(p)
     try receive("Remote sbt initialization failed", server)
-    catch { case _: SocketException => throw new TestFailed("Remote sbt initialization failed") }
+    catch case _: SocketException => throw new TestFailed("Remote sbt initialization failed")
     p
-  }
-}
+end SbtHandler
diff --git a/scripted-sbt/src/main/scala/sbt/scriptedtest/ScriptedTests.scala b/scripted-sbt/src/main/scala/sbt/scriptedtest/ScriptedTests.scala
index b98b6ff1f..1abf56df8 100644
--- a/scripted-sbt/src/main/scala/sbt/scriptedtest/ScriptedTests.scala
+++ b/scripted-sbt/src/main/scala/sbt/scriptedtest/ScriptedTests.scala
@@ -28,7 +28,7 @@ final class ScriptedTests(
     bufferLog: Boolean,
     javaCommand: String,
     launchOpts: Seq[String],
-) {
+):
   def this(
       resourceBaseDirectory: File,
       bufferLog: Boolean,
@@ -49,42 +49,38 @@ final class ScriptedTests(
       prescripted: File => Unit,
       log: Logger,
       prop: RemoteSbtCreatorProp
-  ): Seq[TestRunner] = {
+  ): Seq[TestRunner] =
 
     // Test group and names may be file filters (like '*')
-    for {
+    for
       groupDir <- (resourceBaseDirectory * group).get()
       nme <- (groupDir * name).get()
       if !(nme.isFile)
-    } yield {
+    yield
       val g = groupDir.getName
       val n = nme.getName
       val label = s"$g / $n"
-      () => {
+      () =>
         log.info(s"Running $label")
         val result = testResources.readWriteResourceDirectory(g, n) { testDirectory =>
           val buffer = new BufferedLogger(new FullLogger(log))
-          val singleTestRunner = () => {
+          val singleTestRunner = () =>
             val handlers = createScriptedHandlers(testDirectory, buffer, prop)
             val runner = new BatchScriptRunner
             val states = new mutable.HashMap[StatementHandler, StatementHandler#State]()
             commonRunTest(label, testDirectory, prescripted, handlers, runner, states, buffer)
-          }
           runOrHandleDisabled(label, testDirectory, singleTestRunner, buffer)
         }
         Seq(result)
-      }
-    }
-  }
 
   private def createScriptedHandlers(
       testDir: File,
       buffered: Logger,
       prop: RemoteSbtCreatorProp
-  ): Map[Char, StatementHandler] = {
+  ): Map[Char, StatementHandler] =
     val fileHandler = new FileCommands(testDir)
     val remoteSbtCreator =
-      prop match {
+      prop match
         case LauncherBased(launcherJar) =>
           new LauncherBasedRemoteSbtCreator(testDir, launcherJar, buffered, javaCommand, launchOpts)
         case RunFromSourceBased(scalaVersion, sbtVersion, classpath) =>
@@ -97,10 +93,9 @@ final class ScriptedTests(
             sbtVersion,
             classpath
           )
-      }
     val sbtHandler = new SbtHandler(remoteSbtCreator)
     Map('$' -> fileHandler, '>' -> sbtHandler, '#' -> CommentHandler)
-  }
+  end createScriptedHandlers
 
   def batchScriptedRunner(
       testGroupAndNames: Seq[(String, String)],
@@ -131,17 +126,16 @@ final class ScriptedTests(
       keepTempDirectory: Boolean,
       includeFilter: java.io.FileFilter,
       excludeFilter: java.io.FileFilter,
-  ): Seq[TestRunner] = {
+  ): Seq[TestRunner] =
     // Test group and names may be file filters (like '*')
-    val groupAndNameDirs = {
-      for {
+    val groupAndNameDirs =
+      for
         (group, name) <- testGroupAndNames
         groupDir <- (resourceBaseDirectory * group).get()
         testDir <- (groupDir * name).get()
         if !testDir.isFile
         if includeFilter.accept(testDir) && !excludeFilter.accept(testDir)
-      } yield (groupDir, testDir)
-    }
+      yield (groupDir, testDir)
 
     type TestInfo = ((String, String), File)
 
@@ -152,13 +146,12 @@ final class ScriptedTests(
       (groupName, testName) -> testDirectory
     }
 
-    if (labelsAndDirs.isEmpty) List()
-    else {
+    if labelsAndDirs.isEmpty then List()
+    else
       val totalSize = labelsAndDirs.size
-      val batchSize = totalSize / sbtInstances match {
+      val batchSize = totalSize / sbtInstances match
         case 0 => 1
         case s => s
-      }
 
       def logTests(size: Int, how: String) =
         log.info(
@@ -166,33 +159,30 @@ final class ScriptedTests(
         )
       logTests(labelsAndDirs.size, prop.toString)
 
-      if (keepTempDirectory && labelsAndDirs.size > 1) {
+      if keepTempDirectory && labelsAndDirs.size > 1 then
         sys.error(
           s"scriptedKeepTempDirectory requires exactly one test, but ${labelsAndDirs.size} tests were requested"
         )
-      }
 
-      def createTestRunners(tests: Seq[TestInfo]): Seq[TestRunner] = {
+      def createTestRunners(tests: Seq[TestInfo]): Seq[TestRunner] =
         tests
           .sortBy(_._1)
           .grouped(batchSize)
           .map { batch => () =>
-            if (keepTempDirectory) {
+            if keepTempDirectory then
               val tempDir = IO.createTemporaryDirectory
               log.info(s"Temporary directory for scripted tests: ${tempDir.getAbsolutePath}")
               runBatchedTests(batch, tempDir, prescripted, prop, log, keepTempDirectory)
-            } else {
+            else
               IO.withTemporaryDirectory {
                 runBatchedTests(batch, _, prescripted, prop, log, keepTempDirectory)
               }
-            }
           }
           .toList
-      }
 
       createTestRunners(labelsAndDirs)
-    }
-  }
+    end if
+  end batchScriptedRunner
 
   /**
    * Defines the batch execution of scripted tests.
@@ -219,7 +209,7 @@ final class ScriptedTests(
       prop: RemoteSbtCreatorProp,
       log: Logger,
       keepTempDirectory: Boolean
-  ): Seq[Option[String]] = {
+  ): Seq[Option[String]] =
 
     val runner = new BatchScriptRunner
     val buffer = new BufferedLogger(new FullLogger(log))
@@ -243,70 +233,65 @@ final class ScriptedTests(
           case (p, attrs) if attrs.isDirectory && !attrs.isSymbolicLink =>
             deleteContents(p)
             try Files.deleteIfExists(p)
-            catch { case _: IOException => }
+            catch
+              case _: IOException =>
           case (p, _) =>
             try Files.deleteIfExists(p)
-            catch { case _: IOException => }
+            catch
+              case _: IOException =>
     val tempTestPath = tempTestDir.getCanonicalFile.toPath
 
-    def runBatchTests = {
+    def runBatchTests =
       groupedTests.map { case ((group, name), originalDir) =>
         val label = s"$group/$name"
         log.info(s"Running $label")
         val targetGlobal = new File(tempTestDir, "global")
         val reposForce = new File(targetGlobal, "repositories_force")
-        if (reposForce.exists()) IO.delete(reposForce)
+        if reposForce.exists() then IO.delete(reposForce)
         val repos = new File(targetGlobal, "repositories")
-        if (repos.exists()) IO.delete(repos)
+        if repos.exists() then IO.delete(repos)
         // Copy test's contents and reload the sbt instance to pick them up
         IO.copyDirectory(originalDir, tempTestDir)
 
-        val runTest = () => {
+        val runTest = () =>
           def sbtHandlerError = sys error "Missing sbt handler. Scripted is misconfigured."
           val sbtHandler = handlers.getOrElse('>', sbtHandlerError)
 
-          val wrapHook = (file: File) => {
+          val wrapHook = (file: File) =>
             preHook(file)
             // Reload only when a previous sbt instance exists; a new instance already loads the project on boot
-            if (states(sbtHandler) != None) {
+            if states(sbtHandler) != None then
               val statement =
                 Statement("reload;initialize", Nil, successExpected = true, line = -1)
               try runner.processStatement(sbtHandler, statement, states)
-              catch {
+              catch
                 case t: Throwable =>
                   val newMsg = "Reload for scripted batch execution failed."
                   throw new TestException(statement, newMsg, t)
-              }
-            }
-          }
 
           commonRunTest(label, tempTestDir, wrapHook, handlers, runner, states, buffer)
-        }
 
         // Run the test and delete files (except global that holds local scala jars)
         val result = runOrHandleDisabled(label, tempTestDir, runTest, buffer)
-        if (!keepTempDirectory) deleteContents(tempTestPath)
+        if !keepTempDirectory then deleteContents(tempTestPath)
         result
       }
-    }
 
     try runBatchTests
     finally runner.cleanUpHandlers(seqHandlers, states)
-  }
+  end runBatchedTests
 
   private def runOrHandleDisabled(
       label: String,
       testDirectory: File,
       runTest: () => Option[String],
       log: Logger
-  ): Option[String] = {
+  ): Option[String] =
     val existsDisabled = new File(testDirectory, "disabled").isFile
-    if (!existsDisabled) runTest()
-    else {
+    if !existsDisabled then runTest()
+    else
       log.info(s"D $label [DISABLED]")
       None
-    }
-  }
 
   private val PendingLabel = "[PENDING]"
 
@@ -318,35 +303,30 @@ final class ScriptedTests(
       runner: BatchScriptRunner,
       states: BatchScriptRunner.States,
       log: BufferedLogger
-  ): Option[String] = {
-    if (bufferLog) log.record()
+  ): Option[String] =
+    if bufferLog then log.record()
 
-    val (file, pending) = {
+    val (file, pending) =
       val normal = (new File(testDirectory, ScriptFilename), false)
       val normalScript = (new File(testDirectory, s"$ScriptFilename.script"), false)
       val pending = (new File(testDirectory, PendingScriptFilename), true)
       val pendingScript = (new File(testDirectory, s"$PendingScriptFilename.script"), true)
 
-      List(pending, pendingScript, normal, normalScript).find(_._1.isFile) match {
+      List(pending, pendingScript, normal, normalScript).find(_._1.isFile) match
         case Some(script) => script
         case None         => throw new FileNotFoundException("no test scripts found")
-      }
-    }
 
-    val pendingMark: String = if (pending) PendingLabel else ""
+    val pendingMark: String = if pending then PendingLabel else ""
 
-    def testFailed(t: Throwable): Option[String] = {
-      if (pending) log.clear() else log.stop()
+    def testFailed(t: Throwable): Option[String] =
+      if pending then log.clear() else log.stop()
       log.error(s"x $label $pendingMark")
-      if (!NonFatal(t)) throw t // We make sure fatal errors are rethrown
-      if (t.isInstanceOf[TestException]) {
-        t.getCause match {
+      if !NonFatal(t) then throw t // We make sure fatal errors are rethrown
+      if t.isInstanceOf[TestException] then
+        t.getCause match
           case null | _: SocketException => log.error(s" Cause of test exception: ${t.getMessage}")
-          case _                         => if (!pending) t.printStackTrace()
-        }
-      }
-      if (pending) None else Some(label)
-    }
+          case _                         => if !pending then t.printStackTrace()
+      if pending then None else Some(label)
 
     import scala.util.control.Exception.catching
     catching(classOf[TestException]).withApply(testFailed).andFinally(log.clear()).apply {
@@ -357,24 +337,23 @@ final class ScriptedTests(
 
       // Handle successful tests
       log.info(s"+ $label $pendingMark")
-      if (pending) {
+      if pending then
         log.clear()
         log.error(" Pending test passed. Mark as passing to remove this failure.")
         Some(label)
-      } else {
+      else
         log.play()
         None
-      }
     }
-  }
-}
+  end commonRunTest
+end ScriptedTests
 
-object ScriptedTests extends ScriptedRunner {
+object ScriptedTests extends ScriptedRunner:
 
   /** Represents the function that runs the scripted tests, both in single or batch mode. */
   type TestRunner = () => Seq[Option[String]]
 
-  def main(args: Array[String]): Unit = {
+  def main(args: Array[String]): Unit =
     val directory = new File(args(0))
     val buffer = args(1).toBoolean
     val sbtVersion = args(2)
@@ -396,12 +375,11 @@ object ScriptedTests extends ScriptedRunner {
       cp,
       1
     )
-  }
-
-}
+  end main
+end ScriptedTests
 
 /** Runner for `scripted`. Not be confused with ScriptRunner. */
-class ScriptedRunner {
+class ScriptedRunner:
 
   /**
    * This is the entry point used by sbt-scripted 0.13.18.
@@ -415,7 +393,7 @@ class ScriptedRunner {
       tests: Array[String],
       launcherJar: File,
       launchOpts: Array[String],
-  ): Unit = {
+  ): Unit =
     val logger = TestConsoleLogger()
     run(
       resourceBaseDirectory,
@@ -429,7 +407,6 @@ class ScriptedRunner {
       1,
       parallelExecution = false,
     )
-  }
 
   /**
    * This is the entry point used by SbtPlugin in sbt 1.2.x, 1.3.x, 1.4.x etc.
@@ -444,7 +421,7 @@ class ScriptedRunner {
       launcherJar: File,
       launchOpts: Array[String],
       prescripted: java.util.List[File],
-  ): Unit = {
+  ): Unit =
     val logger = TestConsoleLogger()
     run(
       resourceBaseDirectory,
@@ -458,7 +435,7 @@ class ScriptedRunner {
       Int.MaxValue,
       parallelExecution = false,
     )
-  }
+  end run
 
   /**
    * This is the entry point used by SbtPlugin in sbt 2.0.x etc.
@@ -473,7 +450,7 @@ class ScriptedRunner {
       javaCommand: String,
       launchOpts: Array[String],
       prescripted: java.util.List[File],
-  ): Unit = {
+  ): Unit =
     val logger = TestConsoleLogger()
     run(
       resourceBaseDirectory,
@@ -487,7 +464,7 @@ class ScriptedRunner {
       Int.MaxValue,
       parallelExecution = false,
     )
-  }
+  end run
 
   def run(
       resourceBaseDirectory: File,
@@ -498,7 +475,7 @@ class ScriptedRunner {
       launchOpts: Array[String],
       prescripted: java.util.List[File],
       keepTempDirectory: Boolean,
-  ): Unit = {
+  ): Unit =
     val logger = TestConsoleLogger()
     run(
       resourceBaseDirectory,
@@ -513,7 +490,7 @@ class ScriptedRunner {
       parallelExecution = false,
       keepTempDirectory,
     )
-  }
+  end run
 
   /** Entry point with configurable include/exclude filters. */
   def run(
@@ -527,7 +504,7 @@ class ScriptedRunner {
       keepTempDirectory: Boolean,
       includeFilter: java.io.FileFilter,
       excludeFilter: java.io.FileFilter,
-  ): Unit = {
+  ): Unit =
     val logger = TestConsoleLogger()
     run(
       resourceBaseDirectory,
@@ -544,7 +521,7 @@ class ScriptedRunner {
       includeFilter,
       excludeFilter,
     )
-  }
+  end run
 
   /**
    * This is the entry point used by SbtPlugin in sbt 1.2.x, 1.3.x, 1.4.x etc.
@@ -560,7 +537,7 @@ class ScriptedRunner {
       launchOpts: Array[String],
       prescripted: java.util.List[File],
       instance: Int,
-  ): Unit = {
+  ): Unit =
     val logger = TestConsoleLogger()
     runInParallel(
       resourceBaseDirectory,
@@ -574,7 +551,7 @@ class ScriptedRunner {
       instance,
       keepTempDirectory = false,
     )
-  }
+  end runInParallel
 
   /**
    * This is the entry point used by SbtPlugin in sbt 2.0.x etc.
@@ -590,7 +567,7 @@ class ScriptedRunner {
       launchOpts: Array[String],
       prescripted: java.util.List[File],
       instance: Int,
-  ): Unit = {
+  ): Unit =
     val logger = TestConsoleLogger()
     runInParallel(
       resourceBaseDirectory,
@@ -604,7 +581,7 @@ class ScriptedRunner {
       instance,
       keepTempDirectory = false,
     )
-  }
+  end runInParallel
 
   def runInParallel(
       resourceBaseDirectory: File,
@@ -616,7 +593,7 @@ class ScriptedRunner {
       prescripted: java.util.List[File],
       instance: Int,
       keepTempDirectory: Boolean,
-  ): Unit = {
+  ): Unit =
     val logger = TestConsoleLogger()
     runInParallel(
       resourceBaseDirectory,
@@ -630,7 +607,7 @@ class ScriptedRunner {
       instance,
       keepTempDirectory,
     )
-  }
+  end runInParallel
 
   /** Entry point with configurable include/exclude filters. */
   def runInParallel(
@@ -645,7 +622,7 @@ class ScriptedRunner {
       keepTempDirectory: Boolean,
       includeFilter: java.io.FileFilter,
       excludeFilter: java.io.FileFilter,
-  ): Unit = {
+  ): Unit =
     val logger = TestConsoleLogger()
     runInParallel(
       resourceBaseDirectory,
@@ -661,7 +638,7 @@ class ScriptedRunner {
       includeFilter,
       excludeFilter,
     )
-  }
+  end runInParallel
 
   // This is called by project/Scripted.scala
   // Using java.util.List[File] to encode File => Unit
@@ -762,21 +739,21 @@ class ScriptedRunner {
       keepTempDirectory: Boolean = false,
       includeFilter: java.io.FileFilter = AllPassFilter,
       excludeFilter: java.io.FileFilter = NothingFilter,
-  ): Unit = {
-    val addTestFile = (f: File) => { prescripted.add(f); () }
+  ): Unit =
+    val addTestFile = (f: File) =>
+      prescripted.add(f); ()
     val runner = new ScriptedTests(baseDir, bufferLog, javaCommand, launchOpts.toIndexedSeq)
     val sbtVersion =
-      prop match {
+      prop match
         case LauncherBased(launcherJar) =>
           launcherJar.getName.dropWhile(!_.isDigit).dropRight(".jar".length)
         case RunFromSourceBased(_, sbtVersion, _) => sbtVersion
-      }
     val accept = isTestCompatible(baseDir, sbtVersion)
     // The scripted tests mapped to the inputs that the user wrote after `scripted`.
     val scriptedTests =
       get(tests.toIndexedSeq, baseDir, accept, logger).map(st => (st.group, st.name))
     // Choosing Int.MaxValue will make the groupSize 1 in batchScriptedRunner
-    val groupCount = if (parallelExecution) instances else Int.MaxValue
+    val groupCount = if parallelExecution then instances else Int.MaxValue
     val scriptedRunners =
       runner.batchScriptedRunner(
         scriptedTests,
@@ -789,18 +766,15 @@ class ScriptedRunner {
         excludeFilter,
       )
     // Fail if user provided test patterns but none matched any existing test directories
-    if (tests.nonEmpty && scriptedRunners.isEmpty) {
+    if tests.nonEmpty && scriptedRunners.isEmpty then
       sys.error(s"No tests found matching: ${tests.mkString(", ")}")
-    }
-    if (parallelExecution && instances > 1) {
+    if parallelExecution && instances > 1 then
       import scala.collection.parallel.CollectionConverters.*
       val parallelRunners = scriptedRunners.toArray.par
       parallelRunners.tasksupport = new ForkJoinTaskSupport(new ForkJoinPool(instances))
       runAll(parallelRunners)
-    } else {
-      runAll(scriptedRunners)
-    }
-  }
+    else runAll(scriptedRunners)
+  end run
   def runInParallel(
       baseDir: File,
       bufferLog: Boolean,
@@ -826,7 +800,7 @@ class ScriptedRunner {
     )
 
   private def reportErrors(errors: Seq[String]): Unit =
-    if (errors.nonEmpty) sys.error(errors.mkString("Failed tests:\n\t", "\n\t", "\n")) else ()
+    if errors.nonEmpty then sys.error(errors.mkString("Failed tests:\n\t", "\n\t", "\n")) else ()
 
   def runAll(toRun: Seq[ScriptedTests.TestRunner]): Unit =
     reportErrors(toRun.flatMap(test => test.apply().flatten))
@@ -843,10 +817,10 @@ class ScriptedRunner {
       baseDirectory: File,
       accept: ScriptedTest => Boolean,
       log: Logger,
-  ): Seq[ScriptedTest] = {
-    val unsorted = if (tests.isEmpty) listTests(baseDirectory, accept, log) else parseTests(tests)
+  ): Seq[ScriptedTest] =
+    val unsorted =
+      if tests.isEmpty then listTests(baseDirectory, accept, log) else parseTests(tests)
     unsorted.sortBy(t => (t.group, t.name))
-  }
 
   @deprecated("No longer used", "1.1.0")
   def listTests(baseDirectory: File, log: Logger): Seq[ScriptedTest] =
@@ -860,14 +834,13 @@ class ScriptedRunner {
     (new ListTests(baseDirectory, accept, log)).listTests
 
   def parseTests(in: Seq[String]): Seq[ScriptedTest] =
-    for (testString <- in) yield {
+    for testString <- in yield
       val Array(group, name) = testString.split("/").map(_.trim)
       ScriptedTest(group, name)
-    }
 
   private def isTestCompatible(resourceBaseDirectory: File, sbtVersion: String)(
       test: ScriptedTest
-  ): Boolean = {
+  ): Boolean =
     import sbt.internal.librarymanagement.cross.CrossVersionUtil.binarySbtVersion
     val buildProperties = new Properties()
     val testDir = new File(new File(resourceBaseDirectory, test.group), test.name)
@@ -875,23 +848,19 @@ class ScriptedRunner {
 
     IO.load(buildProperties, buildPropertiesFile)
 
-    Option(buildProperties.getProperty("sbt.version")).map(_.trim) match {
+    Option(buildProperties.getProperty("sbt.version")).map(_.trim) match
       case Some(version) => binarySbtVersion(version) == binarySbtVersion(sbtVersion)
       case None          => true
-    }
-  }
+end ScriptedRunner
 
-}
-
-final case class ScriptedTest(group: String, name: String) {
+final case class ScriptedTest(group: String, name: String):
   override def toString = s"$group/$name"
-}
 
 private[sbt] final class ListTests(
     baseDirectory: File,
     accept: ScriptedTest => Boolean,
     log: Logger,
-) {
+):
 
   def filter = DirectoryFilter -- HiddenFileFilter
 
@@ -903,49 +872,41 @@ private[sbt] final class ListTests(
       }
       .toSeq
 
-  private def listTests(group: File): Set[String] = {
+  private def listTests(group: File): Set[String] =
     val groupName = group.getName
     val allTests = IO.listFiles(group, filter)
-    if (allTests.isEmpty) {
+    if allTests.isEmpty then
       log.warn(s"No tests in test group $groupName")
       Set.empty
-    } else {
+    else
       val (included, skipped) =
         allTests.toList.partition(test => accept(ScriptedTest(groupName, test.getName)))
-      if (included.isEmpty) log.warn(s"Test group $groupName skipped.")
-      else if (skipped.nonEmpty) {
+      if included.isEmpty then log.warn(s"Test group $groupName skipped.")
+      else if skipped.nonEmpty then
         log.warn(s"Tests skipped in group $groupName:")
         skipped.foreach(testName => log.warn(s" ${testName.getName}"))
-      }
       Set(included.map(_.getName)*)
-    }
-  }
-}
+end ListTests
 
-class PendingTestSuccessException(label: String) extends Exception {
+class PendingTestSuccessException(label: String) extends Exception:
   override def getMessage: String =
     s"The pending test $label succeeded. Mark this test as passing to remove this failure."
-}
 
-private[sbt] object TestConsoleLogger {
+private[sbt] object TestConsoleLogger:
   def apply() = new TestConsoleLogger()
-}
 
 // Remove dependencies to log4j to avoid mixup.
-private[sbt] class TestConsoleLogger extends AbstractLogger {
+private[sbt] class TestConsoleLogger extends AbstractLogger:
   val out = ConsoleOut.systemOut
-  def trace(t: => Throwable): Unit = {
+  def trace(t: => Throwable): Unit =
     out.println(t.toString)
     // out.flush()
-  }
-  def success(message: => String): Unit = {
+  def success(message: => String): Unit =
     out.println(message)
     // out.flush()
-  }
-  def log(level: Level.Value, message: => String): Unit = {
+  def log(level: Level.Value, message: => String): Unit =
     out.println(s"[$level] $message")
     // out.flush()
-  }
   def control(event: sbt.util.ControlEvent.Value, message: => String): Unit = ()
   def getLevel: sbt.util.Level.Value = Level.Info
   def getTrace: Int = Int.MaxValue
@@ -954,4 +915,3 @@ private[sbt] class TestConsoleLogger extends AbstractLogger {
   def setSuccessEnabled(flag: Boolean): Unit = ()
   def setTrace(flag: Int): Unit = ()
   def successEnabled: Boolean = true
-}
diff --git a/server-test/src/test/scala/testpkg/AbstractServerTest.scala b/server-test/src/test/scala/testpkg/AbstractServerTest.scala
index 20c0129c5..2905d112f 100644
--- a/server-test/src/test/scala/testpkg/AbstractServerTest.scala
+++ b/server-test/src/test/scala/testpkg/AbstractServerTest.scala
@@ -29,20 +29,17 @@ final class SbtServer(
     val session: ServerSession,
     val baseDirectory: File,
     private val process: scala.sys.process.Process
-) {
-  def close(): Unit = {
+):
+  def close(): Unit =
     val result = scala.util.Try(session.shutdown(process.isAlive(), () => process.destroy()).get)
-    if (process.isAlive()) process.destroy()
-    result match {
+    if process.isAlive() then process.destroy()
+    result match
       case scala.util.Failure(e) =>
         System.err.println(s"server session shutdown failed (process destroyed): $e")
       case _ =>
-    }
-  }
   def isAlive: Boolean = process.isAlive()
-}
 
-trait AbstractServerTest extends AnyFunSuite with BeforeAndAfterAll {
+trait AbstractServerTest extends AnyFunSuite with BeforeAndAfterAll:
   private var temp: File = scala.compiletime.uninitialized
   var svr: SbtServer = scala.compiletime.uninitialized
 
@@ -50,21 +47,19 @@ trait AbstractServerTest extends AnyFunSuite with BeforeAndAfterAll {
   def testPath: Path = temp.toPath.resolve(testDirectory)
   def subscribeToAllForTest: Boolean = true
 
-  private val serverTestBase: File = {
+  private val serverTestBase: File =
     val p0 = new File(".").getAbsoluteFile / "server-test" / "src" / "server-test"
     val p1 = new File(".").getAbsoluteFile / "src" / "server-test"
-    if (p0.exists) p0
+    if p0.exists then p0
     else p1
-  }
 
-  private val targetDir: File = {
+  private val targetDir: File =
     val p0 = new File("..").getAbsoluteFile.getCanonicalFile / "target"
     val p1 = new File("target").getAbsoluteFile
-    if (p0.exists) p0
+    if p0.exists then p0
     else p1
-  }
 
-  override def beforeAll(): Unit = {
+  override def beforeAll(): Unit =
     val base = Files.createTempDirectory(
       Files.createDirectories(targetDir.toPath.resolve("test-server")),
       "server-test"
@@ -97,35 +92,31 @@ trait AbstractServerTest extends AnyFunSuite with BeforeAndAfterAll {
     session.initialize(10.seconds, subscribeToAllForTest)
 
     svr = new SbtServer(session, buildDir, process)
-  }
+  end beforeAll
 
-  private object BlockingInputStream extends InputStream {
-    override def read(): Int = {
+  private object BlockingInputStream extends InputStream:
+    override def read(): Int =
       try Thread.sleep(Long.MaxValue)
-      catch { case _: InterruptedException => }
+      catch
+        case _: InterruptedException =>
       -1
-    }
-  }
   private val nullPrintStream = new PrintStream(_ => {}, false)
 
-  private def background[R](f: => R): R = {
+  private def background[R](f: => R): R =
     val result = new LinkedBlockingQueue[Either[Throwable, R]]
-    val thread = new Thread("server-test-batch-client") {
+    val thread = new Thread("server-test-batch-client"):
       setDaemon(true)
       override def run(): Unit =
         try Util.ignoreResult(result.put(Right(f)))
-        catch { case e: Throwable => Util.ignoreResult(result.put(Left(e))) }
-    }
+        catch case e: Throwable => Util.ignoreResult(result.put(Left(e)))
     thread.start()
-    result.poll(3, TimeUnit.MINUTES) match {
+    result.poll(3, TimeUnit.MINUTES) match
       case null =>
         thread.interrupt()
         thread.join(10000)
         throw new TimeoutException("client did not complete within 3 minutes")
       case Left(e)  => throw e
       case Right(r) => r
-    }
-  }
 
   /** Runs the thin client in batch mode against this suite's server; returns its exit code. */
   protected def runBatchClient(args: String*): Int =
@@ -140,15 +131,13 @@ trait AbstractServerTest extends AnyFunSuite with BeforeAndAfterAll {
       )
     )
 
-  protected def waitUntil(timeout: FiniteDuration)(p: => Boolean): Boolean = {
+  protected def waitUntil(timeout: FiniteDuration)(p: => Boolean): Boolean =
     val deadline = timeout.fromNow
-    while (!p && deadline.hasTimeLeft()) Thread.sleep(100)
+    while !p && deadline.hasTimeLeft() do Thread.sleep(100)
     p
-  }
 
-  override protected def afterAll(): Unit = {
+  override protected def afterAll(): Unit =
     svr.close()
     svr = null
     IO.delete(temp)
-  }
-}
+end AbstractServerTest
diff --git a/server-test/src/test/scala/testpkg/BuildServerTest.scala b/server-test/src/test/scala/testpkg/BuildServerTest.scala
index ddb28dabc..2b3b5faf5 100644
--- a/server-test/src/test/scala/testpkg/BuildServerTest.scala
+++ b/server-test/src/test/scala/testpkg/BuildServerTest.scala
@@ -25,7 +25,7 @@ import scala.concurrent.duration.*
 import scala.util.{ Failure, Success }
 
 // starts svr using server-test/buildserver and perform custom server tests
-class BuildServerTest extends AbstractServerTest {
+class BuildServerTest extends AbstractServerTest:
 
   override val testDirectory: String = "buildserver"
 
@@ -56,12 +56,11 @@ class BuildServerTest extends AbstractServerTest {
     val scalaBuildTarget =
       Converter.fromJsonOptionUnsafe[ScalaBuildTarget](utilTarget.data)
     val javaTarget = scalaBuildTarget.jvmBuildTarget
-    (javaTarget.flatMap(_.javaVersion), javaTarget.flatMap(_.javaHome)) match {
+    (javaTarget.flatMap(_.javaVersion), javaTarget.flatMap(_.javaHome)) match
       case (Some(javaVersion), Some(javaHome)) =>
         assert(javaVersion.equals(sys.props("java.version")))
         assert(javaHome.equals(Paths.get(sys.props("java.home")).toUri))
       case _ => fail("JVM build target should contain javaVersion and javaHome")
-    }
   }
 
   test("buildTarget/sources") {
@@ -204,11 +203,11 @@ class BuildServerTest extends AbstractServerTest {
 
     svr.session
       .waitForNotificationMsg(20.seconds) { n =>
-        n.method match {
+        n.method match
           case "build/publishDiagnostics" =>
             n.params.flatMap(Converter.fromJson[PublishDiagnosticsParams](_).toOption).foreach {
               p =>
-                if (p.textDocument.uri.toString.contains("Diagnostics.scala"))
+                if p.textDocument.uri.toString.contains("Diagnostics.scala") then
                   throw new Exception("shouldn't send publishDiagnostics if noOp compilation")
             }
             false
@@ -217,7 +216,6 @@ class BuildServerTest extends AbstractServerTest {
               .flatMap(Converter.fromJson[TaskFinishParams](_).toOption)
               .exists(_.data.exists(d => CompactPrinter(d).contains("\"noOp\":true")))
           case _ => false
-        }
       }
       .get
   }
@@ -264,7 +262,7 @@ class BuildServerTest extends AbstractServerTest {
     val buildTarget = buildTargetUri("diagnostics", "Compile")
     val mainFile = new File(svr.baseDirectory, "diagnostics/src/main/scala/Diagnostics.scala")
     val original = IO.read(mainFile)
-    try {
+    try
       IO.write(
         mainFile,
         """|object Diagnostics {
@@ -277,9 +275,7 @@ class BuildServerTest extends AbstractServerTest {
         res.statusCode == StatusCode.Error,
         s"expected StatusCode.Error, got ${res.statusCode}"
       )
-    } finally {
-      IO.write(mainFile, original)
-    }
+    finally IO.write(mainFile, original)
   }
 
   // 1. Cause a real compile error and observe non-empty diagnostics.
@@ -298,7 +294,7 @@ class BuildServerTest extends AbstractServerTest {
           )
 
     def failIfForbiddenDiagnosticReset(n: JsonRpcNotificationMessage): Unit =
-      if (isForbiddenDiagnosticReset(n))
+      if isForbiddenDiagnosticReset(n) then
         fail(
           "buildTarget/scalaMainClasses must not publish empty reset=true " +
             "diagnostics for Diagnostics.scala after a failed compile (#9345)"
@@ -306,18 +302,17 @@ class BuildServerTest extends AbstractServerTest {
 
     @tailrec
     def drainQueuedNotificationsAndFailOnForbiddenReset(): Unit =
-      svr.session.waitForNotificationMsg(Duration.Zero)(_ => true) match {
+      svr.session.waitForNotificationMsg(Duration.Zero)(_ => true) match
         case Success(n) =>
           failIfForbiddenDiagnosticReset(n)
           drainQueuedNotificationsAndFailOnForbiddenReset()
         case Failure(_: TimeoutException) => ()
         case Failure(e)                   => throw e
-      }
 
     val buildTarget = buildTargetUri("diagnostics", "Compile")
     val mainFile = new File(svr.baseDirectory, "diagnostics/src/main/scala/Diagnostics.scala")
     val original = IO.read(mainFile)
-    try {
+    try
       IO.write(
         mainFile,
         """|object Diagnostics {
@@ -367,9 +362,8 @@ class BuildServerTest extends AbstractServerTest {
       svr.session.waitForResponseMsg(30.seconds, mainClassesId).get
 
       drainQueuedNotificationsAndFailOnForbiddenReset()
-    } finally {
-      IO.write(mainFile, original)
-    }
+    finally IO.write(mainFile, original)
+    end try
   }
 
   test("buildTarget/compile: Java diagnostics") {
@@ -859,7 +853,7 @@ class BuildServerTest extends AbstractServerTest {
   }
    */
 
-  private def initializeRequest(): String = {
+  private def initializeRequest(): String =
     val params = InitializeBuildParams(
       "test client",
       "1.0.0",
@@ -869,7 +863,6 @@ class BuildServerTest extends AbstractServerTest {
       None
     )
     sendRequest("build/initialize", params)
-  }
 
   private def assertProcessing(method: String): Unit =
     svr.session
@@ -881,47 +874,40 @@ class BuildServerTest extends AbstractServerTest {
   private def reloadWorkspace(): String =
     sendRequest("workspace/reload")
 
-  private def compile(buildTarget: URI): String = {
+  private def compile(buildTarget: URI): String =
     val params =
       CompileParams(targets = Vector(BuildTargetIdentifier(buildTarget)), None, Vector.empty)
     sendRequest("buildTarget/compile", params)
-  }
 
-  private def scalacOptions(buildTargets: Seq[URI]): String = {
+  private def scalacOptions(buildTargets: Seq[URI]): String =
     val targets = buildTargets.map(BuildTargetIdentifier.apply).toVector
     sendRequest("buildTarget/scalacOptions", ScalacOptionsParams(targets))
-  }
 
   // sbt serves javac options via buildTarget/scalacOptions (no separate javacOptions endpoint)
-  private def javacOptions(buildTargets: Seq[URI]): String = {
+  private def javacOptions(buildTargets: Seq[URI]): String =
     val targets = buildTargets.map(BuildTargetIdentifier.apply).toVector
     sendRequest("buildTarget/scalacOptions", ScalacOptionsParams(targets))
-  }
 
-  private def buildTargetSources(buildTargets: Seq[URI]): String = {
+  private def buildTargetSources(buildTargets: Seq[URI]): String =
     val targets = buildTargets.map(BuildTargetIdentifier.apply).toVector
     sendRequest("buildTarget/sources", SourcesParams(targets))
-  }
 
-  private def dependencyModules(buildTargets: Seq[URI]): String = {
+  private def dependencyModules(buildTargets: Seq[URI]): String =
     val targets = buildTargets.map(BuildTargetIdentifier.apply).toVector
     sendRequest("buildTarget/dependencyModules", DependencyModulesParams(targets))
-  }
 
-  private def sendRequest(method: String): String = {
+  private def sendRequest(method: String): String =
     val id = svr.session.nextId()
     svr.session.sendJsonRpc(id, method, "{}").get
-    if (method != "build/initialize") assertProcessing(method)
+    if method != "build/initialize" then assertProcessing(method)
     id
-  }
 
-  private def sendRequest[T: JsonWriter](method: String, params: T): String = {
+  private def sendRequest[T: JsonWriter](method: String, params: T): String =
     val id = svr.session.nextId()
     svr.session.sendJsonRpc(id, method, params).get
-    if (method != "build/initialize") assertProcessing(method)
+    if method != "build/initialize" then assertProcessing(method)
     id
-  }
 
   private def buildTargetUri(project: String, config: String): URI =
     new URI(s"${svr.baseDirectory.getAbsoluteFile.toURI}#$project/$config")
-}
+end BuildServerTest
diff --git a/server-test/src/test/scala/testpkg/ChannelCursorTest.scala b/server-test/src/test/scala/testpkg/ChannelCursorTest.scala
index b80737b52..c282d7fb3 100644
--- a/server-test/src/test/scala/testpkg/ChannelCursorTest.scala
+++ b/server-test/src/test/scala/testpkg/ChannelCursorTest.scala
@@ -14,13 +14,13 @@ import sbt.protocol.codec.JsonProtocol.given
 import sbt.internal.langserver.{ LogMessageParams, SbtExecParams }
 import sbt.internal.langserver.codec.JsonProtocol.given
 
-class ChannelCursorTest extends AbstractServerTest {
+class ChannelCursorTest extends AbstractServerTest:
   override val testDirectory: String = "channel-cursor"
 
   test("channel cursor - independent project cursors") {
     val portfile = testPath.resolve("project/target/active.json").toFile
     val session2 = ServerSession.connect(portfile)
-    try {
+    try
       session2.initialize(10.seconds, subscribeToAll = false)
 
       val switchToAResult = svr.session
@@ -64,12 +64,13 @@ class ChannelCursorTest extends AbstractServerTest {
         "Second channel should still be on projectB"
       )
       session2.waitForResultInResponseMsg[ExecStatusEvent](30.seconds, printB).get
-    } finally {
+    finally
       // close() may fail to join the read thread because UnixDomainSocket
       // input streams block until the server process exits (which happens
       // later in afterAll). Swallow the timeout.
       try session2.close()
-      catch { case _: Exception => }
-    }
+      catch
+        case _: Exception =>
+    end try
   }
-}
+end ChannelCursorTest
diff --git a/server-test/src/test/scala/testpkg/ClientBootTimeoutTest.scala b/server-test/src/test/scala/testpkg/ClientBootTimeoutTest.scala
index d0f6c76e9..f85ba1320 100644
--- a/server-test/src/test/scala/testpkg/ClientBootTimeoutTest.scala
+++ b/server-test/src/test/scala/testpkg/ClientBootTimeoutTest.scala
@@ -15,20 +15,20 @@ import sbt.internal.client.NetworkClient
 import sbt.internal.util.Util
 
 /** Runs the thin client against a fake sbt script; exits with the client's exit code. */
-object ClientBootTimeoutMain {
-  def main(args: Array[String]): Unit = {
+object ClientBootTimeoutMain:
+  def main(args: Array[String]): Unit =
     val Array(base, script) = args
     val code = NetworkClient.client(
       new File(base),
       Array(s"--sbt-script=$script", "willSucceed"),
-      new InputStream { override def read(): Int = -1 },
+      new InputStream:
+        override def read(): Int = -1
+      ,
       new PrintStream(OutputStream.nullOutputStream),
       new PrintStream(System.err, true),
       false
     )
     System.exit(code)
-  }
-}
 
 /**
  * A forked server that never writes its portfile must not hang the client forever:
@@ -36,15 +36,14 @@ object ClientBootTimeoutMain {
  * forked JVM because the timeout is configured via the SBT_CLIENT_CONNECT_TIMEOUT
  * environment variable, which cannot be set in-process.
  */
-class ClientBootTimeoutTest extends AbstractServerTest {
+class ClientBootTimeoutTest extends AbstractServerTest:
   override val testDirectory: String = "client"
 
-  private def fakeServer(script: String): String = {
+  private def fakeServer(script: String): String =
     val f = Files.createTempFile("fake-sbt", ".sh")
     Files.writeString(f, script)
     f.toFile.setExecutable(true)
     f.toString
-  }
 
   test("a forked server that never starts fails within the connect timeout") {
     val base = Files.createTempDirectory("connect-timeout-project").toFile
@@ -54,7 +53,8 @@ class ClientBootTimeoutTest extends AbstractServerTest {
     )
     val script = fakeServer("#!/usr/bin/env bash\necho fake-server-wedged >&2\nsleep 600\n")
     val errFile = Files.createTempFile("client-err", ".log")
-    val javaBin = Path.of(sys.props("java.home"), "bin", if (Util.isWindows) "java.exe" else "java")
+    val javaBin =
+      Path.of(sys.props("java.home"), "bin", if Util.isWindows then "java.exe" else "java")
     val testClasses = Path.of(getClass.getProtectionDomain.getCodeSource.getLocation.toURI)
     val pb = new ProcessBuilder(
       javaBin.toString,
@@ -70,7 +70,7 @@ class ClientBootTimeoutTest extends AbstractServerTest {
     val p = pb.start()
     val finished = p.waitFor(60, TimeUnit.SECONDS)
     val elapsed = (System.nanoTime() - started) / 1000000000L
-    if (!finished) p.destroyForcibly()
+    if !finished then p.destroyForcibly()
     assert(finished, "client is still hanging after 60 seconds")
     assert(p.exitValue != 0, s"expected failure, got ${p.exitValue}")
     assert(elapsed < 45, s"connect wait was not bounded by the timeout (${elapsed}s)")
@@ -81,4 +81,4 @@ class ClientBootTimeoutTest extends AbstractServerTest {
     )
     assert(errText.contains("fake-server-wedged"), s"server stderr not forwarded: $errText")
   }
-}
+end ClientBootTimeoutTest
diff --git a/server-test/src/test/scala/testpkg/ClientSubscriptionTest.scala b/server-test/src/test/scala/testpkg/ClientSubscriptionTest.scala
index 302654133..f95a4ca7b 100644
--- a/server-test/src/test/scala/testpkg/ClientSubscriptionTest.scala
+++ b/server-test/src/test/scala/testpkg/ClientSubscriptionTest.scala
@@ -12,7 +12,7 @@ import scala.concurrent.duration.*
 import sbt.internal.langserver.SbtExecParams
 import sbt.internal.langserver.codec.JsonProtocol.given
 
-class ClientSubscriptionTest extends AbstractServerTest {
+class ClientSubscriptionTest extends AbstractServerTest:
   override val testDirectory: String = "handshake"
 
   test("subscribe-to-all (default) client receives broadcast build/logMessage when command runs") {
@@ -20,9 +20,8 @@ class ClientSubscriptionTest extends AbstractServerTest {
     svr.session.sendJsonRpc(id, "sbt/exec", SbtExecParams("show name")).get
     svr.session.waitForNotificationMsg(10.seconds)(_.method == "build/logMessage").get
   }
-}
 
-class ClientNoSubscriptionTest extends AbstractServerTest {
+class ClientNoSubscriptionTest extends AbstractServerTest:
   override val testDirectory: String = "handshake"
   override def subscribeToAllForTest: Boolean = false
 
@@ -31,4 +30,3 @@ class ClientNoSubscriptionTest extends AbstractServerTest {
     svr.session.sendJsonRpc(id, "sbt/exec", SbtExecParams("show name")).get
     svr.session.waitForNotificationMsg(10.seconds)(_.method == "build/logMessage").get
   }
-}
diff --git a/server-test/src/test/scala/testpkg/ClientTest.scala b/server-test/src/test/scala/testpkg/ClientTest.scala
index 1ba5226b9..1101d90e5 100644
--- a/server-test/src/test/scala/testpkg/ClientTest.scala
+++ b/server-test/src/test/scala/testpkg/ClientTest.scala
@@ -15,67 +15,58 @@ import scala.collection.mutable
 
 import org.scalatest.BeforeAndAfterEach
 
-class ClientTest extends AbstractServerTest with BeforeAndAfterEach {
+class ClientTest extends AbstractServerTest with BeforeAndAfterEach:
   override val testDirectory: String = "client"
-  object NullInputStream extends InputStream {
-    override def read(): Int = {
+  object NullInputStream extends InputStream:
+    override def read(): Int =
       try this.synchronized(this.wait())
-      catch { case _: InterruptedException => }
+      catch
+        case _: InterruptedException =>
       -1
-    }
-  }
   val NullPrintStream = new PrintStream(_ => {}, false)
 
   class CachingPrintStream(cos: CachingOutputStream = new CachingOutputStream)
-      extends PrintStream(cos, true) {
+      extends PrintStream(cos, true):
     def lines = cos.lines
-  }
 
-  class CachingOutputStream extends OutputStream {
+  class CachingOutputStream extends OutputStream:
     private val byteBuffer = new mutable.ArrayBuffer[Byte]
     override def write(i: Int) = Util.ignoreResult(byteBuffer += i.toByte)
     def lines = new String(byteBuffer.toArray, "UTF-8").linesIterator.toSeq
-  }
-  class FixedInputStream(keys: Char*) extends InputStream {
+  class FixedInputStream(keys: Char*) extends InputStream:
     var i = 0
-    override def read(): Int = {
-      if (i < keys.length) {
+    override def read(): Int =
+      if i < keys.length then
         val res = keys(i).toInt
         i += 1
         res
-      } else -1
-    }
-  }
+      else -1
 
-  override def afterEach(): Unit = {
+  override def afterEach(): Unit =
     // Wait between tests so the server can clean up the previous client connection.
     // TODO: probably sometimes NetworkClient doesn't close correclty.
     //   Maybe it should be refactored to use `ServerSession.shutdown`
     //   instead of its' own shutdown logic
     super.afterEach()
     Thread.sleep(500)
-  }
 
-  private def background[R](f: => R): R = {
+  private def background[R](f: => R): R =
     val result = new LinkedBlockingQueue[Either[Throwable, R]]
-    val thread = new Thread("client-bg-thread") {
+    val thread = new Thread("client-bg-thread"):
       setDaemon(true)
       start()
       override def run(): Unit =
         result.put(
           try Right(f)
-          catch { case e: Throwable => Left(e) }
+          catch case e: Throwable => Left(e)
         )
-    }
-    result.poll(1, TimeUnit.MINUTES) match {
+    result.poll(1, TimeUnit.MINUTES) match
       case null =>
         thread.interrupt()
         thread.join(10000)
         throw new TimeoutException("background task did not complete within 1 minute")
       case Left(e)  => throw e
       case Right(r) => r
-    }
-  }
   private def client(args: String*): Int =
     background(
       NetworkClient.client(
@@ -87,7 +78,7 @@ class ClientTest extends AbstractServerTest with BeforeAndAfterEach {
         false
       )
     )
-  def clientWithStdoutLines(args: String*): (Int, Seq[String]) = {
+  def clientWithStdoutLines(args: String*): (Int, Seq[String]) =
     val out = new CachingPrintStream
     val exitCode = background(
       NetworkClient.client(
@@ -100,12 +91,11 @@ class ClientTest extends AbstractServerTest with BeforeAndAfterEach {
       )
     )
     (exitCode, out.lines)
-  }
   // This ensures that the completion command will send a tab that triggers
   // sbt to call definedTestNames or discoveredMainClasses if there hasn't
   // been a necessary compilation
   def tabs = new FixedInputStream('\t', '\t')
-  private def complete(completionString: String): Seq[String] = {
+  private def complete(completionString: String): Seq[String] =
     val cps = new CachingPrintStream
     background(
       NetworkClient.complete(
@@ -117,7 +107,6 @@ class ClientTest extends AbstractServerTest with BeforeAndAfterEach {
       )
     )
     cps.lines
-  }
   test("exit success") {
     assert(client("willSucceed") == 0)
   }
@@ -183,4 +172,4 @@ class ClientTest extends AbstractServerTest with BeforeAndAfterEach {
   test("quote with semi") {
     assert(complete("\"compile; fooB") == Vector("compile; fooBar"))
   }
-}
+end ClientTest
diff --git a/server-test/src/test/scala/testpkg/EventsTest.scala b/server-test/src/test/scala/testpkg/EventsTest.scala
index 74decf02c..78b23b5cd 100644
--- a/server-test/src/test/scala/testpkg/EventsTest.scala
+++ b/server-test/src/test/scala/testpkg/EventsTest.scala
@@ -14,7 +14,7 @@ import sbt.internal.langserver.{ LogMessageParams, SbtExecParams, CancelRequestP
 import sbt.internal.langserver.codec.JsonProtocol.given
 
 // starts svr using server-test/events and perform event related tests
-class EventsTest extends AbstractServerTest {
+class EventsTest extends AbstractServerTest:
   override val testDirectory: String = "events"
 
   test("report task failures in case of exceptions") {
@@ -64,4 +64,4 @@ class EventsTest extends AbstractServerTest {
       .get
     assert(cancelResult.status == "Task cancelled")
   }
-}
+end EventsTest
diff --git a/server-test/src/test/scala/testpkg/ExecRequiresInitializeTest.scala b/server-test/src/test/scala/testpkg/ExecRequiresInitializeTest.scala
index 7b5e74117..2c8dfafaa 100644
--- a/server-test/src/test/scala/testpkg/ExecRequiresInitializeTest.scala
+++ b/server-test/src/test/scala/testpkg/ExecRequiresInitializeTest.scala
@@ -31,14 +31,13 @@ import org.scalatest.funsuite.AnyFunSuite
  * deliberately skip `ServerSession#initialize` to play the part of an attacker who
  * can reach the socket but does not know the token.
  */
-class ExecRequiresInitializeTest extends AnyFunSuite {
+class ExecRequiresInitializeTest extends AnyFunSuite:
   private val testDirectory = "tcp"
 
-  private val serverTestBase: File = {
+  private val serverTestBase: File =
     val p0 = new File(".").getAbsoluteFile / "server-test" / "src" / "server-test"
     val p1 = new File(".").getAbsoluteFile / "src" / "server-test"
-    if (p0.exists) p0 else p1
-  }
+    if p0.exists then p0 else p1
 
   /** Forks a real sbt server for `testDirectory`, connects a raw (un-initialized) session. */
   private def withUnauthenticatedSession(f: ServerSession => Unit): Unit =
@@ -46,7 +45,7 @@ class ExecRequiresInitializeTest extends AnyFunSuite {
 
   private def withUnauthenticatedServer(
       extraJvmOptions: Vector[String]
-  )(f: (ServerSession, scala.sys.process.Process) => Unit): Unit = {
+  )(f: (ServerSession, scala.sys.process.Process) => Unit): Unit =
     val base: Path = Files.createTempDirectory(Path.of("/tmp"), "sbt-tcp-poc")
     val buildDir = base.toFile / testDirectory
     IO.copyDirectory(serverTestBase / testDirectory, buildDir)
@@ -69,7 +68,7 @@ class ExecRequiresInitializeTest extends AnyFunSuite {
       classpath.toSeq
     )
 
-    try {
+    try
       val portfile = buildDir / "project" / "target" / "active.json"
       ServerSession.waitForPortfile(portfile, process.isAlive())
 
@@ -79,18 +78,17 @@ class ExecRequiresInitializeTest extends AnyFunSuite {
         // attacker who can reach the TCP socket but never authenticates.
         f(session, process)
       finally session.close()
-    } finally {
-      if (process.isAlive()) process.destroy()
+    finally
+      if process.isAlive() then process.destroy()
       IO.delete(base.toFile)
-    }
-  }
+  end withUnauthenticatedServer
 
   /** Sends `method`/`params` on `session` and asserts the server rejected it pre-auth. */
   private def assertRejected[A: JsonWriter](
       session: ServerSession,
       method: String,
       params: A
-  ): Unit = {
+  ): Unit =
     val id = session.nextId()
     session.sendJsonRpc(id, method, params).get
     val response = session.waitForResponseMsg(30.seconds, id).get
@@ -100,7 +98,6 @@ class ExecRequiresInitializeTest extends AnyFunSuite {
       s"$method should have been rejected before initialize, but got: $response"
     )
     assertResult(ErrorCodes.InvalidRequest)(response.error.get.code)
-  }
 
   test("sbt/exec is rejected over TCP before a token-authenticated initialize") {
     withUnauthenticatedSession { session =>
@@ -139,8 +136,7 @@ class ExecRequiresInitializeTest extends AnyFunSuite {
   // the central gate rejects every non-handshake request before authentication regardless of
   // whether a handler is registered, so BSP methods (each of which would otherwise reach
   // appendExec) and any plugin-provided method are refused just like sbt/exec.
-  for (
-    method <- Seq(
+  for method <- Seq(
       "build/initialize",
       "workspace/buildTargets",
       "workspace/reload",
@@ -152,7 +148,7 @@ class ExecRequiresInitializeTest extends AnyFunSuite {
       "buildTarget/jvmRunEnvironment",
       "com.example/customPluginMethod",
     )
-  )
+  do
     test(s"$method is rejected over TCP before a token-authenticated initialize") {
       withUnauthenticatedSession { session =>
         assertRejected(session, method, SbtExecParams(""))
@@ -171,4 +167,4 @@ class ExecRequiresInitializeTest extends AnyFunSuite {
       )
     }
   }
-}
+end ExecRequiresInitializeTest
diff --git a/server-test/src/test/scala/testpkg/FailedLoadPromptTest.scala b/server-test/src/test/scala/testpkg/FailedLoadPromptTest.scala
index 02efc40b1..bbad53c0c 100644
--- a/server-test/src/test/scala/testpkg/FailedLoadPromptTest.scala
+++ b/server-test/src/test/scala/testpkg/FailedLoadPromptTest.scala
@@ -22,33 +22,28 @@ import scala.collection.mutable
  * The failed-load prompt must reach the interactive client that triggered the reload,
  * and its answer must get back to the server: typing 'r' retries the load.
  */
-class FailedLoadPromptTest extends AbstractServerTest {
+class FailedLoadPromptTest extends AbstractServerTest:
   override val testDirectory: String = "client"
 
-  private class CachingOutputStream extends OutputStream {
+  private class CachingOutputStream extends OutputStream:
     private val byteBuffer = new mutable.ArrayBuffer[Byte]
     override def write(i: Int) = Util.ignoreResult(synchronized(byteBuffer += i.toByte))
     def text: String = new String(synchronized(byteBuffer.toArray), "UTF-8")
-  }
   private class CachingPrintStream(val cos: CachingOutputStream = new CachingOutputStream)
-      extends PrintStream(cos, true) {
+      extends PrintStream(cos, true):
     def text: String = cos.text
-  }
-  private class QueueInputStream extends InputStream {
+  private class QueueInputStream extends InputStream:
     private val queue = new LinkedBlockingQueue[Integer]
     def push(s: String): Unit = s.getBytes("UTF-8").foreach(b => queue.put(b.toInt))
     override def read(): Int = queue.take()
-  }
 
-  private def awaitUntil(deadlineSeconds: Int)(condition: => Boolean): Boolean = {
+  private def awaitUntil(deadlineSeconds: Int)(condition: => Boolean): Boolean =
     val deadline = System.nanoTime + deadlineSeconds * 1000000000L
     var met = condition
-    while (!met && System.nanoTime < deadline) {
+    while !met && System.nanoTime < deadline do
       Thread.sleep(500)
       met = condition
-    }
     met
-  }
 
   test("an interactive client can answer the failed-load prompt") {
     val buildFile = testPath.resolve("build.sbt")
@@ -57,13 +52,11 @@ class FailedLoadPromptTest extends AbstractServerTest {
     val out = new CachingPrintStream
     val err = new CachingPrintStream
     val exitCode = new AtomicReference[Option[Int]](None)
-    val clientThread = new Thread("failed-load-prompt-test-client") {
+    val clientThread = new Thread("failed-load-prompt-test-client"):
       setDaemon(true)
-      override def run(): Unit = {
+      override def run(): Unit =
         val code = NetworkClient.client(testPath.toFile, Array.empty[String], in, out, err, false)
         exitCode.set(Some(code))
-      }
-    }
     clientThread.start()
     assert(awaitUntil(30)(out.text.contains("sbt:")), s"client never attached: ${out.text}")
 
@@ -89,4 +82,4 @@ class FailedLoadPromptTest extends AbstractServerTest {
     in.push("exit\r")
     assert(awaitUntil(60)(exitCode.get.isDefined), s"client did not exit: ${out.text}")
   }
-}
+end FailedLoadPromptTest
diff --git a/server-test/src/test/scala/testpkg/HandshakeTest.scala b/server-test/src/test/scala/testpkg/HandshakeTest.scala
index 6a14973a4..fc3956fbe 100644
--- a/server-test/src/test/scala/testpkg/HandshakeTest.scala
+++ b/server-test/src/test/scala/testpkg/HandshakeTest.scala
@@ -13,7 +13,7 @@ import sbt.protocol.SettingQuerySuccess
 import sjsonnew.shaded.scalajson.ast.unsafe.JString
 
 // starts svr using server-test/handshake and perform basic tests
-class HandshakeTest extends AbstractServerTest {
+class HandshakeTest extends AbstractServerTest:
   override val testDirectory: String = "handshake"
 
   test("handshake") {
@@ -29,4 +29,3 @@ class HandshakeTest extends AbstractServerTest {
       .get
     assert(response.value == JString("handshake"))
   }
-}
diff --git a/server-test/src/test/scala/testpkg/PortfileReloadTest.scala b/server-test/src/test/scala/testpkg/PortfileReloadTest.scala
index 2eab36cf4..05bc84e76 100644
--- a/server-test/src/test/scala/testpkg/PortfileReloadTest.scala
+++ b/server-test/src/test/scala/testpkg/PortfileReloadTest.scala
@@ -17,7 +17,7 @@ import scala.concurrent.duration.*
  * A project load closes the file tree repository and installs a new one, so a portfile watch that
  * a load does not outlive stops working after the first reload.
  */
-class PortfileReloadTest extends AbstractServerTest {
+class PortfileReloadTest extends AbstractServerTest:
   override val testDirectory: String = "client"
 
   private val settle = 30.seconds
@@ -28,4 +28,3 @@ class PortfileReloadTest extends AbstractServerTest {
     IO.write(portfile, """{"uri":"local:///displaced","serverId":"another-server"}""")
     assert(waitUntil(settle)(!svr.isAlive), "the displaced server exits")
   }
-}
diff --git a/server-test/src/test/scala/testpkg/PortfileTest.scala b/server-test/src/test/scala/testpkg/PortfileTest.scala
index 30fcabda9..99785926a 100644
--- a/server-test/src/test/scala/testpkg/PortfileTest.scala
+++ b/server-test/src/test/scala/testpkg/PortfileTest.scala
@@ -17,7 +17,7 @@ import scala.concurrent.duration.*
  * The portfile names the server that owns the socket. A second server binds the same socket path,
  * which leaves the first server holding a socket that no client can reach.
  */
-class PortfileTest extends AbstractServerTest {
+class PortfileTest extends AbstractServerTest:
   override val testDirectory: String = "client"
 
   private val settle = 30.seconds
@@ -35,4 +35,3 @@ class PortfileTest extends AbstractServerTest {
     assert(waitUntil(settle)(!svr.isAlive), "the displaced server exits")
     assert(IO.read(portfile) == replacement, "the displaced server does not delete the portfile")
   }
-}
diff --git a/server-test/src/test/scala/testpkg/QueuedNotificationTest.scala b/server-test/src/test/scala/testpkg/QueuedNotificationTest.scala
index e6aded5c7..c307a8c5f 100644
--- a/server-test/src/test/scala/testpkg/QueuedNotificationTest.scala
+++ b/server-test/src/test/scala/testpkg/QueuedNotificationTest.scala
@@ -13,7 +13,7 @@ import sbt.protocol.ExecStatusEvent
 import sbt.protocol.codec.JsonProtocol.given
 import sbt.internal.langserver.codec.JsonProtocol.given
 
-class QueuedNotificationTest extends AbstractServerTest {
+class QueuedNotificationTest extends AbstractServerTest:
   override val testDirectory: String = "queued"
 
   test("send Queued notification when command is queued behind another") {
@@ -39,4 +39,4 @@ class QueuedNotificationTest extends AbstractServerTest {
       svr.session.waitForResultInResponseMsg[ExecStatusEvent](10.seconds, quickId).get
     assert(quickResponse.status == "Done")
   }
-}
+end QueuedNotificationTest
diff --git a/server-test/src/test/scala/testpkg/RebootTest.scala b/server-test/src/test/scala/testpkg/RebootTest.scala
index 47f55c406..22a43f0f2 100644
--- a/server-test/src/test/scala/testpkg/RebootTest.scala
+++ b/server-test/src/test/scala/testpkg/RebootTest.scala
@@ -12,7 +12,7 @@ package testpkg
  * Regression for https://github.com/sbt/sbt/issues/9095: `reboot` from a client must bring the
  * server back and complete instead of leaving a zombie server that drops the client.
  */
-class RebootTest extends AbstractServerTest {
+class RebootTest extends AbstractServerTest:
   override val testDirectory: String = "client"
 
   test("reboot completes and the rebooted server serves the next command") {
@@ -22,4 +22,3 @@ class RebootTest extends AbstractServerTest {
       "the rebooted server must serve a new client connection"
     )
   }
-}
diff --git a/server-test/src/test/scala/testpkg/ResponseTest.scala b/server-test/src/test/scala/testpkg/ResponseTest.scala
index 48f914932..4bbbff4d2 100644
--- a/server-test/src/test/scala/testpkg/ResponseTest.scala
+++ b/server-test/src/test/scala/testpkg/ResponseTest.scala
@@ -13,7 +13,7 @@ import scala.util.{ Failure, Success }
 import sjsonnew.support.scalajson.unsafe.CompactPrinter
 
 // starts svr using server-test/response and perform custom server tests
-class ResponseTest extends AbstractServerTest {
+class ResponseTest extends AbstractServerTest:
   override val testDirectory: String = "response"
 
   test("response from a command") {
@@ -92,18 +92,16 @@ class ResponseTest extends AbstractServerTest {
   private def neverReceiveResponse(
       duration: FiniteDuration
   )(predicate: sbt.internal.protocol.JsonRpcResponseMessage => Boolean): Unit =
-    svr.session.waitForResponseMsg(duration)(predicate) match {
+    svr.session.waitForResponseMsg(duration)(predicate) match
       case Success(matched) =>
         fail(s"Expected no matching response, but received: $matched")
       case Failure(_: TimeoutException) => ()
       case Failure(e)                   => throw e
-    }
 
   private def neverReceiveResponseWithId(duration: FiniteDuration, id: String): Unit =
-    svr.session.waitForResponseMsg(duration, id) match {
+    svr.session.waitForResponseMsg(duration, id) match
       case Success(matched) =>
         fail(s"Expected no response for request $id, but received: $matched")
       case Failure(_: TimeoutException) => ()
       case Failure(e)                   => throw e
-    }
-}
+end ResponseTest
diff --git a/server-test/src/test/scala/testpkg/ServerCompletionsTest.scala b/server-test/src/test/scala/testpkg/ServerCompletionsTest.scala
index 012aec00b..b166b027a 100644
--- a/server-test/src/test/scala/testpkg/ServerCompletionsTest.scala
+++ b/server-test/src/test/scala/testpkg/ServerCompletionsTest.scala
@@ -11,7 +11,7 @@ import sbt.protocol.{ CompletionParams, CompletionResponse }
 import sbt.protocol.codec.JsonProtocol.given
 
 // starts svr using server-test/completions and perform sbt/completion tests
-class ServerCompletionsTest extends AbstractServerTest {
+class ServerCompletionsTest extends AbstractServerTest:
   override val testDirectory: String = "completions"
 
   test("return basic completions on request") {
@@ -37,4 +37,4 @@ class ServerCompletionsTest extends AbstractServerTest {
       .get
     assert(response.items.contains("testOnly org.sbt.ExampleSpec"))
   }
-}
+end ServerCompletionsTest
diff --git a/server-test/src/test/scala/testpkg/ServerSysPropsTest.scala b/server-test/src/test/scala/testpkg/ServerSysPropsTest.scala
index ab2355051..6c15ed1d3 100644
--- a/server-test/src/test/scala/testpkg/ServerSysPropsTest.scala
+++ b/server-test/src/test/scala/testpkg/ServerSysPropsTest.scala
@@ -24,28 +24,26 @@ import org.scalatest.funsuite.AnyFunSuite
  * The thin client can only pass `-D` options to a server it starts itself, so a server
  * that is already running has to be restarted for them to take effect (sbt/sbt#9682).
  */
-class ServerSysPropsTest extends AnyFunSuite {
+class ServerSysPropsTest extends AnyFunSuite:
   private val testDirectory = "client"
   private val sysPropsEnv = "SBT_SERVER_SYS_PROPS"
   private val sysPropsPortfileEnv = "SBT_SERVER_SYS_PROPS_PORTFILE"
 
-  private val serverTestBase: File = {
+  private val serverTestBase: File =
     val p0 = new File(".").getAbsoluteFile / "server-test" / "src" / "server-test"
     val p1 = new File(".").getAbsoluteFile / "src" / "server-test"
-    if (p0.exists) p0 else p1
-  }
+    if p0.exists then p0 else p1
 
   private def portfile(buildDir: File): File =
     buildDir / "project" / "target" / "active.json"
 
   /** A script that stands in for the sbt script and never brings a server up. */
-  private def deadScript(): String = {
+  private def deadScript(): String =
     val f = Files.createTempFile("dead-sbt", ".sh")
     Files.writeString(f, "#!/usr/bin/env bash\necho dead-server >&2\nexit 1\n")
     f.toFile.setExecutable(true)
     f.toFile.deleteOnExit()
     f.toString
-  }
 
   /**
    * Forks a server with the environment a client sets when it starts one. `optionsFor` is
@@ -55,7 +53,7 @@ class ServerSysPropsTest extends AnyFunSuite {
   private def withServer(
       sysProps: Seq[String],
       optionsFor: Option[File] = None
-  )(f: (File, scala.sys.process.Process) => Unit): Unit = {
+  )(f: (File, scala.sys.process.Process) => Unit): Unit =
     val base: Path = Files.createTempDirectory("sbt-sysprops")
     val buildDir = base.toFile / testDirectory
     IO.copyDirectory(serverTestBase / testDirectory, buildDir)
@@ -83,47 +81,46 @@ class ServerSysPropsTest extends AnyFunSuite {
       classpath.toSeq
     )
 
-    try {
+    try
       ServerSession.waitForPortfile(portfile(buildDir), process.isAlive())
       f(buildDir, process)
-    } finally {
-      if (process.isAlive()) process.destroy()
+    finally
+      if process.isAlive() then process.destroy()
       IO.delete(base.toFile)
-    }
-  }
+  end withServer
 
-  private class CachingOutputStream extends OutputStream {
+  private class CachingOutputStream extends OutputStream:
     private val bytes = new mutable.ArrayBuffer[Byte]
-    override def write(i: Int): Unit = { bytes += i.toByte; () }
+    override def write(i: Int): Unit =
+      bytes += i.toByte; ()
     def text: String = new String(bytes.toArray, "UTF-8")
-  }
 
   /** Runs the thin client, returning its exit code and everything it logged. */
-  private def client(baseDirectory: File, args: String*): (Int, String) = {
+  private def client(baseDirectory: File, args: String*): (Int, String) =
     val cos = new CachingOutputStream
     val out = new PrintStream(cos, true)
-    try {
+    try
       val code = NetworkClient.client(
         baseDirectory,
         args.toArray,
-        new InputStream { override def read(): Int = -1 },
+        new InputStream:
+          override def read(): Int = -1
+        ,
         out,
         out,
         false
       )
       (code, cos.text)
-    } finally
+    finally
       // the client sets every -D option it parses on its own JVM, which here is the test JVM
       args.foreach { a =>
-        if (a.startsWith("-D")) System.clearProperty(a.drop(2).takeWhile(_ != '='))
+        if a.startsWith("-D") then System.clearProperty(a.drop(2).takeWhile(_ != '='))
       }
-  }
 
-  private def exited(process: scala.sys.process.Process): Boolean = {
+  private def exited(process: scala.sys.process.Process): Boolean =
     val deadline = System.nanoTime + 60L * 1000000000L
-    while (process.isAlive() && System.nanoTime < deadline) Thread.sleep(50)
+    while process.isAlive() && System.nanoTime < deadline do Thread.sleep(50)
     !process.isAlive()
-  }
 
   test("the server records the -D options it was started with, without their values") {
     withServer(Seq("-Dmy.prop=hunter2")) { (buildDir, _) =>
@@ -151,7 +148,9 @@ class ServerSysPropsTest extends AnyFunSuite {
         buildDir,
         Array("--completions=sbtn comp"),
         false,
-        new InputStream { override def read(): Int = -1 },
+        new InputStream:
+          override def read(): Int = -1
+        ,
         out
       )
       assert(process.isAlive(), "a completion query shut the server down")
@@ -247,38 +246,38 @@ class ServerSysPropsTest extends AnyFunSuite {
 
   test("sbt.server.autorestart=false keeps the running server and says what it is missing") {
     withServer(Seq("-Dmy.prop=first")) { (buildDir, process) =>
-      try {
+      try
         val (code, log) =
           client(buildDir, "-Dsbt.server.autorestart=false", "-Dmy.prop=second", "willSucceed")
         assert(code == 0, log)
         assert(process.isAlive(), s"the server was restarted with autorestart turned off: $log")
         assert(log.contains("cannot pick up"), log)
         assert(log.contains("changed: my.prop"), log)
-      } finally System.clearProperty("sbt.server.autorestart")
+      finally System.clearProperty("sbt.server.autorestart")
     }
   }
 
   test("sbt.server.autostart=false keeps the running server and says what it is missing") {
     withServer(Seq("-Dmy.prop=first")) { (buildDir, process) =>
-      try {
+      try
         val (code, log) =
           client(buildDir, "-Dsbt.server.autostart=false", "-Dmy.prop=second", "willSucceed")
         assert(code == 0, log)
         assert(process.isAlive(), s"the server was restarted with autostart turned off: $log")
         assert(log.contains("cannot pick up"), log)
         assert(log.contains("changed: my.prop"), log)
-      } finally System.clearProperty("sbt.server.autostart")
+      finally System.clearProperty("sbt.server.autostart")
     }
   }
 
   test("what a client is missing doesn't include the values") {
     withServer(Seq("-Dmy.prop=hunter2")) { (buildDir, process) =>
-      try {
+      try
         val (_, log) =
           client(buildDir, "-Dsbt.server.autorestart=false", "-Dmy.prop=hunter3", "willSucceed")
         assert(process.isAlive(), log)
         assert(!log.contains("hunter2") && !log.contains("hunter3"), log)
-      } finally System.clearProperty("sbt.server.autorestart")
+      finally System.clearProperty("sbt.server.autorestart")
     }
   }
-}
+end ServerSysPropsTest
diff --git a/server-test/src/test/scala/testpkg/TerminalMapsDrainTest.scala b/server-test/src/test/scala/testpkg/TerminalMapsDrainTest.scala
index 93b4ba9ab..0bb5ee3db 100644
--- a/server-test/src/test/scala/testpkg/TerminalMapsDrainTest.scala
+++ b/server-test/src/test/scala/testpkg/TerminalMapsDrainTest.scala
@@ -20,7 +20,7 @@ import sbt.internal.langserver.codec.JsonProtocol.given
  * Regression: a client that dies while the server waits on a terminal control answer
  * must not strand the parked server-side thread.
  */
-class TerminalMapsDrainTest extends AbstractServerTest {
+class TerminalMapsDrainTest extends AbstractServerTest:
   override val testDirectory: String = "client"
 
   test("a client dying at a failed-reload prompt does not strand the server") {
@@ -29,7 +29,7 @@ class TerminalMapsDrainTest extends AbstractServerTest {
     val goodBuild = java.nio.file.Files.readString(buildFile)
     val silent = SilentTerminalSession.connect(portfile)
     var parkedOn = "none"
-    try {
+    try
       silent.initialize(10.seconds, false).get
       Util.ignoreResult(
         silent.sendJsonRpc(silent.nextId(), Serialization.attach, Attach(interactive = true))
@@ -41,11 +41,10 @@ class TerminalMapsDrainTest extends AbstractServerTest {
       assert(queried || input, "server never queried the terminal nor requested input")
       // the command loop is now parked waiting for an answer that never comes
       parkedOn =
-        Option(silent.firstSilentQuery.get).getOrElse(if (input) "readSystemIn" else "unknown")
-    } finally {
+        Option(silent.firstSilentQuery.get).getOrElse(if input then "readSystemIn" else "unknown")
+    finally
       silent.close()
       java.nio.file.Files.writeString(buildFile, goodBuild)
-    }
     // EOF at the failed-load prompt maps to 'q' by design: the server must shut down
     // cleanly rather than stay parked on the dead client's unanswered query.
     def serverAlive: Boolean =
@@ -53,7 +52,7 @@ class TerminalMapsDrainTest extends AbstractServerTest {
         ph.info.command.orElse("").contains("java")
       }
     val deadline = 90.seconds.fromNow
-    while (serverAlive && deadline.hasTimeLeft()) Thread.sleep(500)
+    while serverAlive && deadline.hasTimeLeft() do Thread.sleep(500)
     assert(!serverAlive, s"server must exit after the prompting client dies (parked on $parkedOn)")
   }
-}
+end TerminalMapsDrainTest
diff --git a/server-test/src/test/scala/testpkg/TerminalPropertiesFreezeTest.scala b/server-test/src/test/scala/testpkg/TerminalPropertiesFreezeTest.scala
index 2093b0815..efe0f1c4c 100644
--- a/server-test/src/test/scala/testpkg/TerminalPropertiesFreezeTest.scala
+++ b/server-test/src/test/scala/testpkg/TerminalPropertiesFreezeTest.scala
@@ -18,13 +18,13 @@ import sbt.protocol.codec.JsonProtocol.given
  * Regression: one attached client that answers the terminal-properties query with a
  * malformed response must not freeze the server for every other client.
  */
-class TerminalPropertiesFreezeTest extends AbstractServerTest {
+class TerminalPropertiesFreezeTest extends AbstractServerTest:
   override val testDirectory: String = "client"
 
   test("a client with a broken terminal-properties response does not freeze the server") {
     val portfile = new java.io.File(testPath.toFile, "project/target/active.json")
     val faulty = FaultyTerminalSession.connect(portfile)
-    try {
+    try
       faulty.initialize(10.seconds, false).get
       Util.ignoreResult(
         faulty.sendJsonRpc(faulty.nextId(), Serialization.attach, Attach(interactive = true))
@@ -35,6 +35,5 @@ class TerminalPropertiesFreezeTest extends AbstractServerTest {
       )
       assert(runBatchClient("willSucceed") == 0, "a well-behaved client must still be served")
       assert(runBatchClient("willSucceed") == 0, "the server must stay serviceable")
-    } finally faulty.close()
+    finally faulty.close()
   }
-}
diff --git a/tasks-standard/src/main/scala/sbt/std/Streams.scala b/tasks-standard/src/main/scala/sbt/std/Streams.scala
index 9d33c7dad..39c5e868c 100644
--- a/tasks-standard/src/main/scala/sbt/std/Streams.scala
+++ b/tasks-standard/src/main/scala/sbt/std/Streams.scala
@@ -25,7 +25,7 @@ import sbt.util.*
  * a particular scoped key. For example, logging for Test/compile is by default sent to the "out"
  * stream in the Test/compile context.
  */
-sealed trait TaskStreams[Key] {
+sealed trait TaskStreams[Key]:
 
   /** The default stream ID, used when an ID is not provided. */
   def default = outID
@@ -75,50 +75,43 @@ sealed trait TaskStreams[Key] {
   def log(sid: String): ManagedLogger
 
   private def getID(s: Option[String]) = s getOrElse default
-}
-sealed trait ManagedStreams[Key] extends TaskStreams[Key] {
+end TaskStreams
+sealed trait ManagedStreams[Key] extends TaskStreams[Key]:
   def open(): Unit
   def close(): Unit
   def isClosed: Boolean
-}
 
-trait Streams[Key] {
+trait Streams[Key]:
   def apply(a: Key): ManagedStreams[Key]
-  def use[T](key: Key)(f: TaskStreams[Key] => T): T = {
+  def use[T](key: Key)(f: TaskStreams[Key] => T): T =
     val s = apply(key)
     s.open()
-    try {
+    try
       f(s)
-    } finally {
+    finally
       s.close()
-    }
-  }
-}
 trait CloseableStreams[Key] extends Streams[Key] with java.io.Closeable
-object Streams {
+object Streams:
   private val closeQuietly = (c: Closeable) =>
-    try {
-      c.close()
-    } catch { case _: IOException => () }
+    try c.close()
+    catch case _: IOException => ()
   private val streamLocks = new ConcurrentHashMap[File, AnyRef]()
 
-  def closeable[Key](delegate: Streams[Key]): CloseableStreams[Key] = new CloseableStreams[Key] {
+  def closeable[Key](delegate: Streams[Key]): CloseableStreams[Key] = new CloseableStreams[Key]:
     private val streams = new collection.mutable.HashMap[Key, ManagedStreams[Key]]
 
     def apply(key: Key): ManagedStreams[Key] =
       synchronized {
-        streams.get(key) match {
+        streams.get(key) match
           case Some(s) if !s.isClosed => s
           case _                      =>
             val newS = delegate(key)
             streams.put(key, newS)
             newS
-        }
       }
 
     def close(): Unit =
       synchronized { streams.values.foreach(_.close()); streams.clear() }
-  }
 
   def apply[Key](
       taskDirectory: Key => File,
@@ -137,7 +130,7 @@ object Streams {
       mkLogger: (Key, PrintWriter) => ManagedLogger,
       mkFactory: File => CacheStoreFactory
   ): Streams[Key] = (a: Key) =>
-    new ManagedStreams[Key] {
+    new ManagedStreams[Key]:
       private var opened: List[Closeable] = nil
       private var closed = false
 
@@ -169,11 +162,10 @@ object Streams {
       def binary(sid: String = default): BufferedOutputStream =
         make(a, sid)(f => new BufferedOutputStream(new FileOutputStream(f)))
 
-      lazy val cacheDirectory: File = {
+      lazy val cacheDirectory: File =
         val dir = taskDirectory(a)
         IO.createDirectory(dir)
         dir
-      }
 
       lazy val cacheStoreFactory: CacheStoreFactory = mkFactory(cacheDirectory)
 
@@ -184,18 +176,16 @@ object Streams {
         val file = taskDirectory(a) / sid
         val parent = file.getParentFile
         val newLock = new AnyRef
-        val lock = streamLocks.putIfAbsent(parent, newLock) match {
+        val lock = streamLocks.putIfAbsent(parent, newLock) match
           case null => newLock
           case l    => l
-        }
         try
           lock.synchronized {
-            if (!file.exists) IO.touch(file, setModified = false)
+            if !file.exists then IO.touch(file, setModified = false)
           }
-        finally {
+        finally
           streamLocks.remove(parent)
           ()
-        }
         val t = f(file)
         opened ::= (t: Closeable)
         t
@@ -206,13 +196,11 @@ object Streams {
       def isClosed: Boolean = synchronized { closed }
 
       def close(): Unit = synchronized {
-        if (!closed) {
+        if !closed then
           closed = true
           opened foreach closeQuietly
-        }
       }
       def checkOpen(): Unit = synchronized {
-        if (closed) sys.error("Streams for '" + name(a) + "' have been closed.")
+        if closed then sys.error("Streams for '" + name(a) + "' have been closed.")
       }
-    }
-}
+end Streams
diff --git a/tasks-standard/src/main/scala/sbt/std/TaskExtra.scala b/tasks-standard/src/main/scala/sbt/std/TaskExtra.scala
index 86946e50e..9bc79bff9 100644
--- a/tasks-standard/src/main/scala/sbt/std/TaskExtra.scala
+++ b/tasks-standard/src/main/scala/sbt/std/TaskExtra.scala
@@ -18,16 +18,15 @@ import java.io.{ BufferedInputStream, BufferedReader, File, InputStream }
 import sbt.io.IO
 import sbt.internal.Action
 
-sealed trait MultiInTask[Tup <: Tuple] {
+sealed trait MultiInTask[Tup <: Tuple]:
   def flatMapN[A](f: Tup => Task[A]): Task[A]
   def flatMapR[A](f: Tuple.Map[Tup, Result] => Task[A]): Task[A]
   def mapN[A](f: Tup => A): Task[A]
   def mapR[A](f: Tuple.Map[Tup, Result] => A): Task[A]
   def flatFailure[A](f: Seq[Incomplete] => Task[A]): Task[A]
   def mapFailure[A](f: Seq[Incomplete] => A): Task[A]
-}
 
-sealed trait SingleInTask[S] {
+sealed trait SingleInTask[S]:
   def flatMapN[T](f: S => Task[T]): Task[T]
   def flatMap[T](f: S => Task[T]): Task[T]
   def mapN[T](f: S => T): Task[T]
@@ -65,29 +64,25 @@ sealed trait SingleInTask[S] {
     "0.13.0"
   )
   def flatMapR[T](f: Result[S] => Task[T]): Task[T]
-}
-sealed trait ForkTask[S, CC[_]] {
+end SingleInTask
+sealed trait ForkTask[S, CC[_]]:
   def fork[T](f: S => T): CC[Task[T]]
   def tasks: Seq[Task[S]]
-}
-sealed trait JoinTask[S, CC[_]] {
+sealed trait JoinTask[S, CC[_]]:
   def join: Task[CC[S]]
   // had to rename from 'reduce' for 2.9.0
   def reduced(f: (S, S) => S): Task[S]
-}
 
-trait TaskExtra0 {
+trait TaskExtra0:
   final implicit def joinAnyTasks(in: Seq[Task[?]]): JoinTask[Any, Seq] =
     joinTasks0[Any](existToAny(in))
-  private[sbt] def joinTasks0[S](in: Seq[Task[S]]): JoinTask[S, Seq] = new JoinTask[S, Seq] {
+  private[sbt] def joinTasks0[S](in: Seq[Task[S]]): JoinTask[S, Seq] = new JoinTask[S, Seq]:
     def join: Task[Seq[S]] =
       Task[Seq[S]](Action.Join(in, (s: Seq[Result[S]]) => Right(TaskExtra.all(s))))
     def reduced(f: (S, S) => S): Task[S] = TaskExtra.reduced(in.toIndexedSeq, f)
-  }
   private[sbt] def existToAny(in: Seq[Task[?]]): Seq[Task[Any]] = in.asInstanceOf[Seq[Task[Any]]]
-}
 
-trait TaskExtra extends TaskExtra0 {
+trait TaskExtra extends TaskExtra0:
   final def nop: Task[Unit] = constant(())
   final def constant[T](t: T): Task[T] = task(t)
 
@@ -100,18 +95,16 @@ trait TaskExtra extends TaskExtra0 {
   }
 
   final implicit def toTasks[S](in: Seq[() => S]): Seq[Task[S]] = in.map(toTask)
-  final implicit def iterableTask[S](in: Seq[S]): ForkTask[S, Seq] = new ForkTask[S, Seq] {
+  final implicit def iterableTask[S](in: Seq[S]): ForkTask[S, Seq] = new ForkTask[S, Seq]:
     def fork[T](f: S => T): Seq[Task[T]] = in.map(x => task(f(x)))
     def tasks: Seq[Task[S]] = fork(identity)
-  }
 
   import TaskExtra.{ allM, anyFailM, failM, successM }
 
-  final implicit def joinTasks[S](in: Seq[Task[S]]): JoinTask[S, Seq] = new JoinTask[S, Seq] {
+  final implicit def joinTasks[S](in: Seq[Task[S]]): JoinTask[S, Seq] = new JoinTask[S, Seq]:
     def join: Task[Seq[S]] =
       Task[Seq[S]](Action.Join(in, (s: Seq[Result[S]]) => Right(TaskExtra.all(s))))
     def reduced(f: (S, S) => S): Task[S] = TaskExtra.reduced(in.toIndexedSeq, f)
-  }
 
   final implicit def multT2Task[A1, A2](in: (Task[A1], Task[A2])): MultiInTask[(A1, A2)] =
     multInputTask[(A1, A2)](in)
@@ -184,14 +177,13 @@ trait TaskExtra extends TaskExtra0 {
       }
       def &&[T](alt: Task[T]): Task[T] = flatMapN(_ => alt)
 
-  extension [S](in: Task[S]) {
+  extension [S](in: Task[S])
     def describedAs(s: String): Task[S] = in.setDescription(s)
     def named(s: String): Task[S] = in.setName(s)
-  }
 
   extension [Key](
       t: Task[?]
-  )(using streams: Task[TaskStreams[Key]], key: Task[?] => Key) {
+  )(using streams: Task[TaskStreams[Key]], key: Task[?] => Key)
     def #|(p: ProcessBuilder): Task[Int] = pipe0(None, p)
     def pipe(sid: String)(p: ProcessBuilder): Task[Int] = pipe0(Some(sid), p)
     private def pipe0(sid: Option[String], p: ProcessBuilder): Task[Int] =
@@ -199,17 +191,18 @@ trait TaskExtra extends TaskExtra0 {
         val in = s.readBinary(key(t), sid)
         val pio = TaskExtra
           .processIO(s)
-          .withInput(out => { BasicIO.transferFully(in, out); out.close() })
+          .withInput(out =>
+            BasicIO.transferFully(in, out); out.close()
+          )
         (p run pio).exitValue()
       }
-  }
 
   extension [Key](
       in: Task[?]
   )(using
       @nowarn("msg=unused") streams: Task[TaskStreams[Key]],
       @nowarn("msg=unused") key: Task[?] => Key
-  ) {
+  )
     def binary[T](f: BufferedInputStream => T): Task[T] = pipeBinary(None, f)
     def binary[T](sid: String)(f: BufferedInputStream => T): Task[T] = pipeBinary(Some(sid), f)
 
@@ -222,11 +215,10 @@ trait TaskExtra extends TaskExtra0 {
       }
 
     private def toFile(f: File) = (in: InputStream) => IO.transfer(in, f)
-  }
 
   extension [Key](
       in: Task[?]
-  )(using streams: Task[TaskStreams[Key]], key: Task[?] => Key) {
+  )(using streams: Task[TaskStreams[Key]], key: Task[?] => Key)
     def text[T](f: BufferedReader => T): Task[T] = pipe0(None, f)
     def text[T](sid: String)(f: BufferedReader => T): Task[T] = pipe0(Some(sid), f)
 
@@ -234,10 +226,9 @@ trait TaskExtra extends TaskExtra0 {
       streams.mapN { s =>
         f(s.readText(key(in), sid))
       }
-  }
   extension [Key](
       in: Task[?]
-  )(using streams: Task[TaskStreams[Key]], key: Task[?] => Key) {
+  )(using streams: Task[TaskStreams[Key]], key: Task[?] => Key)
     def lines: Task[List[String]] = lines0(None)
     def lines(sid: String): Task[List[String]] = lines0(Some(sid))
 
@@ -245,37 +236,33 @@ trait TaskExtra extends TaskExtra0 {
       streams map { s =>
         IO.readLines(s.readText(key(in), sid))
       }
-  }
   implicit def processToTask(p: ProcessBuilder)(using streams: Task[TaskStreams[?]]): Task[Int] =
     streams map { s =>
       val pio = TaskExtra.processIO(s)
       (p run pio).exitValue()
     }
-}
+end TaskExtra
 
-object TaskExtra extends TaskExtra {
-  def processIO(s: TaskStreams[?]): ProcessIO = {
+object TaskExtra extends TaskExtra:
+  def processIO(s: TaskStreams[?]): ProcessIO =
     def transfer(id: String) = (in: InputStream) => BasicIO.transferFully(in, s.binary(id))
     new ProcessIO(_.close(), transfer(s.outID), transfer(s.errorID))
-  }
   def reduced[S](i: IndexedSeq[Task[S]], f: (S, S) => S): Task[S] =
-    i match {
+    i match
       case Seq()     => sys.error("Cannot reduce empty sequence")
       case Seq(x)    => x
       case Seq(x, y) => reducePair(x, y, f)
       case _         =>
         val (a, b) = i.splitAt(i.size / 2)
         reducePair(reduced(a, f), reduced(b, f), f)
-    }
 
   def reducePair[A1](a: Task[A1], b: Task[A1], f: (A1, A1) => A1): Task[A1] =
     multInputTask[(A1, A1)]((a, b)).mapN(f.tupled)
 
-  def anyFailM[Tup <: Tuple]: Tuple.Map[Tup, Result] => Seq[Incomplete] = in => {
+  def anyFailM[Tup <: Tuple]: Tuple.Map[Tup, Result] => Seq[Incomplete] = in =>
     val incs = failuresM[Tup](in)
     if incs.isEmpty then expectedFailure
     else incs
-  }
 
   def failM[A]: Result[A] => Incomplete = {
     case Result.Inc(i) => i
@@ -289,18 +276,16 @@ object TaskExtra extends TaskExtra {
     case Result.Value(a) => a
   }
 
-  def allM[Tup <: Tuple]: Tuple.Map[Tup, Result] => Tup = in => {
+  def allM[Tup <: Tuple]: Tuple.Map[Tup, Result] => Tup = in =>
     val incs = failuresM[Tup](in)
     if incs.isEmpty then in.unmap(Result.tryValue)
     else throw incompleteDeps(incs)
-  }
   def failuresM[Tup <: Tuple]: Tuple.Map[Tup, Result] => Seq[Incomplete] = x => failures(x.toList0)
 
-  def all[D](in: Seq[Result[D]]): Seq[D] = {
+  def all[D](in: Seq[Result[D]]): Seq[D] =
     val incs = failures(in)
     if incs.isEmpty then in.map(Result.tryValue[D])
     else throw incompleteDeps(incs)
-  }
   def failures[A](results: Seq[Result[A]]): Seq[Incomplete] = results.collect {
     case Result.Inc(i) => i
   }
@@ -314,4 +299,4 @@ object TaskExtra extends TaskExtra {
   // But apparently it *cannot* survive a task map/flatMap/etc. See actions/depends-on.
   private[sbt] def newAttributes(attributes: AttributeMap): AttributeMap =
     AttributeMap(attributes.entries.filter(_.key.label != "taskDefinitionKey"))
-}
+end TaskExtra
diff --git a/tasks-standard/src/main/scala/sbt/std/Transform.scala b/tasks-standard/src/main/scala/sbt/std/Transform.scala
index f10d4735f..48e24542c 100644
--- a/tasks-standard/src/main/scala/sbt/std/Transform.scala
+++ b/tasks-standard/src/main/scala/sbt/std/Transform.scala
@@ -21,21 +21,18 @@ object Transform:
 
   def fromDummyStrict[T](original: Task[T], value: T): Task[T] = fromDummy(original)(value)
 
-  final case class DummyTaskMap(mappings: List[TaskAndValue[?]]) {
+  final case class DummyTaskMap(mappings: List[TaskAndValue[?]]):
     def ::[T](tav: (Task[T], T)): DummyTaskMap =
       DummyTaskMap(new TaskAndValue(tav._1, tav._2) :: mappings)
-  }
 
   final class TaskAndValue[T](val task: Task[T], val value: T)
 
-  def dummyMap(dummyMap: DummyTaskMap): [A] => TaskId[A] => Option[Task[A]] = {
+  def dummyMap(dummyMap: DummyTaskMap): [A] => TaskId[A] => Option[Task[A]] =
     val pmap = new DelegatingPMap[TaskId, Task](new collection.mutable.HashMap)
-    def add[T](dummy: TaskAndValue[T]): Unit = {
+    def add[T](dummy: TaskAndValue[T]): Unit =
       pmap(dummy.task) = fromDummyStrict(dummy.task, dummy.value)
-    }
     dummyMap.mappings.foreach(x => add(x))
     ([A] => (task: TaskId[A]) => pmap.get(task))
-  }
 
   /** Applies `map`, returning the result if defined or returning the input unchanged otherwise. */
   private def getOrId(map: [A] => TaskId[A] => Option[Task[A]]): [A] => TaskId[A] => Task[A] =
diff --git a/tasks-standard/src/test/scala/Execute.scala b/tasks-standard/src/test/scala/Execute.scala
index e416c4a6f..d72426235 100644
--- a/tasks-standard/src/test/scala/Execute.scala
+++ b/tasks-standard/src/test/scala/Execute.scala
@@ -12,7 +12,7 @@ import org.scalacheck.*
 import Prop.*
 import TaskGen.*
 
-object ExecuteSpec extends Properties("Execute") {
+object ExecuteSpec extends Properties("Execute"):
   val iGen = Arbitrary.arbInt.arbitrary
   property("evaluates simple task") = forAll(iGen, MaxWorkersGen) { (i: Int, workers: Int) =>
     ("Workers: " + workers) |:
@@ -50,4 +50,4 @@ object ExecuteSpec extends Properties("Execute") {
         checkResult(result, i * times)
       }
   }
-}
+end ExecuteSpec
diff --git a/tasks-standard/src/test/scala/TaskGen.scala b/tasks-standard/src/test/scala/TaskGen.scala
index deb43d76e..d053b8384 100644
--- a/tasks-standard/src/test/scala/TaskGen.scala
+++ b/tasks-standard/src/test/scala/TaskGen.scala
@@ -11,7 +11,7 @@ package sbt
 import org.scalacheck.*
 import Gen.choose
 
-object TaskGen extends std.TaskExtra {
+object TaskGen extends std.TaskExtra:
   // upper bounds to make the tests finish in reasonable time
   val MaxTasks = 100
   val MaxWorkers = 29
@@ -22,7 +22,7 @@ object TaskGen extends std.TaskExtra {
   val MaxJoinGen = choose(0, MaxJoin)
   val TaskListGen = MaxTasksGen.flatMap(size => Gen.listOfN(size, Arbitrary.arbInt.arbitrary))
 
-  def run[T](root: Task[T], checkCycles: Boolean, maxWorkers: Int): Result[T] = {
+  def run[T](root: Task[T], checkCycles: Boolean, maxWorkers: Int): Result[T] =
     val (service, shutdown) = CompletionService(maxWorkers)
     val dummies = std.Transform.DummyTaskMap(Nil)
     val x = new Execute(
@@ -30,15 +30,12 @@ object TaskGen extends std.TaskExtra {
       Execute.noTriggers,
       ExecuteProgress.empty
     )(using std.Transform(dummies))
-    try {
+    try
       x.run(root)(using service)
-    } finally {
+    finally
       shutdown()
-    }
-  }
   def tryRun[T](root: Task[T], checkCycles: Boolean, maxWorkers: Int): T =
-    run(root, checkCycles, maxWorkers) match {
+    run(root, checkCycles, maxWorkers) match
       case Result.Value(v) => v
       case Result.Inc(i)   => throw i
-    }
-}
+end TaskGen
diff --git a/tasks-standard/src/test/scala/TaskRunnerCircular.scala b/tasks-standard/src/test/scala/TaskRunnerCircular.scala
index a8b3eed72..00378a8ce 100644
--- a/tasks-standard/src/test/scala/TaskRunnerCircular.scala
+++ b/tasks-standard/src/test/scala/TaskRunnerCircular.scala
@@ -12,44 +12,35 @@ import org.scalacheck.*
 import Prop.*
 import TaskGen.*
 
-object TaskRunnerCircularTest extends Properties("TaskRunner Circular") {
+object TaskRunnerCircularTest extends Properties("TaskRunner Circular"):
   property("Catches circular references") = forAll(MaxTasksGen, MaxWorkersGen) {
     checkCircularReferences
   }
   property("Allows references to completed tasks") = forAllNoShrink(MaxTasksGen, MaxWorkersGen) {
     allowedReference
   }
-  final def allowedReference(intermediate: Int, workers: Int) = {
+  final def allowedReference(intermediate: Int, workers: Int) =
     val top = task(intermediate).named("top")
     def iterate(tk: Task[Int]): Task[Int] =
       tk flatMap { t =>
-        if (t <= 0)
-          top
-        else
-          iterate(task(t - 1).named((t - 1).toString))
+        if t <= 0 then top
+        else iterate(task(t - 1).named((t - 1).toString))
       }
-    try {
-      checkResult(tryRun(iterate(top), true, workers), intermediate)
-    } catch {
-      case i: Incomplete if cyclic(i) => ("Unexpected cyclic exception: " + i) |: false
-    }
-  }
-  final def checkCircularReferences(intermediate: Int, workers: Int) = {
+    try checkResult(tryRun(iterate(top), true, workers), intermediate)
+    catch case i: Incomplete if cyclic(i) => ("Unexpected cyclic exception: " + i) |: false
+  final def checkCircularReferences(intermediate: Int, workers: Int) =
     lazy val top = iterate(task(intermediate).named("bottom"), intermediate)
     def iterate(tk: Task[Int], i: Int): Task[Int] =
       tk flatMap { t =>
-        if (t <= 0)
-          top
-        else
-          iterate(task(t - 1).named((t - 1).toString), i - 1)
+        if t <= 0 then top
+        else iterate(task(t - 1).named((t - 1).toString), i - 1)
       }
-    try {
+    try
       tryRun(top, true, workers); false
-    } catch { case i: Incomplete => cyclic(i) }
-  }
+    catch case i: Incomplete => cyclic(i)
 
   def cyclic(i: Incomplete) =
     Incomplete
       .allExceptions(i)
       .exists(_.isInstanceOf[Execute#CyclicException])
-}
+end TaskRunnerCircularTest
diff --git a/tasks-standard/src/test/scala/TaskRunnerFork.scala b/tasks-standard/src/test/scala/TaskRunnerFork.scala
index 0283fef42..be1f7b22d 100644
--- a/tasks-standard/src/test/scala/TaskRunnerFork.scala
+++ b/tasks-standard/src/test/scala/TaskRunnerFork.scala
@@ -13,7 +13,7 @@ import Prop.*
 import TaskGen.*
 import math.abs
 
-object TaskRunnerForkTest extends Properties("TaskRunner Fork") {
+object TaskRunnerForkTest extends Properties("TaskRunner Fork"):
   property("fork m tasks and wait for all to complete") = forAll(MaxTasksGen, MaxWorkersGen) {
     (m: Int, workers: Int) =>
       val values = (0 until m).toList
@@ -31,15 +31,14 @@ object TaskRunnerForkTest extends Properties("TaskRunner Fork") {
       runDoubleJoin(abs(a), abs(b), workers)
       true
   }
-  def runDoubleJoin(a: Int, b: Int, workers: Int): Unit = {
+  def runDoubleJoin(a: Int, b: Int, workers: Int): Unit =
     def inner = List.range(0, b).map(j => task(j).named(j.toString)).join
     tryRun(List.range(0, a).map(_ => inner).join, false, workers)
     ()
-  }
   property("fork and reduce") = forAll(TaskListGen, MaxWorkersGen) { (m: List[Int], workers: Int) =>
     m.nonEmpty ==> {
       val expected = m.sum
       checkResult(tryRun(m.tasks.reduced(_ + _), false, workers), expected)
     }
   }
-}
+end TaskRunnerForkTest
diff --git a/tasks-standard/src/test/scala/TaskSerial.scala b/tasks-standard/src/test/scala/TaskSerial.scala
index 022d31f49..d41061018 100644
--- a/tasks-standard/src/test/scala/TaskSerial.scala
+++ b/tasks-standard/src/test/scala/TaskSerial.scala
@@ -21,7 +21,7 @@ import ConcurrentRestrictions.{ completionService, limitTotal }
 
 import java.util.concurrent.{ CountDownLatch, TimeUnit }
 
-object TaskSerial extends Properties("task serial") {
+object TaskSerial extends Properties("task serial"):
   val checkCycles = true
   val Timeout = 100L // in milliseconds
 
@@ -55,7 +55,7 @@ object TaskSerial extends Properties("task serial") {
       size: Int,
       restrictions: ConcurrentRestrictions,
       shouldSucceed: Boolean
-  ) = {
+  ) =
     val latch = task { new CountDownLatch(size) }
     def mktask = latch map { l =>
       l.countDown()
@@ -63,24 +63,23 @@ object TaskSerial extends Properties("task serial") {
     }
     val tasks = (0 until size).map(_ => mktask).toList.join.map { results =>
       val success = results.forall(idFun[Boolean])
-      assert(success == shouldSucceed, if (shouldSucceed) unschedulableMsg else scheduledMsg)
+      assert(success == shouldSucceed, if shouldSucceed then unschedulableMsg else scheduledMsg)
     }
     checkResult(evalRestricted(tasks)(restrictions), ())
-  }
   def unschedulableMsg =
     "Some tasks were unschedulable: verify this is an actual failure by extending the timeout to several seconds."
   def scheduledMsg = "All tasks were unexpectedly scheduled."
 
   def evalRestricted[T](t: Task[T])(restrictions: ConcurrentRestrictions): T =
     tryRun[T](t, checkCycles, restrictions)
-}
+end TaskSerial
 
-object TaskTest {
+object TaskTest:
   def run[T](
       root: Task[T],
       checkCycles: Boolean,
       restrictions: ConcurrentRestrictions
-  ): Result[T] = {
+  ): Result[T] =
     val (service, shutdown) =
       completionService(restrictions, (x: String) => System.err.println(x))
 
@@ -89,19 +88,16 @@ object TaskTest {
       Execute.noTriggers,
       ExecuteProgress.empty
     )(using taskToNode([A] => (id: TaskId[A]) => id.asInstanceOf))
-    try {
+    try
       x.run(root)(using service)
-    } finally {
+    finally
       shutdown()
-    }
-  }
   def tryRun[T](
       root: Task[T],
       checkCycles: Boolean,
       restrictions: ConcurrentRestrictions
   ): T =
-    run(root, checkCycles, restrictions) match {
+    run(root, checkCycles, restrictions) match
       case Result.Value(v) => v
       case Result.Inc(i)   => throw i
-    }
-}
+end TaskTest
diff --git a/tasks-standard/src/test/scala/Test.scala b/tasks-standard/src/test/scala/Test.scala
index 19c40d6d6..3e81d1588 100644
--- a/tasks-standard/src/test/scala/Test.scala
+++ b/tasks-standard/src/test/scala/Test.scala
@@ -45,10 +45,10 @@ object Test extends std.TaskExtra:
   lazy val d3 = t3(a, b, c).flatMapR(f3)
 
   def d4(i: Int): Task[Int] = nop flatMap { _ =>
-    val x = math.random(); if (x < 0.01) task(i); else d4(i + 1)
+    val x = math.random(); if x < 0.01 then task(i); else d4(i + 1)
   }
 
-  def go(): Unit = {
+  def go(): Unit =
     def run[T](root: Task[T]) =
       println("Result : " + TaskGen.run(root, true, 2))
 
@@ -61,5 +61,4 @@ object Test extends std.TaskExtra:
     run(d4(0))
     run(h1)
     run(h2)
-  }
 end Test
diff --git a/tasks-standard/src/test/scala/TestRunnerCall.scala b/tasks-standard/src/test/scala/TestRunnerCall.scala
index dc15b1b2e..669b4fc45 100644
--- a/tasks-standard/src/test/scala/TestRunnerCall.scala
+++ b/tasks-standard/src/test/scala/TestRunnerCall.scala
@@ -14,7 +14,7 @@ import TaskGen.*
 
 import scala.annotation.tailrec
 
-object TaskRunnerCallTest extends Properties("TaskRunner Call") {
+object TaskRunnerCallTest extends Properties("TaskRunner Call"):
   property("calculates fibonacci") = forAll(MaxTasksGen, MaxWorkersGen) { (i: Int, workers: Int) =>
     (i > 0) ==> {
       val f = fibDirect(i)
@@ -24,26 +24,19 @@ object TaskRunnerCallTest extends Properties("TaskRunner Call") {
       }
     }
   }
-  final def fibTask(i: Int) = {
+  final def fibTask(i: Int) =
     require(i > 0)
     lazy val next: (Int, Int, Int) => Task[Int] =
-      (index, x1, x2) => {
-        if (index == i)
-          task(x2)
-        else
-          iterate((index + 1, x2, x1 + x2))
-      }
+      (index, x1, x2) =>
+        if index == i then task(x2)
+        else iterate((index + 1, x2, x1 + x2))
     def iterate(iteration: (Int, Int, Int)) = task(iteration).flatMap(next.tupled)
     iterate((1, 0, 1))
-  }
-  final def fibDirect(i: Int): Int = {
+  final def fibDirect(i: Int): Int =
     require(i > 0)
     @tailrec
     def build(index: Int, x1: Int, x2: Int): Int =
-      if (index == i)
-        x2
-      else
-        build(index + 1, x2, x1 + x2)
+      if index == i then x2
+      else build(index + 1, x2, x1 + x2)
     build(1, 0, 1)
-  }
-}
+end TaskRunnerCallTest
diff --git a/tasks-standard/src/test/scala/TestRunnerSort.scala b/tasks-standard/src/test/scala/TestRunnerSort.scala
index 7d9c96b8d..67fc76b60 100644
--- a/tasks-standard/src/test/scala/TestRunnerSort.scala
+++ b/tasks-standard/src/test/scala/TestRunnerSort.scala
@@ -12,28 +12,25 @@ import org.scalacheck.*
 import Prop.*
 import TaskGen.*
 
-object TaskRunnerSortTest extends Properties("TaskRunnerSort") {
+object TaskRunnerSortTest extends Properties("TaskRunnerSort"):
   property("sort") = forAll(TaskListGen, MaxWorkersGen) { (list: List[Int], workers: Int) =>
     val a = list.toArray
     val sorted = a.toArray
     java.util.Arrays.sort(sorted)
     ("Workers: " + workers) |: ("Array: " + a.toList) |: {
-      def result = tryRun(sort(a.toSeq), false, if (workers > 0) workers else 1)
+      def result = tryRun(sort(a.toSeq), false, if workers > 0 then workers else 1)
       checkResult(result.toList, sorted.toList)
     }
   }
-  final def sortDirect(a: Seq[Int]): Seq[Int] = {
-    if (a.length < 2) a
-    else {
+  final def sortDirect(a: Seq[Int]): Seq[Int] =
+    if a.length < 2 then a
+    else
       val pivot = a(0)
       val (lt, gte) = a.view.drop(1).partition(_ < pivot)
       sortDirect(lt.toSeq) ++ List(pivot) ++ sortDirect(gte.toSeq)
-    }
-  }
-  final def sort(a: Seq[Int]): Task[Seq[Int]] = {
-    if (a.length < 200)
-      task(sortDirect(a))
-    else {
+  final def sort(a: Seq[Int]): Task[Seq[Int]] =
+    if a.length < 200 then task(sortDirect(a))
+    else
       task(a) flatMap { a =>
         val pivot = a(0)
         val (lt, gte) = a.view.drop(1).partition(_ < pivot)
@@ -41,6 +38,4 @@ object TaskRunnerSortTest extends Properties("TaskRunnerSort") {
           l ++ List(pivot) ++ g
         }
       }
-    }
-  }
-}
+end TaskRunnerSortTest
diff --git a/tasks-standard/src/test/scala/checkResult.scala b/tasks-standard/src/test/scala/checkResult.scala
index de1d45082..d082440bb 100644
--- a/tasks-standard/src/test/scala/checkResult.scala
+++ b/tasks-standard/src/test/scala/checkResult.scala
@@ -12,19 +12,16 @@ import scala.util.control.NonFatal
 
 import org.scalacheck.Prop.*
 
-object checkResult {
-  def apply[T](run: => T, expected: T) = {
+object checkResult:
+  def apply[T](run: => T, expected: T) =
     ("Expected: " + expected) |:
-      (try {
+      (try
         val actual = run
         ("Actual: " + actual) |: (actual == expected)
-      } catch {
+      catch
         case i: Incomplete =>
           println(i)
           "One or more tasks failed" |: false
         case NonFatal(e) =>
           e.printStackTrace()
-          "Error in framework" |: false
-      })
-  }
-}
+          "Error in framework" |: false)
diff --git a/tasks/src/main/scala/sbt/CompletionService.scala b/tasks/src/main/scala/sbt/CompletionService.scala
index 64d1d2ee7..b69a06660 100644
--- a/tasks/src/main/scala/sbt/CompletionService.scala
+++ b/tasks/src/main/scala/sbt/CompletionService.scala
@@ -34,73 +34,66 @@ import java.util.concurrent.{
   CompletionService as JCompletionService
 }
 
-object CompletionService {
+object CompletionService:
   val poolID = new AtomicInteger(1)
-  def apply(poolSize: Int): (CompletionService, () => Unit) = {
+  def apply(poolSize: Int): (CompletionService, () => Unit) =
     val i = new AtomicInteger(1)
     val id = poolID.getAndIncrement()
     val pool = Executors.newFixedThreadPool(
       poolSize,
       (r: Runnable) => new Thread(r, s"sbt-completion-thread-$id-${i.getAndIncrement}")
     )
-    (apply(pool), () => { pool.shutdownNow(); () })
-  }
+    (
+      apply(pool),
+      () =>
+        pool.shutdownNow(); ()
+    )
 
   def apply(x: Executor): CompletionService =
     apply(new ExecutorCompletionService[Completed](x))
 
   def apply(completion: JCompletionService[Completed]): CompletionService =
-    new CompletionService {
-      def submit(node: TaskId[?], work: () => Completed) = {
+    new CompletionService:
+      def submit(node: TaskId[?], work: () => Completed) =
         CompletionService.submit(work, completion); ()
-      }
       def take() = completion.take().get()
-    }
 
-  def submit(work: () => Completed, completion: JCompletionService[Completed]): () => Completed = {
+  def submit(work: () => Completed, completion: JCompletionService[Completed]): () => Completed =
     val future = submitFuture(work, completion)
     () => future.get
-  }
 
   private[sbt] def submitFuture(
       work: () => Completed,
       completion: JCompletionService[Completed]
-  ): JFuture[Completed] = {
+  ): JFuture[Completed] =
     val future =
       try
         completion.submit {
-          new Callable[Completed] {
+          new Callable[Completed]:
             def call =
-              try {
-                work()
-              } catch {
+              try work()
+              catch
                 case _: InterruptedException =>
                   throw Incomplete(None, message = Some("cancelled"))
-              }
-          }
         }
-      catch {
+      catch
         case _: RejectedExecutionException =>
           throw Incomplete(None, message = Some("cancelled"))
-      }
     future
-  }
   def manage(
       service: CompletionService
   )(setup: TaskId[?] => Unit, cleanup: TaskId[?] => Unit): CompletionService =
     wrap(service) { (node, work) => () =>
       setup(node)
-      try {
+      try
         work()
-      } finally {
+      finally
         cleanup(node)
-      }
     }
   def wrap(
       service: CompletionService
   )(w: (TaskId[?], () => Completed) => (() => Completed)): CompletionService =
-    new CompletionService {
+    new CompletionService:
       def submit(node: TaskId[?], work: () => Completed) = service.submit(node, w(node, work))
       def take() = service.take()
-    }
-}
+end CompletionService
diff --git a/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala b/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala
index bb5ae2257..1ba2de1c7 100644
--- a/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala
+++ b/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala
@@ -19,7 +19,7 @@ import scala.jdk.CollectionConverters.*
 /**
  * Describes restrictions on concurrent execution for a set of tasks.
  */
-trait ConcurrentRestrictions {
+trait ConcurrentRestrictions:
 
   /** Internal state type used to describe a set of tasks. */
   type G
@@ -42,17 +42,16 @@ trait ConcurrentRestrictions {
    *      valid(empty) 5. forall g: G, a: A, b: A; !valid(add(g,a)) => !valid(add(add(g,b), a))
    */
   def valid(g: G): Boolean
-}
+end ConcurrentRestrictions
 
-private[sbt] sealed trait CancelSentinels {
+private[sbt] sealed trait CancelSentinels:
   def cancelSentinels(): Unit
-}
 
 import java.util.{ LinkedList, Queue }
 import java.util.concurrent.{ Executor, Executors, ExecutorCompletionService }
 import annotation.tailrec
 
-object ConcurrentRestrictions {
+object ConcurrentRestrictions:
   private val completionServices = new java.util.WeakHashMap[CompletionService, Boolean]
   def cancelAll() = completionServices.keySet.asScala.toVector.foreach {
     case a: AutoCloseable => a.close()
@@ -68,24 +67,21 @@ object ConcurrentRestrictions {
    * A ConcurrentRestrictions instance that places no restrictions on concurrently executing tasks.
    */
   def unrestricted: ConcurrentRestrictions =
-    new ConcurrentRestrictions {
+    new ConcurrentRestrictions:
       type G = Unit
       def empty = ()
       def add(g: G, a: TaskId[?]) = ()
       def remove(g: G, a: TaskId[?]) = ()
       def valid(g: G) = true
-    }
 
-  def limitTotal(i: Int): ConcurrentRestrictions = {
+  def limitTotal(i: Int): ConcurrentRestrictions =
     assert(i >= 1, "Maximum must be at least 1 (was " + i + ")")
-    new ConcurrentRestrictions {
+    new ConcurrentRestrictions:
       type G = Int
       def empty = 0
       def add(g: Int, a: TaskId[?]) = g + 1
       def remove(g: Int, a: TaskId[?]) = g - 1
       def valid(g: Int) = g <= i
-    }
-  }
 
   /** A key object used for associating information with a task. */
   final case class Tag(name: String)
@@ -108,30 +104,26 @@ object ConcurrentRestrictions {
    *   defines whether a set of tasks are allowed to execute concurrently based on their merged tags
    */
   def tagged(validF: TagMap => Boolean): ConcurrentRestrictions =
-    new ConcurrentRestrictions {
+    new ConcurrentRestrictions:
       type G = TagMap
       def empty = Map.empty
       def add(g: TagMap, a: TaskId[?]) = merge(g, a)(_ + _)
       def remove(g: TagMap, a: TaskId[?]) = merge(g, a)(_ - _)
       def valid(g: TagMap) = validF(g)
-    }
 
   private def merge(m: TagMap, a: TaskId[?])(
       f: (Int, Int) => Int
-  ): TagMap = {
+  ): TagMap =
     val base = merge(m, a.tags)(f)
-    val un = if (a.tags.isEmpty) update(base, Untagged, 1)(f) else base
+    val un = if a.tags.isEmpty then update(base, Untagged, 1)(f) else base
     update(un, All, 1)(f)
-  }
 
-  private def update[A, B](m: Map[A, B], a: A, b: B)(f: (B, B) => B): Map[A, B] = {
+  private def update[A, B](m: Map[A, B], a: A, b: B)(f: (B, B) => B): Map[A, B] =
     val newb =
-      (m get a) match {
+      (m get a) match
         case Some(bv) => f(bv, b)
         case None     => b
-      }
     m.updated(a, newb)
-  }
   private def merge[A, B](m: Map[A, B], n: Map[A, B])(f: (B, B) => B): Map[A, B] =
     n.foldLeft(m) { case (acc, (a, b)) => update(acc, a, b)(f) }
 
@@ -146,56 +138,54 @@ object ConcurrentRestrictions {
   def completionService(
       tags: ConcurrentRestrictions,
       warn: String => Unit
-  ): (CompletionService, () => Unit) = {
+  ): (CompletionService, () => Unit) =
     val id = poolID.getAndIncrement
     val i = new AtomicInteger(1)
     val pool = Executors.newCachedThreadPool { r =>
       new Thread(r, s"sbt-completion-service-pool-$id-${i.getAndIncrement()}")
     }
     val service = completionService(pool, tags, warn)
-    (service, () => { pool.shutdownNow(); () })
-  }
+    (
+      service,
+      () =>
+        pool.shutdownNow(); ()
+    )
 
   def completionService(
       tags: ConcurrentRestrictions,
       warn: String => Unit,
       isSentinel: TaskId[?] => Boolean
-  ): (CompletionService, () => Unit) = {
+  ): (CompletionService, () => Unit) =
     val pool = Executors.newCachedThreadPool()
     val service = completionService(pool, tags, warn, isSentinel)
     (
       service,
-      () => {
+      () =>
         pool.shutdownNow()
         ()
-      }
     )
-  }
 
   def cancellableCompletionService(
       tags: ConcurrentRestrictions,
       warn: String => Unit,
       isSentinel: TaskId[?] => Boolean
-  ): (CompletionService, Boolean => Unit) = {
+  ): (CompletionService, Boolean => Unit) =
     val pool = Executors.newCachedThreadPool()
     val service = completionService(pool, tags, warn, isSentinel)
     (
       service,
-      force => {
-        if (force) service.close()
+      force =>
+        if force then service.close()
         pool.shutdownNow()
         ()
-      }
     )
-  }
 
   def completionService(
       backing: Executor,
       tags: ConcurrentRestrictions,
       warn: String => Unit
-  ): CompletionService & AutoCloseable = {
+  ): CompletionService & AutoCloseable =
     completionService(backing, tags, warn, _ => false)
-  }
 
   /**
    * Constructs a CompletionService suitable for backing task execution based on the provided
@@ -207,18 +197,17 @@ object ConcurrentRestrictions {
       tags: ConcurrentRestrictions,
       warn: String => Unit,
       isSentinel: TaskId[?] => Boolean,
-  ): CompletionService & CancelSentinels & AutoCloseable = {
+  ): CompletionService & CancelSentinels & AutoCloseable =
 
     // Represents submitted work for a task.
     final class Enqueue(val node: TaskId[?], val work: () => Completed)
 
-    new CompletionService with CancelSentinels with AutoCloseable {
+    new CompletionService with CancelSentinels with AutoCloseable:
       completionServices.put(this, true)
       private val closed = new AtomicBoolean(false)
-      override def close(): Unit = if (closed.compareAndSet(false, true)) {
+      override def close(): Unit = if closed.compareAndSet(false, true) then
         completionServices.remove(this)
         ()
-      }
 
       /** Backing service used to manage execution on threads once all constraints are satisfied. */
       private val jservice = new ExecutorCompletionService[Completed](backing)
@@ -237,12 +226,11 @@ object ConcurrentRestrictions {
 
       private val sentinels: mutable.ListBuffer[JFuture[?]] = mutable.ListBuffer.empty
 
-      def cancelSentinels(): Unit = {
+      def cancelSentinels(): Unit =
         sentinels.toList foreach { s =>
           s.cancel(true)
         }
         sentinels.clear()
-      }
 
       def submit(node: TaskId[?], work: () => Completed): Unit = synchronized {
         if closed.get then throw new RejectedExecutionException
@@ -263,23 +251,21 @@ object ConcurrentRestrictions {
             ()
         ()
       }
-      private def submitValid(node: TaskId[?], work: () => Completed): Unit = {
+      private def submitValid(node: TaskId[?], work: () => Completed): Unit =
         running += 1
         val wrappedWork = () =>
           try work()
           finally cleanup(node)
         CompletionService.submitFuture(wrappedWork, jservice)
         ()
-      }
       private def cleanup(node: TaskId[?]): Unit = synchronized {
         running -= 1
         tagState = tags.remove(tagState, node)
-        if (!tags.valid(tagState)) {
+        if !tags.valid(tagState) then
           warn(
             "Invalid restriction: removing a completed node from a valid system must result in a valid system."
           )
           ()
-        }
         submitValid(new LinkedList)
       }
       private def errorAddingToIdle() =
@@ -287,34 +273,30 @@ object ConcurrentRestrictions {
 
       /** Submits pending tasks that are now allowed to executed. */
       @tailrec private def submitValid(tried: Queue[Enqueue]): Unit =
-        if (pending.isEmpty) {
-          if (!tried.isEmpty) {
-            if (running == 0) errorAddingToIdle()
+        if pending.isEmpty then
+          if !tried.isEmpty then
+            if running == 0 then errorAddingToIdle()
             pending.addAll(tried)
             ()
-          }
-        } else {
+        else
           val next = pending.remove()
           val newState = tags.add(tagState, next.node)
-          if (tags.valid(newState)) {
+          if tags.valid(newState) then
             tagState = newState
             submitValid(next.node, next.work)
             ()
-          } else {
+          else
             tried.add(next)
             ()
-          }
           submitValid(tried)
-        }
 
-      def take(): Completed = {
-        if (closed.get)
+      def take(): Completed =
+        if closed.get then
           throw new RejectedExecutionException(
             "Tried to get values for a closed completion service"
           )
-        try {
-          jservice.take().get()
-        } catch {
+        try jservice.take().get()
+        catch
           case ce: CancellationException =>
             // When tasks are cancelled (e.g., due to compile errors with usePipelining),
             // the future's get() throws CancellationException. Convert this to an Incomplete
@@ -322,8 +304,6 @@ object ConcurrentRestrictions {
             // by the task execution framework, so we just need to prevent the exception
             // from propagating as an unhandled exception.
             throw Incomplete(node = None, message = Some("cancelled"), directCause = Some(ce))
-        }
-      }
-    }
-  }
-}
+    end new
+  end completionService
+end ConcurrentRestrictions
diff --git a/tasks/src/main/scala/sbt/Execute.scala b/tasks/src/main/scala/sbt/Execute.scala
index 250fa79c5..7e05f7410 100644
--- a/tasks/src/main/scala/sbt/Execute.scala
+++ b/tasks/src/main/scala/sbt/Execute.scala
@@ -20,14 +20,13 @@ import scala.collection.mutable
 import scala.jdk.CollectionConverters.*
 import mutable.Map
 
-private[sbt] object Execute {
+private[sbt] object Execute:
   def taskMap[A]: Map[TaskId[?], A] = (new java.util.IdentityHashMap[TaskId[?], A]).asScala
   def taskPMap[F[_]]: PMap[TaskId, F] = new DelegatingPMap(
     (new java.util.IdentityHashMap[TaskId[Any], F[Any]]).asScala
   )
-  private[sbt] def completed(p: => Unit): Completed = new Completed {
+  private[sbt] def completed(p: => Unit): Completed = new Completed:
     def process(): Unit = p
-  }
   def noTriggers = new Triggers(Map.empty, Map.empty, identity)
 
   def config(checkCycles: Boolean, overwriteNode: Incomplete => Boolean = const(false)): Config =
@@ -39,16 +38,13 @@ private[sbt] object Execute {
 
   final val checkPreAndPostConditions =
     sys.props.get("sbt.execute.extrachecks").exists(java.lang.Boolean.parseBoolean)
-}
 
-sealed trait Completed {
+sealed trait Completed:
   def process(): Unit
-}
 
-private[sbt] trait NodeView {
+private[sbt] trait NodeView:
   def apply[A](a: TaskId[A]): Node[A]
   def inline1[A](a: TaskId[A]): Option[() => A]
-}
 
 final class Triggers(
     val runBefore: collection.Map[TaskId[?], Seq[TaskId[?]]],
@@ -60,7 +56,7 @@ private[sbt] final class Execute(
     config: Execute.Config,
     triggers: Triggers,
     progress: ExecuteProgress
-)(using view: NodeView) {
+)(using view: NodeView):
   import Execute.*
 
   private val forward = taskMap[IDSet[TaskId[?]]]
@@ -75,9 +71,8 @@ private[sbt] final class Execute(
       view.inline1(a) match
         case Some(v) => Result.Value(v())
         case None    => results(a)
-  private enum State {
+  private enum State:
     case Pending, Running, Calling, Done
-  }
   import State.{ Pending, Running, Calling, Done }
 
   val init = progress.initial()
@@ -86,11 +81,10 @@ private[sbt] final class Execute(
     "State: " + state.toString + "\n\nResults: " + results + "\n\nCalls: " + callers + "\n\n"
 
   def run[A](root: TaskId[A])(using strategy: CompletionService): Result[A] =
-    try {
-      runKeep(root)(root)
-    } catch { case i: Incomplete => Result.Inc(i) }
+    try runKeep(root)(root)
+    catch case i: Incomplete => Result.Inc(i)
 
-  def runKeep[A](root: TaskId[A])(using strategy: CompletionService): RMap[TaskId, Result] = {
+  def runKeep[A](root: TaskId[A])(using strategy: CompletionService): RMap[TaskId, Result] =
     assert(state.isEmpty, "Execute already running/ran.")
 
     addNew(root)
@@ -100,67 +94,59 @@ private[sbt] final class Execute(
     progress.afterAllCompleted(finalResults)
     progress.stop()
     finalResults
-  }
 
-  def processAll()(using strategy: CompletionService): Unit = {
-    @tailrec def next(): Unit = {
+  def processAll()(using strategy: CompletionService): Unit =
+    @tailrec def next(): Unit =
       pre {
         assert(reverse.nonEmpty, "Nothing to process.")
-        if (!state.values.exists(_ == Running)) {
+        if !state.values.exists(_ == Running) then
           snapshotCycleCheck()
           assert(
             false,
             "Internal task engine error: nothing running.  This usually indicates a cycle in tasks.\n  Calling tasks (internal task engine state):\n" + dumpCalling
           )
-        }
       }
 
-      try {
-        strategy.take().process()
-      } catch {
+      try strategy.take().process()
+      catch
         case e: ExecutionException =>
-          e.getCause match {
+          e.getCause match
             case oom: OutOfMemoryError => throw oom
             case _                     => throw e
-          }
-      }
-      if (reverse.nonEmpty) next()
-    }
+      if reverse.nonEmpty then next()
     next()
 
     post {
       assert(reverse.isEmpty, "Did not process everything.")
       assert(complete, "Not all state was Done.")
     }
-  }
+  end processAll
   def dumpCalling: String = state.filter(_._2 == Calling).mkString("\n\t")
 
-  def call[A](node: TaskId[A], target: TaskId[A])(using strategy: CompletionService): Unit = {
-    if (config.checkCycles) cycleCheck(node, target)
+  def call[A](node: TaskId[A], target: TaskId[A])(using strategy: CompletionService): Unit =
+    if config.checkCycles then cycleCheck(node, target)
     pre {
       assert(running(node))
       readyInv(node)
     }
 
-    results.get(target) match {
+    results.get(target) match
       case Some(result) => retire(node, result)
       case None         =>
         state(node) = Calling
         addChecked(target)
         addCaller(node, target)
-    }
 
     post {
-      if (done(target)) assert(done(node))
-      else {
+      if done(target) then assert(done(node))
+      else
         assert(calling(node))
         assert(callers(target).contains(node))
-      }
       readyInv(node)
     }
-  }
+  end call
 
-  def retire[A](node: TaskId[A], result: Result[A])(using strategy: CompletionService): Unit = {
+  def retire[A](node: TaskId[A], result: Result[A])(using strategy: CompletionService): Unit =
     pre {
       assert(running(node) | calling(node))
       readyInv(node)
@@ -185,39 +171,35 @@ private[sbt] final class Execute(
       assert(!(callers.contains(node)))
       assert(triggeredBy(node) forall added)
     }
-  }
+  end retire
   def callerResult[A](node: TaskId[A], result: Result[A]): Result[A] =
-    result match {
+    result match
       case _: Result.Value[A] => result
       case Result.Inc(i)      => Result.Inc(Incomplete(Some(node), tpe = i.tpe, causes = i :: Nil))
-    }
 
-  def notifyDone(node: TaskId[?], dependent: TaskId[?])(using strategy: CompletionService): Unit = {
+  def notifyDone(node: TaskId[?], dependent: TaskId[?])(using strategy: CompletionService): Unit =
     val f = forward(dependent)
     f -= node
-    if (f.isEmpty) {
+    if f.isEmpty then
       remove(forward, dependent)
       ready(dependent)
-    }
-  }
 
   /**
    * Ensures the given node has been added to the system. Once added, a node is pending until its
    * inputs and dependencies have completed. Its computation is then evaluated and made available
    * for nodes that have it as an input.
    */
-  def addChecked[A](node: TaskId[A])(using strategy: CompletionService): Unit = {
-    if (!added(node)) addNew(node)
+  def addChecked[A](node: TaskId[A])(using strategy: CompletionService): Unit =
+    if !added(node) then addNew(node)
 
     post { addedInv(node) }
-  }
 
   /**
    * Adds a node that has not yet been registered with the system. If all of the node's dependencies
    * have finished, the node's computation is scheduled to run. The node's dependencies will be
    * added (transitively) if they are not already registered.
    */
-  def addNew(node: TaskId[?])(using strategy: CompletionService): Unit = {
+  def addNew(node: TaskId[?])(using strategy: CompletionService): Unit =
     pre { newPre(node) }
 
     val v = register(node)
@@ -230,28 +212,26 @@ private[sbt] final class Execute(
       /* active is mutable, so take a snapshot */
     )
 
-    if (active.isEmpty) ready(node)
-    else {
+    if active.isEmpty then ready(node)
+    else
       forward(node) = active
-      for (a <- active) {
+      for a <- active do
         addChecked(a)
         addReverse(a, node)
-      }
-    }
 
     post {
       addedInv(node)
       assert(running(node) ^ pending(node))
-      if (running(node)) runningInv(node)
-      if (pending(node)) pendingInv(node)
+      if running(node) then runningInv(node)
+      if pending(node) then pendingInv(node)
     }
-  }
+  end addNew
 
   /**
    * Called when a pending 'node' becomes runnable. All of its dependencies must be done. This
    * schedules the node's computation with 'strategy'.
    */
-  def ready(node: TaskId[?])(using strategy: CompletionService): Unit = {
+  def ready(node: TaskId[?])(using strategy: CompletionService): Unit =
     pre {
       assert(pending(node))
       readyInv(node)
@@ -267,21 +247,18 @@ private[sbt] final class Execute(
       assert(reverse.contains(node))
       assert(running(node))
     }
-  }
 
   /** Enters the given node into the system. */
-  def register[A](node: TaskId[A]): Node[A] = {
+  def register[A](node: TaskId[A]): Node[A] =
     state(node) = Pending
     reverse(node) = Seq()
     viewCache.getOrUpdate(node, view(node))
-  }
 
   /** Send the work for this node to the provided Strategy. */
-  def submit(node: TaskId[?])(using strategy: CompletionService): Unit = {
+  def submit(node: TaskId[?])(using strategy: CompletionService): Unit =
     val v = viewCache(node)
     val rs = v.computeInputs(getResult)
     strategy.submit(node, () => work(node, v.work(rs)))
-  }
 
   /**
    * Evaluates the computation 'f' for 'node'. This returns a Completed instance, which contains the
@@ -289,29 +266,26 @@ private[sbt] final class Execute(
    */
   def work[A](node: TaskId[A], f: => Either[TaskId[A], A])(using
       strategy: CompletionService
-  ): Completed = {
+  ): Completed =
     progress.beforeWork(node)
     val rawResult = wideConvert(f).left.map {
-      case i: Incomplete => if (config.overwriteNode(i)) i.copy(node = Some(node)) else i
+      case i: Incomplete => if config.overwriteNode(i) then i.copy(node = Some(node)) else i
       case e             => Incomplete(Some(node), Incomplete.Error, directCause = Some(e))
     }
     val result = rewrap(rawResult)
     progress.afterWork(node, result)
     completed {
-      result match {
+      result match
         case Right(v)     => retire(node, v)
         case Left(target) => call(node, target)
-      }
     }
-  }
   private def rewrap[A](
       rawResult: Either[Incomplete, Either[TaskId[A], A]]
   ): Either[TaskId[A], Result[A]] =
-    rawResult match {
+    rawResult match
       case Left(i)             => Right(Result.Inc(i))
       case Right(Right(v))     => Right(Result.Value(v))
       case Right(Left(target)) => Left(target)
-    }
 
   def remove[K, V](map: Map[K, V], k: K): V =
     map.remove(k).getOrElse(sys.error("Key '" + k + "' not in map :\n" + map))
@@ -331,39 +305,34 @@ private[sbt] final class Execute(
   // Contracts
 
   def addedInv(node: TaskId[?]): Unit = topologicalSort(node).foreach(addedCheck)
-  def addedCheck(node: TaskId[?]): Unit = {
+  def addedCheck(node: TaskId[?]): Unit =
     assert(added(node), "Not added: " + node)
     assert(viewCache.contains(node), "Not in view cache: " + node)
     dependencyCheck(node)
-  }
-  def dependencyCheck(node: TaskId[?]): Unit = {
+  def dependencyCheck(node: TaskId[?]): Unit =
     dependencies(node) foreach { dep =>
-      def onOpt[A](o: Option[A])(f: A => Boolean) = o match {
-        case None => false; case Some(x) => f(x)
-      }
+      def onOpt[A](o: Option[A])(f: A => Boolean) = o match
+        case None    => false;
+        case Some(x) => f(x)
       def checkForward = onOpt(forward.get(node))(_.contains(dep))
       def checkReverse = onOpt(reverse.get(dep))(_.exists(_ == node))
       assert(done(dep) ^ (checkForward && checkReverse))
     }
-  }
-  def pendingInv(node: TaskId[?]): Unit = {
+  def pendingInv(node: TaskId[?]): Unit =
     assert(atState(node, Pending))
     assert((dependencies(node) ++ runBefore(node)).exists(notDone))
-  }
-  def runningInv(node: TaskId[?]): Unit = {
+  def runningInv(node: TaskId[?]): Unit =
     assert(dependencies(node).forall(done))
     assert(!(forward.contains(node)))
-  }
-  def newPre(node: TaskId[?]): Unit = {
+  def newPre(node: TaskId[?]): Unit =
     isNew(node)
     assert(!(reverse.contains(node)))
     assert(!(forward.contains(node)))
     assert(!(callers.contains(node)))
     assert(!(viewCache.contains(node)))
     assert(!(results.contains(node)))
-  }
 
-  def topologicalSort(node: TaskId[?]): Seq[TaskId[?]] = {
+  def topologicalSort(node: TaskId[?]): Seq[TaskId[?]] =
     val seen = IDSet.create[TaskId[?]]
     def visit(n: TaskId[?]): List[TaskId[?]] =
       seen.process(n)(List.empty) {
@@ -373,29 +342,26 @@ private[sbt] final class Execute(
       }
 
     visit(node).reverse
-  }
 
-  def readyInv(node: TaskId[?]): Unit = {
+  def readyInv(node: TaskId[?]): Unit =
     assert(dependencies(node).forall(done))
     assert(!(forward.contains(node)))
-  }
 
   // cyclic reference checking
 
   def snapshotCycleCheck(): Unit =
     callers.toSeq foreach { (called, callers) =>
-      for (caller <- callers) cycleCheck(caller, called)
+      for caller <- callers do cycleCheck(caller, called)
     }
 
-  def cycleCheck(node: TaskId[?], target: TaskId[?]): Unit = {
-    if (node eq target) cyclic(node, target, "Cannot call self")
+  def cycleCheck(node: TaskId[?], target: TaskId[?]): Unit =
+    if node eq target then cyclic(node, target, "Cannot call self")
     val all = IDSet.create[TaskId[?]]
     def allCallers(n: TaskId[?]): Unit = all.process(n)(()) {
       callers.get(n).toList.flatten.foreach(allCallers)
     }
     allCallers(node)
     if all.contains(target) then cyclic(node, target, "Cyclic reference")
-  }
   def cyclic(caller: TaskId[?], target: TaskId[?], msg: String) =
     throw new Incomplete(
       Some(caller),
@@ -417,6 +383,6 @@ private[sbt] final class Execute(
   def added(d: TaskId[?]) = state.contains(d)
   def complete = state.values.forall(_ == Done)
 
-  def pre(f: => Unit) = if (checkPreAndPostConditions) f
-  def post(f: => Unit) = if (checkPreAndPostConditions) f
-}
+  def pre(f: => Unit) = if checkPreAndPostConditions then f
+  def post(f: => Unit) = if checkPreAndPostConditions then f
+end Execute
diff --git a/tasks/src/main/scala/sbt/ExecuteProgress.scala b/tasks/src/main/scala/sbt/ExecuteProgress.scala
index 04c7b1414..8cae979a2 100644
--- a/tasks/src/main/scala/sbt/ExecuteProgress.scala
+++ b/tasks/src/main/scala/sbt/ExecuteProgress.scala
@@ -15,7 +15,7 @@ import sbt.internal.util.RMap
  * except `started` and `finished`, which is called from the executing task's thread. All methods
  * should return quickly to avoid task execution overhead.
  */
-trait ExecuteProgress {
+trait ExecuteProgress:
   def initial(): Unit
 
   /**
@@ -63,13 +63,13 @@ trait ExecuteProgress {
 
   /** Notifies that either all tasks have finished or cancelled. */
   def stop(): Unit
-}
+end ExecuteProgress
 
 /**
  * This module is experimental and subject to binary and source incompatible changes at any time.
  */
-object ExecuteProgress {
-  def empty: ExecuteProgress = new ExecuteProgress {
+object ExecuteProgress:
+  def empty: ExecuteProgress = new ExecuteProgress:
     override def initial(): Unit = ()
     override def afterRegistered(
         task: TaskId[?],
@@ -83,36 +83,26 @@ object ExecuteProgress {
     override def afterCompleted[A](task: TaskId[A], result: Result[A]): Unit = ()
     override def afterAllCompleted(results: RMap[TaskId, Result]): Unit = ()
     override def stop(): Unit = ()
-  }
 
-  def aggregate(reporters: Seq[ExecuteProgress]) = new ExecuteProgress {
-    override def initial(): Unit = {
+  def aggregate(reporters: Seq[ExecuteProgress]) = new ExecuteProgress:
+    override def initial(): Unit =
       reporters foreach { _.initial() }
-    }
     override def afterRegistered(
         task: TaskId[?],
         allDeps: Iterable[TaskId[?]],
         pendingDeps: Iterable[TaskId[?]]
-    ): Unit = {
+    ): Unit =
       reporters foreach { _.afterRegistered(task, allDeps, pendingDeps) }
-    }
-    override def afterReady(task: TaskId[?]): Unit = {
+    override def afterReady(task: TaskId[?]): Unit =
       reporters foreach { _.afterReady(task) }
-    }
-    override def beforeWork(task: TaskId[?]): Unit = {
+    override def beforeWork(task: TaskId[?]): Unit =
       reporters foreach { _.beforeWork(task) }
-    }
-    override def afterWork[A](task: TaskId[A], result: Either[TaskId[A], Result[A]]): Unit = {
+    override def afterWork[A](task: TaskId[A], result: Either[TaskId[A], Result[A]]): Unit =
       reporters foreach { _.afterWork(task, result) }
-    }
-    override def afterCompleted[A](task: TaskId[A], result: Result[A]): Unit = {
+    override def afterCompleted[A](task: TaskId[A], result: Result[A]): Unit =
       reporters foreach { _.afterCompleted(task, result) }
-    }
-    override def afterAllCompleted(results: RMap[TaskId, Result]): Unit = {
+    override def afterAllCompleted(results: RMap[TaskId, Result]): Unit =
       reporters foreach { _.afterAllCompleted(results) }
-    }
-    override def stop(): Unit = {
+    override def stop(): Unit =
       reporters foreach { _.stop() }
-    }
-  }
-}
+end ExecuteProgress
diff --git a/tasks/src/main/scala/sbt/Incomplete.scala b/tasks/src/main/scala/sbt/Incomplete.scala
index 8273f205d..c36fed904 100644
--- a/tasks/src/main/scala/sbt/Incomplete.scala
+++ b/tasks/src/main/scala/sbt/Incomplete.scala
@@ -36,27 +36,25 @@ final case class Incomplete(
     causes: Seq[Incomplete] = Nil,
     directCause: Option[Throwable] = None
 ) extends Exception(message.orNull, directCause.orNull)
-    with sbt.internal.util.UnprintableException {
+    with sbt.internal.util.UnprintableException:
   override def toString =
     "Incomplete(node=" + node + ", tpe=" + tpe + ", msg=" + message + ", causes=" + causes + ", directCause=" + directCause + ")"
-}
 
-object Incomplete extends Enumeration {
+object Incomplete extends Enumeration:
   val Skipped, Error = Value
 
   def transformTD(i: Incomplete)(f: Incomplete => Incomplete): Incomplete = transform(i, true)(f)
   def transformBU(i: Incomplete)(f: Incomplete => Incomplete): Incomplete = transform(i, false)(f)
-  def transform(i: Incomplete, topDown: Boolean)(f: Incomplete => Incomplete): Incomplete = {
+  def transform(i: Incomplete, topDown: Boolean)(f: Incomplete => Incomplete): Incomplete =
     val visited: collection.mutable.Map[Incomplete, Incomplete] =
       (new java.util.IdentityHashMap[Incomplete, Incomplete]).asScala
     def visit(inc: Incomplete): Incomplete =
-      visited.getOrElseUpdate(inc, if (topDown) visitCauses(f(inc)) else f(visitCauses(inc)))
+      visited.getOrElseUpdate(inc, if topDown then visitCauses(f(inc)) else f(visitCauses(inc)))
     def visitCauses(inc: Incomplete): Incomplete =
       inc.copy(causes = inc.causes.map(visit))
 
     visit(i)
-  }
-  def visitAll(i: Incomplete)(f: Incomplete => Unit): Unit = {
+  def visitAll(i: Incomplete)(f: Incomplete => Unit): Unit =
     val visited = IDSet.create[Incomplete]
     def visit(inc: Incomplete): Unit =
       visited.process(inc)(()) {
@@ -64,18 +62,17 @@ object Incomplete extends Enumeration {
         inc.causes.foreach(visit)
       }
     visit(i)
-  }
-  def linearize(i: Incomplete): Seq[Incomplete] = {
+  def linearize(i: Incomplete): Seq[Incomplete] =
     val ordered = ListBuffer[Incomplete]()
     visitAll(i) { ordered += _ }
     ordered.toList
-  }
   def allExceptions(is: Seq[Incomplete]): Iterable[Throwable] =
     allExceptions(new Incomplete(None, causes = is))
-  def allExceptions(i: Incomplete): Iterable[Throwable] = {
+  def allExceptions(i: Incomplete): Iterable[Throwable] =
     val exceptions = IDSet.create[Throwable]
     visitAll(i) { exceptions ++= _.directCause.toList }
     exceptions.all
-  }
-  def show(tpe: Value) = tpe match { case Skipped => "skipped"; case Error => "error" }
-}
+  def show(tpe: Value) = tpe match
+    case Skipped => "skipped";
+    case Error   => "error"
+end Incomplete
diff --git a/tasks/src/main/scala/sbt/Result.scala b/tasks/src/main/scala/sbt/Result.scala
index 287d1465a..55dc9fc14 100644
--- a/tasks/src/main/scala/sbt/Result.scala
+++ b/tasks/src/main/scala/sbt/Result.scala
@@ -23,7 +23,7 @@ enum Result[+A]:
     case Value(value) => Right(value)
 end Result
 
-object Result {
+object Result:
   type Id[X] = X
   val tryValue: [A] => Result[A] => A =
     [A] =>
@@ -32,12 +32,9 @@ object Result {
           case Result.Value(v) => v
           case Result.Inc(i)   => throw i
 
-  def tryValues[S](r: Seq[Result[Unit]], v: Result[S]): S = {
+  def tryValues[S](r: Seq[Result[Unit]], v: Result[S]): S =
     r foreach tryValue[Unit]
     tryValue[S](v)
-  }
-  implicit def fromEither[T](e: Either[Incomplete, T]): Result[T] = e match {
+  implicit def fromEither[T](e: Either[Incomplete, T]): Result[T] = e match
     case Left(i)  => Inc(i)
     case Right(v) => Value(v)
-  }
-}
diff --git a/testing/src/main/scala/sbt/JUnitXmlTestsListener.scala b/testing/src/main/scala/sbt/JUnitXmlTestsListener.scala
index c84ebef38..8616adc13 100644
--- a/testing/src/main/scala/sbt/JUnitXmlTestsListener.scala
+++ b/testing/src/main/scala/sbt/JUnitXmlTestsListener.scala
@@ -36,26 +36,22 @@ import sbt.protocol.testing.TestResult
  * block sbt startup (only resolves when tests actually run).
  * See https://github.com/sbt/sbt/issues/8601
  */
-object JUnitXmlTestsListener {
+object JUnitXmlTestsListener:
 
   /** Cached hostname resolution result with timing info */
-  private lazy val hostnameInfo: (String, Long) = {
+  private lazy val hostnameInfo: (String, Long) =
     val start = System.nanoTime
     val name =
       try InetAddress.getLocalHost.getHostName
-      catch {
-        case _: IOException => "localhost"
-      }
+      catch case _: IOException => "localhost"
     val elapsed = System.nanoTime - start
     (name, elapsed)
-  }
 
   /** Lazily resolved hostname, cached at object level */
   lazy val hostname: String = hostnameInfo._1
 
   /** Time taken to resolve hostname in nanoseconds */
   lazy val hostnameResolutionTime: Long = hostnameInfo._2
-}
 
 /**
  * A tests listener that outputs the results it receives in junit xml report format.
@@ -63,7 +59,7 @@ object JUnitXmlTestsListener {
  *   directory in which test reports are generated
  */
 class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logger: Logger)
-    extends TestsListener {
+    extends TestsListener:
   // These constructors are for binary compatibility with older versions of sbt
   // Use old hard-coded behaviour for constructing `targetDir` from `outputDir`
   def this(outputDir: String, legacyTestReport: Boolean, logger: Logger) =
@@ -72,18 +68,16 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
   def this(outputDir: String) = this(outputDir, false, null)
 
   /** Current hostname so we know which machine executed the tests */
-  lazy val hostname: String = {
+  lazy val hostname: String =
     val name = JUnitXmlTestsListener.hostname
     val elapsed = JUnitXmlTestsListener.hostnameResolutionTime
-    if ((NANOSECONDS.toSeconds(elapsed) >= 4) && Properties.isMac && logger != null) {
+    if (NANOSECONDS.toSeconds(elapsed) >= 4) && Properties.isMac && logger != null then
       logger.warn(
         s"Getting the hostname $name was slow (${elapsed / 1.0e6} ms). " +
           "This is likely because the computer's hostname is not set. You can set the " +
           """hostname with the command: scutil --set HostName "$(scutil --get LocalHostName).local"."""
       )
-    }
     name
-  }
 
   /** all system properties as XML */
   val properties: Elem =
@@ -93,10 +87,9 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
       val clonedProperties = System.getProperties.clone.asInstanceOf[Hashtable[AnyRef, AnyRef]]
       val iter = clonedProperties.entrySet.iterator
       val props: ListBuffer[XNode] = new ListBuffer()
-      while (iter.hasNext) {
+      while iter.hasNext do
         val next = iter.next
         props += <property name={next.getKey.toString} value={next.getValue.toString}/>
-      }
       props
     }
     </properties>
@@ -105,7 +98,7 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
    * Gathers data for one Test Suite. We map test groups to TestSuites. Each TestSuite gets its own
    * output file.
    */
-  class TestSuite(val name: String, timestamp: LocalDateTime) {
+  class TestSuite(val name: String, timestamp: LocalDateTime):
     def this(name: String) = this(name, LocalDateTime.now())
 
     val events: ListBuffer[TEvent] = new ListBuffer()
@@ -119,7 +112,7 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
     /**
      * Stops the time measuring and emits the XML for All tests collected so far.
      */
-    def stop(): Elem = {
+    def stop(): Elem =
       val duration = events.map(_.duration()).sum
 
       val (errors, failures, tests) = (count(TStatus.Error), count(TStatus.Failure), events.size)
@@ -142,50 +135,45 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
         }>
           {properties}
           {
-          for (e <- events)
-            yield <testcase classname={
-              e.selector match {
-                case nested: NestedTestSelector => nested.suiteId()
-                case _                          => name
-              }
-            } name={
-              e.selector match {
-                case selector: TestSelector =>
-                  val matchEnd =
-                    classnameRegex.findFirstMatchIn(selector.testName).map(_.end).getOrElse(0)
-                  selector.testName.substring(matchEnd)
-                case nested: NestedTestSelector => nested.testName()
-                case other => s"(It is not a test it is a ${other.getClass.getCanonicalName})"
-              }
-            } time={(e.duration() / 1000.0).toString}>
+          for e <- events
+          yield <testcase classname={
+            e.selector match
+              case nested: NestedTestSelector => nested.suiteId()
+              case _                          => name
+          } name={
+            e.selector match
+              case selector: TestSelector =>
+                val matchEnd =
+                  classnameRegex.findFirstMatchIn(selector.testName).map(_.end).getOrElse(0)
+                selector.testName.substring(matchEnd)
+              case nested: NestedTestSelector => nested.testName()
+              case other => s"(It is not a test it is a ${other.getClass.getCanonicalName})"
+          } time={(e.duration() / 1000.0).toString}>
                       {
-              val trace: String = if (e.throwable.isDefined) {
-                val stringWriter = new StringWriter()
-                val writer = new PrintWriter(stringWriter)
-                e.throwable.get.printStackTrace(writer)
-                writer.flush()
-                stringWriter.toString
-              } else {
-                ""
-              }
-              e.status match {
-                case TStatus.Error if (e.throwable.isDefined) =>
-                  <error message={e.throwable.get.getMessage} type={
-                    e.throwable.get.getClass.getName
-                  }>{trace}</error>
-                case TStatus.Error =>
-                  <error message={"No Exception or message provided"}/>
-                case TStatus.Failure if (e.throwable.isDefined) =>
-                  <failure message={e.throwable.get.getMessage} type={
-                    e.throwable.get.getClass.getName
-                  }>{trace}</failure>
-                case TStatus.Failure =>
-                  <failure message={"No Exception or message provided"}/>
-                case TStatus.Ignored | TStatus.Skipped | TStatus.Pending =>
-                  <skipped/>
-                case _ => {}
-              }
-            }
+            val trace: String = if e.throwable.isDefined then
+              val stringWriter = new StringWriter()
+              val writer = new PrintWriter(stringWriter)
+              e.throwable.get.printStackTrace(writer)
+              writer.flush()
+              stringWriter.toString
+            else ""
+            e.status match
+              case TStatus.Error if (e.throwable.isDefined) =>
+                <error message={e.throwable.get.getMessage} type={
+                  e.throwable.get.getClass.getName
+                }>{trace}</error>
+              case TStatus.Error =>
+                <error message={"No Exception or message provided"}/>
+              case TStatus.Failure if (e.throwable.isDefined) =>
+                <failure message={e.throwable.get.getMessage} type={
+                  e.throwable.get.getClass.getName
+                }>{trace}</failure>
+              case TStatus.Failure =>
+                <failure message={"No Exception or message provided"}/>
+              case TStatus.Ignored | TStatus.Skipped | TStatus.Pending =>
+                <skipped/>
+              case _ => {}
+          }
                     </testcase>
 
         }
@@ -194,8 +182,8 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
         </testsuite>
 
       result
-    }
-  }
+    end stop
+  end TestSuite
 
   /**
    * A mutable cell holding the suite that is currently running on a thread.
@@ -209,24 +197,21 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
    * remaining life of the JVM. Clearing the cell severs the reference for the owning thread and
    * every thread that inherited it at once.
    */
-  private final class SuiteRef(initial: Option[TestSuite]) {
+  private final class SuiteRef(initial: Option[TestSuite]):
     private val ref = new AtomicReference(initial)
     def current: Option[TestSuite] = ref.get()
     def clear(): Unit = ref.set(None)
-  }
 
   /** The currently running test suite */
-  private val testSuite = new InheritableThreadLocal[SuiteRef] {
+  private val testSuite = new InheritableThreadLocal[SuiteRef]:
     override def initialValue(): SuiteRef = new SuiteRef(None)
-  }
 
   private def withTestSuite[T](f: TestSuite => T): T =
     testSuite.get().current.map(f).getOrElse(sys.error("no test suite"))
 
   /** Creates the output Dir */
-  override def doInit(): Unit = {
+  override def doInit(): Unit =
     val _ = targetDir.mkdirs()
-  }
 
   /**
    * Starts a new, initially empty Suite with the given name.
@@ -245,15 +230,14 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
    * late event into an error line via `TestFramework.safeForeach`.
    */
   override def testEvent(event: TestEvent): Unit =
-    testSuite.get().current match {
-      case Some(suite) => for (e <- event.detail) suite.addEvent(e)
+    testSuite.get().current match
+      case Some(suite) => for e <- event.detail do suite.addEvent(e)
       case None        =>
-        if (logger != null) {
+        if logger != null then
           logger.debug(
             s"ignoring ${event.detail.size} test event(s) reported after the suite was written"
           )
-        } else ()
-    }
+        else ()
 
   /**
    * called for each class or equivalent grouping We map one group to one Testsuite, so for each
@@ -272,9 +256,9 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
    * type="junit.framework.AssertionFailedError">...stack...</failure> </testcase>
    * <system-out><![CDATA[]]></system-out> <system-err><![CDATA[]]></system-err> </testsuite>
    */
-  override def endGroup(name: String, t: Throwable): Unit = {
+  override def endGroup(name: String, t: Throwable): Unit =
     // create our own event to record the error
-    val event: TEvent = new TEvent {
+    val event: TEvent = new TEvent:
       def fullyQualifiedName = name
       // def description =
       // "Throwable escaped the test run of '%s'".format(name)
@@ -283,18 +267,15 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
       def fingerprint = null
       def selector = null
       def throwable = new OptionalThrowable(t)
-    }
     withTestSuite(_.addEvent(event))
     writeSuite()
-  }
 
   /**
    * Ends the current suite, wraps up the result and writes it to an XML file in the output folder
    * that is named after the suite.
    */
-  override def endGroup(name: String, result: TestResult): Unit = {
+  override def endGroup(name: String, result: TestResult): Unit =
     writeSuite()
-  }
 
   // Here we normalize the name to ensure that it's a nicer filename, rather than
   // contort the user into not using spaces.
@@ -306,15 +287,11 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
   private def formatISO8601DateTime(d: LocalDateTime): String =
     d.truncatedTo(ChronoUnit.SECONDS).format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)
 
-  private def writeSuite(): Unit = {
-    val file = if (legacyTestReport) {
+  private def writeSuite(): Unit =
+    val file = if legacyTestReport then
       new File(targetDir, s"${normalizeName(withTestSuite(_.name))}.xml").getAbsolutePath
-    } else {
-      new File(targetDir, s"TEST-${normalizeName(withTestSuite(_.name))}.xml").getAbsolutePath
-    }
-    if (logger != null) {
-      logger.debug(s"writing JUnit XML test report: $file")
-    }
+    else new File(targetDir, s"TEST-${normalizeName(withTestSuite(_.name))}.xml").getAbsolutePath
+    if logger != null then logger.debug(s"writing JUnit XML test report: $file")
     val testSuiteResult = withTestSuite(_.stop())
     XML.save(file, testSuiteResult, "UTF-8", xmlDecl = true, null)
     /* Order matters: `clear()` releases the suite for this thread *and* for every thread that
@@ -325,11 +302,10 @@ class JUnitXmlTestsListener(val targetDir: File, legacyTestReport: Boolean, logg
      */
     testSuite.get().clear()
     testSuite.remove()
-  }
 
   /** Does nothing, as we write each file after a suite is done. */
   override def doComplete(finalResult: TestResult): Unit = {}
 
   /** Returns None */
   override def contentLogger(test: TestDefinition): Option[ContentLogger] = None
-}
+end JUnitXmlTestsListener
diff --git a/testing/src/main/scala/sbt/TestFramework.scala b/testing/src/main/scala/sbt/TestFramework.scala
index 91ca44e9d..d08ea7540 100644
--- a/testing/src/main/scala/sbt/TestFramework.scala
+++ b/testing/src/main/scala/sbt/TestFramework.scala
@@ -17,7 +17,7 @@ import scala.annotation.tailrec
 import sbt.internal.util.ManagedLogger
 import sbt.protocol.testing.TestResult
 
-object TestFrameworks {
+object TestFrameworks:
   val ScalaCheck = TestFramework("org.scalacheck.ScalaCheckFramework")
   val ScalaTest =
     TestFramework("org.scalatest.tools.Framework", "org.scalatest.tools.ScalaTestFramework")
@@ -32,27 +32,23 @@ object TestFrameworks {
 
   val All: Seq[TestFramework] =
     Seq(ScalaCheck, Specs2, Specs, ScalaTest, JUnit, MUnit, ZIOTest, WeaverTestCats, Hedgehog)
-}
 
-final class TestFramework(val implClassNames: String*) extends Serializable {
-  override def equals(o: Any): Boolean = o match {
+final class TestFramework(val implClassNames: String*) extends Serializable:
+  override def equals(o: Any): Boolean = o match
     case x: TestFramework => (this.implClassNames.toList == x.implClassNames.toList)
     case _                => false
-  }
-  override def hashCode: Int = {
+  override def hashCode: Int =
     37 * (17 + implClassNames.##) + "TestFramework".##
-  }
-  override def toString: String = {
+  override def toString: String =
     "TestFramework(" + implClassNames.mkString(", ") + ")"
-  }
 
   @tailrec
   private def createFramework(
       loader: ClassLoader,
       log: ManagedLogger,
       frameworkClassNames: List[String]
-  ): Option[Framework] = {
-    def logError(e: Throwable): Option[Framework] = {
+  ): Option[Framework] =
+    def logError(e: Throwable): Option[Framework] =
       log.error(
         s"""Error loading test framework ($e).
            |This often means that you are using a layered class loader that cannot reach the sbt.testing.Framework class.
@@ -64,16 +60,14 @@ final class TestFramework(val implClassNames: String*) extends Serializable {
            |    Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.Flat""".stripMargin
       )
       None
-    }
-    frameworkClassNames match {
+    frameworkClassNames match
       case head :: tail =>
-        try {
-          Some(Class.forName(head, true, loader).getDeclaredConstructor().newInstance() match {
+        try
+          Some(Class.forName(head, true, loader).getDeclaredConstructor().newInstance() match
             case newFramework: Framework    => newFramework
             case oldFramework: OldFramework =>
-              new sbt.internal.worker1.FrameworkWrapper(oldFramework)
-          })
-        } catch {
+              new sbt.internal.worker1.FrameworkWrapper(oldFramework))
+        catch
           case e: NoClassDefFoundError =>
             logError(e)
             throw e
@@ -83,36 +77,32 @@ final class TestFramework(val implClassNames: String*) extends Serializable {
           case _: ClassNotFoundException =>
             log.debug("Framework implementation '" + head + "' not present.")
             createFramework(loader, log, tail)
-        }
       case Nil =>
         None
-    }
-  }
+  end createFramework
 
   def create(loader: ClassLoader, log: ManagedLogger): Option[Framework] =
     createFramework(loader, log, implClassNames.toList)
-}
+end TestFramework
 
 final class TestDefinition(
     val name: String,
     val fingerprint: Fingerprint,
     val explicitlySpecified: Boolean,
     val selectors: Array[Selector]
-) {
+):
   override def toString = "Test " + name + " : " + TestFramework.toString(fingerprint)
   override def equals(t: Any) =
-    t match {
+    t match
       case r: TestDefinition => name == r.name && TestFramework.matches(fingerprint, r.fingerprint)
       case _                 => false
-    }
   override def hashCode: Int = (name.hashCode, TestFramework.hashCode(fingerprint)).hashCode
-}
 
 private[sbt] final class TestRunner(
     delegate: Runner,
     listeners: Vector[TestReportListener],
     log: ManagedLogger
-) {
+):
 
   final def tasks(testDefs: Set[TestDefinition]): Array[TestTask] =
     delegate.tasks(
@@ -121,7 +111,7 @@ private[sbt] final class TestRunner(
         .toArray
     )
 
-  final def run(taskDef: TaskDef, testTask: TestTask): (SuiteResult, Seq[TestTask]) = {
+  final def run(taskDef: TaskDef, testTask: TestTask): (SuiteResult, Seq[TestTask]) =
     val testDefinition = new TestDefinition(
       taskDef.fullyQualifiedName,
       taskDef.fingerprint,
@@ -131,97 +121,89 @@ private[sbt] final class TestRunner(
     log.debug("Running " + taskDef)
     val name = testDefinition.name
 
-    def runTest() = {
+    def runTest() =
       // Thread-safe collection so AsyncFunSuite (and other async frameworks) can call
       // handle() from multiple threads without corrupting results (fixes #5245).
       val results = new CopyOnWriteArrayList[Event]
-      val handler = new EventHandler {
-        def handle(e: Event): Unit = {
+      val handler = new EventHandler:
+        def handle(e: Event): Unit =
           results.add(e)
           safeListenersCall(_.testEvent(TestEvent(Seq(e))))
-        }
-      }
       val loggers: Vector[ContentLogger] = listeners.flatMap(_.contentLogger(testDefinition))
-      def errorEvents(e: Throwable): Array[sbt.testing.Task] = {
+      def errorEvents(e: Throwable): Array[sbt.testing.Task] =
         val taskDef = testTask.taskDef
-        val event = new Event {
+        val event = new Event:
           val status = Status.Error
           val throwable = new OptionalThrowable(e)
           val fullyQualifiedName = taskDef.fullyQualifiedName
           val selector = new TestSelector(name)
           val fingerprint = taskDef.fingerprint
           val duration = -1L
-        }
         results.add(event)
         safeListenersCall(_.testEvent(TestEvent(Seq(event))))
         Array.empty
-      }
       val nestedTasks =
         try testTask.execute(handler, loggers.map(_.log).toArray)
-        catch {
+        catch
           case e: NoClassDefFoundError => errorEvents(e)
           case NonFatal(e)             => errorEvents(e)
           case e: IllegalAccessError   => errorEvents(e)
-        } finally {
-          loggers.foreach(_.flush())
-        }
+        finally loggers.foreach(_.flush())
       val resultsList = results.asScala.toList
       (SuiteResult(resultsList), nestedTasks.toSeq)
-    }
+    end runTest
 
     safeListenersCall(_.startGroup(name))
-    try {
+    try
       val (suiteResult, nestedTasks) = runTest()
       safeListenersCall(_.endGroup(name, suiteResult.result))
       (suiteResult, nestedTasks)
-    } catch {
+    catch
       case e: LinkageError =>
         safeListenersCall(_.endGroup(name, e))
         throw e
       case NonFatal(e) =>
         safeListenersCall(_.endGroup(name, e))
         (SuiteResult.Error, Seq.empty[TestTask])
-    }
-  }
+  end run
 
   protected def safeListenersCall(call: (TestReportListener) => Unit): Unit =
     TestFramework.safeForeach(listeners, log)(call)
-}
+end TestRunner
 
-object TestFramework {
+object TestFramework:
   def apply(implClassNames: String*): TestFramework = new TestFramework(implClassNames*)
 
   def getFingerprints(framework: Framework): Seq[Fingerprint] =
-    framework.getClass.getMethod("fingerprints").invoke(framework) match {
+    framework.getClass.getMethod("fingerprints").invoke(framework) match
       case fingerprints: Array[Fingerprint] => fingerprints.toList
       case _ => sys.error("Could not call 'fingerprints' on framework " + framework)
-    }
 
   private[sbt] def safeForeach[T](it: Iterable[T], log: ManagedLogger)(f: T => Unit): Unit =
     it.foreach(i =>
       try f(i)
-      catch { case NonFatal(e) => log.trace(e); log.error(e.toString) }
+      catch
+        case NonFatal(e) =>
+          log.trace(e)
+          log.error(e.toString)
     )
 
-  private[sbt] def hashCode(f: Fingerprint): Int = f match {
+  private[sbt] def hashCode(f: Fingerprint): Int = f match
     case s: SubclassFingerprint  => (s.isModule, s.superclassName).hashCode
     case a: AnnotatedFingerprint => (a.isModule, a.annotationName).hashCode
     case _                       => 0
-  }
   def matches(a: Fingerprint, b: Fingerprint) =
-    (a, b) match {
+    (a, b) match
       case (a: SubclassFingerprint, b: SubclassFingerprint) =>
         a.isModule == b.isModule && a.superclassName == b.superclassName
       case (a: AnnotatedFingerprint, b: AnnotatedFingerprint) =>
         a.isModule == b.isModule && a.annotationName == b.annotationName
       case _ => false
-    }
   def toString(f: Fingerprint): String =
-    f match {
+    f match
       case sf: SubclassFingerprint  => "subclass(" + sf.isModule + ", " + sf.superclassName + ")"
       case af: AnnotatedFingerprint => "annotation(" + af.isModule + ", " + af.annotationName + ")"
       case _                        => f.toString
-    }
 
   private[sbt] def testTasks(
       frameworks: Map[TestFramework, Framework],
@@ -230,10 +212,9 @@ object TestFramework {
       tests: Vector[TestDefinition],
       log: ManagedLogger,
       listeners: Vector[TestReportListener]
-  ): (() => Unit, Vector[(String, TestFunction)], TestResult => () => Unit) = {
+  ): (() => Unit, Vector[(String, TestFunction)], TestResult => () => Unit) =
     val mappedTests = testMap(frameworks.values.toSeq, tests)
-    if (mappedTests.isEmpty)
-      (() => (), Vector(), _ => () => ())
+    if mappedTests.isEmpty then (() => (), Vector(), _ => () => ())
     else
       createTestTasks(
         testLoader,
@@ -245,22 +226,22 @@ object TestFramework {
         log,
         listeners
       )
-  }
+  end testTasks
 
   private def order(
       mapped: Map[String, TestFunction],
       inputs: Vector[TestDefinition]
   ): Vector[(String, TestFunction)] =
-    for (d <- inputs; act <- mapped.get(d.name)) yield (d.name, act)
+    for d <- inputs; act <- mapped.get(d.name) yield (d.name, act)
 
   def testMap(
       frameworks: Seq[Framework],
       tests: Seq[TestDefinition]
-  ): Map[Framework, Set[TestDefinition]] = {
+  ): Map[Framework, Set[TestDefinition]] =
     import scala.collection.mutable.{ HashMap, HashSet, Set }
     val map = new HashMap[Framework, Set[TestDefinition]]
 
-    def assignTest(test: TestDefinition): Unit = {
+    def assignTest(test: TestDefinition): Unit =
       def isTestForFramework(framework: Framework) = getFingerprints(framework).exists { t =>
         matches(t, test.fingerprint)
       }
@@ -268,13 +249,10 @@ object TestFramework {
       frameworks.find(isTestForFramework).foreach { framework =>
         map.getOrElseUpdate(framework, new HashSet[TestDefinition]) += test
       }
-    }
 
-    if (frameworks.nonEmpty)
-      for (test <- tests) assignTest(test)
+    if frameworks.nonEmpty then for test <- tests do assignTest(test)
 
     map.view.mapValues(_.toSet).toMap
-  }
 
   private def createTestTasks(
       loader: ClassLoader,
@@ -283,7 +261,7 @@ object TestFramework {
       ordered: Vector[TestDefinition],
       log: ManagedLogger,
       listeners: Vector[TestReportListener]
-  ): (() => Unit, Vector[(String, TestFunction)], TestResult => (() => Unit)) = {
+  ): (() => Unit, Vector[(String, TestFunction)], TestResult => (() => Unit)) =
     val testsListeners = listeners collect { case tl: TestsListener => tl }
 
     def foreachListenerSafe(f: TestsListener => Unit): () => Unit =
@@ -294,24 +272,21 @@ object TestFramework {
       Map(tests.toSeq.flatMap { (framework, testDefinitions) =>
         val runner = runners(framework)
         val testTasks = withContextLoader(loader) { runner.tasks(testDefinitions) }
-        for (testTask <- testTasks) yield {
+        for testTask <- testTasks yield
           val taskDef = testTask.taskDef
           (taskDef.fullyQualifiedName, createTestFunction(loader, taskDef, runner, testTask))
-        }
       }*)
 
     val endTask = (result: TestResult) => foreachListenerSafe(_.doComplete(result))
     (startTask, order(testTasks, ordered), endTask)
-  }
-  private def withContextLoader[T](loader: ClassLoader)(eval: => T): T = {
+  end createTestTasks
+  private def withContextLoader[T](loader: ClassLoader)(eval: => T): T =
     val oldLoader = Thread.currentThread.getContextClassLoader
     Thread.currentThread.setContextClassLoader(loader)
-    try {
+    try
       eval
-    } finally {
+    finally
       Thread.currentThread.setContextClassLoader(oldLoader)
-    }
-  }
   def createTestFunction(
       loader: ClassLoader,
       taskDef: TaskDef,
@@ -322,18 +297,16 @@ object TestFramework {
       taskDef,
       runner,
       (r: TestRunner) => withContextLoader(loader) { r.run(taskDef, testTask) }
-    ) {
+    ):
       def tags = testTask.tags.toSeq
-    }
-}
+end TestFramework
 
 abstract class TestFunction(
     val taskDef: TaskDef,
     val runner: TestRunner,
     fun: (TestRunner) => (SuiteResult, Seq[TestTask])
-) {
+):
 
   def apply(): (SuiteResult, Seq[TestTask]) = fun(runner)
 
   def tags: Seq[String]
-}
diff --git a/testing/src/main/scala/sbt/TestReportListener.scala b/testing/src/main/scala/sbt/TestReportListener.scala
index 3dafa81f5..5c3b093a2 100644
--- a/testing/src/main/scala/sbt/TestReportListener.scala
+++ b/testing/src/main/scala/sbt/TestReportListener.scala
@@ -11,7 +11,7 @@ package sbt
 import testing.{ Logger as TLogger, Event as TEvent, Status as TStatus }
 import sbt.protocol.testing.*
 
-trait TestReportListener {
+trait TestReportListener:
 
   /** called for each class or equivalent grouping */
   def startGroup(name: String): Unit
@@ -28,11 +28,9 @@ trait TestReportListener {
   /** Used by the test framework for logging test results */
   def contentLogger(@deprecated("unused", "") test: TestDefinition): Option[ContentLogger] = None
 
-}
-
 final class ContentLogger(val log: TLogger, val flush: () => Unit)
 
-trait TestsListener extends TestReportListener {
+trait TestsListener extends TestReportListener:
 
   /** called once, at beginning. */
   def doInit(): Unit
@@ -40,8 +38,6 @@ trait TestsListener extends TestReportListener {
   /** called once, at end of the test group. */
   def doComplete(finalResult: TestResult): Unit
 
-}
-
 /**
  * Provides the overall `result` of a group of tests (a suite) and test counts for each result type.
  *
@@ -70,7 +66,7 @@ final class SuiteResult(
     val canceledCount: Int,
     val pendingCount: Int,
     val throwables: Seq[Throwable]
-) {
+):
   def this(
       result: TestResult,
       passedCount: Int,
@@ -113,16 +109,15 @@ final class SuiteResult(
         pendingCount,
       )
 
-  def +(other: SuiteResult): SuiteResult = {
+  def +(other: SuiteResult): SuiteResult =
     val combinedTestResult =
-      (result, other.result) match {
+      (result, other.result) match
         case (TestResult.Empty, TestResult.Empty) => TestResult.Empty: TestResult
         case (TestResult.Passed | TestResult.Empty, TestResult.Passed | TestResult.Empty) =>
           TestResult.Passed: TestResult
         case (_, TestResult.Error) => TestResult.Error: TestResult
         case (TestResult.Error, _) => TestResult.Error: TestResult
         case _                     => TestResult.Failed: TestResult
-      }
     new SuiteResult(
       combinedTestResult,
       passedCount + other.passedCount,
@@ -134,15 +129,14 @@ final class SuiteResult(
       pendingCount + other.pendingCount,
       throwables ++ other.throwables
     )
-  }
-}
+end SuiteResult
 
-object SuiteResult {
+object SuiteResult:
 
   /**
    * Computes the overall result and counts for a suite with individual test results in `events`.
    */
-  def apply(events: Seq[TEvent]): SuiteResult = {
+  def apply(events: Seq[TEvent]): SuiteResult =
     def count(status: TStatus) = events.count(_.status == status)
     new SuiteResult(
       TestEvent.overallResult(events),
@@ -155,32 +149,26 @@ object SuiteResult {
       count(TStatus.Pending),
       events.collect { case e if e.throwable.isDefined => e.throwable.get }
     )
-  }
 
   val Error: SuiteResult = new SuiteResult(TestResult.Error, 0, 0, 0, 0, 0, 0, 0)
   val Empty: SuiteResult = new SuiteResult(TestResult.Passed, 0, 0, 0, 0, 0, 0, 0)
+end SuiteResult
 
-}
-
-abstract class TestEvent {
+abstract class TestEvent:
   def result: Option[TestResult]
   def detail: Seq[TEvent] = Nil
-}
-object TestEvent {
+object TestEvent:
   def apply(events: Seq[TEvent]): TestEvent =
-    new TestEvent {
+    new TestEvent:
       val result = Some(overallResult(events))
       override val detail = events
-    }
 
   private[sbt] def overallResult(events: Seq[TEvent]): TestResult =
     events.foldLeft(TestResult.Passed: TestResult) { (sum, event) =>
-      (sum, event.status) match {
+      (sum, event.status) match
         case (TestResult.Error, _)  => TestResult.Error
         case (_, TStatus.Error)     => TestResult.Error
         case (TestResult.Failed, _) => TestResult.Failed
         case (_, TStatus.Failure)   => TestResult.Failed
         case _                      => TestResult.Passed
-      }
     }
-}
diff --git a/testing/src/main/scala/sbt/internal/testing/StatusFormats.scala b/testing/src/main/scala/sbt/internal/testing/StatusFormats.scala
index b75bfef0d..42b17f6ff 100644
--- a/testing/src/main/scala/sbt/internal/testing/StatusFormats.scala
+++ b/testing/src/main/scala/sbt/internal/testing/StatusFormats.scala
@@ -12,12 +12,13 @@ import sbt.testing.Status
 
 import _root_.sjsonnew.{ deserializationError, Builder, JsonFormat, Unbuilder }
 
-trait StatusFormats { self: sjsonnew.BasicJsonProtocol =>
-  given StatusFormat: JsonFormat[Status] = new JsonFormat[Status] {
-    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Status = {
-      jsOpt match {
+trait StatusFormats:
+  self: sjsonnew.BasicJsonProtocol =>
+  given StatusFormat: JsonFormat[Status] = new JsonFormat[Status]:
+    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Status =
+      jsOpt match
         case Some(js) =>
-          unbuilder.readString(js) match {
+          unbuilder.readString(js) match
             case "Success"  => Status.Success
             case "Error"    => Status.Error
             case "Failure"  => Status.Failure
@@ -25,13 +26,10 @@ trait StatusFormats { self: sjsonnew.BasicJsonProtocol =>
             case "Ignored"  => Status.Ignored
             case "Canceled" => Status.Canceled
             case "Pending"  => Status.Pending
-          }
         case None =>
           deserializationError("Expected JsString but found None")
-      }
-    }
-    override def write[J](obj: Status, builder: Builder[J]): Unit = {
-      val str = obj match {
+    override def write[J](obj: Status, builder: Builder[J]): Unit =
+      val str = obj match
         case Status.Success  => "Success"
         case Status.Error    => "Error"
         case Status.Failure  => "Failure"
@@ -39,8 +37,5 @@ trait StatusFormats { self: sjsonnew.BasicJsonProtocol =>
         case Status.Ignored  => "Ignored"
         case Status.Canceled => "Canceled"
         case Status.Pending  => "Pending"
-      }
       builder.writeString(str)
-    }
-  }
-}
+end StatusFormats
diff --git a/testing/src/main/scala/sbt/internal/testing/TestLogger.scala b/testing/src/main/scala/sbt/internal/testing/TestLogger.scala
index 2b67ee54d..02912832b 100644
--- a/testing/src/main/scala/sbt/internal/testing/TestLogger.scala
+++ b/testing/src/main/scala/sbt/internal/testing/TestLogger.scala
@@ -15,7 +15,7 @@ import sbt.util.{ Level, ShowLines }
 import sbt.protocol.testing.*
 import java.util.concurrent.atomic.AtomicInteger
 
-object TestLogger {
+object TestLogger:
   import sbt.protocol.testing.codec.JsonProtocol.given
 
   given testStringEventShowLines: ShowLines[TestStringEvent] =
@@ -39,10 +39,10 @@ object TestLogger {
       global: ManagedLogger,
       perTest: TestDefinition => PerTest,
       level: Level.Value
-  ): TestLogger = {
+  ): TestLogger =
     val context = global.context
     val as = context.appenders(global.name)
-    def makePerTest(tdef: TestDefinition): ContentLogger = {
+    def makePerTest(tdef: TestDefinition): ContentLogger =
       val per = perTest(tdef)
       val l0 = per.log
       val buffs = as.map(a => BufferedAppender(generateBufferName, a)).toList
@@ -51,19 +51,15 @@ object TestLogger {
       buffs.foreach { b =>
         context.addAppender(newLog.name, b -> level)
       }
-      if (per.buffered) {
-        buffs foreach { _.record() }
-      }
+      if per.buffered then buffs foreach { _.record() }
       new ContentLogger(
         wrap(newLog),
-        () => {
+        () =>
           buffs foreach { _.stopQuietly() }
           per.flush()
           // do not unbind here. since there's a delay in the async appender,
           // it will result in missing log output.
-        }
       )
-    }
 
     global.registerStringCodec[TestStringEvent]
 
@@ -81,10 +77,10 @@ object TestLogger {
 
     val config = new TestLogging(wrap(global), global, makePerTest)
     new TestLogger(config)
-  }
+  end make
 
   def wrap(logger: ManagedLogger): TLogger =
-    new TLogger {
+    new TLogger:
       def error(s: String) = log(Level.Error, TestStringEvent(s))
       def warn(s: String) = log(Level.Warn, TestStringEvent(s))
       def info(s: String) = log(Level.Info, TestStringEvent(s))
@@ -92,7 +88,6 @@ object TestLogger {
       def trace(t: Throwable) = logger.trace(t)
       private def log(level: Level.Value, event: TestStringEvent) = logger.logEvent(level, event)
       def ansiCodesSupported() = Terminal.isAnsiSupported
-    }
 
   private[sbt] def toTestItemEvent(event: TestEvent): TestItemEvent =
     TestItemEvent(
@@ -101,21 +96,20 @@ object TestLogger {
         TestItemDetail(
           d.fullyQualifiedName,
           d.status,
-          d.duration match {
+          d.duration match
             case -1 => (None: Option[Long]) // util.Util is not in classpath
             case x  => (Some(x): Option[Long])
-          }
         )
       }
     )
-}
+end TestLogger
 final class TestLogging(
     val global: TLogger,
     val managed: ManagedLogger,
     val logTest: TestDefinition => ContentLogger
 )
 
-class TestLogger(val logging: TestLogging) extends TestsListener {
+class TestLogger(val logging: TestLogging) extends TestsListener:
   import TestLogger.*
   import logging.{ global, logTest, managed }
   import sbt.protocol.testing.codec.JsonProtocol.given
@@ -129,7 +123,7 @@ class TestLogger(val logging: TestLogging) extends TestsListener {
   def endGroup(name: String, result: TestResult): Unit =
     managed.logEvent(Level.Info, EndTestGroupEvent(name, result))
 
-  def endGroup(name: String, t: Throwable): Unit = {
+  def endGroup(name: String, t: Throwable): Unit =
     global.trace(t)
     global.error(s"Could not run test $name: $t")
     managed.logEvent(
@@ -137,10 +131,9 @@ class TestLogger(val logging: TestLogging) extends TestsListener {
       EndTestGroupErrorEvent(name, (t.getMessage + t.getStackTrace.toString).mkString("\n"))
     )
     ()
-  }
 
   def doComplete(finalResult: TestResult): Unit =
     managed.logEvent(Level.Info, TestCompleteEvent(finalResult))
 
   override def contentLogger(test: TestDefinition): Option[ContentLogger] = Some(logTest(test))
-}
+end TestLogger
diff --git a/testing/src/test/scala/sbt/TestRunnerSpec.scala b/testing/src/test/scala/sbt/TestRunnerSpec.scala
index 741a67add..e31041fe1 100644
--- a/testing/src/test/scala/sbt/TestRunnerSpec.scala
+++ b/testing/src/test/scala/sbt/TestRunnerSpec.scala
@@ -22,7 +22,7 @@ import testing.{
 }
 import verify.BasicTestSuite
 
-object TestRunnerSpec extends BasicTestSuite {
+object TestRunnerSpec extends BasicTestSuite:
   // The direct counterpart to sbt-app/src/sbt-test/tests/test-report-listener-linkage-error.
   // This test isolates TestRunner's catch path; the scripted fixture additionally verifies the
   // public testListeners setting with both implicitly created and explicitly thrown errors.
@@ -33,12 +33,10 @@ object TestRunnerSpec extends BasicTestSuite {
     val testTaskDef = taskDef(suiteName)
 
     val thrown = withTestRunner(listener) { runner =>
-      try {
+      try
         runner.run(testTaskDef, new ThrowingTask(testTaskDef, linkageError))
         None
-      } catch {
-        case error: ExceptionInInitializerError => Some(error)
-      }
+      catch case error: ExceptionInInitializerError => Some(error)
     }
 
     assert(thrown.contains(linkageError), s"expected $linkageError to be rethrown, got $thrown")
@@ -56,7 +54,7 @@ object TestRunnerSpec extends BasicTestSuite {
     )
   }
 
-  private final class RecordingListener extends TestReportListener {
+  private final class RecordingListener extends TestReportListener:
     val startedGroups: ArrayBuffer[String] = ArrayBuffer.empty
     val errorEnds: ArrayBuffer[(String, Throwable)] = ArrayBuffer.empty
     val resultEnds: ArrayBuffer[(String, TestResult)] = ArrayBuffer.empty
@@ -65,38 +63,33 @@ object TestRunnerSpec extends BasicTestSuite {
     override def testEvent(event: TestEvent): Unit = ()
     override def endGroup(name: String, error: Throwable): Unit = errorEnds += name -> error
     override def endGroup(name: String, result: TestResult): Unit = resultEnds += name -> result
-  }
 
-  private final class ThrowingTask(testTaskDef: TaskDef, error: LinkageError) extends TestTask {
+  private final class ThrowingTask(testTaskDef: TaskDef, error: LinkageError) extends TestTask:
     override def tags(): Array[String] = Array.empty
     override def taskDef(): TaskDef = testTaskDef
-    override def execute(handler: EventHandler, loggers: Array[TestLogger]): Array[TestTask] = {
+    override def execute(handler: EventHandler, loggers: Array[TestLogger]): Array[TestTask] =
       throw error
-    }
-  }
 
-  private object NoOpRunner extends Runner {
+  private object NoOpRunner extends Runner:
     override def tasks(taskDefs: Array[TaskDef]): Array[TestTask] = Array.empty
     override def done(): String = ""
     override def remoteArgs(): Array[String] = Array.empty
     override def args(): Array[String] = Array.empty
-  }
 
-  private def taskDef(name: String): TaskDef = {
+  private def taskDef(name: String): TaskDef =
     new TaskDef(
       name,
-      new AnnotatedFingerprint {
+      new AnnotatedFingerprint:
         override def isModule(): Boolean = false
         override def annotationName(): String = "example.Test"
-      },
+      ,
       false,
       Array(new SuiteSelector)
     )
-  }
 
-  private def withTestRunner[T](listener: TestReportListener)(f: TestRunner => T): T = {
+  private def withTestRunner[T](listener: TestReportListener)(f: TestRunner => T): T =
     val loggerContext = LoggerContext()
-    try {
+    try
       f(
         new TestRunner(
           NoOpRunner,
@@ -104,8 +97,6 @@ object TestRunnerSpec extends BasicTestSuite {
           loggerContext.logger("TestRunnerSpec", None, None)
         )
       )
-    } finally {
+    finally
       loggerContext.close()
-    }
-  }
-}
+end TestRunnerSpec
diff --git a/util-cache/src/main/scala/sbt/internal/util/codec/ByteBufferFormats.scala b/util-cache/src/main/scala/sbt/internal/util/codec/ByteBufferFormats.scala
index a7dc8e641..faff49610 100644
--- a/util-cache/src/main/scala/sbt/internal/util/codec/ByteBufferFormats.scala
+++ b/util-cache/src/main/scala/sbt/internal/util/codec/ByteBufferFormats.scala
@@ -6,7 +6,8 @@ package codec
 import java.nio.ByteBuffer
 import sjsonnew.{ BasicJsonProtocol, BUtil, IsoString }
 
-trait ByteBufferFormats { self: BasicJsonProtocol =>
+trait ByteBufferFormats:
+  self: BasicJsonProtocol =>
 
   /**
    * A string representation of HashedVirtualFileRef, delimited by `>`.
@@ -19,4 +20,3 @@ trait ByteBufferFormats { self: BasicJsonProtocol =>
 
   given byteBufferIsoString: IsoString[ByteBuffer] =
     IsoString.iso(byteBufferToStr, strToByteBuffer)
-}
diff --git a/util-cache/src/main/scala/sbt/internal/util/codec/HashedVirtualFileRefFormats.scala b/util-cache/src/main/scala/sbt/internal/util/codec/HashedVirtualFileRefFormats.scala
index ad260098b..2fabe4c77 100644
--- a/util-cache/src/main/scala/sbt/internal/util/codec/HashedVirtualFileRefFormats.scala
+++ b/util-cache/src/main/scala/sbt/internal/util/codec/HashedVirtualFileRefFormats.scala
@@ -6,7 +6,8 @@ package codec
 import sjsonnew.{ BasicJsonProtocol, IsoString }
 import xsbti.HashedVirtualFileRef
 
-trait HashedVirtualFileRefFormats { self: BasicJsonProtocol =>
+trait HashedVirtualFileRefFormats:
+  self: BasicJsonProtocol =>
 
   /**
    * A string representation of HashedVirtualFileRef, delimited by `>`.
@@ -15,15 +16,12 @@ trait HashedVirtualFileRefFormats { self: BasicJsonProtocol =>
     s"${ref.id}>${ref.contentHashStr}/${ref.sizeBytes}"
 
   def strToHashedVirtualFileRef(s: String): HashedVirtualFileRef =
-    s.split(">").toList match {
+    s.split(">").toList match
       case path :: rest :: Nil =>
-        rest.split("/").toList match {
+        rest.split("/").toList match
           case hash :: size :: Nil => HashedVirtualFileRef.of(path, hash, size.toLong)
           case _ => throw new RuntimeException(s"invalid HashedVirtualFileRefIsoString $s")
-        }
       case _ => throw new RuntimeException(s"invalid HashedVirtualFileRefIsoString $s")
-    }
 
   given hashedVirtualFileRefIsoString: IsoString[HashedVirtualFileRef] =
     IsoString.iso(hashedVirtualFileRefToStr, strToHashedVirtualFileRef)
-}
diff --git a/util-cache/src/main/scala/sbt/util/ActionCache.scala b/util-cache/src/main/scala/sbt/util/ActionCache.scala
index dcc46126e..fbbfed536 100644
--- a/util-cache/src/main/scala/sbt/util/ActionCache.scala
+++ b/util-cache/src/main/scala/sbt/util/ActionCache.scala
@@ -140,11 +140,14 @@ object ActionCache:
               )
               result
             case Left(e) => throw e
+        end if
       catch
         case NonFatal(e) =>
           logger.debug(s"Skipping cache storage due to error: ${e.getMessage}")
           cacheEventLog.append(ActionCacheEvent.Error)
           result
+      end try
+    end organicTask
 
     def spawnInput = SpawnInput(
       digest = inputDigest,
@@ -231,6 +234,8 @@ object ActionCache:
             )
             Left(None)
       case Left(_) => Left(None)
+    end match
+  end getWithFailure
 
   /**
    * Retrieves the cached value.
@@ -320,6 +325,7 @@ object ActionCache:
         else Vector(Digest.dummy(cacheVersion))
       })*
     )
+  end mkInput
 
   /** Walks `t`'s cause chain for a `NoSuchFileException`, returning the missing file's path. */
   @tailrec
@@ -396,6 +402,7 @@ object ActionCache:
       IO.copyFile(tempZipPath.toFile, zipPath.toFile)
 
       conv.toVirtualFile(zipPath)
+  end packageDirectory
 
   inline def actionResult[A1](inline value: A1): InternalActionResult[A1] =
     InternalActionResult(value, Nil)
diff --git a/util-cache/src/main/scala/sbt/util/ActionCacheStore.scala b/util-cache/src/main/scala/sbt/util/ActionCacheStore.scala
index 8f28b00b7..51516e02a 100644
--- a/util-cache/src/main/scala/sbt/util/ActionCacheStore.scala
+++ b/util-cache/src/main/scala/sbt/util/ActionCacheStore.scala
@@ -188,17 +188,15 @@ end InMemoryActionCacheStore
 
 case class DiskActionCacheStore(base: Path, converter: FileConverter)
     extends AbstractActionCacheStore:
-  lazy val casBase: Path = {
+  lazy val casBase: Path =
     val dir = base.resolve("cas")
     IO.createDirectory(dir.toFile)
     dir
-  }
 
-  lazy val acBase: Path = {
+  lazy val acBase: Path =
     val dir = base.resolve("ac")
     IO.createDirectory(dir.toFile)
     dir
-  }
 
   // Files.copy clones on APFS, so a real file costs no extra disk while sparing every later
   // directory walk the CAS inode lookup that resolving a symlink pays.
@@ -462,6 +460,7 @@ case class DiskActionCacheStore(base: Path, converter: FileConverter)
           // but in practice, NoSuchFileException is thrown often
           case _: NoSuchFileException =>
             writeFileAndNotify(p)
+  end syncFile
 
   /**
    * Emulate virtual side effects.
@@ -518,6 +517,7 @@ case class DiskActionCacheStore(base: Path, converter: FileConverter)
     allPaths.foreach: path =>
       IO.delete(path.toFile())
     dirPath
+  end unpackageDirZip
 
   override def findBlobs(refs: Seq[HashedVirtualFileRef]): Seq[HashedVirtualFileRef] =
     parBlobs(refs)
diff --git a/util-cache/src/main/scala/sbt/util/BasicCacheImplicits.scala b/util-cache/src/main/scala/sbt/util/BasicCacheImplicits.scala
index f29e25b2f..26bc24b72 100644
--- a/util-cache/src/main/scala/sbt/util/BasicCacheImplicits.scala
+++ b/util-cache/src/main/scala/sbt/util/BasicCacheImplicits.scala
@@ -12,20 +12,19 @@ import sbt.internal.util.codec.HashedVirtualFileRefFormats
 import sjsonnew.{ BasicJsonProtocol, IsoString, JsonFormat }
 import xsbti.VirtualFileRef
 
-trait BasicCacheImplicits extends HashedVirtualFileRefFormats { self: BasicJsonProtocol =>
+trait BasicCacheImplicits extends HashedVirtualFileRefFormats:
+  self: BasicJsonProtocol =>
 
   given basicCache[I: JsonFormat, O: JsonFormat]: Cache[I, O] =
     new BasicCache[I, O]()
 
   def wrapIn[I, J](using f: I => J, g: J => I, jCache: SingletonCache[J]): SingletonCache[I] =
-    new SingletonCache[I] {
+    new SingletonCache[I]:
       override def read(from: Input): I = g(jCache.read(from))
       override def write(to: Output, value: I) = jCache.write(to, f(value))
-    }
 
   def singleton[T](t: T): SingletonCache[T] =
     SingletonCache.basicSingletonCache(using asSingleton(t))
 
   given virtualFileRefIsoString: IsoString[VirtualFileRef] =
     IsoString.iso(_.id, VirtualFileRef.of)
-}
diff --git a/util-cache/src/main/scala/sbt/util/Cache.scala b/util-cache/src/main/scala/sbt/util/Cache.scala
index 38d410296..1e5dd0901 100644
--- a/util-cache/src/main/scala/sbt/util/Cache.scala
+++ b/util-cache/src/main/scala/sbt/util/Cache.scala
@@ -24,15 +24,14 @@ case class Miss[O](update: O => Unit) extends CacheResult[O]
 /**
  * A simple cache with keys of type `I` and values of type `O`
  */
-trait Cache[I, O] {
+trait Cache[I, O]:
 
   /**
    * Queries the cache backed with store `store` for key `key`.
    */
   def apply(store: CacheStore)(key: I): CacheResult[O]
-}
 
-object Cache {
+object Cache:
 
   /**
    * Materializes a cache.
@@ -60,7 +59,7 @@ object Cache {
    */
   def cached[I, O](store: CacheStore)(default: I => O)(using cache: Cache[I, O]): I => O =
     key =>
-      cache(store)(key) match {
+      cache(store)(key) match
         case Hit(value) =>
           value
 
@@ -68,19 +67,15 @@ object Cache {
           val result = default(key)
           update(result)
           result
-      }
 
   def debug[I](label: String, cache: SingletonCache[I]): SingletonCache[I] =
-    new SingletonCache[I] {
-      override def read(from: Input): I = {
+    new SingletonCache[I]:
+      override def read(from: Input): I =
         val value = cache.read(from)
         println(label + ".read: " + value)
         value
-      }
 
-      override def write(to: Output, value: I): Unit = {
+      override def write(to: Output, value: I): Unit =
         println(label + ".write: " + value)
         cache.write(to, value)
-      }
-    }
-}
+end Cache
diff --git a/util-cache/src/main/scala/sbt/util/CacheStore.scala b/util-cache/src/main/scala/sbt/util/CacheStore.scala
index ea7fcf852..984c6f4fb 100644
--- a/util-cache/src/main/scala/sbt/util/CacheStore.scala
+++ b/util-cache/src/main/scala/sbt/util/CacheStore.scala
@@ -17,14 +17,12 @@ import sjsonnew.support.scalajson.unsafe.{ CompactPrinter, Parser }
 import sjsonnew.{ IsoString, JsonReader, JsonWriter, SupportConverter }
 
 /** A `CacheStore` is used by the caching infrastructure to persist cached information. */
-abstract class CacheStore extends Input with Output {
+abstract class CacheStore extends Input with Output:
 
   /** Delete the persisted information. */
   def delete(): Unit
 
-}
-
-object CacheStore {
+object CacheStore:
   @deprecated("Create your own IsoString[JValue]", "1.4") given jvalueIsoString: IsoString[JValue] =
     IsoString.iso(CompactPrinter.apply, Parser.parseUnsafe)
 
@@ -36,10 +34,9 @@ object CacheStore {
 
   /** Returns a file-based CacheStore that gzips what it writes. */
   private[sbt] def gzipFile(cacheFile: File): CacheStore = new GzipFileBasedStore(cacheFile)
-}
 
 /** Factory that can make new stores. */
-abstract class CacheStoreFactory {
+abstract class CacheStoreFactory:
 
   /** Create a new store. */
   def make(identifier: String): CacheStore
@@ -52,9 +49,8 @@ abstract class CacheStoreFactory {
 
   /** A symbolic alias for `sub`. */
   final def /(identifier: String): CacheStoreFactory = sub(identifier)
-}
 
-object CacheStoreFactory {
+object CacheStoreFactory:
   @deprecated("Create your own IsoString[JValue]", "1.4") given jvalueIsoString: IsoString[JValue] =
     IsoString.iso(CompactPrinter.apply, Parser.parseUnsafe)
 
@@ -63,10 +59,9 @@ object CacheStoreFactory {
 
   /** Returns directory-based CacheStoreFactory using standard JSON converter. */
   def directory(base: File): CacheStoreFactory = new DirectoryStoreFactory(base)
-}
 
 /** A factory that creates new stores persisted in `base`. */
-class DirectoryStoreFactory[J](base: File) extends CacheStoreFactory {
+class DirectoryStoreFactory[J](base: File) extends CacheStoreFactory:
   IO.createDirectory(base)
 
   def make(identifier: String): CacheStore = new FileBasedStore(base / identifier)
@@ -76,10 +71,9 @@ class DirectoryStoreFactory[J](base: File) extends CacheStoreFactory {
 
   def sub(identifier: String): CacheStoreFactory =
     new DirectoryStoreFactory(base / identifier)
-}
 
 /** A `CacheStore` that persists information in `file`. */
-class FileBasedStore[J](file: File) extends CacheStore {
+class FileBasedStore[J](file: File) extends CacheStore:
   IO.touch(file, setModified = false)
 
   def read[T: JsonReader]() =
@@ -90,10 +84,9 @@ class FileBasedStore[J](file: File) extends CacheStore {
 
   def delete() = IO.delete(file)
   def close() = ()
-}
 
 /** A `CacheStore` that persists information in `file`, gzip-framed. */
-private[sbt] class GzipFileBasedStore(file: File) extends CacheStore {
+private[sbt] class GzipFileBasedStore(file: File) extends CacheStore:
   IO.touch(file, setModified = false)
 
   def read[T: JsonReader]() =
@@ -104,16 +97,15 @@ private[sbt] class GzipFileBasedStore(file: File) extends CacheStore {
 
   def delete() = IO.delete(file)
   def close() = ()
-}
 
 /** A store that reads from `inputStream` and writes to `outputStream`. */
 class StreamBasedStore[J: IsoString](
     inputStream: InputStream,
     outputStream: OutputStream,
     converter: SupportConverter[J]
-) extends CacheStore {
+) extends CacheStore:
   def read[T: JsonReader]() = new PlainInput(inputStream, converter).read()
   def write[T: JsonWriter](value: T) = new PlainOutput(outputStream, converter).write(value)
   def delete() = ()
-  def close() = { inputStream.close(); outputStream.close() }
-}
+  def close() =
+    inputStream.close(); outputStream.close()
diff --git a/util-cache/src/main/scala/sbt/util/Digest.scala b/util-cache/src/main/scala/sbt/util/Digest.scala
index fb4517bb4..7ae61a7e3 100644
--- a/util-cache/src/main/scala/sbt/util/Digest.scala
+++ b/util-cache/src/main/scala/sbt/util/Digest.scala
@@ -132,6 +132,7 @@ object Digest:
         val md = MessageDigest.getInstance(jvmAlgo(algo))
         val size = transfer((buf, n) => md.update(buf, 0, n))
         apply(algo, md.digest(), size)
+  end transferAndHash
 
   // first check the file size, then the hash
   def sameDigest(path: Path, digest: Digest): Boolean =
@@ -205,7 +206,10 @@ object Digest:
           case (a @ Sha512) :: value :: sizeBytes :: Nil =>
             (a, value, sizeBytes.toLong, parseHex(value, 512))
           case _ => throw IllegalArgumentException(s"unexpected digest: $s")
+        end match
       case _ => throw IllegalArgumentException(s"unexpected digest: $s")
+    end match
+  end parse
 
   private def jvmAlgo(algo: String): String =
     algo match
diff --git a/util-cache/src/main/scala/sbt/util/DigestHasher.scala b/util-cache/src/main/scala/sbt/util/DigestHasher.scala
index de307327c..cb2bebc79 100644
--- a/util-cache/src/main/scala/sbt/util/DigestHasher.scala
+++ b/util-cache/src/main/scala/sbt/util/DigestHasher.scala
@@ -53,3 +53,4 @@ private[sbt] object DigestHasher extends SupportHasher[Digest]:
     def jobject(vs: Map[String, Digest]): Digest =
       val sorted = vs.toSeq.sortBy(_._1).flatMap((k, v) => Seq(jstring(k), v))
       Digest.sha256Hash((objectTag +: sorted)*)
+end DigestHasher
diff --git a/util-cache/src/main/scala/sbt/util/FileInfo.scala b/util-cache/src/main/scala/sbt/util/FileInfo.scala
index 603064e2c..16887ca94 100644
--- a/util-cache/src/main/scala/sbt/util/FileInfo.scala
+++ b/util-cache/src/main/scala/sbt/util/FileInfo.scala
@@ -17,43 +17,39 @@ import sjsonnew.BasicJsonProtocol.given
 import sbt.nio.file.*
 import sbt.nio.file.syntax.*
 
-sealed trait FileInfo { def file: File }
-sealed trait HashFileInfo extends FileInfo {
+sealed trait FileInfo:
+  def file: File
+sealed trait HashFileInfo extends FileInfo:
   @deprecated("Use hashArray instead", "1.3.0")
   def hash: List[Byte] = hashArray.toList
   private[util] def hashArray: Array[Byte]
-}
-sealed trait ModifiedFileInfo extends FileInfo { def lastModified: Long }
-sealed trait PlainFileInfo extends FileInfo { def exists: Boolean }
+sealed trait ModifiedFileInfo extends FileInfo:
+  def lastModified: Long
+sealed trait PlainFileInfo extends FileInfo:
+  def exists: Boolean
 
 sealed trait HashModifiedFileInfo extends HashFileInfo with ModifiedFileInfo
 
-object HashFileInfo {
+object HashFileInfo:
   given format: JsonFormat[HashFileInfo] = FileInfo.hash.format
-}
-object ModifiedFileInfo {
+object ModifiedFileInfo:
   given format: JsonFormat[ModifiedFileInfo] = FileInfo.lastModified.format
-}
-object PlainFileInfo {
+object PlainFileInfo:
   given format: JsonFormat[PlainFileInfo] = FileInfo.exists.format
-}
-object HashModifiedFileInfo {
+object HashModifiedFileInfo:
   given format: JsonFormat[HashModifiedFileInfo] = FileInfo.full.format
-}
 
 private final case class PlainFile(file: File, exists: Boolean) extends PlainFileInfo
 
 private final case class FileModified(file: File, lastModified: Long) extends ModifiedFileInfo
 
 private final case class FileHashArrayRepr(file: File, override val hashArray: Array[Byte])
-    extends HashFileInfo {
+    extends HashFileInfo:
   override def hashCode(): Int = (file, java.util.Arrays.hashCode(hashArray)).hashCode()
-  override def equals(obj: Any): Boolean = obj match {
+  override def equals(obj: Any): Boolean = obj match
     case that: FileHashArrayRepr =>
       this.file == that.file && java.util.Arrays.equals(this.hashArray, that.hashArray)
     case _ => false
-  }
-}
 
 private final case class FileHashModifiedArrayRepr(
     file: File,
@@ -62,7 +58,7 @@ private final case class FileHashModifiedArrayRepr(
 ) extends HashModifiedFileInfo
 
 final case class FilesInfo[F <: FileInfo] private[sbt] (files: Set[F])
-object FilesInfo {
+object FilesInfo:
   def empty[F <: FileInfo]: FilesInfo[F] = FilesInfo(Set.empty[F])
 
   given format[F <: FileInfo: JsonFormat]: JsonFormat[FilesInfo[F]] =
@@ -72,34 +68,27 @@ object FilesInfo {
   def hash: FileInfo.Style = FileInfo.hash
   def lastModified: FileInfo.Style = FileInfo.lastModified
   def exists: FileInfo.Style = FileInfo.exists
-}
 
-object FileInfo {
+object FileInfo:
 
   /**
    * Stores byte arrays as hex encoded strings, but falls back to reading an array of integers,
    * which is how it used to be stored, if that fails.
    */
-  given byteArrayFormat: JsonFormat[Array[Byte]] = new JsonFormat[Array[Byte]] {
-    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Array[Byte] = {
-      jsOpt match {
+  given byteArrayFormat: JsonFormat[Array[Byte]] = new JsonFormat[Array[Byte]]:
+    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Array[Byte] =
+      jsOpt match
         case Some(js) =>
-          try {
-            Hash.fromHex(unbuilder.readString(js))
-          } catch {
+          try Hash.fromHex(unbuilder.readString(js))
+          catch
             case _: DeserializationException =>
               CacheImplicits.arrayFormat[Byte].read(jsOpt, unbuilder)
-          }
         case None => Array.empty
-      }
-    }
 
-    override def write[J](obj: Array[Byte], builder: Builder[J]): Unit = {
+    override def write[J](obj: Array[Byte], builder: Builder[J]): Unit =
       builder.writeString(Hash.toHex(obj))
-    }
-  }
 
-  sealed trait Style {
+  sealed trait Style:
     type F <: FileInfo
 
     given format: JsonFormat[F]
@@ -111,21 +100,19 @@ object FileInfo {
 
     def unapply(info: F): File = info.file
     def unapply(infos: FilesInfo[F]): Set[File] = infos.files map (_.file)
-  }
 
-  object full extends Style {
+  object full extends Style:
     type F = HashModifiedFileInfo
 
-    given format: JsonFormat[HashModifiedFileInfo] = new JsonFormat[HashModifiedFileInfo] {
-      def write[J](obj: HashModifiedFileInfo, builder: Builder[J]) = {
+    given format: JsonFormat[HashModifiedFileInfo] = new JsonFormat[HashModifiedFileInfo]:
+      def write[J](obj: HashModifiedFileInfo, builder: Builder[J]) =
         builder.beginObject()
         builder.addField("file", obj.file.toString)
         builder.addField("hash", obj.hashArray)
         builder.addField("lastModified", obj.lastModified)
         builder.endObject()
-      }
 
-      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match {
+      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match
         case Some(js) =>
           unbuilder.beginObject(js)
           val file = unbuilder.readField[String]("file")
@@ -134,27 +121,24 @@ object FileInfo {
           unbuilder.endObject()
           FileHashModifiedArrayRepr(new File(file), hash, lastModified)
         case None => deserializationError("Expected JsObject but found None")
-      }
-    }
 
     implicit def apply(file: File): HashModifiedFileInfo =
       FileHashModifiedArrayRepr(file.getAbsoluteFile, Hash(file), IO.getModifiedTimeOrZero(file))
     def apply(file: File, hash: Array[Byte], lastModified: Long): HashModifiedFileInfo =
       FileHashModifiedArrayRepr(file.getAbsoluteFile, hash, lastModified)
-  }
+  end full
 
-  object hash extends Style {
+  object hash extends Style:
     type F = HashFileInfo
 
-    given format: JsonFormat[HashFileInfo] = new JsonFormat[HashFileInfo] {
-      def write[J](obj: HashFileInfo, builder: Builder[J]) = {
+    given format: JsonFormat[HashFileInfo] = new JsonFormat[HashFileInfo]:
+      def write[J](obj: HashFileInfo, builder: Builder[J]) =
         builder.beginObject()
         builder.addField("file", obj.file.toString)
         builder.addField("hash", obj.hashArray)
         builder.endObject()
-      }
 
-      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match {
+      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match
         case Some(js) =>
           unbuilder.beginObject(js)
           val file = unbuilder.readField[String]("file")
@@ -162,8 +146,6 @@ object FileInfo {
           unbuilder.endObject()
           FileHashArrayRepr(new File(file), hash)
         case None => deserializationError("Expected JsObject but found None")
-      }
-    }
 
     implicit def apply(file: File): HashFileInfo =
       FileHashArrayRepr(file.getAbsoluteFile, computeHash(file))
@@ -172,15 +154,15 @@ object FileInfo {
 
     private def computeHash(file: File): Array[Byte] =
       try Hash(file)
-      catch { case NonFatal(_) => Array.empty }
-  }
+      catch case NonFatal(_) => Array.empty
+  end hash
 
-  object lastModified extends Style {
+  object lastModified extends Style:
     type F = ModifiedFileInfo
 
-    given format: JsonFormat[ModifiedFileInfo] = new JsonFormat[ModifiedFileInfo] {
+    given format: JsonFormat[ModifiedFileInfo] = new JsonFormat[ModifiedFileInfo]:
       override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): ModifiedFileInfo =
-        jsOpt match {
+        jsOpt match
           case Some(js) =>
             unbuilder.beginObject(js)
             val file = unbuilder.readField[String]("file")
@@ -189,15 +171,12 @@ object FileInfo {
             FileModified(new File(file), lastModified)
           case None =>
             deserializationError("Expected JsObject but found None")
-        }
 
-      override def write[J](obj: ModifiedFileInfo, builder: Builder[J]): Unit = {
+      override def write[J](obj: ModifiedFileInfo, builder: Builder[J]): Unit =
         builder.beginObject()
         builder.addField[String]("file", obj.file.toString)
         builder.addField[String]("lastModified", obj.lastModified.toString)
         builder.endObject()
-      }
-    }
 
     implicit def apply(file: File): ModifiedFileInfo =
       FileModified(file.getAbsoluteFile, IO.getModifiedTimeOrZero(file))
@@ -215,30 +194,29 @@ object FileInfo {
      * @return
      *   the [[FileModified]]
      */
-    private[sbt] def fileOrDirectoryMax(file: File): ModifiedFileInfo = {
+    private[sbt] def fileOrDirectoryMax(file: File): ModifiedFileInfo =
       val maxLastModified =
-        if (file.isDirectory) FileTreeView.default.list(file.toGlob / **).foldLeft(0L) {
-          case (max, (path, attributes)) =>
-            val lm = if (!attributes.isDirectory) IO.getModifiedTimeOrZero(path.toFile) else 0L
-            if (lm > max) lm else max
-        }
+        if file.isDirectory then
+          FileTreeView.default.list(file.toGlob / **).foldLeft(0L) {
+            case (max, (path, attributes)) =>
+              val lm = if !attributes.isDirectory then IO.getModifiedTimeOrZero(path.toFile) else 0L
+              if lm > max then lm else max
+          }
         else IO.getModifiedTimeOrZero(file)
       FileModified(file, maxLastModified)
-    }
-  }
+  end lastModified
 
-  object exists extends Style {
+  object exists extends Style:
     type F = PlainFileInfo
 
-    given format: JsonFormat[PlainFileInfo] = new JsonFormat[PlainFileInfo] {
-      def write[J](obj: PlainFileInfo, builder: Builder[J]): Unit = {
+    given format: JsonFormat[PlainFileInfo] = new JsonFormat[PlainFileInfo]:
+      def write[J](obj: PlainFileInfo, builder: Builder[J]): Unit =
         builder.beginObject()
         builder.addField("file", obj.file.toString)
         builder.addField("exists", obj.exists)
         builder.endObject()
-      }
 
-      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match {
+      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match
         case Some(js) =>
           unbuilder.beginObject(js)
           val file = unbuilder.readField[String]("file")
@@ -246,16 +224,12 @@ object FileInfo {
           unbuilder.endObject()
           PlainFile(new File(file), exists)
         case None => deserializationError("Expected JsObject but found None")
-      }
-    }
 
-    implicit def apply(file: File): PlainFileInfo = {
+    implicit def apply(file: File): PlainFileInfo =
       val abs = file.getAbsoluteFile
       PlainFile(abs, abs.exists)
-    }
-    def apply(file: File, exists: Boolean): PlainFileInfo = {
+    def apply(file: File, exists: Boolean): PlainFileInfo =
       val abs = file.getAbsoluteFile
       PlainFile(abs, exists)
-    }
-  }
-}
+  end exists
+end FileInfo
diff --git a/util-cache/src/main/scala/sbt/util/Input.scala b/util-cache/src/main/scala/sbt/util/Input.scala
index 636b7bf81..aaec97961 100644
--- a/util-cache/src/main/scala/sbt/util/Input.scala
+++ b/util-cache/src/main/scala/sbt/util/Input.scala
@@ -17,91 +17,82 @@ import sjsonnew.{ IsoString, JsonReader, SupportConverter }
 import sbt.io.{ IO, Using }
 import sbt.internal.util.EmptyCacheError
 
-trait Input extends Closeable {
+trait Input extends Closeable:
   def read[T: JsonReader](): T
   def read[T: JsonReader](default: => T): T =
     try read[T]()
-    catch { case NonFatal(_) => default }
-}
+    catch case NonFatal(_) => default
 
-class PlainInput[J: IsoString](input: InputStream, converter: SupportConverter[J]) extends Input {
+class PlainInput[J: IsoString](input: InputStream, converter: SupportConverter[J]) extends Input:
   val isoFormat: IsoString[J] = implicitly
 
-  private def readFully(): String = {
+  private def readFully(): String =
     Using.streamReader((input, IO.utf8)) { reader =>
       val builder = new StringBuilder()
       val bufferSize = 1024
       val buffer = new Array[Char](bufferSize)
       var read = 0
-      while ({ read = reader.read(buffer, 0, bufferSize); read != -1 }) {
+      while { read = reader.read(buffer, 0, bufferSize); read != -1 } do
         builder.appendAll(buffer, 0, read)
-      }
 
       builder.toString()
     }
-  }
 
-  def read[T: JsonReader](): T = {
+  def read[T: JsonReader](): T =
     val str = readFully()
-    if (str == "") throw new EmptyCacheError()
+    if str == "" then throw new EmptyCacheError()
     else converter.fromJson(isoFormat.from(str)).get
-  }
 
   def close() = input.close()
-}
+end PlainInput
 
-class FileInput(file: File) extends Input {
+class FileInput(file: File) extends Input:
 
-  override def read[T: JsonReader](): T = {
+  override def read[T: JsonReader](): T =
     sjsonnew.support.scalajson.unsafe.Converter
       .fromJson(sjsonnew.support.scalajson.unsafe.Parser.parseFromFile(file).get)
       .get
-  }
 
   def close() = ()
-}
 
 /** Sniffs the framing rather than trusting the name, so a cache written uncompressed still loads. */
-private[sbt] class GzipFileInput(file: File) extends Input {
+private[sbt] class GzipFileInput(file: File) extends Input:
 
-  override def read[T: JsonReader](): T = {
+  override def read[T: JsonReader](): T =
     val json = Using.fileInputStream(file) { raw =>
       val buffered = new BufferedInputStream(raw)
       buffered.mark(2)
       val gzipped = buffered.read() == 0x1f && buffered.read() == 0x8b
       buffered.reset()
       val bytes =
-        if (gzipped) Using.gzipInputStream(buffered)(IO.readBytes)
+        if gzipped then Using.gzipInputStream(buffered)(IO.readBytes)
         else IO.readBytes(buffered)
-      if (bytes.isEmpty) throw new EmptyCacheError()
+      if bytes.isEmpty then throw new EmptyCacheError()
       sjsonnew.support.scalajson.unsafe.Parser.parseFromByteArray(bytes).get
     }
     sjsonnew.support.scalajson.unsafe.Converter.fromJson(json).get
-  }
 
   def close() = ()
-}
 
-private[sbt] object GzipFileInput {
+private[sbt] object GzipFileInput:
 
   /**
    * What `file` holds once inflated: gzip records it in the last four bytes of the member. Anything
    * that is not a whole gzip member weighs what it occupies on disk instead.
    */
-  def uncompressedSize(file: File): Long = {
+  def uncompressedSize(file: File): Long =
     val channel = Files.newByteChannel(file.toPath)
-    try {
+    try
       val size = channel.size
       // Shorter than an empty gzip member, so there is no trailer to read.
-      if (size < 18) size
-      else {
-        def readAt(position: Long, n: Int): Option[ByteBuffer] = {
+      if size < 18 then size
+      else
+        def readAt(position: Long, n: Int): Option[ByteBuffer] =
           val buffer = ByteBuffer.allocate(n)
           channel.position(position)
-          while (buffer.hasRemaining && channel.read(buffer) > 0) ()
+          while buffer.hasRemaining && channel.read(buffer) > 0 do ()
           // A short read leaves zeros behind, which would pass for a valid ISIZE.
-          if (buffer.hasRemaining) None else Some(buffer)
-        }
+          if buffer.hasRemaining then None else Some(buffer)
         val isize =
           for
             magic <- readAt(0, 2)
@@ -110,7 +101,6 @@ private[sbt] object GzipFileInput {
           yield (0 until 4).foldLeft(0L)((acc, i) => acc | ((trailer.get(i) & 0xffL) << (8 * i)))
         // ISIZE is the payload length modulo 2^32, so it is only a floor above that.
         isize.filter(_ > 0).getOrElse(size)
-      }
-    } finally channel.close()
-  }
-}
+    finally channel.close()
+  end uncompressedSize
+end GzipFileInput
diff --git a/util-cache/src/main/scala/sbt/util/Output.scala b/util-cache/src/main/scala/sbt/util/Output.scala
index 1a323e3ba..f63c83e96 100644
--- a/util-cache/src/main/scala/sbt/util/Output.scala
+++ b/util-cache/src/main/scala/sbt/util/Output.scala
@@ -13,15 +13,14 @@ import java.io.{ Closeable, File, OutputStream }
 import sjsonnew.{ IsoString, JsonWriter, SupportConverter }
 import sbt.io.{ IO, Using }
 
-trait Output extends Closeable {
+trait Output extends Closeable:
   def write[T: JsonWriter](value: T): Unit
-}
 
 class PlainOutput[J: IsoString](output: OutputStream, converter: SupportConverter[J])
-    extends Output {
+    extends Output:
   val isoFormat: IsoString[J] = implicitly
 
-  def write[T: JsonWriter](value: T) = {
+  def write[T: JsonWriter](value: T) =
     val js = converter.toJson(value).get
     val asString = isoFormat.to(js)
     Using.bufferedOutputStream(output) { writer =>
@@ -29,27 +28,23 @@ class PlainOutput[J: IsoString](output: OutputStream, converter: SupportConverte
       out.print(asString)
       out.flush()
     }
-  }
 
   def close() = output.close()
-}
 
-class FileOutput(file: File) extends Output {
-  override def write[T: JsonWriter](value: T): Unit = {
+class FileOutput(file: File) extends Output:
+  override def write[T: JsonWriter](value: T): Unit =
     val js = sjsonnew.support.scalajson.unsafe.Converter.toJson(value).get
     Using.fileOutputStream(append = false)(file) { stream =>
       val out = new java.io.PrintWriter(stream)
       sjsonnew.support.scalajson.unsafe.CompactPrinter.print(js, out)
       out.flush()
     }
-  }
 
   def close() = ()
-}
 
 /** Writes a gzip-framed cache file. */
-private[sbt] class GzipFileOutput(file: File) extends Output {
-  override def write[T: JsonWriter](value: T): Unit = {
+private[sbt] class GzipFileOutput(file: File) extends Output:
+  override def write[T: JsonWriter](value: T): Unit =
     val js = sjsonnew.support.scalajson.unsafe.Converter.toJson(value).get
     Using.fileOutputStream(append = false)(file) { stream =>
       Using.gzipOutputStream(stream) { gz =>
@@ -59,7 +54,5 @@ private[sbt] class GzipFileOutput(file: File) extends Output {
         out.flush()
       }
     }
-  }
 
   def close() = ()
-}
diff --git a/util-cache/src/main/scala/sbt/util/SeparatedCache.scala b/util-cache/src/main/scala/sbt/util/SeparatedCache.scala
index 53682274f..a027a2d31 100644
--- a/util-cache/src/main/scala/sbt/util/SeparatedCache.scala
+++ b/util-cache/src/main/scala/sbt/util/SeparatedCache.scala
@@ -19,7 +19,7 @@ import CacheImplicits.*
 /**
  * A cache that stores a single value.
  */
-trait SingletonCache[A] {
+trait SingletonCache[A]:
 
   /** Reads the cache from the backing `from`. */
   def read(from: Input): A
@@ -27,42 +27,34 @@ trait SingletonCache[A] {
   /** Writes `value` to the backing `to`. */
   def write(to: Output, value: A): Unit
 
-}
-
-object SingletonCache {
+object SingletonCache:
 
   given basicSingletonCache[A: JsonFormat]: SingletonCache[A] =
-    new SingletonCache[A] {
+    new SingletonCache[A]:
       override def read(from: Input): A = from.read[A]()
       override def write(to: Output, value: A) = to.write(value)
-    }
 
   /** A lazy `SingletonCache` */
   @nowarn("msg=unused")
   def lzy[A: JsonFormat](mkCache: => SingletonCache[A]): SingletonCache[A] =
-    new SingletonCache[A] {
+    new SingletonCache[A]:
       lazy val cache = mkCache
       override def read(from: Input): A = cache.read(from)
       override def write(to: Output, value: A) = cache.write(to, value)
-    }
-}
 
 /**
  * Simple key-value cache.
  */
-class BasicCache[I: JsonFormat, O: JsonFormat] extends Cache[I, O] {
+class BasicCache[I: JsonFormat, O: JsonFormat] extends Cache[I, O]:
   private val singletonCache: SingletonCache[(Long, O)] = implicitly
   val jsonFormat: JsonFormat[I] = implicitly
-  override def apply(store: CacheStore)(key: I): CacheResult[O] = {
+  override def apply(store: CacheStore)(key: I): CacheResult[O] =
     val keyHash: Long = Hasher.hashUnsafe[I](key).toLong
     Try {
       val (previousKeyHash, previousValue) = singletonCache.read(store)
-      if (keyHash == previousKeyHash) Hit(previousValue)
+      if keyHash == previousKeyHash then Hit(previousValue)
       else Miss(update(store)(keyHash))
     } getOrElse Miss(update(store)(keyHash))
-  }
 
-  private def update(store: CacheStore)(keyHash: Long) = (value: O) => {
+  private def update(store: CacheStore)(keyHash: Long) = (value: O) =>
     singletonCache.write(store, (keyHash, value))
-  }
-}
diff --git a/util-cache/src/main/scala/sbt/util/StampedFormat.scala b/util-cache/src/main/scala/sbt/util/StampedFormat.scala
index 81251bc86..8dacf4c89 100644
--- a/util-cache/src/main/scala/sbt/util/StampedFormat.scala
+++ b/util-cache/src/main/scala/sbt/util/StampedFormat.scala
@@ -12,44 +12,39 @@ import scala.reflect.ClassTag
 
 import sjsonnew.{ BasicJsonProtocol, Builder, deserializationError, JsonFormat, Unbuilder }
 
-object StampedFormat extends BasicJsonProtocol {
+object StampedFormat extends BasicJsonProtocol:
 
-  def apply[T](format: JsonFormat[T])(using mf: ClassTag[JsonFormat[T]]): JsonFormat[T] = {
+  def apply[T](format: JsonFormat[T])(using mf: ClassTag[JsonFormat[T]]): JsonFormat[T] =
     withStamp(stamp(format))(format)
-  }
 
   def withStamp[T, S](stamp: S)(format: JsonFormat[T])(using
       formatStamp: JsonFormat[S],
       equivStamp: Equiv[S]
   ): JsonFormat[T] =
-    new JsonFormat[T] {
+    new JsonFormat[T]:
       override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): T =
-        jsOpt match {
+        jsOpt match
           case Some(js) =>
             val stampedLength = unbuilder.beginArray(js)
-            if (stampedLength != 2)
+            if stampedLength != 2 then
               sys.error(s"Expected JsArray of size 2, found JsArray of size $stampedLength.")
             val readStamp = unbuilder.nextElement
             val readValue = unbuilder.nextElement
             val actualStamp = formatStamp.read(Some(readStamp), unbuilder)
-            if (equivStamp.equiv(actualStamp, stamp)) format.read(Some(readValue), unbuilder)
+            if equivStamp.equiv(actualStamp, stamp) then format.read(Some(readValue), unbuilder)
             else sys.error(s"Incorrect stamp. Expected: $stamp, Found: $readStamp")
 
           case None =>
             deserializationError("Expected JsArray but found None.")
-        }
 
-      override def write[J](obj: T, builder: Builder[J]): Unit = {
+      override def write[J](obj: T, builder: Builder[J]): Unit =
         builder.beginArray()
         formatStamp.write(stamp, builder)
         format.write(obj, builder)
         builder.endArray()
-      }
-    }
 
   private def stamp[T](format: JsonFormat[T])(using mf: ClassTag[JsonFormat[T]]): Int =
     typeHash(using mf)
 
   private def typeHash[T](using mf: ClassTag[T]) = mf.toString.hashCode
-
-}
+end StampedFormat
diff --git a/util-cache/src/test/scala/sbt/util/ActionCacheTest.scala b/util-cache/src/test/scala/sbt/util/ActionCacheTest.scala
index eeae34656..74eb0e594 100644
--- a/util-cache/src/test/scala/sbt/util/ActionCacheTest.scala
+++ b/util-cache/src/test/scala/sbt/util/ActionCacheTest.scala
@@ -56,7 +56,7 @@ object ActionCacheTest extends BasicTestSuite:
     var b: String = null
     var i = 0
     val cap = 5000000
-    while (b == null && i < cap) do
+    while b == null && i < cap do
       val key = s"input-$i"
       Hasher.hashUnsafe[String](key) match
         case h if seen.contains(h) => a = seen(h); b = key
@@ -209,10 +209,9 @@ object ActionCacheTest extends BasicTestSuite:
   def testActionCacheBasic(cache: ActionCacheStore): Unit =
     import sjsonnew.BasicJsonProtocol.*
     var called = 0
-    val action: ((Int, Int)) => InternalActionResult[Int] = { (a, b) =>
+    val action: ((Int, Int)) => InternalActionResult[Int] = (a, b) =>
       called += 1
       InternalActionResult(a + b, Nil)
-    }
     IO.withTemporaryDirectory: (tempDir) =>
       val config = getCacheConfig(cache, tempDir)
       val v1 =
@@ -231,11 +230,10 @@ object ActionCacheTest extends BasicTestSuite:
     import sjsonnew.BasicJsonProtocol.*
     IO.withTemporaryDirectory: (tempDir) =>
       var called = 0
-      val action: ((Int, Int)) => InternalActionResult[Int] = { (a, b) =>
+      val action: ((Int, Int)) => InternalActionResult[Int] = (a, b) =>
         called += 1
         val out = StringVirtualFile1(s"$tempDir/a.txt", (a + b).toString)
         InternalActionResult(a + b, Seq(out))
-      }
       val config = getCacheConfig(cache, tempDir)
       val v1 =
         ActionCache.cache((1, 1), Digest.zero, Digest.zero, tags, config)(action)
@@ -252,6 +250,7 @@ object ActionCacheTest extends BasicTestSuite:
       assert(v2 == 2)
       // check that the action has been invoked only once
       assert(called == 1)
+  end testActionCacheWithBlob
 
   test("Disk cache can recover gracefully from invalid JSON"):
     withDiskCache(testActionCacheInvalidJson)
@@ -262,10 +261,9 @@ object ActionCacheTest extends BasicTestSuite:
   def testActionCacheInvalidJson(cache: DiskActionCacheStore): Unit =
     import sjsonnew.BasicJsonProtocol.*
     var called = 0
-    val action: ((Int, Int)) => InternalActionResult[Int] = { (a, b) =>
+    val action: ((Int, Int)) => InternalActionResult[Int] = (a, b) =>
       called += 1
       InternalActionResult(a + b, Nil)
-    }
     IO.withTemporaryDirectory: tempDir =>
       val config = getCacheConfig(cache, tempDir)
 
@@ -302,10 +300,9 @@ object ActionCacheTest extends BasicTestSuite:
       override def problems(): Array[Problem] = Array(testProblem)
       override def getMessage(): String = "Compilation failed"
 
-    val action: ((Int, Int)) => InternalActionResult[Int] = { (a, b) =>
+    val action: ((Int, Int)) => InternalActionResult[Int] = (a, b) =>
       called += 1
       throw testException
-    }
     IO.withTemporaryDirectory: tempDir =>
       val config = getCacheConfig(cache, tempDir)
 
@@ -333,6 +330,7 @@ object ActionCacheTest extends BasicTestSuite:
       assert(caught2.problems().length == 1)
       assert(caught2.problems()(0).message() == "Test error message")
       assert(caught2.getMessage() == "Compilation failed")
+  end testCachedCompileFailure
 
   test("Disk cache does not cache an environmental (position-less) CompileFailed"):
     withDiskCache(testEnvironmentalCompileFailureNotCached)
@@ -359,10 +357,9 @@ object ActionCacheTest extends BasicTestSuite:
       override def problems(): Array[Problem] = Array(ioProblem)
       override def getMessage(): String = "Compilation failed"
 
-    val action: ((Int, Int)) => InternalActionResult[Int] = { (_, _) =>
+    val action: ((Int, Int)) => InternalActionResult[Int] = (_, _) =>
       called += 1
       throw ioException
-    }
     IO.withTemporaryDirectory: tempDir =>
       val config = getCacheConfig(cache, tempDir)
 
@@ -382,6 +379,7 @@ object ActionCacheTest extends BasicTestSuite:
         called == 2,
         s"environmental failure must not be cached; action should re-run (called=$called)"
       )
+  end testEnvironmentalCompileFailureNotCached
 
   test("A position-less failure cached by an older sbt is not replayed and is cured by a re-run"):
     withDiskCache(testLegacyPoisonedFailureCured)
@@ -407,10 +405,9 @@ object ActionCacheTest extends BasicTestSuite:
       override def problems(): Array[Problem] = Array(ioProblem)
       override def getMessage(): String = "Compilation failed"
 
-    val action: ((Int, Int)) => InternalActionResult[Int] = { (a, b) =>
+    val action: ((Int, Int)) => InternalActionResult[Int] = (a, b) =>
       called += 1
       InternalActionResult(a + b, Nil)
-    }
     IO.withTemporaryDirectory: tempDir =>
       val config = getCacheConfig(cache, tempDir)
 
@@ -435,6 +432,7 @@ object ActionCacheTest extends BasicTestSuite:
       val v2 = ActionCache.cache((1, 1), Digest.zero, Digest.zero, tags, config)(action)
       assert(v2 == 2)
       assert(called == 1, s"expected a success cache hit after the cure (called=$called)")
+  end testLegacyPoisonedFailureCured
 
   test("A file vanishing after its blob is stored no longer breaks the cache write"):
     withDiskCache: cache =>
@@ -454,10 +452,9 @@ object ActionCacheTest extends BasicTestSuite:
           override def contentHashStr: String = maybeThrow(goodHash)
           override def input: java.io.InputStream =
             new ByteArrayInputStream("hello".getBytes(StandardCharsets.UTF_8))
-        val action: ((Int, Int)) => InternalActionResult[Int] = { (a, b) =>
+        val action: ((Int, Int)) => InternalActionResult[Int] = (a, b) =>
           called += 1
           InternalActionResult(a + b, Seq(vanishing))
-        }
         val v1 = ActionCache.cache((1, 1), Digest.zero, Digest.zero, tags, config)(action)
         assert(v1 == 2)
         assert(called == 1)
@@ -476,10 +473,9 @@ object ActionCacheTest extends BasicTestSuite:
           override def sizeBytes: Long = throw new NoSuchFileException(id)
           override def contentHashStr: String = throw new NoSuchFileException(id)
           override def input: java.io.InputStream = throw new NoSuchFileException(id)
-        val action: ((Int, Int)) => InternalActionResult[Int] = { (a, b) =>
+        val action: ((Int, Int)) => InternalActionResult[Int] = (a, b) =>
           called += 1
           InternalActionResult(a + b, Seq(gone))
-        }
         val v1 = ActionCache.cache((1, 1), Digest.zero, Digest.zero, tags, config)(action)
         assert(v1 == 2)
         assert(called == 1)
@@ -519,11 +515,10 @@ object ActionCacheTest extends BasicTestSuite:
         val midnightUTC = java.nio.file.attribute.FileTime.from(
           java.time.Instant.parse("2026-08-01T00:00:00Z")
         )
-        val action: ((Int, Int)) => InternalActionResult[Int] = { (a, b) =>
+        val action: ((Int, Int)) => InternalActionResult[Int] = (a, b) =>
           Files.writeString(outPath, "foo")
           Files.setLastModifiedTime(outPath, midnightUTC)
           InternalActionResult(a + b, Seq(binaryConverter.toVirtualFile(outPath)))
-        }
         val config = getCacheConfig(cache, tempDir, converter = binaryConverter)
         val v1 = ActionCache.cache((1, 1), Digest.zero, Digest.zero, tags, config)(action)
         assert(v1 == 2)
@@ -548,10 +543,9 @@ object ActionCacheTest extends BasicTestSuite:
             unbuilder: sjsonnew.Unbuilder[J]
         ): Unserializable = Unserializable(0)
       import sjsonnew.BasicJsonProtocol.*
-      val action: ((Int, Int)) => InternalActionResult[Unserializable] = { (a, b) =>
+      val action: ((Int, Int)) => InternalActionResult[Unserializable] = (a, b) =>
         called += 1
         InternalActionResult(Unserializable(a + b), Nil)
-      }
       IO.withTemporaryDirectory: tempDir =>
         val config = getCacheConfig(cache, tempDir)
         val v1 = ActionCache.cache((1, 1), Digest.zero, Digest.zero, tags, config)(action)
@@ -567,10 +561,9 @@ object ActionCacheTest extends BasicTestSuite:
   def testSyncBlobsThrowsFallback(underlying: DiskActionCacheStore): Unit =
     import sjsonnew.BasicJsonProtocol.*
     var called = 0
-    val action: ((Int, Int)) => InternalActionResult[Int] = { (a, b) =>
+    val action: ((Int, Int)) => InternalActionResult[Int] = (a, b) =>
       called += 1
       InternalActionResult(a + b, Nil)
-    }
     class ThrowingSyncStore extends AbstractActionCacheStore:
       override def storeName: String = "throwing-sync"
       override def get(request: GetActionResultRequest): Either[Throwable, ActionResult] =
@@ -591,6 +584,7 @@ object ActionCacheTest extends BasicTestSuite:
       val v2 = ActionCache.cache((1, 1), Digest.zero, Digest.zero, tags, config)(action)
       assert(v2 == 2)
       assert(called == 2)
+  end testSyncBlobsThrowsFallback
 
   test(
     "readFromSymlink fast path falls back to recompute when syncBlobs throws FileNotFoundException"
@@ -608,10 +602,9 @@ object ActionCacheTest extends BasicTestSuite:
         StringVirtualFile1(path.toString, content)
     val diskCache = DiskActionCacheStore(cacheDir.toPath, absConverter)
     var called = 0
-    val action: Unit => InternalActionResult[Int] = { _ =>
+    val action: Unit => InternalActionResult[Int] = _ =>
       called += 1
       InternalActionResult(42, Nil)
-    }
     val logger = new Logger:
       override def trace(t: => Throwable): Unit = ()
       override def success(message: => String): Unit = ()
@@ -650,6 +643,7 @@ object ActionCacheTest extends BasicTestSuite:
     val v2 = ActionCache.cache((), Digest.zero, Digest.zero, tags, config2)(action)
     assert(v2 == 42)
     assert(called == 2)
+  end testReadFromSymlinkFallback
 
   test("packageDirectory is safe when many threads package the same directory concurrently"):
     IO.withTemporaryDirectory: tmp =>
@@ -707,7 +701,7 @@ object ActionCacheTest extends BasicTestSuite:
         val classesDir = outDir.toPath.resolve("classes")
         val classFile = classesDir.resolve("pkg/A.class")
         var called = 0
-        val action: Unit => InternalActionResult[Int] = { _ =>
+        val action: Unit => InternalActionResult[Int] = _ =>
           called += 1
           Files.createDirectories(classFile.getParent)
           Files.writeString(classFile, "compiled")
@@ -718,7 +712,6 @@ object ActionCacheTest extends BasicTestSuite:
               outDir.toPath
             )
           InternalActionResult(1, Seq(dirzip))
-        }
         val config = getCacheConfig(cache, outDir, converter = conv)
         val v1 = ActionCache.cache((), Digest.zero, Digest.zero, tags, config)(action)
         assert(v1 == 1)
@@ -752,11 +745,10 @@ object ActionCacheTest extends BasicTestSuite:
               outputDirectory: Path,
           ): Path = throw mkError(ref)
         var called = 0
-        val action: ((Int, Int)) => InternalActionResult[Int] = { (a, b) =>
+        val action: ((Int, Int)) => InternalActionResult[Int] = (a, b) =>
           called += 1
           val out = StringVirtualFile1(s"$outDir/a.txt", (a + b).toString)
           InternalActionResult(a + b, Seq(out))
-        }
         val config = getCacheConfig(broken, outDir)
         val v1 = ActionCache.cache((1, 1), Digest.zero, Digest.zero, tags, config)(action)
         assert(v1 == 2)
@@ -764,6 +756,7 @@ object ActionCacheTest extends BasicTestSuite:
         val v2 = ActionCache.cache((1, 1), Digest.zero, Digest.zero, tags, config)(action)
         assert(v2 == 2)
         assert(called == 2, s"broken restore must degrade to onsite recompute (called=$called)")
+  end testBrokenRestoreDegrades
 
   test("Changing cacheVersion invalidates the cache"):
     withDiskCache(testCacheVersionInvalidation)
@@ -771,10 +764,9 @@ object ActionCacheTest extends BasicTestSuite:
   def testCacheVersionInvalidation(cache: ActionCacheStore): Unit =
     import sjsonnew.BasicJsonProtocol.*
     var called = 0
-    val action: ((Int, Int)) => InternalActionResult[Int] = { (a, b) =>
+    val action: ((Int, Int)) => InternalActionResult[Int] = (a, b) =>
       called += 1
       InternalActionResult(a + b, Nil)
-    }
     IO.withTemporaryDirectory: tempDir =>
       val config0 = getCacheConfig(cache, tempDir)
       // First call: computes the result
@@ -794,6 +786,7 @@ object ActionCacheTest extends BasicTestSuite:
       val v4 = ActionCache.cache((1, 1), Digest.zero, Digest.zero, tags, config1)(action)
       assert(v4 == 2)
       assert(called == 2)
+  end testCacheVersionInvalidation
 
   // Adversarial cache entries: a poisoned shared/remote cache must not escape the output
   // directory (zip-slip / path traversal) or restore blobs whose bytes do not match their
diff --git a/util-cache/src/test/scala/sbt/util/GzipCacheStoreSpec.scala b/util-cache/src/test/scala/sbt/util/GzipCacheStoreSpec.scala
index 59a82e9e3..ab78e8c32 100644
--- a/util-cache/src/test/scala/sbt/util/GzipCacheStoreSpec.scala
+++ b/util-cache/src/test/scala/sbt/util/GzipCacheStoreSpec.scala
@@ -87,3 +87,4 @@ object GzipCacheStoreSpec extends verify.BasicTestSuite:
       val file = new File(dir, "tiny.bin")
       IO.write(file, "{}")
       assert(GzipFileInput.uncompressedSize(file) == 2L)
+end GzipCacheStoreSpec
diff --git a/util-collection/src/main/scala/sbt/internal/util/Attributes.scala b/util-collection/src/main/scala/sbt/internal/util/Attributes.scala
index f3a2a04e0..58029cc5e 100644
--- a/util-collection/src/main/scala/sbt/internal/util/Attributes.scala
+++ b/util-collection/src/main/scala/sbt/internal/util/Attributes.scala
@@ -76,14 +76,13 @@ private[sbt] abstract class SharedAttributeKey[A] extends AttributeKey[A]:
   override final def toString = label
   override final def hashCode = label.hashCode
   override final def equals(o: Any) =
-    (this eq o.asInstanceOf[AnyRef]) || (o match {
+    (this eq o.asInstanceOf[AnyRef]) || (o match
       case a: SharedAttributeKey[t] => a.label == this.label && a.tag == this.tag
-      case _                        => false
-    })
+      case _                        => false)
   final def isLocal: Boolean = false
 end SharedAttributeKey
 
-object AttributeKey {
+object AttributeKey:
   def apply[A: KeyTag: OptJsonWriter](name: String): AttributeKey[A] =
     make(name, None, Nil, Int.MaxValue)
 
@@ -149,7 +148,7 @@ object AttributeKey {
       override val optJsonWriter: OptJsonWriter[A] = summon
 
   private[sbt] final val LocalLabel = "$" + "local"
-}
+end AttributeKey
 
 /**
  * An immutable map where a key is the tuple `(String,T)` for a fixed type `T` and can only be
@@ -254,9 +253,8 @@ type StringAttributeMap = scala.collection.immutable.Map[StringAttributeKey, Str
 
 // type inference required less generality
 /** A map entry where `key` is constrained to only be associated with a fixed value of type `T`. */
-final case class AttributeEntry[T](key: AttributeKey[T], value: T) {
+final case class AttributeEntry[T](key: AttributeKey[T], value: T):
   override def toString = key.label + ": " + value
-}
 
 /** Associates a `metadata` map with `data`. */
 final case class Attributed[A1](data: A1)(val metadata: StringAttributeMap):
diff --git a/util-collection/src/main/scala/sbt/internal/util/Dag.scala b/util-collection/src/main/scala/sbt/internal/util/Dag.scala
index 45524012b..b46d2dd7b 100644
--- a/util-collection/src/main/scala/sbt/internal/util/Dag.scala
+++ b/util-collection/src/main/scala/sbt/internal/util/Dag.scala
@@ -8,13 +8,16 @@
 
 package sbt.internal.util
 
-trait Dag[Node <: Dag[Node]] { self: Node =>
+import scala.collection.mutable
+
+trait Dag[Node <: Dag[Node]]:
+  self: Node =>
 
   def dependencies: Iterable[Node]
   def topologicalSort = Dag.topologicalSort(self)(_.dependencies)
-}
-object Dag {
-  import scala.collection.mutable
+end Dag
+
+object Dag:
   import scala.jdk.CollectionConverters.*
 
   /**
@@ -29,68 +32,58 @@ object Dag {
   def topologicalSort[T](root: T)(dependencies: T => Iterable[T]): List[T] =
     topologicalSort(root :: Nil)(dependencies)
 
-  def topologicalSort[T](nodes: Iterable[T])(dependencies: T => Iterable[T]): List[T] = {
+  def topologicalSort[T](nodes: Iterable[T])(dependencies: T => Iterable[T]): List[T] =
     val discovered = new mutable.HashSet[T]
     val finished = (new java.util.LinkedHashSet[T]).asScala
 
     def visitAll(nodes: Iterable[T]) = nodes foreach visit
-    def visit(node: T): Unit = {
-      if (!discovered(node)) {
+
+    def visit(node: T): Unit =
+      if !discovered(node) then
         discovered(node) = true;
-        try {
-          visitAll(dependencies(node));
-        } catch { case c: Cyclic => throw node :: c }
+        try visitAll(dependencies(node))
+        catch case c: Cyclic => throw node :: c
         finished += node
         ()
-      } else if (!finished(node))
-        throw new Cyclic(node)
-    }
+      else if !finished(node) then throw new Cyclic(node)
 
     visitAll(nodes)
 
     finished.toList
-  }
 
   // doesn't check for cycles
   def topologicalSortUnchecked[T](node: T)(dependencies: T => Iterable[T]): List[T] =
     topologicalSortUnchecked(node :: Nil)(dependencies)
 
-  def topologicalSortUnchecked[T](nodes: Iterable[T])(dependencies: T => Iterable[T]): List[T] = {
+  def topologicalSortUnchecked[T](nodes: Iterable[T])(dependencies: T => Iterable[T]): List[T] =
     val discovered = new mutable.HashSet[T]
     var finished: List[T] = Nil
 
     def visitAll(nodes: Iterable[T]) = nodes foreach visit
-    def visit(node: T): Unit = {
-      if (!discovered(node)) {
+    def visit(node: T): Unit =
+      if !discovered(node) then
         discovered(node) = true
         visitAll(dependencies(node))
         finished ::= node
-      }
-    }
 
     visitAll(nodes);
     finished;
-  }
 
   final class Cyclic(val value: Any, val all: List[Any], val complete: Boolean)
       extends Exception(
         "Cyclic reference involving " +
-          (if (complete) all.mkString("\n   ", "\n   ", "") else value)
-      ) {
+          (if complete then all.mkString("\n   ", "\n   ", "") else value)
+      ):
     def this(value: Any) = this(value, value :: Nil, false)
     override def toString = getMessage
 
     def ::(a: Any): Cyclic =
-      if (complete)
-        this
-      else if (a == value)
-        new Cyclic(value, all, true)
-      else
-        new Cyclic(value, a :: all, false)
-  }
+      if complete then this
+      else if a == value then new Cyclic(value, all, true)
+      else new Cyclic(value, a :: all, false)
 
   /** A directed graph with edges labeled positive or negative. */
-  private[sbt] trait DirectedSignedGraph[Node] {
+  private[sbt] trait DirectedSignedGraph[Node]:
 
     /**
      * Directed edge type that tracks the sign and target (head) vertex. The sign can be obtained
@@ -110,42 +103,35 @@ object Dag {
     /** The target of the directed edge `a`. */
     def head(a: Arrow): Node
 
-  }
-
   /**
    * Traverses a directed graph defined by `graph` looking for a cycle that includes a "negative"
    * edge. The directed edges are weighted by the caller as "positive" or "negative". If a cycle
    * containing a "negative" edge is detected, its member edges are returned in order. Otherwise,
    * the empty list is returned.
    */
-  private[sbt] def findNegativeCycle[Node](graph: DirectedSignedGraph[Node]): List[graph.Arrow] = {
+  private[sbt] def findNegativeCycle[Node](graph: DirectedSignedGraph[Node]): List[graph.Arrow] =
     import graph.*
     val finished = new mutable.HashSet[Node]
     val visited = new mutable.HashSet[Node]
 
-    def visit(edges: List[Arrow], stack: List[Arrow]): List[Arrow] = edges match {
+    def visit(edges: List[Arrow], stack: List[Arrow]): List[Arrow] = edges match
       case Nil          => Nil
       case edge :: tail =>
         val node = head(edge)
-        if (!visited(node)) {
+        if !visited(node) then
           visited += node
-          visit(dependencies(node), edge :: stack) match {
+          visit(dependencies(node), edge :: stack) match
             case Nil =>
               finished += node
               visit(tail, stack)
             case cycle => cycle
-          }
-        } else if (!finished(node)) {
+        else if !finished(node) then
           // cycle. If a negative edge is involved, it is an error.
           val between = edge :: stack.takeWhile(f => head(f) != node)
-          if (between exists isNegative)
-            between
-          else
-            visit(tail, stack)
-        } else visit(tail, stack)
-    }
+          if between exists isNegative then between
+          else visit(tail, stack)
+        else visit(tail, stack)
 
     visit(graph.nodes, Nil)
-  }
-
-}
+  end findNegativeCycle
+end Dag
diff --git a/util-collection/src/main/scala/sbt/internal/util/IDSet.scala b/util-collection/src/main/scala/sbt/internal/util/IDSet.scala
index 663ded067..2b1e1384c 100644
--- a/util-collection/src/main/scala/sbt/internal/util/IDSet.scala
+++ b/util-collection/src/main/scala/sbt/internal/util/IDSet.scala
@@ -11,7 +11,7 @@ package sbt.internal.util
 import scala.jdk.CollectionConverters.*
 
 /** A mutable set interface that uses object identity to test for set membership. */
-trait IDSet[T] {
+trait IDSet[T]:
   def apply(t: T): Boolean
   def contains(t: T): Boolean
   def +=(t: T): Unit
@@ -22,40 +22,37 @@ trait IDSet[T] {
   def isEmpty: Boolean
   def foreach(f: T => Unit): Unit
   def process[S](t: T)(ifSeen: S)(ifNew: => S): S
-}
 
-object IDSet {
+object IDSet:
   implicit def toTraversable[T]: IDSet[T] => Iterable[T] = _.all
   def apply[T](values: T*): IDSet[T] = fromIterable(values)
 
   def apply[T](values: Iterable[T]): IDSet[T] = fromIterable(values)
 
-  private def fromIterable[T](values: Iterable[T]): IDSet[T] = {
+  private def fromIterable[T](values: Iterable[T]): IDSet[T] =
     val s = create[T]
     s ++= values
     s
-  }
 
-  def create[T]: IDSet[T] = new IDSet[T] {
+  def create[T]: IDSet[T] = new IDSet[T]:
     private val backing = new java.util.IdentityHashMap[T, AnyRef]
     private val Dummy: AnyRef = ""
 
     def apply(t: T) = contains(t)
     def contains(t: T) = backing.containsKey(t)
     def foreach(f: T => Unit) = all foreach f
-    def +=(t: T) = { backing.put(t, Dummy); () }
+    def +=(t: T) =
+      backing.put(t, Dummy); ()
     def ++=(t: Iterable[T]) = t foreach +=
-    def -=(t: T) = if (backing.remove(t) eq null) false else true
+    def -=(t: T) = if backing.remove(t) eq null then false else true
     def all = backing.keySet.asScala
     def toList = all.toList
     def isEmpty = backing.isEmpty
 
     def process[S](t: T)(ifSeen: S)(ifNew: => S) =
-      if (contains(t)) ifSeen
-      else {
+      if contains(t) then ifSeen
+      else
         this += t; ifNew
-      }
 
     override def toString = backing.toString
-  }
-}
+end IDSet
diff --git a/util-collection/src/main/scala/sbt/internal/util/INode.scala b/util-collection/src/main/scala/sbt/internal/util/INode.scala
index a56e772e6..5d9544bf5 100644
--- a/util-collection/src/main/scala/sbt/internal/util/INode.scala
+++ b/util-collection/src/main/scala/sbt/internal/util/INode.scala
@@ -65,7 +65,7 @@ class EvaluateSettings[I <: Init](
   private val running = new AtomicInteger
   private val cancel = new AtomicBoolean(false)
 
-  def run(using delegates: ScopeType => Seq[ScopeType]): Settings = {
+  def run(using delegates: ScopeType => Seq[ScopeType]): Settings =
     assert(running.get() == 0, "Already running")
     startWork()
     roots.foreach(_.registerIfNew())
@@ -75,7 +75,6 @@ class EvaluateSettings[I <: Init](
       throw ex
     }
     getResults(using delegates)
-  }
 
   private def getResults(using ScopeType => Seq[ScopeType]) =
     static.toTypedSeq.foldLeft(empty) { case (ss, static.TPair(key, node)) =>
@@ -95,12 +94,12 @@ class EvaluateSettings[I <: Init](
     executor.execute(() => if !cancel.get() then run0(work))
 
   private def run0(work: => Unit): Unit =
-    try {
-      work
-    } catch { case e: Throwable => complete.put(Some(e)) }
+    try work
+    catch case e: Throwable => complete.put(Some(e))
     workComplete()
 
-  private def startWork(): Unit = { running.incrementAndGet(); () }
+  private def startWork(): Unit =
+    running.incrementAndGet(); ()
 
   private def workComplete(): Unit =
     if running.decrementAndGet() == 0 then complete.put(None)
@@ -119,7 +118,7 @@ class EvaluateSettings[I <: Init](
     private def keyString =
       static.toSeq
         .flatMap { (key, value) =>
-          if (value eq this) init.showFullKey.show(key) :: Nil else Nil
+          if value eq this then init.showFullKey.show(key) :: Nil else Nil
         }
         .headOption
         .getOrElse("non-static")
@@ -131,10 +130,9 @@ class EvaluateSettings[I <: Init](
 
     final def doneOrBlock(from: INode[?]): Boolean = synchronized {
       val ready = state == Evaluated
-      if (!ready) {
+      if !ready then
         blocking += from
         ()
-      }
       registerIfNew()
       ready
     }
@@ -142,15 +140,14 @@ class EvaluateSettings[I <: Init](
     final def isDone: Boolean = synchronized { state == Evaluated }
     final def isNew: Boolean = synchronized { state == New }
     final def isCalling: Boolean = synchronized { state == Calling }
-    final def registerIfNew(): Unit = synchronized { if (state == New) register() }
+    final def registerIfNew(): Unit = synchronized { if state == New then register() }
 
-    private def register(): Unit = {
+    private def register(): Unit =
       assert(state == New, "Already registered and: " + toString)
       val deps = dependsOn
       blockedOn = deps.size - deps.count(_.doneOrBlock(this))
       if blockedOn == 0 then schedule()
       else state = Blocked
-    }
 
     final def schedule(): Unit = synchronized {
       assert(state == New || state == Blocked, "Invalid state for schedule() call: " + toString)
@@ -162,23 +159,22 @@ class EvaluateSettings[I <: Init](
       assert(state == Blocked, "Invalid state for unblocked() call: " + toString)
       blockedOn -= 1
       assert(blockedOn >= 0, "Negative blockedOn: " + blockedOn + " for " + toString)
-      if (blockedOn == 0) schedule()
+      if blockedOn == 0 then schedule()
     }
 
     final def evaluate(): Unit = synchronized { evaluate0() }
 
-    protected final def makeCall(source: BindNode[?, A1], target: INode[A1]): Unit = {
+    protected final def makeCall(source: BindNode[?, A1], target: INode[A1]): Unit =
       assert(state == Ready, "Invalid state for call to makeCall: " + toString)
       state = Calling
       target.call(source)
-    }
 
-    protected final def setValue(v: A1): Unit = {
+    protected final def setValue(v: A1): Unit =
       assert(
         state != Evaluated,
         "Already evaluated (trying to set value to " + v + "): " + toString
       )
-      if (v == null) sys.error("Setting value cannot be null: " + keyString)
+      if v == null then sys.error("Setting value cannot be null: " + keyString)
       value = v
       state = Evaluated
       blocking foreach { _.unblocked() }
@@ -187,16 +183,14 @@ class EvaluateSettings[I <: Init](
         submitCallComplete(node, value)
       }
       calledBy.clear()
-    }
 
     final def call(by: BindNode[?, A1]): Unit = synchronized {
       registerIfNew()
-      state match {
+      state match
         case Evaluated => submitCallComplete(by, value)
         case _         =>
           calledBy += by
           ()
-      }
     }
 
     protected def dependsOn: Seq[INode[?]]
diff --git a/util-collection/src/main/scala/sbt/internal/util/PMap.scala b/util-collection/src/main/scala/sbt/internal/util/PMap.scala
index 7622dec7f..1cd657ce0 100644
--- a/util-collection/src/main/scala/sbt/internal/util/PMap.scala
+++ b/util-collection/src/main/scala/sbt/internal/util/PMap.scala
@@ -9,7 +9,7 @@ package sbt.internal.util
 
 import collection.mutable
 
-trait RMap[K[_], V[_]] {
+trait RMap[K[_], V[_]]:
   def apply[T](k: K[T]): V[T]
   def get[T](k: K[T]): Option[V[T]]
   def contains[T](k: K[T]): Boolean
@@ -24,23 +24,20 @@ trait RMap[K[_], V[_]] {
   def isEmpty: Boolean
 
   sealed case class TPair[T](key: K[T], value: V[T])
-}
 
-trait IMap[K[_], V[_]] extends RMap[K, V] {
+trait IMap[K[_], V[_]] extends RMap[K, V]:
   def put[T](k: K[T], v: V[T]): IMap[K, V]
   def remove[T](k: K[T]): IMap[K, V]
   def mapValue[T](k: K[T], init: V[T], f: V[T] => V[T]): IMap[K, V]
   def mapValues[V2[_]](f: [A] => V[A] => V2[A]): IMap[K, V2]
-}
 
-trait PMap[K[_], V[_]] extends RMap[K, V] {
+trait PMap[K[_], V[_]] extends RMap[K, V]:
   def update[T](k: K[T], v: V[T]): Unit
   def remove[T](k: K[T]): Option[V[T]]
   def getOrUpdate[T](k: K[T], make: => V[T]): V[T]
   def mapValue[T](k: K[T], init: V[T], f: V[T] => V[T]): V[T]
-}
 
-object PMap {
+object PMap:
   // implicit def toFunction[K[_], V[_]](map: PMap[K, V]): [A] => K[A] => V[A] =
   //   [A] => (k: K[A]) => map.apply[A](k)
 
@@ -49,9 +46,8 @@ object PMap {
       def apply(map: PMap[K, V]): [A] => K[A] => V[A] =
         [A] => (k: K[A]) => map.apply[A](k)
   def empty[K[_], V[_]]: PMap[K, V] = new DelegatingPMap[K, V](new mutable.HashMap)
-}
 
-object IMap {
+object IMap:
 
   /**
    * Only suitable for K that is invariant in its type parameter. Option and List keys are not
@@ -64,7 +60,7 @@ object IMap {
 
   private[sbt] class IMap0[K[_], V[_]](val backing: Map[K[Any], V[Any]])
       extends AbstractRMap[K, V]
-      with IMap[K, V] {
+      with IMap[K, V]:
     def get[T](k: K[T]): Option[V[T]] =
       (backing get k.asInstanceOf).asInstanceOf[Option[V[T]]]
     def put[T](k: K[T], v: V[T]) =
@@ -85,13 +81,12 @@ object IMap {
     def isEmpty = backing.isEmpty
 
     override def toString = backing.toString
-  }
-}
+  end IMap0
+end IMap
 
-abstract class AbstractRMap[K[_], V[_]] extends RMap[K, V] {
+abstract class AbstractRMap[K[_], V[_]] extends RMap[K, V]:
   def apply[T](k: K[T]): V[T] = get(k).get
   def contains[T](k: K[T]): Boolean = get(k).isDefined
-}
 
 /**
  * Only suitable for K that is invariant in its type parameter. Option and List keys are not
@@ -99,18 +94,17 @@ abstract class AbstractRMap[K[_], V[_]] extends RMap[K, V] {
  */
 class DelegatingPMap[K[_], V[_]](backing: mutable.Map[K[Any], V[Any]])
     extends AbstractRMap[K, V]
-    with PMap[K, V] {
+    with PMap[K, V]:
   def get[T](k: K[T]): Option[V[T]] = cast[T](backing.get(k.asInstanceOf))
-  def update[T](k: K[T], v: V[T]): Unit = { backing(k.asInstanceOf) = v.asInstanceOf }
+  def update[T](k: K[T], v: V[T]): Unit = backing(k.asInstanceOf) = v.asInstanceOf
   def remove[T](k: K[T]) = cast(backing.remove(k.asInstanceOf))
   def getOrUpdate[T](k: K[T], make: => V[T]) =
     cast[T](backing.getOrElseUpdate(k.asInstanceOf, make.asInstanceOf))
 
-  def mapValue[T](k: K[T], init: V[T], f: V[T] => V[T]): V[T] = {
+  def mapValue[T](k: K[T], init: V[T], f: V[T] => V[T]): V[T] =
     val v = f(this.get(k).getOrElse(init))
     update(k, v)
     v
-  }
 
   def toSeq: Seq[(K[Any], V[Any])] = backing.toSeq
   def keys: Iterable[K[Any]] = backing.keys
@@ -121,4 +115,4 @@ class DelegatingPMap[K[_], V[_]](backing: mutable.Map[K[Any], V[Any]])
   private def cast[A](o: Option[V[Any]]): Option[V[A]] = o map cast[A]
 
   override def toString = backing.toString
-}
+end DelegatingPMap
diff --git a/util-collection/src/main/scala/sbt/internal/util/Par.scala b/util-collection/src/main/scala/sbt/internal/util/Par.scala
index 934c627ce..72963fa37 100644
--- a/util-collection/src/main/scala/sbt/internal/util/Par.scala
+++ b/util-collection/src/main/scala/sbt/internal/util/Par.scala
@@ -10,6 +10,5 @@ package sbt.internal.util
 import scala.collection.parallel.CollectionConverters.*
 import scala.collection.parallel.ParSeq
 
-private[util] object Par {
+private[util] object Par:
   def apply[R](s: Seq[R]): ParSeq[R] = s.par
-}
diff --git a/util-collection/src/main/scala/sbt/internal/util/Settings.scala b/util-collection/src/main/scala/sbt/internal/util/Settings.scala
index 3205b157c..0f4bda2f0 100644
--- a/util-collection/src/main/scala/sbt/internal/util/Settings.scala
+++ b/util-collection/src/main/scala/sbt/internal/util/Settings.scala
@@ -92,9 +92,8 @@ trait Init:
       d(key.scope).iterator.map(s => key.copy(scope = s))
   end Settings0
 
-  private[sbt] abstract class ValidateKeyRef {
+  private[sbt] abstract class ValidateKeyRef:
     def apply[T](key: ScopedKey[T], selfRefOk: Boolean): ValidatedRef[T]
-  }
 
   /**
    * The result of this initialization is the composition of applied transformations.
@@ -161,10 +160,9 @@ trait Init:
     if default then d.default()
     else d
 
-  def deriveAllowed[T](s: Setting[T], allowDynamic: Boolean): Option[String] = s.init match {
+  def deriveAllowed[T](s: Setting[T], allowDynamic: Boolean): Option[String] = s.init match
     case _: Bind[?, ?] if !allowDynamic => Some("Cannot derive from dynamic dependencies.")
     case _                              => None
-  }
 
   // id is used for equality
   private[sbt] final def defaultSetting[T](s: Setting[T]): Setting[T] = s.default()
@@ -189,7 +187,7 @@ trait Init:
   def mapScope(f: ScopeType => ScopeType): MapScoped =
     [a] => (k: ScopedKey[a]) => k.copy(scope = f(k.scope))
 
-  private def applyDefaults(ss: Seq[Setting[?]]): Seq[Setting[?]] = {
+  private def applyDefaults(ss: Seq[Setting[?]]): Seq[Setting[?]] =
     val result = new java.util.LinkedHashSet[Setting[?]]
     val others = new java.util.ArrayList[Setting[?]]
     ss.foreach {
@@ -198,13 +196,12 @@ trait Init:
     }
     result.addAll(others)
     result.asScala.toVector
-  }
 
   def compiled(init: Seq[Setting[?]], actual: Boolean = true)(using
       delegates: ScopeType => Seq[ScopeType],
       scopeLocal: ScopeLocal,
       display: Show[ScopedKey[?]]
-  ): CompiledMap = {
+  ): CompiledMap =
     val initDefaults = applyDefaults(init)
     // inject derived settings into scopes where their dependencies are directly defined
     // and prepend per-scope settings
@@ -213,10 +210,9 @@ trait Init:
     val sMap: ScopedMap = grouped(derived)
     // delegate references to undefined values according to 'delegates'
     val dMap: ScopedMap =
-      if (actual) delegate(sMap)(using delegates, display) else sMap
+      if actual then delegate(sMap)(using delegates, display) else sMap
     // merge Seq[Setting[_]] into Compiled
     compile(dMap)
-  }
 
   def makeWithCompiledMap(init: Seq[Setting[?]])(using
       delegates: ScopeType => Seq[ScopeType],
@@ -227,12 +223,10 @@ trait Init:
     // order the initializations.  cyclic references are detected here.
     val ordered: Seq[Compiled[?]] = sort(cMap)
     // evaluation: apply the initializations.
-    try {
-      (cMap, applyInits(ordered))
-    } catch {
+    try (cMap, applyInits(ordered))
+    catch
       case rru: RuntimeUndefined =>
         throw Uninitialized(cMap.keys.toSeq, delegates, rru.undefined, true)
-    }
 
   def sort(cMap: CompiledMap): Seq[Compiled[?]] =
     Dag.topologicalSort(cMap.values)(_.dependencies.map(cMap))
@@ -257,10 +251,9 @@ trait Init:
   def grouped(init: Seq[Setting[?]]): ScopedMap =
     val result = new java.util.HashMap[ScopedKey[?], Seq[Setting[?]]]
     init.foreach { s =>
-      result.putIfAbsent(s.key, Vector(s)) match {
+      result.putIfAbsent(s.key, Vector(s)) match
         case null =>
-        case ss   => result.put(s.key, if (s.definitive) Vector(s) else ss :+ s)
-      }
+        case ss   => result.put(s.key, if s.definitive then Vector(s) else ss :+ s)
     }
     IMap.fromJMap[ScopedKey, SettingSeq](
       result.asInstanceOf[java.util.Map[ScopedKey[Any], SettingSeq[Any]]]
@@ -279,11 +272,10 @@ trait Init:
   def delegate(sMap: ScopedMap)(using
       delegates: ScopeType => Seq[ScopeType],
       display: Show[ScopedKey[?]]
-  ): ScopedMap = {
-    def refMap(ref: Setting[?], isFirst: Boolean) = new ValidateKeyRef {
+  ): ScopedMap =
+    def refMap(ref: Setting[?], isFirst: Boolean) = new ValidateKeyRef:
       def apply[T](k: ScopedKey[T], selfRefOk: Boolean) =
         delegateForKey(sMap, k, delegates(k.scope), ref, selfRefOk || !isFirst)
-    }
 
     val undefined = new java.util.ArrayList[Undefined]
     val result = new java.util.concurrent.ConcurrentHashMap[ScopedKey[?], Any]
@@ -291,19 +283,16 @@ trait Init:
     Par(backing).foreach { (key, settings) =>
       val valid = new java.util.ArrayList[Setting[?]]
       val undefs = new java.util.ArrayList[Undefined]
-      def validate(s: Setting[?], first: Boolean): Unit = {
-        s.validateKeyReferenced(refMap(s, first)) match {
+      def validate(s: Setting[?], first: Boolean): Unit =
+        s.validateKeyReferenced(refMap(s, first)) match
           case Right(v) => valid.add(v); ()
           case Left(us) => us.foreach(u => undefs.add(u))
-        }
-      }
-      settings.headOption match {
+      settings.headOption match
         case Some(s) =>
           validate(s, true)
           settings.tail.foreach(validate(_, false))
         case _ =>
-      }
-      if (undefs.isEmpty) result.put(key, valid.asScala.toVector)
+      if undefs.isEmpty then result.put(key, valid.asScala.toVector)
       else undefined.addAll(undefs)
     }
 
@@ -312,7 +301,7 @@ trait Init:
         result.asInstanceOf[java.util.Map[ScopedKey[Any], SettingSeq[Any]]]
       )
     else throw Uninitialized(sMap.keys.toSeq, delegates, undefined.asScala.toList, false)
-  }
+  end delegate
 
   private def delegateForKey[A1](
       sMap: ScopedMap,
@@ -330,12 +319,10 @@ trait Init:
   ): Settings =
     val x =
       java.util.concurrent.Executors.newFixedThreadPool(Runtime.getRuntime.availableProcessors)
-    try {
+    try
       val eval: EvaluateSettings[Init.this.type] = new EvaluateSettings(Init.this, x, ordered)
       eval.run(using delegates)
-    } finally {
-      x.shutdown()
-    }
+    finally x.shutdown()
 
   def showUndefined(
       u: Undefined,
@@ -358,9 +345,12 @@ trait Init:
     display.show(
       u.referencedKey
     ) + " from " + refString + sourceString + derivedString + guessedString
+  end showUndefined
 
   private def parenPosString(s: Setting[?]): String =
-    s.positionString match { case None => ""; case Some(s) => " (" + s + ")" }
+    s.positionString match
+      case None    => "";
+      case Some(s) => " (" + s + ")"
 
   def guessIntendedScope(
       validKeys: Seq[ScopedKey[?]],
@@ -378,11 +368,10 @@ trait Init:
       b: ScopedKey[?]
   ): Option[Int] =
     if a.key != b.key || a == b then None
-    else {
+    else
       val dist = delegates(a.scope).indexOf(b.scope)
       if dist < 0 then None
       else Some(dist)
-    }
 
   final class Uninitialized(val undefined: Seq[Undefined], override val toString: String)
       extends Exception(toString)
@@ -392,17 +381,16 @@ trait Init:
       delegates: ScopeType => Seq[ScopeType],
       keys: Seq[Undefined],
       runtime: Boolean
-  )(using display: Show[ScopedKey[?]]): Uninitialized = {
+  )(using display: Show[ScopedKey[?]]): Uninitialized =
     assert(keys.nonEmpty)
-    val suffix = if (keys.length > 1) "s" else ""
-    val prefix = if (runtime) "Runtime reference" else "Reference"
+    val suffix = if keys.length > 1 then "s" else ""
+    val prefix = if runtime then "Runtime reference" else "Reference"
     val keysString =
       keys.map(u => showUndefined(u, validKeys, delegates)).mkString("\n\n  ", "\n\n  ", "")
     new Uninitialized(
       keys,
       prefix + suffix + " to undefined setting" + suffix + ": " + keysString + "\n "
     )
-  }
 
   final class Compiled[A1](
       val key: ScopedKey[A1],
@@ -414,7 +402,7 @@ trait Init:
 
   final class Flattened(val key: ScopedKey[?], val dependencies: Iterable[ScopedKey[?]])
 
-  def flattenLocals(compiled: CompiledMap): Map[ScopedKey[?], Flattened] = {
+  def flattenLocals(compiled: CompiledMap): Map[ScopedKey[?], Flattened] =
     val locals = compiled.collect { case (key, comp) if key.key.isLocal => comp }
     val ordered = Dag.topologicalSort(locals)(
       _.dependencies.collect { case dep if dep.key.isLocal => compiled(dep) }
@@ -426,7 +414,7 @@ trait Init:
     ): Flattened =
       new Flattened(
         key,
-        deps.flatMap(dep => if (dep.key.isLocal) cmap(dep).dependencies else Seq(dep))
+        deps.flatMap(dep => if dep.key.isLocal then cmap(dep).dependencies else Seq(dep))
       )
 
     val empty = Map.empty[ScopedKey[?], Flattened]
@@ -439,18 +427,16 @@ trait Init:
       case (key, comp) if !key.key.isLocal =>
         (key, flatten(flattenedLocals, key, comp.dependencies))
     }
-  }
+  end flattenLocals
 
-  def definedAtString(settings: Seq[Setting[?]]): String = {
+  def definedAtString(settings: Seq[Setting[?]]): String =
     val posDefined = settings.flatMap(_.positionString.toList)
-    if (posDefined.nonEmpty) {
+    if posDefined.nonEmpty then
       val header =
-        if (posDefined.size == settings.size) "defined at:"
-        else
-          "some of the defining occurrences:"
+        if posDefined.size == settings.size then "defined at:"
+        else "some of the defining occurrences:"
       header + (posDefined.distinct.mkString("\n\t", "\n\t", "\n"))
-    } else ""
-  }
+    else ""
 
   /**
    *  The intersect method was calling Seq.contains which is very slow compared
@@ -467,22 +453,19 @@ trait Init:
     def exists(f: ScopeType => Boolean): Boolean
   end Delegates
 
-  private def mkDelegates(delegates: ScopeType => Seq[ScopeType]): ScopeType => Delegates = {
+  private def mkDelegates(delegates: ScopeType => Seq[ScopeType]): ScopeType => Delegates =
     val delegateMap = new java.util.concurrent.ConcurrentHashMap[ScopeType, Delegates]
     s =>
-      delegateMap.get(s) match {
+      delegateMap.get(s) match
         case null =>
           val seq = delegates(s)
           val set = seq.toSet
-          val d = new Delegates {
+          val d = new Delegates:
             override def contains(s: ScopeType): Boolean = set.contains(s)
             override def exists(f: ScopeType => Boolean): Boolean = seq.exists(f)
-          }
           delegateMap.put(s, d)
           d
         case d => d
-      }
-  }
 
   /**
    * Intersects two scopes, returning the more specific one if they intersect, or None otherwise.
@@ -499,28 +482,26 @@ trait Init:
       s2: ScopeType,
       delegates: ScopeType => Delegates
   ): Option[ScopeType] =
-    if (delegates(s1).contains(s2)) Some(s1) // s1 is more specific
-    else if (delegates(s2).contains(s1)) Some(s2) // s2 is more specific
+    if delegates(s1).contains(s2) then Some(s1) // s1 is more specific
+    else if delegates(s2).contains(s1) then Some(s2) // s2 is more specific
     else None
 
   private def deriveAndLocal(init: Seq[Setting[?]], delegates: ScopeType => Delegates)(using
       scopeLocal: ScopeLocal
-  ): Seq[Setting[?]] = {
+  ): Seq[Setting[?]] =
     import collection.mutable
 
-    final class Derived(val setting: DerivedSetting[?]) {
+    final class Derived(val setting: DerivedSetting[?]):
       val dependencies = setting.dependencies.map(_.key)
       def triggeredBy = dependencies.filter(setting.trigger)
       val inScopes = new mutable.HashSet[ScopeType]
       val outputs = new mutable.ListBuffer[Setting[?]]
-    }
 
-    final class Deriveds(val key: AttributeKey[?], val settings: mutable.ListBuffer[Derived]) {
+    final class Deriveds(val key: AttributeKey[?], val settings: mutable.ListBuffer[Derived]):
       def dependencies = settings.flatMap(_.dependencies)
       // This is mainly for use in the cyclic reference error message
       override def toString =
         s"Derived settings for ${key.label}, ${definedAtString(settings.map(_.setting).toSeq)}"
-    }
 
     // separate `derived` settings from normal settings (`defs`)
     val (derived, rawDefs) =
@@ -531,14 +512,13 @@ trait Init:
 
     // group derived settings by the key they define
     val derivedsByDef = new mutable.HashMap[AttributeKey[?], Deriveds]
-    for (s <- derived) {
+    for s <- derived do
       val key = s.setting.key.key
       derivedsByDef.getOrElseUpdate(key, new Deriveds(key, new mutable.ListBuffer)).settings += s
-    }
 
     // index derived settings by triggering key.  This maps a key to the list of settings potentially derived from it.
     val derivedBy = new mutable.HashMap[AttributeKey[?], mutable.ListBuffer[Derived]]
-    for (s <- derived; d <- s.triggeredBy)
+    for s <- derived; d <- s.triggeredBy do
       derivedBy.getOrElseUpdate(d, new mutable.ListBuffer) += s
 
     // Map a DerivedSetting[_] to the `Derived` struct wrapping it. Used to ultimately replace a DerivedSetting with
@@ -549,7 +529,7 @@ trait Init:
 
     // set of defined scoped keys, used to ensure a derived setting is only added if all dependencies are present
     val defined = new mutable.HashSet[ScopedKey[?]]
-    def addDefs(ss: Seq[Setting[?]]): Unit = { for (s <- ss) defined += s.key }
+    def addDefs(ss: Seq[Setting[?]]): Unit = for s <- ss do defined += s.key
     addDefs(defs)
 
     // true iff the scoped key is in `defined`, taking delegation into account
@@ -570,38 +550,35 @@ trait Init:
     //   2. it applies to outputScope (as determined by its `filter`)
     //   3. all of its dependencies are defined for outputScope (allowing for delegation)
     // This needs to handle local settings because a derived setting wouldn't be injected if it's local setting didn't exist yet.
-    val deriveFor = (sk: ScopedKey[?]) => {
+    val deriveFor = (sk: ScopedKey[?]) =>
       val derivedForKey: List[Derived] = derivedBy.get(sk.key).toList.flatten
       val scope = sk.scope
-      def localAndDerived(d: Derived): Seq[Setting[?]] = {
+      def localAndDerived(d: Derived): Seq[Setting[?]] =
         def definingScope = d.setting.key.scope
         val outputScope = intersectDelegates(scope, definingScope, delegates)
         outputScope collect {
           case s if !d.inScopes.contains(s) && d.setting.filter(s) =>
             val local = d.dependencies.flatMap(dep => scopeLocal(ScopedKey(s, dep)))
-            if (allDepsDefined(d, s, local.map(_.key.key).toSet)) {
+            if allDepsDefined(d, s, local.map(_.key.key).toSet) then
               d.inScopes.add(s)
               val out = local :+ d.setting.setScope(s)
               d.outputs ++= out
               out
-            } else nilSeq
+            else nilSeq
         } getOrElse nilSeq
-      }
       derivedForKey.flatMap(localAndDerived)
-    }
 
     val processed = new mutable.HashSet[ScopedKey[?]]
 
     // derives settings, transitively so that a derived setting can trigger another
     @tailrec
-    def process(rem: List[Setting[?]]): Unit = rem match {
+    def process(rem: List[Setting[?]]): Unit = rem match
       case s :: ss =>
         val sk = s.key
-        val ds = if (processed.add(sk)) deriveFor(sk) else nil
+        val ds = if processed.add(sk) then deriveFor(sk) else nil
         addDefs(ds)
         process(ds ::: ss)
       case Nil =>
-    }
     process(defs.toList)
 
     // Take all the original defs and DerivedSettings along with locals, replace each DerivedSetting with the actual
@@ -611,7 +588,7 @@ trait Init:
       case d: DerivedSetting[?] => (derivedToStruct get d map (_.outputs)).toSeq.flatten
       case s                    => s :: nil
     }
-  }
+  end deriveAndLocal
 
   extension (f: [x] => Initialize[x] => Initialize[x])
     def ∙(g: [x] => Initialize[x] => Initialize[x]): [x] => Initialize[x] => Initialize[x] =
@@ -640,9 +617,8 @@ trait Init:
     private[sbt] def mapConstant(g: MapConstant): Initialize[A1]
 
     private[sbt] def validateReferenced(g: ValidateRef): ValidatedInit[A1] =
-      validateKeyReferenced(new ValidateKeyRef {
-        def apply[A2](key: ScopedKey[A2], selfRefOk: Boolean) = g(key)
-      })
+      validateKeyReferenced(new ValidateKeyRef:
+        def apply[A2](key: ScopedKey[A2], selfRefOk: Boolean) = g(key))
 
     private[sbt] def validateKeyReferenced(g: ValidateKeyRef): ValidatedInit[A1]
 
@@ -746,7 +722,8 @@ trait Init:
     protected[sbt] override def isDerived: Boolean = true
 
     override def default(_id: => Long): DefaultSetting[A1] =
-      new DerivedSetting[A1](sk, i, p, filter, trigger) with DefaultSetting[A1] { val id = _id }
+      new DerivedSetting[A1](sk, i, p, filter, trigger) with DefaultSetting[A1]:
+        val id = _id
 
     override def toString = "derived " + super.toString
   end DerivedSetting
@@ -926,7 +903,7 @@ trait Init:
     // proper solution is for evaluate to be deprecated or for external use only and a new internal method returning Either be used
     private def trapBadRef[A](run: => A): Option[A] =
       try Some(run)
-      catch { case _: InvalidReference => None }
+      catch case _: InvalidReference => None
 
     private[sbt] override def processAttributes[B](init: B)(f: (B, AttributeMap) => B): B = a match
       case None    => init
diff --git a/util-collection/src/main/scala/sbt/internal/util/Signal.scala b/util-collection/src/main/scala/sbt/internal/util/Signal.scala
index 864740703..014a58843 100644
--- a/util-collection/src/main/scala/sbt/internal/util/Signal.scala
+++ b/util-collection/src/main/scala/sbt/internal/util/Signal.scala
@@ -10,27 +10,24 @@ package sbt.internal.util
 
 import sun.misc.{ Signal, SignalHandler }
 
-object Signals {
+object Signals:
   val CONT = "CONT"
   val INT = "INT"
 
-  def withHandler[T](handler: () => Unit, signal: String = INT)(action: () => T): T = {
+  def withHandler[T](handler: () => Unit, signal: String = INT)(action: () => T): T =
     val result =
-      try {
+      try
         val signals = new Signals0
         signals.withHandler(signal, handler, action)
-      } catch { case _: LinkageError => Right(action()): Either[Throwable, T] }
+      catch case _: LinkageError => Right(action()): Either[Throwable, T]
 
-    result match {
+    result match
       case Left(e)  => throw e
       case Right(v) => v
-    }
-  }
 
   /** Helper interface so we can expose internals of signal-isms to others. */
-  sealed trait Registration {
+  sealed trait Registration:
     def remove(): Unit
-  }
 
   /**
    * Register a signal handler that can be removed later. NOTE: Does not stack with other signal
@@ -38,62 +35,53 @@ object Signals {
    */
   def register(handler: () => Unit, signal: String = INT): Registration =
     // TODO - Maybe we can just ignore things if not is-supported.
-    if (supported(signal)) {
+    if supported(signal) then
       val intSignal = new Signal(signal)
-      val newHandler = new SignalHandler {
-        def handle(sig: Signal): Unit = { handler() }
-      }
+      val newHandler = new SignalHandler:
+        def handle(sig: Signal): Unit = handler()
       val oldHandler = Signal.handle(intSignal, newHandler)
       new UnregisterNewHandler(intSignal, oldHandler)
-    } else {
+    else
       // TODO - Maybe we should just throw an exception if we don't support signals...
       NullUnregisterNewHandler
-    }
 
   def supported(signal: String): Boolean =
-    try {
+    try
       val signals = new Signals0
       signals.supported(signal)
-    } catch { case _: LinkageError => false }
-}
+    catch case _: LinkageError => false
+end Signals
 
 private class UnregisterNewHandler(intSignal: Signal, oldHandler: SignalHandler)
-    extends Signals.Registration {
-  override def remove(): Unit = {
+    extends Signals.Registration:
+  override def remove(): Unit =
     Signal.handle(intSignal, oldHandler)
     ()
-  }
-}
-private object NullUnregisterNewHandler extends Signals.Registration {
+private object NullUnregisterNewHandler extends Signals.Registration:
   override def remove(): Unit = ()
-}
 
 // Must only be referenced using a
 //   try { } catch { case _: LinkageError => ... }
 // block to
-private final class Signals0 {
-  def supported(signal: String): Boolean = {
+private final class Signals0:
+  def supported(signal: String): Boolean =
     import sun.misc.Signal
-    try {
+    try
       new Signal(signal); true
-    } catch { case _: IllegalArgumentException => false }
-  }
+    catch case _: IllegalArgumentException => false
 
   // returns a LinkageError in `action` as Left(t) in order to avoid it being
   // incorrectly swallowed as missing Signal/SignalHandler
-  def withHandler[T](signal: String, handler: () => Unit, action: () => T): Either[Throwable, T] = {
+  def withHandler[T](signal: String, handler: () => Unit, action: () => T): Either[Throwable, T] =
     import sun.misc.{ Signal, SignalHandler }
     val intSignal = new Signal(signal)
-    val newHandler = new SignalHandler {
-      def handle(sig: Signal): Unit = { handler() }
-    }
+    val newHandler = new SignalHandler:
+      def handle(sig: Signal): Unit = handler()
 
     val oldHandler = Signal.handle(intSignal, newHandler)
 
     try Right(action())
-    catch { case e: LinkageError => Left(e) }
-    finally {
+    catch case e: LinkageError => Left(e)
+    finally
       Signal.handle(intSignal, oldHandler); ()
-    }
-  }
-}
+end Signals0
diff --git a/util-collection/src/main/scala/sbt/internal/util/TupleMapExtension.scala b/util-collection/src/main/scala/sbt/internal/util/TupleMapExtension.scala
index f3aee8a3a..9774fd7ea 100644
--- a/util-collection/src/main/scala/sbt/internal/util/TupleMapExtension.scala
+++ b/util-collection/src/main/scala/sbt/internal/util/TupleMapExtension.scala
@@ -51,4 +51,6 @@ object TupleMapExtension:
             case _ => scala.runtime.TupleXXL.fromIterator(tuple.iterator.map(f(_)))
       // format: on
       res.asInstanceOf[Tuple.Map[Tup, F2]]
+    end transform
+  end extension
 end TupleMapExtension
diff --git a/util-collection/src/main/scala/sbt/internal/util/WrappedMap.scala b/util-collection/src/main/scala/sbt/internal/util/WrappedMap.scala
index e25a7f2a9..73e15fd09 100644
--- a/util-collection/src/main/scala/sbt/internal/util/WrappedMap.scala
+++ b/util-collection/src/main/scala/sbt/internal/util/WrappedMap.scala
@@ -9,11 +9,10 @@ package sbt.internal.util
 
 import scala.jdk.CollectionConverters.*
 
-private[util] class WrappedMap[K, V](val jmap: java.util.Map[K, V]) extends Map[K, V] {
+private[util] class WrappedMap[K, V](val jmap: java.util.Map[K, V]) extends Map[K, V]:
   def removed(key: K): scala.collection.immutable.Map[K, V] = jmap.asScala.toMap.removed(key)
   def updated[V1 >: V](key: K, value: V1): scala.collection.immutable.Map[K, V1] =
     jmap.asScala.toMap.updated(key, value)
 
   def get(key: K): Option[V] = Option(jmap.get(key))
   def iterator: Iterator[(K, V)] = jmap.asScala.iterator
-}
diff --git a/util-collection/src/main/scala/sbt/util/OptJsonWriter.scala b/util-collection/src/main/scala/sbt/util/OptJsonWriter.scala
index 8b6b5c650..17a12bac8 100644
--- a/util-collection/src/main/scala/sbt/util/OptJsonWriter.scala
+++ b/util-collection/src/main/scala/sbt/util/OptJsonWriter.scala
@@ -14,17 +14,13 @@ sealed trait OptJsonWriter[A]
 final case class NoJsonWriter[A]() extends OptJsonWriter[A]
 final case class SomeJsonWriter[A](value: JsonWriter[A]) extends OptJsonWriter[A]
 
-trait OptJsonWriter0 {
+trait OptJsonWriter0:
   given fallback[A]: NoJsonWriter[A] = NoJsonWriter()
-}
-object OptJsonWriter extends OptJsonWriter0 {
+object OptJsonWriter extends OptJsonWriter0:
   given lift[A](using z: JsonWriter[A]): SomeJsonWriter[A] = SomeJsonWriter(z)
 
-  trait StrictMode0 {
+  trait StrictMode0:
     given conflictingFallback1[A]: NoJsonWriter[A] = NoJsonWriter()
     given conflictingFallback2[A]: NoJsonWriter[A] = NoJsonWriter()
-  }
-  object StrictMode extends StrictMode0 {
+  object StrictMode extends StrictMode0:
     given lift[A](using z: JsonWriter[A]): SomeJsonWriter[A] = SomeJsonWriter(z)
-  }
-}
diff --git a/util-collection/src/test/scala/DagSpecification.scala b/util-collection/src/test/scala/DagSpecification.scala
index 3c301a664..3020d3433 100644
--- a/util-collection/src/test/scala/DagSpecification.scala
+++ b/util-collection/src/test/scala/DagSpecification.scala
@@ -14,7 +14,7 @@ import Prop.*
 import scala.annotation.tailrec
 import scala.collection.mutable.HashSet
 
-object DagSpecification extends Properties("Dag") {
+object DagSpecification extends Properties("Dag"):
   property("No repeated nodes") = forAll { (dag: TestDag) =>
     isSet(dag.topologicalSort)
   }
@@ -26,37 +26,30 @@ object DagSpecification extends Properties("Dag") {
   }
 
   given Arbitrary[TestDag] = Arbitrary(Gen.sized(dagGen))
-  private def dagGen(nodeCount: Int): Gen[TestDag] = {
+  private def dagGen(nodeCount: Int): Gen[TestDag] =
     val nodes = new HashSet[TestDag]
-    def nonterminalGen(p: Gen.Parameters): Gen[TestDag] = {
+    def nonterminalGen(p: Gen.Parameters): Gen[TestDag] =
       val seed = rng.Seed.random()
-      for {
+      for
         i <- 0 until nodeCount
         nextDeps <- Gen.someOf(nodes).apply(p, seed)
-      } nodes += new TestDag(i, nextDeps)
-      for (nextDeps <- Gen.someOf(nodes)) yield new TestDag(nodeCount, nextDeps)
-    }
+      do nodes += new TestDag(i, nextDeps)
+      for nextDeps <- Gen.someOf(nodes) yield new TestDag(nodeCount, nextDeps)
     Gen.parameterized(nonterminalGen)
-  }
 
   private def isSet[T](c: Seq[T]) = Set(c*).size == c.size
-  private def dependenciesPrecedeNodes(sort: List[TestDag]) = {
+  private def dependenciesPrecedeNodes(sort: List[TestDag]) =
     val seen = new HashSet[TestDag]
     @tailrec
-    def iterate(remaining: List[TestDag]): Boolean = {
-      remaining match {
+    def iterate(remaining: List[TestDag]): Boolean =
+      remaining match
         case Nil          => true
         case node :: tail =>
-          if (node.dependencies.forall(seen.contains) && !seen.contains(node)) {
+          if node.dependencies.forall(seen.contains) && !seen.contains(node) then
             seen += node
             iterate(tail)
-          } else
-            false
-      }
-    }
+          else false
     iterate(sort)
-  }
-}
-class TestDag(id: Int, val dependencies: Iterable[TestDag]) extends Dag[TestDag] {
+end DagSpecification
+class TestDag(id: Int, val dependencies: Iterable[TestDag]) extends Dag[TestDag]:
   override def toString = String.valueOf(id) + "->" + dependencies.mkString("[", ",", "]")
-}
diff --git a/util-collection/src/test/scala/SettingsExample.scala b/util-collection/src/test/scala/SettingsExample.scala
index 23e1267ad..602b05850 100644
--- a/util-collection/src/test/scala/SettingsExample.scala
+++ b/util-collection/src/test/scala/SettingsExample.scala
@@ -19,29 +19,26 @@ final case class Scope(nestIndex: Int, idAtIndex: Int = 0)
 //  Lots of type constructors would become binary, which as you may know requires lots of type lambdas
 //  when you want a type function with only one parameter.
 //  That would be a general pain.)
-case class SettingsExample() extends Init {
+case class SettingsExample() extends Init:
   type ScopeType = Scope
   // Provides a way of showing a Scope+AttributeKey[_]
-  val showFullKey: Show[ScopedKey[?]] = Show[ScopedKey[?]]((key: ScopedKey[?]) => {
+  val showFullKey: Show[ScopedKey[?]] = Show[ScopedKey[?]]((key: ScopedKey[?]) =>
     s"${key.scope.nestIndex}(${key.scope.idAtIndex})/${key.key.label}"
-  })
+  )
 
   // A sample delegation function that delegates to a Scope with a lower index.
   val delegates: Scope => Seq[Scope] = { case s @ Scope(index, proj) =>
-    s +: (if (index <= 0) Nil
-          else {
-            (if (proj > 0) List(Scope(index)) else Nil) ++: delegates(Scope(index - 1))
-          })
+    s +: (if index <= 0 then Nil
+          else (if proj > 0 then List(Scope(index)) else Nil) ++: delegates(Scope(index - 1)))
   }
 
   // Not using this feature in this example.
   val scopeLocal: ScopeLocal = _ => Nil
 
   // These three functions + a scope (here, Scope) are sufficient for defining our settings system.
-}
 
 /** Usage Example * */
-case class SettingsUsage(settingsExample: SettingsExample) {
+case class SettingsUsage(settingsExample: SettingsExample):
   import settingsExample.*
 
   // Define some keys
@@ -95,4 +92,4 @@ case class SettingsUsage(settingsExample: SettingsExample) {
    * a5 = Some(4)
    * b5 = Some(9)
    */
-}
+end SettingsUsage
diff --git a/util-tracking/src/main/scala/sbt/util/ChangeReport.scala b/util-tracking/src/main/scala/sbt/util/ChangeReport.scala
index 3140873f5..d8c837781 100644
--- a/util-tracking/src/main/scala/sbt/util/ChangeReport.scala
+++ b/util-tracking/src/main/scala/sbt/util/ChangeReport.scala
@@ -8,23 +8,20 @@
 
 package sbt.util
 
-object ChangeReport {
+object ChangeReport:
   def modified[T](files: Set[T]): ChangeReport[T] =
-    new EmptyChangeReport[T] {
+    new EmptyChangeReport[T]:
       override def checked = files
       override def modified = files
       override def markAllModified = this
-    }
 
   def unmodified[T](files: Set[T]): ChangeReport[T] =
-    new EmptyChangeReport[T] {
+    new EmptyChangeReport[T]:
       override def checked = files
       override def unmodified = files
-    }
-}
 
 /** The result of comparing some current set of objects against a previous set of objects. */
-trait ChangeReport[T] {
+trait ChangeReport[T]:
 
   /** The set of all of the objects in the current set. */
   def checked: Set[T]
@@ -51,38 +48,33 @@ trait ChangeReport[T] {
    * sets are the same as in this report.
    */
   def markAllModified: ChangeReport[T] =
-    new ChangeReport[T] {
+    new ChangeReport[T]:
       def checked = ChangeReport.this.checked
       def unmodified = Set.empty[T]
       def modified = ChangeReport.this.checked
       def added = ChangeReport.this.added
       def removed = ChangeReport.this.removed
       override def markAllModified = this
-    }
 
-  override def toString = {
+  override def toString =
     val labels = List("Checked", "Modified", "Unmodified", "Added", "Removed")
     val sets = List(checked, modified, unmodified, added, removed)
     val keyValues = labels.lazyZip(sets).map { (label, set) => label + ": " + set.mkString(", ") }
     keyValues.mkString("Change report:\n\t", "\n\t", "")
-  }
+end ChangeReport
 
-}
-
-class EmptyChangeReport[T] extends ChangeReport[T] {
+class EmptyChangeReport[T] extends ChangeReport[T]:
   def checked = Set.empty[T]
   def unmodified = Set.empty[T]
   def modified = Set.empty[T]
   def added = Set.empty[T]
   def removed = Set.empty[T]
   override def toString = "No changes"
-}
 
 private class CompoundChangeReport[T](a: ChangeReport[T], b: ChangeReport[T])
-    extends ChangeReport[T] {
+    extends ChangeReport[T]:
   lazy val checked = a.checked ++ b.checked
   lazy val unmodified = a.unmodified ++ b.unmodified
   lazy val modified = a.modified ++ b.modified
   lazy val added = a.added ++ b.added
   lazy val removed = a.removed ++ b.removed
-}
diff --git a/util-tracking/src/main/scala/sbt/util/FileFunction.scala b/util-tracking/src/main/scala/sbt/util/FileFunction.scala
index efd8dc4ac..19b115801 100644
--- a/util-tracking/src/main/scala/sbt/util/FileFunction.scala
+++ b/util-tracking/src/main/scala/sbt/util/FileFunction.scala
@@ -10,7 +10,7 @@ package sbt.util
 
 import java.io.File
 
-object FileFunction {
+object FileFunction:
   type UpdateFunction = (ChangeReport[File], ChangeReport[File]) => Set[File]
   private val defaultInStyle = FileInfo.lastModified
   private val defaultOutStyle = FileInfo.exists
@@ -148,18 +148,14 @@ object FileFunction {
    */
   def cached(storeFactory: CacheStoreFactory, inStyle: FileInfo.Style, outStyle: FileInfo.Style)(
       action: UpdateFunction
-  ): Set[File] => Set[File] = {
+  ): Set[File] => Set[File] =
     lazy val inCache = Difference.inputs(storeFactory.make("in-cache"), inStyle)
     lazy val outCache = Difference.outputs(storeFactory.make("out-cache"), outStyle)
-    inputs => {
+    inputs =>
       inCache(inputs) { inReport =>
         outCache { outReport =>
-          if (inReport.modified.isEmpty && outReport.modified.isEmpty)
-            outReport.checked
-          else
-            action(inReport, outReport)
+          if inReport.modified.isEmpty && outReport.modified.isEmpty then outReport.checked
+          else action(inReport, outReport)
         }
       }
-    }
-  }
-}
+end FileFunction
diff --git a/util-tracking/src/main/scala/sbt/util/Tracked.scala b/util-tracking/src/main/scala/sbt/util/Tracked.scala
index a66b36360..2ee26c453 100644
--- a/util-tracking/src/main/scala/sbt/util/Tracked.scala
+++ b/util-tracking/src/main/scala/sbt/util/Tracked.scala
@@ -18,7 +18,7 @@ import sjsonnew.{ JsonFormat, JsonWriter }
 import sjsonnew.support.murmurhash.Hasher
 import scala.annotation.nowarn
 
-object Tracked {
+object Tracked:
 
   /**
    * Creates a tracker that provides the last time it was evaluated. If the function throws an
@@ -38,10 +38,9 @@ object Tracked {
    * time is when the evaluated function completes. In both cases, the timestamp is not updated if
    * the function throws an exception.
    */
-  def tstamp(store: CacheStore, useStartTime: Boolean): Timestamp = {
+  def tstamp(store: CacheStore, useStartTime: Boolean): Timestamp =
     import CacheImplicits.LongJsonFormat
     new Timestamp(store, useStartTime)
-  }
 
   /**
    * Creates a tracker that provides the last time it was evaluated. If 'useStartTime' is true, the
@@ -81,12 +80,11 @@ object Tracked {
     diffOutputs(CacheStore(cacheFile), style)
 
   /** Creates a tracker that provides the output of the most recent invocation of the function */
-  def lastOutput[I, O: JsonFormat](store: CacheStore)(f: (I, Option[O]) => O): I => O = { in =>
+  def lastOutput[I, O: JsonFormat](store: CacheStore)(f: (I, Option[O]) => O): I => O = in =>
     val previous = Try { store.read[O]() }.toOption
     val next = f(in, previous)
     store.write(next)
     next
-  }
 
   /** Creates a tracker that provides the output of the most recent invocation of the function */
   def lastOutput[I, O: JsonFormat](cacheFile: File)(f: (I, Option[O]) => O): I => O =
@@ -108,9 +106,8 @@ object Tracked {
    */
   def outputChanged[A1: JsonFormat, A2](store: CacheStore)(
       f: (Boolean, A1) => A2
-  ): (() => A1) => A2 = {
+  ): (() => A1) => A2 =
     outputChangedW(store)(f)
-  }
 
   /**
    * Creates a tracker that indicates whether the output returned from `p` has changed or not.
@@ -131,20 +128,16 @@ object Tracked {
    */
   def outputChangedW[A1: JsonWriter, A2](store: CacheStore)(
       f: (Boolean, A1) => A2
-  ): (() => A1) => A2 = p => {
-    val cache: SingletonCache[Long] = {
+  ): (() => A1) => A2 = p =>
+    val cache: SingletonCache[Long] =
       import CacheImplicits.LongJsonFormat
       implicitly
-    }
     val initial = p()
     val help = new CacheHelp(cache)
     val changed = help.changed(store, initial)
     val result = f(changed, initial)
-    if (changed) {
-      help.save(store, p())
-    }
+    if changed then help.save(store, p())
     result
-  }
 
   /**
    * Creates a tracker that indicates whether the output returned from `p` has changed or not.
@@ -225,18 +218,15 @@ object Tracked {
    */
   def inputChangedW[I: JsonWriter, O](store: CacheStore)(
       f: (Boolean, I) => O
-  ): I => O = { in =>
-    val cache: SingletonCache[Long] = {
+  ): I => O = in =>
+    val cache: SingletonCache[Long] =
       import CacheImplicits.LongJsonFormat
       implicitly
-    }
     val help = new CacheHelp(cache)
     val changed = help.changed(store, in)
     val result = f(changed, in)
-    if (changed)
-      help.save(store, in)
+    if changed then help.save(store, in)
     result
-  }
 
   /**
    * Creates a tracker that indicates whether the arguments given to f have changed since the most
@@ -280,67 +270,59 @@ object Tracked {
   ): I => O =
     inputChangedW(CacheStore(cacheFile))(f)
 
-  private final class CacheHelp[I: JsonWriter](val sc: SingletonCache[Long]) {
+  private final class CacheHelp[I: JsonWriter](val sc: SingletonCache[Long]):
     import CacheImplicits.implicitHashWriter
     import CacheImplicits.LongJsonFormat
-    def save(store: CacheStore, value: I): Unit = {
-      Hasher.hash(value) match {
+    def save(store: CacheStore, value: I): Unit =
+      Hasher.hash(value) match
         case USuccess(keyHash) => store.write[Long](keyHash.toLong)
         case Failure(e)        =>
-          if (isStrictMode) throw e
+          if isStrictMode then throw e
           else ()
-      }
-    }
 
     def changed(store: CacheStore, value: I): Boolean =
-      Try { store.read[Long]() } match {
+      Try { store.read[Long]() } match
         case USuccess(prev: Long) =>
-          Hasher.hash(value) match {
+          Hasher.hash(value) match
             case USuccess(keyHash: Int) => keyHash.toLong != prev
             case Failure(e)             =>
-              if (isStrictMode) throw e
+              if isStrictMode then throw e
               else true
-          }
         case Failure(_: EmptyCacheError) => true
         case Failure(e)                  =>
-          if (isStrictMode) throw e
+          if isStrictMode then throw e
           else true
-      }
-  }
+  end CacheHelp
 
   private[sbt] def isStrictMode: Boolean =
     java.lang.Boolean.getBoolean("sbt.strict")
-}
+end Tracked
 
-trait Tracked {
+trait Tracked:
 
   /** Cleans outputs and clears the cache. */
   def clean(): Unit
 
-}
-
 class Timestamp(val store: CacheStore, useStartTime: Boolean)(using format: JsonFormat[Long])
-    extends Tracked {
+    extends Tracked:
   def clean() = store.delete()
 
   /**
    * Reads the previous timestamp, evaluates the provided function, and then updates the timestamp
    * if the function completes normally.
    */
-  def apply[T](f: Long => T): T = {
+  def apply[T](f: Long => T): T =
     val start = now()
     val result = f(readTimestamp)
-    store.write(if (useStartTime) start else now())
+    store.write(if useStartTime then start else now())
     result
-  }
 
   private def now() = System.currentTimeMillis
 
   def readTimestamp: Long =
     Try { store.read[Long]() } getOrElse 0
-}
 
-object Difference {
+object Difference:
   def constructor(
       defineClean: Boolean,
       filesAreOutputs: Boolean
@@ -361,18 +343,15 @@ object Difference {
    */
   val inputs = constructor(false, false)
 
-}
-
 class Difference(
     val store: CacheStore,
     val style: FileInfo.Style,
     val defineClean: Boolean,
     val filesAreOutputs: Boolean
-) extends Tracked {
-  def clean() = {
-    if (defineClean) IO.delete(raw(cachedFilesInfo)) else ()
+) extends Tracked:
+  def clean() =
+    if defineClean then IO.delete(raw(cachedFilesInfo)) else ()
     clearCache()
-  }
 
   private def clearCache() = store.delete()
 
@@ -380,26 +359,24 @@ class Difference(
     store.read(default = FilesInfo.empty[style.F])(using style.formats).files
   private def raw(fs: Set[style.F]): Set[File] = fs.map(_.file)
 
-  def apply[T](files: Set[File])(f: ChangeReport[File] => T): T = {
+  def apply[T](files: Set[File])(f: ChangeReport[File] => T): T =
     val lastFilesInfo = cachedFilesInfo
     apply(files, lastFilesInfo)(f)(_ => files)
-  }
 
-  def apply[T](f: ChangeReport[File] => T)(using toFiles: T => Set[File]): T = {
+  def apply[T](f: ChangeReport[File] => T)(using toFiles: T => Set[File]): T =
     val lastFilesInfo = cachedFilesInfo
     apply(raw(lastFilesInfo), lastFilesInfo)(f)(toFiles)
-  }
 
   private def abs(files: Set[File]) = files.map(_.getAbsoluteFile)
 
   private def apply[T](files: Set[File], lastFilesInfo: Set[style.F])(
       f: ChangeReport[File] => T
-  )(extractFiles: T => Set[File]): T = {
+  )(extractFiles: T => Set[File]): T =
     val lastFiles = raw(lastFilesInfo)
     val currentFiles = abs(files)
     val currentFilesInfo = style(currentFiles)
 
-    val report = new ChangeReport[File] {
+    val report = new ChangeReport[File]:
       lazy val checked = currentFiles
       lazy val removed =
         lastFiles -- checked // all files that were included previously but not this time.  This is independent of whether the files exist.
@@ -407,13 +384,12 @@ class Difference(
         checked -- lastFiles // all files included now but not previously.  This is independent of whether the files exist.
       lazy val modified = raw(lastFilesInfo -- currentFilesInfo.files) ++ added
       lazy val unmodified = checked -- modified
-    }
 
     val result = f(report)
-    val info = if (filesAreOutputs) style(abs(extractFiles(result))) else currentFilesInfo
+    val info = if filesAreOutputs then style(abs(extractFiles(result))) else currentFilesInfo
 
     store.write(info)(using style.formats)
 
     result
-  }
-}
+  end apply
+end Difference
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/Errors.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/Errors.scala
index e23e0fa67..d1d456ede 100644
--- a/zinc-lm-integration/src/main/scala/sbt/internal/inc/Errors.scala
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/Errors.scala
@@ -8,17 +8,14 @@
 
 package sbt.internal.inc
 
-class InvalidComponent(msg: String, cause: Throwable) extends RuntimeException(msg, cause) {
+class InvalidComponent(msg: String, cause: Throwable) extends RuntimeException(msg, cause):
   def this(msg: String) = this(msg, null)
-}
 
-final class MissingScalaJar(msg: String, cause: Throwable) extends RuntimeException(msg, cause) {
+final class MissingScalaJar(msg: String, cause: Throwable) extends RuntimeException(msg, cause):
   def this(msg: String) = this(msg, null)
-}
 
-object MissingScalaJar {
+object MissingScalaJar:
   def missingTemplate(missing: String): String =
     s"The $missing could neither be found in your cache nor downloaded from the Internet."
   def compiler: MissingScalaJar = new MissingScalaJar(missingTemplate("Scala compiler"))
   def library: MissingScalaJar = new MissingScalaJar(missingTemplate("Scala library"))
-}
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/IfMissing.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/IfMissing.scala
index abdee08c0..2d058c985 100644
--- a/zinc-lm-integration/src/main/scala/sbt/internal/inc/IfMissing.scala
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/IfMissing.scala
@@ -10,13 +10,11 @@ package sbt.internal.inc
 
 sealed trait IfMissing
 
-object IfMissing {
+object IfMissing:
   def fail: IfMissing = Fail
 
   /** f is expected to call ZincComponentManager.define. */
   def define(useSecondaryCache: Boolean, f: => Unit): IfMissing = new Define(useSecondaryCache, f)
   object Fail extends IfMissing
-  final class Define(val useSecondaryCache: Boolean, define: => Unit) extends IfMissing {
+  final class Define(val useSecondaryCache: Boolean, define: => Unit) extends IfMissing:
     def run(): Unit = define
-  }
-}
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ResourceLoader.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ResourceLoader.scala
index 82ea68cc0..b800031c6 100644
--- a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ResourceLoader.scala
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ResourceLoader.scala
@@ -12,29 +12,22 @@ import java.util.Properties
 import scala.util.Using
 
 /** Defines utilities to load Java properties from the JVM. */
-private[inc] object ResourceLoader {
-  def getPropertiesFor(resource: String): Properties = {
+private[inc] object ResourceLoader:
+  def getPropertiesFor(resource: String): Properties =
     val properties = new Properties
     val resourceUrl = getClass.getResource(resource)
-    if (resourceUrl eq null) {
+    if resourceUrl eq null then
       throw new java.io.FileNotFoundException(s"Resource not found: $resource")
-    }
     Using.resource(resourceUrl.openStream) { propertiesStream =>
       properties.load(propertiesStream)
     }
     properties
-  }
 
-  def getSafePropertiesFor(resource: String, classLoader: ClassLoader): Properties = {
+  def getSafePropertiesFor(resource: String, classLoader: ClassLoader): Properties =
     val properties = new Properties
-    val propertiesStream = classLoader.getResourceAsStream(resource)
-    if (propertiesStream ne null) {
-      try {
-        properties.load(propertiesStream)
-      } catch {
-        case _: Exception =>
-      } finally propertiesStream.close()
-    }
+    Using.resource(classLoader.getResourceAsStream(resource)): propertiesStream =>
+      if propertiesStream ne null then
+        try properties.load(propertiesStream)
+        catch
+          case _: Exception =>
     properties
-  }
-}
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentCompiler.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentCompiler.scala
index 9ea5d12e8..8a4d283ed 100644
--- a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentCompiler.scala
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentCompiler.scala
@@ -29,7 +29,7 @@ import java.io.File
 import java.nio.file.{ Files, Path }
 import java.util.concurrent.Callable
 
-private[sbt] object ZincComponentCompiler {
+private[sbt] object ZincComponentCompiler:
   final val binSeparator = "-bin_"
   final val javaClassVersion = System.getProperty("java.class.version")
 
@@ -44,7 +44,7 @@ private[sbt] object ZincComponentCompiler {
       manager: ZincComponentManager,
       dependencyResolution: DependencyResolution,
       scalaJarsTarget: File
-  ) extends CompilerBridgeProvider {
+  ) extends CompilerBridgeProvider:
 
     /**
      * Defines a richer interface for Scala users that want to pass in an explicit module id.
@@ -68,7 +68,7 @@ private[sbt] object ZincComponentCompiler {
       zinc.compiledBridgeJar
     }
 
-    override def fetchCompiledBridge(scalaInstance: XScalaInstance, logger: Logger): File = {
+    override def fetchCompiledBridge(scalaInstance: XScalaInstance, logger: Logger): File =
       val scalaVersion = scalaInstance.actualVersion()
       val bridgeSources = userProvidedBridgeSources
         .getOrElse(
@@ -78,7 +78,6 @@ private[sbt] object ZincComponentCompiler {
           )
         )
       compiledBridge(bridgeSources, scalaInstance, logger)
-    }
 
     // internal representation of Scala artifacts
     private case class ScalaArtifacts(
@@ -87,7 +86,7 @@ private[sbt] object ZincComponentCompiler {
         others: Vector[Path]
     )
 
-    private def getScalaArtifacts(scalaVersion: String, logger: Logger): ScalaArtifacts = {
+    private def getScalaArtifacts(scalaVersion: String, logger: Logger): ScalaArtifacts =
       def isPrefixedWith(artifact: Path, prefix: String) =
         artifact.getFileName.toString.startsWith(prefix)
 
@@ -120,9 +119,9 @@ private[sbt] object ZincComponentCompiler {
       val scalaCompilerJar = maybeScalaCompiler.getOrElse(throw MissingScalaJar.compiler)
       val scalaLibraryJar = maybeScalaLibrary.getOrElse(throw MissingScalaJar.library)
       ScalaArtifacts(scalaCompilerJar, Vector(scalaLibraryJar), others)
-    }
+    end getScalaArtifacts
 
-    override def fetchScalaInstance(scalaVersion: String, logger: Logger): XScalaInstance = {
+    override def fetchScalaInstance(scalaVersion: String, logger: Logger): XScalaInstance =
       val scalaArtifacts = getScalaArtifacts(scalaVersion, logger)
       val scalaCompilerJar = scalaArtifacts.compilerJar
       val scalaLibraryJars = scalaArtifacts.libraryJars
@@ -149,8 +148,8 @@ private[sbt] object ZincComponentCompiler {
         allJars,
         loaderVersion,
       )
-    }
-  }
+    end fetchScalaInstance
+  end ZincCompilerBridgeProvider
 
   // Used by ZincUtil.
   def interfaceProvider(
@@ -158,10 +157,9 @@ private[sbt] object ZincComponentCompiler {
       manager: ZincComponentManager,
       dependencyResolution: DependencyResolution,
       scalaJarsTarget: File,
-  ): CompilerBridgeProvider = {
+  ): CompilerBridgeProvider =
     val bridgeSources = Some(compilerBridgeSource)
     new ZincCompilerBridgeProvider(bridgeSources, manager, dependencyResolution, scalaJarsTarget)
-  }
 
   def interfaceProvider(
       manager: ZincComponentManager,
@@ -171,26 +169,24 @@ private[sbt] object ZincComponentCompiler {
     new ZincCompilerBridgeProvider(None, manager, dependencyResolution, scalaJarsTarget)
 
   private final val LocalIvy =
-    (sys.props.get("sbt.ivy.home") match {
+    (sys.props.get("sbt.ivy.home") match
       case Some(home) =>
-        if (home.endsWith("/")) home
+        if home.endsWith("/") then home
         else home + "/"
       case _ => s"$${user.home}/.ivy2/"
-    }) + "local/" + Resolver.localBasePattern
+    ) + "local/" + Resolver.localBasePattern
 
-  final val LocalResolver: Resolver = {
+  final val LocalResolver: Resolver =
     val toUse = Vector(LocalIvy)
     val ivyPatterns = Patterns().withIsMavenCompatible(false)
     val finalPatterns = ivyPatterns.withIvyPatterns(toUse).withArtifactPatterns(toUse)
     FileRepository("local", Resolver.defaultFileConfiguration, finalPatterns)
-  }
 
-  def getDefaultLock: GlobalLock = new GlobalLock {
+  def getDefaultLock: GlobalLock = new GlobalLock:
     override def apply[T](file: File, callable: Callable[T]): T = callable.call()
-  }
 
   /** Defines a default component provider that manages the component in a given directory. */
-  private final class DefaultComponentProvider(targetDir: File) extends ComponentProvider {
+  private final class DefaultComponentProvider(targetDir: File) extends ComponentProvider:
     import sbt.io.syntax.*
     private val LockFile = targetDir / "lock"
     override def lockFile(): File = LockFile
@@ -199,18 +195,14 @@ private[sbt] object ZincComponentCompiler {
       IO.listFiles(targetDir / componentID)
     override def defineComponent(componentID: String, files: Array[File]): Unit =
       files.foreach(f => IO.copyFile(f, targetDir / componentID / f.getName))
-    override def addToComponent(componentID: String, files: Array[File]): Boolean = {
+    override def addToComponent(componentID: String, files: Array[File]): Boolean =
       defineComponent(componentID, files)
       true
-    }
-  }
 
-  def getDefaultComponentProvider(targetDir: File): ComponentProvider = {
+  def getDefaultComponentProvider(targetDir: File): ComponentProvider =
     require(targetDir.isDirectory)
     new DefaultComponentProvider(targetDir)
-  }
-
-}
+end ZincComponentCompiler
 
 /**
  * Component compiler which is able to to retrieve the compiler bridge sources
@@ -224,13 +216,12 @@ private[inc] class ZincComponentCompiler(
     dependencyResolution: DependencyResolution,
     bridgeSources: ModuleID,
     log: sbt.util.Logger
-) {
+):
   private final val buffered = new BufferedLogger(FullLogger(log))
 
-  def compiledBridgeJar: File = {
+  def compiledBridgeJar: File =
     val jarBinaryName = createBridgeSourcesID(bridgeSources)
     manager.file(jarBinaryName)(IfMissing.define(true, compileAndInstall(jarBinaryName)))
-  }
 
   /**
    * Returns the id for the compiler interface component.
@@ -246,12 +237,11 @@ private[inc] class ZincComponentCompiler(
    * @param sources The moduleID representing the compiler bridge sources.
    * @return The complete jar identifier for the bridge sources.
    */
-  private def createBridgeSourcesID(sources: ModuleID): String = {
+  private def createBridgeSourcesID(sources: ModuleID): String =
     import ZincComponentCompiler.{ binSeparator, javaClassVersion }
     val id = s"${sources.organization}-${sources.name}-${sources.revision}"
     val scalaVersion = compiler.scalaInstance.actualVersion()
     s"$id$binSeparator${scalaVersion}__$javaClassVersion"
-  }
 
   /**
    * Resolves the compiler bridge sources, compiles them and installs the sbt component
@@ -259,7 +249,7 @@ private[inc] class ZincComponentCompiler(
    *
    * @param compilerBridgeId The identifier for the compiler bridge sources.
    */
-  private def compileAndInstall(compilerBridgeId: String): Unit = {
+  private def compileAndInstall(compilerBridgeId: String): Unit =
     val moduleForBridge = dependencyResolution.wrapDependencyInModule(bridgeSources)
     IO.withTemporaryDirectory { binaryDirectory =>
       val target = new File(binaryDirectory, s"$compilerBridgeId.jar")
@@ -288,11 +278,10 @@ private[inc] class ZincComponentCompiler(
         }
       }
     }
-  }
+  end compileAndInstall
+end ZincComponentCompiler
 
-}
-
-private object ZincLMHelper {
+private object ZincLMHelper:
   private final val warningConf = UnresolvedWarningConfiguration()
   private final val defaultRetrievePattern = Resolver.defaultRetrievePattern
 
@@ -306,11 +295,11 @@ private object ZincLMHelper {
       noSource: Boolean,
       logger: sbt.util.Logger,
       desc: String,
-  ): Vector[Path] = {
+  ): Vector[Path] =
     val updateConfiguration = newUpdateConfiguration(retrieveDirectory, noSource)
     val dependencies = prettyPrintDependency(module)
     logger.info(s"Attempting to fetch $dependencies.")
-    dependencyResolution.update(module, updateConfiguration, warningConf, logger) match {
+    dependencyResolution.update(module, updateConfiguration, warningConf, logger) match
       case Left(uw) =>
         logger.debug(s"couldn't retrieve module(s) ${prettyPrintDependency(module)}.")
         val unretrievedMessage = s"The $desc could not be retrieved."
@@ -321,26 +310,23 @@ private object ZincLMHelper {
         logger.debug(s"Files retrieved for ${prettyPrintDependency(module)}:")
         logger.debug(allFiles.mkString(", "))
         allFiles
-    }
-  }
+  end update
 
-  private def newUpdateConfiguration(targetDir: File, noSource: Boolean): UpdateConfiguration = {
+  private def newUpdateConfiguration(targetDir: File, noSource: Boolean): UpdateConfiguration =
     val retrieve = RetrieveConfiguration()
       .withRetrieveDirectory(targetDir)
       .withOutputPattern(defaultRetrievePattern)
     val logLevel = UpdateLogging.DownloadOnly
     val defaultExcluded = Set("doc")
-    val finalExcluded = if (noSource) defaultExcluded + "src" else defaultExcluded
+    val finalExcluded = if noSource then defaultExcluded + "src" else defaultExcluded
     val artifactFilter = ArtifactTypeFilter.forbid(finalExcluded)
     UpdateConfiguration()
       .withRetrieveManaged(retrieve)
       .withLogging(logLevel)
       .withArtifactFilter(artifactFilter)
-  }
 
-  private def prettyPrintDependency(module: ModuleDescriptor): String = {
+  private def prettyPrintDependency(module: ModuleDescriptor): String =
     module.directDependencies
       .map(m => s"${m.organization}:${m.name}:${m.revision}") // like ModuleIDExtra.toStringImpl
       .mkString(", ")
-  }
-}
+end ZincLMHelper
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentManager.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentManager.scala
index 2c837955d..82e688fae 100644
--- a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentManager.scala
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentManager.scala
@@ -32,47 +32,41 @@ class ZincComponentManager(
     provider: ComponentProvider,
     secondaryCacheDir: Option[File],
     log0: Logger,
-) {
+):
   val log = new FullLogger(log0)
 
   /** Get all of the files for component 'id', throwing an exception if no files exist for the component. */
-  def files(id: String)(ifMissing: IfMissing): Iterable[File] = {
+  def files(id: String)(ifMissing: IfMissing): Iterable[File] =
     def notFound = invalid(s"Could not find required component '$id'")
-    def getOrElse(orElse: => Iterable[File]): Iterable[File] = {
+    def getOrElse(orElse: => Iterable[File]): Iterable[File] =
       val existing = provider.component(id)
       // log.info(s"[zinc-lm] existing = ${existing.toList}")
-      if (existing.isEmpty) orElse
+      if existing.isEmpty then orElse
       else existing
-    }
 
-    def createAndCache = {
-      ifMissing match {
+    def createAndCache =
+      ifMissing match
         case IfMissing.Fail      => notFound
         case d: IfMissing.Define =>
           d.run() // this is expected to have called define.
-          if (d.useSecondaryCache) {
-            cacheToSecondaryCache(id)
-          }
+          if d.useSecondaryCache then cacheToSecondaryCache(id)
           getOrElse(notFound)
-      }
-    }
 
-    def fromSecondary: Iterable[File] = {
+    def fromSecondary: Iterable[File] =
       lockSecondaryCache {
         update(id)
         getOrElse(createAndCache)
       }.getOrElse(notFound)
-    }
 
     lockLocalCache(getOrElse(fromSecondary))
-  }
+  end files
 
   /**
    * Get the file for component 'id',
    *  throwing an exception if no files or multiple files exist for the component.
    */
-  def file(id: String)(ifMissing: IfMissing): File = {
-    files(id)(ifMissing).toList match {
+  def file(id: String)(ifMissing: IfMissing): File =
+    files(id)(ifMissing).toList match
       case x :: Nil          => x
       case xs if xs.size > 1 =>
         val canonical = xs.find(_.getName == s"$id.jar").getOrElse(xs.head)
@@ -83,8 +77,6 @@ class ZincComponentManager(
         )
         canonical
       case xs => invalid(s"Expected single file for component '$id', found: ${xs.mkString(", ")}")
-    }
-  }
 
   /** Associate a component id to a series of jars. */
   def define(id: String, files: Iterable[File]): Unit =
@@ -101,7 +93,11 @@ class ZincComponentManager(
     secondaryCacheDir.map(dir => lock(new File(dir, ".sbt.cache.lock"))(action))
 
   private def lock[T](file: File)(action: => T): T =
-    globalLock(file, new Callable[T] { def call = action })
+    globalLock(
+      file,
+      new Callable[T]:
+        def call = action
+    )
 
   private def invalid(msg: String) = throw new InvalidComponent(msg)
 
@@ -117,37 +113,29 @@ class ZincComponentManager(
    * To prevent this, we first remove any existing files in the component directory
    * before defining the component with the canonical name (`id.jar`).
    */
-  private def update(id: String): Unit = {
+  private def update(id: String): Unit =
     secondaryCacheDir.foreach { dir =>
       val secondary = secondaryCacheFile(id, dir)
-      if (secondary.exists) {
+      if secondary.exists then
         val componentDir = provider.componentLocation(id)
-        if (componentDir.isDirectory) {
-          IO.listFiles(componentDir).foreach(IO.delete)
-        }
+        if componentDir.isDirectory then IO.listFiles(componentDir).foreach(IO.delete)
         val canonicalJar = new File(componentDir, s"$id.jar")
         IO.copyFile(secondary, canonicalJar)
-      }
     }
-  }
 
   /** Install the files for component 'id' to the secondary cache. */
-  private def cacheToSecondaryCache(id: String): Unit = {
+  private def cacheToSecondaryCache(id: String): Unit =
     val fromPrimaryCache = file(id)(IfMissing.fail)
     secondaryCacheDir.foreach { dir =>
       IO.copyFile(fromPrimaryCache, secondaryCacheFile(id, dir))
     }
-  }
 
-  private def secondaryCacheFile(id: String, dir: File): File = {
+  private def secondaryCacheFile(id: String, dir: File): File =
     new File(new File(dir, SbtOrganization), s"$id-${ZincComponentManager.stampedVersion}.jar")
-  }
-}
+end ZincComponentManager
 
-object ZincComponentManager {
-  lazy val (version, timestamp) = {
+object ZincComponentManager:
+  lazy val (version, timestamp) =
     val properties = ResourceLoader.getPropertiesFor("/incrementalcompiler.version.properties")
     (properties.getProperty("version"), properties.getProperty("timestamp"))
-  }
   lazy val stampedVersion = s"${version}_$timestamp"
-}
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincLmUtil.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincLmUtil.scala
index 2151745b5..f7033ef06 100644
--- a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincLmUtil.scala
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincLmUtil.scala
@@ -23,7 +23,7 @@ import xsbti.ArtifactInfo.SbtOrganization
 import xsbti.*
 import xsbti.compile.{ ClasspathOptions, ScalaInstance as XScalaInstance }
 
-object ZincLmUtil {
+object ZincLmUtil:
 
   final val scala2SbtBridgeStart = ScalaArtifacts.scala2SbtBridgeStart
   def hasScala2SbtBridge(sv: String): Boolean =
@@ -45,7 +45,7 @@ object ZincLmUtil {
       scalaJarsTarget: File,
       classLoaderCache: Option[ClassLoaderCache],
       log: Logger
-  ): AnalyzingCompiler = {
+  ): AnalyzingCompiler =
     val compilerBridgeProvider = ZincComponentCompiler.interfaceProvider(
       compilerBridgeSource,
       new ZincComponentManager(globalLock, componentProvider, secondaryCacheDir, log),
@@ -59,7 +59,7 @@ object ZincLmUtil {
       _ => (),
       classLoaderCache
     )
-  }
+  end scalaCompiler
 
   def scalaCompilerBridgeJars(
       scalaInstance: XScalaInstance,
@@ -86,7 +86,7 @@ object ZincLmUtil {
       updateConfiguration: UpdateConfiguration,
       warningConfig: UnresolvedWarningConfiguration,
       logger: Logger
-  ): File = {
+  ): File =
     val bridgeModule = getDefaultBridgeModule(scalaOrganization, scalaVersion)
     val descriptor = dependencyResolution.wrapDependencyInModule(bridgeModule)
     dependencyResolution
@@ -98,33 +98,30 @@ object ZincLmUtil {
           moduleFilter(bridgeModule.organization, bridgeModule.name, bridgeModule.revision),
           artifactFilter(`extension` = "jar", classifier = "")
         )
-        if (jars.size > 1)
+        if jars.size > 1 then
           sys.error(s"There should be only one jar for $bridgeModule but found $jars")
         else jars.headOption
       }
       .getOrElse(throw new MessageOnlyException(s"Missing $bridgeModule"))
-  }
+  end fetchDefaultBridgeModule
 
-  def getDefaultBridgeModule(scalaOrganization: String, scalaVersion: String): ModuleID = {
-    if (ScalaArtifacts.isScala3(scalaVersion)) {
+  def getDefaultBridgeModule(scalaOrganization: String, scalaVersion: String): ModuleID =
+    if ScalaArtifacts.isScala3(scalaVersion) then
       ModuleID(scalaOrganization, "scala3-sbt-bridge", scalaVersion)
         .withConfigurations(Some(Compile.name))
-    } else if (hasScala2SbtBridge(scalaVersion)) {
+    else if hasScala2SbtBridge(scalaVersion) then
       ModuleID(scalaOrganization, "scala2-sbt-bridge", scalaVersion)
         .withConfigurations(Some(Compile.name))
-    } else {
-      val compilerBridgeId = scalaVersion match {
+    else
+      val compilerBridgeId = scalaVersion match
         case sc if sc.startsWith("2.10.") => "compiler-bridge_2.10"
         case sc if sc.startsWith("2.11.") => "compiler-bridge_2.11"
         case sc if sc.startsWith("2.12.") => "compiler-bridge_2.12"
         case "2.13.0-M1"                  => "compiler-bridge_2.12"
         case _                            => "compiler-bridge_2.13"
-      }
       ModuleID(SbtOrganization, compilerBridgeId, ZincComponentManager.version)
         .withConfigurations(Some(Compile.name))
-    }
-  }
 
   def getDefaultBridgeSourceModule(scalaOrganization: String, scalaVersion: String): ModuleID =
     getDefaultBridgeModule(scalaOrganization, scalaVersion).sources()
-}
+end ZincLmUtil
diff --git a/zinc-lm-integration/src/test/scala/sbt/internal/inc/BridgeProviderSpecification.scala b/zinc-lm-integration/src/test/scala/sbt/internal/inc/BridgeProviderSpecification.scala
index 05c52ee01..0bdae54b6 100644
--- a/zinc-lm-integration/src/test/scala/sbt/internal/inc/BridgeProviderSpecification.scala
+++ b/zinc-lm-integration/src/test/scala/sbt/internal/inc/BridgeProviderSpecification.scala
@@ -28,7 +28,7 @@ import lmcoursier.*
 abstract class BridgeProviderSpecification
     extends flatspec.FixtureAnyFlatSpec
     with fixture.TestDataFixture
-    with Matchers {
+    with Matchers:
   def currentBase: File = new File(".")
   def currentTarget: File = currentBase / "target" / "ivyhome"
   def currentManaged: File = currentBase / "target" / "lib_managed"
@@ -39,7 +39,7 @@ abstract class BridgeProviderSpecification
     Resolver.mavenCentral: Resolver,
   )
 
-  def getZincProvider(bridge: ModuleID, targetDir: File, log: Logger): CompilerBridgeProvider = {
+  def getZincProvider(bridge: ModuleID, targetDir: File, log: Logger): CompilerBridgeProvider =
     val lock = ZincComponentCompiler.getDefaultLock
     val secondaryCache = Some(secondaryCacheDirectory)
     val componentProvider = ZincComponentCompiler.getDefaultComponentProvider(targetDir)
@@ -49,17 +49,15 @@ abstract class BridgeProviderSpecification
     )
     // IvyDependencyResolution(ivyConfiguration(log))
     ZincComponentCompiler.interfaceProvider(bridge, manager, dependencyResolution, currentManaged)
-  }
 
   def getCompilerBridge(
       targetDir: File,
       log: Logger,
       scalaVersion: String,
-  )(using td: TestData): File = {
-    val zincVersion = td.configMap.get("sbt.zinc.version") match {
+  )(using td: TestData): File =
+    val zincVersion = td.configMap.get("sbt.zinc.version") match
       case Some(v: String) => v
       case _               => throw new IllegalStateException("No zinc version specified")
-    }
     val bridge0 = ZincLmUtil.getDefaultBridgeSourceModule(ScalaArtifacts.Organization, scalaVersion)
     // redefine the compiler bridge version
     // using the version of zinc used during testing
@@ -74,6 +72,5 @@ abstract class BridgeProviderSpecification
     val target = targetDir / s"target-bridge-$scalaVersion.jar"
     IO.copyFile(bridge, target)
     target
-  }
-
-}
+  end getCompilerBridge
+end BridgeProviderSpecification
diff --git a/zinc-lm-integration/src/test/scala/sbt/internal/inc/ZincComponentCompilerSpec.scala b/zinc-lm-integration/src/test/scala/sbt/internal/inc/ZincComponentCompilerSpec.scala
index 2c89bd4e9..ab85decab 100644
--- a/zinc-lm-integration/src/test/scala/sbt/internal/inc/ZincComponentCompilerSpec.scala
+++ b/zinc-lm-integration/src/test/scala/sbt/internal/inc/ZincComponentCompilerSpec.scala
@@ -11,7 +11,7 @@ package sbt.internal.inc
 import sbt.internal.util.ConsoleLogger
 import sbt.io.IO
 
-class ZincComponentCompilerSpec extends BridgeProviderSpecification {
+class ZincComponentCompilerSpec extends BridgeProviderSpecification:
   val scala2107 = "2.10.7"
   val scala21112 = "2.11.12"
   val scala21221 = "2.12.21"
@@ -34,4 +34,4 @@ class ZincComponentCompilerSpec extends BridgeProviderSpecification {
   it should "compile the bridge for Scala 2.13.11" in { case given FixtureParam =>
     IO.withTemporaryDirectory(t => getCompilerBridge(t, logger, scala21311) should exist)
   }
-}
+end ZincComponentCompilerSpec