Tweak quantifier AST builders

Because of the unlabeled parameters, callers were
never able to use the `.eager` default. Give the
child parameter an argument label so they can.

Author: hamishknight

Sources/_StringProcessing/ASTBuilder.swift

@@ -242,51 +242,51 @@ func quant(
   _ child: AST.Node
 ) -> AST.Node {
   .quantification(.init(
-    .init(faking: amount), .init(faking: kind), child, .fake))
+    .init(faking: amount), .init(faking: kind), child, .fake, trivia: []))
 }
 func zeroOrMore(
   _ kind: AST.Quantification.Kind = .eager,
-  _ child: AST.Node
+  of child: AST.Node
 ) -> AST.Node {
   quant(.zeroOrMore, kind, child)
 }
 func zeroOrOne(
   _ kind: AST.Quantification.Kind = .eager,
-  _ child: AST.Node
+  of child: AST.Node
 ) -> AST.Node {
   quant(.zeroOrOne, kind, child)
 }
 func oneOrMore(
   _ kind: AST.Quantification.Kind = .eager,
-  _ child: AST.Node
+  of child: AST.Node
 ) -> AST.Node {
   quant(.oneOrMore, kind, child)
 }
 func exactly(
-  _ kind: AST.Quantification.Kind = .eager,
   _ i: Int,
-  _ child: AST.Node
+  _ kind: AST.Quantification.Kind = .eager,
+  of child: AST.Node
 ) -> AST.Node {
   quant(.exactly(.init(faking: i)), kind, child)
 }
 func nOrMore(
-  _ kind: AST.Quantification.Kind = .eager,
   _ i: Int,
-  _ child: AST.Node
+  _ kind: AST.Quantification.Kind = .eager,
+  of child: AST.Node
 ) -> AST.Node {
   quant(.nOrMore(.init(faking: i)), kind, child)
 }
 func upToN(
-  _ kind: AST.Quantification.Kind = .eager,
   _ i: Int,
-  _ child: AST.Node
+  _ kind: AST.Quantification.Kind = .eager,
+  of child: AST.Node
 ) -> AST.Node {
   quant(.upToN(.init(faking: i)), kind, child)
 }
 func quantRange(
-  _ kind: AST.Quantification.Kind = .eager,
   _ r: ClosedRange<Int>,
-  _ child: AST.Node
+  _ kind: AST.Quantification.Kind = .eager,
+  of child: AST.Node
 ) -> AST.Node {
   let lower = AST.Located(faking: r.lowerBound)
   let upper = AST.Located(faking: r.upperBound)

Sources/_StringProcessing/RegexDSL/DSL.swift

@@ -67,7 +67,7 @@ public struct OneOrMore<Component: RegexProtocol>: RegexProtocolWithComponent {
 
   public init(component: Component) {
     self.regex = .init(ast:
-      oneOrMore(.eager, component.regex.ast.root)
+      oneOrMore(of: component.regex.ast.root)
     )
   }
 
@@ -93,7 +93,7 @@ public struct Repeat<
 
   public init(component: Component) {
     self.regex = .init(ast:
-      zeroOrMore(.eager, component.regex.ast.root))
+      zeroOrMore(of: component.regex.ast.root))
   }
 
   public init(@RegexBuilder _ content: () -> Component) {
@@ -116,7 +116,7 @@ public struct Optionally<Component: RegexProtocol>: RegexProtocolWithComponent {
 
   public init(component: Component) {
     self.regex = .init(ast:
-      zeroOrOne(.eager, component.regex.ast.root))
+      zeroOrOne(of: component.regex.ast.root))
   }
 
   public init(@RegexBuilder _ content: () -> Component) {

Tests/RegexTests/ParseTests.swift

@@ -201,7 +201,7 @@ extension RegexTests {
       "abc", concat("a", "b", "c"))
     parseTest(
       #"abc\+d*"#,
-      concat("a", "b", "c", "+", zeroOrMore(.eager, "d")))
+      concat("a", "b", "c", "+", zeroOrMore(of: "d")))
     parseTest(
       "a(b)", concat("a", capture("b")),
       captures: .atom())
@@ -211,31 +211,31 @@ extension RegexTests {
         concat(
           "a", "b", "c",
           oneOrMore(
-            .eager, nonCapture(concat("d", "e"))),
-          "f", "g", "h", zeroOrMore(.eager, "i"), "k"),
+            of: nonCapture(concat("d", "e"))),
+          "f", "g", "h", zeroOrMore(of: "i"), "k"),
         "j"))
     parseTest(
       "a(?:b|c)?d",
       concat("a", zeroOrOne(
-        .eager, nonCapture(alt("b", "c"))), "d"))
+        of: nonCapture(alt("b", "c"))), "d"))
     parseTest(
       "a?b??c+d+?e*f*?",
       concat(
-        zeroOrOne(.eager, "a"), zeroOrOne(.reluctant, "b"),
-        oneOrMore(.eager, "c"), oneOrMore(.reluctant, "d"),
-        zeroOrMore(.eager, "e"), zeroOrMore(.reluctant, "f")))
+        zeroOrOne(of: "a"), zeroOrOne(.reluctant, of: "b"),
+        oneOrMore(of: "c"), oneOrMore(.reluctant, of: "d"),
+        zeroOrMore(of: "e"), zeroOrMore(.reluctant, of: "f")))
 
     parseTest(
       "(.)*(.*)",
       concat(
-        zeroOrMore(.eager, capture(atom(.any))),
-        capture(zeroOrMore(.eager, atom(.any)))),
+        zeroOrMore(of: capture(atom(.any))),
+        capture(zeroOrMore(of: atom(.any)))),
       captures: .tuple([.array(.atom()), .atom()]))
     parseTest(
       "((.))*((.)?)",
       concat(
-        zeroOrMore(.eager, capture(capture(atom(.any)))),
-        capture(zeroOrOne(.eager, capture(atom(.any))))),
+        zeroOrMore(of: capture(capture(atom(.any)))),
+        capture(zeroOrOne(of: capture(atom(.any))))),
       captures: .tuple([
         .array(.atom()), .array(.atom()), .atom(), .optional(.atom())
       ]))
