Keep track of a regex's initial options

The initial options are stored in the lower program, and include
all options that are set before the first attempted match. Note that
not all initial options are global - a leading option-setting group
is included in initial options, even though it applies only to a
portion of the overall regex.

Sources/_StringProcessing/ByteCodeGen.swift

@@ -35,6 +35,9 @@ extension Compiler.ByteCodeGen {
       builder.buildUnresolvedReference(id: id)
 
     case let .changeMatchingOptions(optionSequence):
+      if !builder.hasReceivedInstructions {
+        builder.initialOptions.apply(optionSequence.ast)
+      }
       options.apply(optionSequence.ast)
 
     case let .unconverted(astAtom):
@@ -379,6 +382,9 @@ extension Compiler.ByteCodeGen {
       throw Unreachable("These should produce a capture node")
 
     case .changeMatchingOptions(let optionSequence):
+      if !builder.hasReceivedInstructions {
+        builder.initialOptions.apply(optionSequence)
+      }
       options.apply(optionSequence)
       try emitNode(child)
 

Sources/_StringProcessing/Engine/MEBuilder.swift

@@ -39,6 +39,7 @@ extension MEProgram where Input.Element: Hashable {
     var failAddressToken: AddressToken? = nil
 
     var captureList = CaptureList()
+    var initialOptions = MatchingOptions()
 
     // Symbolic reference resolution
     var unresolvedReferences: [ReferenceID: [InstructionAddress]] = [:]
@@ -77,6 +78,11 @@ extension MEProgram.Builder {
   var lastInstructionAddress: InstructionAddress {
     .init(instructions.endIndex - 1)
   }
+
+  /// `true` if the builder has received any instructions.
+  var hasReceivedInstructions: Bool {
+    !instructions.isEmpty
+  }
 
   mutating func buildNop(_ r: StringRegister? = nil) {
     instructions.append(.init(.nop, .init(optionalString: r)))
@@ -353,7 +359,8 @@ extension MEProgram.Builder {
       registerInfo: regInfo,
       captureList: captureList,
       referencedCaptureOffsets: referencedCaptureOffsets,
-      namedCaptureOffsets: namedCaptureOffsets)
+      namedCaptureOffsets: namedCaptureOffsets,
+      initialOptions: initialOptions)
   }
 
   mutating func reset() { self = Self() }

Sources/_StringProcessing/Engine/MEProgram.swift

@@ -37,6 +37,8 @@ struct MEProgram<Input: Collection> where Input.Element: Equatable {
   let captureList: CaptureList
   let referencedCaptureOffsets: [ReferenceID: Int]
   let namedCaptureOffsets: [String: Int]
+
+  var initialOptions: MatchingOptions
 }
 
 extension MEProgram: CustomStringConvertible {

Sources/_StringProcessing/MatchingOptions.swift

@@ -54,6 +54,13 @@ extension MatchingOptions {
     stack[stack.count - 1].apply(sequence)
     _invariantCheck()
   }
+
+  // @testable
+  /// Returns true if the options at the top of `stack` are equal to those
+  /// for `other`.
+  func _equal(to other: MatchingOptions) -> Bool {
+    stack.last == other.stack.last
+  }
 }
 
 // MARK: Matching behavior API
@@ -127,6 +134,7 @@ extension MatchingOptions {
   }
 }
 
+// MARK: - Implementation
 extension MatchingOptions {
   /// An option that changes the behavior of a regular expression.
   fileprivate enum Option: Int {

Sources/_StringProcessing/Regex/ASTConversion.swift

@@ -13,15 +13,7 @@
 
 extension AST {
   var dslTree: DSLTree {
-    return DSLTree(
-      root.dslTreeNode, options: globalOptions?.dslTreeOptions)
-  }
-}
-
-extension AST.GlobalMatchingOptionSequence {
-  var dslTreeOptions: DSLTree.Options {
-    // TODO: map options
-    return .init()
+    return DSLTree(root.dslTreeNode)
   }
 }
 

Sources/_StringProcessing/Regex/Core.swift

@@ -102,6 +102,6 @@ extension Regex {
 
   @_spi(RegexBuilder)
   public init(node: DSLTree.Node) {
-    self.program = Program(tree: .init(node, options: nil))
+    self.program = Program(tree: .init(node))
   }
 }

Sources/_StringProcessing/Regex/DSLTree.swift

@@ -14,11 +14,9 @@
 @_spi(RegexBuilder)
 public struct DSLTree {
   var root: Node
-  var options: Options?
 
-  init(_ r: Node, options: Options?) {
+  init(_ r: Node) {
     self.root = r
-    self.options = options
   }
 }
 

Tests/RegexTests/CompileTests.swift

@@ -88,4 +88,51 @@ extension RegexTests {
       try testCompilationEquivalence(row)
     }
   }
+
+  func testCompileInitialOptions() throws {
+    func expectInitialOptions<T>(
+      _ regex: Regex<T>,
+      _ optionSequence: AST.MatchingOptionSequence,
+      file: StaticString = #file,
+      line: UInt = #line
+    ) throws {
+      var options = MatchingOptions()
+      options.apply(optionSequence)
+
+      XCTAssertTrue(
+        regex.program.loweredProgram.initialOptions._equal(to: options),
+        file: file, line: line)
+    }
+
+    func expectInitialOptions(
+      _ pattern: String,
+      _ optionSequence: AST.MatchingOptionSequence,
+      file: StaticString = #file,
+      line: UInt = #line
+    ) throws {
+      let regex = try Regex(pattern)
+      try expectInitialOptions(regex, optionSequence, file: file, line: line)
+    }
+
+    try expectInitialOptions(".", matchingOptions())
+    try expectInitialOptions("(?i)(?-i).", matchingOptions())
+
+    try expectInitialOptions("(?i).", matchingOptions(adding: [.caseInsensitive]))
+    try expectInitialOptions("(?i).(?-i)", matchingOptions(adding: [.caseInsensitive]))
+
+    try expectInitialOptions(
+      "(?im)(?s).",
+      matchingOptions(adding: [.caseInsensitive, .multiline, .singleLine]))
+    try expectInitialOptions(".", matchingOptions())
+    try expectInitialOptions(
+      "(?im)(?s).(?u)",
+      matchingOptions(adding: [.caseInsensitive, .multiline, .singleLine]))
+
+    try expectInitialOptions(
+      "(?i:.)",
+      matchingOptions(adding: [.caseInsensitive]))
+    try expectInitialOptions(
+      "(?i:.)(?m:.)",
+      matchingOptions(adding: [.caseInsensitive]))
+  }
 }