try to turn lexicals into locals.

Author: timo

src/NQP/Optimizer.nqp

@@ -1,32 +1,103 @@
 class NQP::Optimizer {
     has @!block_stack;
+    has @!local_var_stack;
 
     method optimize($ast, *%adverbs) {
         @!block_stack := [$ast[0]];
+        @!local_var_stack := nqp::list();
         self.visit_children($ast);
         $ast;
     }
 
     method visit_block($block) {
         @!block_stack.push($block);
+        my %*shallow_var_usages := nqp::hash();
+        @!local_var_stack.push(%*shallow_var_usages);
+
+        # Push all the lexically declared variables into our shallow vars hash.
+        # Currently we limit ourselves to natives, because they are guaranteed
+        # not to have some weird setup that we have to be careful about.
+        if nqp::istype($block[0], QAST::Stmts) {
+            my int $idx := 0;
+            # before the $_ come the arguments. we must not turn these into locals,
+            # otherwise our signature binding will explode.
+            #say("THE BLOCK:::::::::::::::::::::::::::::::::::::::::::::::");
+            #say($block.dump);
+            #say(":::::::::::::::::::::::::::::::::::::::::::::::THE BLOCK");
+            while $idx < +@($block[0]) {
+                my $var := $block[0][$idx];
+                if nqp::istype($var, QAST::Op) && $var.op eq 'bind' {
+                    # variables are initialised on the spot in nqp.
+                    $var := $var[0]
+                }
+                if nqp::istype($var, QAST::Var) && $var.scope eq 'lexical' && $var.decl eq 'var' {
+                    # also make sure we don't turn dynamic vars into locals
+                    my $twigil := nqp::substr($var.name, 1, 1);
+                    my $sigil := nqp::substr($var.name, 0, 1);
+                    if $sigil eq '$'  && $twigil ne '*'
+                            && $var.name ne '$_' && $var.name ne '$/' && $var.name ne '$!' && $var.name ne '$¢' {
+                        %*shallow_var_usages{$var.name} := nqp::list($var);
+                    }
+                } elsif nqp::istype($var, QAST::Op) && $var.op eq 'bind' {
+                    if nqp::existskey(%*shallow_var_usages, $var[0].name) {
+                        nqp::push(%*shallow_var_usages{$var[0].name}, $var[0]);
+                    }
+                }
+                $idx := $idx + 1;
+            }
+        }
 
         self.visit_children($block);
 
+        my $succ;
+        for %*shallow_var_usages {
+            my $name := $_.key;
+            my $newname := $block.unique('lex_to_loc_' ~ +@!block_stack);
+            my @usages := $_.value;
+            say("found " ~ +@usages ~ " usages for $name");
+            for @usages -> $var {
+                say($var.scope ~ ": " ~ $var.name ~ " <- old");
+                $var.scope('local');
+                $var.name($newname);
+                #if $var.decl eq 'var' {
+                    #$var.decl('static');
+                #}
+                $succ := 1;
+            }
+            say("turned $name into a local ($newname), yippie");
+        }
+        if $succ {
+            say($block.dump);
+        }
+
         @!block_stack.pop();
+        @!local_var_stack.pop();
 
         $block;
     }
 
-    method find_lex($name) {
+    method lexical_depth($name) {
         my int $i := +@!block_stack;
         while $i > 0 {
             $i := $i - 1;
-            my %sym := @!block_stack[$i].symbol($name);
+            my $block := @!block_stack[$i];
+            my %sym := $block.symbol($name);
             if +%sym {
-                return %sym;
+                return $i;
             }
         }
-        NQPMu;
+        -1
+    }
+
+    method find_lex($name) {
+        my int $d := self.lexical_depth($name);
+        if $d >= 0 {
+            my $block := @!block_stack[$d];
+            my %sym := $block.symbol($name);
+            return %sym;
+        } else {
+            nqp::hash();
+        }
     }
 
     method find_sym($name) {
@@ -39,6 +110,34 @@ class NQP::Optimizer {
         }
     }
 
+    method visit_var($var) {
+        if $var.scope eq 'lexical' {
+            my int $lexdepth := self.lexical_depth($var.name);
+            my int $vardepth := +@!block_stack - 1 - $lexdepth;
+            if $lexdepth != -1 {
+                if $vardepth == 0 {
+                    if nqp::existskey(%*shallow_var_usages, $var.name) {
+                        say("found a usage for " ~ $var.name);
+                        nqp::push(%*shallow_var_usages{$var.name}, $var);
+                    }
+                } else {
+                    say("poisoned " ~ $var.name);
+                    say("my local var stack is " ~ +@!local_var_stack ~ " deep, my lexdepth is $lexdepth");
+                    say(nqp::existskey(@!local_var_stack[$lexdepth-1], $var.name));
+                    try {
+                        nqp::deletekey(@!local_var_stack[$lexdepth-1], $var.name);
+                    }
+                }
+            }
+        }
+
+        if nqp::istype($var, QAST::VarWithFallback) {
+            self.visit_children($var);
+        }
+
+        $var;
+    }
+    
     method visit_op($op) {
         sub returns_int($node) {
             if nqp::objprimspec($node.returns) == 1 {
@@ -63,6 +162,7 @@ class NQP::Optimizer {
             }
             return 0;
         }
+
         self.visit_children($op);
 
         my $typeinfo := nqp::chars($op.op) >= 2
@@ -118,6 +218,8 @@ class NQP::Optimizer {
                         $node[$i] := self.visit_op($visit)
                     } elsif nqp::istype($visit, QAST::Block) {
                         $node[$i] := self.visit_block($visit)
+                    } elsif nqp::istype($visit, QAST::Var) {
+                        $node[$i] := self.visit_var($visit);
                     } elsif nqp::istype($visit, QAST::Want) {
                         self.visit_children($visit, :skip_selectors)
                     } else {