Eliminate convertedRegexLiteral wrapper node

Author: natecook1000

Sources/_StringProcessing/ByteCodeGen.swift

@@ -809,7 +809,7 @@ fileprivate extension Compiler.ByteCodeGen {
       default:
         return false
       }
-    case .convertedRegexLiteral(let node, _):
+    case .limitCaptureNesting(let node):
       return tryEmitFastQuant(node, kind, minTrips, maxExtraTrips)
     case .nonCapturingGroup(let groupKind, let node):
       // .nonCapture nonCapturingGroups are ignored during compilation
@@ -1203,7 +1203,7 @@ fileprivate extension Compiler.ByteCodeGen {
       switch node {
       case .concatenation(let ch):
         return ch.flatMap(flatten)
-      case .convertedRegexLiteral(let n, _), .ignoreCapturesInTypedOutput(let n):
+      case .ignoreCapturesInTypedOutput(let n), .limitCaptureNesting(let n):
         return flatten(n)
       default:
         return [node]
@@ -1283,6 +1283,9 @@ fileprivate extension Compiler.ByteCodeGen {
     case let .ignoreCapturesInTypedOutput(child):
       try emitNode(child)
 
+    case let .limitCaptureNesting(child):
+      return try emitNode(child)
+      
     case .conditional:
       throw Unsupported("Conditionals")
 
@@ -1306,9 +1309,6 @@ fileprivate extension Compiler.ByteCodeGen {
     case let .quotedLiteral(s):
       emitQuotedLiteral(s)
 
-    case let .convertedRegexLiteral(n, _):
-      return try emitNode(n)
-
     case .absentFunction:
       throw Unsupported("absent function")
     case .consumer:
@@ -1359,8 +1359,6 @@ extension DSLTree.Node {
       return false
     case .quotedLiteral(let string):
       return !string.isEmpty
-    case .convertedRegexLiteral(let node, _):
-      return node.guaranteesForwardProgress
     case .consumer, .matcher:
       // Allow zero width consumers and matchers
      return false
@@ -1369,6 +1367,8 @@ extension DSLTree.Node {
     case .quantification(let amount, _, let child):
       let (atLeast, _) = amount.ast.bounds
       return atLeast ?? 0 > 0 && child.guaranteesForwardProgress
+    case .limitCaptureNesting(let node), .ignoreCapturesInTypedOutput(let node):
+      return node.guaranteesForwardProgress
     default: return false
     }
   }

Sources/_StringProcessing/LiteralPrinter.swift

@@ -116,11 +116,9 @@ extension LiteralPrinter {
       outputNode(child)
       output(")")
 
-    case let .ignoreCapturesInTypedOutput(child):
+    case let .ignoreCapturesInTypedOutput(child),
+         let .limitCaptureNesting(child):
       outputNode(child)
-    case .convertedRegexLiteral(let node, _):
-      outputNode(node)
-
     case let .quantification(amount, kind, node):
       outputQuantification(amount, kind, node)
     case let .customCharacterClass(charClass):

Sources/_StringProcessing/PrintAsPattern.swift

@@ -179,6 +179,9 @@ extension PrettyPrinter {
     case let .ignoreCapturesInTypedOutput(child):
       printAsPattern(convertedFromAST: child, isTopLevel: isTopLevel)
 
+    case let .limitCaptureNesting(child):
+      printAsPattern(convertedFromAST: child, isTopLevel: isTopLevel)
+      
     case .conditional:
       print("/* TODO: conditional */")
 
@@ -258,20 +261,6 @@ extension PrettyPrinter {
 
           break
 
-        case let .convertedRegexLiteral(.atom(a), _):
-          if let pattern = a._patternBase(&self), pattern.canBeWrapped {
-            printAtom(pattern.0)
-            return
-          }
-          
-          break
-        case let .convertedRegexLiteral(.customCharacterClass(ccc), _):
-          if ccc.isSimplePrint {
-            printSimpleCCC(ccc)
-            return
-          }
-          
-          break
         default:
           break
         }
@@ -305,13 +294,6 @@ extension PrettyPrinter {
     case let .quotedLiteral(v):
       print(v._quoted)
 
-    case let .convertedRegexLiteral(n, _):
-      // FIXME: This recursion coordinates with back-off
-      // check above, so it should work out. Need a
-      // cleaner way to do this. This means the argument
-      // label is a lie.
-      printAsPattern(convertedFromAST: n, isTopLevel: isTopLevel)
-
     case let .customCharacterClass(ccc):
       printAsPattern(ccc)
 
@@ -1431,9 +1413,6 @@ extension DSLTree.Node {
         result += node.getNamedCaptures()
       }
 
-    case .convertedRegexLiteral(let node, _):
-      result += node.getNamedCaptures()
-      
     case .quantification(_, _, let node):
       result += node.getNamedCaptures()
 

Sources/_StringProcessing/Regex/ASTConversion.swift

@@ -13,27 +13,27 @@ internal import _RegexParser
 
 extension AST {
   var dslTree: DSLTree {
-    return DSLTree(root.dslTreeNode)
+    return DSLTree(.limitCaptureNesting(root.dslTreeNode))
   }
 }
 
 extension AST.Node {
   /// Converts an AST node to a `convertedRegexLiteral` node.
   var dslTreeNode: DSLTree.Node {
-    func wrap(_ node: DSLTree.Node) -> DSLTree.Node {
-      switch node {
-      case .convertedRegexLiteral:
-        // FIXME: DSL can have one item concats
-//        assertionFailure("Double wrapping?")
-        return node
-      default:
-        break
-      }
-      // TODO: Should we do this for the
-      // single-concatenation child too, or should?
-      // we wrap _that_?
-      return .convertedRegexLiteral(node, .init(ast: self))
-    }
+//    func wrap(_ node: DSLTree.Node) -> DSLTree.Node {
+//      switch node {
+//      case .convertedRegexLiteral(let child, _):
+//        // FIXME: DSL can have one item concats
+////        assertionFailure("Double wrapping?")
+//        return child
+//      default:
+//        break
+//      }
+//      // TODO: Should we do this for the
+//      // single-concatenation child too, or should?
+//      // we wrap _that_?
+//      return node
+//    }
 
     // Convert the top-level node without wrapping
     func convert() throws -> DSLTree.Node {
@@ -107,7 +107,8 @@ extension AST.Node {
 
     // FIXME: make total function again
     let converted = try! convert()
-    return wrap(converted)
+//    return wrap(converted)
+    return converted
   }
 }
 

Sources/_StringProcessing/Regex/DSLList.swift

@@ -67,8 +67,9 @@ extension DSLTree.Node {
     case .orderedChoice(let c), .concatenation(let c):
       return c.count
 
-    case .convertedRegexLiteral, .capture, .nonCapturingGroup,
-        .quantification, .ignoreCapturesInTypedOutput, .conditional:
+    case .capture, .nonCapturingGroup,
+        .quantification, .ignoreCapturesInTypedOutput,
+        .limitCaptureNesting, .conditional:
       return 1
 
     case .absentFunction:

Sources/_StringProcessing/Regex/DSLTree.swift

@@ -44,7 +44,8 @@ extension DSLTree {
 
     /// Marks all captures in a subpattern as ignored in strongly-typed output.
     case ignoreCapturesInTypedOutput(Node)
-    
+    case limitCaptureNesting(Node)
+
     // TODO: Consider splitting off grouped conditions, or have
     // our own kind
 
@@ -79,13 +80,6 @@ extension DSLTree {
     /// TODO: Consider splitting off expression functions, or have our own kind
     case absentFunction(_AST.AbsentFunction)
 
-    // MARK: - Tree conversions
-
-    /// The target of AST conversion.
-    ///
-    /// Keeps original AST around for rich syntactic and source information
-    case convertedRegexLiteral(Node, _AST.ASTNode)
-
     // MARK: - Extensibility points
 
     case consumer(_ConsumerInterface)
@@ -384,8 +378,9 @@ extension DSLTree.Node {
     case .orderedChoice(let c), .concatenation(let c):
       return !c.isEmpty
 
-    case .convertedRegexLiteral, .capture, .nonCapturingGroup,
-        .quantification, .ignoreCapturesInTypedOutput, .conditional:
+    case .capture, .nonCapturingGroup,
+        .quantification, .ignoreCapturesInTypedOutput, .limitCaptureNesting,
+        .conditional:
       return true
 
     case .absentFunction(let abs):
@@ -400,14 +395,14 @@ extension DSLTree.Node {
     case let .orderedChoice(v):   return v
     case let .concatenation(v): return v
 
-    case let .convertedRegexLiteral(n, _):
-      // Treat this transparently
-      return n.children
-
     case let .capture(_, _, n, _):        return [n]
     case let .nonCapturingGroup(_, n):    return [n]
     case let .quantification(_, _, n):    return [n]
-    case let .ignoreCapturesInTypedOutput(n):        return [n]
+    case let .ignoreCapturesInTypedOutput(n): return [n]
+    
+    case let .limitCaptureNesting(n):
+      // This is a transparent wrapper
+      return n.children
 
     case let .conditional(_, t, f): return [t,f]
 
@@ -424,18 +419,12 @@ extension DSLTree.Node {
 
 extension DSLTree.Node {
   var astNode: AST.Node? {
-    switch self {
-    case let .convertedRegexLiteral(_, literal): return literal.ast
-    default: return nil
-    }
+    nil
   }
 
   /// If this node is for a converted literal, look through it.
   var lookingThroughConvertedLiteral: Self {
-    switch self {
-    case let .convertedRegexLiteral(n, _): return n
-    default: return self
-    }
+    self
   }
 }
 
@@ -468,10 +457,6 @@ extension DSLTree.Node {
     switch self {
     case .capture:
       return true
-    case let .convertedRegexLiteral(n, re):
-      assert(n.hasCapture == re.ast.hasCapture)
-      return n.hasCapture
-
     default:
       return self.children.any(\.hasCapture)
     }
@@ -655,6 +640,9 @@ extension CaptureList.Builder {
     case let .ignoreCapturesInTypedOutput(child):
       addCaptures(of: child, optionalNesting: nesting, visibleInTypedOutput: false)
 
+    case let .limitCaptureNesting(child):
+      addCaptures(of: child, optionalNesting: nesting.disablingNesting, visibleInTypedOutput: visibleInTypedOutput)
+      
     case let .conditional(cond, trueBranch, falseBranch):
       switch cond.ast {
       case .group(let g):
@@ -685,11 +673,11 @@ extension CaptureList.Builder {
       #endif
       }
 
-    case let .convertedRegexLiteral(n, _):
-      // We disable nesting for converted AST trees, as literals do not nest
-      // captures. This includes literals nested in a DSL.
-      return addCaptures(of: n, optionalNesting: nesting.disablingNesting, visibleInTypedOutput: visibleInTypedOutput)
-
+//    case let .convertedRegexLiteral(n, _):
+//      // We disable nesting for converted AST trees, as literals do not nest
+//      // captures. This includes literals nested in a DSL.
+//      return addCaptures(of: n, optionalNesting: nesting.disablingNesting, visibleInTypedOutput: visibleInTypedOutput)
+//
     case .matcher:
       break
 
@@ -717,8 +705,8 @@ extension DSLTree.Node {
       return true
     case .orderedChoice, .concatenation, .capture,
          .conditional, .quantification, .customCharacterClass, .atom,
-         .trivia, .empty, .quotedLiteral, .absentFunction,
-         .convertedRegexLiteral, .consumer,
+         .trivia, .empty, .quotedLiteral, .limitCaptureNesting,
+         .consumer, .absentFunction,
          .characterPredicate, .matcher:
       return false
     }
@@ -805,8 +793,7 @@ extension DSLTree.Node {
       options.beginScope()
       defer { options.endScope() }
       return child._canOnlyMatchAtStartImpl(&options)
-    case .ignoreCapturesInTypedOutput(let child),
-        .convertedRegexLiteral(let child, _):
+    case .ignoreCapturesInTypedOutput(let child), .limitCaptureNesting(let child):
       return child._canOnlyMatchAtStartImpl(&options)
 
     // A quantification that doesn't require its child to exist can still
@@ -869,14 +856,13 @@ extension DSLTree {
       case let .orderedChoice(v): return v.map(_Tree.init)
       case let .concatenation(v): return v.map(_Tree.init)
 
-      case let .convertedRegexLiteral(n, _):
-        // Treat this transparently
-        return _Tree(n).children
-
       case let .capture(_, _, n, _):        return [_Tree(n)]
       case let .nonCapturingGroup(_, n):    return [_Tree(n)]
       case let .quantification(_, _, n):    return [_Tree(n)]
-      case let .ignoreCapturesInTypedOutput(n):        return [_Tree(n)]
+      case let .ignoreCapturesInTypedOutput(n): return [_Tree(n)]
+      case let .limitCaptureNesting(n):
+        // This is a transparent wrapper
+        return _Tree(n).children
 
       case let .conditional(_, t, f): return [_Tree(t), _Tree(f)]