Anonymous trait mixin breaks inline match + erasedValue + summonInline

[kavedaa]

Compiler version

3.2.2, 3.3.0-RC3

Minimized code

//> using scala "3.3.0-RC3"

import scala.deriving.Mirror
import scala.compiletime.*

trait Reader[-In, Out]

trait A:
  type T
  type F[X]
  type Q = F[T]

object Reader:

  given [X]: Reader[A { type Q = X }, X] with {}    

  type Map2[Tup1 <: Tuple, Tup2 <: Tuple, F[_, _]] <: Tuple = (Tup1, Tup2) match
    case (h1 *: t1, h2 *: t2) => F[h1, h2] *: Map2[t1, t2, F]
    case (EmptyTuple, EmptyTuple) => EmptyTuple    

  inline given productReader[In <: Product, Out <: Product](using mi: Mirror.ProductOf[In])(using mo: Mirror.ProductOf[Out]): Reader[In, Out] = 
    summonAll[Map2[mi.MirroredElemTypes, mo.MirroredElemTypes, Reader]]
    ???

object Test:
  
  trait B[X] extends A:
    type T = X

  trait C extends A:
    type F[X] = X
  
  val bc = new B[Int] with C

  summon[Reader[(bc.type, bc.type), (Int, Int)]]    // fails

Output

Compiling project (Scala 3.3.0-RC3, JVM)
[error] .\fails.scala:35:49: No given instance of type Reader[(Test.bc : Test.B[Int] & Test.C), Int] was found.
[error] I found:
[error]
[error]     Reader.productReader[In, Out](/* missing */summon[deriving.Mirror.ProductOf[In]]
[error]       )
[error]
[error] But Failed to synthesize an instance of type deriving.Mirror.ProductOf[In]: class Nothing is not a generic product because it is not a case class.
[error]   summon[Reader[(bc.type, bc.type), (Int, Int)]]    // fails
[error]                                                 ^
Error compiling project (Scala 3.3.0-RC3, JVM)
Compilation failed

Expectation

Successful compilation

[kavedaa]

If the last couple of lines are replaced with this, it works:

trait D[X] extends B[X] with C

val d = new D[Int] {}

summon[Reader[(d.type, d.type), (Int, Int)]]    // works

[bishabosha]

this issue is incorrectly titled, in fact the mirror synthesis works fine (can be observed with -Xprint:typer), what is failing is summonAll[(Reader[bc.type, Int], Reader[bc.type, Int])], see the following code, where I manually inline Reader. productReader:

//> using scala "3.3.0-RC3"

import scala.compiletime.*

trait Reader[-In, Out]

trait A:
  type T
  type F[X]
  type Q = F[T]

object Reader:

  given [X]: Reader[A { type Q = X }, X] with {}

object Test:

  trait B[X] extends A:
    type T = X

  trait C extends A:
    type F[X] = X

  trait D[X] extends B[X] with C

  val d = new D[Int] {}
  val bc = new B[Int] with C

  summonAll[(Reader[d.type, Int], Reader[d.type, Int])] // works
  summonAll[(Reader[bc.type, Int], Reader[bc.type, Int])] // error
  summonInline[Reader[d.type, Int]] // works
  summonInline[Reader[bc.type, Int]] // works??

so it appears the problem is summonAll

[bishabosha]

If I reimplement summonAll as summonOne, with a single case, then we get the same problem, so is the issue inline match with erasedValue?

object Test:
  // ...

  case class Box[T]()

  /** compiletime.summonAll, but with one case */
  inline def summonOne[T <: Box[?]]: T =
    val res =
      inline erasedValue[T] match
        case _: Box[t] => summonInline[t]
      end match
    Box(res).asInstanceOf[T]
  end summonOne

  summonOne[Box[Reader[d.type, Int]]] // works
  summonOne[Box[Reader[bc.type, Int]]] // errors

[kavedaa]

Here is a complete minimized example. There are many ways to make it compile, but only one way to make it fail:

//> using scala 3.3.3

import scala.compiletime.*

trait Reader[-In, Out]

trait A:
  type T
  type F[X]
  type Q = F[T]

given [X]: Reader[A { type Q = X }, X] with {}    

case class Box[T](x: T)

/** compiletime.summonAll, but with one case */
inline def summonOne[T]: T =
  val res =
    inline erasedValue[T] match
      case _: Box[t] => summonInline[t]
    end match
  Box(res).asInstanceOf[T]
end summonOne


@main def main = 


  trait B[X] extends A:
    type T = X

  trait C extends A:
    type F[X] = X

  
  val bc = new B[Int] with C
  
  summonOne[Box[Reader[bc.type, Int]]] // errors


  val bc2: A { type Q = Int } = new B[Int] with C
  
  summonOne[Box[Reader[bc2.type, Int]]] // works


  object BC extends B[Int] with C

  summonOne[Box[Reader[BC.type, Int]]] // works


  val a = new A:
    type T = Int
    type F[X] = X
  
  summonOne[Box[Reader[a.type, Int]]] // works


  val b = new B[Int]:
    type F[X] = X
  
  summonOne[Box[Reader[b.type, Int]]] // works


  val ac = new A with C:
    type T = Int

  summonOne[Box[Reader[ac.type, Int]]] // works


  trait D[X] extends B[X] with C
  val d = new D[Int] {}

  summonOne[Box[Reader[d.type, Int]]] // works

[jchyb]

Spent some time investigating this, further minimization:

//> using scala 3.3.3
import scala.compiletime.*

trait Reader[-In, Out]

trait A:
  type T
  type F[X]
  type Q = F[T]

given [X]: Reader[A { type Q = X }, X] with {}    

case class Box[T](x: T)

inline def summonOne[T]: T =
  summonInline[T]
end summonOne

@main def main = 
  trait B[X] extends A:
    type T = X
  trait C extends A:
    type F[X] = X
  
  val bc = new B[Int] with C
  summonInline[Reader[bc.type, Int]] // (I) Works
  summonOne[Reader[bc.type, Int]] // (II) Errors

Looks like the only difference between the working call (I) and the erroring call (II) is that the failing call has a slightly different Context, the type argument is unchanged after the inlining of the enclosing method. In the failing call (II) the compiler is able to correctly identify the implicit method, however a later TypeComparer.testSubType check fails.

This is where it gets difficult, in both calls the TypeComparer tries to check the subtyping of Reader[A{type Q = X}, X] <:< Reader[(bc : B[Int] & C), Int], later checking B[Int] & C <:< A{type Q = X}, later checking B[Int].Q <:< X.

• In the successful check (I), it resolves B[Int].Q into a denotation representing TypeBounds(Nothing, Any).
• In the failing check (II), it resolves B[Int].Q into a denotation representing B[Int]#F[B[Int]#T].

I have no idea why the things differ here. In the failing check this causes the X type variable to "become" B[Int]#F[B[Int]#T], later failing X <: Int check. Type comparer is not an area of the compiler I usually touch, so I have no idea why the B[Int].Q denotations differ in those 2 calls and I am a bit stuck (any help/ideas would be appreciated).