Try to better convey void context.

Author: jnthn

src/QAST/Compiler.nqp

@@ -227,20 +227,21 @@ class QAST::Compiler is HLL::Compiler {
     method rxescape($str) { 'ucs4:"' ~ pir::escape__Ss($str) ~ '"' }
 
     proto method as_post($node, :$want) {
+        my $*WANT := $want;
         if $want {
             if nqp::istype($node, QAST::Want) {
                 self.coerce(self.as_post(want($node, $want)), $want)
             }
             else {
-                self.coerce(self.as_post($node), $want)
+                self.coerce({*}, $want)
             }
         }
         else {
             {*}
         }
     }
 
-    multi method as_post(QAST::CompUnit $cu) {
+    multi method as_post(QAST::CompUnit $cu, :$want) {
         # Set HLL.
         my $*HLL := '';
         if $cu.hll {
@@ -349,7 +350,7 @@ class QAST::Compiler is HLL::Compiler {
         )
     }
 
-    multi method as_post(QAST::Block $node) {
+    multi method as_post(QAST::Block $node, :$want) {
         # Build the POST::Sub.
         my $sub;
         {
@@ -572,7 +573,7 @@ class QAST::Compiler is HLL::Compiler {
         $ops
     }
 
-    multi method as_post(QAST::BlockMemo $node) {
+    multi method as_post(QAST::BlockMemo $node, :$want) {
         # Build the POST::Sub.
         my $sub;
         {
@@ -616,11 +617,11 @@ class QAST::Compiler is HLL::Compiler {
         return $sub;
     }
 
-    multi method as_post(QAST::Stmts $node) {
+    multi method as_post(QAST::Stmts $node, :$want) {
         self.compile_all_the_stmts($node.list, $node.resultchild, :node($node.node))
     }
 
-    multi method as_post(QAST::Stmt $node) {
+    multi method as_post(QAST::Stmt $node, :$want) {
         my $orig_reg := $*REGALLOC;
         {
             my $*REGALLOC := RegAlloc.new($orig_reg);
@@ -636,10 +637,15 @@ class QAST::Compiler is HLL::Compiler {
         my $n := +@stmts;
         for @stmts {
             my $void := $i + 1 < $n;
-            if nqp::istype($_, QAST::Want) && $void {
-                $_ := want($_, 'v');
+            if $void {
+                if nqp::istype($_, QAST::Want) {
+                    $_ := want($_, 'v');
+                }
+                $last := self.as_post($_, :want('v'));
+            }
+            else {
+                $last := self.as_post($_);
             }
-            $last := self.as_post($_);
             $ops.push($last)
                 unless $void && nqp::istype($_, QAST::Var);
             if nqp::defined($resultchild) && $resultchild == $i {
@@ -670,7 +676,7 @@ class QAST::Compiler is HLL::Compiler {
         $best
     }
 
-    multi method as_post(QAST::Op $node) {
+    multi method as_post(QAST::Op $node, :$want) {
         my $hll := '';
         my $result;
         my $err;
@@ -685,7 +691,7 @@ class QAST::Compiler is HLL::Compiler {
         $result
     }
 
-    multi method as_post(QAST::VM $node) {
+    multi method as_post(QAST::VM $node, :$want) {
         if $node.supports('parrot') {
             return self.as_post($node.alternative('parrot'))
         }
@@ -722,11 +728,11 @@ class QAST::Compiler is HLL::Compiler {
         }
     }
 
-    multi method as_post(QAST::Var $node) {
+    multi method as_post(QAST::Var $node, :$want) {
         self.compile_var($node)
     }
 
-    multi method as_post(QAST::VarWithFallback $node) {
+    multi method as_post(QAST::VarWithFallback $node, :$want) {
         my $post := self.compile_var($node);
         my $result;
         if $*BINDVAL {
@@ -928,35 +934,35 @@ class QAST::Compiler is HLL::Compiler {
         $want ?? self.as_post($node, :$want) !! self.as_post($node)
     }
 
-    multi method as_post(QAST::Want $node) {
+    multi method as_post(QAST::Want $node, :$want) {
         # If we're not in a coercive context, take the default.
         self.as_post($node[0])
     }
 
-    multi method as_post(QAST::IVal $node) {
+    multi method as_post(QAST::IVal $node, :$want) {
         PIRT::Ops.new(:result(~$node.value))
     }
 
-    multi method as_post(QAST::NVal $node) {
+    multi method as_post(QAST::NVal $node, :$want) {
         my $val := ~$node.value;
         $val := $val ~ '.0' unless nqp::index($val, '.', 0) >= 0 ||
                                    nqp::index($val, 'e', 0) > 0;
         PIRT::Ops.new(:result($val))
     }
 
-    multi method as_post(QAST::SVal $node) {
+    multi method as_post(QAST::SVal $node, :$want) {
         PIRT::Ops.new(:result(self.escape($node.value)))
     }
 
-    multi method as_post(QAST::BVal $node) {
+    multi method as_post(QAST::BVal $node, :$want) {
         my $cuid := self.escape($node.value.cuid);
         my $reg  := $*REGALLOC.fresh_p();
         my $ops  := PIRT::Ops.new(:result($reg));
         $ops.push_pirop(".const 'Sub' $reg = $cuid");
         $ops;
     }
 
-    multi method as_post(QAST::WVal $node) {
+    multi method as_post(QAST::WVal $node, :$want) {
         my $val    := $node.value;
         my $sc     := pir::nqp_get_sc_for_object__PP($val);
         my $handle := $sc.handle;
@@ -968,6 +974,7 @@ class QAST::Compiler is HLL::Compiler {
     }
 
     method coerce($post, $desired) {
+        return $post if $desired eq 'v';
         my $result := self.infer_type($post.result());
         if $result eq $desired {
             # Exact match
@@ -1046,7 +1053,7 @@ class QAST::Compiler is HLL::Compiler {
         }
     }
 
-    multi method as_post(QAST::Regex $node) {
+    multi method as_post(QAST::Regex $node, :$want) {
         my $ops := self.post_new('Ops');
         $ops.node($node.node) if $node.node;
         my $prefix := self.unique('rx') ~ '_';
@@ -1563,7 +1570,7 @@ class QAST::Compiler is HLL::Compiler {
         $ops.push_pirop('nqp_rxcommit', %*REG<bstack>, $mark);
     }
 
-    multi method as_post($unknown) {
+    multi method as_post($unknown, :$want) {
         nqp::die("Unknown QAST node type " ~ $unknown.HOW.name($unknown));
     }