fix issue 26

Author: arainko

build.sbt

@@ -36,9 +36,9 @@ lazy val ducktape =
   project
     .in(file("ducktape"))
     .settings(
-      scalacOptions ++= List("-Xcheck-macros", "-no-indent", "-old-syntax", "-Xfatal-warnings", "-deprecation", "-explain"),
+      scalacOptions ++= List("-Xcheck-macros", "-no-indent", "-old-syntax", "-Xfatal-warnings", "-deprecation"),
       libraryDependencies += "org.scalameta" %% "munit" % "1.0.0-M7" % Test,
-      mimaPreviousArtifacts := Set("io.github.arainko" %% "ducktape" % "0.1.0")
+      mimaPreviousArtifacts := Set("io.github.arainko" %% "ducktape" % "0.1.0", "io.github.arainko" %% "ducktape" % "0.1.1")
     )
 
 lazy val docs =

docs/readme.md

@@ -23,7 +23,7 @@ final case class PersonButMoreFields(firstName: String, lastName: String, age: I
 
 val personWithMoreFields = PersonButMoreFields("John", "Doe", 30, "SOCIAL-NUM-12345")
 
-val transformed = personWithMoreFields.transformInto[Person]
+val transformed = personWithMoreFields.to[Person]
 
 ```
 
@@ -34,7 +34,7 @@ If these requirements are not met, a compiletime error is issued:
 ```scala mdoc:fail
 val person = Person("Jerry", "Smith", 20)
 
-person.transformInto[PersonButMoreFields]
+person.to[PersonButMoreFields]
 
 ```
 
@@ -49,14 +49,14 @@ enum Size:
 enum ExtraSize:
   case ExtraSmall, Small, Medium, Large, ExtraLarge
 
-val transformed = Size.Small.transformInto[ExtraSize]
+val transformed = Size.Small.to[ExtraSize]
 // transformed: ExtraSize = Small
 ```
 
 We can't go to a coproduct that doesn't contain all of our cases (name wise):
 
 ```scala
-val size = ExtraSize.Small.transformInto[Size]
+val size = ExtraSize.Small.to[Size]
 // error:
 // No child named 'ExtraSmall' in Size
 ```
@@ -234,9 +234,9 @@ final case class WrappedString(value: String) extends AnyVal
 
 val wrapped = WrappedString("I am a String")
 
-val unwrapped = wrapped.transformInto[String]
+val unwrapped = wrapped.to[String]
 
-val wrappedAgain = unwrapped.transformInto[WrappedString]
+val wrappedAgain = unwrapped.to[WrappedString]
 ```
 
 #### 8. Defining custom `Transformers`
@@ -301,16 +301,16 @@ case class EvenMoreInside2(str: String, int: Int)
 
 val person = Person(23, Some("str"), Inside("insideStr", 24, EvenMoreInside("evenMoreInsideStr", 25)), Vector.empty)
 ```
-#### Generated code - expansion of `.transformInto`
-Calling the `.transformInto` method
+#### Generated code - expansion of `.to`
+Calling the `.to` method
 ```scala mdoc:silent
-person.transformInto[Person2]
+person.to[Person2]
 ```
 expands to:
 ```scala mdoc:passthrough
 import io.github.arainko.ducktape.docs.*
 
-Docs.printCode(person.transformInto[Person2])
+Docs.printCode(person.to[Person2])
 ```
 
 #### Generated code - expansion of `.into`

ducktape/src/main/scala/io/github/arainko/ducktape/internal/macros/ProductTransformerMacros.scala

@@ -157,19 +157,23 @@ private[ducktape] final class ProductTransformerMacros(using val quotes: Quotes)
 
   private def resolveTransformation[Source: Type](sourceValue: Expr[Source], source: Field, destination: Field)(using Quotes) =
     source.transformerTo(destination) match {
+      // even though this is taken care of in LiftTransformation.liftTransformation
+      // we need to do this here due to a compiler bug where multiple matches on a
+      // Transformer[A, B >: A] the B type get replaced with `B | dest` but only if
+      // you refer to a case class defined in an object by NOT its full path (it works if you refer to it as the full path)
+      // workaround for issue: https://github.com/arainko/ducktape/issues/26 until this gets fixed in dotty.
+      case '{
+            type a
+            $transformer: Transformer.Identity[`a`, `a`]
+          } =>
+        accessField(sourceValue, source.name)
       case '{ $transformer: Transformer[source, dest] } =>
         val field = accessField(sourceValue, source.name).asExprOf[source]
-        // println()
-        // println(Type.show[dest])
-        // println(field.asTerm.tpe.widen.show)
-        // '{ $transformer.transform($field) }.asTerm
         LiftTransformation.liftTransformation(transformer, field).asTerm
     }
 
   private def accessField(value: Expr[Any], fieldName: String)(using Quotes) = Select.unique(value.asTerm, fieldName)
 