@@ -247,7 +247,7 @@ extension RegexTests {
 
     parseTest(
       "a|b?c",
-      alt("a", concat(zeroOrOne(.eager, "b"), "c")))
+      alt("a", concat(zeroOrOne(of: "b"), "c")))
     parseTest(
       "(a|b)c",
       concat(capture(alt("a", "b")), "c"),
@@ -419,7 +419,7 @@ extension RegexTests {
 
     parseTest(
       #"[a[bc]de&&[^bc]\d]+"#,
-      oneOrMore(.eager, charClass(
+      oneOrMore(of: charClass(
         .setOperation(
           ["a", charClass("b", "c"), "d", "e"],
           .init(faking: .intersection),
@@ -448,13 +448,13 @@ extension RegexTests {
     parseTest(
       "a&&b", concat("a", "&", "&", "b"))
     parseTest(
-      "&?", zeroOrOne(.eager, "&"))
+      "&?", zeroOrOne(of: "&"))
     parseTest(
-      "&&?", concat("&", zeroOrOne(.eager, "&")))
+      "&&?", concat("&", zeroOrOne(of: "&")))
     parseTest(
-      "--+", concat("-", oneOrMore(.eager, "-")))
+      "--+", concat("-", oneOrMore(of: "-")))
     parseTest(
-      "~~*", concat("~", zeroOrMore(.eager, "~")))
+      "~~*", concat("~", zeroOrMore(of: "~")))
 
     // MARK: Quotes
 
@@ -496,25 +496,25 @@ extension RegexTests {
 
     parseTest(
       #"a{1,2}"#,
-      quantRange(.eager, 1...2, "a"))
+      quantRange(1...2, of: "a"))
     parseTest(
       #"a{,2}"#,
-      upToN(.eager, 2, "a"))
+      upToN(2, of: "a"))
     parseTest(
       #"a{2,}"#,
-      nOrMore(.eager, 2, "a"))
+      nOrMore(2, of: "a"))
     parseTest(
       #"a{1}"#,
-      exactly(.eager, 1, "a"))
+      exactly(1, of: "a"))
     parseTest(
       #"a{1,2}?"#,
-      quantRange(.reluctant, 1...2, "a"))
+      quantRange(1...2, .reluctant, of: "a"))
     parseTest(
       #"a{0}"#,
-      exactly(.eager, 0, "a"))
+      exactly(0, of: "a"))
     parseTest(
       #"a{0,0}"#,
-      quantRange(.eager, 0...0, "a"))
+      quantRange(0...0, of: "a"))
 
     // Make sure ranges get treated as literal if invalid.
     parseTest("{", "{")
