Implement wireResource for scala 2

README.md

@@ -209,6 +209,53 @@ trait UserModule {
 
 This feature is inspired by @yakivy's work on [jam](https://github.com/yakivy/jam).
 
+## Auto wiring
+
+In case you need to build an instance from some particular instances and factory methods it's recommended to use `autowire`. This feature is intended to interpolate with fp libraries (currently we support `cats`).
+
+`autowire` takes as an argument a list which may contain:
+* values (e.g. `new A()`)
+* factory methods (e.g. `C.create _`)
+* cats.effect.Resource (e.g. `cats.effect.Resource[IO].pure(new A())`)
+* cats.effect.IO (e.g. `cats.effect.IO.pure(new A())`)
+Based on the given list it creates a set of available instances and performs `wireRec` bypassing the instances search phase. The result of the wiring is always wrapped in `cats.effect.Resource`. For example:
+
+```Scala
+import cats.effect._
+
+class DatabaseAccess()
+
+class SecurityFilter private (databaseAccess: DatabaseAccess)
+object SecurityFilter {
+ def apply(databaseAccess: DatabaseAccess): SecurityFilter = new SecurityFilter(databaseAccess)
+}
+
+class UserFinder(databaseAccess: DatabaseAccess, securityFilter: SecurityFilter)
+class UserStatusReader(databaseAccess: DatabaseAccess, userFinder: UserFinder)
+
+object UserModule {
+ import com.softwaremill.macwire._
+
+ val theDatabaseAccess: Resource[IO, DatabaseAccess] = Resource.pure(new DatabaseAccess())
+
+ val theUserStatusReader: Resource[IO, UserStatusReader] = autowire[UserStatusReader](theDatabaseAccess)
+}
+```
+
+will generate
+```Scala
+[...]
+object UserModule {
+ import com.softwaremill.macwire._
+
+ val theDatabaseAccess: Resource[IO, DatabaseAccess] = Resource.pure(new DatabaseAccess())
+
+ val theUserStatusReader: Resource[IO, UserStatusReader] = UserModule.this.theDatabaseAccess.flatMap(
+ da => Resource.pure[IO, UserStatusReader](new UserStatusReader(da, new UserFinder(da, SecurityFilter.apply(da))))
+ )
+}
+```
+
 ## Composing modules
 
 Modules (traits or classes containing parts of the object graph) can be combined using inheritance or composition.

build.sbt

@@ -64,6 +64,8 @@ val scalatest = "org.scalatest" %% "scalatest" % "3.2.9"
 val javassist = "org.javassist" % "javassist" % "3.28.0-GA"
 val akkaActor = "com.typesafe.akka" %% "akka-actor" % "2.6.15"
 val javaxInject = "javax.inject" % "javax.inject" % "1"
+val cats = "org.typelevel" %% "cats-core" % "2.6.1"
+val catsEffect = "org.typelevel" %% "cats-effect" % "3.2.1"
 
 lazy val root = project
  .in(file("."))
@@ -79,7 +81,9 @@ lazy val root = project
  testUtil,
  utilTests,
  macrosAkka,
- macrosAkkaTests
+ macrosAkkaTests,
+ macrosAutoCats,
+ macrosAutoCatsTests
  ).flatMap(_.projectRefs): _*
  )
 
@@ -167,6 +171,21 @@ lazy val macrosAkkaTests = projectMatrix
  .dependsOn(macrosAkka, testUtil)
  .jvmPlatform(scalaVersions = scala2)
 