-  // Select.unique()
-
   private def constructor(tpe: TypeRepr)(using Quotes): Term = {
     val (repr, constructor, tpeArgs) = tpe match {
       case AppliedType(repr, reprArguments) => (repr, repr.typeSymbol.primaryConstructor, reprArguments)

ducktape/src/main/scala/io/github/arainko/ducktape/syntax.scala

@@ -10,10 +10,10 @@ import scala.deriving.Mirror
 extension [Source](value: Source) {
   def into[Dest]: AppliedBuilder[Source, Dest] = AppliedBuilder(value)
 
-  inline def transformInto[Dest](using inline transformer: Transformer[Source, Dest]) =
-    ${ LiftTransformation.liftTransformation('transformer, 'value) }
+  // TODO: Introduce in ducktape 0.2 as a replacement for `.to`, this will break binary compat
+  // inline def transformInto[Dest](using inline transformer: Transformer[Source, Dest]) =
+  //   ${ LiftTransformation.liftTransformation('transformer, 'value) }
 
-  // @deprecated(message = "Use '.transformInto' instead, it includes some additional optimizations", since = "0.1.2")
   def to[Dest](using Transformer[Source, Dest]): Dest = Transformer[Source, Dest].transform(value)
 
   transparent inline def intoVia[Func](inline function: Func)(using Mirror.ProductOf[Source], FunctionMirror[Func]) =

ducktape/src/test/scala/io/github/arainko/ducktape/derivation/DerivedTransformerSuite.scala

@@ -61,7 +61,7 @@ class DerivedTransformerSuite extends DucktapeSuite {
 
     val actualComplex =
       List(
-        expectedPrimitive.transformInto[ComplexPerson],
+        expectedPrimitive.to[ComplexPerson],
         expectedPrimitive.into[ComplexPerson].transform(),
         expectedPrimitive.via(ComplexPerson.apply),
         expectedPrimitive.intoVia(ComplexPerson.apply).transform(),
@@ -71,7 +71,7 @@ class DerivedTransformerSuite extends DucktapeSuite {
 
     val actualPrimitive =
       List(
-        expectedComplex.transformInto[PrimitivePerson],
+        expectedComplex.to[PrimitivePerson],
         expectedComplex.into[PrimitivePerson].transform(),
         expectedComplex.via(PrimitivePerson.apply),
         expectedComplex.intoVia(PrimitivePerson.apply).transform(),
@@ -105,7 +105,7 @@ class DerivedTransformerSuite extends DucktapeSuite {
 
     val actualComplex =
       List(
-        primitive.transformInto[ComplexPerson],
+        primitive.to[ComplexPerson],
         primitive.into[ComplexPerson].transform(),
         primitive.via(ComplexPerson.apply),
         primitive.intoVia(ComplexPerson.apply).transform(),
@@ -126,12 +126,12 @@ class DerivedTransformerSuite extends DucktapeSuite {
     val expectedFromEnum2Mapping = expectedFromEnum1Mapping.map(_.swap)
 
     Enum1.values.foreach { value =>
-      val actual = value.transformInto[Enum2]
+      val actual = value.to[Enum2]
       assertEquals(expectedFromEnum1Mapping(value), actual)
     }
 
     Enum2.values.foreach { value =>
-      val actual = value.transformInto[Enum1]
+      val actual = value.to[Enum1]
       assertEquals(expectedFromEnum2Mapping(value), actual)
     }
   }
@@ -144,7 +144,7 @@ class DerivedTransformerSuite extends DucktapeSuite {
     val expected = LessFields(1, 2, 3)
     val actual =
       List(
-        more.transformInto[LessFields],
+        more.to[LessFields],
         more.into[LessFields].transform(),
         more.via(LessFields.apply),
         more.intoVia(LessFields.apply).transform(),
@@ -170,7 +170,7 @@ class DerivedTransformerSuite extends DucktapeSuite {
 
     val actual =
       List(
-        person.transformInto[Person2],
+        person.to[Person2],
         person.into[Person2].transform(),
         person.via(Person2.apply),
         person.intoVia(Person2.apply).transform(),
@@ -185,8 +185,8 @@ class DerivedTransformerSuite extends DucktapeSuite {
     val wrappedString = Wrapped("asd")
     val unwrapped = "asd"
 
-    assertEquals(wrappedString.transformInto[String], unwrapped)
-    assertEquals(unwrapped.transformInto[Wrapped[String]], wrappedString)
+    assertEquals(wrappedString.to[String], unwrapped)
+    assertEquals(unwrapped.to[Wrapped[String]], wrappedString)
   }
 
   test("products with AnyVal fields with type params roundrip to their primitives") {
@@ -198,7 +198,7 @@ class DerivedTransformerSuite extends DucktapeSuite {
 
     val actualUnwrapped =
       List(
-        person.transformInto[UnwrappedPerson[Long]],
+        person.to[UnwrappedPerson[Long]],
         person.into[UnwrappedPerson[Long]].transform(),
         person.via(UnwrappedPerson.apply[Long]),
         person.intoVia(UnwrappedPerson.apply[Long]).transform(),
@@ -208,7 +208,7 @@ class DerivedTransformerSuite extends DucktapeSuite {
 
     val actualPerson =
       List(
-        unwrapped.transformInto[Person[Long]],
+        unwrapped.to[Person[Long]],
         unwrapped.into[Person[Long]].transform(),
         unwrapped.via(Person.apply[Long]),
         unwrapped.intoVia(Person.apply[Long]).transform(),
@@ -220,6 +220,27 @@ class DerivedTransformerSuite extends DucktapeSuite {
     actualPerson.foreach(actual => assertEquals(actual, person))
   }
 
+  test("transformers are derived for products with supertypes of the original product type") {
+    case class ProductSuper(iterable: Iterable[CharSequence], number: Number, charSeq: CharSequence)
+    case class ProductSub(iterable: List[String], number: java.lang.Integer, charSeq: String)
+
+    val prodSub = ProductSub(List("test"), 1, "test")
+    val expected = ProductSuper(Iterable("test"), 1, "test")
+
+    val actual =
+      List(
+        prodSub.to[ProductSuper],
+        prodSub.into[ProductSuper].transform(),
+        prodSub.via(ProductSuper.apply),
+        prodSub.intoVia(ProductSuper.apply).transform(),
+        Transformer.define[ProductSub, ProductSuper].build().transform(prodSub),
+        Transformer.defineVia[ProductSub](ProductSuper.apply).build().transform(prodSub),
+      )
+
+    actual.foreach(assertEquals(_, expected))
+  }
+
+
   test("derivation fails when going from a product with less fields to a product with more fields") {
     assertFailsToCompileWith {
       """
@@ -228,7 +249,7 @@ class DerivedTransformerSuite extends DucktapeSuite {
 
       val less = LessFields(1, 2, 3)
 
-      val derived = less.transformInto[MoreFields]
+      val derived = less.to[MoreFields]
       """
     }("No field named 'field4' found in LessFields")
   }
@@ -242,6 +263,6 @@ class DerivedTransformerSuite extends DucktapeSuite {
   }
 
   test("derivation fails when going from a sum with more cases to a sum with less cases") {
-    assertFailsToCompileWith("MoreCases.Case3.transformInto[LessCases]")("No child named 'Case4' found in LessCases")
+    assertFailsToCompileWith("MoreCases.Case3.to[LessCases]")("No child named 'Case4' found in LessCases")
   }
 }

ducktape/src/test/scala/io/github/arainko/ducktape/issues/Issue26Spec.scala

@@ -1,24 +1,33 @@
 package io.github.arainko.ducktape.issues
 
 import io.github.arainko.ducktape.*
-import io.github.arainko.ducktape.DucktapeSuite
 
 case class A(anotherCaseClass: A.AnotherCaseClass)
 
 object A {
   case class AnotherCaseClass(name: String)
-  case class B(anotherCaseClass: A.AnotherCaseClass)
-}
 
-object SomeOtherObject {
+  // note how AnotherCaseClass is not referred to as A.AnotherCaseClass
+  case class B(anotherCaseClass: AnotherCaseClass)
 }
 
+// https://github.com/arainko/ducktape/issues/26
 class Issue26Spec extends DucktapeSuite {
-  // import A.*
+  test("derive a correct transformer no matter how you refer to A.AnotherCaseClass inside of `A.B`") {
+    val expected = A.B(A.AnotherCaseClass("test"))
 
-  test("repro") {
     val a = A(A.AnotherCaseClass("test"))
-    val b = a.to[A.B]
+    val actual =
+      List(
+        a.to[A.B],
+        a.into[A.B].transform(),
+        a.via(A.B.apply),
+        a.intoVia(A.B.apply).transform(),
+        Transformer.define[A, A.B].build().transform(a),
+        Transformer.defineVia[A](A.B.apply).build().transform(a)
+      )
+
+    actual.foreach(actual => assertEquals(actual, expected))
   }
 
 }