Merge pull request #731 from tshortli/unknown-default

tshortli · web-flow · commit cd0ce57a6931 · 2024-03-14T22:23:42.000-07:00
Resolve `switch covers known cases, but 'Enum' may have additional unknown values` warnings
diff --git a/Sources/_StringProcessing/ByteCodeGen.swift b/Sources/_StringProcessing/ByteCodeGen.swift
@@ -156,6 +156,10 @@ fileprivate extension Compiler.ByteCodeGen {
         name, isScalarMode: options.semanticLevel == .unicodeScalar)
     case .relative:
       throw Unsupported("Backreference kind: \(ref)")
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      fatalError()
+    #endif
     }
   }
 
@@ -683,6 +687,10 @@ fileprivate extension Compiler.ByteCodeGen {
       // quantification break if trying to restore to a prior
       // iteration because the register got overwritten?
       //
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      fatalError()
+    #endif
     }
 
     builder.label(exit)
diff --git a/Sources/_StringProcessing/ConsumerInterface.swift b/Sources/_StringProcessing/ConsumerInterface.swift
@@ -324,6 +324,11 @@ extension AST.Atom {
         .backtrackingDirective, .changeMatchingOptions, .invalid:
       // FIXME: implement
       return nil
+
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      fatalError()
+    #endif
     }
   }
 }
@@ -685,7 +690,13 @@ extension AST.Atom.CharacterProperty {
 
       case .invalid:
         throw Unreachable("Expected valid property")
+
+      #if RESILIENT_LIBRARIES
+      @unknown default:
+        throw Unreachable("Unknown kind \(kind)")
+      #endif
       }
+
     }()
 
     if !isInverted { return preInversion }
@@ -855,6 +866,10 @@ extension Unicode.BinaryProperty {
     case .expandsOnNFC, .expandsOnNFD, .expandsOnNFKD,
         .expandsOnNFKC:
       throw Unsupported("Unicode-deprecated: \(self)")
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      break
+    #endif
     }
 
     throw Unsupported("TODO: map prop \(self)")
@@ -905,6 +920,10 @@ extension Unicode.POSIXProperty {
     case .xdigit:
       return consume(propertyScalarPredicate(\.isHexDigit)) // or number
 
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      fatalError()
+    #endif
     }
   }
 }
@@ -1023,6 +1042,11 @@ extension Unicode.ExtendedGeneralCategory {
       return consume(categoryScalarPredicate(.paragraphSeparator))
     case .spaceSeparator:
       return consume(categoryScalarPredicate(.spaceSeparator))
+
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      fatalError()
+    #endif
     }
   }
 }
diff --git a/Sources/_StringProcessing/Engine/InstPayload.swift b/Sources/_StringProcessing/Engine/InstPayload.swift
@@ -431,6 +431,10 @@ struct QuantifyPayload: RawRepresentable {
       kindVal = 1
     case .possessive:
       kindVal = 2
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      fatalError()
+    #endif
     }
     // TODO: refactor / reimplement
     let maxExtraTripsVal: UInt64 = maxExtraTrips == nil ? 1 : UInt64(maxExtraTrips!) << 1
diff --git a/Sources/_StringProcessing/LiteralPrinter.swift b/Sources/_StringProcessing/LiteralPrinter.swift
@@ -216,6 +216,10 @@ extension LiteralPrinter {
       output("{,\(n.value!)}")
     case let .range(low, high):
       output("{\(low.value!),\(high.value!)}")
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      fatalError()
+    #endif
     }
     
     outputQuantificationKind(kind)
@@ -235,6 +239,10 @@ extension LiteralPrinter {
         output(options.isReluctantByDefault ? "" : "?")
       case .possessive:
         output("+")
+      #if RESILIENT_LIBRARIES
+      @unknown default:
+        fatalError()
+      #endif
       }
     case let .syntax(kind):
       // Syntactically-specified quantification modifiers can stay as-is.
@@ -245,6 +253,10 @@ extension LiteralPrinter {
         output("?")
       case .possessive:
         output("+")
+      #if RESILIENT_LIBRARIES
+      @unknown default:
+        fatalError()
+      #endif
       }
     }
   }
