Add TransformTypeConstraintRule and TransformImplicitConversionRule

chimney-macro-commons/src/main/scala-2/io/scalaland/chimney/internal/compiletime/TypesPlatform.scala

@@ -2,6 +2,8 @@ package io.scalaland.chimney.internal.compiletime
 
 import scala.collection.compat.Factory
 
+import TypeAlias.<:<<
+
 private[compiletime] trait TypesPlatform extends Types { this: DefinitionsPlatform =>
 
   import c.universe.{internal as _, Transformer as _, *}
@@ -185,6 +187,12 @@ private[compiletime] trait TypesPlatform extends Types { this: DefinitionsPlatfo
     object CharLiteral extends LiteralImpl[Char] with CharLiteralModule
     object StringLiteral extends LiteralImpl[String] with StringLiteralModule
 
+    object <:< extends `<:<Module` {
+      def apply[From: Type, To: Type]: Type[From <:<< To] = weakTypeTag[From <:<< To]
+      def unapply[A](A: Type[A]): Option[(??, ??)] =
+        A.asCtor[<:<<[?, ?]].map(A0 => A0.param(0) -> A0.param(1))
+    }
+
     def isTuple[A](A: Type[A]): Boolean = A.tpe.typeSymbol.fullName.startsWith("scala.Tuple")
 
     def isSubtypeOf[A, B](A: Type[A], B: Type[B]): Boolean = A.tpe <:< B.tpe

chimney-macro-commons/src/main/scala-3/io/scalaland/chimney/internal/compiletime/TypesPlatform.scala

@@ -3,6 +3,8 @@ package io.scalaland.chimney.internal.compiletime
 import scala.quoted
 import scala.collection.compat.Factory
 
+import TypeAlias.<:<<
+
 private[compiletime] trait TypesPlatform extends Types { this: DefinitionsPlatform =>
 
   import quotes.*, quotes.reflect.*
@@ -261,6 +263,14 @@ private[compiletime] trait TypesPlatform extends Types { this: DefinitionsPlatfo
     object CharLiteral extends LiteralImpl[Char](CharConstant(_)) with CharLiteralModule
     object StringLiteral extends LiteralImpl[String](StringConstant(_)) with StringLiteralModule
 
+    object <:< extends `<:<Module` {
+      def apply[From: Type, To: Type]: Type[From <:<< To] = quoted.Type.of[From <:<< To]
+      def unapply[A](A: Type[A]): Option[(??, ??)] = A match {
+        case '[<:<<[from, to]] => Some(Type[to].as_?? -> Type[to].as_??)
+        case _                 => scala.None
+      }
+    }
+
     def isTuple[A](A: Type[A]): Boolean = TypeRepr.of(using A).typeSymbol.fullName.startsWith("scala.Tuple")
 
     def isSubtypeOf[A, B](A: Type[A], B: Type[B]): Boolean = TypeRepr.of(using A) <:< TypeRepr.of(using B)

chimney-macro-commons/src/main/scala/io/scalaland/chimney/internal/compiletime/Types.scala

@@ -3,6 +3,8 @@ package io.scalaland.chimney.internal.compiletime
 import scala.collection.compat.Factory
 import scala.collection.immutable.ListSet
 
+import TypeAlias.<:<<
+
 private[compiletime] trait Types { this: (Existentials & Results) =>
 
   /** Platform-specific type representation (`c.WeakTypeTag[A]` in 2, `scala.quoted.Type[A]` in 3) */
@@ -145,6 +147,9 @@ private[compiletime] trait Types { this: (Existentials & Results) =>
     val StringLiteral: StringLiteralModule
     trait StringLiteralModule extends Literal[String] { this: StringLiteral.type => }
 
+    val <:< : `<:<Module`
+    trait `<:<Module` extends Ctor2[<:<<] { this: `<:<`.type => }
+
     // You can `import Type.Implicits.*` in your shared code to avoid providing types manually, while avoiding conflicts
     // with implicit types seen in platform-specific scopes (which would happen if those implicits were always used).
     object Implicits {
@@ -183,6 +188,8 @@ private[compiletime] trait Types { this: (Existentials & Results) =>
       implicit def MapType[K: Type, V: Type]: Type[scala.collection.Map[K, V]] = Map[K, V]
       implicit def IteratorType[A: Type]: Type[Iterator[A]] = Iterator[A]
       implicit def FactoryType[A: Type, C: Type]: Type[Factory[A, C]] = Factory[A, C]
+
+      implicit def `<:<Type`[From: Type, To: Type]: Type[From <:<< To] = <:<[From, To]
     }
 
     // Implementations of extension methods
@@ -254,3 +261,8 @@ private[compiletime] trait Types { this: (Existentials & Results) =>
     def extractStringSingleton: String = Type.extractStringSingleton(tpe)
   }
 }
+private[compiletime] object TypeAlias {
+  // Workaround for "type <:< is not a member of object Predef":
+  // apparently on 2.13/3 <:< is seen as defined in scala not scala.Predef.
+  type <:<<[-From, +To] = From <:< To
+}

chimney/src/main/scala-2/io/scalaland/chimney/internal/compiletime/derivation/transformer/DerivationPlatform.scala

@@ -11,7 +11,9 @@ trait DerivationPlatform
     with datatypes.ValueClassesPlatform
     with rules.TransformImplicitRuleModule
     with rules.TransformImplicitOuterTransformerRuleModule
+    with rules.TransformImplicitConversionRuleModule
     with rules.TransformSubtypesRuleModule
+    with rules.TransformTypeConstraintRuleModule
     with rules.TransformToSingletonRuleModule
     with rules.TransformOptionToOptionRuleModule
     with rules.TransformPartialOptionToNonOptionRuleModule
@@ -28,7 +30,9 @@ trait DerivationPlatform
   override protected val rulesAvailableForPlatform: List[Rule] = List(
     TransformImplicitRule,
     TransformImplicitOuterTransformerRule,
+    TransformImplicitConversionRule,
     TransformSubtypesRule,
+    TransformTypeConstraintRule,
     TransformToSingletonRule,
     TransformOptionToOptionRule,
     TransformPartialOptionToNonOptionRule,

chimney/src/main/scala-3/io/scalaland/chimney/internal/compiletime/derivation/transformer/DerivationPlatform.scala

@@ -12,7 +12,9 @@ abstract private[compiletime] class DerivationPlatform(q: scala.quoted.Quotes)
     with datatypes.ValueClassesPlatform
     with rules.TransformImplicitRuleModule
     with rules.TransformImplicitOuterTransformerRuleModule
+    with rules.TransformImplicitConversionRuleModule
     with rules.TransformSubtypesRuleModule
+    with rules.TransformTypeConstraintRuleModule
     with rules.TransformToSingletonRuleModule
     with rules.TransformOptionToOptionRuleModule
     with rules.TransformPartialOptionToNonOptionRuleModule
@@ -29,7 +31,9 @@ abstract private[compiletime] class DerivationPlatform(q: scala.quoted.Quotes)
   override protected val rulesAvailableForPlatform: List[Rule] = List(
     TransformImplicitRule,
     TransformImplicitOuterTransformerRule,
+    TransformImplicitConversionRule,
     TransformSubtypesRule,
+    TransformTypeConstraintRule,
     TransformToSingletonRule,
     TransformOptionToOptionRule,
     TransformPartialOptionToNonOptionRule,

chimney/src/main/scala/io/scalaland/chimney/internal/compiletime/derivation/transformer/rules/TransformImplicitConversionRuleModule.scala

@@ -0,0 +1,27 @@
+package io.scalaland.chimney.internal.compiletime.derivation.transformer.rules
+
+import io.scalaland.chimney.internal.compiletime.DerivationResult
+import io.scalaland.chimney.internal.compiletime.derivation.transformer.Derivation
+
+private[compiletime] trait TransformImplicitConversionRuleModule { this: Derivation =>
+
+  import Type.Implicits.*
+
+  protected object TransformImplicitConversionRule extends Rule("ImplicitConversion") {
+
+    def expand[From, To](implicit ctx: TransformationContext[From, To]): DerivationResult[Rule.ExpansionResult[To]] =
+      if (ctx.config.flags.implicitConversions) {
+        Expr.summonImplicit[From => To] match {
+          case Some(ev) => transformWithConversion[From, To](ev)
+          case None     => DerivationResult.attemptNextRule
+        }
+      } else DerivationResult.attemptNextRuleBecause("Implicit conversions are disabled")
+
+    private def transformWithConversion[From, To](ev: Expr[From => To])(implicit
+        ctx: TransformationContext[From, To]
+    ): DerivationResult[Rule.ExpansionResult[To]] =
+      // We're constructing:
+      // '{ ${ ev }.apply(${ src }) }
+      DerivationResult.expandedTotal(ev.apply(ctx.src))
+  }
+}

chimney/src/main/scala/io/scalaland/chimney/internal/compiletime/derivation/transformer/rules/TransformTypeConstraintRule.scala

@@ -0,0 +1,27 @@
+package io.scalaland.chimney.internal.compiletime.derivation.transformer.rules
+
+import io.scalaland.chimney.internal.compiletime.DerivationResult
+import io.scalaland.chimney.internal.compiletime.derivation.transformer.Derivation
+
+private[compiletime] trait TransformTypeConstraintRuleModule { this: Derivation =>
+
+  import Type.Implicits.*
+
+  protected object TransformTypeConstraintRule extends Rule("TypeConstraint") {
+
+    def expand[From, To](implicit ctx: TransformationContext[From, To]): DerivationResult[Rule.ExpansionResult[To]] =
+      if (ctx.config.flags.typeConstraintEvidence) {
+        Expr.summonImplicit[From <:< To] match {
+          case Some(ev) => transformWithEvidence[From, To](ev)
+          case None     => DerivationResult.attemptNextRule
+        }
+      } else DerivationResult.attemptNextRuleBecause("<:< evidence is disabled")
+
+    private def transformWithEvidence[From, To](ev: Expr[From <:< To])(implicit
+        ctx: TransformationContext[From, To]
+    ): DerivationResult[Rule.ExpansionResult[To]] =
+      // We're constructing:
+      // '{ ${ ev }.apply(${ src }) }
+      DerivationResult.expandedTotal(ev.upcastToExprOf[From => To].apply(ctx.src))
+  }
+}