Rename BacktrackingScope to Local (#239)

milseman · web-flow · commit 692237f84af7 · 2022-03-31T14:40:55.000-06:00
diff --git a/Sources/RegexBuilder/DSL.swift b/Sources/RegexBuilder/DSL.swift
@@ -239,7 +239,7 @@ public struct TryCapture<Output>: _BuiltinRegexComponent {
 
 /// An atomic group, i.e. opens a local backtracking scope which, upon successful exit,
 /// discards any remaining backtracking points from within the scope
-public struct BacktrackingScope<Output>: _BuiltinRegexComponent {
+public struct Local<Output>: _BuiltinRegexComponent {
   public var regex: Regex<Output>
 
   internal init(_ regex: Regex<Output>) {
diff --git a/Sources/RegexBuilder/Variadics.swift b/Sources/RegexBuilder/Variadics.swift
@@ -1566,7 +1566,7 @@ extension Repeat {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
-extension BacktrackingScope {
+extension Local {
   @_disfavoredOverload
   public init<Component: RegexComponent>(
     _ component: Component
@@ -1575,158 +1575,158 @@ extension BacktrackingScope {
   }
 }
 
-extension BacktrackingScope {
+extension Local {
   @_disfavoredOverload
   public init<Component: RegexComponent>(
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == Substring {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))
   }
 }
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, Component: RegexComponent>(
     _ component: Component
   ) where Output == (Substring, C0), Component.Output == (W, C0) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))
   }
 }
 
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, Component: RegexComponent>(
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0), Component.Output == (W, C0) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))
   }
 }
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, Component: RegexComponent>(
     _ component: Component
   ) where Output == (Substring, C0, C1), Component.Output == (W, C0, C1) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))
   }
 }
 
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, Component: RegexComponent>(
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1), Component.Output == (W, C0, C1) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))
   }
 }
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     _ component: Component
   ) where Output == (Substring, C0, C1, C2), Component.Output == (W, C0, C1, C2) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))
   }
 }
 
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2), Component.Output == (W, C0, C1, C2) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))
   }
 }
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ component: Component
   ) where Output == (Substring, C0, C1, C2, C3), Component.Output == (W, C0, C1, C2, C3) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))
   }
 }
 
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3), Component.Output == (W, C0, C1, C2, C3) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))
   }
 }
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ component: Component
   ) where Output == (Substring, C0, C1, C2, C3, C4), Component.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))
   }
 }
 
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4), Component.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))
   }
 }
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ component: Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))
   }
 }
 
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))
   }
 }
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ component: Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))
   }
 }
 
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))
   }
 }
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ component: Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))
   }
 }
 
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))
   }
 }
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ component: Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))
   }
 }
 
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))
   }
 }
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ component: Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))
   }
 }
 
