Merge pull request tofu-tf#286 from zawodskoj/refinements

Add support for deriving typeclasses with refinements

Author: Odomontois

core/src/main/scala/derevo/Derevo.scala

@@ -10,9 +10,10 @@ class Derevo(val c: blackbox.Context) {
   type Newtype      = NewtypeP[Tree]
   type NameAndTypes = NameAndTypesP[c.Type]
 
-  val DelegatingSymbol   = typeOf[delegating].typeSymbol
-  val PhantomSymbol      = typeOf[phantom].typeSymbol
-  val PassTypeArgsSymbol = typeOf[PassTypeArgs].typeSymbol
+  val DelegatingSymbol      = typeOf[delegating].typeSymbol
+  val PhantomSymbol         = typeOf[phantom].typeSymbol
+  val PassTypeArgsSymbol    = typeOf[PassTypeArgs].typeSymbol
+  val KeepRefinementsSymbol = typeOf[KeepRefinements].typeSymbol
 
   val instanceDefs         = Vector(
   )
@@ -179,9 +180,9 @@ class Derevo(val c: blackbox.Context) {
     }
 
     val (mode, call) = tree match {
-      case q"$obj(..$args)" => (nameAndTypes(obj), tree)
+      case q"$obj.$method(..$args)" => (nameAndTypes(obj), tree)
 
-      case q"$obj.$method($args)" => (nameAndTypes(obj), tree)
+      case q"$obj(..$args)" => (nameAndTypes(obj), tree)
 
       case q"$obj" =>
         val call = newType.fold(q"$obj.instance")(t => q"$obj.newtype[${t.underlying}].instance")
@@ -207,14 +208,33 @@ class Derevo(val c: blackbox.Context) {
 
     val callWithT = if (mode.passArgs) q"$call[$outTyp]" else call
 
+    def fixFirstTypeParam = {
+      val nothingT = c.typeOf[Nothing]
+
+      c.typecheck(call, silent = true) match {
+        case q"$method[$nothing, ..$remainingTpes](..$args)" if nothing.tpe == nothingT =>
+          q"$method[$outTyp, ..$remainingTpes](..$args)"
+        case q"$method[$nothing, ..$remainingTpes]" if nothing.tpe == nothingT          =>
+          q"$method[$outTyp, ..$remainingTpes]"
+        case _                                                                          => tree
+      }
+    }
+
     if (allTparams.isEmpty || allTparams.length <= mode.drop) {
-      val resTc = if (newType.isDefined) mode.newtype else mode.to
-      val resT  = mkAppliedType(resTc, tq"$typRef")
+      if (mode.keepRefinements) {
+        q"""
+        @java.lang.SuppressWarnings(scala.Array("org.wartremover.warts.All", "scalafix:All", "all"))
+        implicit val $tn = $fixFirstTypeParam
+        """
+      } else {
+        val resTc = if (newType.isDefined) mode.newtype else mode.to
+        val resT  = mkAppliedType(resTc, tq"$typRef")
 
-      q"""
-      @java.lang.SuppressWarnings(scala.Array("org.wartremover.warts.All", "scalafix:All", "all"))
-      implicit val $tn: $resT = $callWithT
-      """
+        q"""
+        @java.lang.SuppressWarnings(scala.Array("org.wartremover.warts.All", "scalafix:All", "all"))
+        implicit val $tn: $resT = $callWithT
+        """
+      }
     } else {
 
       val implicits =
@@ -231,10 +251,17 @@ class Derevo(val c: blackbox.Context) {
           }
         else Nil
 
-      q"""
-      @java.lang.SuppressWarnings(scala.Array("org.wartremover.warts.All", "scalafix:All", "all"))
-      implicit def $tn[..$tparams](implicit ..$implicits): $resT = $callWithT
-      """
+      if (mode.keepRefinements) {
+        q"""
+        @java.lang.SuppressWarnings(scala.Array("org.wartremover.warts.All", "scalafix:All", "all"))
+        implicit def $tn[..$tparams](implicit ..$implicits) = $fixFirstTypeParam
+        """
+      } else {
+        q"""
+        @java.lang.SuppressWarnings(scala.Array("org.wartremover.warts.All", "scalafix:All", "all"))
+        implicit def $tn[..$tparams](implicit ..$implicits): $resT = $callWithT
+        """
+      }
     }
   }
 
@@ -266,7 +293,12 @@ class Derevo(val c: blackbox.Context) {
       case _                => false
     }
 
-    nt.copy(passArgs = passArgs)
+    val keepRefinements = objTyp.baseType(KeepRefinementsSymbol) match {
+      case TypeRef(_, _, _) => true
+      case _                => false
+    }
+
+    nt.copy(passArgs = passArgs, keepRefinements = keepRefinements)
   }
 
   trait DerivationMatcher {
@@ -319,6 +351,7 @@ object Derevo {
       newtype: typ,
       drop: Int,
       cascade: Boolean,
+      keepRefinements: Boolean = false,
       passArgs: Boolean = false,
   )
 }

core/src/main/scala/derevo/package.scala

@@ -8,6 +8,7 @@ package derevo {
   /**
     */
   trait PassTypeArgs
+  trait KeepRefinements
 
   class delegating(to: String, args: Any*) extends StaticAnnotation
   class phantom                            extends StaticAnnotation

tests/src/main/scala/derevo/tests/Refinement.scala

@@ -0,0 +1,27 @@
+package derevo.tests
+
+import derevo._
+
+trait Trait[T]
+
+object refinedTrait extends Derivation[Trait] with KeepRefinements {
+  def apply[T, A](a: A): Trait[T] { type Refinement = A } = new Trait[T] { type Refinement = A }
+  def singleTparam[T](dummy: Int): Trait[T] { type Refinement = String } = new Trait[T] { type Refinement = String }
+}
+
+object refinedTraitWithInstanceMethod extends Derivation[Trait] with KeepRefinements {
+  def instance[T]: Trait[T] { type Refinement = String } = new Trait[T] { type Refinement = String }
+}
+
+object Test {
+  @derive(refinedTrait("123")) case class Foo()
+  @derive(refinedTrait.singleTparam(123)) case class Bar()
+  @derive(refinedTraitWithInstanceMethod) case class Baz()
+  @derive(refinedTrait(123)) case class PolymorphicFoo[@phantom Arg](arg: Arg)
+
+  val nonRefined: Trait[Foo] = implicitly
+  val refinedFoo: Trait[Foo] { type Refinement = String } = implicitly
+  val refinedBar: Trait[Bar] { type Refinement = String } = implicitly
+  val refinedBaz: Trait[Baz] { type Refinement = String } = implicitly
+  val refinedPolymorphic: Trait[PolymorphicFoo[Foo]] { type Refinement = Int } = implicitly
+}