Refactor BooleanCastWithDefaultNode to later support DSL inlining

Author: horakivo

src/main/java/org/truffleruby/RubyLanguage.java

@@ -100,7 +100,6 @@
 import org.truffleruby.interop.RubyInnerContext;
 import org.truffleruby.interop.RubySourceLocation;
 import org.truffleruby.language.LexicalScope;
-import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.RubyDynamicObject;
 import org.truffleruby.language.RubyEvalInteractiveRootNode;
 import org.truffleruby.language.RubyInlineParsingRequestNode;
@@ -136,6 +135,8 @@
 import com.oracle.truffle.api.utilities.CyclicAssumption;
 import org.truffleruby.stdlib.digest.RubyDigest;
 
+import static org.truffleruby.language.RubyBaseNode.createArray;
+import static org.truffleruby.language.RubyBaseNode.createString;
 import static org.truffleruby.language.RubyBaseNode.nil;
 
 @TruffleLanguage.Registration(
@@ -913,13 +914,13 @@ public static String filenameLine(SourceSection section) {
 
     public Object rubySourceLocation(RubyContext context, SourceSection section,
             TruffleString.FromJavaStringNode fromJavaStringNode,
-            RubyBaseNode node) {
+            Node node) {
         if (!BacktraceFormatter.isAvailable(section)) {
             return nil;
         } else {
-            var file = node.createString(fromJavaStringNode, getSourcePath(section.getSource()), Encodings.UTF_8);
+            var file = createString(node, fromJavaStringNode, getSourcePath(section.getSource()), Encodings.UTF_8);
             Object[] objects = new Object[]{ file, RubySource.getStartLineAdjusted(context, section) };
-            return node.createArray(objects);
+            return createArray(node, objects);
         }
     }
 

src/main/java/org/truffleruby/core/cast/BooleanCastWithDefaultNode.java

@@ -11,41 +11,24 @@
 
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Fallback;
-import org.truffleruby.language.RubyBaseNodeWithExecute;
+import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.NotProvided;
 
-import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
 
 /** Casts a value into a boolean and defaults to the given value if not provided. */
-@NodeChild(value = "valueNode", type = RubyBaseNodeWithExecute.class)
-public abstract class BooleanCastWithDefaultNode extends RubyBaseNodeWithExecute {
+public abstract class BooleanCastWithDefaultNode extends RubyBaseNode {
 
-    public static BooleanCastWithDefaultNode create(boolean defaultValue, RubyBaseNodeWithExecute node) {
-        return BooleanCastWithDefaultNodeGen.create(defaultValue, node);
-    }
-
-    private final boolean defaultValue;
-
-    public BooleanCastWithDefaultNode(boolean defaultValue) {
-        this.defaultValue = defaultValue;
-    }
-
-    public abstract RubyBaseNodeWithExecute getValueNode();
+    public abstract boolean execute(Object value, boolean defaultValue);
 
     @Specialization
-    protected boolean doDefault(NotProvided value) {
+    protected boolean doDefault(NotProvided value, boolean defaultValue) {
         return defaultValue;
     }
 
     @Fallback
-    protected boolean fallback(Object value,
+    protected boolean fallback(Object value, boolean defaultValue,
             @Cached BooleanCastNode booleanCastNode) {
         return booleanCastNode.execute(value);
     }
-
-    @Override
-    public RubyBaseNodeWithExecute cloneUninitialized() {
-        return create(defaultValue, getValueNode().cloneUninitialized());
-    }
 }

src/main/java/org/truffleruby/core/kernel/KernelNodes.java

@@ -149,7 +149,6 @@
 import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Cached.Exclusive;
-import com.oracle.truffle.api.dsl.CreateCast;
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
 import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.ImportStatic;
@@ -1251,29 +1250,40 @@ protected RubyMethod method(Frame callerFrame, Object self, Object[] rubyArgs, R
     @CoreMethod(names = "methods", optional = 1)
     @NodeChild(value = "object", type = RubyNode.class)
     @NodeChild(value = "regular", type = RubyBaseNodeWithExecute.class)
-    public abstract static class MethodsNode extends CoreMethodNode {
+    public abstract static class KernelMethodsNode extends CoreMethodNode {
+
+        @Specialization
+        protected RubyArray doMethods(Object self, Object maybeRegular,
+                @Cached BooleanCastWithDefaultNode booleanCastWithDefaultNode,
+                @Cached MethodsNode methodsNode) {
+            final boolean regular = booleanCastWithDefaultNode.execute(maybeRegular, true);
+            return methodsNode.execute(this, self, regular);
 
-        @CreateCast("regular")
-        protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute regular) {
-            return BooleanCastWithDefaultNode.create(true, regular);
         }
+    }
+
+    @GenerateInline
+    @GenerateCached(false)
+    public abstract static class MethodsNode extends RubyBaseNode {
+
+        public abstract RubyArray execute(Node node, Object self, boolean regular);
 
         @TruffleBoundary
         @Specialization(guards = "regular")
-        protected RubyArray methodsRegular(Object self, boolean regular,
+        protected static RubyArray methodsRegular(Node node, Object self, boolean regular,
                 @Cached MetaClassNode metaClassNode) {
-            final RubyModule metaClass = metaClassNode.execute(this, self);
+            final RubyModule metaClass = metaClassNode.execute(node, self);
 
             Object[] objects = metaClass.fields
-                    .filterMethodsOnObject(getLanguage(), regular, MethodFilter.PUBLIC_PROTECTED)
+                    .filterMethodsOnObject(getLanguage(node), regular, MethodFilter.PUBLIC_PROTECTED)
                     .toArray();
-            return createArray(objects);
+            return createArray(node, objects);
         }
 
         @Specialization(guards = "!regular")
-        protected RubyArray methodsSingleton(Object self, boolean regular,
+        protected static RubyArray methodsSingleton(Node node, Object self, boolean regular,
                 @Cached SingletonMethodsNode singletonMethodsNode) {
-            return singletonMethodsNode.execute(this, self, false);
+            return singletonMethodsNode.execute(node, self, false);
         }
 
     }
@@ -1312,15 +1322,12 @@ private void print(Object inspected) {
     @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class)
     public abstract static class PrivateMethodsNode extends CoreMethodNode {
 
-        @CreateCast("includeAncestors")
-        protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) {
-            return BooleanCastWithDefaultNode.create(true, includeAncestors);
-        }
-
         @TruffleBoundary
         @Specialization
-        protected RubyArray privateMethods(Object self, boolean includeAncestors,
+        protected RubyArray privateMethods(Object self, Object maybeIncludeAncestors,
+                @Cached BooleanCastWithDefaultNode booleanCastWithDefaultNode,
                 @Cached MetaClassNode metaClassNode) {
+            final boolean includeAncestors = booleanCastWithDefaultNode.execute(maybeIncludeAncestors, true);
             RubyClass metaClass = metaClassNode.execute(this, self);
 
             Object[] objects = metaClass.fields
@@ -1347,15 +1354,12 @@ protected RubyProc proc(VirtualFrame frame, Object maybeBlock,
     @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class)
     public abstract static class ProtectedMethodsNode extends CoreMethodNode {
 
-        @CreateCast("includeAncestors")
-        protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) {
-            return BooleanCastWithDefaultNode.create(true, includeAncestors);
-        }
-
         @TruffleBoundary
         @Specialization
-        protected RubyArray protectedMethods(Object self, boolean includeAncestors,
+        protected RubyArray protectedMethods(Object self, Object maybeIncludeAncestors,
+                @Cached BooleanCastWithDefaultNode booleanCastWithDefaultNode,
                 @Cached MetaClassNode metaClassNode) {
+            final boolean includeAncestors = booleanCastWithDefaultNode.execute(maybeIncludeAncestors, true);
             final RubyClass metaClass = metaClassNode.execute(this, self);
 
             Object[] objects = metaClass.fields
@@ -1386,16 +1390,13 @@ protected RubyMethod method(Frame callerFrame, Object self, Object[] rubyArgs, R
     @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class)
     public abstract static class PublicMethodsNode extends CoreMethodNode {
 
-        @CreateCast("includeAncestors")
-        protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) {
-            return BooleanCastWithDefaultNode.create(true, includeAncestors);
-        }
-
         @TruffleBoundary
         @Specialization
-        protected RubyArray publicMethods(Object self, boolean includeAncestors,
+        protected RubyArray publicMethods(Object self, Object maybeIncludeAncestors,
+                @Cached BooleanCastWithDefaultNode booleanCastWithDefaultNode,
                 @Cached MetaClassNode metaClassNode) {
             final RubyModule metaClass = metaClassNode.execute(this, self);
+            final boolean includeAncestors = booleanCastWithDefaultNode.execute(maybeIncludeAncestors, true);
 
             Object[] objects = metaClass.fields
                     .filterMethodsOnObject(getLanguage(), includeAncestors, MethodFilter.PUBLIC)
@@ -1557,14 +1558,11 @@ protected RubyMethod singletonMethod(Object self, Object nameObject,
     @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class)
     public abstract static class KernelSingletonMethodsNode extends CoreMethodNode {
 
-        @CreateCast("includeAncestors")
-        protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) {
-            return BooleanCastWithDefaultNode.create(true, includeAncestors);
-        }
-
         @Specialization
-        protected RubyArray singletonMethods(Object self, boolean includeAncestors,
+        protected RubyArray singletonMethods(Object self, Object maybeIncludeAncestors,
+                @Cached BooleanCastWithDefaultNode booleanCastWithDefaultNode,
                 @Cached SingletonMethodsNode singletonMethodsNode) {
+            final boolean includeAncestors = booleanCastWithDefaultNode.execute(maybeIncludeAncestors, true);
             return singletonMethodsNode.execute(this, self, includeAncestors);
         }
     }