add version of Nat to int using enums

Author: bishabosha

compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala

@@ -354,8 +354,11 @@ trait ConstraintHandling {
       case WildcardType(optBounds) => optBounds.exists && isSingleton(optBounds.bounds.hi)
       case _ => isSubTypeWhenFrozen(tp, defn.SingletonType)
 
+    def isEnumBound(tp: Type): Boolean =
+      bound.isValueType && bound.typeSymbol.is(Enum, butNot=JavaDefined) && tp <:< bound
+
     val wideInst =
-      if isSingleton(bound) then inst
+      if isSingleton(bound) || isEnumBound(bound) then inst
       else dropSuperTraits(widenOr(widenSingle(inst)))
     wideInst match
       case wideInst: TypeRef if wideInst.symbol.is(Module) =>

tests/neg/enum-widen.scala

@@ -0,0 +1,19 @@
+import Nat._
+
+enum Nat:
+  case Zero
+  case Succ[N <: Nat](n: N)
+
+enum MyEnum:
+  case A[E <: Enum](e: E)
+
+final case class Foo[T](t: T)
+
+inline def willNotReduce1 = inline Foo(Zero) match // assert that enums are widened when the bound is not a parent enum type
+  case Foo(Zero) => ()
+
+inline def willNotReduce2 = inline MyEnum.A(Zero) match // assert that enums are only narrowed when bound is own enum type
+  case MyEnum.A(Zero) => ()
+
+val foo = willNotReduce1 // error: cannot reduce inline match with scrutinee: Foo.apply[Nat](Nat$#Zero) : Foo[Nat]
+val bar = willNotReduce2 // error: cannot reduce inline match with scrutinee: MyEnum.A.apply[Nat](Nat$#Zero): MyEnum.A[Nat]

tests/run/enum-nat.scala

@@ -0,0 +1,25 @@
+import Nat._
+import compiletime._
+
+enum Nat:
+  case Zero
+  case Succ[N <: Nat](n: N)
+
+inline def toIntTypeLevel[N <: Nat]: Int = inline erasedValue[N] match
+  case _: Zero.type => 0
+  case _: Succ[n]   => toIntTypeLevel[n] + 1
+
+inline def toInt(inline nat: Nat): Int = inline nat match
+  case nat: Zero.type => 0
+  case nat: Succ[n]   => toInt(nat.n) + 1
+
+inline def toIntTypeTailRec[N <: Nat, Acc <: Int]: Int = inline erasedValue[N] match
+  case _: Zero.type => constValue[Acc]
+  case _: Succ[n]   => toIntTypeTailRec[n, S[Acc]]
+
+inline def toIntErased[N <: Nat](inline nat: N): Int = toIntTypeTailRec[N, 0]
+
+@main def Test: Unit =
+  assert(toIntTypeLevel[Succ[Succ[Zero.type]]] == 2)
+  assert(toInt(Succ(Succ(Zero))) == 2)
+  assert(toIntErased(Succ(Succ(Zero))) == 2)