Convert nqp::istrue into nqp::elems

In the same vein as 7573562, `if %hash`
or `if @array` just ends up checking the number of elems in the hash or
array, so doing it manually in places that get called a lot skips a lot
of calls to MVM_coerce_istrue.

src/HLL/Compiler.nqp

@@ -756,16 +756,19 @@ class HLL::Compiler does HLL::Backend::Default {
     method linefileof($target, int $pos, int :$cache = 0, int :$directives = 0) {
         my int $line := nqp::atpos_i(self.line_and_column_of($target, $pos, :$cache), 0);
         my str $file := '';
-        if $directives && (my @clds := @*comp_line_directives) {
+        if $directives {
+            my @clds := @*comp_line_directives;
             my int $i := nqp::elems(@clds);
-            while $i > 0 {
-                $i := $i - 1;
-                last if $line > @clds[$i][0];
-            }
-            if $line > @clds[$i][0] {
-                my @directive := @clds[$i];
-                $line := $line - @directive[0] + @directive[1] - 1;
-                $file := @directive[2];
+            if $i {
+                while $i > 0 {
+                    $i := $i - 1;
+                    last if $line > @clds[$i][0];
+                }
+                if $line > @clds[$i][0] {
+                    my @directive := @clds[$i];
+                    $line := $line - @directive[0] + @directive[1] - 1;
+                    $file := @directive[2];
+                }
             }
         }
         [$line, $file];

src/HLL/Grammar.nqp

@@ -405,7 +405,7 @@ An operator precedence parser.
             $pos := nqp::getattr_i($termcur, NQPMatch, '$!pos');
             nqp::bindattr_i($here, NQPMatch, '$!pos', $pos);
             if $pos < 0 {
-                $here.panic('Missing required term after infix') if @opstack;
+                $here.panic('Missing required term after infix') if nqp::elems(@opstack);
                 return $here;
             }
 
@@ -419,7 +419,7 @@ An operator precedence parser.
             @postfixish := nqp::atkey(%termOPER, 'postfixish');
 
             unless nqp::isnull(@prefixish) || nqp::isnull(@postfixish) {
-                while @prefixish && @postfixish {
+                while nqp::elems(@prefixish) && nqp::elems(@postfixish) {
                     my %preO     := @prefixish[0]<OPER><O>.made;
                     my %postO    := @postfixish[nqp::elems(@postfixish)-1]<OPER><O>.made;
                     my $preprec  := nqp::ifnull(nqp::atkey(%preO, 'sub'), nqp::ifnull(nqp::atkey(%preO, 'prec'), ''));
@@ -441,8 +441,8 @@ An operator precedence parser.
                         self.EXPR_nonassoc($here, ~@prefixish[0], ~@postfixish[0]);
                     }
                 }
-                nqp::push(@opstack, nqp::shift(@prefixish)) while @prefixish;
-                nqp::push(@opstack, nqp::pop(@postfixish)) while @postfixish;
+                nqp::push(@opstack, nqp::shift(@prefixish)) while nqp::elems(@prefixish);
+                nqp::push(@opstack, nqp::pop(@postfixish)) while nqp::elems(@postfixish);
             }
             nqp::deletekey($termish, 'prefixish');
             nqp::deletekey($termish, 'postfixish');
@@ -484,8 +484,8 @@ An operator precedence parser.
                     last;
                 }
 
-                while @opstack {
-                    my %opO := @opstack[+@opstack-1]<OPER><O>.made;
+                while nqp::elems(@opstack) {
+                    my %opO := @opstack[nqp::elems(@opstack)-1]<OPER><O>.made;
 
                     $opprec := nqp::ifnull(nqp::atkey(%opO, 'sub'), nqp::atkey(%opO, 'prec'));
                     last unless $opprec gt $inprec;
@@ -529,7 +529,7 @@ An operator precedence parser.
             return $here if $pos < 0;
         }
 
-        self.EXPR_reduce(@termstack, @opstack) while @opstack;
+        self.EXPR_reduce(@termstack, @opstack) while nqp::elems(@opstack);
 
 	    self.'!clone_match_at'(
 	        nqp::pop(@termstack),

src/QAST/Block.nqp

@@ -17,7 +17,7 @@ class QAST::Block is QAST::Node does QAST::Children {
         nqp::bindattr($node, QAST::Block, '@!children', @children);
         nqp::bindattr_s($node, QAST::Block, '$!name', $name);
         nqp::bindattr_s($node, QAST::Block, '$!blocktype', $blocktype);
-        $node.set(%options) if %options;
+        $node.set(%options) if nqp::isconcrete(%options) && nqp::elems(%options);
         $node
     }
 
@@ -60,7 +60,7 @@ class QAST::Block is QAST::Node does QAST::Children {
     my %NOSYMS := nqp::hash();
     method symbol(str $name, *%attrs) {
         %!symbol := nqp::hash() if nqp::isnull(%!symbol);
-        if %attrs {
+        if nqp::isconcrete(%attrs) && nqp::elems(%attrs) {
             my %syms := %!symbol{$name};
             if nqp::ishash(%syms) && nqp::elems(%syms) {
                 for %attrs {

src/QAST/Op.nqp

@@ -10,7 +10,7 @@ class QAST::Op is QAST::Node does QAST::Children {
         nqp::bindattr($node, QAST::Op, '@!children', @children);
         nqp::bindattr_s($node, QAST::Op, '$!name', $name);
         nqp::bindattr_s($node, QAST::Op, '$!op', $op);
-        $node.set(%options) if %options;
+        $node.set(%options) if nqp::isconcrete(%options) && nqp::elems(%options);
         $node
     }
 

src/QAST/Var.nqp

@@ -12,7 +12,7 @@ class QAST::Var is QAST::Node does QAST::Children {
         nqp::bindattr_s($node, QAST::Var, '$!name', $name);
         nqp::bindattr_s($node, QAST::Var, '$!scope', $scope);
         nqp::bindattr_s($node, QAST::Var, '$!decl', $decl);
-        $node.set(%options) if %options;
+        $node.set(%options) if nqp::isconcrete(%options) && nqp::elems(%options);
         $node
     }
 

src/QRegex/Cursor.nqp

@@ -625,7 +625,7 @@ role NQPMatchRole is export {
         my @rxfate := $nfa.states[0];
         my $cur;
         my $rxname;
-        while @fates {
+        while nqp::elems(@fates) {
             $rxname := nqp::atpos(@rxfate, nqp::pop_i(@fates));
             # note("invoking $rxname");
             $cur    := self."$rxname"();
@@ -1113,7 +1113,7 @@ class NQPMatch is NQPCapture does NQPMatchRole {
 
             # Walk the Cursor stack and populate the Cursor.
             my $cs := nqp::getattr(self, NQPMatch, '$!cstack');
-            if nqp::isnull($cs) || !nqp::istrue($cs) {}
+            if nqp::isnull($cs) || !nqp::isconcrete($cs) || !nqp::elems($cs) {}
             elsif $onlyname ne '' {
                 # If there's only one destination, avoid repeated hash lookups
                 my int $cselems := nqp::elems($cs);

src/QRegex/NFA.nqp

@@ -662,7 +662,7 @@ class QRegex::NFA {
 #        my $indent := dentin();
 #        note("$indent mergesubstates start $start to $to fate $fate") if $nfadeb;
         @!states[0][$fate] := $fate;  # overridden by !protoregex_nfa
-        if @substates {
+        if nqp::istype(@substates, NQPArray) && nqp::elems(@substates) {
             # create an empty end state for the subrule's NFA
             my int $substart := self.addstate();
             # Copy (yes, clone) @substates[1..*] into our states.
@@ -671,7 +671,7 @@ class QRegex::NFA {
             @substates := nqp::clone(@substates);
             nqp::shift(@substates);
             nqp::push(@!states, nqp::clone(nqp::shift(@substates)))
-              while @substates;
+              while nqp::elems(@substates);
             # Go through all of the newly added states, and
             #    apply $substart offset to target states
             #    adjust fate edges to be $fate

src/vm/moar/QAST/QASTOperationsMAST.nqp

@@ -92,7 +92,7 @@ class QAST::MASTOperations {
         my $mapper;
         if $hll {
             my %ops := %hll_ops{$hll};
-            $mapper := %ops{$name} if %ops;
+            $mapper := %ops{$name} if nqp::isconcrete(%ops) && nqp::elems(%ops);
         }
         $mapper := %core_ops{$name} unless $mapper;
         $mapper