@@ -351,6 +363,10 @@ extension LiteralPrinter {
       output("\\g{\(prefix)\(abs(value))}")
     case .named(let name):
       output("\\g{\(name)}")
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      fatalError()
+    #endif
     }
   }
   
@@ -558,6 +574,11 @@ extension AST.MatchingOption.Kind {
       
     // NSRE Compatibility option; no literal representation
     case .nsreCompatibleDot: return nil
+
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      fatalError()
+    #endif
     }
   }
 }
@@ -597,6 +618,11 @@ extension DSLTree._AST.GroupKind {
       
     case let .changeMatchingOptions(sequence):
       return sequence._patternString + ":"
+
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      fatalError()
+    #endif
     }
   }
 }
diff --git a/Sources/_StringProcessing/MatchingOptions.swift b/Sources/_StringProcessing/MatchingOptions.swift
@@ -217,6 +217,10 @@ extension MatchingOptions {
         self = .extended
       case .extraExtended:
         self = .extraExtended
+      #if RESILIENT_LIBRARIES
+      @unknown default:
+        fatalError()
+      #endif
       }
     }
     
diff --git a/Sources/_StringProcessing/PrintAsPattern.swift b/Sources/_StringProcessing/PrintAsPattern.swift
@@ -1105,6 +1105,11 @@ extension AST.Atom {
       
     case .changeMatchingOptions:
       return "/* TODO: change matching options */"
+
+    #if RESILIENT_LIBRARIES
+    @unknown default:
+      fatalError()
+    #endif
     }
   }
 }
@@ -1125,6 +1130,9 @@ extension AST.Quantification.Amount {
     case let .nOrMore(n):  return "Repeat(\(n._patternBase)...)"
     case let .upToN(n):    return "Repeat(...\(n._patternBase))"
     case let .range(n, m): return "Repeat(\(n._patternBase)...\(m._patternBase))"
+    #if RESILIENT_LIBRARIES
+    @unknown default: fatalError()
+    #endif
     }
   }
   
@@ -1144,6 +1152,9 @@ extension AST.Quantification.Kind {
     case .eager: return ".eager"
     case .reluctant: return ".reluctant"
     case .possessive: return ".possessive"
+    #if RESILIENT_LIBRARIES
+    @unknown default: fatalError()
+    #endif
     }
   }
 }
diff --git a/Sources/_StringProcessing/Regex/ASTConversion.swift b/Sources/_StringProcessing/Regex/ASTConversion.swift
@@ -97,6 +97,11 @@ extension AST.Node {
       case let .absentFunction(abs):
         // TODO: What should this map to?
         return .absentFunction(.init(ast: abs))
+
+      #if RESILIENT_LIBRARIES
+      @unknown default:
+        fatalError()
+      #endif
       }
     }
 
@@ -141,9 +146,18 @@ extension AST.CustomCharacterClass {
           return .intersection(lhs, rhs)
         case .symmetricDifference:
           return .symmetricDifference(lhs, rhs)
+        #if RESILIENT_LIBRARIES
+        @unknown default:
+          fatalError()
+        #endif
         }
       case let .trivia(t):
         return .trivia(t.contents)
+
+      #if RESILIENT_LIBRARIES
+      @unknown default:
+        fatalError()
+      #endif
       }
     }
 
diff --git a/Sources/_StringProcessing/Regex/DSLTree.swift b/Sources/_StringProcessing/Regex/DSLTree.swift
@@ -651,6 +651,10 @@ extension CaptureList.Builder {
         addCaptures(of: child, optionalNesting: nesting, visibleInTypedOutput: visibleInTypedOutput)
       case .clearer, .repeater, .stopper:
         break
+      #if RESILIENT_LIBRARIES
+      @unknown default:
+        fatalError()
+      #endif
       }
 
     case let .convertedRegexLiteral(n, _):
@@ -926,6 +930,10 @@ extension DSLTree {
           return true
         case .exactly(let num), .nOrMore(let num), .range(let num, _):
           return num.value.map { $0 > 0 } ?? false
+        #if RESILIENT_LIBRARIES
+        @unknown default:
+          fatalError()
+        #endif
         }
       }
     }

