remove repeated logic and add test for range based case

compiler/ast/ast_query.nim

@@ -711,19 +711,15 @@ proc endsInNoReturn*(n: PNode): bool =
       result = endsInNoReturn(n[i])
       if not result:
         break
-    # xxx: this duplicates logic in `semstmts.semCase`, this should eventually
-    #      be combined
     let
-      caseType = n[0].typ.skipTypes(abstractInst - {tyTypeDesc})
+      caseType = n[0].typ.skipTypes(abstractRange)
       requiresElse =
         case caseType.kind
-        of tyCaseExhaustive:
-          false
-        of tyRange:
-          not (caseType[0].skipTypes(abstractInst).kind in tyCaseExhaustive)
-        else:
+        of tyFloat..tyFloat64, tyString:
           true
-    result = result and (not requiresElse or n[^1].kind == nkElse)
+        else:
+          false
+    result = result and (n[^1].kind == nkElse or not requiresElse)
   of nkTryStmt:
     # ignore the 'finally' -- it doesn't contribute to the type
     for i in 0..<(n.len - ord(n[^1].kind == nkFinally)):

compiler/ast/ast_types.nim

@@ -593,10 +593,6 @@ const
     ## type-bound operations are attached to. User type-classes are also
     ## unconditionally included in this set
 
-  tyCaseExhaustive* = {tyInt..tyInt64, tyChar, tyEnum, tyUInt..tyUInt64,
-                       tyBool}
-    ## types that need exhaustiveness checking for case statement selectors
-
 type
   TTypeKinds* = set[TTypeKind]
 

compiler/sem/semstmts.nim

@@ -1641,14 +1641,13 @@ proc semCase(c: PContext, n: PNode; flags: TExprFlags): PNode =
   var covered: Int128 = toInt128(0)
   var typ = commonTypeBegin
   var hasElse = false
-  # xxx: the exhaustiveness logic is duplicated in `ast_query.endsInNoReturn`,
-  #      this should eventually be combined.
   let caseTyp = skipTypes(selector, abstractInst-{tyTypeDesc})
+  const shouldChckCovered = {tyInt..tyInt64, tyChar, tyEnum, tyUInt..tyUInt64, tyBool}
   case caseTyp.kind
-  of tyCaseExhaustive:
+  of shouldChckCovered:
     chckCovered = true
   of tyRange:
-    if skipTypes(caseTyp[0], abstractInst).kind in tyCaseExhaustive:
+    if skipTypes(caseTyp[0], abstractInst).kind in shouldChckCovered:
       chckCovered = true
   of tyFloat..tyFloat64, tyString:
     discard "not all possible values have to be covered"

tests/lang_exprs/tnoreturn_nested.nim

@@ -42,6 +42,17 @@ block nested_in_case:
 
   doAssert x is int
 
+  block nested_in_case_range:
+    type Foo = range[1..1]
+    let x =
+      if true:
+        0
+      else:
+        let y: Foo = 1
+        case y
+        of 1:
+          raise newException(CatchableError, "error")
+
 block nested_in_block:
   let x =
     if true: