Use faster nqp::elems instead of + on QAST nodes

zoffixznet · zoffixznet · commit 6b9d226f0cf8 · 2018-01-10T22:48:27.000-05:00
Bench shows it being about 20% faster
diff --git a/src/NQP/Optimizer.nqp b/src/NQP/Optimizer.nqp
@@ -361,7 +361,7 @@ class NQP::Optimizer {
     method visit_children($node, :$skip_selectors) {
         my int $i := 0;
         unless nqp::isstr($node) || !nqp::defined($node) {
-            while $i < +@($node) {
+            while $i < nqp::elems(@($node)) {
                 unless $skip_selectors && $i % 2 {
                     my $visit := $node[$i];
                     if nqp::istype($visit, QAST::Op) {
diff --git a/src/NQP/World.nqp b/src/NQP/World.nqp
@@ -240,7 +240,7 @@ class NQP::World is HLL::World {
 
                     # Clear up the fixup statements.
                     my $fixup_stmts := %!code_object_fixup_list{$subid};
-                    $fixup_stmts.shift() while +@($fixup_stmts);
+                    $fixup_stmts.shift() while nqp::elems(@($fixup_stmts));
                 }
                 $i := $i + 1;
             }
diff --git a/src/QAST/Block.nqp b/src/QAST/Block.nqp
@@ -84,7 +84,7 @@ class QAST::Block is QAST::Node does QAST::Children {
     method evaluate_unquotes(@unquotes) {
         my $result := self.shallow_clone();
         my $i := 0;
-        my $elems := +@(self);
+        my $elems := nqp::elems(@(self));
         while $i < $elems {
             $result[$i] := self[$i].evaluate_unquotes(@unquotes);
             $i := $i + 1;
diff --git a/src/QAST/Op.nqp b/src/QAST/Op.nqp
@@ -30,7 +30,7 @@ class QAST::Op is QAST::Node does QAST::Children {
 
     method count_inline_placeholder_usages(@usages) {
         my int $i := 0;
-        my int $elems := +@(self);
+        my int $elems := nqp::elems(@(self));
         while $i < $elems {
             self[$i].count_inline_placeholder_usages(@usages);
             $i++;
@@ -40,7 +40,7 @@ class QAST::Op is QAST::Node does QAST::Children {
     method substitute_inline_placeholders(@fillers) {
         my $result := self.shallow_clone();
         my int $i := 0;
-        my int $elems := +@(self);
+        my int $elems := nqp::elems(@(self));
         while $i < $elems {
             $result[$i] := self[$i].substitute_inline_placeholders(@fillers)
                 unless nqp::isstr(self[$i]);
@@ -52,7 +52,7 @@ class QAST::Op is QAST::Node does QAST::Children {
     method evaluate_unquotes(@unquotes) {
         my $result := self.shallow_clone();
         my $i := 0;
-        my $elems := +@(self);
+        my $elems := nqp::elems(@(self));
         while $i < $elems {
             $result[$i] := self[$i].evaluate_unquotes(@unquotes)
                 unless nqp::isstr(self[$i]);
diff --git a/src/QAST/Stmt.nqp b/src/QAST/Stmt.nqp
@@ -13,7 +13,7 @@ class QAST::Stmt is QAST::Node does QAST::Children {
 
     method count_inline_placeholder_usages(@usages) {
         my int $i := 0;
-        my int $elems := +@(self);
+        my int $elems := nqp::elems(@(self));
         while $i < $elems {
             self[$i].count_inline_placeholder_usages(@usages);
             $i++;
@@ -23,7 +23,7 @@ class QAST::Stmt is QAST::Node does QAST::Children {
     method substitute_inline_placeholders(@fillers) {
         my $result := self.shallow_clone();
         my int $i := 0;
-        my int $elems := +@(self);
+        my int $elems := nqp::elems(@(self));
         while $i < $elems {
             $result[$i] := self[$i].substitute_inline_placeholders(@fillers);
             $i++;
@@ -34,7 +34,7 @@ class QAST::Stmt is QAST::Node does QAST::Children {
     method evaluate_unquotes(@unquotes) {
         my $result := self.shallow_clone();
         my $i := 0;
-        my $elems := +@(self);
+        my $elems := nqp::elems(@(self));
         while $i < $elems {
             $result[$i] := self[$i].evaluate_unquotes(@unquotes);
             $i := $i + 1;
diff --git a/src/QAST/Stmts.nqp b/src/QAST/Stmts.nqp
@@ -13,7 +13,7 @@ class QAST::Stmts is QAST::Node does QAST::Children {
 
     method count_inline_placeholder_usages(@usages) {
         my int $i := 0;
-        my int $elems := +@(self);
+        my int $elems := nqp::elems(@(self));
         while $i < $elems {
             self[$i].count_inline_placeholder_usages(@usages);
             $i++;
@@ -23,7 +23,7 @@ class QAST::Stmts is QAST::Node does QAST::Children {
     method substitute_inline_placeholders(@fillers) {
         my $result := self.shallow_clone();
         my $i := 0;
-        my $elems := +@(self);
+        my $elems := nqp::elems(@(self));
         while $i < $elems {
             $result[$i] := self[$i].substitute_inline_placeholders(@fillers);
             $i := $i + 1;
@@ -34,7 +34,7 @@ class QAST::Stmts is QAST::Node does QAST::Children {
     method evaluate_unquotes(@unquotes) {
         my $result := self.shallow_clone();
         my $i := 0;
-        my $elems := +@(self);
+        my $elems := nqp::elems(@(self));
         while $i < $elems {
             $result[$i] := self[$i].evaluate_unquotes(@unquotes);
             $i := $i + 1;
diff --git a/src/QAST/Want.nqp b/src/QAST/Want.nqp
@@ -19,7 +19,7 @@ class QAST::Want is QAST::Node does QAST::Children {
 
     method count_inline_placeholder_usages(@usages) {
         my int $i := 0;
-        my int $elems := +@(self);
+        my int $elems := nqp::elems(@(self));
         while $i < $elems {
             self[$i].count_inline_placeholder_usages(@usages);
             $i := $i + 2;
@@ -29,7 +29,7 @@ class QAST::Want is QAST::Node does QAST::Children {
     method substitute_inline_placeholders(@fillers) {
         my $result := self.shallow_clone();
         my int $i := 0;
-        my int $elems := +@(self);
+        my int $elems := nqp::elems(@(self));
         while $i < $elems {
             $result[$i] := self[$i].substitute_inline_placeholders(@fillers);
             $i := $i + 2;
@@ -40,7 +40,7 @@ class QAST::Want is QAST::Node does QAST::Children {
     method evaluate_unquotes(@unquotes) {
         my $result := self.shallow_clone();
         my $i := 0;
-        my $elems := +@(self);
+        my $elems := nqp::elems(@(self));
         while $i < $elems {
             $result[$i] := self[$i].evaluate_unquotes(@unquotes);
             $i := $i + 2;
diff --git a/src/QRegex/NFA.nqp b/src/QRegex/NFA.nqp
@@ -168,7 +168,7 @@ class QRegex::NFA {
     }
 
     method altseq($node, $from, $to) {
-        if +@($node) {
+        if nqp::elems(@($node)) {
             my $indent := dentin();
             my int $st := self.regex_nfa($node[0], $from, $to);
             $to := $st if $to < 0 && $st > 0;
diff --git a/src/QRegex/P5Regex/Actions.nqp b/src/QRegex/P5Regex/Actions.nqp
@@ -455,8 +455,8 @@ class QRegex::P5Regex::Actions is HLL::Actions {
         }
         elsif $qast.rxtype eq 'concat' {
             my @tmp;
-            while +@($qast) { @tmp.push(@($qast).shift) }
-            while @tmp      { @($qast).push(self.flip_ast(@tmp.pop)) }
+            while nqp::elems(@($qast)) { @tmp.push(@($qast).shift) }
+            while @tmp { @($qast).push(self.flip_ast(@tmp.pop)) }
         }
         else {
             for @($qast) { self.flip_ast($_) }
diff --git a/src/QRegex/P6Regex/Actions.nqp b/src/QRegex/P6Regex/Actions.nqp
@@ -993,8 +993,8 @@ class QRegex::P6Regex::Actions is HLL::Actions {
         }
         elsif $qast.rxtype eq 'concat' {
             my @tmp;
-            while +@($qast) { @tmp.push(@($qast).shift) }
-            while @tmp      { @($qast).push(self.flip_ast(@tmp.pop)) }
+            while nqp::elems(@($qast)) { @tmp.push(@($qast).shift) }
+            while @tmp { @($qast).push(self.flip_ast(@tmp.pop)) }
         }
         else {
             for @($qast) { self.flip_ast($_) }
diff --git a/src/QRegex/P6Regex/Optimizer.nqp b/src/QRegex/P6Regex/Optimizer.nqp
@@ -32,7 +32,7 @@ class QRegex::Optimizer {
     }
 
     method first_non_concat_child($node) {
-        while +@($node) >= 1 {
+        while nqp::elems(@($node)) >= 1 {
             if nqp::istype($node, QAST::Regex) {
                 if $node.rxtype eq 'concat' {
                     if $node[0].rxtype eq 'qastnode' && $node[0].subtype eq 'declarative' {
@@ -52,7 +52,7 @@ class QRegex::Optimizer {
     }
 
     method dont_scan($node) {
-        while +@($node) >= 1 {
+        while nqp::elems(@($node)) >= 1 {
             if nqp::istype($node, QAST::Regex) {
                 if nqp::istype($node[0], QAST::Regex) && $node[0].rxtype eq 'scan' {
                     $node.shift;
@@ -72,9 +72,10 @@ class QRegex::Optimizer {
     method visit_concat($node) {
         # a single-child concat can become the child itself
         self.visit_children($node);
-        if +@($node) == 1 && $!level >= 1 {
+        if nqp::elems(@($node)) == 1 && $!level >= 1 {
             return $node[0];
-        } elsif nqp::istype($node[0], QAST::Regex) && +@($node) >= 2 && $!level >= 2 {
+        } elsif nqp::istype($node[0], QAST::Regex)
+        && nqp::elems(@($node)) >= 2 && $!level >= 2 {
             # we may have a scan followed by a begin-of-string assertion.
             # in that case we just shouldn't scan.
             if $node[0].rxtype eq 'scan'
diff --git a/src/vm/js/Compiler.nqp b/src/vm/js/Compiler.nqp
@@ -1504,7 +1504,7 @@ class QAST::CompilerJS does DWIMYNameMangling does SerializeOnce {
 
     multi method as_js(QAST::CompUnit $node, :$want) {
         # Should have a single child which is the outer block.
-        if +@($node) != 1 || !nqp::istype($node[0], QAST::Block) {
+        if nqp::elems(@($node)) != 1 || !nqp::istype($node[0], QAST::Block) {
             nqp::die("QAST::CompUnit should have one child that is a QAST::Block");
         }
 
diff --git a/src/vm/js/Operations.nqp b/src/vm/js/Operations.nqp
@@ -1520,7 +1520,7 @@ class QAST::OperationsJS {
     add_simple_op('getlexrel', $T_OBJ, [$T_OBJ, $T_STR]);
 
     add_op('getlex', sub ($comp, $node, :$want) {
-        if +@($node) != 1 || !nqp::istype($node[0], QAST::SVal) {
+        if nqp::elems(@($node)) != 1 || !nqp::istype($node[0], QAST::SVal) {
             nqp::die('getlex requires one string literal operand');
         }
         my str $name := $node[0].value;
@@ -1684,7 +1684,7 @@ class QAST::OperationsJS {
     }
 
     add_op('takedispatcher', sub ($comp, $node, :$want) {
-        if +@($node) != 1 || !nqp::istype($node[0], QAST::SVal) {
+        if nqp::elems(@($node)) != 1 || !nqp::istype($node[0], QAST::SVal) {
             nqp::die('takedispatcher requires one string literal operand');
         }
         my str $var := $node[0].value;
@@ -1732,7 +1732,7 @@ class QAST::OperationsJS {
         }
 
         my $code := nqp::istype($node[0], QAST::Want) ?? want($node[0], $T_STR) !! $node[0];
-        if +@($node) != 1 || !nqp::istype($code, QAST::SVal) {
+        if nqp::elems(@($node)) != 1 || !nqp::istype($code, QAST::SVal) {
             nqp::die('js requires one string literal operand');
         }
         Chunk.void($code.value ~ ";\n");
diff --git a/src/vm/js/RegexCompiler.nqp b/src/vm/js/RegexCompiler.nqp
@@ -261,9 +261,9 @@ class RegexCompiler {
     }
 
     method uniprop($node) {
-        if +@($node) == 1 || +@($node) == 2 {
+        if nqp::elems(@($node)) == 1 || nqp::elems(@($node)) == 2 {
             my $arg;
-            if +@($node) == 2 {
+            if nqp::elems(@($node)) == 2 {
                 $arg := $!compiler.as_js($node[1], :want($T_OBJ));
             }
 
@@ -274,7 +274,7 @@ class RegexCompiler {
             # except the hyphen in U+1180 HANGUL JUNGSEONG O-E.
 
             my str $prop := "nqp.uniprop_{$node.negate ?? 'not_' !! ''}{$mangled}";
-            my str $try_prop := +@($node) == 1
+            my str $try_prop := nqp::elems(@($node)) == 1
                 ?? "$prop($!target, $!pos)"
                 !! "$prop($*CTX, $!cursor, $!target, $!pos, {$arg.expr})";
 
@@ -288,7 +288,7 @@ class RegexCompiler {
                 ~ "if ($offset === -1) \{{self.fail}\} else \{$!pos += $offset\}\n";
             }
 
-            +@($node) == 1 ?? $check !! Chunk.void($arg, $check);
+            nqp::elems(@($node)) == 1 ?? $check !! Chunk.void($arg, $check);
         } else {
             $!compiler.NYI("NYI uniprop with more arguments");
         }
@@ -305,7 +305,7 @@ class RegexCompiler {
         if $node.name {
             @setup.push("," ~ quote_string($node.name));
         }
-        elsif +@($node) == 1 {
+        elsif nqp::elems(@($node)) == 1 {
             my $name := $!compiler.as_js($node[0], :want($T_STR));
             @setup.unshift($name);
             @setup.push(',');
diff --git a/src/vm/jvm/QAST/Compiler.nqp b/src/vm/jvm/QAST/Compiler.nqp
@@ -322,7 +322,7 @@ class QAST::OperationsJAST {
     sub op_mapper($op, $instruction, @stack_in, $stack_out, :$tc = 0, :$cont = 0) {
         my int $expected_args := +@stack_in;
         return -> $qastcomp, $node {
-            if +@($node) != $expected_args {
+            if nqp::elems(@($node)) != $expected_args {
                 nqp::die("Operation '$op' requires $expected_args operands");
             }
 
@@ -1449,7 +1449,7 @@ my $call_codegen := sub ($qastcomp, $node) {
     # Otherwise, it's an indirect call.
     else {
         # Ensure we have a thing to invoke.
-        nqp::die("A 'call' node must have a name or at least one child") unless +@($node) >= 1;
+        nqp::die("A 'call' node must have a name or at least one child") unless nqp::elems(@($node)) >= 1;
 
         # Process arguments, making sure first one is an object (since that is
         # the thing to invoke).
@@ -1477,7 +1477,7 @@ QAST::OperationsJAST.add_core_op('callmethod', -> $qastcomp, $node {
     my $il := JAST::InstructionList.new();
 
     # Ensure we have an invocant.
-    if +@($node) == 0 {
+    if nqp::elems(@($node)) == 0 {
         nqp::die("A 'callmethod' node must have at least one child");
     }
     my @children := nqp::clone(@($node));
@@ -2702,7 +2702,7 @@ QAST::OperationsJAST.map_classlib_core_op('getstaticcode', $TYPE_OPS, 'getstatic
 QAST::OperationsJAST.map_classlib_core_op('setdispatcher', $TYPE_OPS, 'setdispatcher', [$RT_OBJ], $RT_OBJ, :tc);
 QAST::OperationsJAST.map_classlib_core_op('setdispatcherfor', $TYPE_OPS, 'setdispatcherfor', [$RT_OBJ, $RT_OBJ], $RT_OBJ, :tc);
 QAST::OperationsJAST.add_core_op('takedispatcher', -> $qastcomp, $op {
-    if +@($op) != 1 || !nqp::istype($op[0], QAST::SVal) {
+    if nqp::elems(@($op)) != 1 || !nqp::istype($op[0], QAST::SVal) {
         nqp::die('takedispatcher requires one string literal operand');
     }
     my $name := $op[0].value;
@@ -2718,7 +2718,7 @@ QAST::OperationsJAST.add_core_op('takedispatcher', -> $qastcomp, $op {
     result($il, $RT_VOID);
 });
 QAST::OperationsJAST.add_core_op('cleardispatcher', -> $qastcomp, $op {
-    if +@($op) != 0 {
+    if nqp::elems(@($op)) != 0 {
         nqp::die('cleardispatcher accepts no operands');
     }
     my $il := JAST::InstructionList.new();
@@ -2729,7 +2729,7 @@ QAST::OperationsJAST.add_core_op('cleardispatcher', -> $qastcomp, $op {
     result($il, $RT_OBJ);
 });
 QAST::OperationsJAST.add_core_op('setup_blv', -> $qastcomp, $op {
-    if +@($op) != 1 || !nqp::ishash($op[0]) {
+    if nqp::elems(@($op)) != 1 || !nqp::ishash($op[0]) {
         nqp::die('setup_blv requires one hash operand');
     }
 
@@ -3420,7 +3420,7 @@ class QAST::CompilerJAST {
         }
 
         # Should have a single child which is the outer block.
-        if +@($cu) != 1 || !nqp::istype($cu[0], QAST::Block) {
+        if nqp::elems(@($cu)) != 1 || !nqp::istype($cu[0], QAST::Block) {
             nqp::die("QAST::CompUnit should have one child that is a QAST::Block");
         }
 
@@ -5748,7 +5748,7 @@ class QAST::CompilerJAST {
         if $node.name() {
             $qast.push(QAST::SVal.new( :value($node.name()) ));
         }
-        elsif +@($node) == 1 {
+        elsif nqp::elems(@($node)) == 1 {
             $qast.push($node[0]);
         }
         if $node.backtrack ne 'r' {
@@ -6477,7 +6477,7 @@ class QAST::CompilerJAST {
 
     method uniprop($node) {
         my $il := JAST::InstructionList.new();
-        if +@($node) > 1 {
+        if nqp::elems(@($node)) > 1 {
             nqp::die("Unicode property pairs NYI on jvm backend");
         }
 
diff --git a/src/vm/moar/QAST/QASTCompilerMAST.nqp b/src/vm/moar/QAST/QASTCompilerMAST.nqp
@@ -739,8 +739,9 @@ my class MASTCompilerInstance {
 
     multi method compile_node(QAST::CompUnit $cu, :$want) {
         # Should have a single child
-        if +@($cu) != 1 {
-            nqp::die("QAST::CompUnit should have 1 child, got " ~ +@($cu));
+        if nqp::elems(@($cu)) != 1 {
+            nqp::die("QAST::CompUnit should have 1 child, got "
+                ~ nqp::elems(@($cu)));
         }
 
         # Which is the outer block.
@@ -1324,8 +1325,9 @@ my class MASTCompilerInstance {
 
     multi method compile_node(QAST::Stmts $node, :$want) {
         my $resultchild := $node.resultchild;
-        nqp::die("resultchild out of range, max allowed is " ~ +@($node) - 1 ~ ", got $resultchild")
-            if (nqp::defined($resultchild) && $resultchild >= +@($node));
+        nqp::die("resultchild out of range, max allowed is "
+            ~ nqp::elems(@($node)) - 1 ~ ", got $resultchild")
+        if (nqp::defined($resultchild) && $resultchild >= nqp::elems(@($node)));
         self.compile_all_the_stmts(@($node), $resultchild)
     }
 
@@ -1344,8 +1346,9 @@ my class MASTCompilerInstance {
         my %*STMTTEMPS  := %stmt_temps;
         my $*INSTMT     := 1;
         my $resultchild := $node.resultchild;
-        nqp::die("resultchild out of range, max allowed is " ~ +@($node) - 1 ~ ", got $resultchild")
-            if (nqp::defined($resultchild) && $resultchild >= +@($node));
+        nqp::die("resultchild out of range, max allowed is "
+            ~ nqp::elems(@($node)) - 1 ~ ", got $resultchild")
+        if (nqp::defined($resultchild) && $resultchild >= nqp::elems(@($node)));
         self.compile_all_the_stmts(@($node), $resultchild);
     }
 
diff --git a/src/vm/moar/QAST/QASTOperationsMAST.nqp b/src/vm/moar/QAST/QASTOperationsMAST.nqp
diff --git a/src/vm/moar/QAST/QASTRegexCompilerMAST.nqp b/src/vm/moar/QAST/QASTRegexCompilerMAST.nqp

Original file line number	Diff line number	Diff line change
`@@ -240,7 +240,7 @@ class NQP::World is HLL::World {`
`240`	`240`
`241`	`241`	`# Clear up the fixup statements.`
`242`	`242`	`my $fixup_stmts := %!code_object_fixup_list{$subid};`
`243`		`- $fixup_stmts.shift() while +@($fixup_stmts);`
	`243`	`+ $fixup_stmts.shift() while nqp::elems(@($fixup_stmts));`
`244`	`244`	`}`
`245`	`245`	`$i := $i + 1;`
`246`	`246`	`}`
Original file line number	Diff line number	Diff line change
`@@ -168,7 +168,7 @@ class QRegex::NFA {`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`method altseq($node, $from, $to) {`
`171`		`- if +@($node) {`
	`171`	`+ if nqp::elems(@($node)) {`
`172`	`172`	`my $indent := dentin();`
`173`	`173`	`my int $st := self.regex_nfa($node[0], $from, $to);`
`174`	`174`	`$to := $st if $to < 0 && $st > 0;`
Original file line number	Diff line number	Diff line change
`@@ -455,8 +455,8 @@ class QRegex::P5Regex::Actions is HLL::Actions {`
`455`	`455`	`}`
`456`	`456`	`elsif $qast.rxtype eq 'concat' {`
`457`	`457`	`my @tmp;`
`458`		`- while +@($qast) { @tmp.push(@($qast).shift) }`
`459`		`- while @tmp { @($qast).push(self.flip_ast(@tmp.pop)) }`
	`458`	`+ while nqp::elems(@($qast)) { @tmp.push(@($qast).shift) }`
	`459`	`+ while @tmp { @($qast).push(self.flip_ast(@tmp.pop)) }`
`460`	`460`	`}`
`461`	`461`	`else {`
`462`	`462`	`for @($qast) { self.flip_ast($_) }`
Original file line number	Diff line number	Diff line change
`@@ -993,8 +993,8 @@ class QRegex::P6Regex::Actions is HLL::Actions {`
`993`	`993`	`}`
`994`	`994`	`elsif $qast.rxtype eq 'concat' {`
`995`	`995`	`my @tmp;`
`996`		`- while +@($qast) { @tmp.push(@($qast).shift) }`
`997`		`- while @tmp { @($qast).push(self.flip_ast(@tmp.pop)) }`
	`996`	`+ while nqp::elems(@($qast)) { @tmp.push(@($qast).shift) }`
	`997`	`+ while @tmp { @($qast).push(self.flip_ast(@tmp.pop)) }`
`998`	`998`	`}`
`999`	`999`	`else {`
`1000`	`1000`	`for @($qast) { self.flip_ast($_) }`