restrict mirrors of any union type

Author: bishabosha

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

@@ -26,7 +26,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
   /** Handlers to synthesize implicits for special types */
   type SpecialHandler = (Type, Span) => Context ?=> TreeWithErrors
   private type SpecialHandlers = List[(ClassSymbol, SpecialHandler)]
-  
+
   val synthesizedClassTag: SpecialHandler = (formal, span) =>
     formal.argInfos match
       case arg :: Nil =>
@@ -282,7 +282,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
     def acceptable(tp: Type, cls: Symbol): Boolean = tp match
       case tp: HKTypeLambda if tp.resultType.isInstanceOf[HKTypeLambda] => false
       case tp: TypeProxy    => acceptable(tp.underlying, cls)
-      case OrType(tp1, tp2) => acceptable(tp1, cls) && acceptable(tp2, cls)
+      case OrType(tp1, tp2) => false
       case _                => tp.classSymbol eq cls
 
     /** for a case class, if it will have an anonymous mirror,
@@ -323,12 +323,12 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       withNoErrors(mirrorRef.cast(mirrorType))
     end makeProductMirror
 
-    def getError(cls: Symbol): String = 
+    def getError(cls: Symbol): String =
       val reason = if !cls.isGenericProduct then
         i"because ${cls.whyNotGenericProduct}"
       else if !canAccessCtor(cls) then
         i"because the constructor of $cls is innaccessible from the calling scope."
-      else 
+      else
         ""
       i"$cls is not a generic product $reason"
     end getError
@@ -369,7 +369,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       case tp: TermRef => false
       case tp: HKTypeLambda if tp.resultType.isInstanceOf[HKTypeLambda] => false
       case tp: TypeProxy => acceptable(tp.underlying)
-      case OrType(tp1, tp2) => acceptable(tp1) && acceptable(tp2)
+      case OrType(tp1, tp2) => false
       case _            => tp.classSymbol eq cls
 
     if acceptable(mirroredType) && clsIsGenericSum then
@@ -428,7 +428,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       withNoErrors(mirrorRef.cast(mirrorType))
     else if !clsIsGenericSum then
       (EmptyTree, List(i"$cls is not a generic sum because ${cls.whyNotGenericSum(declScope)}"))
-    else 
+    else
       EmptyTreeNoError
   end sumMirror
 
@@ -595,7 +595,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             tp.baseType(cls)
         val base = baseWithRefinements(formal)
         val result =
-          if (base <:< formal.widenExpr)  
+          if (base <:< formal.widenExpr)
             // With the subtype test we enforce that the searched type `formal` is of the right form
             handler(base, span)
           else EmptyTreeNoError
@@ -609,19 +609,19 @@ end Synthesizer
 
 object Synthesizer:
 
-  /** Tuple used to store the synthesis result with a list of errors.  */ 
+  /** Tuple used to store the synthesis result with a list of errors.  */
   type TreeWithErrors = (Tree, List[String])
   private def withNoErrors(tree: Tree): TreeWithErrors = (tree, List.empty)
 
   private val EmptyTreeNoError: TreeWithErrors = withNoErrors(EmptyTree)
 
   private def orElse(treeWithErrors1: TreeWithErrors, treeWithErrors2: => TreeWithErrors): TreeWithErrors = treeWithErrors1 match
-    case (tree, errors) if tree eq genericEmptyTree => 
+    case (tree, errors) if tree eq genericEmptyTree =>
       val (tree2, errors2) = treeWithErrors2
       (tree2, errors ::: errors2)
     case _ => treeWithErrors1
 
-  private def clearErrorsIfNotEmpty(treeWithErrors: TreeWithErrors) = treeWithErrors match 
+  private def clearErrorsIfNotEmpty(treeWithErrors: TreeWithErrors) = treeWithErrors match
     case (tree, _) if tree eq genericEmptyTree => treeWithErrors
     case (tree, _)                             => withNoErrors(tree)
 

tests/neg/i14823a.scala

@@ -0,0 +1,20 @@
+import deriving.Mirror
+
+object MirrorK1:
+  type Of[F[_]] = Mirror { type MirroredType[A] = F[A] }
+
+sealed trait Box[T]
+object Box
+
+case class Child[T]() extends Box[T]
+
+sealed abstract class Foo[T]
+object Foo {
+  case class A[T]() extends Foo[T]
+}
+
+val foo = summon[Mirror.Of[Box[Int] | Box[Int]]] // error
+val bar = summon[MirrorK1.Of[[X] =>> Box[Int] | Box[Int]]] // error
+def baz = summon[deriving.Mirror.Of[Foo[String] | Foo[String]]] // error
+
+def qux = summon[deriving.Mirror.Of[Option[Int] | Option[String]]] // error