fix i13146 - use fullyDefinedType

Author: bishabosha

compiler/src/dotty/tools/dotc/typer/Synthesizer.scala

@@ -540,7 +540,8 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       (using Context): TreeWithErrors =
     if checkFormal(formal) then
       formal.member(tpnme.MirroredType).info match
-        case TypeBounds(mirroredType, _) => synth(TypeOps.stripTypeVars(mirroredType), formal, span)
+        case TypeBounds(mirroredType, _) =>
+          synth(fullyDefinedType(mirroredType, "Mirror.*Of argument", ctx.source.atSpan(span)), formal, span)
         case other => EmptyTreeNoError
     else EmptyTreeNoError
 

tests/run/i13146.scala

@@ -0,0 +1,53 @@
+import scala.deriving.*
+import scala.compiletime.{erasedValue, summonInline}
+
+inline def summonAll[T <: Tuple]: List[Eq[_]] =
+  inline erasedValue[T] match
+    case _: EmptyTuple => Nil
+    case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]
+
+trait Eq[-T]:
+  def eqv(x: T, y: T): Boolean
+
+object Eq:
+  given Eq[Int] with
+    def eqv(x: Int, y: Int) = x == y
+
+  def check(elem: Eq[_])(x: Any, y: Any): Boolean =
+    elem.asInstanceOf[Eq[Any]].eqv(x, y)
+
+  def iterator[T](p: T) = p.asInstanceOf[Product].productIterator
+
+  def eqSum[T](s: Mirror.SumOf[T], elems: => List[Eq[_]]): Eq[T] =
+    new Eq[T]:
+      def eqv(x: T, y: T): Boolean =
+        val ordx = s.ordinal(x)
+        (s.ordinal(y) == ordx) && check(elems(ordx))(x, y)
+
+  def eqProduct[T](p: Mirror.ProductOf[T], elems: => List[Eq[_]]): Eq[T] =
+    new Eq[T]:
+      def eqv(x: T, y: T): Boolean =
+        iterator(x).zip(iterator(y)).zip(elems.iterator).forall {
+          case ((x, y), elem) => check(elem)(x, y)
+        }
+
+  inline given derived[T](using m: Mirror.Of[T]): Eq[T] =
+    lazy val elemInstances = summonAll[m.MirroredElemTypes]
+    inline m match
+      case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
+      case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
+end Eq
+
+enum Opt[+T]:
+  case Sm(t: T)
+  case Nn
+
+object Opt:
+  given derivedEq[T]: Eq[Opt[T]] = Eq.derived
+
+@main def Test(): Unit =
+  import Opt.*
+  val eqoi = summon[Eq[Opt[Int]]]
+  // assert(eqoi.eqv(Sm(23), Sm(23))) -> eqoi.eqv makes an infinite loop
+  // assert(!eqoi.eqv(Sm(23), Sm(13)))  -> eqoi.eqv makes an infinite loop
+  // assert(!eqoi.eqv(Sm(23), Nn))  -> eqoi.eqv makes an infinite loop