Pattern Matching generates incorrect code when matching a nested case class

[smarter]

The following code:

case class Foo(val underlying: Int)

object O {
  def test(): Unit = {
    val x: Option[Foo] = Some(Foo(1))
    x match {
      case Some(m) =>
        println(m)
    }
  }
}

Generates after patternMatcher:

final module class O$() extends Object() { this: O.type => 
  def test(): Unit = {
    val x: Option[Foo] = Some.apply[Foo'](Foo.apply(1))
    {
      case val selector12: Option[Foo] = x
      {
        def case31(): Unit = {
          def matchFail21(): Unit = throw new MatchError(selector12)
          if selector12.isInstanceOf[Some[Foo']] then {
            val x21: Some[Foo'] = selector12.asInstanceOf[Some[Foo']]
            {
              val o41: Option[Foo] = 
                Some.unapply[Foo'](selector12.asInstanceOf[Some[Foo']])
              if o41.isDefined then {
                val x31: Foo = o41.get
                {
                  val m: Foo = x31._1.asInstanceOf[Foo]
                  {
                    {
                      println(m)
                    }
                  }
                }
              } else matchFail21()
            }
          } else matchFail21()
        }
        case31()
      }
    }
  }
}

Note that x31 has type Foo, but the next line calls x31._1.asInstanceOf[Foo] which does not make sense as the accessor of Foo has type Int, not Foo.

[smarter]

@DarkDimius : Could you take a look ?

[DarkDimius]

@smarter could you test for case class with 2 fields, will the problem persist?
It seems that I haven't entirely fixed https://issues.scala-lang.org/browse/SI-7897

[smarter]

@DarkDimius: with 2 fields in Foo, same problem:

final module class O$() extends Object() { this: O.type => 
  def test(): Unit = {
    val x: Option[Foo] = Some.apply[Foo'](Foo.apply(1, 2))
    {
      case val selector12: Option[Foo] = x
      {
        def case31(): Unit = {
          def matchFail21(): Unit = throw new MatchError(selector12)
          if selector12.isInstanceOf[Some[Foo']] then {
            val x21: Some[Foo'] = selector12.asInstanceOf[Some[Foo']]
            {
              val o41: Option[Foo] = 
                Some.unapply[Foo'](selector12.asInstanceOf[Some[Foo']])
              if o41.isDefined then {
                val x31: Foo = o41.get
                {
                  val m: Foo = x31._1.asInstanceOf[Foo]
                  {
                    {
                      println(m)
                    }
                  }
                }
              } else matchFail21()
            }
          } else matchFail21()
        }
        case31()
      }
    }
  }
}

[smarter]

The problem doesn't seem to happen if I replace Option by a custom case class:

case class Foo(val ff: Int)
sealed trait Option2[T]
case class Some2[T](underlying: T) extends Option2[T]
case object None2 extends Option2[Nothing]

object O {
  def test(): Unit = {
    val x: Option2[Foo] = Some2(Foo(1))
    x match {
      case Some2(m) =>
        println(m)
    }
  }
}

Becomes:

final module class O$() extends Object() { this: O.type => 
  def test(): Unit = {
    val x: Option2[Foo] = Some2.apply[Foo'](Foo.apply(1))
    {
      case val selector13: Option2[Foo] = x
      {
        def case51(): Unit = {
          def matchFail31(): Unit = throw new MatchError(selector13)
          if selector13.isInstanceOf[Some2[Foo']] then {
            val x21: Some2[Foo'] = selector13.asInstanceOf[Some2[Foo']]
            {
              val x31: Some2[Foo] = 
                Some2.unapply[Foo'](selector13.asInstanceOf[Some2[Foo']])
              {
                val m: Foo = x31._1
                {
                  {
                    println(m)
                  }
                }
              }
            }
          } else matchFail31()
        }
        case51()
      }
    }
  }
}

[DarkDimius]

b8807ca I guess should fix it, but I'm not sure if it wouldn't break something else.
That's a particular moment when we need run tests to validate that pattern matching does what it should do.