Enable regex-based assertions.

src/NQP/Actions.pm

@@ -817,12 +817,17 @@ class NQP::RegexActions is Regex::P6Regex::Actions {
     method metachar:sym<{ }>($/) { make $<codeblock>.ast; }
 
     method metachar:sym<nqpvar>($/) {
-        make PAST::Regex.new( '!INTERPOLATE', $<var>.ast, :pasttype<subrule>,
-                              :subtype<method>, :node($/) );
+        make PAST::Regex.new( '!INTERPOLATE', $<var>.ast, 
+                              :pasttype<subrule>, :subtype<method>, :node($/));
     }
 
     method assertion:sym<{ }>($/) { make $<codeblock>.ast; }
 
+    method assertion:sym<var>($/) {
+        make PAST::Regex.new( '!INTERPOLATE_REGEX', $<var>.ast, 
+                              :pasttype<subrule>, :subtype<method>, :node($/));
+    }
+
     method codeblock($/) {
         my $block := $<block>.ast;
         $block.blocktype('immediate');

src/NQP/Grammar.pm

@@ -573,6 +573,9 @@ grammar NQP::Regex is Regex::P6Regex::Grammar {
             ]?
     }
 
+    token assertion:sym<var> {
+        <?[$@]> <var=.LANG('MAIN', 'variable')>
+    }
 
     token codeblock {
         <block=.LANG('MAIN','pblock')>

src/Regex/Cursor.pir

@@ -717,7 +717,9 @@ and the longest match is returned.
     if $I0 goto var_array
 
   var_scalar:
-    $I0 = does var, ['Sub']
+    $I0 = isa var, ['Sub']
+    if $I0 goto var_sub
+    $I0 = isa var, ['Eval']
     if $I0 goto var_sub
 
   var_string:
@@ -745,7 +747,7 @@ and the longest match is returned.
   array_loop:
     unless var_it goto array_done
     elem = shift var_it
-    $I0 = does elem, ['Sub']
+    $I0 = isa elem, ['Sub']
     if $I0 goto array_sub
   array_string:
     $S0 = elem
@@ -771,6 +773,47 @@ and the longest match is returned.
     .return (cur)
 .end
 
+
+=item !INTERPOLATE_REGEX(var)
+
+Same as C<!INTERPOLATE> above, except that any non-regex values
+are first compiled to regexes prior to being matched.  
+
+=cut
+
+.sub '!INTERPOLATE_REGEX' :method
+    .param pmc var
+
+    $I0 = isa var, ['Sub']
+    if $I0 goto done
+
+    .local pmc p6regex
+    p6regex = compreg 'Regex::P6Regex'
+
+    $I0 = does var, 'array'
+    if $I0 goto var_array
+    var = p6regex.'compile'(var)
+    goto done
+
+  var_array:
+    .local pmc var_it, elem
+    var_it = iter var
+    var = new ['ResizablePMCArray']
+  var_loop:
+    unless var_it goto done
+    elem = shift var_it
+    $I0 = isa elem, ['Sub']
+    if $I0 goto var_next
+    elem = p6regex.'compile'(elem)
+  var_next:
+    push var, elem
+    goto var_loop
+
+  done:
+    .tailcall self.'!INTERPOLATE'(var)
+.end
+
+
 =back
 
 =head2 Vtable functions

t/nqp/49-regex-interpolation.t

@@ -13,18 +13,18 @@ ok("ac+d" ~~ /a @foo d/,     'plain array interpolates as alternations of litera
 ok(!("abbbbbd" ~~ /a @foo d/), 'plain array interpolates as alternations of literals 3');
 ok(!("acccccd" ~~ /a @foo d/), 'plain array interpolates as alternations of literals 4');
 
-@foo := [ "b", "bb", "bbc", "bc" ];
+my @ltm := [ "b", "bb", "bbc", "bc" ];
 
-ok(("abd" ~~ / @foo /) eq 'b', 'array finds longest match 1');
-ok(("abbd" ~~ / @foo /) eq 'bb', 'array finds longest match 2');
-ok(("abbcd" ~~ / @foo /) eq 'bbc', 'array finds longest match 3');
-ok(("abccd" ~~ / @foo /) eq 'bc', 'array finds longest match 4');
+ok(("abd" ~~ / @ltm /) eq 'b', 'array finds longest match 1');
+ok(("abbd" ~~ / @ltm /) eq 'bb', 'array finds longest match 2');
+ok(("abbcd" ~~ / @ltm /) eq 'bbc', 'array finds longest match 3');
+ok(("abccd" ~~ / @ltm /) eq 'bc', 'array finds longest match 4');
 
+ok(!("ab+d"  ~~ /a <$b> d/), 'scalar assertion interpolates as regex 1');
+ok("abbbbbd" ~~ /a <$b> d/, 'scalar assertion interpolates as regex 2');
 
 =begin END
 
-ok(!("ab+d"  ~~ /a <$b> d/), 'scalar assertion interpolates as regex 1');
-ok("abbbbbd" ~~ /a <$b> d/, 'scalar assertion interpolates as regex 2');
 ok(!("ab+d" ~~ /a <@foo> d/),   'array assertion interpolates as alternations of regexen 1');
 ok(!("ac+d" ~~ /a <@foo> d/),   'array assertion interpolates as alternations of regexen 2');
 ok("abbbbbd" ~~ /a <@foo> d/, 'array assertion interpolates as alternations of regexen 3');