Don't grab sigspace after $<var> = binding

Author: Mouq

src/QRegex/P6Regex/Actions.nqp

@@ -75,17 +75,21 @@ class QRegex::P6Regex::Actions is HLL::Actions {
 
     method quantified_atom($/) {
         my $qast := $<atom>.ast;
-        my $sig  := $<sigmaybe>.ast;
-        $qast := QAST::Regex.new(:rxtype<concat>, $qast, $sig) if $sig;
-        if $<quantifier> {
+        my $quant := $<quantifier>;
+        if $quant {
             $/.CURSOR.panic('Quantifier quantifies nothing')
                 unless $qast;
-            my $ast := $<quantifier>[0].ast;
+
+            # Always capture sigspace before quantifier
+            my $sig  := $<sigmaybe>.ast if $<sigmaybe>;
+            $qast := QAST::Regex.new(:rxtype<concat>, $qast, $sig) if $sig;
+
+            my $ast := $quant[0].ast;
             $ast.unshift($qast);
             $qast := $ast;
         }
         if $<separator> {
-            unless $qast.rxtype eq 'quant' || $<sigfinal> {
+            unless $qast.rxtype eq 'quant' {
                 $/.CURSOR.panic("'" ~ $<separator>[0]<septype> ~
                     "' many only be used immediately following a quantifier")
             }
@@ -95,11 +99,19 @@ class QRegex::P6Regex::Actions is HLL::Actions {
                     QAST::Regex.new( :rxtype<quant>, :min(0), :max(1), $<separator>[0].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;
+        }
         if $qast {
-            my $finalsig := $<sigfinal>[0].ast if $<quantifier>;
-            $qast := QAST::Regex.new(:rxtype<concat>, $qast, $finalsig) if $finalsig && !$sig;
             $qast.backtrack('r') if !$qast.backtrack && (%*RX<r> || $<backmod> && ~$<backmod>[0] eq ':');
-            $qast.node($/) if $qast;
+            $qast.node($/);
         }
         make $qast;
     }

src/QRegex/P6Regex/Grammar.nqp

@@ -101,7 +101,8 @@ grammar QRegex::P6Regex::Grammar is HLL::Grammar {
         || <?infixstopper>
         || $$ <.panic: "Regex not terminated">
         || (\W) { self.throw_unrecognized_metachar: ~$/[0] }
-        || <.panic: "Regex not terminated">
+        || (\w) { self.panic("missed one, boss: '"~$/[0]~"'") }
+        || {self.panic('Regex no term bra "'~$/~'", matched '~$<termseq>~'.')} #<.panic: "Regex not terminated">
         ]
     }
 
@@ -148,18 +149,19 @@ grammar QRegex::P6Regex::Grammar is HLL::Grammar {
     }
 
     token termish {
-        :my $*SIGOK := 0;
+        :my $*SIGOK  := False;
+        :my $*VARDEF := False;
         <noun=.quantified_atom>+
     }
 
     method SIGOK() { $*SIGOK := %*RX<s>; self }
 
     token quantified_atom {
         <!rxstopper>
-        <atom> <sigmaybe>
+        <atom> <sigmaybe>?
         [
             [
-            | <!rxstopper> <quantifier> <sigfinal=.sigmaybe>
+            | <!rxstopper> <quantifier> <.SIGOK> <sigfinal=.sigmaybe>?
             | <?[:]> <backmod> <!alpha>
             ]
             [ <separator> ]**0..1
@@ -189,8 +191,6 @@ grammar QRegex::P6Regex::Grammar is HLL::Grammar {
         { $*SIGOK := False }
     }
 
-    token sigmaybe:sym<nosp> { <?[\S]> }
-
     proto token quantifier { <...> }
     token quantifier:sym<*> { <sym> <backmod> }
     token quantifier:sym<+> { <sym> <backmod> }
@@ -264,7 +264,12 @@ grammar QRegex::P6Regex::Grammar is HLL::Grammar {
         | '$' $<pos>=[\d+]
         ]
 
-        [ <.ws> '=' <.ws> <quantified_atom> ]**0..1
+        [
+            <.ws> '=' <.ws>
+            {$*VARDEF := True}
+            <quantified_atom>
+            {$*VARDEF := False}
+        ]**0..1
         <.SIGOK>
     }