Update DSL concatenation to coalesce characters

Author: natecook1000

Sources/_StringProcessing/Regex/Core.swift

@@ -223,10 +223,6 @@ extension Regex {
 
 @available(SwiftStdlib 5.7, *)
 extension Regex {
-//  var root: DSLTree.Node {
-//    program.tree.root
-//  }
-
   var list: DSLList {
     program.list
   }
@@ -245,23 +241,34 @@ extension Regex {
     return Regex<T>(list: list)
   }
 
-  func appending<T>(contentsOf node: some Collection<DSLTree.Node>) -> Regex<T> {
+  func appending<T>(contentsOf node: [DSLTree.Node]) -> Regex<T> {
     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.list.nodes
-    switch nodes[0] {
+  func concatenating<T>(_ other: DSLList) -> Regex<T> {
+    // TODO: Quick check to see if these copies are necessary?
+    var list = program.list
+    var other = other
+    list.coalesce(withFirstAtomIn: &other)
+    
+    // Sometimes coalescing consumes all of `other`
+    guard !other.nodes.isEmpty else {
+      return Regex<T>(list: list)
+    }
+    
+    // Use an existing concatenation if it's already the root;
+    // otherwise, embed self and other in a new concatenation root.
+    switch list.nodes[0] {
     case .concatenation(let children):
-      nodes[0] = .concatenation(Array(repeating: TEMP_FAKE_NODE, count: children.count + 1))
-      nodes.append(contentsOf: other)
+      list.nodes[0] = .concatenation(Array(repeating: TEMP_FAKE_NODE, count: children.count + 1))
+      list.nodes.append(contentsOf: other.nodes)
     default:
-      nodes.insert(.concatenation(Array(repeating: TEMP_FAKE_NODE, count: 2)), at: 0)
-      nodes.append(contentsOf: other)
+      list.nodes.insert(.concatenation(Array(repeating: TEMP_FAKE_NODE, count: 2)), at: 0)
+      list.nodes.append(contentsOf: other.nodes)
     }
-    return Regex<T>(list: DSLList(nodes))
+    return Regex<T>(list: list)
   }
 
   func alternating<T>(with other: some Collection<DSLTree.Node>) -> Regex<T> {

Sources/_StringProcessing/Regex/DSLList.swift

@@ -164,4 +164,58 @@ extension DSLList {
       break
     }
   }
+  
+  func indexOfCoalescableAtom(startingAt position: Int, findLast: Bool = false) -> Int? {
+    switch nodes[position] {
+    case .concatenation(let children):
+      var position = position + 1
+      if findLast {
+        for _ in 0..<(children.count - 1) {
+          skipNode(&position)
+          position += 1
+        }
+      }
+      return indexOfCoalescableAtom(startingAt: position, findLast: findLast)
+    case .ignoreCapturesInTypedOutput, .limitCaptureNesting:
+      return indexOfCoalescableAtom(startingAt: position + 1, findLast: findLast)
+    case .atom(let atom):
+      if atom.literalCharacterValue != nil {
+        return position
+      }
+    case .quotedLiteral:
+      return position
+    default:
+      break
+    }
+    return nil
+  }
+    
+  mutating func coalesce(withFirstAtomIn other: inout DSLList) {
+    // Find the last coalescable node in the LHS and the first in the RHS
+    guard let prefixIndex = indexOfCoalescableAtom(startingAt: 0, findLast: true),
+          let postfixIndex = other.indexOfCoalescableAtom(startingAt: 0),
+          let prefixValue = nodes[prefixIndex].literalStringValue,
+          let postfixValue = other.nodes[postfixIndex].literalStringValue
+    else { return }
+
+    // Replace the prefix node with a coalesced version of the two
+    nodes[prefixIndex] = .quotedLiteral(prefixValue + postfixValue)
+    
+    // Remove the postfix node and fix up any parent concatenations
+    other.nodes.remove(at: postfixIndex)
+    var i = postfixIndex - 1
+  Loop:
+    while i >= 0 {
+      switch other.nodes[i] {
+      case .concatenation(let children):
+        other.nodes[i] = .concatenation(.init(repeating: .empty, count: children.count - 1))
+        break Loop
+      case .limitCaptureNesting, .ignoreCapturesInTypedOutput:
+        other.nodes.remove(at: i)
+        i -= 1
+      default:
+        break Loop
+      }
+    }
+  }
 }

Sources/_StringProcessing/Regex/DSLTree.swift

@@ -514,6 +514,16 @@ extension DSLTree.Atom {
   }
 }
 
+extension DSLTree.Node {
+  var literalStringValue: String? {
+    switch self {
+    case .atom(let a):   return a.literalCharacterValue.map(String.init)
+    case .quotedLiteral(let s): return s
+    default: return nil
+    }
+  }
+}
+
 extension DSLTree {
   struct Options {
     // TBD

Sources/_StringProcessing/Utility/RegexFactory.swift

@@ -36,7 +36,7 @@ public struct _RegexFactory {
     _ left: some RegexComponent,
     _ right: some RegexComponent
   ) -> Regex<Output> {
-    left.regex.concatenating(right.regex.program.list.nodes)
+    left.regex.concatenating(right.regex.program.list)
   }
 
   @available(SwiftStdlib 5.7, *)