fromProduct on Mirror.Product broken for case class with companion case object

[barnardb]

Compiler version

3.0.0 and 3.0.2-RC1-bin-20210622-a059dbc-NIGHTLY

Minimized code

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() = {
  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
}

Expectation

The Mirror.Product[ClassWithCaseCompanion] synthesised by the compiler should correctly instantiate the case class it claims to mirror, not its companion object. It seems the compiler gets confused when the companion object is a case object.

[bishabosha]

maybe the companion should not cache the Mirror if it itself is a generic product / singleton (aka change to instead create a new mirror at each callsite)

Edit: "generic product" here means the check the compiler does to see if a product mirror should be generated:
https://github.com/lampepfl/dotty/blob/fb86c0515a7004d90322c8485f958a3f50d48b9c/compiler/src/dotty/tools/dotc/transform/SymUtils.scala#L81

[barnardb]

@bishabosha Note that the product (ClassWithCaseCompanion) in my example is not generic. I haven't looked at the implementation at all, but I don't think caching the mirror is problematic per se. Perhaps the same name/field is being used to cache the mirror for the case class and its companion case object, in which case the solution might be to use a different name/field for the object's mirror as for the class's mirror.

[barnardb]

@bishabosha Ah, I now understand that you used "generic product" to signify a type for which the compiler synthesises Mirror.Product. Yes, if the object is only able to cache one Mirror, perhaps it should cache its own and leave the other to be synthesised at call sites, though perhaps an object should be able to cache both its own Mirror and that of the class for which it is a companion. Thanks for taking a look, BTW.

[bishabosha]

@bishabosha Ah, I now understand that you used "generic product" to signify a type for which the compiler synthesises Mirror.Product.

Yes sorry, my comment was a bit confusing, I have updated my comment to link to the compiler code I was implying here.