WIP

Author: biboudis

tests/run-macros/i8007/Macro_1.scala

@@ -3,7 +3,6 @@ import scala.quoted._
 import scala.quoted.matching._
 
 object Macro1 {
-  case class Person(name: String, age: Int)
 
   def mirrorFields[T](t: Type[T])(given qctx: QuoteContext): List[String] =
     t match {

tests/run-macros/i8007/Macro_3.scala

@@ -2,54 +2,77 @@ import scala.deriving._
 import scala.quoted._
 import scala.quoted.matching._
 
-object Macro3 {
+trait Eq[T] {
+  def eqv(x: T, y: T): Boolean
+}
+
+object Eq {
+  given Eq[String] {
+    def eqv(x: String, y: String) = x == y
+  }
 
-  trait Eq[T] {
-    def eqv(x: T, y: T): Boolean
+  given Eq[Int] {
+    def eqv(x: Int, y: Int) = x == y
   }
 
-  object Eq {
-    given Eq[String] {
-      def eqv(x: String, y: String) = x == y
+  def eqProduct[T](body: (T, T) => Boolean): Eq[T] =
+    new Eq[T] {
+      def eqv(x: T, y: T): Boolean = body(x, y)
     }
 
-    given Eq[Int] {
-      def eqv(x: Int, y: Int) = x == y
+  def eqSum[T](body: (T, T) => Boolean): Eq[T] =
+    new Eq[T] {
+      def eqv(x: T, y: T): Boolean = body(x, y)
     }
 
-    def eqProduct[T](body: (T, T) => Boolean): Eq[T] =
-      new Eq[T] {
-        def eqv(x: T, y: T): Boolean = body(x, y)
-      }
+  def summonAll[T](t: Type[T])(given qctx: QuoteContext): List[Expr[Eq[_]]] = t match {
+    case '[$tpe *: $tpes] =>
+      println(tpe.show)
+      summonExpr(given '[Eq[$tpe]]).get :: summonAll(tpes)
+    case '[Unit] => Nil
+  }
 
-    def summonAll[T](t: Type[T])(given qctx: QuoteContext): List[Expr[Eq[_]]] = t match {
-      case '[$tpe *: $tpes] => summonExpr(given '[Eq[$tpe]]).get :: summonAll(tpes)
-      case '[Unit] => Nil
-    }
+  def derived[T: Type](ev: Expr[Mirror.Of[T]])(given qctx: QuoteContext): Expr[Eq[T]] = {
+    import qctx.tasty.{_, given}
 
-    def derived[T: Type](ev: Expr[Mirror.Of[T]])(given qctx: QuoteContext): Expr[Eq[T]] = {
-      import qctx.tasty.{_, given}
+    ev match {
+      case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = $elementTypes }} =>
+        val elemInstances = summonAll(elementTypes)
+        val eqProductBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) => {
+          elemInstances.zipWithIndex.foldLeft(Expr(true: Boolean)) {
+            case (acc, (elem, index)) =>
+              val e1 = '{$x.asInstanceOf[Product].productElement(${Expr(index)})}
+              val e2 = '{$y.asInstanceOf[Product].productElement(${Expr(index)})}
 
-      val elementTypes = ev match {
-        case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = $elem } } => elem
-      }
+              '{ $acc && $elem.asInstanceOf[Eq[Any]].eqv($e1, $e2) }
+          }
+        }
+        '{
+          eqProduct((x: T, y: T) => ${eqProductBody('x, 'y)})
+        }
 
-      val elemInstances = summonAll(elementTypes)
+      case '{ $m: Mirror.SumOf[T] { type MirroredElemTypes = $elementTypes }} =>
+        val elemInstances = summonAll(elementTypes)
+        val eqSumBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) => {
+          val ordx = '{ $m.ordinal($x) }
+          val ordy = '{ $m.ordinal($y) }
 
-      val eqProductBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) => {
-        elemInstances.zipWithIndex.foldLeft(Expr(true: Boolean)) {
-          case (acc, (elem, index)) =>
-            val e1 = '{$x.asInstanceOf[Product].productElement(${Expr(index)})}
-            val e2 = '{$y.asInstanceOf[Product].productElement(${Expr(index)})}
-            '{ $acc && $elem.asInstanceOf[Eq[Any]].eqv($e1, $e2) }
+          val elements = Expr.ofList(elemInstances)
+          '{
+              $ordx == $ordy && $elements($ordx).asInstanceOf[Eq[Any]].eqv($x, $y)
+          }
         }
-      }
 
-      '{
-        eqProduct((x: T, y: T) => ${eqProductBody('x, 'y)})
-      }
+        '{
+          eqSum((x: T, y: T) => ${eqSumBody('x, 'y)})
+        }
     }
   }
+}
+
+object Macro3 {
+
+
 
   inline def test3[T](value: =>T, value2: =>T): Boolean = ${ test3Impl('value, 'value2) }
 

tests/run-macros/i8007/Test_4.scala

@@ -1,8 +1,18 @@
 import Macro1._
 import Macro2._
 import Macro3._
+import scala.deriving._
+
+case class Person(name: String, age: Int)
+
+enum Opt[+T] derives Eq {
+  case Sm(t: T)
+  case Nn
+}
 
 @main def Test() = {
+  import Opt._
+
   val t1 = test1(Person("Test", 23))
   println(t1)
   println
@@ -18,4 +28,8 @@ import Macro3._
   val t4 = test3(Person("Test", 23), Person("Test", 24))
   println(t4) // false
   println
+
+  val t5 = test3(Sm(Person("Test", 23)), Sm(Person("Test", 23)))
+  println(t5) // true
+  println
 }