Repository: 7mind/izumi
Pull request #1680 (2022-01-01 23:05:32)

Update scalafmt-core to 3.3.1
Updates [org.scalameta:scalafmt-core](https://github.com/scalameta/scalafmt) from 3.3.0 to 3.3.1.
[GitHub Release Notes](https://github.com/scalameta/scalafmt/releases/tag/v3.3.1) - [Version Diff](https://github.com/scalameta/scalafmt/compare/v3.3.0...v3.3.1)

I'll automatically update this PR to resolve conflicts as long as you don't change it yourself.

If you'd like to skip this version, you can just close this PR. If you have any feedback, just mention me in the comments below.

Configure Scala Steward for your repository with a [`.scala-steward.conf`](https://github.com/scala-steward-org/scala-steward/blob/2772ccf169a0667d434a3e562193fed1850abba9/docs/repo-specific-configuration.md) file.

Have a fantastic day writing Scala!

<details>
<summary>Files still referring to the old version number</summary>

The following files still refer to the old version number (3.3.0).
You might want to review and update them manually.
```
project/Versions.scala
```
</details>
<details>
<summary>Ignore future updates</summary>

Add this to your `.scala-steward.conf` file to ignore future updates of this dependency:
```
updates.ignore = [ { groupId = "org.scalameta", artifactId = "scalafmt-core" } ]
```
</details>

labels: library-update, early-semver-patch, semver-spec-patch, old-version-remains, commit-count:n:2


Patch:
diff --git a/.scalafmt.conf b/.scalafmt.conf
index 22c9baa62..d85f774fa 100644
--- a/.scalafmt.conf
+++ b/.scalafmt.conf
@@ -1,4 +1,4 @@
-version = "3.3.0"
+version = "3.3.1"
 runner.dialect = scala213source3
 project.git = true
 project.excludePaths = ["glob:**.sbt"]
diff --git a/distage/distage-core-api/src/main/scala/izumi/distage/constructors/macros/HasConstructorMacro.scala b/distage/distage-core-api/src/main/scala/izumi/distage/constructors/macros/HasConstructorMacro.scala
index cf923c131..25dfa96af 100644
--- a/distage/distage-core-api/src/main/scala/izumi/distage/constructors/macros/HasConstructorMacro.scala
+++ b/distage/distage-core-api/src/main/scala/izumi/distage/constructors/macros/HasConstructorMacro.scala
@@ -34,7 +34,7 @@ object HasConstructorMacro {
         val logger = TrivialMacroLogger.make[this.type](c, DebugProperties.`izumi.debug.macro.distage.constructors`.name)
 
         val params = reflectionProvider.zioHasParameters(c.freshName)(deepIntersection)
-        val provider: c.Expr[Functoid[T]] = {
+        val provider: c.Expr[Functoid[T]] =
           generateProvider[T, ProviderType.ZIOHas.type](params :: Nil) {
             case (headParam :: params) :: Nil =>
               params.foldLeft(q"_root_.zio.Has.apply($headParam)") {
@@ -42,7 +42,6 @@ object HasConstructorMacro {
               }
             case _ => c.abort(c.enclosingPosition, s"Impossible happened, empty Has intersection or malformed type $targetType in HasConstructorMacro")
           }
-        }
 
         val res = c.Expr[HasConstructor[T]](q"{ new ${weakTypeOf[HasConstructor[T]]}($provider) }")
         logger.log(s"Final syntax tree of HasConstructor for $targetType:\n$res")
diff --git a/distage/distage-core-api/src/main/scala/izumi/distage/model/effect/QuasiAsync.scala b/distage/distage-core-api/src/main/scala/izumi/distage/model/effect/QuasiAsync.scala
index e36142989..6e949cc32 100644
--- a/distage/distage-core-api/src/main/scala/izumi/distage/model/effect/QuasiAsync.scala
+++ b/distage/distage-core-api/src/main/scala/izumi/distage/model/effect/QuasiAsync.scala
@@ -32,7 +32,7 @@ trait QuasiAsync[F[_]] {
 object QuasiAsync extends LowPriorityQuasiAsyncInstances {
   def apply[F[_]: QuasiAsync]: QuasiAsync[F] = implicitly
 
-  implicit lazy val quasiAsyncIdentity: QuasiAsync[Identity] = {
+  implicit lazy val quasiAsyncIdentity: QuasiAsync[Identity] =
     new QuasiAsync[Identity] {
       final val maxAwaitTime = FiniteDuration(1L, "minute")
       final val QuasiAsyncIdentityThreadFactory = new NamedThreadFactory("QuasiIO-cached-pool", daemon = true)
@@ -72,7 +72,6 @@ object QuasiAsync extends LowPriorityQuasiAsyncInstances {
         ()
       }
     }
-  }
 
   private[izumi] def parTraverseIdentity[A, B](ec0: ExecutionContext)(l: IterableOnce[A])(f: A => Identity[B]): Identity[List[B]] = {
     implicit val ec: ExecutionContext = ec0
diff --git a/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/Provider.scala b/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/Provider.scala
index b66538f71..e5630e204 100644
--- a/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/Provider.scala
+++ b/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/Provider.scala
@@ -23,11 +23,10 @@ trait Provider {
   def addUnused(keys: Iterable[DIKey]): Provider
   def replaceKeys(f: DIKey => DIKey): Provider
 
-  private val eqField: AnyRef = {
+  private val eqField: AnyRef =
     if (providerType eq ProviderType.Function) originalFun
     else if (providerType eq ProviderType.FunctionWithUnusedKeys) (originalFun, diKeys)
     else ret
-  }
   override final def equals(obj: Any): Boolean = obj match {
     case that: Provider => eqField == that.eqField
     case _ => false
diff --git a/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/macros/DIUniverseLiftables.scala b/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/macros/DIUniverseLiftables.scala
index e972cccd5..56fdc3263 100644
--- a/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/macros/DIUniverseLiftables.scala
+++ b/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/macros/DIUniverseLiftables.scala
@@ -27,12 +27,11 @@ class DIUniverseLiftables[D <: StaticDIUniverse](val u: D) {
       q"""{ new $modelReflectionPkg.DIKey.IdKey(${liftTypeToSafeType(idKey.tpe.typeNative)}, $lifted) }"""
   }
 
-  protected[this] implicit val liftableBasicDIKey: Liftable[DIKey.BasicKey] = {
+  protected[this] implicit val liftableBasicDIKey: Liftable[DIKey.BasicKey] =
     Liftable[DIKey.BasicKey] {
       case t: DIKey.TypeKey => q"${liftableTypeKey(t)}"
       case i: DIKey.IdKey[_] => q"${liftableIdKey(i)}"
     }
-  }
 
   // SymbolInfo
 
diff --git a/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/macros/FunctoidMacro.scala b/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/macros/FunctoidMacro.scala
index d81499322..74f9c4e08 100644
--- a/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/macros/FunctoidMacro.scala
+++ b/distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/macros/FunctoidMacro.scala
@@ -162,12 +162,11 @@ class FunctoidMacro(val c: blackbox.Context) {
   }
 
   protected[this] def extractMethodReferenceParams(symbol: Symbol): List[Symbol] = {
-    val isSyntheticCaseClassApply = {
+    val isSyntheticCaseClassApply =
       symbol.name.decodedName.toString == "apply" &&
-      symbol.isSynthetic &&
-      symbol.owner.companion.isClass &&
-      symbol.owner.companion.asClass.isCaseClass
-    }
+        symbol.isSynthetic &&
+        symbol.owner.companion.isClass &&
+        symbol.owner.companion.asClass.isCaseClass
 
     val method = if (isSyntheticCaseClassApply) {
       // since this is a _synthetic_ apply, its signature must match the case class constructor exactly, so we don't check it
diff --git a/distage/distage-core/.jvm/src/main/scala/izumi/distage/provisioning/strategies/ProxyStrategyDefaultImplPlatformSpecific.scala b/distage/distage-core/.jvm/src/main/scala/izumi/distage/provisioning/strategies/ProxyStrategyDefaultImplPlatformSpecific.scala
index cf573b2b4..655da26b0 100644
--- a/distage/distage-core/.jvm/src/main/scala/izumi/distage/provisioning/strategies/ProxyStrategyDefaultImplPlatformSpecific.scala
+++ b/distage/distage-core/.jvm/src/main/scala/izumi/distage/provisioning/strategies/ProxyStrategyDefaultImplPlatformSpecific.scala
@@ -21,7 +21,7 @@ abstract class ProxyStrategyDefaultImplPlatformSpecific(
     val classConstructorParams = if (noArgsConstructor(tpe)) {
       ProxyParams.Empty
     } else {
-      val allArgsAsNull: Array[(Class[?], Any)] = {
+      val allArgsAsNull: Array[(Class[?], Any)] =
         op.op match {
           case WiringOp.CallProvider(_, f: Wiring.SingletonWiring.Function, _) if f.provider.providerType eq ProviderType.Class =>
             // for class constructors, try to fetch known dependencies from the object graph
@@ -31,7 +31,6 @@ abstract class ProxyStrategyDefaultImplPlatformSpecific(
             runtimeClass.getConstructors.head.getParameterTypes
               .map(clazz => clazz -> TypeUtil.defaultValue(clazz))
         }
-      }
       val (argClasses, argValues) = allArgsAsNull.unzip
       ProxyParams.Params(argClasses, argValues)
     }
diff --git a/distage/distage-core/src/main/scala/izumi/distage/InjectorDefaultImpl.scala b/distage/distage-core/src/main/scala/izumi/distage/InjectorDefaultImpl.scala
index 8a25be32d..3063dfc0f 100644
--- a/distage/distage-core/src/main/scala/izumi/distage/InjectorDefaultImpl.scala
+++ b/distage/distage-core/src/main/scala/izumi/distage/InjectorDefaultImpl.scala
@@ -121,13 +121,11 @@ object InjectorDefaultImpl {
     }
   }
 
-  private[this] lazy val selfReflectionKeys: Set[DIKey] = {
+  private[this] lazy val selfReflectionKeys: Set[DIKey] =
     // passing nulls to prevent key list getting out of sync
     selfReflectionModule(null, null, null, null.asInstanceOf[Activation], null).keys
-  }
 
-  lazy val providedKeys: Set[DIKey] = {
+  lazy val providedKeys: Set[DIKey] =
     selfReflectionKeys +
-    DIKey[LocatorRef] // magic import, always available
-  }
+      DIKey[LocatorRef] // magic import, always available
 }
diff --git a/distage/distage-core/src/main/scala/izumi/distage/bootstrap/BootstrapLocator.scala b/distage/distage-core/src/main/scala/izumi/distage/bootstrap/BootstrapLocator.scala
index 57c2a5d61..0861dc075 100644
--- a/distage/distage-core/src/main/scala/izumi/distage/bootstrap/BootstrapLocator.scala
+++ b/distage/distage-core/src/main/scala/izumi/distage/bootstrap/BootstrapLocator.scala
@@ -92,7 +92,7 @@ object BootstrapLocator {
     resourceStrategy = new ResourceStrategyDefaultImpl,
   )
 
-  private final val bootstrapProducer: PlanInterpreter = {
+  private final val bootstrapProducer: PlanInterpreter =
     new PlanInterpreterNonSequentialRuntimeImpl(
       planner = bootstrapPlanner,
       importStrategy = new ImportStrategyDefaultImpl,
@@ -100,7 +100,6 @@ object BootstrapLocator {
       verifier = new ProvisionOperationVerifier.Default(mirrorProvider),
       fullStackTraces = fullStackTraces,
     )
-  }
 
   final val defaultBootstrap: BootstrapContextModule = new BootstrapContextModuleDef {
     make[Boolean].named("izumi.distage.interpreter.full-stacktraces").fromValue(fullStackTraces)
@@ -158,8 +157,7 @@ object BootstrapLocator {
     }
   }
 
-  lazy val selfReflectionKeys: Set[DIKey] = {
+  lazy val selfReflectionKeys: Set[DIKey] =
     // passing nulls to prevent key list getting out of sync
     selfReflectionModule(null, null.asInstanceOf[Activation]).keys
-  }
 }
diff --git a/distage/distage-framework-docker/src/main/scala/izumi/distage/docker/Docker.scala b/distage/distage-framework-docker/src/main/scala/izumi/distage/docker/Docker.scala
index 4bb5908ef..bbbbc24af 100644
--- a/distage/distage-framework-docker/src/main/scala/izumi/distage/docker/Docker.scala
+++ b/distage/distage-framework-docker/src/main/scala/izumi/distage/docker/Docker.scala
@@ -207,11 +207,10 @@ object Docker {
     implicit val configReader: ConfigReader[ClientConfig] = PureconfigAutoDerive.derived
     implicit val diConfigReader: DIConfigReader[ClientConfig] = DIConfigReader.deriveFromPureconfigConfigReader
 
-    val defaultReusePolicy: DockerReusePolicy = {
+    val defaultReusePolicy: DockerReusePolicy =
       DebugProperties.`izumi.distage.docker.reuse`
         .strValue()
         .fold[DockerReusePolicy](DockerReusePolicy.ReuseEnabled)(parseReusePolicy)
-    }
 
     def parseReusePolicy(name: String): DockerReusePolicy = {
       name match {
diff --git a/distage/distage-framework-docker/src/main/scala/izumi/distage/docker/DockerClientWrapper.scala b/distage/distage-framework-docker/src/main/scala/izumi/distage/docker/DockerClientWrapper.scala
index a428716c1..0cb44515e 100644
--- a/distage/distage-framework-docker/src/main/scala/izumi/distage/docker/DockerClientWrapper.scala
+++ b/distage/distage-framework-docker/src/main/scala/izumi/distage/docker/DockerClientWrapper.scala
@@ -90,7 +90,7 @@ object DockerClientWrapper {
   ) extends Lifecycle.Basic[F, DockerClientWrapper[F]]
     with IntegrationCheck[F] {
 
-    private[this] lazy val rawClientConfig: DefaultDockerClientConfig = {
+    private[this] lazy val rawClientConfig: DefaultDockerClientConfig =
       Value(DefaultDockerClientConfig.createDefaultConfigBuilder())
         .mut(clientConfig.remote.filter(_ => clientConfig.useRemote))(
           (b, c) => b.withDockerHost(c.host).withDockerTlsVerify(c.tlsVerify).withDockerCertPath(c.certPath).withDockerConfig(c.config)
@@ -99,11 +99,9 @@ object DockerClientWrapper {
           (b, c) => b.withRegistryUrl(c.url).withRegistryUsername(c.username).withRegistryPassword(c.password).withRegistryEmail(c.email)
         )
         .get.build()
-    }
 
-    private[this] lazy val rawClient: DockerClient = {
+    private[this] lazy val rawClient: DockerClient =
       clientFactory.makeClient(clientConfig, rawClientConfig)
-    }
 
     override def resourcesAvailable(): F[ResourceCheck] = F.maybeSuspend {
       try {
diff --git a/fundamentals/fundamentals-collections/src/main/scala/izumi/functional/IzEitherAggregations.scala b/fundamentals/fundamentals-collections/src/main/scala/izumi/functional/IzEitherAggregations.scala
index 408820c95..6fa9e1634 100644
--- a/fundamentals/fundamentals-collections/src/main/scala/izumi/functional/IzEitherAggregations.scala
+++ b/fundamentals/fundamentals-collections/src/main/scala/izumi/functional/IzEitherAggregations.scala
@@ -1,6 +1,6 @@
 package izumi.functional
 
-import izumi.functional.IzEitherAggregations.{EitherScalarOps, EitherBiAggregate, EitherBiFlatAggregate, EitherBiFlatMapAggregate, EitherBiMapAggregate}
+import izumi.functional.IzEitherAggregations.{EitherBiAggregate, EitherBiFlatAggregate, EitherBiFlatMapAggregate, EitherBiMapAggregate, EitherScalarOps}
 import izumi.fundamentals.collections.nonempty.NonEmptyList
 
 import scala.collection.compat.*
@@ -36,7 +36,8 @@ object IzEitherAggregations extends IzEitherAggregations {
     }
   }
 
-  final class EitherBiFlatAggregate[L, R, Col[x] <: IterableOnce[x], Col2[x] <: IterableOnce[x]](private val result: Col[Either[NonEmptyList[L], Col2[R]]]) extends AnyVal {
+  final class EitherBiFlatAggregate[L, R, Col[x] <: IterableOnce[x], Col2[x] <: IterableOnce[x]](private val result: Col[Either[NonEmptyList[L], Col2[R]]])
+    extends AnyVal {
     /** `flatSequence` with error accumulation */
     def biFlatAggregate(implicit b: Factory[R, Col[R]]): Either[NonEmptyList[L], Col[R]] = {
       new IzEither.EitherBiFlatAggregate(result)
@@ -53,14 +54,16 @@ object IzEitherAggregations extends IzEitherAggregations {
 
     /** `traverse` with error accumulation */
     def biMapAggregateTo[L, A, CC](f: T => Either[NonEmptyList[L], A])(b: Factory[A, CC]): Either[NonEmptyList[L], CC] = {
-      IzEither.EitherBiMapAggregate(col)
+      IzEither
+        .EitherBiMapAggregate(col)
         .biMapAggregateTo(f)(b)(_.toList)
         .left.map(NonEmptyList.unsafeFrom)
     }
 
     /** `traverse_` with error accumulation */
     def biMapAggregateVoid[L](f: T => Either[NonEmptyList[L], Unit]): Either[NonEmptyList[L], Unit] = {
-      IzEither.EitherBiMapAggregate(col)
+      IzEither
+        .EitherBiMapAggregate(col)
         .biMapAggregateVoid(f)(_.toList)
         .left.map(NonEmptyList.unsafeFrom)
     }
@@ -74,7 +77,8 @@ object IzEitherAggregations extends IzEitherAggregations {
 
     /** `flatTraverse` with error accumulation */
     def biFlatMapAggregateTo[L, A, CC](f: T => Either[NonEmptyList[L], IterableOnce[A]])(b: Factory[A, CC]): Either[NonEmptyList[L], CC] = {
-      IzEither.EitherBiFlatMapAggregate(col)
+      IzEither
+        .EitherBiFlatMapAggregate(col)
         .biFlatMapAggregateTo(f)(b)(_.toList)
         .left.map(NonEmptyList.unsafeFrom)
     }
@@ -83,9 +87,7 @@ object IzEitherAggregations extends IzEitherAggregations {
   final class EitherScalarOps[L, R, Col[x] <: IterableOnce[x]](private val e: Col[Either[L, R]]) extends AnyVal {
     /** `sequence` with error accumulation */
     def biAggregateScalar(implicit b: Factory[R, Col[R]]): Either[NonEmptyList[L], Col[R]] = {
-      IzEither.EitherScalarOps(e)
-        .biAggregateScalar
-        .left.map(NonEmptyList.unsafeFrom)
+      IzEither.EitherScalarOps(e).biAggregateScalar.left.map(NonEmptyList.unsafeFrom)
     }
   }
 }
diff --git a/fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/graphs/dotml/GraphVizDotML.scala b/fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/graphs/dotml/GraphVizDotML.scala
index 65d2ccfeb..ca3ce23d4 100644
--- a/fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/graphs/dotml/GraphVizDotML.scala
+++ b/fundamentals/fundamentals-collections/src/main/scala/izumi/fundamentals/graphs/dotml/GraphVizDotML.scala
@@ -129,10 +129,9 @@ abstract class GraphVizDotML(
     if (this.strict) result += s"${sj}strict ${head.format(na)}"
     else result += s"$sj${head.format(na)}"
 
-    val styled = {
+    val styled =
       if (this.graphAttr.nonEmpty || this.nodeAttr.nonEmpty || this.edgeAttr.nonEmpty) true
       else false
-    }
     if (this.graphAttr.nonEmpty) {
       result += s"$sj\t%s %s".format("graph", this.attribute(null, this.graphAttr))
     }
diff --git a/fundamentals/fundamentals-functional/src/main/scala/izumi/functional/IzEither.scala b/fundamentals/fundamentals-functional/src/main/scala/izumi/functional/IzEither.scala
index d7547a3e2..ff4c6d091 100644
--- a/fundamentals/fundamentals-functional/src/main/scala/izumi/functional/IzEither.scala
+++ b/fundamentals/fundamentals-functional/src/main/scala/izumi/functional/IzEither.scala
@@ -68,12 +68,20 @@ object IzEither extends IzEither {
 
   final class EitherBiFlatMapAggregate[Col[x] <: IterableOnce[x], T](private val col: Col[T]) extends AnyVal {
     /** `flatTraverse` with error accumulation */
-    def biFlatMapAggregate[Src[_], L, A](f: T => Either[Src[L], IterableOnce[A]])(implicit b: Factory[A, Col[A]], ev: Src[L] => IterableOnce[L]): Either[List[L], Col[A]] = {
+    def biFlatMapAggregate[Src[_], L, A](
+      f: T => Either[Src[L], IterableOnce[A]]
+    )(implicit b: Factory[A, Col[A]],
+      ev: Src[L] => IterableOnce[L],
+    ): Either[List[L], Col[A]] = {
       biFlatMapAggregateTo(f)(b)
     }
 
     /** `flatTraverse` with error accumulation */
-    def biFlatMapAggregateTo[Src[_], L, A, CC](f: T => Either[Src[L], IterableOnce[A]])(b: Factory[A, CC])(implicit ev: Src[L] => IterableOnce[L]): Either[List[L], CC] = {
+    def biFlatMapAggregateTo[Src[_], L, A, CC](
+      f: T => Either[Src[L], IterableOnce[A]]
+    )(b: Factory[A, CC]
+    )(implicit ev: Src[L] => IterableOnce[L]
+    ): Either[List[L], CC] = {
       val bad = List.newBuilder[L]
       val good = b.newBuilder
 
@@ -137,7 +145,8 @@ object IzEither extends IzEither {
     }
   }
 
-  final class EitherBiFlatAggregate[L, R, Col[x] <: IterableOnce[x], Col2[x] <: IterableOnce[x], Src[_]](private val result: Col[Either[Src[L], Col2[R]]]) extends AnyVal {
+  final class EitherBiFlatAggregate[L, R, Col[x] <: IterableOnce[x], Col2[x] <: IterableOnce[x], Src[_]](private val result: Col[Either[Src[L], Col2[R]]])
+    extends AnyVal {
     /** `flatSequence` with error accumulation */
     def biFlatAggregate(implicit b: Factory[R, Col[R]], ev: Src[L] => IterableOnce[L]): Either[List[L], Col[R]] = {
       val bad = List.newBuilder[L]
diff --git a/fundamentals/fundamentals-functional/src/main/scala/izumi/functional/IzEitherTraversals.scala b/fundamentals/fundamentals-functional/src/main/scala/izumi/functional/IzEitherTraversals.scala
index 5cdcd6d59..04e780a93 100644
--- a/fundamentals/fundamentals-functional/src/main/scala/izumi/functional/IzEitherTraversals.scala
+++ b/fundamentals/fundamentals-functional/src/main/scala/izumi/functional/IzEitherTraversals.scala
@@ -58,4 +58,4 @@ object IzEitherTraversals extends IzEitherTraversals {
       (bad.result(), good.result())
     }
   }
-}
\ No newline at end of file
+}
diff --git a/fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/network/IzSockets.scala b/fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/network/IzSockets.scala
index d352ad89a..e188b2567 100644
--- a/fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/network/IzSockets.scala
+++ b/fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/network/IzSockets.scala
@@ -18,7 +18,7 @@ object IzSockets {
 
   val RANDOM_LOOPBACK_ADDRESS = "RANDOM_LOOPBACK_ADDRESS"
 
-  private val canBindOnAlternativeLoopbackAddresses = {
+  private val canBindOnAlternativeLoopbackAddresses =
     try {
       IzSockets.temporaryServerAddress(address = "127.20.0.0")
       true
@@ -26,7 +26,6 @@ object IzSockets {
       case _: java.net.BindException =>
         false
     }
-  }
 
   /** @return A port on 'localhost' that is currently available */
   def temporaryLocalPort(udp: Boolean = false): Int = temporaryServerAddress("localhost", udp).getPort
diff --git a/fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/time/IzTime.scala b/fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/time/IzTime.scala
index 1be03bcc2..0961a1624 100644
--- a/fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/time/IzTime.scala
+++ b/fundamentals/fundamentals-platform/src/main/scala/izumi/fundamentals/platform/time/IzTime.scala
@@ -16,19 +16,17 @@ trait IzTimeSafe {
   @inline implicit final def toRichDuration(duration: Duration): IzDuration = new IzDuration(duration)
 
   // formatters with 3 decimal positions for nanos
-  final lazy val ISO_LOCAL_DATE_TIME_3NANO: DateTimeFormatter = {
+  final lazy val ISO_LOCAL_DATE_TIME_3NANO: DateTimeFormatter =
     new DateTimeFormatterBuilder().parseCaseInsensitive
       .append(ISO_LOCAL_DATE)
       .appendLiteral('T')
       .append(ISO_LOCAL_TIME_3NANO)
       .toFormatter()
-  }
 
-  final lazy val ISO_LOCAL_DATE: DateTimeFormatter = {
+  final lazy val ISO_LOCAL_DATE: DateTimeFormatter =
     DateTimeFormatter.ISO_LOCAL_DATE
-  }
 
-  final lazy val ISO_LOCAL_TIME_3NANO: DateTimeFormatter = {
+  final lazy val ISO_LOCAL_TIME_3NANO: DateTimeFormatter =
     new DateTimeFormatterBuilder()
       .appendValue(HOUR_OF_DAY, 2)
       .appendLiteral(':')
@@ -39,16 +37,14 @@ trait IzTimeSafe {
       .optionalStart
       .appendFraction(NANO_OF_SECOND, 3, 3, true)
       .toFormatter()
-  }
 
-  final lazy val ISO_OFFSET_TIME_3NANO: DateTimeFormatter = {
+  final lazy val ISO_OFFSET_TIME_3NANO: DateTimeFormatter =
     new DateTimeFormatterBuilder().parseCaseInsensitive
       .append(ISO_LOCAL_TIME_3NANO)
       .appendOffsetId
       .toFormatter()
-  }
 
-  final val ISO_DATE_TIME_3NANO: DateTimeFormatter = {
+  final val ISO_DATE_TIME_3NANO: DateTimeFormatter =
     new DateTimeFormatterBuilder().parseCaseInsensitive
       .append(ISO_LOCAL_DATE_TIME_3NANO)
       .appendOffsetId
@@ -58,19 +54,16 @@ trait IzTimeSafe {
       .appendZoneRegionId()
       .appendLiteral(']')
       .toFormatter()
-  }
 
-  final val ISO_DATE = {
+  final val ISO_DATE =
     DateTimeFormatter.ISO_DATE
-  }
 
-  final val ISO_TIME_3NANO = {
+  final val ISO_TIME_3NANO =
     new DateTimeFormatterBuilder().parseCaseInsensitive
       .append(ISO_LOCAL_TIME_3NANO)
       .optionalStart
       .appendOffsetId
       .toFormatter
-  }
 }
 
 object IzTimeSafe extends IzTimeSafe with IzTimeOrderingSafe
@@ -96,7 +89,7 @@ trait IzTime extends IzTimeSafe {
 
   def isoNow: String = utcNow.isoFormat
 
-  final lazy val ISO_ZONED_DATE_TIME_3NANO: DateTimeFormatter = {
+  final lazy val ISO_ZONED_DATE_TIME_3NANO: DateTimeFormatter =
     new DateTimeFormatterBuilder()
       .append(ISO_OFFSET_DATE_TIME_3NANO)
       .optionalStart
@@ -105,16 +98,14 @@ trait IzTime extends IzTimeSafe {
       .appendZoneRegionId
       .appendLiteral(']')
       .toFormatter
-  }
 
-  final lazy val ISO_OFFSET_DATE_TIME_3NANO: DateTimeFormatter = {
+  final lazy val ISO_OFFSET_DATE_TIME_3NANO: DateTimeFormatter =
     new DateTimeFormatterBuilder().parseCaseInsensitive
       .append(ISO_LOCAL_DATE_TIME_3NANO)
       .parseLenient
       .appendOffsetId
       .parseStrict
       .toFormatter
-  }
 }
 
 object IzTime extends IzTime with IzTimeOrdering
diff --git a/logstage/logstage-core/.jvm/src/main/scala/izumi/logstage/sink/file/FileServiceImpl.scala b/logstage/logstage-core/.jvm/src/main/scala/izumi/logstage/sink/file/FileServiceImpl.scala
index 58229ac18..97ebe2dcf 100644
--- a/logstage/logstage-core/.jvm/src/main/scala/izumi/logstage/sink/file/FileServiceImpl.scala
+++ b/logstage/logstage-core/.jvm/src/main/scala/izumi/logstage/sink/file/FileServiceImpl.scala
@@ -25,14 +25,12 @@ object FileServiceImpl {
       Source.fromFile(this.name)
     }
 
-    private val outputSink = {
+    private val outputSink =
       for {
         _ <- createIfNotExists
         writer <- Try(Files.newOutputStream(filePath, StandardOpenOption.APPEND))
       } yield writer
 
-    }
-
     override def exists: Boolean = {
       new File(name).exists()
     }
diff --git a/logstage/logstage-core/.jvm/src/main/scala/izumi/logstage/sink/file/models/FileSinkConfig.scala b/logstage/logstage-core/.jvm/src/main/scala/izumi/logstage/sink/file/models/FileSinkConfig.scala
index b6bad1bb3..b6365d022 100644
--- a/logstage/logstage-core/.jvm/src/main/scala/izumi/logstage/sink/file/models/FileSinkConfig.scala
+++ b/logstage/logstage-core/.jvm/src/main/scala/izumi/logstage/sink/file/models/FileSinkConfig.scala
@@ -4,14 +4,13 @@ import LogPayloadSize._
 
 final case class FileSinkConfig private (fileSizeInBytes: Option[Int], fileSizeSoft: Option[Int]) {
 
-  val (maxAllowedSize, calculateMessageSize) = {
+  val (maxAllowedSize, calculateMessageSize) =
     (fileSizeSoft, fileSizeInBytes) match {
       case (Some(size), _) => (size, LogPayloadSizeSoft.size(_: String))
       case (_, Some(size)) => (size, LogPayloadSizeInBytes.size(_: String))
       case (None, None) =>
         throw new IllegalArgumentException("File limit parameter should be specified")
     }
-  }
 }
 
 object FileSinkConfig {
diff --git a/logstage/logstage-rendering-circe/src/main/scala/izumi/logstage/api/rendering/json/LogstageCirceRenderingPolicy.scala b/logstage/logstage-rendering-circe/src/main/scala/izumi/logstage/api/rendering/json/LogstageCirceRenderingPolicy.scala
index af6f10d58..147fac080 100644
--- a/logstage/logstage-rendering-circe/src/main/scala/izumi/logstage/api/rendering/json/LogstageCirceRenderingPolicy.scala
+++ b/logstage/logstage-rendering-circe/src/main/scala/izumi/logstage/api/rendering/json/LogstageCirceRenderingPolicy.scala
@@ -156,9 +156,8 @@ class LogstageCirceRenderingPolicy(
     case o => Json.fromString(o.toString)
   }
 
-  private val mapListElement: PartialFunction[Any, Json] = {
+  private val mapListElement: PartialFunction[Any, Json] =
     mapScalar orElse mapToString
-  }
 }
 
 object LogstageCirceRenderingPolicy {


Test patch:
diff --git a/distage/distage-testkit-core/src/main/scala/izumi/distage/testkit/services/dstest/DistageTestEnv.scala b/distage/distage-testkit-core/src/main/scala/izumi/distage/testkit/services/dstest/DistageTestEnv.scala
index feabdeaee..7f73568a4 100644
--- a/distage/distage-testkit-core/src/main/scala/izumi/distage/testkit/services/dstest/DistageTestEnv.scala
+++ b/distage/distage-testkit-core/src/main/scala/izumi/distage/testkit/services/dstest/DistageTestEnv.scala
@@ -79,13 +79,12 @@ trait DistageTestEnv {
 }
 
 object DistageTestEnv {
-  private[distage] final val cache: SyncCache[EnvCacheKey, TestEnvironment] = {
+  private[distage] final val cache: SyncCache[EnvCacheKey, TestEnvironment] =
     if (DebugProperties.`izumi.distage.testkit.environment.cache`.boolValue(true)) {
       new SyncCache[EnvCacheKey, TestEnvironment]
     } else {
       null
     }
-  }
 
   private[distage] final case class EnvCacheKey(config: TestConfig, rolesInfo: RolesInfo, mergeStrategy: PluginMergeStrategy)
 }
diff --git a/distage/distage-testkit-core/src/main/scala/izumi/distage/testkit/services/dstest/DistageTestRunner.scala b/distage/distage-testkit-core/src/main/scala/izumi/distage/testkit/services/dstest/DistageTestRunner.scala
index 5145cd68b..9ebe28089 100644
--- a/distage/distage-testkit-core/src/main/scala/izumi/distage/testkit/services/dstest/DistageTestRunner.scala
+++ b/distage/distage-testkit-core/src/main/scala/izumi/distage/testkit/services/dstest/DistageTestRunner.scala
@@ -140,11 +140,10 @@ class DistageTestRunner[F[_]: TagK: DefaultModule](
     val moduleProvider = env.bootstrapFactory.makeModuleProvider[F](envExec.planningOptions, config, lateLogger.router, env.roles, env.activationInfo, env.activation)
 
     val bsModule = moduleProvider.bootstrapModules().merge overriddenBy env.bsModule
-    val appModule = {
+    val appModule =
       // add default module manually, instead of passing it to Injector, to be able to split it later into runtime/non-runtime manually
       IdentitySupportModule ++ DefaultModule[F] overriddenBy
-      moduleProvider.appModules().merge overriddenBy env.appModule
-    }
+        moduleProvider.appModules().merge overriddenBy env.appModule
 
     val (bsPlanMinusVariableKeys, bsModuleMinusVariableKeys, injector, planner) = {
       // FIXME: Including both bootstrap Plan & bootstrap Module into merge criteria to prevent `Bootloader`
diff --git a/fundamentals/fundamentals-bio/.jvm/src/test/scala/izumi/functional/bio/data/FreeMonadTest.scala b/fundamentals/fundamentals-bio/.jvm/src/test/scala/izumi/functional/bio/data/FreeMonadTest.scala
index 3d19d2386..5d8fadb79 100644
--- a/fundamentals/fundamentals-bio/.jvm/src/test/scala/izumi/functional/bio/data/FreeMonadTest.scala
+++ b/fundamentals/fundamentals-bio/.jvm/src/test/scala/izumi/functional/bio/data/FreeMonadTest.scala
@@ -10,7 +10,7 @@ import zio.internal.Platform
 class FreeMonadTest extends AnyWordSpec {
   import FreeMonadTest._
   val syntax = new TestFreeSyntax[IO]
-  val simpleExecution: FreePanic[TestFreeChoice, Nothing, Unit] = {
+  val simpleExecution: FreePanic[TestFreeChoice, Nothing, Unit] =
     for {
       res <- syntax.pure(1)
       _ <- syntax.sync(assert(res == 1))
@@ -23,7 +23,6 @@ class FreeMonadTest extends AnyWordSpec {
         }.catchAll(_ => syntax.unit)
       _ <- syntax.scopeAccess(res => assert(res == 1000))
     } yield ()
-  }
   // tailrec test, just in case
   val nested: FreePanic[TestFreeChoice, Nothing, Unit] = List.fill(100000)(simpleExecution).reduce((f1, f2) => f1.flatMap(_ => f2))
 
diff --git a/fundamentals/fundamentals-bio/src/test/scala/izumi/fundamentals/bio/test/SyntaxTest.scala b/fundamentals/fundamentals-bio/src/test/scala/izumi/fundamentals/bio/test/SyntaxTest.scala
index 6d6876805..3e2b3c0a5 100644
--- a/fundamentals/fundamentals-bio/src/test/scala/izumi/fundamentals/bio/test/SyntaxTest.scala
+++ b/fundamentals/fundamentals-bio/src/test/scala/izumi/fundamentals/bio/test/SyntaxTest.scala
@@ -348,7 +348,7 @@ class SyntaxTest extends AnyWordSpec {
     def attachScheduler3[FR[-_, +_, +_]: Monad3: Scheduler3]: FR[Nothing, Nothing, Int] = {
       F.repeat(F.pure(42))(RetryPolicy.recurs(2))
     }
-    lazy val zioTest = {
+    lazy val zioTest =
       (
         x[zio.IO],
         y[zio.IO],
@@ -359,7 +359,6 @@ class SyntaxTest extends AnyWordSpec {
         attachScheduler2[zio.IO],
         attachScheduler3[zio.ZIO],
       )
-    }
 
     lazy val monixTest = (
       x[bio.IO],