handle widened module class in productMirror

Author: bishabosha

compiler/src/dotty/tools/dotc/transform/SymUtils.scala

@@ -94,7 +94,7 @@ object SymUtils:
         && (!ctor.privateWithin.exists || isAccessible(ctor.privateWithin)) // check scope is compatible
 
 
-      val companionMirror = self.useCompanionAsProductMirror
+      def companionMirror = self.useCompanionAsProductMirror
       if (!self.is(CaseClass)) "it is not a case class"
       else if (self.is(Abstract)) "it is an abstract class"
       else if (self.primaryConstructor.info.paramInfoss.length != 1) "it takes more than one parameter list"

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

@@ -310,22 +310,31 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       withNoErrors(mirrorRef.cast(mirrorType))
     end makeProductMirror
 
+    /** widen TermRef to see if they are an alias to an enum singleton */
+    def isEnumSingletonRef(tp: Type)(using Context): Boolean = tp match
+      case tp: TermRef =>
+        val sym = tp.termSymbol
+        sym.isEnumCase || (!tp.isOverloaded && isEnumSingletonRef(tp.underlying.widenExpr))
+      case _ => false
+
     mirroredType match
       case AndType(tp1, tp2) =>
         orElse(productMirror(tp1, formal, span), productMirror(tp2, formal, span))
       case _ =>
-        if mirroredType.termSymbol.is(CaseVal) then
-          val module = mirroredType.termSymbol
-          val modulePath = pathFor(mirroredType).withSpan(span)
-          if module.info.classSymbol.is(Scala2x) then
-            val mirrorType = mirrorCore(defn.Mirror_SingletonProxyClass, mirroredType, mirroredType, module.name, formal)
-            val mirrorRef = New(defn.Mirror_SingletonProxyClass.typeRef, modulePath :: Nil)
+        val cls = mirroredType.classSymbol
+        if isEnumSingletonRef(mirroredType) || cls.isAllOf(Case | Module) then
+          val (singleton, singletonRef) =
+            if mirroredType.termSymbol.exists then (mirroredType.termSymbol, mirroredType)
+            else (cls.sourceModule, cls.sourceModule.reachableTermRef)
+          val singletonPath = pathFor(singletonRef).withSpan(span)
+          if singleton.info.classSymbol.is(Scala2x) then // could be Scala 3 alias of Scala 2 case object.
+            val mirrorType = mirrorCore(defn.Mirror_SingletonProxyClass, mirroredType, mirroredType, singleton.name, formal)
+            val mirrorRef = New(defn.Mirror_SingletonProxyClass.typeRef, singletonPath :: Nil)
             withNoErrors(mirrorRef.cast(mirrorType))
           else
-            val mirrorType = mirrorCore(defn.Mirror_SingletonClass, mirroredType, mirroredType, module.name, formal)
-            withNoErrors(modulePath.cast(mirrorType))
+            val mirrorType = mirrorCore(defn.Mirror_SingletonClass, mirroredType, mirroredType, singleton.name, formal)
+            withNoErrors(singletonPath.cast(mirrorType))
         else
-          val cls = mirroredType.classSymbol
           val acceptableMsg = whyNotAcceptableType(mirroredType, cls)
           if acceptableMsg.isEmpty then
             if cls.isGenericProduct then makeProductMirror(cls)

tests/run/i15234.scala

@@ -0,0 +1,22 @@
+import scala.deriving.Mirror
+
+package lib {
+  enum Foo:
+    case A
+
+  case object Bar
+}
+
+package app {
+  object Foo:
+    val A: lib.Foo.A.type = lib.Foo.A
+  val Bar: lib.Bar.type = lib.Bar
+}
+
+
+@main def Test =
+  assert(summon[Mirror.Of[scala.Nil.type]].fromProduct(EmptyTuple) == Nil) // alias scala 2 defined
+  assert(summon[Mirror.Of[lib.Foo.A.type]].fromProduct(EmptyTuple) == lib.Foo.A) // real mirror
+  assert(summon[Mirror.Of[lib.Bar.type]].fromProduct(EmptyTuple) == lib.Bar) // real mirror
+  assert(summon[Mirror.Of[app.Foo.A.type]].fromProduct(EmptyTuple) == lib.Foo.A) // alias mirror
+  assert(summon[Mirror.Of[app.Bar.type]].fromProduct(EmptyTuple) == lib.Bar) // alias mirror