refactor default case, test default cases

Author: bishabosha

compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala

@@ -161,7 +161,7 @@ object DesugarEnums {
         fromOrdinalMeth(throwArg)
       else
         def default(ordinal: Tree) =
-          CaseDef(Ident(nme.x_0), EmptyTree, throwArg(ordinal))
+          CaseDef(Ident(nme.WILDCARD), EmptyTree, throwArg(ordinal))
         if constraints.isEnumeration then
           fromOrdinalMeth(ordinal =>
             Try(Apply(valuesDot(nme.apply), ordinal), default(ordinal) :: Nil, EmptyTree))

tests/run/enum-values.scala

@@ -4,6 +4,9 @@ import deriving.Mirror
 enum Color:
   case Red, Green, Blue
 
+enum Suits extends java.lang.Enum[Suits]:
+  case Clubs, Spades, Diamonds, Hearts
+
 enum Tag[T]:
   case Int extends Tag[Int]
   case OfClass[T]()(using val tag: reflect.ClassTag[T]) extends Tag[T] // mix order of class and value
@@ -29,7 +32,7 @@ enum ClassOnly: // this should still generate the `ordinal` and `fromOrdinal` co
   case BranchProd(i: Int)
 
 @main def Test: Unit =
-  import Color._, Tag._, Expr._, ListLike._, TypeCtorsK._, MixedParams._, ClassOnly._
+  import Color._, Suits._, Tag._, Expr._, ListLike._, TypeCtorsK._, MixedParams._, ClassOnly._
 
   type FromOrdinal[T] = {
     def fromOrdinal(ordinal: Int): T
@@ -47,15 +50,19 @@ enum ClassOnly: // this should still generate the `ordinal` and `fromOrdinal` co
         s"$c does not `eq` companion.fromOrdinal(${c.ordinal}), got ${companion.fromOrdinal(c.ordinal)}")
 
   def notFromOrdinal[T <: AnyRef & reflect.Enum](companion: FromOrdinal[T], compare: T): Unit =
+    cantFind(companion, compare.ordinal)
+
+  def cantFind[T](companion: FromOrdinal[T], ordinal: Int): Unit =
     try
-      companion.fromOrdinal(compare.ordinal)
-      assertFail(s"$companion.fromOrdinal(${compare.ordinal}) did not fail")
+      companion.fromOrdinal(ordinal)
+      assertFail(s"$companion.fromOrdinal(${ordinal}) did not fail")
     catch
       case e: java.lang.reflect.InvocationTargetException => // TODO: maybe reflect.Selectable should catch this?
         assert(e.getCause.isInstanceOf[java.util.NoSuchElementException]
-          && e.getCause.getMessage == compare.ordinal.toString)
+          && e.getCause.getMessage == ordinal.toString)
 
   fetchFromOrdinal(companion = Color,       compare = Red, Green, Blue)
+  fetchFromOrdinal(companion = Suits,       compare = Clubs, Spades, Diamonds, Hearts)
   fetchFromOrdinal(companion = Tag,         compare = Int, String)
   fetchFromOrdinal(companion = Expr,        compare = EmptyTree, AnyTree)
   fetchFromOrdinal(companion = ListLike,    compare = EmptyListLike)
@@ -66,6 +73,11 @@ enum ClassOnly: // this should still generate the `ordinal` and `fromOrdinal` co
   notFromOrdinal(companion = TypeCtorsK, compare = Const[String]())
   notFromOrdinal(companion = ClassOnly,  compare = BranchProd(1)) // ClassOnly has the `fromOrdinal` method
 
+  cantFind(companion = Color,     ordinal = 500) // test default case for enumeration
+  cantFind(companion = Suits,     ordinal = 500) // test default case for Java style enumeration
+  cantFind(companion = Tag,       ordinal = 500) // test default case for mixed adt with non-simple values
+  cantFind(companion = ClassOnly, ordinal = 500) // should always throw
+
   assert(summon[Mirror.SumOf[ClassOnly]].ordinal(BranchProd(1)) == 0)
 
   val colors: Array[Color]             = Color.values