Reformat code

Author: adamw

.scalafmt.conf

@@ -1,2 +1,8 @@
-version = 2.7.5
-maxColumn = 120
+version = 3.0.7
+maxColumn = 120
+runner.dialect = scala3
+fileOverride {
+  "glob:**/scala-2/**" {
+    runner.dialect = scala213
+  }
+}

build.sbt

@@ -171,15 +171,15 @@ lazy val macrosAkkaTests = projectMatrix
   .dependsOn(macrosAkka, testUtil)
   .jvmPlatform(scalaVersions = scala2)
 
-  lazy val macrosAutoCats = projectMatrix
+lazy val macrosAutoCats = projectMatrix
   .in(file("macrosAutoCats"))
   .settings(commonSettings)
   .settings(libraryDependencies ++= Seq(catsEffect, cats))
   .dependsOn(macros)
   .jvmPlatform(scalaVersions = scala2)
   .jsPlatform(scalaVersions = scala2)
 
-  lazy val macrosAutoCatsTests = projectMatrix
+lazy val macrosAutoCatsTests = projectMatrix
   .in(file("macrosAutoCatsTests"))
   .settings(testSettings)
   .settings(libraryDependencies ++= Seq(scalatest, catsEffect, tagging))

macros/src/main/scala-2/com/softwaremill/macwire/MacwireMacros.scala

