Remove bitset fast path

Sources/_StringProcessing/Engine/InstPayload.swift

@@ -204,20 +204,20 @@ extension Instruction.Payload {
     interpret()
   }
 
-  init(_ cc: BuiltinCC, _ isStrict: Bool, _ isScalar: Bool, bitset: AsciiBitsetRegister) {
+  init(_ cc: BuiltinCC, _ isStrict: Bool, _ isScalar: Bool) {
     let strictBit = isStrict ? 1 << 15 : 0
     let scalarBit = isScalar ? 1 << 14 : 0
     // val must be 16 bits, reserve the top 2 bits for if it is strict ascii or scalar
     assert(cc.rawValue <= 0x3F_FF)
     let val = cc.rawValue + UInt64(strictBit) + UInt64(scalarBit)
-    self.init(val, bitset)
+    self.init(val)
   }
-  var builtinCCPayload: (cc: BuiltinCC, isStrict: Bool, isScalar: Bool, bitset: AsciiBitsetRegister) {
-    let (val, bitset): (UInt64, AsciiBitsetRegister) = self.interpretPair()
+  var builtinCCPayload: (cc: BuiltinCC, isStrict: Bool, isScalar: Bool) {
+    let val = self.rawValue
     let cc = BuiltinCC(rawValue: val & 0x3F_FF)!
     let isStrict = (val >> 15) & 1 == 1
     let isScalar = (val >> 14) & 1 == 1
-    return (cc, isStrict, isScalar, bitset)
+    return (cc, isStrict, isScalar)
   }
 
   init(consumer: ConsumeFunctionRegister) {

Sources/_StringProcessing/Engine/MEBuilder.swift

@@ -162,7 +162,7 @@ extension MEProgram.Builder {
     isScalar: Bool
   ) {
     instructions.append(.init(
-      .matchBuiltin, .init(cc, isStrict, isScalar, bitset: makeAsciiBitset(bitset))))
+      .matchBuiltin, .init(cc, isStrict, isScalar)))
   }
 
   mutating func buildConsume(

Sources/_StringProcessing/Engine/Processor.swift

@@ -247,22 +247,13 @@ extension Processor {
 
   mutating func matchBuiltin(
     _ cc: BuiltinCC,
-    _ isStrictAscii: Bool,
-    _ bitset: DSLTree.CustomCharacterClass.AsciiBitset
+    _ isStrictAscii: Bool
   ) -> Bool {
     guard let c = load() else {
       signalFailure()
       return false
     }
 
-    // Fast path: See if c is a single scalar ascii character
-    // If so, and it matches, consume a character
-    // Note: CR-LF will fall through because it is not a single scalar
-    if bitset.matches(char: c) && cc != .anyScalar {
-      _uncheckedForcedConsumeOne()
-      return true
-    }
-
     // Slow path: Do full match
     var matched: Bool
     var next = input.index(after: currentPosition)
@@ -300,23 +291,12 @@ extension Processor {
 
   mutating func matchBuiltinScalar(
     _ cc: BuiltinCC,
-    _ isStrictAscii: Bool,
-    _ bitset: DSLTree.CustomCharacterClass.AsciiBitset
+    _ isStrictAscii: Bool
   ) -> Bool {
     guard let c = loadScalar() else {
       signalFailure()
       return false
     }
-
-    // Fast path: See if c is a single scalar ascii character
-    // If so, and it matches, consume a character
-    // Note: CR-LF must be matched fully if we are matching a .newlineSequence
-    // so exclude "\r" from the fast path
-    if bitset.matches(scalar: c) && cc != .anyGrapheme && c != "\r" {
-      input.unicodeScalars.formIndex(after: &currentPosition)
-      return true
-    }
-
     // Slow path: Do full match
     var matched: Bool
     var next = input.unicodeScalars.index(after: currentPosition)
@@ -501,14 +481,13 @@ extension Processor {
       }
 
     case .matchBuiltin:
-      let (cc, isStrict, isScalar, reg) = payload.builtinCCPayload
-      let bitset = registers[reg]
+      let (cc, isStrict, isScalar) = payload.builtinCCPayload
       if isScalar {
-        if matchBuiltinScalar(cc, isStrict, bitset) {
+        if matchBuiltinScalar(cc, isStrict) {
           controller.step()
         }
       } else {
-        if matchBuiltin(cc, isStrict, bitset) {
+        if matchBuiltin(cc, isStrict) {
           controller.step()
         }
       }