fix #12919: use SingletonProxy if case obj has generic companion

Author: bishabosha

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

@@ -117,6 +117,18 @@ object SymUtils:
       self.isOneOf(FinalOrInline, butNot = Mutable)
       && (!self.is(Method) || self.is(Accessor))
 
+    /** This module must use a `Mirror.SingletonProxy` for its mirror if:
+     *  - it is Scala 2 defined
+     *  - the companion class is a generic product or generic sum and would cache
+     *    its mirror in this module.
+     */
+    def requiresSingletonProxyMirror(using Context): Boolean =
+      self.is(Scala2x) || {
+        val cls = self.companionClass
+        cls.isGenericProduct
+        || cls.useCompanionAsSumMirror && cls.isGenericSum(self)
+      }
+
     def useCompanionAsSumMirror(using Context): Boolean =
       def companionExtendsSum(using Context): Boolean =
         self.linkedClass.isSubClass(defn.Mirror_SumClass)

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

@@ -592,7 +592,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     }
 
     if (clazz.is(Module)) {
-      if (clazz.is(Case)) makeSingletonMirror()
+      if (clazz.is(Case) && !clazz.requiresSingletonProxyMirror) makeSingletonMirror()
       else if (linked.isGenericProduct) makeProductMirror(linked)
       else if (linked.isGenericSum(clazz)) makeSumMirror(linked)
       else if (linked.is(Sealed))

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

@@ -282,7 +282,10 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
         if mirroredType.termSymbol.is(CaseVal) then
           val module = mirroredType.termSymbol
           val modulePath = pathFor(mirroredType).withSpan(span)
-          if module.info.classSymbol.is(Scala2x) then
+          val requiresProxy =
+            val mClass = module.info.classSymbol
+            mClass.is(Module) && mClass.requiresSingletonProxyMirror
+          if requiresProxy then
             val mirrorType = mirrorCore(defn.Mirror_SingletonProxyClass, mirroredType, mirroredType, module.name, formal)
             val mirrorRef = New(defn.Mirror_SingletonProxyClass.typeRef, modulePath :: Nil)
             mirrorRef.cast(mirrorType)

library/src/scala/deriving/Mirror.scala

@@ -37,7 +37,9 @@ object Mirror {
     def fromProduct(p: scala.Product): MirroredMonoType = this
   }
 
-  /** A proxy for Scala 2 singletons, which do not inherit `Singleton` directly */
+  /** A proxy for Scala 2 singletons (which do not inherit `Singleton` directly),
+   *  or case objects with a case class companion
+   */
   class SingletonProxy(val value: AnyRef) extends Product {
     type MirroredMonoType = value.type
     type MirroredType = value.type

tests/run/i12919.scala

@@ -0,0 +1,20 @@
+case class Normal(value: String)
+object Normal
+
+case class ClassWithCaseCompanion(value: String)
+case object ClassWithCaseCompanion
+
+def instantiate[T](product: Product)(implicit mirror: scala.deriving.Mirror.ProductOf[T]) =
+  mirror.fromProduct(product)
+
+@main def Test: Unit = {
+  assert(instantiate[Normal](Tuple1("a")) == Normal("a")) // works as expected
+
+  assert(instantiate[ClassWithCaseCompanion.type](EmptyTuple) == ClassWithCaseCompanion) // works as expected
+
+  val c = instantiate[ClassWithCaseCompanion](Tuple1("b")) // throws java.lang.ClassCastException: class ClassWithCaseCompanion$ cannot be cast to class ClassWithCaseCompanion
+  assert(c == ClassWithCaseCompanion("b")) // desired behaviour
+
+  val d = instantiate[ClassWithCaseCompanion.type](EmptyTuple)
+  assert(d == ClassWithCaseCompanion)
+}

tests/run/i12919a.scala

@@ -0,0 +1,19 @@
+import scala.deriving.Mirror
+
+class Standalone
+case object Standalone
+
+case class WithCompanionCaseClass(i: Int)
+case object WithCompanionCaseClass
+
+@main def Test: Unit =
+
+  val mStandalone = summon[Mirror.Of[Standalone.type]]
+  assert(mStandalone eq Standalone) // the object is its own mirror
+  assert(mStandalone.isInstanceOf[Mirror.Singleton]) // object extends Mirror.Singleton because its its own mirror.
+
+  val mWithCompanion = summon[Mirror.Of[WithCompanionCaseClass.type]]
+  assert(mWithCompanion ne WithCompanionCaseClass) // the object is not its own mirror
+  assert(mWithCompanion.isInstanceOf[Mirror.SingletonProxy]) // its companion is a case class, so the mirror is a proxy
+  assert(!mWithCompanion.isInstanceOf[Mirror.Singleton]) // it can not extend Mirror.Singleton because its companion is a case class.
+  assert(WithCompanionCaseClass.isInstanceOf[Mirror.Product]) // its companion is a case class, so the mirror is a product.

tests/run/i12919b.scala

@@ -0,0 +1,17 @@
+import scala.deriving.Mirror
+
+
+sealed trait WithCompanionSealedTrait
+case object WithCompanionSealedTrait:
+  case class FirstChild(x: Int) extends WithCompanionSealedTrait
+
+@main def Test: Unit =
+
+  val mWithCompanionSum = summon[Mirror.SumOf[WithCompanionSealedTrait]]
+  assert(mWithCompanionSum.ordinal(WithCompanionSealedTrait.FirstChild(1)) == 0)
+  assert(mWithCompanionSum eq WithCompanionSealedTrait) // case object caches sum mirror of its companion
+
+  val mWithCompanionSingleton = summon[Mirror.ProductOf[WithCompanionSealedTrait.type]]
+  assert(mWithCompanionSingleton.fromProduct(EmptyTuple) == WithCompanionSealedTrait)
+  assert(mWithCompanionSingleton.isInstanceOf[Mirror.SingletonProxy])
+  assert(mWithCompanionSingleton ne WithCompanionSealedTrait) // proxy mirror is never the object itself