+ 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
+ .in(file("macrosAutoCatsTests"))
+ .settings(testSettings)
+ .settings(libraryDependencies ++= Seq(scalatest, catsEffect, tagging))
+ .dependsOn(macrosAutoCats, testUtil)
+ .jvmPlatform(scalaVersions = scala2)
+
 Compile / compile := {
  // Enabling debug project-wide. Can't find a better way to pass options to scalac.
  System.setProperty("macwire.debug", "")

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

@@ -2,45 +2,62 @@ package com.softwaremill.macwire.internals
 
 import scala.reflect.macros.blackbox
 
-private[macwire] class CompanionCrimper [C <: blackbox.Context, T: C#WeakTypeTag](val c: C, log: Logger) {
+private[macwire] class CompanionCrimper[C <: blackbox.Context, T: C#WeakTypeTag](val c: C, log: Logger) {
  import c.universe._
 
  type DependencyResolverType = DependencyResolver[c.type, Type, Tree]
 
  lazy val targetType: Type = implicitly[c.WeakTypeTag[T]].tpe
 
- lazy val companionType: Option[Type] = if(targetType.companion == NoType) None else Some(targetType.companion)
+ lazy val companionType: Option[Type] = CompanionCrimper.companionType(c)(targetType)
 
- def isCompanionApply(method: Symbol): Boolean =
+ 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(_, _))
+
+}
+
+object CompanionCrimper {
+ private def showApply[C <: blackbox.Context](c: C)(s: c.Symbol): String = s.asMethod.typeSignature.toString
+
+ 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"
 
- lazy val applies: Option[List[Symbol]] = log.withBlock("Looking for apply methods of Companion Object") {
- val as: Option[List[Symbol]] = companionType.map(_.members.filter(isCompanionApply).toList)
- as.foreach(x => log.withBlock(s"There are ${x.size} apply methods:" ) { x.foreach(c => log(showApply(c))) })
+ 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
  }
 
- lazy val apply: Option[Symbol] = applies.flatMap( _ match {
- case applyMethod :: Nil => Some(applyMethod)
- case _ => None
- })
+ 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 applySelect: Option[Select] = apply.map(a => Select(Ident(targetType.typeSymbol.companion), a))
+ lazy val apply: Option[Symbol] = CompanionCrimper.applies(c, log)(targetType).flatMap( _ match {
+ case applyMethod :: Nil => Some(applyMethod)
+ case _ => None
+ })
 
- lazy val applyParamLists: Option[List[List[Symbol]]] = apply.map(_.asMethod.paramLists)
+  lazy val applySelect: Option[Select] = apply.map(a => Select(Ident(targetType.typeSymbol.companion), a))
 
- def wireParams(dependencyResolver: DependencyResolverType)(paramLists: List[List[Symbol]]): List[List[Tree]] = paramLists.map(_.map(p => dependencyResolver.resolve(p, p.typeSignature)))
+  lazy val applyParamLists: Option[List[List[Symbol]]] = apply.map(_.asMethod.paramLists)
 
- def applyArgs(dependencyResolver: DependencyResolverType): Option[List[List[Tree]]] = applyParamLists.map(wireParams(dependencyResolver))
+  def wireParams(paramLists: List[List[Symbol]]): List[List[Tree]] = paramLists.map(_.map(p => resolver(p, p.typeSignature)))
 
- def applyTree(dependencyResolver: DependencyResolverType): Option[Tree] = for {
- pl: List[List[Tree]] <- applyArgs(dependencyResolver)
- applyMethod: Tree <- applySelect
- } yield pl.foldLeft(applyMethod)((acc: Tree, args: List[Tree]) => Apply(acc, args))
+ def applyArgs: Option[List[List[Tree]]] = applyParamLists.map(x => wireParams(x))
 
- def showApply(c: Symbol): String = c.asMethod.typeSignature.toString
-}
+ for {
+ pl: List[List[Tree]] <- applyArgs
+ applyMethod: Tree <- applySelect
+ } yield pl.foldLeft(applyMethod)((acc: Tree, args: List[Tree]) => Apply(acc, args))
+ }
 
+}

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

@@ -2,98 +2,139 @@ package com.softwaremill.macwire.internals
 
 import scala.reflect.macros.blackbox
 