Original file line number	Diff line number	Diff line change
`@@ -156,6 +156,10 @@ fileprivate extension Compiler.ByteCodeGen {`
`156`	`156`	`name, isScalarMode: options.semanticLevel == .unicodeScalar)`
`157`	`157`	`case .relative:`
`158`	`158`	`throw Unsupported("Backreference kind: \(ref)")`
	`159`	`+ #if RESILIENT_LIBRARIES`
	`160`	`+ @unknown default:`
	`161`	`+ fatalError()`
	`162`	`+ #endif`
`159`	`163`	`}`
`160`	`164`	`}`
`161`	`165`
`@@ -683,6 +687,10 @@ fileprivate extension Compiler.ByteCodeGen {`
`683`	`687`	`// quantification break if trying to restore to a prior`
`684`	`688`	`// iteration because the register got overwritten?`
`685`	`689`	`//`
	`690`	`+ #if RESILIENT_LIBRARIES`
	`691`	`+ @unknown default:`
	`692`	`+ fatalError()`
	`693`	`+ #endif`
`686`	`694`	`}`
`687`	`695`
`688`	`696`	`builder.label(exit)`
Original file line number	Diff line number	Diff line change
`@@ -324,6 +324,11 @@ extension AST.Atom {`
`324`	`324`	`.backtrackingDirective, .changeMatchingOptions, .invalid:`
`325`	`325`	`// FIXME: implement`
`326`	`326`	`return nil`
	`327`	`+`
	`328`	`+ #if RESILIENT_LIBRARIES`
	`329`	`+ @unknown default:`
	`330`	`+ fatalError()`
	`331`	`+ #endif`
`327`	`332`	`}`
`328`	`333`	`}`
`329`	`334`	`}`
`@@ -685,7 +690,13 @@ extension AST.Atom.CharacterProperty {`
`685`	`690`
`686`	`691`	`case .invalid:`
`687`	`692`	`throw Unreachable("Expected valid property")`
	`693`	`+`
	`694`	`+ #if RESILIENT_LIBRARIES`
	`695`	`+ @unknown default:`
	`696`	`+ throw Unreachable("Unknown kind \(kind)")`
	`697`	`+ #endif`
`688`	`698`	`}`
	`699`	`+`
`689`	`700`	`}()`
`690`	`701`
`691`	`702`	`if !isInverted { return preInversion }`
`@@ -855,6 +866,10 @@ extension Unicode.BinaryProperty {`
`855`	`866`	`case .expandsOnNFC, .expandsOnNFD, .expandsOnNFKD,`
`856`	`867`	`.expandsOnNFKC:`
`857`	`868`	`throw Unsupported("Unicode-deprecated: \(self)")`
	`869`	`+ #if RESILIENT_LIBRARIES`
	`870`	`+ @unknown default:`
	`871`	`+ break`
	`872`	`+ #endif`
`858`	`873`	`}`
`859`	`874`
`860`	`875`	`throw Unsupported("TODO: map prop \(self)")`
`@@ -905,6 +920,10 @@ extension Unicode.POSIXProperty {`
`905`	`920`	`case .xdigit:`
`906`	`921`	`return consume(propertyScalarPredicate(\.isHexDigit)) // or number`
`907`	`922`
	`923`	`+ #if RESILIENT_LIBRARIES`
	`924`	`+ @unknown default:`
	`925`	`+ fatalError()`
	`926`	`+ #endif`
`908`	`927`	`}`
`909`	`928`	`}`
`910`	`929`	`}`
`@@ -1023,6 +1042,11 @@ extension Unicode.ExtendedGeneralCategory {`
`1023`	`1042`	`return consume(categoryScalarPredicate(.paragraphSeparator))`
`1024`	`1043`	`case .spaceSeparator:`
`1025`	`1044`	`return consume(categoryScalarPredicate(.spaceSeparator))`
	`1045`	`+`
	`1046`	`+ #if RESILIENT_LIBRARIES`
	`1047`	`+ @unknown default:`
	`1048`	`+ fatalError()`
	`1049`	`+ #endif`
