Nested `transparent` calls `*:` mangles types

[ncreep]

Compiler version

3.3.0

Minimized code

Following #18010 (working around nested transparent calls), I'm adding some summonInline to the mix.
Given the following code:

//> using scala "3.3.0"

import scala.compiletime.*

trait Hidden:
  type Value

object Hidden:
  type Of[A] = Hidden { type Value = A }

  given [A]: Hidden.Of[A] = new Hidden { type Value = A }

class Typed[A]

transparent inline def unhide[T <: Tuple]: Typed[_ <: Tuple] =
  inline erasedValue[T] match
    case _: EmptyTuple => Typed[EmptyTuple]
    case _: (h *: t) =>
      inline unhide[t] match
        case _: Typed[ts] =>
          inline summonInline[h] match
            case _: Hidden.Of[x] =>
              Typed[x *: ts]
              
val x = unhide[(Hidden.Of["a"], Hidden.Of["b"], Hidden.Of["c"])]

Output

The code above fails to compile on the definition of x with:

Found:    Typed[?1.CAP]
Required: Typed[? >: Nothing *: EmptyTuple.type <: Any *: EmptyTuple.type]

where:    ?1 is an unknown value of type scala.runtime.TypeBox[Nothing *: Nothing, Any *: Tuple]

But if I replace the second branch with a seemingly equivalent expression like so:

case _: Hidden.Of[x] =>
  Typed[Prepend[x, ts]]

Where Prepend is defined as:

type Prepend[X, +Y <: Tuple] <: Tuple = X match
  case X => X *: Y

Everything compiles just fine.

(And as per #18010, if I add a random println on that branch it will fully preserve type information.)

Expectation

*: should not cause compilation to fail.

Thanks

[odersky]

The fact that there's a capture conversion type ?1.CAP shows that this is probably as far as type inference will go. It already goes through extra-ordinary lengths to make code using wildcard arguments work. So without a concrete proposal how to improve the already crazily complicated algorithms to deal with that case, I don't see a way to make progress.

[ncreep]

Thanks for answering.

I'm not sure where type-inference is playing a role here (or I'm misunderstanding which type inference you mean).
If I annotate the various definitions like so:

transparent inline def unhide[T <: Tuple]: Typed[_ <: Tuple] =
  inline erasedValue[T] match
    case _: EmptyTuple => 
      val x: Typed[EmptyTuple] = Typed[EmptyTuple]
      x
    case _: (h *: t) =>
      inline unhide[t] match
        case _: Typed[ts] =>
          inline summonInline[h] match
            case _: Hidden.Of[x] =>
              val x: Typed[x *: ts] = Typed[x *: ts]
              x
              
val x: Typed[("a", "b", "c")] = unhide[(Hidden.Of["a"], Hidden.Of["b"], Hidden.Of["c"])]

This still fails with:

Found:    Typed[?1.CAP]
Required: Typed[("c" : String) *: EmptyTuple.type]

where:    ?1 is an unknown value of type scala.runtime.TypeBox[Nothing *: Nothing, Any *: Tuple]

While this compiles fine:

            case _: Hidden.Of[x] =>
              val x: Typed[Prepend[x, ts]] = Typed[Prepend[x, ts]]
              x
    
val x: Typed[("a", "b", "c")] = unhide[(Hidden.Of["a"], Hidden.Of["b"], Hidden.Of["c"])]

(Note that the precise type of the results is only available due to #18010 and the intermediate val in the case).

Is type inference still playing a role here?