Fix @switch warnings for matches on value classes

Matches on value classes that have an underlying switchable type may be
emitted as tableswitch or lookupswitch, but the shape of the result tree
differs from ordinary switch-compiled matches.

Previously, this caused a spurious warning to be issued if such a match
was annotated with @switch, as none of the result cases were discovered
by the warning logic, and hence the match was warned as having too few cases.

With the warning for too few cases now removed, we have the opposite
issue: in no circumstance is a switch warning issued for @switch
annotated matches on value classes.

This commit attempts to address this issue and restore the @switch
warnings for those matches on value classes where a tableswitch or
lookupswitch is not emitted.

A complicating factor is that the original case types for matches
on value class extractors are not singleton types, and so counting
the number of unique types is not useful for determining the number
of original cases.

Author: griggt

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -973,15 +973,19 @@ object PatternMatcher {
         val resultCases = result match
           case Match(_, cases) => cases
           case Block(_, Match(_, cases)) => cases
+          case Block((_: ValDef) :: Block(_, Match(_, cases)) :: Nil, _) => cases
           case _ => Nil
+        val caseThreshold =
+          if ValueClasses.isDerivedValueClass(tpt.tpe.widen.typeSymbol) then 1
+          else MinSwitchCases
         def typesInPattern(pat: Tree): List[Type] = pat match
           case Alternative(pats) => pats.flatMap(typesInPattern)
           case _ => pat.tpe :: Nil
         def typesInCases(cdefs: List[CaseDef]): List[Type] =
           cdefs.flatMap(cdef => typesInPattern(cdef.pat))
         def numTypes(cdefs: List[CaseDef]): Int =
           typesInCases(cdefs).toSet.size: Int // without the type ascription, testPickling fails because of #2840.
-        if numTypes(original.cases) >= MinSwitchCases && numTypes(resultCases) < numTypes(original.cases) then
+        if numTypes(original.cases) >= caseThreshold && numTypes(resultCases) < numTypes(original.cases) then
           patmatch.println(i"switch warning for ${ctx.compilationUnit}")
           patmatch.println(i"original types: ${typesInCases(original.cases)}%, %")
           patmatch.println(i"switch types  : ${typesInCases(resultCases)}%, %")

tests/neg-custom-args/fatal-warnings/switches.scala

@@ -76,4 +76,25 @@ object Main {
     case 1 | 2 | 3 => true
     case _ => false
   }
+
+  case class IntAnyVal(x: Int) extends AnyVal
+
+  val Ten = IntAnyVal(10)
+  def fail5(x: IntAnyVal) = (x: @switch) match { // error: Could not emit switch for @switch annotated match
+    case IntAnyVal(1) => 0
+    case Ten           => 1
+    case IntAnyVal(100) => 2
+    case IntAnyVal(1000) => 3
+    case IntAnyVal(10000) => 4
+  }
+
+  // the generated lookupswitch covers only a subset of the cases
+  final val One = IntAnyVal(1)
+  def fail6(x: IntAnyVal) = (x: @switch) match { // error: Could not emit switch for @switch annotated match
+    case One          => 0
+    case IntAnyVal(10) => 1
+    case IntAnyVal(100) => 2
+    case IntAnyVal(1000) => 3
+    case IntAnyVal(10000) => 4
+  }
 }

tests/pos-special/fatal-warnings/switches.scala

@@ -33,8 +33,18 @@ class Test {
     case 1 | 2 | 3 => true
     case _ => false
   }
+
+  def test6(x: IntAnyVal) = (x: @switch) match {
+    case IntAnyVal(1) => 0
+    case IntAnyVal(10) => 1
+    case IntAnyVal(100) => 2
+    case IntAnyVal(1000) => 3
+    case IntAnyVal(10000) => 4
+  }
 }
 
+case class IntAnyVal(x: Int) extends AnyVal
+
 object Test {
   final val LF = '\u000A'
   final val CR = '\u000D'