Make sigspace after $<var> = binding significant

Doing this required complexifying the grammar some, but in the process I
was at least able to simplify the $<quantified_atom> action

Author: Mouq

src/QRegex/P6Regex/Actions.nqp

@@ -75,16 +75,14 @@ class QRegex::P6Regex::Actions is HLL::Actions {
 
     method quantified_atom($/) {
         my $qast := $<atom>.ast;
-        my $quant := $<quantifier>;
-        if $quant {
-            $/.CURSOR.panic('Quantifier quantifies nothing')
-                unless $qast;
 
-            # Always capture sigspace before quantifier
-            my $sig  := $<sigmaybe>.ast if $<sigmaybe>;
-            $qast := QAST::Regex.new(:rxtype<concat>, $qast, $sig) if $sig;
+        my $sigmaybe := $<sigmaybe>.ast if $<sigmaybe>;
+        $qast := QAST::Regex.new(:rxtype<concat>, $qast, $sigmaybe) if $sigmaybe;
 
-            my $ast := $quant[0].ast;
+        if $<quantifier> {
+            $/.CURSOR.panic('Quantifier quantifies nothing')
+                unless $qast;
+            my $ast := $<quantifier>.ast;
             $ast.unshift($qast);
             $qast := $ast;
         }
@@ -93,22 +91,16 @@ class QRegex::P6Regex::Actions is HLL::Actions {
                 $/.CURSOR.panic("'" ~ $<separator>[0]<septype> ~
                     "' many only be used immediately following a quantifier")
             }
-            $qast.push($<separator>[0].ast);
-            if $<separator>[0]<septype> eq '%%' {
+            $qast.push($<separator>.ast);
+            if $<separator><septype> eq '%%' {
                 $qast := QAST::Regex.new( :rxtype<concat>, $qast,
-                    QAST::Regex.new( :rxtype<quant>, :min(0), :max(1), $<separator>[0].ast ));
+                    QAST::Regex.new( :rxtype<quant>, :min(0), :max(1), $<separator>.ast ));
             }
         }
-        # Don't capture trailing sigspace in a $<var> = binding
-        unless $*VARDEF {
-            my $sig;
-            if $quant {
-                $sig := $<sigfinal>[0].ast if $<sigfinal>;
-            } else {
-                $sig := $<sigmaybe>.ast if $<sigmaybe>;
-            }
-            $qast := QAST::Regex.new(:rxtype<concat>, $qast, $sig) if $sig && $qast;
-        }
+
+        my $sigfinal := $<sigfinal>.ast if $<sigfinal>;
+        $qast := QAST::Regex.new(:rxtype<concat>, $qast, $sigfinal) if $sigfinal;
+
         if $qast {
             $qast.backtrack('r') if !$qast.backtrack && (%*RX<r> || $<backmod> && ~$<backmod>[0] eq ':');
             $qast.node($/);

src/QRegex/P6Regex/Grammar.nqp

@@ -148,27 +148,34 @@ grammar QRegex::P6Regex::Grammar is HLL::Grammar {
     }
 
     token termish {
-        :my $*SIGOK  := False;
-        :my $*VARDEF := False;
+        :my $*SIGOK  := 0;
+        :my $*VARDEF := 0;
         <noun=.quantified_atom>+
     }
 
     method SIGOK() { $*SIGOK := %*RX<s>; self }
 
     token quantified_atom {
         <!rxstopper>
-        <atom> <sigmaybe>?
+        <atom>
         [
+        ||  <sigmaybe>?
             [
-            | <!rxstopper> <quantifier> <.SIGOK> <sigfinal=.sigmaybe>?
+            | <!rxstopper> <quantifier>
             | <?[:]> <backmod> <!alpha>
             ]
-            [ <separator> ]**0..1
-        ]**0..1
+            [ <!{$*VARDEF}> <.SIGOK> <sigfinal=.sigmaybe> ]?
+            [ <.ws> <separator> ]?
+        ||  [ <!{$*VARDEF}> <sigfinal=.sigmaybe> ]?
+        ]
+        { $*SIGOK := 0 }
     }
 
-    token separator {
-        $<septype>=['%''%'?] <normspace>**0..1 <quantified_atom>
+    rule separator {
+        $<septype>=['%''%'?]
+        :my $*VARDEF := 0;
+        :my $*SIGOK  := 0;
+        <quantified_atom>
     }
 
     token atom {
@@ -187,7 +194,6 @@ grammar QRegex::P6Regex::Grammar is HLL::Grammar {
 
     token sigmaybe:sym<sigwhite> {
         <?{$*SIGOK}> <normspace>
-        { $*SIGOK := False }
     }
 
     proto token quantifier { <...> }
@@ -265,9 +271,9 @@ grammar QRegex::P6Regex::Grammar is HLL::Grammar {
 
         [
             <.ws> '=' <.ws>
-            {$*VARDEF := True}
+            { $*VARDEF := 1 }
             <quantified_atom>
-            {$*VARDEF := False}
+            { $*VARDEF := 0 }
         ]**0..1
         <.SIGOK>
     }