Chained `.collect`s break with F-bounded polymorfism

[JD557]

Compiler version

3.2.1

Minimized code

trait MyTrait[E <: MyTrait[E]]

case class MyClass() extends MyTrait[MyClass]

List(MyClass()).collect {
	case e: MyTrait[_] => e
}.collect {
  case e: MyTrait[_] => e
}

Output

assertion failed: 
no owner from  <none>/ <none> in List.apply[test.MyClass](
  scala.runtime.ScalaRunTime.wrapRefArray[test.MyClass](
    [test.MyClass.apply() : test.MyClass]
  )
).collect[(test.MyClass & test.MyTrait[? <: test.MyTrait[test.MyTrait[?]#E]])](
  {
    final class $anon() extends scala.runtime.AbstractPartialFunction[
      test.MyClass
    , test.MyClass & test.MyTrait[? <: test.MyTrait[test.MyTrait[?]#E]]](),
      java.io.Serializable
     {
      override final def isDefinedAt(x: test.MyClass): Boolean =
        matchResult4[Boolean]: 
          {
            case val x5: (x : test.MyClass) @unchecked @unchecked =
              x:(x : test.MyClass) @unchecked:
                (x : test.MyClass) @unchecked @unchecked
            if x5.$isInstanceOf[test.MyTrait[_] @_$1] then
              {
                case val e: test.MyClass & test.MyTrait[_] =
                  x5.$asInstanceOf[test.MyTrait[_] @_$1].$asInstanceOf[
                    test.MyClass & test.MyTrait[_]
                  ]
                return[matchResult4] true
              }
             else ()
            return[matchResult4] false
          }
      override final def applyOrElse[A1 <: test.MyClass,
        B1 >: test.MyClass & test.MyTrait[? <: test.MyTrait[test.MyTrait[?]#E]]
      ](x: A1, default: A1 => B1): B1 =
        matchResult5[Object]: 
          {
            case val x7: (x : test.MyClass) @unchecked @unchecked =
              x:(x : test.MyClass) @unchecked:
                (x : test.MyClass) @unchecked @unchecked
            if x7.$isInstanceOf[test.MyTrait[_] @_$1] then
              {
                case val e: test.MyClass & test.MyTrait[_] =
                  x7.$asInstanceOf[test.MyTrait[_] @_$1].$asInstanceOf[
                    test.MyClass & test.MyTrait[_]
                  ]
                return[matchResult5]
                  {
                    e:
                      test.MyClass & 
                        test.MyTrait[? <: test.MyTrait[test.MyTrait[?]#E]]

                  }
              }
             else ()
            return[matchResult5] default.apply(x)
          }
    }
    new scala.runtime.AbstractPartialFunction with java.io.Serializable {...}()
  }
).<none>

Expectation

The code should work (it works fine on 2.13).

Also, the following variations compile just fine on 3.2.1:

trait MyTrait[E <: MyTrait[E]]

case class MyClass() extends MyTrait[MyClass]

// With a helper type
type Helper = MyTrait[_]

List(MyClass()).collect {
	case e: Helper => e
}.collect {
  case e: Helper => e
}

trait MyTrait[E <: MyTrait[E]]

case class MyClass() extends MyTrait[MyClass]

// Computation split in two steps with an helper variable
val x = List(MyClass()).collect {
	case e: MyTrait[_] => e
}
x.collect {
  case e: MyTrait[_] => e
}

// No F-bounds
trait MyTrait[E]

case class MyClass() extends MyTrait[MyClass]

List(MyClass()).collect {
	case e: MyTrait[_] => e
}.collect {
  case e: MyTrait[_] => e
}

[jchyb]

The minimizations lack a top level method, so they fail earlier when using scalac (of course, they will work when used as .sc files in scala-cli), e.g.:

trait MyTrait[E <: MyTrait[E]]

case class MyClass() extends MyTrait[MyClass]

def main =
  List(MyClass()).collect {
    case e: MyTrait[_] => e
  }.collect {
    case e: MyTrait[_] => e
  }