Let's use the right name for the list

Author: natecook1000

Sources/_StringProcessing/LiteralPrinter.swift

@@ -36,7 +36,7 @@ extension Regex {
   @available(SwiftStdlib 6.0, *)
   public var _literalPattern: String? {
     var gen = LiteralPrinter(options: MatchingOptions())
-    var list = self.program.tree.nodes[...]
+    var list = self.program.list.nodes[...]
     try? gen.outputList(&list)
     return gen.canonicalLiteralString
   }

Sources/_StringProcessing/Regex/AnyRegexOutput.swift

@@ -265,7 +265,7 @@ extension Regex {
   /// - Parameter name: The name to look for among the regular expression's
   ///   capture groups. Capture group names are case sensitive.
   public func contains(captureNamed name: String) -> Bool {
-    program.tree.captureList.captures.contains(where: {
+    program.list.captureList.captures.contains(where: {
       $0.name == name
     })
   }

Sources/_StringProcessing/Regex/Core.swift

@@ -93,10 +93,10 @@ public struct Regex<Output>: RegexComponent {
   let program: Program
 
   var hasCapture: Bool {
-    program.tree.hasCapture
+    program.list.hasCapture
   }
   var hasChildren: Bool {
-    program.tree.hasChildren
+    program.list.hasChildren
   }
 
   init(ast: AST) {
@@ -153,7 +153,7 @@ extension Regex {
     /// FIXME: If Regex is the unit of composition, then it should be a Node instead,
     /// and we should have a separate type that handled both global options and,
     /// likely, compilation/caching.
-    var tree: DSLList
+    var list: DSLList
 
     /// OptionSet of compiler options for testing purposes
     fileprivate var compileOptions: _CompileOptions = .default
@@ -183,7 +183,7 @@ extension Regex {
       }
 
       // Compile the DSLTree into a lowered program and store it atomically.
-      let compiledProgram = try! Compiler(tree: tree, compileOptions: compileOptions).emit()
+      let compiledProgram = try! Compiler(tree: list, compileOptions: compileOptions).emit()
       let storedNewProgram = _stdlib_atomicInitializeARCRef(
         object: _loweredProgramStoragePtr,
         desired: ProgramBox(compiledProgram))
@@ -196,15 +196,15 @@ extension Regex {
     }
 
     init(ast: AST) {
-      self.tree = DSLList(ast: ast)
+      self.list = DSLList(ast: ast)
     }
 
     init(tree: DSLTree) {
-      self.tree = DSLList(tree: tree)
+      self.list = DSLList(tree: tree)
     }
 
     init(list: DSLList) {
-      self.tree = list
+      self.list = list
     }
   }
 
@@ -228,7 +228,7 @@ extension Regex {
 //  }
 
   var list: DSLList {
-    program.tree
+    program.list
   }
 
   init(node: DSLTree.Node) {
@@ -240,19 +240,19 @@ extension Regex {
   }
 
   func appending<T>(_ node: DSLTree.Node) -> Regex<T> {
-    var list = program.tree
+    var list = program.list
     list.append(node)
     return Regex<T>(list: list)
   }
 
   func appending<T>(contentsOf node: some Collection<DSLTree.Node>) -> Regex<T> {
-    var list = program.tree
+    var list = program.list
     list.append(contentsOf: node)
     return Regex<T>(list: list)
   }
 
   func concatenating<T>(_ other: some Collection<DSLTree.Node>) -> Regex<T> {
-    var nodes = program.tree.nodes
+    var nodes = program.list.nodes
     switch nodes[0] {
     case .concatenation(let children):
       nodes[0] = .concatenation(Array(repeating: TEMP_FAKE_NODE, count: children.count + 1))
@@ -265,7 +265,7 @@ extension Regex {
   }
 
   func alternating<T>(with other: some Collection<DSLTree.Node>) -> Regex<T> {
-    var nodes = program.tree.nodes
+    var nodes = program.list.nodes
     switch nodes[0] {
     case .orderedChoice(let children):
       nodes[0] = .orderedChoice(Array(repeating: TEMP_FAKE_NODE, count: children.count + 1))
@@ -278,13 +278,13 @@ extension Regex {
   }
 
   func prepending<T>(_ node: DSLTree.Node) -> Regex<T> {
-    var list = program.tree
+    var list = program.list
     list.prepend(node)
     return Regex<T>(list: list)
   }
 
   func prepending<T>(contentsOf node: some Collection<DSLTree.Node>) -> Regex<T> {
-    var list = program.tree
+    var list = program.list
     list.prepend(contentsOf: node)
     return Regex<T>(list: list)
   }
@@ -309,7 +309,7 @@ extension Regex {
         return true
       case .recompile:
         let _ = try Compiler(
-          tree: program.tree,
+          tree: program.list,
           compileOptions: program.compileOptions).emit()
         return true
       }

Sources/_StringProcessing/Regex/Options.swift

@@ -295,7 +295,7 @@ extension RegexComponent {
       ? AST.MatchingOptionSequence(adding: [.init(option, location: .fake)])
       : AST.MatchingOptionSequence(removing: [.init(option, location: .fake)])
 
-    var list = regex.program.tree
+    var list = regex.program.list
     list.nodes.insert(.nonCapturingGroup(.init(ast: .changeMatchingOptions(sequence)), TEMP_FAKE_NODE), at: 0)
     return Regex(list: list)
   }

Sources/_StringProcessing/Utility/RegexFactory.swift

@@ -28,23 +28,23 @@ public struct _RegexFactory {
     // Don't wrap `child` again if it's a leaf node.
     child.regex.list.hasChildren
       ? child.regex.prepending(.ignoreCapturesInTypedOutput(TEMP_FAKE_NODE)) as Regex<Substring>
-      : .init(list: child.regex.program.tree)
+      : .init(list: child.regex.program.list)
   }
 
   @available(SwiftStdlib 5.7, *)
   public func accumulate<Output>(
     _ left: some RegexComponent,
     _ right: some RegexComponent
   ) -> Regex<Output> {
-    left.regex.concatenating(right.regex.program.tree.nodes)
+    left.regex.concatenating(right.regex.program.list.nodes)
   }
 
   @available(SwiftStdlib 5.7, *)
   public func accumulateAlternation<Output>(
     _ left: some RegexComponent,
     _ right: some RegexComponent
   ) -> Regex<Output> {
-    left.regex.alternating(with: right.regex.program.tree.nodes)
+    left.regex.alternating(with: right.regex.program.list.nodes)
   }
 
   @_spi(RegexBuilder)

Sources/_StringProcessing/Utility/TypeVerification.swift

@@ -21,7 +21,7 @@ extension Regex {
     var tupleElements: [Any.Type] = []
     var labels = ""
 
-    for capture in program.tree.captureList.captures {
+    for capture in program.list.captureList.captures {
       var captureType = capture.type
       var i = capture.optionalDepth
 
@@ -41,7 +41,7 @@ extension Regex {
 
     // If we have no captures, then our Regex must be Regex<Substring>.
     if tupleElements.count == 1 {
-      let wholeMatchType = program.tree.wholeMatchType
+      let wholeMatchType = program.list.wholeMatchType
       return (Output.self == wholeMatchType, wholeMatchType)
     }
 

Tests/RegexTests/DSLListTests.swift

@@ -21,13 +21,13 @@ struct DSLListTests {
     (#/a(?:b+)c*/#, 8),     // literal, concat, a, noncap grp, quant, b, quant, c
   ])
   func convertedNodeCount(regex: Regex<Substring>, nodeCount: Int) {
-    let dslList = regex.program.tree
+    let dslList = regex.program.list
     #expect(dslList.nodes.count == nodeCount)
   }
 
   @Test(arguments: [#/a|b/#, #/a+b?c/#, #/abc/#, #/a(?:b+)c*/#, #/;[\r\n]/#, #/(?=(?:[1-9]|(?:a|b)))/#])
   func compilationComparison(regex: Regex<Substring>) throws {
-    let listCompiler = Compiler(list: regex.program.tree)
+    let listCompiler = Compiler(list: regex.program.list)
     let listProgram = try listCompiler.emitViaList()
 
 //    #expect(treeProgram.instructions == listProgram.instructions)

Tests/RegexTests/OptimizationTests.swift

@@ -17,23 +17,23 @@ import Testing
   @available(macOS 9999, *)
   @Test(arguments: [#/a/#, #/a+/#, #/(?:a+)/#, #/(?:a)+/#, #/(?m)a+/#, #/ab?c/#, #/(?:a+)+$/#, #/(?:(?:a+b)+b)/#])
   func requiredFirstAtom(pattern: Regex<Substring>) throws {
-    let list = pattern.program.tree
+    let list = pattern.program.list
     let atom = list.requiredFirstAtom(allowOptionsChanges: true)
     #expect(atom?.literalCharacterValue == "a", "Missing first character atom in '\(pattern._literalPattern!)'")
   }
 
   @available(macOS 9999, *)
   @Test(arguments: [#/a?/#, #/(?:a|b)/#, #/[a]/#, #/a?bc/#])
   func noRequiredFirstAtom(pattern: Regex<Substring>) throws {
-    let list = pattern.program.tree
+    let list = pattern.program.list
     let atom = list.requiredFirstAtom(allowOptionsChanges: true)
     #expect(atom == nil, "Unexpected required first atom in '\(pattern._literalPattern!)'")
   }
 
   @available(macOS 9999, *)
   @Test(arguments: [#/a+b/#, #/a*b/#, #/\w+\s/#, #/(?:a+b|b+a)/#, #/\d+a/#, #/a+A/#])
   func autoPossessify(pattern: Regex<Substring>) throws {
-    var list = pattern.program.tree
+    var list = pattern.program.list
     list.autoPossessify()
     for node in list.nodes {
       switch node {
@@ -53,7 +53,7 @@ import Testing
     #/(?:(?:ab)+b)/#,           // single atom quantifications only
   ])
   func noAutoPossessify(pattern: Regex<Substring>) throws {
-    var list = pattern.program.tree
+    var list = pattern.program.list
     list.autoPossessify()
     for node in list.nodes {
       switch node {