@@ -524,16 +524,16 @@ extension RegexTests {
     parseTest("{,6", concat("{", ",", "6"))
     parseTest("{6", concat("{", "6"))
     parseTest("{6,", concat("{", "6", ","))
-    parseTest("{+", oneOrMore(.eager, "{"))
-    parseTest("{6,+", concat("{", "6", oneOrMore(.eager, ",")))
+    parseTest("{+", oneOrMore(of: "{"))
+    parseTest("{6,+", concat("{", "6", oneOrMore(of: ",")))
     parseTest("x{", concat("x", "{"))
     parseTest("x{}", concat("x", "{", "}"))
     parseTest("x{,}", concat("x", "{", ",", "}"))
     parseTest("x{,6", concat("x", "{", ",", "6"))
     parseTest("x{6", concat("x", "{", "6"))
     parseTest("x{6,", concat("x", "{", "6", ","))
-    parseTest("x{+", concat("x", oneOrMore(.eager, "{")))
-    parseTest("x{6,+", concat("x", "{", "6", oneOrMore(.eager, ",")))
+    parseTest("x{+", concat("x", oneOrMore(of: "{")))
+    parseTest("x{6,+", concat("x", "{", "6", oneOrMore(of: ",")))
 
     // TODO: We should emit a diagnostic for this.
     parseTest("x{3, 5}", concat("x", "{", "3", ",", " ", "5", "}"))
@@ -915,14 +915,11 @@ extension RegexTests {
 
     parseTest(#"\N{abc}"#, atom(.namedCharacter("abc")))
     parseTest(#"[\N{abc}]"#, charClass(atom_m(.namedCharacter("abc"))))
-    parseTest(
-      #"\N{abc}+"#,
-      oneOrMore(.eager,
-                atom(.namedCharacter("abc"))))
+    parseTest(#"\N{abc}+"#, oneOrMore(of: atom(.namedCharacter("abc"))))
     parseTest(
       #"\N {2}"#,
-      concat(atom(.escaped(.notNewline)),
-             exactly(.eager, 2, " ")))
+      concat(atom(.escaped(.notNewline)), exactly(2, of: " "))
+    )
 
     parseTest(#"\N{AA}"#, atom(.namedCharacter("AA")))
     parseTest(#"\N{U+AA}"#, scalar("\u{AA}"))
@@ -945,7 +942,7 @@ extension RegexTests {
     parseTest(#"[\p{C}]"#, charClass(prop_m(.generalCategory(.other))))
     parseTest(
       #"\p{C}+"#,
-      oneOrMore(.eager, prop(.generalCategory(.other))))
+      oneOrMore(of: prop(.generalCategory(.other))))
 
     parseTest(#"\p{Lx}"#, prop(.other(key: nil, value: "Lx")))
     parseTest(#"\p{gcL}"#, prop(.other(key: nil, value: "gcL")))
@@ -1064,7 +1061,7 @@ extension RegexTests {
       captures: .atom(name: "a1")
     )
 
-    parseTest(#"(?(1))?"#, zeroOrOne(.eager, conditional(
+    parseTest(#"(?(1))?"#, zeroOrOne(of: conditional(
       .groupMatched(ref(1)), trueBranch: empty(), falseBranch: empty())))
 
     parseTest(#"(?(R)a|b)"#, conditional(
@@ -1108,19 +1105,19 @@ extension RegexTests {
 
     parseTest(#"(?((a)?(b))(a)+|b)"#, conditional(
       groupCondition(.capture, concat(
-        zeroOrOne(.eager, capture("a")), capture("b")
+        zeroOrOne(of: capture("a")), capture("b")
       )),
-      trueBranch: oneOrMore(.eager, capture("a")),
+      trueBranch: oneOrMore(of: capture("a")),
       falseBranch: "b"
     ), captures: .tuple([
       .atom(), .optional(.atom()), .atom(), .optional(.array(.atom()))
     ]))
 
     parseTest(#"(?(?:(a)?(b))(a)+|b)"#, conditional(
       groupCondition(.nonCapture, concat(
-        zeroOrOne(.eager, capture("a")), capture("b")
+        zeroOrOne(of: capture("a")), capture("b")
       )),
-      trueBranch: oneOrMore(.eager, capture("a")),
+      trueBranch: oneOrMore(of: capture("a")),
       falseBranch: "b"
     ), captures: .tuple([
       .optional(.atom()), .atom(), .optional(.array(.atom()))
@@ -1190,10 +1187,10 @@ extension RegexTests {
 
     // MARK: Backtracking directives
 
-    parseTest("(*ACCEPT)?", zeroOrOne(.eager, backtrackingDirective(.accept)))
+    parseTest("(*ACCEPT)?", zeroOrOne(of: backtrackingDirective(.accept)))
     parseTest(
       "(*ACCEPT:a)??",
-      zeroOrOne(.reluctant, backtrackingDirective(.accept, name: "a"))
+      zeroOrOne(.reluctant, of: backtrackingDirective(.accept, name: "a"))
     )
     parseTest("(*:a)", backtrackingDirective(.mark, name: "a"))
     parseTest("(*MARK:a)", backtrackingDirective(.mark, name: "a"))
@@ -1208,17 +1205,17 @@ extension RegexTests {
 
     parseTest("(?~)", absentRepeater(empty()))
     parseTest("(?~abc)", absentRepeater(concat("a", "b", "c")))
-    parseTest("(?~a+)", absentRepeater(oneOrMore(.eager, "a")))
+    parseTest("(?~a+)", absentRepeater(oneOrMore(of: "a")))
     parseTest("(?~~)", absentRepeater("~"))
     parseTest("(?~a|b|c)", absentRepeater(alt("a", "b", "c")))
     parseTest("(?~(a))", absentRepeater(capture("a")), captures: .empty)
-    parseTest("(?~)*", zeroOrMore(.eager, absentRepeater(empty())))
+    parseTest("(?~)*", zeroOrMore(of: absentRepeater(empty())))
 
     parseTest("(?~|abc)", absentStopper(concat("a", "b", "c")))
-    parseTest("(?~|a+)", absentStopper(oneOrMore(.eager, "a")))
+    parseTest("(?~|a+)", absentStopper(oneOrMore(of: "a")))
     parseTest("(?~|~)", absentStopper("~"))
     parseTest("(?~|(a))", absentStopper(capture("a")), captures: .empty)
-    parseTest("(?~|a){2}", exactly(.eager, 2, absentStopper("a")))
+    parseTest("(?~|a){2}", exactly(2, of: absentStopper("a")))
 
     parseTest("(?~|a|b)", absentExpression("a", "b"))
     parseTest("(?~|~|~)", absentExpression("~", "~"))
@@ -1227,13 +1224,13 @@ extension RegexTests {
     parseTest("(?~|(a)|(?:(b)|c))", absentExpression(
       capture("a"), nonCapture(alt(capture("b"), "c"))
     ), captures: .optional(.atom()))
-    parseTest("(?~|a|b)?", zeroOrOne(.eager, absentExpression("a", "b")))
+    parseTest("(?~|a|b)?", zeroOrOne(of: absentExpression("a", "b")))
 
     parseTest("(?~|)", absentRangeClear())
 
     // TODO: It's not really clear what this means, but Oniguruma parses it...
     // Maybe we should diagnose it?
-    parseTest("(?~|)+", oneOrMore(.eager, absentRangeClear()))
+    parseTest("(?~|)+", oneOrMore(of: absentRangeClear()))
 
     // MARK: Global matching options
 
@@ -1372,19 +1369,19 @@ extension RegexTests {
       "(?x)a *",
       changeMatchingOptions(
         matchingOptions(adding: .extended), isIsolated: true,
-        zeroOrMore(.eager, "a"))
+        zeroOrMore(of: "a"))
     )
     parseTest(
       "(?x)a + ?",
       changeMatchingOptions(
         matchingOptions(adding: .extended), isIsolated: true,
-        oneOrMore(.reluctant, "a"))
+        oneOrMore(.reluctant, of: "a"))
     )
     parseTest(
       "(?x)a {2,4}",
       changeMatchingOptions(
         matchingOptions(adding: .extended), isIsolated: true,
-        quantRange(.eager, 2 ... 4, "a"))
+        quantRange(2 ... 4, of: "a"))
     )
 
     // PCRE states that whitespace won't be ignored within a range.
@@ -1424,7 +1421,7 @@ extension RegexTests {
 
     // Non-semantic whitespace between quantifier characters for consistency
     // with PCRE.
-    parseWithDelimitersTest("'|a * ?|'", zeroOrMore(.reluctant, "a"))
+    parseWithDelimitersTest("'|a * ?|'", zeroOrMore(.reluctant, of: "a"))
 
     // End-of-line comments aren't enabled by default in experimental syntax.
     parseWithDelimitersTest("'|#abc|'", concat("#", "a", "b", "c"))