@ttsc/lint 0.18.4 → 0.19.1

package/linthost/rules_ts_switch_exhaustiveness_check.go

@@ -1,33 +1,52 @@
-// switchExhaustivenessCheck reports `switch (e)` statements where the
-// discriminant is a union of literal types or an enum and at least one
-// constituent has no matching `case` clause AND the switch carries no
-// `default` clause. Either covering every member explicitly or adding a
-// `default` arm makes the intent visible and forces the compiler to
-// flag any future addition to the union/enum at every switch site.
-// typescript-eslint strict-type-checked:
+// typescript/switch-exhaustiveness-check: require switches over finite
+// discriminants to cover every enumerable member. The implementation mirrors
+// typescript-eslint's scalar defaults and option interactions while using the
+// TypeScript-Go Checker as the type oracle.
+//
+// Reference:
 // https://typescript-eslint.io/rules/switch-exhaustiveness-check/
 package linthost
 
 import (
+  "regexp"
+  "strings"
+
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
-// switchExhaustivenessCheck is type-aware: the discriminant is resolved
-// via the Checker, and uncovered members are computed by removing every
-// case-clause expression's type from the union's constituent set. The
-// rule only fires when the discriminant resolves to a union — plain
-// `string` or `number` discriminants are open-ended and outside the
-// rule's scope, matching typescript-eslint's behavior.
-//
-// Identity is established by `*Type` pointer comparison rather than
-// literal value comparison: TypeScript canonicalizes string and number
-// literal types (`stringLiteralTypes` / `numberLiteralTypes` maps inside
-// the checker), so two references to `"a"` resolve to the same `*Type`
-// instance. Enum literal types are likewise canonicalized per enum
-// member, so `case E.A:` and the `E.A` constituent of the discriminant's
-// union share their `*Type` pointer.
-type switchExhaustivenessCheck struct{}
+type switchExhaustivenessCheck struct{ optionsRule }
+
+type switchExhaustivenessCheckOptions struct {
+  AllowDefaultCaseForExhaustiveSwitch *bool   `json:"allowDefaultCaseForExhaustiveSwitch"`
+  ConsiderDefaultExhaustiveForUnions  *bool   `json:"considerDefaultExhaustiveForUnions"`
+  DefaultCaseCommentPattern           *string `json:"defaultCaseCommentPattern"`
+  RequireDefaultForNonUnion           *bool   `json:"requireDefaultForNonUnion"`
+}
+
+type resolvedSwitchExhaustivenessCheckOptions struct {
+  allowDefaultCaseForExhaustiveSwitch bool
+  considerDefaultExhaustiveForUnions  bool
+  defaultCaseCommentPattern           *regexp.Regexp
+  requireDefaultForNonUnion           bool
+}
+
+type switchExhaustivenessCheckDefaultCase struct {
+  node *shimast.Node
+  pos  int
+  end  int
+}
+
+type switchExhaustivenessCheckMetadata struct {
+  containsNonLiteralType bool
+  defaultCase            *switchExhaustivenessCheckDefaultCase
+  caseBlock              *shimast.Node
+  lastClause             *shimast.Node
+  missingMembers         []*shimchecker.Type
+}
+
+var switchExhaustivenessCheckDefaultCommentPattern = regexp.MustCompile(`(?i)^no default$`)
 
 func (switchExhaustivenessCheck) Name() string { return "typescript/switch-exhaustiveness-check" }
 func (switchExhaustivenessCheck) NeedsTypeChecker() bool {
@@ -40,106 +59,557 @@ func (switchExhaustivenessCheck) Check(ctx *Context, node *shimast.Node) {
   if ctx.Checker == nil {
     return
   }
-  sw := node.AsSwitchStatement()
-  if sw == nil || sw.Expression == nil || sw.CaseBlock == nil {
+
+  var rawOptions switchExhaustivenessCheckOptions
+  if err := ctx.DecodeOptions(&rawOptions); err != nil {
     return
   }
-  block := sw.CaseBlock.AsCaseBlock()
-  if block == nil || block.Clauses == nil {
+  options := resolveSwitchExhaustivenessCheckOptions(rawOptions)
+  metadata := switchExhaustivenessCheckCollectMetadata(
+    ctx,
+    node,
+    options.defaultCaseCommentPattern,
+  )
+  if metadata == nil {
     return
   }
-  // A `default` clause covers anything not enumerated above, so the
-  // rule has nothing to add. typescript-eslint also exits early in
-  // this case.
-  for _, clause := range block.Clauses.Nodes {
-    if clause != nil && clause.Kind == shimast.KindDefaultClause {
-      return
+
+  sw := node.AsSwitchStatement()
+  if sw == nil || sw.Expression == nil {
+    return
+  }
+
+  if !(options.considerDefaultExhaustiveForUnions && metadata.defaultCase != nil) &&
+    len(metadata.missingMembers) > 0 {
+    missing := make([]string, 0, len(metadata.missingMembers))
+    for _, member := range metadata.missingMembers {
+      missing = append(missing, switchExhaustivenessCheckTypeName(ctx.Checker, sw.Expression, member))
+    }
+    message := "Switch is not exhaustive. Cases not matched: " + strings.Join(missing, " | ")
+    if edit, ok := switchExhaustivenessCheckSuggestion(
+      ctx,
+      node,
+      metadata,
+      metadata.missingMembers,
+      false,
+    ); ok {
+      ctx.ReportSuggestion(sw.Expression, message, "Add branches for missing cases.", edit)
+    } else {
+      ctx.Report(sw.Expression, message)
     }
   }
-  discriminantType := ctx.Checker.GetTypeAtLocation(sw.Expression)
-  if discriminantType == nil {
-    return
+
+  if !options.allowDefaultCaseForExhaustiveSwitch &&
+    len(metadata.missingMembers) == 0 &&
+    metadata.defaultCase != nil &&
+    !metadata.containsNonLiteralType {
+    switchExhaustivenessCheckReportDefaultCase(
+      ctx,
+      metadata.defaultCase,
+      "The switch statement is exhaustive, so the default case is unnecessary.",
+    )
   }
-  // Only consider discriminants whose static type is a finite union of
-  // literal-like constituents. Plain `string` / `number` / `unknown`
-  // are open-ended and never exhaustively coverable.
-  members := switchExhaustivenessCheckCollectMembers(discriminantType)
-  if len(members) == 0 {
-    return
+
+  if options.requireDefaultForNonUnion &&
+    metadata.containsNonLiteralType &&
+    metadata.defaultCase == nil {
+    const message = "Switch is not exhaustive. Cases not matched: default"
+    if edit, ok := switchExhaustivenessCheckSuggestion(
+      ctx,
+      node,
+      metadata,
+      nil,
+      true,
+    ); ok {
+      ctx.ReportSuggestion(sw.Expression, message, "Add a default branch.", edit)
+    } else {
+      ctx.Report(sw.Expression, message)
+    }
+  }
+}
+
+func resolveSwitchExhaustivenessCheckOptions(
+  raw switchExhaustivenessCheckOptions,
+) resolvedSwitchExhaustivenessCheckOptions {
+  resolved := resolvedSwitchExhaustivenessCheckOptions{
+    allowDefaultCaseForExhaustiveSwitch: true,
+    defaultCaseCommentPattern:           switchExhaustivenessCheckDefaultCommentPattern,
+  }
+  if raw.AllowDefaultCaseForExhaustiveSwitch != nil {
+    resolved.allowDefaultCaseForExhaustiveSwitch = *raw.AllowDefaultCaseForExhaustiveSwitch
+  }
+  if raw.ConsiderDefaultExhaustiveForUnions != nil {
+    resolved.considerDefaultExhaustiveForUnions = *raw.ConsiderDefaultExhaustiveForUnions
+  }
+  if raw.RequireDefaultForNonUnion != nil {
+    resolved.requireDefaultForNonUnion = *raw.RequireDefaultForNonUnion
+  }
+  if raw.DefaultCaseCommentPattern != nil {
+    pattern, err := regexp.Compile(*raw.DefaultCaseCommentPattern)
+    if err != nil {
+      resolved.defaultCaseCommentPattern = nil
+    } else {
+      resolved.defaultCaseCommentPattern = pattern
+    }
   }
-  covered := make(map[*shimchecker.Type]bool, len(members))
+  return resolved
+}
+
+// switchExhaustivenessCheckCollectMetadata resolves the discriminant and case
+// expressions through their base constraints, then computes missing literal
+// branches before applying any policy option. Open primitive constituents are
+// recorded independently, so `string | undefined` keeps `undefined` enumerable
+// without pretending the `string` portion can be exhausted.
+func switchExhaustivenessCheckCollectMetadata(
+  ctx *Context,
+  node *shimast.Node,
+  commentPattern *regexp.Regexp,
+) *switchExhaustivenessCheckMetadata {
+  sw := node.AsSwitchStatement()
+  if sw == nil || sw.Expression == nil || sw.CaseBlock == nil {
+    return nil
+  }
+  block := sw.CaseBlock.AsCaseBlock()
+  if block == nil || block.Clauses == nil {
+    return nil
+  }
+
+  discriminantType := switchExhaustivenessCheckConstrainedType(
+    ctx.Checker,
+    ctx.Checker.GetTypeAtLocation(sw.Expression),
+  )
+  if discriminantType == nil {
+    return nil
+  }
+
+  caseTypes := make([]*shimchecker.Type, 0, len(block.Clauses.Nodes))
+  var defaultCase *switchExhaustivenessCheckDefaultCase
+  var lastClause *shimast.Node
   for _, clause := range block.Clauses.Nodes {
-    if clause == nil || clause.Kind != shimast.KindCaseClause {
+    if clause == nil {
+      continue
+    }
+    lastClause = clause
+    if clause.Kind == shimast.KindDefaultClause {
+      if defaultCase == nil {
+        pos, _ := tokenRange(ctx.File, clause)
+        defaultCase = &switchExhaustivenessCheckDefaultCase{node: clause, pos: pos}
+      }
+      continue
+    }
+    if clause.Kind != shimast.KindCaseClause {
       continue
     }
     caseClause := clause.AsCaseOrDefaultClause()
     if caseClause == nil || caseClause.Expression == nil {
       continue
     }
-    caseType := ctx.Checker.GetTypeAtLocation(caseClause.Expression)
-    if caseType == nil {
+    caseType := switchExhaustivenessCheckConstrainedType(
+      ctx.Checker,
+      ctx.Checker.GetTypeAtLocation(caseClause.Expression),
+    )
+    if caseType != nil {
+      caseTypes = append(caseTypes, caseType)
+    }
+  }
+  if defaultCase == nil {
+    defaultCase = switchExhaustivenessCheckCommentDefaultCase(
+      ctx,
+      sw.CaseBlock,
+      lastClause,
+      commentPattern,
+    )
+  }
+
+  members, containsNonLiteralType := switchExhaustivenessCheckTypeParts(ctx.Checker, discriminantType)
+  missing := make([]*shimchecker.Type, 0, len(members))
+  for _, member := range members {
+    if !switchExhaustivenessCheckCaseTypesCover(caseTypes, member) {
+      missing = append(missing, member)
+    }
+  }
+  return &switchExhaustivenessCheckMetadata{
+    containsNonLiteralType: containsNonLiteralType,
+    defaultCase:            defaultCase,
+    caseBlock:              sw.CaseBlock,
+    lastClause:             lastClause,
+    missingMembers:         missing,
+  }
+}
+
+func switchExhaustivenessCheckConstrainedType(
+  checker *shimchecker.Checker,
+  t *shimchecker.Type,
+) *shimchecker.Type {
+  if checker == nil || t == nil {
+    return t
+  }
+  if constraint := checker.GetBaseConstraintOfType(t); constraint != nil {
+    t = constraint
+  }
+  return shimchecker.Checker_getRegularTypeOfLiteralType(checker, t)
+}
+
+// switchExhaustivenessCheckTypeParts mirrors typescript-eslint's nested
+// unionConstituents/intersectionConstituents walk. Literal-like intersection
+// pieces remain enumerable even when another piece is open-ended. A union part
+// is considered non-literal only when every one of its intersection pieces is
+// non-literal.
+func switchExhaustivenessCheckTypeParts(
+  checker *shimchecker.Checker,
+  t *shimchecker.Type,
+) ([]*shimchecker.Type, bool) {
+  if t == nil {
+    return nil, false
+  }
+  unionParts := []*shimchecker.Type{t}
+  if t.Flags()&shimchecker.TypeFlagsUnion != 0 {
+    unionParts = t.Types()
+  }
+
+  members := make([]*shimchecker.Type, 0, len(unionParts))
+  seen := make(map[*shimchecker.Type]struct{}, len(unionParts))
+  containsNonLiteralType := false
+  for _, unionPart := range unionParts {
+    if unionPart == nil {
       continue
     }
-    covered[caseType] = true
+    intersectionParts := []*shimchecker.Type{unionPart}
+    if unionPart.Flags()&shimchecker.TypeFlagsIntersection != 0 {
+      intersectionParts = unionPart.Types()
+    }
+    partContainsLiteral := false
+    for _, intersectionPart := range intersectionParts {
+      intersectionPart = shimchecker.Checker_getRegularTypeOfLiteralType(checker, intersectionPart)
+      if !switchExhaustivenessCheckIsLiteralLike(intersectionPart) {
+        continue
+      }
+      partContainsLiteral = true
+      if switchExhaustivenessCheckContainsEquivalentMember(members, intersectionPart) {
+        continue
+      }
+      if _, ok := seen[intersectionPart]; ok {
+        continue
+      }
+      seen[intersectionPart] = struct{}{}
+      members = append(members, intersectionPart)
+    }
+    if !partContainsLiteral {
+      containsNonLiteralType = true
+    }
+  }
+  return members, containsNonLiteralType
+}
+
+func switchExhaustivenessCheckContainsEquivalentMember(
+  members []*shimchecker.Type,
+  candidate *shimchecker.Type,
+) bool {
+  if candidate == nil || candidate.Flags()&shimchecker.TypeFlagsUndefined == 0 {
+    return false
   }
-  missing := 0
   for _, member := range members {
-    if !covered[member] {
-      missing++
+    if member != nil && member.Flags()&shimchecker.TypeFlagsUndefined != 0 {
+      return true
     }
   }
-  if missing == 0 {
-    return
+  return false
+}
+
+func switchExhaustivenessCheckCaseTypesCover(
+  caseTypes []*shimchecker.Type,
+  member *shimchecker.Type,
+) bool {
+  if member == nil {
+    return false
   }
-  ctx.Report(node, "Switch is not exhaustive. Cases not matched: add a `case` for every union/enum member, or include a `default` clause.")
+  for _, caseType := range caseTypes {
+    if caseType == member {
+      return true
+    }
+    // TypeScript represents `undefined`, optional, and no-unchecked-indexed-
+    // access missing types with distinct pointers. They all carry the
+    // Undefined flag and denote the same runtime switch value.
+    if caseType != nil &&
+      caseType.Flags()&shimchecker.TypeFlagsUndefined != 0 &&
+      member.Flags()&shimchecker.TypeFlagsUndefined != 0 {
+      return true
+    }
+  }
+  return false
 }
 
-// switchExhaustivenessCheckCollectMembers returns the finite literal /
-// enum-literal constituents of t when t is a discriminable union, and
-// nil when t is open-ended (plain `string`, `number`, `any`, `unknown`,
-// etc.). A union whose constituents are all literals or enum literals
-// is treated as exhaustively coverable; any non-literal constituent
-// (e.g. `string` mixed into `"a" | "b" | string`) widens the union and
-// disqualifies the whole discriminant.
-func switchExhaustivenessCheckCollectMembers(t *shimchecker.Type) []*shimchecker.Type {
+func switchExhaustivenessCheckIsLiteralLike(t *shimchecker.Type) bool {
   if t == nil {
+    return false
+  }
+  return t.Flags()&(shimchecker.TypeFlagsLiteral|
+    shimchecker.TypeFlagsUndefined|
+    shimchecker.TypeFlagsNull|
+    shimchecker.TypeFlagsUniqueESSymbol) != 0
+}
+
+func switchExhaustivenessCheckTypeName(
+  checker *shimchecker.Checker,
+  location *shimast.Node,
+  t *shimchecker.Type,
+) string {
+  if t == nil {
+    return "unknown"
+  }
+  if t.Flags()&shimchecker.TypeFlagsESSymbolLike != 0 {
+    if symbol := t.Symbol(); symbol != nil {
+      if name := shimchecker.Checker_symbolToValueString(checker, symbol, location); name != "" {
+        return "typeof " + name
+      }
+      if symbol.Name != "" {
+        return "typeof " + symbol.Name
+      }
+    }
+  }
+  if name := shimchecker.Checker_typeToStringFullyQualified(checker, t, location); name != "" {
+    return name
+  }
+  return checker.TypeToString(t)
+}
+
+func switchExhaustivenessCheckSuggestion(
+  ctx *Context,
+  switchNode *shimast.Node,
+  metadata *switchExhaustivenessCheckMetadata,
+  members []*shimchecker.Type,
+  includeDefault bool,
+) (TextEdit, bool) {
+  if ctx == nil || ctx.File == nil || ctx.Checker == nil ||
+    switchNode == nil || metadata == nil {
+    return TextEdit{}, false
+  }
+  sw := switchNode.AsSwitchStatement()
+  if sw == nil || sw.Expression == nil {
+    return TextEdit{}, false
+  }
+  branches := make([]string, 0, len(members)+1)
+  for _, member := range members {
+    expression, ok := switchExhaustivenessCheckCaseExpression(
+      ctx.Checker,
+      sw.Expression,
+      member,
+    )
+    if !ok {
+      return TextEdit{}, false
+    }
+    branches = append(
+      branches,
+      `case `+expression+`: { throw new Error("Not implemented yet"); }`,
+    )
+  }
+  if includeDefault {
+    branches = append(branches, `default: { throw new Error("Not implemented yet"); }`)
+  }
+  if len(branches) == 0 {
+    return TextEdit{}, false
+  }
+  return switchExhaustivenessCheckInsertionEdit(ctx.File, switchNode, metadata, branches)
+}
+
+func switchExhaustivenessCheckCaseExpression(
+  checker *shimchecker.Checker,
+  location *shimast.Node,
+  member *shimchecker.Type,
+) (string, bool) {
+  if checker == nil || location == nil || member == nil {
+    return "", false
+  }
+  if symbol := member.Symbol(); symbol != nil {
+    if !shimchecker.Checker_isSymbolAccessibleAsValue(checker, symbol, location) {
+      return "", false
+    }
+    expression := strings.TrimSpace(
+      shimchecker.Checker_symbolToValueString(checker, symbol, location),
+    )
+    return expression, expression != ""
+  }
+  expression := strings.TrimSpace(
+    shimchecker.Checker_typeToStringFullyQualified(checker, member, location),
+  )
+  return expression, expression != ""
+}
+
+func switchExhaustivenessCheckInsertionEdit(
+  file *shimast.SourceFile,
+  switchNode *shimast.Node,
+  metadata *switchExhaustivenessCheckMetadata,
+  branches []string,
+) (TextEdit, bool) {
+  if file == nil || switchNode == nil || metadata == nil || len(branches) == 0 {
+    return TextEdit{}, false
+  }
+  source := file.Text()
+  newline := "\n"
+  if strings.Contains(source, "\r\n") {
+    newline = "\r\n"
+  }
+
+  if metadata.defaultCase != nil &&
+    metadata.defaultCase.pos >= 0 && metadata.defaultCase.pos <= len(source) {
+    pos := metadata.defaultCase.pos
+    indent := switchExhaustivenessCheckLineIndent(source, pos)
+    text := strings.Join(branches, newline+indent) + newline + indent
+    if !switchExhaustivenessCheckLineHasOnlyIndent(source, pos) {
+      indent = switchExhaustivenessCheckCaseIndent(source, file, switchNode, metadata)
+      text = newline + indent + strings.Join(branches, newline+indent) + newline + indent
+    }
+    return TextEdit{Pos: pos, End: pos, Text: text}, true
+  }
+
+  if metadata.lastClause != nil {
+    pos := metadata.lastClause.End()
+    if pos < 0 || pos > len(source) {
+      return TextEdit{}, false
+    }
+    clausePos, _ := tokenRange(file, metadata.lastClause)
+    indent := switchExhaustivenessCheckLineIndent(source, clausePos)
+    text := newline + indent + strings.Join(branches, newline+indent)
+    return TextEdit{Pos: pos, End: pos, Text: text}, true
+  }
+
+  if metadata.caseBlock == nil ||
+    shimscanner.ScanTokenAtPosition(file, metadata.caseBlock.Pos()) != shimast.KindOpenBraceToken {
+    return TextEdit{}, false
+  }
+  openingBrace := shimscanner.GetRangeOfTokenAtPosition(file, metadata.caseBlock.Pos())
+  if shimscanner.ScanTokenAtPosition(file, openingBrace.End()) != shimast.KindCloseBraceToken {
+    return TextEdit{}, false
+  }
+  closingBrace := shimscanner.GetRangeOfTokenAtPosition(file, openingBrace.End())
+  if openingBrace.End() < 0 || closingBrace.Pos() < openingBrace.End() ||
+    closingBrace.Pos() > len(source) {
+    return TextEdit{}, false
+  }
+  switchPos, _ := tokenRange(file, switchNode)
+  switchIndent := switchExhaustivenessCheckLineIndent(source, switchPos)
+  caseIndent := switchIndent + "  "
+  branchText := strings.Join(branches, newline+caseIndent)
+  interior := source[openingBrace.End():closingBrace.Pos()]
+  if strings.TrimSpace(interior) == "" {
+    return TextEdit{
+      Pos:  openingBrace.End(),
+      End:  closingBrace.Pos(),
+      Text: newline + caseIndent + branchText + newline + switchIndent,
+    }, true
+  }
+  return TextEdit{
+    Pos:  openingBrace.End(),
+    End:  openingBrace.End(),
+    Text: newline + caseIndent + branchText + newline + caseIndent,
+  }, true
+}
+
+func switchExhaustivenessCheckLineIndent(source string, pos int) string {
+  if pos < 0 || pos > len(source) {
+    return ""
+  }
+  lineStart := strings.LastIndex(source[:pos], "\n") + 1
+  indent := source[lineStart:pos]
+  for _, ch := range indent {
+    if ch != ' ' && ch != '\t' && ch != '\r' {
+      return ""
+    }
+  }
+  return indent
+}
+
+func switchExhaustivenessCheckLineHasOnlyIndent(source string, pos int) bool {
+  if pos < 0 || pos > len(source) {
+    return false
+  }
+  lineStart := strings.LastIndex(source[:pos], "\n") + 1
+  return strings.TrimSpace(source[lineStart:pos]) == ""
+}
+
+func switchExhaustivenessCheckCaseIndent(
+  source string,
+  file *shimast.SourceFile,
+  switchNode *shimast.Node,
+  metadata *switchExhaustivenessCheckMetadata,
+) string {
+  if metadata != nil && metadata.lastClause != nil {
+    clausePos, _ := tokenRange(file, metadata.lastClause)
+    if switchExhaustivenessCheckLineHasOnlyIndent(source, clausePos) {
+      return switchExhaustivenessCheckLineIndent(source, clausePos)
+    }
+  }
+  switchPos, _ := tokenRange(file, switchNode)
+  return switchExhaustivenessCheckLineIndent(source, switchPos) + "  "
+}
+
+// switchExhaustivenessCheckCommentDefaultCase recognizes only the last comment
+// after the last real clause and before the case block's closing brace. This is
+// the same scope as SourceCode#getCommentsAfter(lastCase); a matching comment
+// elsewhere in the switch cannot suppress a diagnostic.
+func switchExhaustivenessCheckCommentDefaultCase(
+  ctx *Context,
+  caseBlock *shimast.Node,
+  lastClause *shimast.Node,
+  pattern *regexp.Regexp,
+) *switchExhaustivenessCheckDefaultCase {
+  if ctx.File == nil || caseBlock == nil || lastClause == nil || pattern == nil {
     return nil
   }
-  flags := t.Flags()
-  if flags&shimchecker.TypeFlagsUnion == 0 {
+  text := ctx.File.Text()
+  from := lastClause.End()
+  if shimscanner.ScanTokenAtPosition(ctx.File, lastClause.End()) != shimast.KindCloseBraceToken {
     return nil
   }
-  parts := t.Types()
-  if len(parts) == 0 {
+  closeBrace := shimscanner.GetRangeOfTokenAtPosition(ctx.File, lastClause.End())
+  to := closeBrace.Pos()
+  if from < 0 || to < from || to > len(text) {
     return nil
   }
-  members := make([]*shimchecker.Type, 0, len(parts))
-  for _, part := range parts {
-    if part == nil {
-      return nil
-    }
-    if !switchExhaustivenessCheckIsLiteralLike(part) {
-      return nil
-    }
-    members = append(members, part)
+  candidateKind := shimast.KindUnknown
+  candidatePos := -1
+  candidateEnd := -1
+  // `from:to` is itself a parser-classified trivia gap: it begins after the
+  // last clause and ends before the case block's closing-brace token. Scan the
+  // bounded gap directly so a file with many switches does not re-enumerate
+  // the whole AST for every switch node.
+  scanCommentGap(shimscanner.NewScanner(), text, from, to, func(kind shimast.Kind, pos, end int) {
+    candidateKind = kind
+    candidatePos = pos
+    candidateEnd = end
+  })
+  if candidatePos < 0 || candidateEnd <= candidatePos {
+    return nil
+  }
+  value := text[candidatePos:candidateEnd]
+  switch candidateKind {
+  case shimast.KindSingleLineCommentTrivia:
+    value = strings.TrimPrefix(value, "//")
+  case shimast.KindMultiLineCommentTrivia:
+    value = strings.TrimSuffix(strings.TrimPrefix(value, "/*"), "*/")
+  }
+  if !pattern.MatchString(strings.TrimSpace(value)) {
+    return nil
+  }
+  return &switchExhaustivenessCheckDefaultCase{
+    pos: candidatePos,
+    end: candidateEnd,
   }
-  return members
 }
 
-// switchExhaustivenessCheckIsLiteralLike reports whether t is a
-// constituent that participates in finite enumeration: a unit type
-// (string/number/bigint/boolean literal), an enum literal, or one of
-// the nullish singletons. The matching set mirrors typescript-eslint's
-// `lib.isTypeFlagSet(constituent, TypeFlags.Literal | ...)` filter.
-func switchExhaustivenessCheckIsLiteralLike(t *shimchecker.Type) bool {
-  flags := t.Flags()
-  if flags&shimchecker.TypeFlagsLiteral != 0 {
-    return true
+func switchExhaustivenessCheckReportDefaultCase(
+  ctx *Context,
+  defaultCase *switchExhaustivenessCheckDefaultCase,
+  message string,
+) {
+  if defaultCase == nil {
+    return
   }
-  if flags&(shimchecker.TypeFlagsUndefined|shimchecker.TypeFlagsNull|shimchecker.TypeFlagsVoid) != 0 {
-    return true
+  if defaultCase.node != nil {
+    ctx.Report(defaultCase.node, message)
+    return
   }
-  return false
+  ctx.ReportRange(defaultCase.pos, defaultCase.end, message)
 }
 
 func init() {