@@ -7,27 +7,29 @@ import scala.reflect.macros.blackbox
 object MacwireMacros {
   private val log = new Logger()
 
-  def wire_impl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[T] = 
+  def wire_impl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[T] =
     wire(c)(DependencyResolver.throwErrorOnResolutionFailure[c.type, c.universe.Type, c.universe.Tree](c, log))
 
   def wireRec_impl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[T] = {
     import c.universe._
 
     def isWireable(tpe: Type): Boolean = {
       val name = tpe.typeSymbol.fullName
-      
-      !name.startsWith("java.lang.") && !name.startsWith("scala.")  
+
+      !name.startsWith("java.lang.") && !name.startsWith("scala.")
     }
-    
-    val dependencyResolver = new DependencyResolver[c.type, Type, Tree](c, log)(tpe => 
+
+    val dependencyResolver = new DependencyResolver[c.type, Type, Tree](c, log)(tpe =>
       if (!isWireable(tpe)) c.abort(c.enclosingPosition, s"Cannot find a value of type: [${tpe}]")
       else c.Expr[T](q"wireRec[$tpe]").tree
     )
-    
+
     wire(c)(dependencyResolver)
   }
 
-  def wire[T: c.WeakTypeTag](c: blackbox.Context)(dependencyResolver: DependencyResolver[c.type, c.universe.Type, c.universe.Tree]): c.Expr[T] = {
+  def wire[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(dependencyResolver: DependencyResolver[c.type, c.universe.Type, c.universe.Tree]): c.Expr[T] = {
     import c.universe._
 
     val constructorCrimper = new ConstructorCrimper[c.type, T](c, log)
@@ -44,7 +46,9 @@ object MacwireMacros {
       else s"Target type not supported for wiring: $targetType. Please file a bug report with your use-case."
     }
 
-    val code: Tree = (constructorCrimper.constructorTree(dependencyResolver) orElse companionCrimper.applyTree(dependencyResolver)) getOrElse
+    val code: Tree = (constructorCrimper.constructorTree(dependencyResolver) orElse companionCrimper.applyTree(
+      dependencyResolver
+    )) getOrElse
       c.abort(c.enclosingPosition, whatWasWrong)
     log(s"Generated code: ${showCode(code)}, ${showRaw(code)}")
     c.Expr(code)
@@ -60,16 +64,16 @@ object MacwireMacros {
     val (params, fun) = factory match {
       // Function with two parameter lists (implicit parameters) (<2.13)
       case Block(Nil, Function(p, Apply(Apply(f, _), _))) => (p, f)
-      case Block(Nil, Function(p, Apply(f, _))) => (p, f)
+      case Block(Nil, Function(p, Apply(f, _)))           => (p, f)
       // Function with two parameter lists (implicit parameters) (>=2.13)
       case Function(p, Apply(Apply(f, _), _)) => (p, f)
-      case Function(p, Apply(f, _)) => (p, f)
+      case Function(p, Apply(f, _))           => (p, f)
       // Other types not supported
       case _ => c.abort(c.enclosingPosition, s"Not supported factory type: [$factory]")
     }
 
-    val values = params.map {
-      case vd@ValDef(_, name, tpt, rhs) => dependencyResolver.resolve(vd.symbol, typeCheckIfNeeded(tpt))
+    val values = params.map { case vd @ ValDef(_, name, tpt, rhs) =>
+      dependencyResolver.resolve(vd.symbol, typeCheckIfNeeded(tpt))
     }
     val code = q"$fun(..$values)"
 
@@ -99,7 +103,7 @@ object MacwireMacros {
     def extractTypeFromNullaryType(tpe: Type) = {
       tpe match {
         case NullaryMethodType(underlying) => Some(underlying)
-        case _ => None
+        case _                             => None
       }
     }
 

macros/src/main/scala-2/com/softwaremill/macwire/internals/CompanionCrimper.scala

@@ -12,8 +12,9 @@ private[macwire] class CompanionCrimper[C <: blackbox.Context, T: C#WeakTypeTag]
   lazy val companionType: Option[Type] = CompanionCrimper.companionType(c)(targetType)
 
   lazy val applies: Option[List[Symbol]] = CompanionCrimper.applies(c, log)(targetType)
-  
-  def applyTree(dependencyResolver: DependencyResolverType): Option[Tree] = CompanionCrimper.applyTree[C](c, log)(targetType, dependencyResolver.resolve(_, _))
+
+  def applyTree(dependencyResolver: DependencyResolverType): Option[Tree] =
+    CompanionCrimper.applyTree[C](c, log)(targetType, dependencyResolver.resolve(_, _))
 
 }
 
@@ -22,35 +23,43 @@ object CompanionCrimper {
 
   private def isCompanionApply[C <: blackbox.Context](c: C)(targetType: c.Type, method: c.Symbol): Boolean =
     method.isMethod &&
-    method.isPublic &&
-    method.asMethod.returnType <:< targetType &&
-    method.asMethod.name.decodedName.toString == "apply"
+      method.isPublic &&
+      method.asMethod.returnType <:< targetType &&
+      method.asMethod.name.decodedName.toString == "apply"
 
   private def companionType[C <: blackbox.Context](c: C)(targetType: c.Type): Option[c.Type] = {
     import c.universe._
 
-    if(targetType.companion == NoType) None else Some(targetType.companion)
-  }
-
-  private def applies[C <: blackbox.Context](c: C, log: Logger)(targetType: c.Type): Option[List[c.Symbol]] = log.withBlock("Looking for apply methods of Companion Object") {
-    val as: Option[List[c.Symbol]] = companionType(c)(targetType).map(_.members.filter(CompanionCrimper.isCompanionApply(c)(targetType, _)).toList)
-    as.foreach(x => log.withBlock(s"There are ${x.size} apply methods:" ) { x.foreach(s => log(showApply(c)(s))) })
-    as
+    if (targetType.companion == NoType) None else Some(targetType.companion)
   }
 
-  def applyTree[C <: blackbox.Context](c: C, log: Logger)(targetType: c.Type, resolver: (c.Symbol, c.Type) => c.Tree): Option[c.Tree] = {
+  private def applies[C <: blackbox.Context](c: C, log: Logger)(targetType: c.Type): Option[List[c.Symbol]] =
+    log.withBlock("Looking for apply methods of Companion Object") {
+      val as: Option[List[c.Symbol]] =
+        companionType(c)(targetType).map(_.members.filter(CompanionCrimper.isCompanionApply(c)(targetType, _)).toList)
+      as.foreach(x => log.withBlock(s"There are ${x.size} apply methods:") { x.foreach(s => log(showApply(c)(s))) })
+      as
+    }
+
+  def applyTree[C <: blackbox.Context](
+      c: C,
+      log: Logger
+  )(targetType: c.Type, resolver: (c.Symbol, c.Type) => c.Tree): Option[c.Tree] = {
     import c.universe._
 
-    lazy val apply: Option[Symbol] = CompanionCrimper.applies(c, log)(targetType).flatMap( _ match {
-      case applyMethod :: Nil => Some(applyMethod)
-      case _ => None
-    })
+    lazy val apply: Option[Symbol] = CompanionCrimper
+      .applies(c, log)(targetType)
+      .flatMap(_ match {
+        case applyMethod :: Nil => Some(applyMethod)
+        case _                  => None
+      })
 
     lazy val applySelect: Option[Select] = apply.map(a => Select(Ident(targetType.typeSymbol.companion), a))
 
     lazy val applyParamLists: Option[List[List[Symbol]]] = apply.map(_.asMethod.paramLists)
 
-    def wireParams(paramLists: List[List[Symbol]]): List[List[Tree]] = paramLists.map(_.map(p => resolver(p, p.typeSignature)))
+    def wireParams(paramLists: List[List[Symbol]]): List[List[Tree]] =
+      paramLists.map(_.map(p => resolver(p, p.typeSignature)))
 
     def applyArgs: Option[List[List[Tree]]] = applyParamLists.map(x => wireParams(x))
 

macros/src/main/scala-2/com/softwaremill/macwire/internals/ConstructorCrimper.scala

@@ -44,22 +44,22 @@ object ConstructorCrimper {
   private def constructor[C <: blackbox.Context](c: C, log: Logger)(targetType: c.Type) = {
     import c.universe._
 
-    /** In some cases there is one extra (phantom) constructor.
-      * This happens when extended trait has implicit param:
+    /** In some cases there is one extra (phantom) constructor. This happens when extended trait has implicit param:
       *
       * {{{
       *   trait A { implicit val a = ??? };
       *   class X extends A
       *   import scala.reflect.runtime.universe._
       *   typeOf[X].members.filter(m => m.isMethod && m.asMethod.isConstructor && m.asMethod.isPrimaryConstructor).map(_.asMethod.fullName)
       *
-      *  //res1: Iterable[String] = List(X.<init>, A.$init$)
-      *  }}}
+      *   //res1: Iterable[String] = List(X.<init>, A.$init$)
+      * }}}
       *
-      *  The {{{A.$init$}}} is the phantom constructor and we don't want it.
+      * The {{{A.$init$}}} is the phantom constructor and we don't want it.
       *
-      *  In other words, if we don't filter such constructor using this function
-      *  'wireActor-12-noPublicConstructor.failure' will compile and throw exception during runtime but we want to fail it during compilation time.
+      * In other words, if we don't filter such constructor using this function
+      * 'wireActor-12-noPublicConstructor.failure' will compile and throw exception during runtime but we want to fail
+      * it during compilation time.
       */
     def isPhantomConstructor(constructor: Symbol): Boolean = constructor.asMethod.fullName.endsWith("$init$")
 

macros/src/main/scala-2/com/softwaremill/macwire/internals/DependencyResolver.scala

@@ -4,40 +4,47 @@ import com.softwaremill.macwire.internals.EligibleValuesFinder.Scope.LocalForwar
 
 import scala.reflect.macros.blackbox
 
-class DependencyResolver[C <: blackbox.Context, TypeC <: C#Type, TreeC <: C#Tree](val c: C, debug: Logger)(resolutionFallback: TypeC => TreeC) {
+class DependencyResolver[C <: blackbox.Context, TypeC <: C#Type, TreeC <: C#Tree](val c: C, debug: Logger)(
+    resolutionFallback: TypeC => TreeC
+) {
 
   import c.universe._
 
   private val eligibleValuesFinder = new EligibleValuesFinder[c.type](c, debug)
 
   private lazy val eligibleValues = eligibleValuesFinder.find()
 
-  /** Look for a single instance of type `t`.
-    * If either no instance or multiple instances are found,
-    * a compilation error is reported and `None` is returned.
+  /** Look for a single instance of type `t`. If either no instance or multiple instances are found, a compilation error
+    * is reported and `None` is returned.
     */
   def resolve(param: Symbol, t: Type): Tree = {
     eligibleValues.findInFirstScope(t).toList match {
       case Nil => resolutionFallback(t.asInstanceOf[TypeC]).asInstanceOf[Tree]
       case value :: Nil =>
         val forwardValues = eligibleValues.findInScope(t, LocalForward)
         if (forwardValues.nonEmpty) {
-          c.warning(c.enclosingPosition, s"Found [$value] for parameter [${param.name}], " +
-            s"but a forward reference [${forwardValues.mkString(", ")}] was also eligible")
+          c.warning(
+            c.enclosingPosition,
+            s"Found [$value] for parameter [${param.name}], " +
+              s"but a forward reference [${forwardValues.mkString(", ")}] was also eligible"
+          )
         }
         value
       case values => c.abort(c.enclosingPosition, s"Found multiple values of type [$t]: [$values]")
     }
   }
 
-  /** @return all the instances of type `t` that are accessible.
+  /** @return
+    *   all the instances of type `t` that are accessible.
     */
   def resolveAll(t: Type): Iterable[Tree] = {
     eligibleValues.findInAllScope(t)
   }
 }
 
 object DependencyResolver {
-  def throwErrorOnResolutionFailure[C <: blackbox.Context, TypeC <: C#Type, TreeC <: C#Tree](c: C, debug: Logger)  =
-    new DependencyResolver[C, TypeC, TreeC](c, debug)(t => c.abort(c.enclosingPosition, s"Cannot find a value of type: [$t]"))
-}
+  def throwErrorOnResolutionFailure[C <: blackbox.Context, TypeC <: C#Type, TreeC <: C#Tree](c: C, debug: Logger) =
+    new DependencyResolver[C, TypeC, TreeC](c, debug)(t =>
+      c.abort(c.enclosingPosition, s"Cannot find a value of type: [$t]")
+    )
+}