Cleanup

Sources/_StringProcessing/ByteCodeGen.swift

@@ -643,8 +643,7 @@ fileprivate extension Compiler.ByteCodeGen {
   mutating func emitCustomCharacterClass(
     _ ccc: DSLTree.CustomCharacterClass
   ) throws {
-    if ccc.isAscii() {
-      let asciiBitset = ccc.asAsciiBitset(options)
+    if let asciiBitset = ccc.asAsciiBitset(options) {
       builder.buildMatchAsciiBitset(asciiBitset)
     } else {
       let consumer = try ccc.generateConsumer(options)

Sources/_StringProcessing/ConsumerInterface.swift

@@ -52,39 +52,22 @@ extension DSLTree.Node {
 }
 
 extension DSLTree._AST.Atom {
-  func isAscii() -> Bool {
-    return ast.isAscii()
-  }
-
-  func toAsciiValue() -> UInt8 {
-    return ast.toAsciiValue()
+  var asciiValue: UInt8? {
+    return ast.asciiValue
   }
 }
 
 extension DSLTree.Atom {
-  func isAscii() -> Bool {
+  var asciiValue: UInt8? {
     switch self {
-    case let .char(c):
-      return c.isASCII
-    case let .scalar(s):
-      return s.isASCII
-    case let .unconverted(atom):
-      return atom.isAscii()
-    default:
-      return false
-    }
-  }
-
-  func toAsciiValue() -> UInt8 {
-    switch self {
-    case let .char(c):
-      return c.asciiValue!
-    case let .scalar(s):
+    case let .char(c) where c != "\r\n":
+      return c.asciiValue
+    case let .scalar(s) where s.isASCII:
       return UInt8(ascii: s)
     case let .unconverted(atom):
-      return atom.toAsciiValue()
+      return atom.asciiValue
     default:
-      fatalError("Should have been checked by isAscii first")
+      return nil
     }
   }
 
@@ -213,26 +196,15 @@ extension AST.Atom {
     default: return nil
     }
   }
-
-  func isAscii() -> Bool {
-    switch kind {
-    case let .char(c):
-      return c.isASCII
-    case let .scalar(s):
-      return s.value.isASCII
-    default:
-      return false
-    }
-  }
 
-  func toAsciiValue() -> UInt8 {
+  var asciiValue: UInt8? {
     switch kind {
-    case let .char(c):
-      return c.asciiValue!
-    case let .scalar(s):
+    case let .char(c) where c != "\r\n":
+      return c.asciiValue
+    case let .scalar(s) where s.value.isASCII:
       return UInt8(ascii: s.value)
     default:
-      fatalError("Should have been checked by isAscii first")
+      return nil
     }
   }
 
@@ -293,40 +265,32 @@ extension AST.Atom {
 }
 
 extension DSLTree.CustomCharacterClass.Member {
-  func isAscii() -> Bool {
-    switch self {
-    case let .atom(a):
-      return a.isAscii()
-    case let .range(low, high):
-      return low.isAscii() && high.isAscii()
-    // The remaining cases have nested character classes with possibly different
-    // inversion so leave them out of this optimization
-    default:
-      return false
-    }
-  }
-
   func asAsciiBitset(
     _ opts: MatchingOptions,
     _ isInverted: Bool
-  ) -> DSLTree.CustomCharacterClass.AsciiBitset {
+  ) -> DSLTree.CustomCharacterClass.AsciiBitset? {
     switch self {
     case let .atom(a):
-      return DSLTree.CustomCharacterClass.AsciiBitset(
-        a.toAsciiValue(),
-        isInverted,
-        opts.isCaseInsensitive
-      )
+      if let val = a.asciiValue {
+        return DSLTree.CustomCharacterClass.AsciiBitset(
+          val,
+          isInverted,
+          opts.isCaseInsensitive
+        )
+      }
     case let .range(low, high):
-      return DSLTree.CustomCharacterClass.AsciiBitset(
-        low: low.toAsciiValue(),
-        high: high.toAsciiValue(),
-        isInverted: isInverted,
-        isCaseInsensitive: opts.isCaseInsensitive
-      )
+      if let lowVal = low.asciiValue, let highVal = high.asciiValue {
+        return DSLTree.CustomCharacterClass.AsciiBitset(
+          low: lowVal,
+          high: highVal,
+          isInverted: isInverted,
+          isCaseInsensitive: opts.isCaseInsensitive
+        )
+      }
     default:
-      fatalError("Should have been checked by isAscii first")
+      return nil
     }
+    return nil
   }
 
   func generateConsumer(
@@ -436,14 +400,16 @@ extension DSLTree.CustomCharacterClass.Member {
 }
 
 extension DSLTree.CustomCharacterClass {
-  func isAscii() -> Bool {
-    return members.allSatisfy { member in member.isAscii() }
-  }
-
-  func asAsciiBitset(_ opts: MatchingOptions) -> AsciiBitset {
+  func asAsciiBitset(_ opts: MatchingOptions) -> AsciiBitset? {
     return members.reduce(
       .init(isInverted: isInverted, isCaseInsensitive: opts.isCaseInsensitive),
-      {result, member in result.union(member.asAsciiBitset(opts, isInverted))}
+      {result, member in
+        if let next = member.asAsciiBitset(opts, isInverted) {
+          return result?.union(next)
+        } else {
+          return nil
+        }
+      }
     )
   }
 

Sources/_StringProcessing/Regex/DSLTree.swift

@@ -170,26 +170,26 @@ extension DSLTree {
       let isCaseInsensitive: Bool
       var a: UInt64 = 0
       var b: UInt64 = 0
-      
+
       init(isInverted: Bool, isCaseInsensitive: Bool) {
         self.isInverted = isInverted
         self.isCaseInsensitive = isCaseInsensitive
       }
-      
+
       init(_ val: UInt8, _ isInverted: Bool, _ isCaseInsensitive: Bool) {
         self.isInverted = isInverted
         self.isCaseInsensitive = isCaseInsensitive
         add(val)
       }
-      
+
       init(low: UInt8, high: UInt8, isInverted: Bool, isCaseInsensitive: Bool) {
         self.isInverted = isInverted
         self.isCaseInsensitive = isCaseInsensitive
         for val in low...high {
           add(val)
         }
       }
-      
+
       internal init(
         a: UInt64,
         b: UInt64,
@@ -201,29 +201,27 @@ extension DSLTree {
         self.a = a
         self.b = b
       }
-      
+
       internal mutating func add(_ val: UInt8) {
         setBit(val)
         if isCaseInsensitive {
-          let c = Character(Unicode.Scalar.init(val))
-          let otherCase: String
-          if c.isUppercase {
-            otherCase = c.lowercased()
-          } else {
-            otherCase = c.uppercased()
+          if val >= 64 && val <= 90 {
+            setBit(val + 32)
+          }
+          if val >= 97 && val <= 122 {
+            setBit(val - 32)
           }
-          setBit(otherCase.first!.asciiValue!)
         }
       }
-      
+
       internal mutating func setBit(_ val: UInt8) {
         if val < 64 {
           a = a | 1 << val
         } else {
           b = b | 1 << (val - 64)
         }
       }
-      
+
       internal func matches(char: Character) -> Bool {
         let ret: Bool
         if let val = char.asciiValue {
@@ -242,7 +240,7 @@ extension DSLTree {
 
         return ret
       }
-      
+
       /// Joins another bitset from a Member of the same CustomCharacterClass
       internal func union(_ other: AsciiBitset) -> AsciiBitset {
         precondition(self.isInverted == other.isInverted)