Add quoted Liftable derivation

Author: nicolasstucki

tests/run-macros/quoted-liftable-derivation-macro/Derivation_1.scala

@@ -0,0 +1,48 @@
+import scala.compiletime.{erasedValue, summonFrom}
+import scala.deriving._
+import scala.quoted._
+
+trait Lft[T]:
+  def toExpr(x: T): Quotes ?=> Expr[T]
+
+object Lft {
+  given Lft[Int] with
+    def toExpr(x: Int) = Expr(x)
+
+  inline given derived[T](using inline m: Mirror.Of[T]): Lft[T] = ${ derivedExpr('m) }
+
+  private def derivedExpr[T](mirrorExpr: Expr[Mirror.Of[T]])(using qctx: Quotes, tpe: Type[T]): Expr[Lft[T]] = {
+    mirrorExpr match {
+      case '{ $mirrorExpr : Mirror.Sum { type MirroredElemTypes = mirroredElemTypes } } =>
+        val liftableExprs = elemTypesLfts[mirroredElemTypes]
+        '{
+          new Lft[T]:
+            def toExpr(x: T) =
+              val mirror = $mirrorExpr
+              val liftable = ${Expr.ofSeq(liftableExprs)}.apply(mirror.ordinal(x)).asInstanceOf[Lft[T]] // TODO generate switch
+              liftable.toExpr(x)
+        }
+
+      case '{ $mirrorExpr : Mirror.Product { type MirroredElemTypes = mirroredElemTypes } } =>
+        val liftableExprs = Expr.ofList(elemTypesLfts[mirroredElemTypes])
+        '{
+          new Lft[T]:
+            def toExpr(x: T) =
+              val liftables = $liftableExprs
+              val lifted = Expr.ofSeq(liftables.zipWithIndex.map { (liftable, i) =>
+                liftable.asInstanceOf[Lft[AnyRef]].toExpr(???) // (productElement(x, i))
+              })
+              val liftedProduct = '{ Tuple.fromArray(Array($lifted: _*)) }
+              val mirror = Expr.summon(using '[Mirror.ProductOf[T]]).get
+              '{ $mirror.fromProduct($liftedProduct) }
+        }
+    }
+  }
+
+  private def elemTypesLfts[X: Type](using Quotes): List[Expr[Lft[_]]] =
+    Type.of[X] match
+      case '[ head *: tail ] =>
+        Expr.summon(using '[Lft[head]]).getOrElse(quotes.reflect.report.throwError(s"Could not find given Lft[${Type.show[head]}]")) :: elemTypesLfts[tail]
+      case '[ Unit ] => Nil
+
+}

tests/run-macros/quoted-liftable-derivation-macro/Lib_2.scala

@@ -0,0 +1,20 @@
+
+sealed trait Opt[+T] derives Lft
+case class Sm[T](t: T) extends Opt[T] derives Lft
+case object Nn extends Opt[Nothing] derives Lft
+
+object Lib {
+
+  import scala.quoted._
+  import Opt.{given _}
+
+  inline def smTwo = ${smTwoExpr}
+  inline def none = ${noneExpr}
+
+  private def smTwoExpr(using Quotes): Expr[Opt[Int]] =
+    summon[Lft[Sm[Int]]].toExpr(Sm(2))
+
+  private def noneExpr(using Quotes): Expr[Opt[Int]] =
+    summon[Lft[Nn.type]].toExpr(Nn)
+}
+

tests/run-macros/quoted-liftable-derivation-macro/Test_3.scala

@@ -0,0 +1,5 @@
+object Test extends App {
+  import Opt._
+  assert(Lib.smTwo == Sm(2))
+  assert(Lib.none == Nn)
+}