Add block lex values to the CodeRefAnnotation

This unfortunately blows the classfile size for Rakudo CORE.setting

Author: Donald Hunter

src/vm/jvm/QAST/Compiler.nqp

@@ -2755,6 +2755,7 @@ class QAST::CompilerJAST {
         has @!lexical_names;    # List by type of lexial name lists
         has int $!num_save_sites;   # Count of points where a SaveStackException handler is needed
         has %!local2temp;       # Maps local names to temporarization info
+        has @!blv;
 
         method new($qast, $outer) {
             my $obj := nqp::create(self);
@@ -2773,6 +2774,7 @@ class QAST::CompilerJAST {
             %!lexical_idxs := nqp::hash();
             %!local2temp := nqp::hash();
             @!lexical_names := nqp::list([],[],[],[]);
+            @!blv := [];
         }
 
         method add_param($var) {
@@ -2795,6 +2797,7 @@ class QAST::CompilerJAST {
                 my $flags := $is_static ?? 0 !!
                              $is_cont   ?? 1 !! 2;
                 nqp::push(%blv{$!qast.cuid}, [$var.name, $var.value, $flags]);
+                nqp::push(@!blv, [$var.name, $var.value, $flags]);
             }
             @!lexicals[+@!lexicals] := $var;
         }
@@ -2868,6 +2871,7 @@ class QAST::CompilerJAST {
         method lexical_type($name) { %!lexical_types{$name} }
         method lexical_idx($name) { %!lexical_idxs{$name} }
         method lexical_names_by_type() { @!lexical_names }
+        method block_lexical_values() { @!blv }
     }
 
     my class BlockTempAlloc {
@@ -2992,7 +2996,21 @@ class QAST::CompilerJAST {
         # Now compile $source. By the end of this, the various data structures
         # set up above will be fully populated.
         self.as_jast($source);
-        
+
+        # Now fixup all the block lexical values to reference the serialization ids.
+        # The array of arrays will end up being a flat array of tuples.
+        for $*JCLASS.methods() -> $method {
+            my @bits := [];
+            for $method.block_lexical_values -> $lex {
+                nqp::push(@bits, $lex[0]);
+	            my $sc := nqp::getobjsc($lex[1]);
+                nqp::push(@bits, nqp::scgethandle($sc));
+                nqp::push(@bits, ~nqp::scgetobjidx($sc, $lex[1]));
+                nqp::push(@bits, ~$lex[2]);
+            }
+            $method.block_lexical_values(@bits);
+        }
+
         # Make various code-ref/dispatch related things.
         $*CODEREFS.jastify();
 
@@ -3849,7 +3867,9 @@ class QAST::CompilerJAST {
             if $node.is_thunk {
                 $*JMETH.is_thunk(1);
             }
-            
+
+            $*JMETH.block_lexical_values($block.block_lexical_values);
+
             # Finalize method and add it to the class.
             $*JCLASS.add_method($*JMETH);
         }

src/vm/jvm/QAST/JASTNodes.nqp

@@ -1,3 +1,4 @@
+
 class JAST::Node {
 }
 
@@ -116,6 +117,7 @@ class JAST::Method is JAST::Node {
     has int $!has_exit_handler;
     has int $!args_expectation;
     has int $!is_thunk;
+    has @!block_lexical_values;
 
     method BUILD(:$name!, :$returns!, :$static = 1) {
         $!name := $name;
@@ -132,6 +134,7 @@ class JAST::Method is JAST::Node {
         @!cr_nlex := [];
         @!cr_slex := [];
         @!cr_handlers := [];
+        @!block_lexical_values := [];
     }
 
     method add_argument($name, $type) {
@@ -165,6 +168,7 @@ class JAST::Method is JAST::Node {
     method has_exit_handler(*@value) { $!has_exit_handler := @value[0] if @value; $!has_exit_handler }
     method args_expectation(*@value) { $!args_expectation := @value[0] if @value; $!args_expectation }
     method is_thunk(*@value) { $!is_thunk := @value[0] if @value; $!is_thunk }
+    method block_lexical_values(*@value) { @value ?? (@!block_lexical_values := @value[0]) !! @!block_lexical_values }
 
     method dump(@dumped) {
         nqp::push(@dumped, "+ method");

src/vm/jvm/runtime/org/perl6/nqp/jast2bc/JASTCompiler.java

@@ -186,6 +186,15 @@ private void compileMethod(JavaClass jcout, JastMethod method, ClassWriter c, St
             if (method.hasExitHandler) av.visit("hasExitHandler", method.hasExitHandler);
             if (method.argsExpectation > 0) av.visit("argsExpectation", method.argsExpectation);
             if (method.isThunk) av.visit("isThunk", method.isThunk);
+
+            if (method.blv.size() > 0) {
+                avLex = av.visitArray("blockLexValues");
+                for (String s : method.blv) {
+                    avLex.visit(null,  s);
+                }
+                avLex.visitEnd();
+            }
+
             av.visitEnd();
         }
 

src/vm/jvm/runtime/org/perl6/nqp/jast2bc/JastMethod.java

@@ -35,6 +35,7 @@ public class JastMethod {
     public boolean hasExitHandler = false;
     public short argsExpectation = 0;
     public boolean isThunk = false;
+    public List<String> blv = new ArrayList<String>();
 
     Label beginAll, endAll;
     Map<String, LabelInfo> labels = new HashMap<String, LabelInfo>();
@@ -101,6 +102,8 @@ public JastMethod(SixModelObject jast, SixModelObject jastMethod, ThreadContext
         } catch (Throwable t) {
             /* Most likely a version of the node without the field. */
         }
+
+        fillList(blv, getattr(jast, jastMethod,"@!block_lexical_values", blvHint, tc), tc);
     }
 
     private void fillList(List<String> list, SixModelObject smoList, ThreadContext tc) {
@@ -114,7 +117,7 @@ private void fillList(List<String> list, SixModelObject smoList, ThreadContext t
     private static long nameHint, staticHint, returnsHint, argumentsHint,
             localsHint, instructionsHint, crNameHint, crCuidHint, crOuterHint,
             crOlexHint, crIlexHint, crNlexHint, crSlexHint, crHandlersHint,
-            hasExitHandlerHint, argsExpectationHint, isThunkHint;
+            hasExitHandlerHint, argsExpectationHint, isThunkHint,blvHint;
     public static void setup(SixModelObject jastMethod, ThreadContext tc) {
         nameHint            = jastMethod.st.REPR.hint_for(tc, jastMethod.st, jastMethod, "$!name");
         staticHint          = jastMethod.st.REPR.hint_for(tc, jastMethod.st, jastMethod, "$!static");
@@ -133,5 +136,6 @@ public static void setup(SixModelObject jastMethod, ThreadContext tc) {
         hasExitHandlerHint  = jastMethod.st.REPR.hint_for(tc, jastMethod.st, jastMethod, "$!has_exit_handler");
         argsExpectationHint = jastMethod.st.REPR.hint_for(tc, jastMethod.st, jastMethod, "$!args_expectation");
         isThunkHint         = jastMethod.st.REPR.hint_for(tc, jastMethod.st, jastMethod, "$!is_thunk");
+        blvHint             = jastMethod.st.REPR.hint_for(tc, jastMethod.st, jastMethod, "@!block_lexical_values");
     }
 }

src/vm/jvm/runtime/org/perl6/nqp/runtime/CodeRefAnnotation.java

@@ -17,4 +17,5 @@
     boolean hasExitHandler() default false;
     short argsExpectation() default 0;
     boolean isThunk() default false;
+    String[] blockLexValues() default {};
 }