make symbol cache result-wide vs on each scope

Author: enebo

src/main/java/org/jruby/prism/builder/IRBuilderPrism.java

@@ -92,7 +92,10 @@ public class IRBuilderPrism extends IRBuilder<Node, DefNode, WhenNode, RescueNod
     byte[] source;
     Nodes.Source nodeSource;
     StaticScope staticScope;
-    IdentityHashMap<byte[], RubySymbol> symbols = new IdentityHashMap<>();
+    // This is originally sourced from ParseResult so that we only resolve symbols once per result instead of
+    // one per scope.  There is a little dance to set this ... we keep getting it from the parent scope
+    // unless it is a method definition then we get reference from the lazymethoddefinition.
+    IdentityHashMap<byte[], RubySymbol> symbols = null;
     ThreadContext context;
 
     public IRBuilderPrism(IRManager manager, IRScope scope, IRBuilder parent, IRBuilder variableBuilder, Encoding encoding) {
@@ -101,12 +104,19 @@ public IRBuilderPrism(IRManager manager, IRScope scope, IRBuilder parent, IRBuil
         if (parent != null) {
             source = ((IRBuilderPrism) parent).source;
             nodeSource = ((IRBuilderPrism) parent).nodeSource;
+            symbols = ((IRBuilderPrism) parent).symbols;
+        } else { // For END which is made without a parent and not setup by lazy method def.
+            symbols = new IdentityHashMap<>();
         }
         staticScope = scope.getStaticScope();
         staticScope.setFile(scope.getFile()); // staticScope and IRScope contain the same field.
         context = manager.getRuntime().getCurrentContext();
     }
 
+    public void setSymbols(IdentityHashMap<byte[], RubySymbol> symbols) {
+        this.symbols = symbols;
+    }
+
     // FIXME: Delete once we are no longer depedent on source code
     public void setSourceFrom(IRBuilderPrism other) {
         if (other.nodeSource == null) throw new RuntimeException("WETF");
@@ -130,6 +140,7 @@ public Operand build(ParseResult result) {
         this.executesOnce = false;
         this.source = ((ParseResultPrism) result).getSource();
         this.nodeSource = ((ParseResultPrism) result).getSourceNode();
+        this.symbols = ((ParseResultPrism) result).getSymbols();
 
 //        System.out.println("NAME: " + fileName);
 //        System.out.println(((ParseResultPrism) result).getRoot());
@@ -899,7 +910,7 @@ private Operand buildDef(DefNode node) {
         // FIXME: due to how lazy methods work we need this set on method before we actually parse the method.
         StaticScope staticScope = createStaticScopeFrom(node.locals, StaticScope.Type.LOCAL);
         staticScope.setSignature(calculateSignature(node.parameters));
-        LazyMethodDefinition def = new LazyMethodDefinitionPrism(getManager().getRuntime(), source, nodeSource, encoding, node);
+        LazyMethodDefinition def = new LazyMethodDefinitionPrism(getManager().getRuntime(), source, nodeSource, encoding, node, symbols);
 
         if (node.receiver == null) {
             return buildDefn(defineNewMethod(def, symbol(node.name).getBytes(), getLine(node), staticScope, true));
@@ -2860,6 +2871,21 @@ private Operand buildModuleParent(Node parent) {
     }
 
     private RubySymbol symbol(byte[] bytes) {
+        /*
+        var hit = symbols.get(bytes);
+
+        if (hit == null) {
+            hit = asSymbol(context, new ByteList(bytes, encoding));
+            if (hit.idString().charAt(0) == 'R') {
+                System.out.println("SAVING: " + hit + ", ENC: " + encoding);
+            }
+            symbols.put(bytes, hit);
+        } else {
+            //System.out.println("ALREADY FOUND: " + hit);
+        }
+
+        return hit;
+         */
         return symbols.computeIfAbsent(bytes, (_b) -> asSymbol(context, new ByteList(bytes, encoding)));
     }
 

src/main/java/org/jruby/prism/builder/LazyMethodDefinitionPrism.java

@@ -2,6 +2,7 @@
 
 import org.jcodings.Encoding;
 import org.jruby.Ruby;
+import org.jruby.RubySymbol;
 import org.jruby.ir.IRManager;
 import org.jruby.ir.IRMethod;
 import org.jruby.ir.builder.IRBuilder;
@@ -19,6 +20,7 @@
 import org.ruby_lang.prism.Nodes.WhenNode;
 
 import java.util.ArrayList;
+import java.util.IdentityHashMap;
 import java.util.List;
 
 import static org.jruby.api.Convert.asSymbol;
@@ -28,15 +30,18 @@ public class LazyMethodDefinitionPrism implements LazyMethodDefinition<Node, Def
     private final Nodes.Source nodeSource;
     private DefNode node;
     private byte[] source;
+    private IdentityHashMap<byte[], RubySymbol> symbols;
 
     final private Encoding encoding;
 
-    public LazyMethodDefinitionPrism(Ruby runtime, byte[] source, Nodes.Source nodeSource, Encoding encoding, DefNode node) {
+    public LazyMethodDefinitionPrism(Ruby runtime, byte[] source, Nodes.Source nodeSource, Encoding encoding,
+                                     DefNode node, IdentityHashMap<byte[], RubySymbol> symbols) {
         this.runtime = runtime;
         this.source = source;
         this.node = node;
         this.nodeSource = nodeSource;
         this.encoding = encoding;
+        this.symbols = symbols;
     }
     @Override
     public int getEndLine() {
@@ -89,6 +94,7 @@ public Node getMethodBody() {
     public IRBuilder<Node, DefNode, WhenNode, RescueNode, ConstantPathNode, Nodes.HashPatternNode> getBuilder(IRManager manager, IRMethod methodScope) {
         IRBuilder<Node, DefNode, WhenNode, RescueNode, ConstantPathNode, Nodes.HashPatternNode> builder = manager.getBuilderFactory().newIRBuilder(manager, methodScope, null, encoding);
 
+        ((IRBuilderPrism) builder).setSymbols(symbols);
         ((IRBuilderPrism) builder).setSourceFrom(nodeSource, source);
 
         return builder;

src/main/java/org/jruby/prism/parser/ParseResultPrism.java

@@ -10,12 +10,15 @@
 import org.jruby.util.ByteList;
 import org.ruby_lang.prism.Nodes;
 
+import java.util.IdentityHashMap;
+
 import static org.jruby.api.Convert.asSymbol;
 
 public class ParseResultPrism implements ParseResult {
     final Encoding encoding;
     StaticScope rootScope;
     Nodes.ProgramNode root;
+    IdentityHashMap<byte[], RubySymbol> symbols = new IdentityHashMap<>();
 
     final Nodes.Source nodeSource;
     final String fileName;
@@ -73,6 +76,10 @@ public int getCoverageMode() {
         return coverageMode;
     }
 
+    public IdentityHashMap<byte[], RubySymbol> getSymbols() {
+        return symbols;
+    }
+
     public Nodes.ProgramNode getRoot() {
         return root;
     }