Since 0.16.0-RC3, value classes can't be derived

[kfish610]

minimized code

import scala.deriving._
import compiletime._
case class B(v: Double) extends AnyVal
val m = summon[Mirror.ProductOf[B]]

expectation

m should be a mirror, instead it throws the error no implicit argument of type deriving.Mirror.ProductOf[B] was found for parameter x of method the in object DottyPredef

[milessabin]

A restriction excluding Mirrors for value classes was introduced in 5c924ca (see whyNotGenericProduct in SymUtils.scala. Dropping this restriction allows the example above to compile and run as expected.

However, if the value class is made polymorphic, ie.

case class C[T](v: T) extends AnyVal
val m1 = the[Mirror.ProductOf[C[Double]]]

it fails during erasure,

-- Error: tests/run/i7000.scala:13:13 ------------------------------------------
13 |  case class C[T](v: T) extends AnyVal
   |             ^
   |bridge generated for member method fromProduct(x$0: Product): Test.C.MirroredMonoType in object C
   |which overrides method fromProduct(p: Product): Product.this.MirroredMonoType in trait Product
   |clashes with definition of the member itself; both have erased type (x$0: Product): Object."

attempting to bridge between,

method fromProduct (x$0: Product): ErasedValueType(Test.C, Object)

and

method fromProduct (p: Product): Object

The second of which, I think, is the erased form of,

sealed trait Mirror {
  type MirroredMonoType
}
trait Product extends Mirror {
  def fromProduct(p: scala.Product): MirroredMonoType
}

The immediate explanation for compiler to refusing to construct the bridge is that ErasedValueType(Test.C, Object) doesn't match Object. What's less clear to me is why that's the case.

I could do with some pointers from someone more familiar with the interaction of polymorphic value types and erasure than me /cc @smarter @odersky.

[smarter]

It's complicated, see #1905 for the background, if you make sure that the value class underlying type is something other than Object (e.g., case class C[T <: Foo](v: T) extends AnyVal to erase it to Foo), then it should avoid these weird clashes.

[milessabin]

@smarter #1905 looks gnarly :-(

Adding a bound to ensure that the result type of fromProduct doesn't erase to Object seems to do the trick for these examples.

I could relax the condition in whyNotGenericProduct to match, ie. we generate mirrors for value classes iff the result type of fromProduct doesn't erase to Object. That probably covers most of the cases that people care about. WDYT?

[smarter]

I could relax the condition in whyNotGenericProduct to match, ie. we generate mirrors for value classes iff the result type of fromProduct doesn't erase to Object. That probably covers most of the cases that people care about. WDYT?

Sounds good to me.

I wonder if you could change the definition of MirroredMonoType to type MirroredMonoType <: Product, this way def fromProduct(...): MirroredMonoType would erase to def fromProduct(...): Product which should reduce the chance of getting a clash.

[milessabin]

I wonder if you could change the definition of MirroredMonoType to type MirroredMonoType <: Product

We can't do that in general, but it might be possible to special-case value classes in that way. I'll give it a try.