-extension BacktrackingScope {
+extension Local {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
diff --git a/Sources/VariadicsGenerator/VariadicsGenerator.swift b/Sources/VariadicsGenerator/VariadicsGenerator.swift
@@ -404,7 +404,7 @@ struct VariadicsGenerator: ParsableCommand {
 
   func emitAtomicGroup(arity: Int) {
     assert(arity >= 0)
-    let groupName = "BacktrackingScope"
+    let groupName = "Local"
     func node(builder: Bool) -> String {
       """
       .nonCapturingGroup(.atomicNonCapturing, component\(

Original file line number	Diff line number	Diff line change
`@@ -1566,7 +1566,7 @@ extension Repeat {`
`1566`	`1566`	`self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))`
`1567`	`1567`	`}`
`1568`	`1568`	`}`
`1569`		`-extension BacktrackingScope {`
	`1569`	`+extension Local {`
`1570`	`1570`	`@_disfavoredOverload`
`1571`	`1571`	`public init<Component: RegexComponent>(`
`1572`	`1572`	`_ component: Component`
`@@ -1575,158 +1575,158 @@ extension BacktrackingScope {`
`1575`	`1575`	`}`
`1576`	`1576`	`}`
`1577`	`1577`
`1578`		`-extension BacktrackingScope {`
	`1578`	`+extension Local {`
`1579`	`1579`	`@_disfavoredOverload`
`1580`	`1580`	`public init<Component: RegexComponent>(`
`1581`	`1581`	`@RegexComponentBuilder _ component: () -> Component`
`1582`	`1582`	`) where Output == Substring {`
`1583`	`1583`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))`
`1584`	`1584`	`}`
`1585`	`1585`	`}`
`1586`		`-extension BacktrackingScope {`
	`1586`	`+extension Local {`
`1587`	`1587`	`public init<W, C0, Component: RegexComponent>(`
`1588`	`1588`	`_ component: Component`
`1589`	`1589`	`) where Output == (Substring, C0), Component.Output == (W, C0) {`
`1590`	`1590`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))`
`1591`	`1591`	`}`
`1592`	`1592`	`}`
`1593`	`1593`
`1594`		`-extension BacktrackingScope {`
	`1594`	`+extension Local {`
`1595`	`1595`	`public init<W, C0, Component: RegexComponent>(`
`1596`	`1596`	`@RegexComponentBuilder _ component: () -> Component`
`1597`	`1597`	`) where Output == (Substring, C0), Component.Output == (W, C0) {`
`1598`	`1598`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))`
`1599`	`1599`	`}`
`1600`	`1600`	`}`
`1601`		`-extension BacktrackingScope {`
	`1601`	`+extension Local {`
`1602`	`1602`	`public init<W, C0, C1, Component: RegexComponent>(`
`1603`	`1603`	`_ component: Component`
`1604`	`1604`	`) where Output == (Substring, C0, C1), Component.Output == (W, C0, C1) {`
`1605`	`1605`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))`
`1606`	`1606`	`}`
`1607`	`1607`	`}`
`1608`	`1608`
`1609`		`-extension BacktrackingScope {`
	`1609`	`+extension Local {`
`1610`	`1610`	`public init<W, C0, C1, Component: RegexComponent>(`
`1611`	`1611`	`@RegexComponentBuilder _ component: () -> Component`
`1612`	`1612`	`) where Output == (Substring, C0, C1), Component.Output == (W, C0, C1) {`
`1613`	`1613`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))`
`1614`	`1614`	`}`
`1615`	`1615`	`}`
`1616`		`-extension BacktrackingScope {`
	`1616`	`+extension Local {`
`1617`	`1617`	`public init<W, C0, C1, C2, Component: RegexComponent>(`
`1618`	`1618`	`_ component: Component`
`1619`	`1619`	`) where Output == (Substring, C0, C1, C2), Component.Output == (W, C0, C1, C2) {`
`1620`	`1620`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))`
`1621`	`1621`	`}`
`1622`	`1622`	`}`
`1623`	`1623`
`1624`		`-extension BacktrackingScope {`
	`1624`	`+extension Local {`
`1625`	`1625`	`public init<W, C0, C1, C2, Component: RegexComponent>(`
`1626`	`1626`	`@RegexComponentBuilder _ component: () -> Component`
`1627`	`1627`	`) where Output == (Substring, C0, C1, C2), Component.Output == (W, C0, C1, C2) {`
`1628`	`1628`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))`
`1629`	`1629`	`}`
`1630`	`1630`	`}`
`1631`		`-extension BacktrackingScope {`
	`1631`	`+extension Local {`
`1632`	`1632`	`public init<W, C0, C1, C2, C3, Component: RegexComponent>(`
`1633`	`1633`	`_ component: Component`
`1634`	`1634`	`) where Output == (Substring, C0, C1, C2, C3), Component.Output == (W, C0, C1, C2, C3) {`
`1635`	`1635`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))`
`1636`	`1636`	`}`
`1637`	`1637`	`}`
`1638`	`1638`
`1639`		`-extension BacktrackingScope {`
	`1639`	`+extension Local {`
`1640`	`1640`	`public init<W, C0, C1, C2, C3, Component: RegexComponent>(`
`1641`	`1641`	`@RegexComponentBuilder _ component: () -> Component`
`1642`	`1642`	`) where Output == (Substring, C0, C1, C2, C3), Component.Output == (W, C0, C1, C2, C3) {`
`1643`	`1643`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))`
`1644`	`1644`	`}`
`1645`	`1645`	`}`
`1646`		`-extension BacktrackingScope {`
	`1646`	`+extension Local {`
`1647`	`1647`	`public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(`
`1648`	`1648`	`_ component: Component`
`1649`	`1649`	`) where Output == (Substring, C0, C1, C2, C3, C4), Component.Output == (W, C0, C1, C2, C3, C4) {`
`1650`	`1650`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))`
`1651`	`1651`	`}`
`1652`	`1652`	`}`
`1653`	`1653`
`1654`		`-extension BacktrackingScope {`
	`1654`	`+extension Local {`
`1655`	`1655`	`public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(`
`1656`	`1656`	`@RegexComponentBuilder _ component: () -> Component`
`1657`	`1657`	`) where Output == (Substring, C0, C1, C2, C3, C4), Component.Output == (W, C0, C1, C2, C3, C4) {`
`1658`	`1658`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))`
`1659`	`1659`	`}`
`1660`	`1660`	`}`
`1661`		`-extension BacktrackingScope {`
	`1661`	`+extension Local {`
`1662`	`1662`	`public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(`
`1663`	`1663`	`_ component: Component`
`1664`	`1664`	`) where Output == (Substring, C0, C1, C2, C3, C4, C5), Component.Output == (W, C0, C1, C2, C3, C4, C5) {`
`1665`	`1665`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))`
`1666`	`1666`	`}`
`1667`	`1667`	`}`
`1668`	`1668`
`1669`		`-extension BacktrackingScope {`
	`1669`	`+extension Local {`
`1670`	`1670`	`public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(`
`1671`	`1671`	`@RegexComponentBuilder _ component: () -> Component`
`1672`	`1672`	`) where Output == (Substring, C0, C1, C2, C3, C4, C5), Component.Output == (W, C0, C1, C2, C3, C4, C5) {`
`1673`	`1673`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))`
`1674`	`1674`	`}`
`1675`	`1675`	`}`
`1676`		`-extension BacktrackingScope {`
	`1676`	`+extension Local {`
`1677`	`1677`	`public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(`
`1678`	`1678`	`_ component: Component`
`1679`	`1679`	`) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {`
`1680`	`1680`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))`
`1681`	`1681`	`}`
`1682`	`1682`	`}`
`1683`	`1683`
`1684`		`-extension BacktrackingScope {`
	`1684`	`+extension Local {`
`1685`	`1685`	`public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(`
`1686`	`1686`	`@RegexComponentBuilder _ component: () -> Component`
`1687`	`1687`	`) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {`
`1688`	`1688`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))`
`1689`	`1689`	`}`
`1690`	`1690`	`}`
`1691`		`-extension BacktrackingScope {`
	`1691`	`+extension Local {`
`1692`	`1692`	`public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(`
`1693`	`1693`	`_ component: Component`
`1694`	`1694`	`) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {`
`1695`	`1695`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))`
`1696`	`1696`	`}`
`1697`	`1697`	`}`
`1698`	`1698`
`1699`		`-extension BacktrackingScope {`
	`1699`	`+extension Local {`
`1700`	`1700`	`public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(`
`1701`	`1701`	`@RegexComponentBuilder _ component: () -> Component`
`1702`	`1702`	`) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {`
`1703`	`1703`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))`
`1704`	`1704`	`}`
`1705`	`1705`	`}`
`1706`		`-extension BacktrackingScope {`
	`1706`	`+extension Local {`
`1707`	`1707`	`public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(`
`1708`	`1708`	`_ component: Component`
`1709`	`1709`	`) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {`
`1710`	`1710`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))`
`1711`	`1711`	`}`
`1712`	`1712`	`}`
`1713`	`1713`
`1714`		`-extension BacktrackingScope {`
	`1714`	`+extension Local {`
`1715`	`1715`	`public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(`
`1716`	`1716`	`@RegexComponentBuilder _ component: () -> Component`
`1717`	`1717`	`) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {`
`1718`	`1718`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component().regex.root))`
`1719`	`1719`	`}`
`1720`	`1720`	`}`
`1721`		`-extension BacktrackingScope {`
	`1721`	`+extension Local {`
`1722`	`1722`	`public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(`
`1723`	`1723`	`_ component: Component`
`1724`	`1724`	`) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {`
`1725`	`1725`	`self.init(node: .nonCapturingGroup(.atomicNonCapturing, component.regex.root))`
`1726`	`1726`	`}`
`1727`	`1727`	`}`
`1728`	`1728`
`1729`		`-extension BacktrackingScope {`
	`1729`	`+extension Local {`
`1730`	`1730`	`public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(`
`1731`	`1731`	`@RegexComponentBuilder _ component: () -> Component`
`1732`	`1732`	`) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {`