strange MatchError if match body has generic method call without explicit type param

[xuwei-k]

Compiler version

3.0.0, 3.0.1-RC2 and 3.0.2-RC1-bin-20210626-f33bc8d-NIGHTLY

Minimized code

package example

case class A(s: String)

class B {
  def b1[X](str: String): String = str

  def b2[X](str: String): X = null.asInstanceOf[X]
}

object Main {

  def main(args: Array[String]): Unit = {
    val a = A("aaa")
    val b = new B

    // no error
    a match {
      case A(s) =>
        b.b1(s)
    }

    // no error if add explicit type param
    a match {
      case A(s) =>
        b.b2[Boolean](s)
    }

    // scala.MatchError: A(aaa)
    a match {
      case A(s) =>
        b.b2(s)
    }
  }

}

Output

[info] running example.Main 
[error] (run-main-5) scala.MatchError: A(aaa) (of class example.A)
[error] scala.MatchError: A(aaa) (of class example.A)
[error] 	at example.Main$.main(Main.scala:32)
[error] 	at example.Main.main(Main.scala)
[error] 	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
[error] 	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
[error] 	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
[error] 	at java.lang.reflect.Method.invoke(Method.java:498)

Expectation

[dwijnand]

Is the expected type Unit of main propagating backwards to b2? And is that then affecting the match translation? Or is the problem elsewhere? 🤔

[odersky]

Here's the code of the main method after pattern matcher:

    def main(args: Array[String]): Unit = 
      {
        val a: A = A.apply("aaa")
        val b: B = new B()
        matchResult4[String]: 
          {
            case val x5: (a : A) = a
            if x5.ne(null) then 
              {
                case val x6: A = A.unapply(x5)
                case val x7: String = x6._1
                case val s: String = x7
                return[matchResult4] 
                  {
                    b.b1[Any](s)
                  }
              }
             else ()
            throw new MatchError(x5)
          }
        matchResult5[Boolean]: 
          {
            case val x8: (a : A) = a
            if x8.ne(null) then 
              {
                case val x9: A = A.unapply(x8)
                case val x10: String = x9._1
                case val s: String = x10
                return[matchResult5] 
                  {
                    b.b2[Boolean](s)
                  }
              }
             else ()
            throw new MatchError(x8)
          }
        matchResult6[Nothing]: 
          {
            case val x11: (a : A) = a
            if x11.ne(null) then 
              {
                case val x12: A = A.unapply(x11)
                case val x13: String = x12._1
                case val s: String = x13
                b.b2[Nothing](s)
              }
             else ()
            throw new MatchError(x11)
          }
      }

In the third case, the return around the body of the case is missing, which means that we run into the MatchError that follows.

I think we should either reject that case statically, or not leave out the return.

[odersky]

The case where it happens is here (line 931 of Pattern Matcher)

        case ResultPlan(tree) =>
          if (tree.tpe <:< defn.NothingType) tree // For example MatchError
          else Return(tree, ref(resultLabel))

The commit is from #5082.