`1026`	`1050`	`}`
`1027`	`1051`	`}`
`1028`	`1052`	`}`
Original file line number	Diff line number	Diff line change
`@@ -216,6 +216,10 @@ extension LiteralPrinter {`
`216`	`216`	`output("{,\(n.value!)}")`
`217`	`217`	`case let .range(low, high):`
`218`	`218`	`output("{\(low.value!),\(high.value!)}")`
	`219`	`+ #if RESILIENT_LIBRARIES`
	`220`	`+ @unknown default:`
	`221`	`+ fatalError()`
	`222`	`+ #endif`
`219`	`223`	`}`
`220`	`224`
`221`	`225`	`outputQuantificationKind(kind)`
`@@ -235,6 +239,10 @@ extension LiteralPrinter {`
`235`	`239`	`output(options.isReluctantByDefault ? "" : "?")`
`236`	`240`	`case .possessive:`
`237`	`241`	`output("+")`
	`242`	`+ #if RESILIENT_LIBRARIES`
	`243`	`+ @unknown default:`
	`244`	`+ fatalError()`
	`245`	`+ #endif`
`238`	`246`	`}`
`239`	`247`	`case let .syntax(kind):`
`240`	`248`	`// Syntactically-specified quantification modifiers can stay as-is.`
`@@ -245,6 +253,10 @@ extension LiteralPrinter {`
`245`	`253`	`output("?")`
`246`	`254`	`case .possessive:`
`247`	`255`	`output("+")`
	`256`	`+ #if RESILIENT_LIBRARIES`
	`257`	`+ @unknown default:`
	`258`	`+ fatalError()`
	`259`	`+ #endif`
`248`	`260`	`}`
`249`	`261`	`}`
`250`	`262`	`}`
`@@ -351,6 +363,10 @@ extension LiteralPrinter {`
`351`	`363`	`output("\\g{\(prefix)\(abs(value))}")`
`352`	`364`	`case .named(let name):`
`353`	`365`	`output("\\g{\(name)}")`
	`366`	`+ #if RESILIENT_LIBRARIES`
	`367`	`+ @unknown default:`
	`368`	`+ fatalError()`
	`369`	`+ #endif`
`354`	`370`	`}`
`355`	`371`	`}`
`356`	`372`
`@@ -558,6 +574,11 @@ extension AST.MatchingOption.Kind {`
`558`	`574`
`559`	`575`	`// NSRE Compatibility option; no literal representation`
`560`	`576`	`case .nsreCompatibleDot: return nil`
	`577`	`+`
	`578`	`+ #if RESILIENT_LIBRARIES`
	`579`	`+ @unknown default:`
	`580`	`+ fatalError()`
	`581`	`+ #endif`
`561`	`582`	`}`
`562`	`583`	`}`
`563`	`584`	`}`
`@@ -597,6 +618,11 @@ extension DSLTree._AST.GroupKind {`
`597`	`618`
`598`	`619`	`case let .changeMatchingOptions(sequence):`
`599`	`620`	`return sequence._patternString + ":"`
	`621`	`+`
	`622`	`+ #if RESILIENT_LIBRARIES`
	`623`	`+ @unknown default:`
	`624`	`+ fatalError()`
	`625`	`+ #endif`
`600`	`626`	`}`
`601`	`627`	`}`
`602`	`628`	`}`
Original file line number	Diff line number	Diff line change
`@@ -217,6 +217,10 @@ extension MatchingOptions {`
`217`	`217`	`self = .extended`
`218`	`218`	`case .extraExtended:`
`219`	`219`	`self = .extraExtended`
	`220`	`+ #if RESILIENT_LIBRARIES`
	`221`	`+ @unknown default:`
	`222`	`+ fatalError()`
	`223`	`+ #endif`
`220`	`224`	`}`
`221`	`225`	`}`
`222`	`226`
Original file line number	Diff line number	Diff line change
`@@ -1105,6 +1105,11 @@ extension AST.Atom {`
`1105`	`1105`
`1106`	`1106`	`case .changeMatchingOptions:`
`1107`	`1107`	`return "/* TODO: change matching options */"`
	`1108`	`+`
	`1109`	`+ #if RESILIENT_LIBRARIES`
	`1110`	`+ @unknown default:`
	`1111`	`+ fatalError()`
	`1112`	`+ #endif`
