allow code block in ** quantifiers, / foo ** { $three..$seven } /

The code block in a quantifier can either provide a range object that
is used for min and maximum quantity, or it provides a single numeric
item that is used to match exactly that many times.

src/Perl6/Actions.nqp

@@ -7277,7 +7277,37 @@ class Perl6::RegexActions is QRegex::P6Regex::Actions does STDActions {
                                 :rxtype<subrule>, :subtype<method>, :node($/));
         }
     }
-
+
+    method quantifier:sym<**>($/) {
+        my $qast;
+        if $<codeblock> {
+            $qast := QAST::Regex.new( :rxtype<dynquant>, :node($/),
+                QAST::Op.new( :op('callmethod'), :name('DYNQUANT_LIMITS'),
+                    QAST::Var.new( :name('$¢'), :scope('lexical') ),
+                    $<codeblock>.ast
+                ),
+            );
+        }
+        else {
+            my $min := $<min>.ast;
+            my $max := -1;
+            if ! $<max> { $max := $min }
+            elsif $<max> ne '*' {
+                $max := $<max>.ast;
+                $/.CURSOR.panic("Empty range") if $min > $max;
+            }
+            $qast := QAST::Regex.new( :rxtype<quant>, :min($min), :max($max), :node($/) );
+        }
+        make backmod($qast, $<backmod>);
+    }
+
+    sub backmod($ast, $backmod) {
+        if $backmod eq ':' { $ast.backtrack('r') }
+        elsif $backmod eq ':?' || $backmod eq '?' { $ast.backtrack('f') }
+        elsif $backmod eq ':!' || $backmod eq '!' { $ast.backtrack('g') }
+        $ast;
+    }
+
     method metachar:sym<rakvar>($/) {
         make QAST::Regex.new( QAST::Node.new(
                                     QAST::SVal.new( :value('INTERPOLATE') ),

src/core/Cursor.pm

@@ -161,7 +161,19 @@ my class Cursor does NQPCursorRole {
             self."!cursor_start_cur"()
         }
     }
-
+
+    method DYNQUANT_LIMITS($mm) {
+        if $mm ~~ Range {
+            die 'Range minimum in quantifier (**) cannot be +Inf' if $mm.min ==  Inf;
+            die 'Range maximum in quantifier (**) cannot be -Inf' if $mm.max == -Inf;
+            nqp::list_i($mm.min < 0 ?? 0 !! $mm.min, $mm.max == Inf ?? -1 !! $mm.max)
+        }
+        else {
+            fail 'Fixed quantifier cannot be infinite' if $mm == -Inf || $mm == Inf;
+            nqp::list_i($mm, $mm)
+        }
+    }
+
     method OTHERGRAMMAR($grammar, $name, |) {
         my $lang_cursor := $grammar.'!cursor_init'(self.target(), :p(self.pos()));
         $lang_cursor."$name"();