[perf] Implement auto-possessification (#832)

This optimization recognizes quantifications followed by
an atom that can't be matched at the start of the quantification,
and converts them to possessive, eliminating any backtracking
at that position. This change includes an accessor for the
first "required" atom (which will be used in other
optimizations), and converts DSL.QuantificationKind to a
struct to support the possessification changes.

When deciding on exclusion during auto-possessification, awareness of
the current matching options is important for correct analysis. For
example, /a+A/ can be auto-possessified, but the case insensitive
pattern /(?i)a+A/ cannot be.

Author: natecook1000

Sources/_StringProcessing/ByteCodeGen+DSLList.swift

@@ -12,7 +12,7 @@
 internal import _RegexParser
 
 extension Compiler.ByteCodeGen {
-  mutating func emitRoot(_ root: DSLList) throws -> MEProgram {
+  mutating func emitRoot(_ root: inout DSLList) throws -> MEProgram {
     // If the whole regex is a matcher, then the whole-match value
     // is the constructed value. Denote that the current value
     // register is the processor's value output.
@@ -22,7 +22,11 @@ extension Compiler.ByteCodeGen {
     default:
       break
     }
-
+    
+    if optimizationsEnabled {
+      root.autoPossessify()
+    }
+    
     var list = root.nodes[...]
     try emitNode(&list)
 
@@ -352,15 +356,7 @@ fileprivate extension Compiler.ByteCodeGen {
     _ kind: DSLTree.QuantificationKind,
     _ list: inout ArraySlice<DSLTree.Node>
   ) throws {
-    let updatedKind: AST.Quantification.Kind
-    switch kind {
-    case .explicit(let kind):
-      updatedKind = kind.ast
-    case .syntax(let kind):
-      updatedKind = kind.ast.applying(options)
-    case .default:
-      updatedKind = options.defaultQuantificationKind
-    }
+    let updatedKind = kind.applying(options: options)
 
     let (low, high) = amount.bounds
     guard let low = low else {

Sources/_StringProcessing/ByteCodeGen.swift

@@ -506,15 +506,7 @@ extension Compiler.ByteCodeGen {
     _ kind: DSLTree.QuantificationKind,
     _ child: DSLTree.Node
   ) throws {
-    let updatedKind: AST.Quantification.Kind
-    switch kind {
-    case .explicit(let kind):
-      updatedKind = kind.ast
-    case .syntax(let kind):
-      updatedKind = kind.ast.applying(options)
-    case .default:
-      updatedKind = options.defaultQuantificationKind
-    }
+    let updatedKind = kind.applying(options: options)
 
     let (low, high) = amount.bounds
     guard let low = low else {

Sources/_StringProcessing/Compiler.swift

@@ -47,13 +47,13 @@ class Compiler {
 
   __consuming func emitViaList() throws -> MEProgram {
     // TODO: Handle global options
-    let dslList = DSLList(tree: tree)
+    var dslList = DSLList(tree: tree)
     var codegen = ByteCodeGen(
       options: options,
       compileOptions:
         compileOptions,
       captureList: tree.captureList)
-    return try codegen.emitRoot(dslList)
+    return try codegen.emitRoot(&dslList)
   }
 }
 

Sources/_StringProcessing/LiteralPrinter.swift

@@ -224,13 +224,16 @@ extension LiteralPrinter {
   }
 
   mutating func outputQuantificationKind(_ kind: DSLTree.QuantificationKind) {
-    switch kind {
-    case .`default`:
+    guard let astKind = kind.quantificationKind?.ast else {
       // We can treat this as if the current default had been given explicity.
       outputQuantificationKind(
         .explicit(.init(ast: options.defaultQuantificationKind)))
-    case let .explicit(kind):
-      switch kind.ast {
+      return
+    }
+    
+    if kind.isExplicit {
+      // Explicitly provided modifiers need to match the current option state.
+      switch astKind {
       case .eager:
         output(options.isReluctantByDefault ? "?" : "")
       case .reluctant:
@@ -242,9 +245,9 @@ extension LiteralPrinter {
         fatalError()
       #endif
       }
-    case let .syntax(kind):
+    } else {
       // Syntactically-specified quantification modifiers can stay as-is.
-      switch kind.ast {
+      switch astKind {
       case .eager:
         output("")
       case .reluctant: