Match Type producing a List in all cases is not always recognized as List but as IterableOnce

[daenenk]

Compiler version 3.0.0-RC1

Minimized code

type Return[X] = X match
    case List[t] => List[t]
    case Any => List[X]

object Return:
  def apply[A](a:A):Return[A] = a match 
    case a: List[t] => a
    case a: Any => List(a)

object Test:
  Return(1).map(x => x)

Output

WARNING: method map in class IterableOnceExtensionMethods is deprecated since 2.13.0: Use .iterator.map instead or consider requiring an Iterable

Expectation

This should work. the same way as

  List(1).map(x => x)

[OlivierBlanvillain]

The issue is that the compiler keeps Return's type variable around for too long, you can fix it by specifying it (Return[Int](1).map(x => x) or splitting the statement in two (val x = Return(1); x.map(x => x))

[smarter]

ah, so I guess we end up with Return[?T] where ?T >: Int which is not enough to conclude that there's a map on this type because it's a match type? But typedSelect calls couldInstantiateTypeVar whose job is to instantiate any type variable that might uncover members, and when it sees a match type it should instantiate its type variables: https://github.com/lampepfl/dotty/blob/60cbef1436d82b275bb1f9b155cf0fb2b74ed8e4/compiler/src/dotty/tools/dotc/typer/Inferencing.scala#L103-L108, any idea why this doesn't trigger here?

[daenenk]

I have a similar example, looks like a similar issue

Code

type Boxed[X] = X match
   case Box[t] => Box[t]
   case Any => Box[X]

def box[X](x: X): Boxed[X] = x match
   case b: Box[t] => b
   case x: Any => Box(x)

case class Box[A](a:A):
  def map[B](f: A => B): Box[B] = Box(f(a))

object Test:
   box(box(1)).map(_ + 1)

Output

error: value map is not a member of Boxed[Boxed[Int]]

Expected output

The following snippet does work, so I expect the above to behave the same

object Test:
  box(1).map(_ + 1)

  val b = box(1)
  val bb = box(b)
  bb.map(_ + 1)

when I modify the match type declaration to:

type Boxed[X] <: Box[?] = X match
   case Box[t] => Box[t]
   case Any => Box[X]

the line

    box(1).map(_ + 1)

gives the error

Found:    Int => Int
Required: Boxed[Int]#A => Int