`1108`	`1113`	`}`
`1109`	`1114`	`}`
`1110`	`1115`	`}`
`@@ -1125,6 +1130,9 @@ extension AST.Quantification.Amount {`
`1125`	`1130`	`case let .nOrMore(n): return "Repeat(\(n._patternBase)...)"`
`1126`	`1131`	`case let .upToN(n): return "Repeat(...\(n._patternBase))"`
`1127`	`1132`	`case let .range(n, m): return "Repeat(\(n._patternBase)...\(m._patternBase))"`
	`1133`	`+ #if RESILIENT_LIBRARIES`
	`1134`	`+ @unknown default: fatalError()`
	`1135`	`+ #endif`
`1128`	`1136`	`}`
`1129`	`1137`	`}`
`1130`	`1138`
`@@ -1144,6 +1152,9 @@ extension AST.Quantification.Kind {`
`1144`	`1152`	`case .eager: return ".eager"`
`1145`	`1153`	`case .reluctant: return ".reluctant"`
`1146`	`1154`	`case .possessive: return ".possessive"`
	`1155`	`+ #if RESILIENT_LIBRARIES`
	`1156`	`+ @unknown default: fatalError()`
	`1157`	`+ #endif`
`1147`	`1158`	`}`
`1148`	`1159`	`}`
`1149`	`1160`	`}`
Original file line number	Diff line number	Diff line change
`@@ -97,6 +97,11 @@ extension AST.Node {`
`97`	`97`	`case let .absentFunction(abs):`
`98`	`98`	`// TODO: What should this map to?`
`99`	`99`	`return .absentFunction(.init(ast: abs))`
	`100`	`+`
	`101`	`+ #if RESILIENT_LIBRARIES`
	`102`	`+ @unknown default:`
	`103`	`+ fatalError()`
	`104`	`+ #endif`
`100`	`105`	`}`
`101`	`106`	`}`
`102`	`107`
`@@ -141,9 +146,18 @@ extension AST.CustomCharacterClass {`
`141`	`146`	`return .intersection(lhs, rhs)`
`142`	`147`	`case .symmetricDifference:`
`143`	`148`	`return .symmetricDifference(lhs, rhs)`
	`149`	`+ #if RESILIENT_LIBRARIES`
	`150`	`+ @unknown default:`
	`151`	`+ fatalError()`
	`152`	`+ #endif`
`144`	`153`	`}`
`145`	`154`	`case let .trivia(t):`
`146`	`155`	`return .trivia(t.contents)`
	`156`	`+`
	`157`	`+ #if RESILIENT_LIBRARIES`
	`158`	`+ @unknown default:`
	`159`	`+ fatalError()`
	`160`	`+ #endif`
`147`	`161`	`}`
`148`	`162`	`}`
`149`	`163`
Original file line number	Diff line number	Diff line change
`@@ -651,6 +651,10 @@ extension CaptureList.Builder {`
`651`	`651`	`addCaptures(of: child, optionalNesting: nesting, visibleInTypedOutput: visibleInTypedOutput)`
`652`	`652`	`case .clearer, .repeater, .stopper:`
`653`	`653`	`break`
	`654`	`+ #if RESILIENT_LIBRARIES`
	`655`	`+ @unknown default:`
	`656`	`+ fatalError()`
	`657`	`+ #endif`
`654`	`658`	`}`
`655`	`659`
`656`	`660`	`case let .convertedRegexLiteral(n, _):`
`@@ -926,6 +930,10 @@ extension DSLTree {`
`926`	`930`	`return true`
`927`	`931`	`case .exactly(let num), .nOrMore(let num), .range(let num, _):`
`928`	`932`	`return num.value.map { $0 > 0 } ?? false`
	`933`	`+ #if RESILIENT_LIBRARIES`
	`934`	`+ @unknown default:`
	`935`	`+ fatalError()`
	`936`	`+ #endif`
`929`	`937`	`}`
`930`	`938`	`}`
`931`	`939`	`}`