Unreachable case warning for Option[A] match when A is sealed and extended by a private abstract class

[DarkWingMcQuack]

Compiler version

3.3.7 - 3.8.1

Minimized code

sealed trait A

object A {
  private abstract class B extends A

  def ccc(oa: Option[A]) = oa match {
    case Some(_) => println("match")
    case None => println("no match")}
}

The warning appears only when all of these are true:

• A is sealed
• B is abstract
• B is private

Output

[info] compiling 1 Scala source to /home/.../reproduction/target/scala-3.7.4/classes ...
[warn] -- [E030] Match case Unreachable Warning: /home/.../reproduction/src/main/scala/Repro.scala:8:11
[warn] 8 |      case Some(_) => println("reachable")
[warn]   |           ^^^^^^^
[warn]   |           Unreachable case
[warn] one warning found
[success] Total time: 2 s, completed 17.02.2026, 16:10:03

Expectation

No Unreachable case warning. case Some(_) is reachable because oa: Option[A] may contain a value of type A.

[som-snytt]

It's reachable for Some(null.asInstanceOf[A]), but it's also true that extractors don't receive null, so I wonder how the pattern match should work in Scala 3.

[sjrd]

null is generally considered not to happen, otherwise pattern match exhaustivity would be useless. So this looks correct to me.

[DarkWingMcQuack]

I stumbled accross this when creating something like this für skunk sessions

class SkunkTransactionManager(pool: Resource[IO, Session[IO]], local: IOLocal[Option[Session[IO]]]):

  def transaction[A](fa: IO[A]): IO[A] =
    local.get.flatMap {
      // Already in a transaction, just execute
      case Some(_) => fa
      // Not in a transaction, borrow from pool and start transaction
      case None    =>
        pool.flatTap(x => x.transaction).use { session =>
          local.set(Some(session)) *> fa.guarantee(local.reset)
        }
    }

  def session: Resource[IO, Session[IO]] =
    Resource.eval(local.get.to[IO]).flatMap {
      case Some(s) => Resource.pure(s)
      case None    => pool
    }

It didn’t really make sense to me why this would be unreachable.

[som-snytt]

What message do you see? I don't see any diagnostic with this example.

The original example does not warn for A.ccc(Some(new A {})).

Oh, I see, it warns for

sealed trait A

object A {
  private abstract class B extends A

  def ccc(oa: Option[A]) = oa match {
    case Some(_) => println("match")
    case None => println("no match")
  }

  def b: A = new B {}
}

@main def main =
  println:
    A.ccc(Some(A.b))

[BalmungSan]

Here is a Scastie that is closer to the real code: https://scastie.scala-lang.org/BalmungSan/QaSzmWeTQ0eyT952zoo8fA/1

The point is that A can be instantiated, even if the compiler thinks it can't.