Exhaustivity warning should tell you when outer pointer is the cause

[scabug]

Example:

sealed trait Foo {
    val index: Int
}

case class BasicFoo(index: Int) extends Foo

class NonExhaustive {
    case class FancyFoo(index: Int) extends Foo

    def convert(foos: Vector[Foo]): Vector[Int] = {
        foos.foldLeft(Vector.empty[Int]) {
            case (acc, basic: BasicFoo) => acc :+ basic.index
            case (acc, fancy: FancyFoo) => acc :+ fancy.index
        }
    }
}

Output:

NonExhaustive.scala:15: match may not be exhaustive.
It would fail on the following input: (_, FancyFoo(_))
foos.foldLeft(Vector.empty[Int]) {
                                 ^

This doesn't make sense, because the code explicitly matches that pattern.

If I move the definition of FancyFoo out of NonExhaustive, the warning goes away.

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-10100?orig=1
Reporter: Benjamin Geer (benjamingeer)
Affected Versions: 2.12.1

[liufengyun]

The compiler is actually correct here (Dotty also reports a warning). It's possible to for the pattern match to fail at runtime:

sealed trait Foo {
  val index: Int
}

case class BasicFoo(index: Int) extends Foo

class NonExhaustive {
  case class FancyFoo(index: Int) extends Foo

  def convert(foos: Vector[Foo]): Vector[Int] = {
    foos.foldLeft(Vector.empty[Int]) {
      case (acc, basic: BasicFoo) => acc :+ basic.index
      case (acc, fancy: FancyFoo) => acc :+ fancy.index
    }
  }
}

@main
def Test = {
  val a = new NonExhaustive
  val b = new NonExhaustive

  val fa: Foo = a.FancyFoo(3)
  val fb: Foo = b.FancyFoo(4)

  a.convert(Vector(fa, fb))
}

[dwijnand]

Agreed. But there's still a UX bug: neither the message nor the counter-examples explain that it's to do with the outer pointer.