-private[macwire] class ConstructorCrimper[C <: blackbox.Context, T: C#WeakTypeTag] (val c: C, log: Logger) {
+private[macwire] class ConstructorCrimper[C <: blackbox.Context, T: C#WeakTypeTag](val c: C, log: Logger) {
  import c.universe._
 
  type DependencyResolverType = DependencyResolver[c.type, Type, Tree]
 
- lazy val typeCheckUtil = new TypeCheckUtil[c.type](c, log)
-
  lazy val targetType: Type = implicitly[c.WeakTypeTag[T]].tpe
 
  // We need to get the "real" type in case the type parameter is a type alias - then it cannot
  // be directly instantiated
  lazy val targetTypeD: Type = targetType.dealias
 
- lazy val classOfT: c.Expr[Class[T]] = c.Expr[Class[T]](q"classOf[$targetType]")
+ lazy val constructor: Option[Symbol] = ConstructorCrimper.constructor(c, log)(targetType)
 
- lazy val publicConstructors: Iterable[Symbol] = {
- val ctors = targetType.members
- .filter(m => m.isMethod && m.asMethod.isConstructor && m.isPublic)
- .filterNot(isPhantomConstructor)
- log.withBlock(s"There are ${ctors.size} eligible constructors" ) { ctors.foreach(c => log(showConstructor(c))) }
- ctors
- }
+ def constructorArgsWithImplicitLookups(dependencyResolver: DependencyResolverType): Option[List[List[Tree]]] =
+ log.withBlock("Looking for targetConstructor arguments with implicit lookups") {
+ constructor.map(_.asMethod.paramLists).map(wireConstructorParamsWithImplicitLookups(dependencyResolver))
+ }
 
- lazy val primaryConstructor: Option[Symbol] = publicConstructors.find(_.asMethod.isPrimaryConstructor)
+ def constructorTree(dependencyResolver: DependencyResolverType): Option[Tree] =
+ ConstructorCrimper.constructorTree(c, log)(targetType, dependencyResolver.resolve(_, _))
 
- lazy val injectConstructors: Iterable[Symbol] = {
- val isInjectAnnotation = (a: Annotation) => a.toString == "javax.inject.Inject"
- val ctors = publicConstructors.filter(_.annotations.exists(isInjectAnnotation))
- log.withBlock(s"There are ${ctors.size} constructors annotated with @javax.inject.Inject" ) { ctors.foreach(c => log(showConstructor(c))) }
- ctors
- }
+ def wireConstructorParams(
+ dependencyResolver: DependencyResolverType
+ )(paramLists: List[List[Symbol]]): List[List[Tree]] = paramLists.map(
+ _.map(p => dependencyResolver.resolve(p, /*SI-4751*/ ConstructorCrimper.paramType(c)(targetTypeD, p)))
+ )
 
- lazy val injectConstructor: Option[Symbol] = if(injectConstructors.size > 1) abort(s"Ambiguous constructors annotated with @javax.inject.Inject for type [$targetType]") else injectConstructors.headOption
+ def wireConstructorParamsWithImplicitLookups(
+ dependencyResolver: DependencyResolverType
+ )(paramLists: List[List[Symbol]]): List[List[Tree]] = paramLists.map(_.map {
+ case i if i.isImplicit => q"implicitly[${ConstructorCrimper.paramType(c)(targetType, i)}]"
+ case p => dependencyResolver.resolve(p, /*SI-4751*/ ConstructorCrimper.paramType(c)(targetTypeD, p))
+ })
 
- lazy val constructor: Option[Symbol] = log.withBlock(s"Looking for constructor for $targetType"){
- val ctor = injectConstructor orElse primaryConstructor
- ctor.foreach(ctor => log(s"Found ${showConstructor(ctor)}"))
- ctor
- }
+}
 
- lazy val constructorParamLists: Option[List[List[Symbol]]] = constructor.map(_.asMethod.paramLists.filterNot(_.headOption.exists(_.isImplicit)))
+object ConstructorCrimper {
+ def showConstructor[C <: blackbox.Context](c: C)(s: c.Symbol): String = s.asMethod.typeSignature.toString
+
+ 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:
+ *
+ * {{{
+ * 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$)
+ * }}}
+ *
+ * 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.
+ */
+ def isPhantomConstructor(constructor: Symbol): Boolean = constructor.asMethod.fullName.endsWith("$init$")
+
+ lazy val publicConstructors: Iterable[Symbol] = {
+ val ctors = targetType.members
+ .filter(m => m.isMethod && m.asMethod.isConstructor && m.isPublic)
+ .filterNot(isPhantomConstructor)
+ log.withBlock(s"There are ${ctors.size} eligible constructors") { ctors.foreach(s => log(showConstructor(c)(s))) }
+ ctors
+ }
 
- def constructorArgs(dependencyResolver: DependencyResolverType): Option[List[List[Tree]]] = log.withBlock("Looking for targetConstructor arguments") {
- constructorParamLists.map(wireConstructorParams(dependencyResolver))
- }
+ lazy val primaryConstructor: Option[Symbol] = publicConstructors.find(_.asMethod.isPrimaryConstructor)
 
- def constructorArgsWithImplicitLookups(dependencyResolver: DependencyResolverType): Option[List[List[Tree]]] = log.withBlock("Looking for targetConstructor arguments with implicit lookups") {
- constructor.map(_.asMethod.paramLists).map(wireConstructorParamsWithImplicitLookups(dependencyResolver))
- }
+ lazy val injectConstructors: Iterable[Symbol] = {
+ val isInjectAnnotation = (a: Annotation) => a.toString == "javax.inject.Inject"
+ val ctors = publicConstructors.filter(_.annotations.exists(isInjectAnnotation))
+ log.withBlock(s"There are ${ctors.size} constructors annotated with @javax.inject.Inject") {
+ ctors.foreach(s => log(showConstructor(c)(s)))
+ }
+ ctors
+ }
 
- def constructorTree(dependencyResolver: DependencyResolverType): Option[Tree] = log.withBlock(s"Creating Constructor Tree for $targetType"){
- val constructionMethodTree: Tree = Select(New(Ident(targetTypeD.typeSymbol)), termNames.CONSTRUCTOR)
- constructorArgs(dependencyResolver).map(_.foldLeft(constructionMethodTree)((acc: Tree, args: List[Tree]) => Apply(acc, args)))
+ lazy val injectConstructor: Option[Symbol] =
+ if (injectConstructors.size > 1)
+ c.abort(
+ c.enclosingPosition,
+ s"Ambiguous constructors annotated with @javax.inject.Inject for type [$targetType]"
+ )
+ else injectConstructors.headOption
+
+ log.withBlock(s"Looking for constructor for $targetType") {
+ val ctor = injectConstructor orElse primaryConstructor
+ ctor.foreach(ctor => log(s"Found ${showConstructor(c)(ctor)}"))
+ ctor
+ }
  }
 
- def wireConstructorParams(dependencyResolver: DependencyResolverType)(paramLists: List[List[Symbol]]): List[List[Tree]] = paramLists.map(_.map(p => dependencyResolver.resolve(p, /*SI-4751*/paramType(p))))
+ private def paramType[C <: blackbox.Context](c: C)(targetTypeD: c.Type, param: c.Symbol): c.Type = {
+ import c.universe._
 
- def wireConstructorParamsWithImplicitLookups(dependencyResolver: DependencyResolverType)(paramLists: List[List[Symbol]]): List[List[Tree]] = paramLists.map(_.map {
- case i if i.isImplicit => q"implicitly[${paramType(i)}]"
- case p => dependencyResolver.resolve(p, /*SI-4751*/ paramType(p))
- })
-
- private def paramType(param: Symbol): Type = {
  val (sym: Symbol, tpeArgs: List[Type]) = targetTypeD match {
  case TypeRef(_, sym, tpeArgs) => (sym, tpeArgs)
- case t => abort(s"Target type not supported for wiring: $t. Please file a bug report with your use-case.")
+ case t =>
+ c.abort(
+ c.enclosingPosition,
+ s"Target type not supported for wiring: $t. Please file a bug report with your use-case."
+ )
  }
  val pTpe = param.typeSignature.substituteTypes(sym.asClass.typeParams, tpeArgs)
  if (param.asTerm.isByNameParam) pTpe.typeArgs.head else pTpe
  }
 
- /**
- * 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$)
- * }}}
- *
- * 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.
- */
- def isPhantomConstructor(constructor: Symbol): Boolean = constructor.asMethod.fullName.endsWith("$init$")
-
- def showConstructor(c: Symbol): String = c.asMethod.typeSignature.toString
-
- def abort(msg: String): Nothing = c.abort(c.enclosingPosition, msg)
+ def constructorTree[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 targetTypeD: Type = targetType.dealias
+
+ lazy val constructor: Option[Symbol] = ConstructorCrimper.constructor(c, log)(targetType)
+
+ lazy val constructorParamLists: Option[List[List[Symbol]]] =
+ constructor.map(_.asMethod.paramLists.filterNot(_.headOption.exists(_.isImplicit)))
+
+ def constructorArgs: Option[List[List[Tree]]] = log.withBlock("Looking for targetConstructor arguments") {
+ constructorParamLists.map(wireConstructorParams(_))
+ }
+
+ def wireConstructorParams(paramLists: List[List[Symbol]]): List[List[Tree]] =
+ paramLists.map(_.map(p => resolver(p, /*SI-4751*/ paramType(c)(targetTypeD, p))))
+
+ log.withBlock(s"Creating Constructor Tree for $targetType") {
+ val constructionMethodTree: Tree = Select(New(Ident(targetTypeD.typeSymbol)), termNames.CONSTRUCTOR)
+ constructorArgs.map(_.foldLeft(constructionMethodTree)((acc: Tree, args: List[Tree]) => Apply(acc, args)))
+ }
+ }
 }