Liftable derivation moved to the compiler

Author: anatoliykmetyuk

library/src-bootstrapped/scala/quoted/Liftable.scala

@@ -1,6 +1,7 @@
 package scala.quoted
 
 import scala.reflect.ClassTag
+import scala.deriving._
 
 /** A typeclass for types that can be turned to `quoted.Expr[T]`
  *  without going through an explicit `'{...}` operation.
@@ -305,4 +306,27 @@ object Liftable {
       '{ BigDecimal(${Expr(x.toString)}) }
   }
 
+  inline given productLiftable[T <: Product: Type](given
+      m : Mirror.ProductOf[T],
+      em: Expr[Mirror.ProductOf[T]]): Liftable[T] = new Liftable[T] {
+    def toExpr(x: T) =
+      val genRepr = Tuple.fromProductTyped(x)
+      val liftables = summonAll[Tuple.Map[m.MirroredElemTypes, Liftable]]
+      val elemsWithLiftables = liftables.zip(genRepr.asInstanceOf[Product].productIterator.toList)
+      val tupleOfExprs = elemsWithLiftables.map {
+        case (l: Liftable[a], x) => l.toExpr(x.asInstanceOf[a])
+      }
+      val exprOfTuple = Expr.ofTuple(tupleOfExprs)
+      '{$em.fromProduct($exprOfTuple.asInstanceOf[Product])}
+  }
+
+  inline given sumLiftable[T: Type](given m: Mirror.SumOf[T]): Liftable[T] = new Liftable[T] {
+    def toExpr(x: T) =
+      val liftables = summonAll[Tuple.Map[m.MirroredElemTypes, Liftable]]
+      val tags = summonAll[Tuple.Map[m.MirroredElemTypes, ClassTag]]
+      tags.zip(liftables).flatMap { case (t: ClassTag[a], l: Liftable[?]) =>
+        t.unapply(x).map(xa => l.asInstanceOf[Liftable[a]].toExpr(xa)) }
+        .head.asInstanceOf[Expr[T]]
+  }
+
 }

library/src/dotty/DottyPredef.scala

@@ -1,7 +1,7 @@
 package dotty
 
 object DottyPredef {
-  import compiletime.summonFrom
+  import compiletime.{ summonFrom, erasedValue }
 
   @forceInline final def assert(assertion: => Boolean, message: => Any): Unit = {
     if (!assertion)
@@ -38,4 +38,10 @@ object DottyPredef {
   }
 
   inline def summon[T](given x: T): x.type = x
+
+  inline def summonInline[T] = summonFrom { case x: T => x }
+
+  inline def summonAll[T <: Tuple]: List[?] = inline erasedValue[T] match
+    case _: Unit => Nil
+    case _: (t *: ts) => summonInline[t] :: summonAll[ts]
 }

tests/pos-macros/liftable-derivation/Macro_1.scala

@@ -9,9 +9,13 @@ import scala.compiletime.{ erasedValue, summonFrom }
 
 inline def mcr(given m: Mirror.ProductOf[Foo], m2: Mirror.ProductOf[Bar], m3: Mirror.ProductOf[Stuff.FooS], m4: Mirror.ProductOf[Stuff.BarS]): Any = ${mcrImpl(given 'm, 'm2, 'm3, 'm4)}
 def mcrImpl(given m: Expr[Mirror.ProductOf[Foo]], m2: Expr[Mirror.ProductOf[Bar]], m3: Expr[Mirror.ProductOf[Stuff.FooS]], m4: Expr[Mirror.ProductOf[Stuff.BarS]])(given ctx: QuoteContext): Expr[Any] =
-  val x: A = Foo(1, "foo")
+  val x = Foo(1, "foo")
   val y: Stuff = Stuff.FooS(10)
-  Expr(y)
+  val z: A = x
+  val e1 = Expr(x)
+  val e2 = Expr(y)
+  val e3 = Expr(z)
+  '{List($e1, $e2, $e3)}
 
 sealed trait A
 case class Foo(x: Int, y: String) extends A
@@ -21,32 +25,3 @@ enum Stuff {
   case FooS(x: Int)
   case BarS(y: String)
 }
-
-inline def summonInline[T] = summonFrom { case x: T => x }
-
-inline def summonAll[T <: Tuple]: List[?] = inline erasedValue[T] match
-  case _: Unit => Nil
-  case _: (t *: ts) => summonInline[t] :: summonAll[ts]
-
-inline given productLiftable[T <: Product: Type](given
-    m : Mirror.ProductOf[T],
-    em: Expr[Mirror.ProductOf[T]]): Liftable[T] = new Liftable[T] {
-  def toExpr(x: T) =
-    val genRepr = Tuple.fromProductTyped(x)
-    val liftables = summonAll[Tuple.Map[m.MirroredElemTypes, Liftable]]
-    val elemsWithLiftables = liftables.zip(genRepr.asInstanceOf[Product].productIterator.toList)
-    val tupleOfExprs = elemsWithLiftables.map {
-      case (l: Liftable[a], x) => l.toExpr(x.asInstanceOf[a])
-    }
-    val exprOfTuple = Expr.ofTuple(tupleOfExprs)
-    '{$em.fromProduct($exprOfTuple.asInstanceOf[Product])}
-}
-
-inline given sumLiftable[T: Type](given m: Mirror.SumOf[T]): Liftable[T] = new Liftable[T] {
-  def toExpr(x: T) =
-    val liftables = summonAll[Tuple.Map[m.MirroredElemTypes, Liftable]]
-    val tags = summonAll[Tuple.Map[m.MirroredElemTypes, ClassTag]]
-    tags.zip(liftables).flatMap { case (t: ClassTag[a], l: Liftable[?]) =>
-      t.unapply(x).map(xa => l.asInstanceOf[Liftable[a]].toExpr(xa)) }
-      .head.asInstanceOf[Expr[T]]
-}