Convert WithoutVisibilityNode to DSL inlinable node + BlockDefinitionNode converted to DSL node

Author: horakivo

src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java

@@ -9,6 +9,8 @@
  */
 package org.truffleruby.language.methods;
 
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Specialization;
 import org.truffleruby.core.kernel.TruffleKernelNodes.GetSpecialVariableStorage;
 import org.truffleruby.core.proc.ProcOperations;
 import org.truffleruby.core.proc.ProcCallTargets;
@@ -20,23 +22,19 @@
 import org.truffleruby.language.control.BreakID;
 import org.truffleruby.language.control.FrameOnStackMarker;
 
-import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import org.truffleruby.parser.BodyTranslator;
 
 /** Create a Ruby Proc to pass as a block to the called method. The literal block is represented as call targets and a
  * SharedMethodInfo. This is executed at the call site just before dispatch. */
-public final class BlockDefinitionNode extends RubyContextSourceNode {
+public abstract class BlockDefinitionNode extends RubyContextSourceNode {
 
     private final ProcType type;
     private final SharedMethodInfo sharedMethodInfo;
     private final ProcCallTargets callTargets;
     private final BreakID breakID;
     private final int frameOnStackMarkerSlot;
 
-    @Child private GetSpecialVariableStorage readSpecialVariableStorageNode;
-    @Child private WithoutVisibilityNode withoutVisibilityNode;
-
     public BlockDefinitionNode(
             ProcType type,
             SharedMethodInfo sharedMethodInfo,
@@ -50,15 +48,18 @@ public BlockDefinitionNode(
         this.breakID = breakID;
 
         this.frameOnStackMarkerSlot = frameOnStackMarkerSlot;
-        readSpecialVariableStorageNode = GetSpecialVariableStorage.create();
     }
 
     public BreakID getBreakID() {
         return breakID;
     }
 
-    @Override
-    public RubyProc execute(VirtualFrame frame) {
+    public abstract RubyProc execute(VirtualFrame virtualFrame);
+
+    @Specialization
+    RubyProc doBlockDefinition(VirtualFrame frame,
+            @Cached GetSpecialVariableStorage readSpecialVariableStorageNode,
+            @Cached WithoutVisibilityNode withoutVisibilityNode) {
         final FrameOnStackMarker frameOnStackMarker;
         if (frameOnStackMarkerSlot != BodyTranslator.NO_FRAME_ON_STACK_MARKER) {
             frameOnStackMarker = (FrameOnStackMarker) frame.getObject(frameOnStackMarkerSlot);
@@ -74,23 +75,16 @@ public RubyProc execute(VirtualFrame frame) {
                 sharedMethodInfo,
                 callTargets,
                 frame.materialize(),
-                readSpecialVariableStorageNode.executeCached(frame),
+                readSpecialVariableStorageNode.execute(frame, this),
                 RubyArguments.getMethod(frame),
                 frameOnStackMarker,
-                executeWithoutVisibility(RubyArguments.getDeclarationContext(frame)));
+                withoutVisibilityNode.executeWithoutVisibility(this, RubyArguments.getDeclarationContext(frame)));
     }
 
-    private DeclarationContext executeWithoutVisibility(DeclarationContext ctxIn) {
-        if (withoutVisibilityNode == null) {
-            CompilerDirectives.transferToInterpreterAndInvalidate();
-            withoutVisibilityNode = insert(WithoutVisibilityNodeGen.create());
-        }
-        return withoutVisibilityNode.executeWithoutVisibility(ctxIn);
-    }
 
     @Override
     public RubyNode cloneUninitialized() {
-        var copy = new BlockDefinitionNode(type, sharedMethodInfo, callTargets, breakID, frameOnStackMarkerSlot);
+        var copy = BlockDefinitionNodeGen.create(type, sharedMethodInfo, callTargets, breakID, frameOnStackMarkerSlot);
         return copy.copyFlags(this);
     }
 

src/main/java/org/truffleruby/language/methods/WithoutVisibilityNode.java

@@ -9,25 +9,30 @@
  */
 package org.truffleruby.language.methods;
 
+import com.oracle.truffle.api.dsl.GenerateCached;
+import com.oracle.truffle.api.dsl.GenerateInline;
+import com.oracle.truffle.api.nodes.Node;
 import org.truffleruby.language.RubyBaseNode;
 
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Specialization;
 
+@GenerateCached(false)
+@GenerateInline
 public abstract class WithoutVisibilityNode extends RubyBaseNode {
 
-    public abstract DeclarationContext executeWithoutVisibility(DeclarationContext declarationContext);
+    public abstract DeclarationContext executeWithoutVisibility(Node node, DeclarationContext declarationContext);
 
     @Specialization(guards = { "isSingleContext()", "declarationContext == cachedContext" },
             limit = "getDefaultCacheLimit()")
-    DeclarationContext cached(DeclarationContext declarationContext,
+    static DeclarationContext cached(DeclarationContext declarationContext,
             @Cached("declarationContext") DeclarationContext cachedContext,
             @Cached("uncached(cachedContext)") DeclarationContext without) {
         return without;
     }
 
     @Specialization(replaces = "cached")
-    DeclarationContext uncached(DeclarationContext declarationContext) {
+    static DeclarationContext uncached(DeclarationContext declarationContext) {
         return declarationContext.withVisibility(null);
     }
 

src/main/java/org/truffleruby/parser/MethodTranslator.java

@@ -17,6 +17,7 @@
 import org.truffleruby.language.control.IfElseNodeGen;
 import org.truffleruby.language.control.NotNodeGen;
 import org.truffleruby.language.locals.FindDeclarationVariableNodes.FrameSlotAndDepth;
+import org.truffleruby.language.methods.BlockDefinitionNodeGen;
 import org.truffleruby.language.methods.CachedLazyCallTargetSupplier;
 import org.truffleruby.core.IsNilNode;
 import org.truffleruby.core.cast.SplatCastNode;
@@ -178,7 +179,7 @@ public BlockDefinitionNode compileBlockNode(SourceIndexLength sourceSection, Par
             callTargets = new ProcCallTargets(procCompiler.get(), null, lambdaCompiler);
         }
 
-        final BlockDefinitionNode ret = new BlockDefinitionNode(
+        final BlockDefinitionNode ret = BlockDefinitionNodeGen.create(
                 emitLambda ? ProcType.LAMBDA : ProcType.PROC,
                 environment.getSharedMethodInfo(),
                 callTargets,