From 8c6262042a44fb4c968c45fc8632ef19bbf96d91 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 19 Aug 2022 14:46:49 +0200 Subject: [PATCH 01/46] Implement generic cloneUninitialized() for CoreMethodNode, CoreArrayArgumentsNode, PrimitiveNode and PrimitiveArrayArgumentsNode --- .../truffleruby/builtins/BuiltinsClasses.java | 19 +++++++++++++++++++ .../CoreMethodArrayArgumentsNode.java | 14 +++++++++++++- .../truffleruby/builtins/CoreMethodNode.java | 10 ++++++++++ .../builtins/PrimitiveArrayArgumentsNode.java | 14 +++++++++++++- .../truffleruby/builtins/PrimitiveNode.java | 9 ++++++++- .../language/RubyContextSourceNode.java | 6 ++++++ .../org/truffleruby/language/RubyNode.java | 9 +++++++++ .../truffleruby/language/RubyRootNode.java | 17 +++++++++++++++++ 8 files changed, 95 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/truffleruby/builtins/BuiltinsClasses.java b/src/main/java/org/truffleruby/builtins/BuiltinsClasses.java index ec97bc25dff8..a2a6839853d4 100644 --- a/src/main/java/org/truffleruby/builtins/BuiltinsClasses.java +++ b/src/main/java/org/truffleruby/builtins/BuiltinsClasses.java @@ -12,6 +12,7 @@ import java.util.Arrays; import java.util.List; +import com.oracle.truffle.api.CompilerDirectives; import org.truffleruby.cext.CExtNodesBuiltins; import org.truffleruby.cext.CExtNodesFactory; import org.truffleruby.core.GCNodesBuiltins; @@ -155,6 +156,7 @@ import org.truffleruby.interop.SourceLocationNodesBuiltins; import org.truffleruby.interop.SourceLocationNodesFactory; import org.truffleruby.language.RubyBaseNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.TruffleBootNodesBuiltins; import org.truffleruby.language.TruffleBootNodesFactory; import org.truffleruby.stdlib.CoverageNodesBuiltins; @@ -418,4 +420,21 @@ public static List>> getCoreN WeakRefNodesFactory.getFactories()); } + // TODO: maybe we can make this more efficient or prepopulate it (but that might eager-load node classes on JVM, not so good) + public static final ClassValue> FACTORIES = new ClassValue<>() { + @SuppressWarnings("unchecked") + @Override + protected NodeFactory computeValue(Class type) { + for (var factories : getCoreNodeFactories()) { + for (var factory : factories) { + if (factory.getNodeClass() == type) { + return (NodeFactory) factory; + } + } + } + + throw CompilerDirectives.shouldNotReachHere("Could not find NodeFactory for " + type); + } + }; + } diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java b/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java index 9846dcabe261..645a05b8be24 100644 --- a/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java +++ b/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java @@ -9,11 +9,23 @@ */ package org.truffleruby.builtins; +import com.oracle.truffle.api.dsl.NodeFactory; import org.truffleruby.language.RubyNode; import com.oracle.truffle.api.dsl.NodeChild; -@NodeChild(value = "arguments", type = RubyNode[].class) +@NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract class CoreMethodArrayArgumentsNode extends CoreMethodNode { + public abstract RubyNode[] getArgumentNodes(); + + @Override + public RubyNode cloneUninitialized() { + NodeFactory factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass()); + RubyNode[] copiedArguments = cloneUninitialized(getArgumentNodes()); + var copy = (CoreMethodArrayArgumentsNode) CoreMethodNodeManager.createNodeFromFactory(factory, copiedArguments); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodNode.java b/src/main/java/org/truffleruby/builtins/CoreMethodNode.java index 09d210eb18e1..13a9b51ff1da 100644 --- a/src/main/java/org/truffleruby/builtins/CoreMethodNode.java +++ b/src/main/java/org/truffleruby/builtins/CoreMethodNode.java @@ -9,11 +9,21 @@ */ package org.truffleruby.builtins; +import com.oracle.truffle.api.dsl.NodeFactory; import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.dsl.GenerateNodeFactory; +import org.truffleruby.language.RubyNode; @GenerateNodeFactory public abstract class CoreMethodNode extends RubyContextSourceNode { + @Override + public RubyNode cloneUninitialized() { + NodeFactory factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass()); + var copy = (CoreMethodNode) CoreMethodNodeManager.createNodeFromFactory(factory, RubyNode.EMPTY_ARRAY); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/builtins/PrimitiveArrayArgumentsNode.java b/src/main/java/org/truffleruby/builtins/PrimitiveArrayArgumentsNode.java index 4064ec2dfcc7..08dde73f119d 100644 --- a/src/main/java/org/truffleruby/builtins/PrimitiveArrayArgumentsNode.java +++ b/src/main/java/org/truffleruby/builtins/PrimitiveArrayArgumentsNode.java @@ -9,11 +9,23 @@ */ package org.truffleruby.builtins; +import com.oracle.truffle.api.dsl.NodeFactory; import org.truffleruby.language.RubyNode; import com.oracle.truffle.api.dsl.NodeChild; -@NodeChild(value = "arguments", type = RubyNode[].class) +@NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract class PrimitiveArrayArgumentsNode extends PrimitiveNode { + public abstract RubyNode[] getArgumentNodes(); + + @Override + public RubyNode cloneUninitialized() { + NodeFactory factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass()); + RubyNode[] copiedArguments = cloneUninitialized(getArgumentNodes()); + var copy = (PrimitiveArrayArgumentsNode) CoreMethodNodeManager.createNodeFromFactory(factory, copiedArguments); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/builtins/PrimitiveNode.java b/src/main/java/org/truffleruby/builtins/PrimitiveNode.java index d753b0c964f9..4ece4710c1c9 100644 --- a/src/main/java/org/truffleruby/builtins/PrimitiveNode.java +++ b/src/main/java/org/truffleruby/builtins/PrimitiveNode.java @@ -10,10 +10,12 @@ package org.truffleruby.builtins; +import com.oracle.truffle.api.dsl.NodeFactory; import org.truffleruby.language.RubyContextSourceNode; import org.truffleruby.language.NotProvided; import com.oracle.truffle.api.dsl.GenerateNodeFactory; +import org.truffleruby.language.RubyNode; @GenerateNodeFactory public abstract class PrimitiveNode extends RubyContextSourceNode { @@ -21,7 +23,12 @@ public abstract class PrimitiveNode extends RubyContextSourceNode { // The same as "undefined" in Ruby code protected static final Object FAILURE = NotProvided.INSTANCE; - public PrimitiveNode() { + @Override + public RubyNode cloneUninitialized() { + NodeFactory factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass()); + var copy = (PrimitiveNode) CoreMethodNodeManager.createNodeFromFactory(factory, RubyNode.EMPTY_ARRAY); + copy.copyFlags(this); + return copy; } } diff --git a/src/main/java/org/truffleruby/language/RubyContextSourceNode.java b/src/main/java/org/truffleruby/language/RubyContextSourceNode.java index 40ec4d02fbda..1f47cd6b8a86 100644 --- a/src/main/java/org/truffleruby/language/RubyContextSourceNode.java +++ b/src/main/java/org/truffleruby/language/RubyContextSourceNode.java @@ -60,4 +60,10 @@ protected void setSourceLength(int sourceLength) { public String toString() { return super.toString() + " at " + RubyLanguage.fileLine(getSourceSection()); } + + public void copyFlags(RubyContextSourceNode original) { + this.sourceCharIndex = original.sourceCharIndex; + this.sourceLength = original.sourceLength; + this.flags = original.flags; + } } diff --git a/src/main/java/org/truffleruby/language/RubyNode.java b/src/main/java/org/truffleruby/language/RubyNode.java index f8ff3598a92c..545a67d80320 100644 --- a/src/main/java/org/truffleruby/language/RubyNode.java +++ b/src/main/java/org/truffleruby/language/RubyNode.java @@ -317,4 +317,13 @@ Object getRootInstance(Frame frame, method); } + public abstract RubyNode cloneUninitialized(); + + protected static RubyNode[] cloneUninitialized(RubyNode[] nodes) { + RubyNode[] copies = new RubyNode[nodes.length]; + for (int i = 0; i < nodes.length; i++) { + copies[i] = nodes[i].cloneUninitialized(); + } + return copies; + } } diff --git a/src/main/java/org/truffleruby/language/RubyRootNode.java b/src/main/java/org/truffleruby/language/RubyRootNode.java index b4221e3a6b8f..0e45b376f815 100644 --- a/src/main/java/org/truffleruby/language/RubyRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyRootNode.java @@ -9,9 +9,11 @@ */ package org.truffleruby.language; +import com.oracle.truffle.api.CompilerDirectives; import com.oracle.truffle.api.RootCallTarget; import com.oracle.truffle.api.dsl.NodeFactory; import com.oracle.truffle.api.nodes.NodeUtil; +import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.builtins.ReRaiseInlinedExceptionNode; import org.truffleruby.language.control.ReturnID; @@ -115,4 +117,19 @@ public RubyNode copyBody() { return NodeUtil.cloneNode(body); } + @Override + protected boolean isCloneUninitializedSupported() { + return true; + } + + @Override + protected RootNode cloneUninitialized() { + if (getClass() != RubyRootNode.class) { + throw CompilerDirectives.shouldNotReachHere( + "TODO need to implement cloneUninitialized() on a subclass of RubyRootNode " + getClass()); + } + + return new RubyRootNode(getLanguage(), getSourceSection(), getFrameDescriptor(), sharedMethodInfo, + body.cloneUninitialized(), split, returnID); + } } From abb08d226db271e025e391fc0ebb2bfeede56b84 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Wed, 31 Aug 2022 21:09:34 +0300 Subject: [PATCH 02/46] Implement cloneUninitialized() for RubyBaseNodeWithExecute ancestors --- .../truffleruby/core/cast/BigIntegerCastNode.java | 8 +++++++- .../core/cast/BooleanCastWithDefaultNode.java | 8 +++++++- .../core/cast/NameToJavaStringNode.java | 8 +++++++- .../java/org/truffleruby/core/cast/ToAryNode.java | 14 +++++++++++++- .../java/org/truffleruby/core/cast/ToIntNode.java | 10 +++++++++- .../java/org/truffleruby/core/cast/ToLongNode.java | 9 ++++++++- .../java/org/truffleruby/core/cast/ToPathNode.java | 12 +++++++++++- .../java/org/truffleruby/core/cast/ToSNode.java | 12 +++++++++++- .../java/org/truffleruby/core/cast/ToStrNode.java | 12 +++++++++++- .../core/cast/ToStringOrSymbolNode.java | 12 +++++++++++- .../org/truffleruby/core/cast/ToSymbolNode.java | 10 +++++++++- .../language/RubyBaseNodeWithExecute.java | 2 ++ 12 files changed, 106 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/truffleruby/core/cast/BigIntegerCastNode.java b/src/main/java/org/truffleruby/core/cast/BigIntegerCastNode.java index bb561828324f..b3c26dbd803b 100644 --- a/src/main/java/org/truffleruby/core/cast/BigIntegerCastNode.java +++ b/src/main/java/org/truffleruby/core/cast/BigIntegerCastNode.java @@ -21,13 +21,15 @@ import java.math.BigInteger; /** Casts a value into a BigInteger. */ -@NodeChild(value = "value", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "valueNode", type = RubyBaseNodeWithExecute.class) public abstract class BigIntegerCastNode extends RubyBaseNodeWithExecute { public static BigIntegerCastNode create(RubyBaseNodeWithExecute value) { return BigIntegerCastNodeGen.create(value); } + abstract RubyBaseNodeWithExecute getValueNode(); + @Specialization protected BigInteger doInt(int value) { return BigIntegerOps.valueOf(value); @@ -56,4 +58,8 @@ private RubyException notAnInteger(Object object) { this); } + @Override + public RubyBaseNodeWithExecute cloneUninitialized() { + return create(getValueNode().cloneUninitialized()); + } } diff --git a/src/main/java/org/truffleruby/core/cast/BooleanCastWithDefaultNode.java b/src/main/java/org/truffleruby/core/cast/BooleanCastWithDefaultNode.java index 83fc903a7b4a..f70aa76ab5e3 100644 --- a/src/main/java/org/truffleruby/core/cast/BooleanCastWithDefaultNode.java +++ b/src/main/java/org/truffleruby/core/cast/BooleanCastWithDefaultNode.java @@ -18,7 +18,7 @@ import com.oracle.truffle.api.dsl.Specialization; /** Casts a value into a boolean and defaults to the given value if not provided. */ -@NodeChild(value = "value", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "valueNode", type = RubyBaseNodeWithExecute.class) public abstract class BooleanCastWithDefaultNode extends RubyBaseNodeWithExecute { public static BooleanCastWithDefaultNode create(boolean defaultValue, RubyBaseNodeWithExecute node) { @@ -31,6 +31,8 @@ public BooleanCastWithDefaultNode(boolean defaultValue) { this.defaultValue = defaultValue; } + abstract RubyBaseNodeWithExecute getValueNode(); + @Specialization protected boolean doDefault(NotProvided value) { return defaultValue; @@ -42,4 +44,8 @@ protected boolean fallback(Object value, return booleanCastNode.execute(value); } + @Override + public RubyBaseNodeWithExecute cloneUninitialized() { + return create(defaultValue, getValueNode().cloneUninitialized()); + } } diff --git a/src/main/java/org/truffleruby/core/cast/NameToJavaStringNode.java b/src/main/java/org/truffleruby/core/cast/NameToJavaStringNode.java index 1588f022eb7a..a06a88b8c71f 100644 --- a/src/main/java/org/truffleruby/core/cast/NameToJavaStringNode.java +++ b/src/main/java/org/truffleruby/core/cast/NameToJavaStringNode.java @@ -27,7 +27,7 @@ /** Converts a method name to a Java String. The exception message below assumes this conversion is done for a method * name. */ @GenerateUncached -@NodeChild(value = "value", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "valueNode", type = RubyBaseNodeWithExecute.class) public abstract class NameToJavaStringNode extends RubyBaseNodeWithExecute { public static NameToJavaStringNode create() { @@ -44,6 +44,8 @@ public static NameToJavaStringNode getUncached() { public abstract String execute(Object name); + abstract RubyBaseNodeWithExecute getValueNode(); + @Specialization(guards = "strings.isRubyString(value)", limit = "1") protected String stringNameToJavaString(Object value, @Cached RubyStringLibrary strings, @@ -95,4 +97,8 @@ protected String nameToJavaString(Object object, } } + @Override + public RubyBaseNodeWithExecute cloneUninitialized() { + return create(getValueNode().cloneUninitialized()); + } } diff --git a/src/main/java/org/truffleruby/core/cast/ToAryNode.java b/src/main/java/org/truffleruby/core/cast/ToAryNode.java index b7b795779b72..2f3fd7e3ea4f 100644 --- a/src/main/java/org/truffleruby/core/cast/ToAryNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToAryNode.java @@ -19,15 +19,21 @@ import com.oracle.truffle.api.dsl.Specialization; import com.oracle.truffle.api.profiles.BranchProfile; -@NodeChild(value = "child", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "childNode", type = RubyBaseNodeWithExecute.class) public abstract class ToAryNode extends RubyBaseNodeWithExecute { public static ToAryNode create() { return ToAryNodeGen.create(null); } + public static ToAryNode create(RubyBaseNodeWithExecute child) { + return ToAryNodeGen.create(child); + } + public abstract RubyArray executeToAry(Object object); + abstract RubyBaseNodeWithExecute getChildNode(); + @Specialization protected RubyArray coerceRubyArray(RubyArray array) { return array; @@ -60,4 +66,10 @@ protected RubyArray coerceObject(Object object, coreExceptions().typeErrorBadCoercion(object, "Array", "to_ary", coerced, this)); } } + + @Override + public RubyBaseNodeWithExecute cloneUninitialized() { + return create(getChildNode().cloneUninitialized()); + } + } diff --git a/src/main/java/org/truffleruby/core/cast/ToIntNode.java b/src/main/java/org/truffleruby/core/cast/ToIntNode.java index 28dd59c819f0..75ae9a595178 100644 --- a/src/main/java/org/truffleruby/core/cast/ToIntNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToIntNode.java @@ -47,7 +47,7 @@ * */ @GenerateUncached -@NodeChild(value = "child", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "childNode", type = RubyBaseNodeWithExecute.class) public abstract class ToIntNode extends RubyBaseNodeWithExecute { public static ToIntNode create() { @@ -60,6 +60,8 @@ public static ToIntNode create(RubyBaseNodeWithExecute child) { public abstract int execute(Object object); + abstract RubyBaseNodeWithExecute getChildNode(); + @Specialization protected int coerceInt(int value) { return value; @@ -116,4 +118,10 @@ protected int coerceObject(Object object, .call(coreLibrary().truffleTypeModule, "rb_to_int_fallback", object); return fitNode.execute(coerced); } + + @Override + public RubyBaseNodeWithExecute cloneUninitialized() { + return create(getChildNode().cloneUninitialized()); + } + } diff --git a/src/main/java/org/truffleruby/core/cast/ToLongNode.java b/src/main/java/org/truffleruby/core/cast/ToLongNode.java index 1e6551ff6f44..8bcb8a50b466 100644 --- a/src/main/java/org/truffleruby/core/cast/ToLongNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToLongNode.java @@ -24,7 +24,7 @@ /** See {@link ToIntNode} for a comparison of different integer conversion nodes. */ @GenerateUncached -@NodeChild(value = "child", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "childNode", type = RubyBaseNodeWithExecute.class) public abstract class ToLongNode extends RubyBaseNodeWithExecute { public static ToLongNode create() { @@ -37,6 +37,8 @@ public static ToLongNode create(RubyBaseNodeWithExecute child) { public abstract long execute(Object object); + abstract RubyBaseNodeWithExecute getChildNode(); + @Specialization protected long coerceInt(int value) { return value; @@ -87,4 +89,9 @@ protected long coerceObject(Object object, .call(coreLibrary().truffleTypeModule, "rb_to_int_fallback", object); return fitNode.execute(coerced); } + + @Override + public RubyBaseNodeWithExecute cloneUninitialized() { + return create(getChildNode().cloneUninitialized()); + } } diff --git a/src/main/java/org/truffleruby/core/cast/ToPathNode.java b/src/main/java/org/truffleruby/core/cast/ToPathNode.java index ecc1385ea41c..083f8e079763 100644 --- a/src/main/java/org/truffleruby/core/cast/ToPathNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToPathNode.java @@ -18,9 +18,15 @@ import com.oracle.truffle.api.dsl.NodeChild; import com.oracle.truffle.api.dsl.Specialization; -@NodeChild(value = "child", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "childNode", type = RubyBaseNodeWithExecute.class) public abstract class ToPathNode extends RubyBaseNodeWithExecute { + public static ToPathNode create(RubyBaseNodeWithExecute child) { + return ToPathNodeGen.create(child); + } + + abstract RubyBaseNodeWithExecute getChildNode(); + @Specialization protected RubyString coerceRubyString(RubyString path) { return path; @@ -37,4 +43,8 @@ protected RubyString coerceObject(Object object, return (RubyString) toPathNode.call(coreLibrary().truffleTypeModule, "coerce_to_path", object); } + @Override + public RubyBaseNodeWithExecute cloneUninitialized() { + return create(getChildNode().cloneUninitialized()); + } } diff --git a/src/main/java/org/truffleruby/core/cast/ToSNode.java b/src/main/java/org/truffleruby/core/cast/ToSNode.java index e8629c7f0d59..ba228acd2673 100644 --- a/src/main/java/org/truffleruby/core/cast/ToSNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToSNode.java @@ -22,11 +22,17 @@ import com.oracle.truffle.api.frame.VirtualFrame; import org.truffleruby.language.library.RubyStringLibrary; -@NodeChild(value = "value", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "valueNode", type = RubyBaseNodeWithExecute.class) public abstract class ToSNode extends RubyBaseNodeWithExecute { @Child private KernelNodes.ToSNode kernelToSNode; + public static ToSNode create(RubyBaseNodeWithExecute value) { + return ToSNodeGen.create(value); + } + + abstract RubyBaseNodeWithExecute getValueNode(); + @Specialization protected RubyString toS(RubyString string) { return string; @@ -58,4 +64,8 @@ protected RubyString kernelToS(Object object) { return kernelToSNode.executeToS(object); } + @Override + public RubyBaseNodeWithExecute cloneUninitialized() { + return create(getValueNode().cloneUninitialized()); + } } diff --git a/src/main/java/org/truffleruby/core/cast/ToStrNode.java b/src/main/java/org/truffleruby/core/cast/ToStrNode.java index ed5fee04735f..ee1e84f9a4ac 100644 --- a/src/main/java/org/truffleruby/core/cast/ToStrNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToStrNode.java @@ -24,15 +24,21 @@ import org.truffleruby.language.library.RubyStringLibrary; @GenerateUncached -@NodeChild(value = "child", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "childNode", type = RubyBaseNodeWithExecute.class) public abstract class ToStrNode extends RubyBaseNodeWithExecute { public static ToStrNode create() { return ToStrNodeGen.create(null); } + public static ToStrNode create(RubyBaseNodeWithExecute child) { + return ToStrNodeGen.create(child); + } + public abstract Object execute(Object object); + abstract RubyBaseNodeWithExecute getChildNode(); + @Specialization protected RubyString coerceRubyString(RubyString string) { return string; @@ -72,4 +78,8 @@ protected Object coerceObject(Object object, } } + @Override + public RubyBaseNodeWithExecute cloneUninitialized() { + return create(getChildNode().cloneUninitialized()); + } } diff --git a/src/main/java/org/truffleruby/core/cast/ToStringOrSymbolNode.java b/src/main/java/org/truffleruby/core/cast/ToStringOrSymbolNode.java index 1506e54100a6..5bb0fdf3b7c4 100644 --- a/src/main/java/org/truffleruby/core/cast/ToStringOrSymbolNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToStringOrSymbolNode.java @@ -25,15 +25,21 @@ /** Convert objects to a String by calling #to_str, but leave existing Strings or Symbols as they are. */ @GenerateUncached -@NodeChild(value = "child", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "childNode", type = RubyBaseNodeWithExecute.class) public abstract class ToStringOrSymbolNode extends RubyBaseNodeWithExecute { public static ToStringOrSymbolNode create() { return ToStringOrSymbolNodeGen.create(null); } + public static ToStringOrSymbolNode create(RubyBaseNodeWithExecute child) { + return ToStringOrSymbolNodeGen.create(child); + } + public abstract Object execute(Object value); + abstract RubyBaseNodeWithExecute getChildNode(); + @Specialization protected RubySymbol coerceRubySymbol(RubySymbol symbol) { return symbol; @@ -78,4 +84,8 @@ protected Object coerceObject(Object object, } } + @Override + public RubyBaseNodeWithExecute cloneUninitialized() { + return create(getChildNode().cloneUninitialized()); + } } diff --git a/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java b/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java index 8205bf9644a6..6e84689458a2 100644 --- a/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java @@ -26,7 +26,7 @@ import org.truffleruby.utils.Utils; @GenerateUncached -@NodeChild(value = "value", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "valueNode", type = RubyBaseNodeWithExecute.class) public abstract class ToSymbolNode extends RubyBaseNodeWithExecute { public static ToSymbolNode create() { @@ -43,6 +43,8 @@ public static ToSymbolNode getUncached() { public abstract RubySymbol execute(Object object); + abstract RubyBaseNodeWithExecute getValueNode(); + @Specialization protected RubySymbol symbol(RubySymbol symbol) { return symbol; @@ -114,4 +116,10 @@ protected RubySymbol toStr(Object object, protected int getCacheLimit() { return getLanguage().options.DISPATCH_CACHE; } + + @Override + public RubyBaseNodeWithExecute cloneUninitialized() { + return create(getValueNode().cloneUninitialized()); + } + } diff --git a/src/main/java/org/truffleruby/language/RubyBaseNodeWithExecute.java b/src/main/java/org/truffleruby/language/RubyBaseNodeWithExecute.java index 8c58ab663258..c1179a186f21 100644 --- a/src/main/java/org/truffleruby/language/RubyBaseNodeWithExecute.java +++ b/src/main/java/org/truffleruby/language/RubyBaseNodeWithExecute.java @@ -23,4 +23,6 @@ public abstract class RubyBaseNodeWithExecute extends RubyBaseNode { // Fundamental execute methods public abstract Object execute(VirtualFrame frame); + + public abstract RubyBaseNodeWithExecute cloneUninitialized(); } From d155b2160190d0cbdb6c396edc15f18a62e709df Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Thu, 25 Aug 2022 17:11:27 +0300 Subject: [PATCH 03/46] Implement cloneUninitialized() using node factory --- .../core/basicobject/BasicObjectNodes.java | 26 +++- .../core/binding/BindingNodes.java | 88 +++++++++++-- .../truffleruby/core/kernel/KernelNodes.java | 42 +++++- .../truffleruby/core/range/RangeNodes.java | 14 +- .../truffleruby/core/string/StringNodes.java | 13 +- .../truffleruby/core/support/TypeNodes.java | 10 +- .../org/truffleruby/interop/InteropNodes.java | 120 ++++++++++++++++-- 7 files changed, 280 insertions(+), 33 deletions(-) diff --git a/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java b/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java index 975966ca4a31..3930e1189daf 100644 --- a/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java +++ b/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java @@ -121,19 +121,25 @@ protected boolean equal(VirtualFrame frame, Object a, Object b) { @GenerateUncached @GenerateNodeFactory @CoreMethod(names = { "equal?", "==" }, required = 1) - @NodeChild(value = "arguments", type = RubyNode[].class) + @NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract static class ReferenceEqualNode extends RubySourceNode { public static ReferenceEqualNode create() { return ReferenceEqualNodeFactory.create(null); } + public static ReferenceEqualNode create(RubyNode[] argumentNodes) { + return ReferenceEqualNodeFactory.create(argumentNodes); + } + public static ReferenceEqualNode getUncached() { return ReferenceEqualNodeFactory.getUncached(); } public abstract boolean executeReferenceEqual(Object a, Object b); + abstract RubyNode[] getArgumentNodes(); + @Specialization protected boolean equal(boolean a, boolean b) { return a == b; @@ -194,18 +200,27 @@ protected static boolean comparablePrimitives(Object a, Object b) { (RubyGuards.isImplicitLong(a) && RubyGuards.isImplicitLong(b)) || (RubyGuards.isDouble(a) && RubyGuards.isDouble(b)); } + + @Override + public RubyNode cloneUninitialized() { + return create(cloneUninitialized(getArgumentNodes())); + } } @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "value", type = RubyNode.class) @CoreMethod(names = "__id__") + @NodeChild(value = "valueNode", type = RubyNode.class) public abstract static class ObjectIDNode extends RubySourceNode { public static ObjectIDNode create() { return BasicObjectNodesFactory.ObjectIDNodeFactory.create(null); } + public static ObjectIDNode create(RubyNode valueNode) { + return BasicObjectNodesFactory.ObjectIDNodeFactory.create(valueNode); + } + public static ObjectIDNode getUncached() { return BasicObjectNodesFactory.ObjectIDNodeFactory.getUncached(); } @@ -214,6 +229,8 @@ public static ObjectIDNode getUncached() { public abstract long execute(RubyDynamicObject value); + abstract RubyNode getValueNode(); + @Specialization protected long objectIDNil(Nil nil) { return ObjectIDOperations.NIL; @@ -310,6 +327,11 @@ protected int objectIDForeign(Object value, return System.identityHashCode(value); } } + + @Override + public RubyNode cloneUninitialized() { + return create(getValueNode().cloneUninitialized()); + } } @GenerateUncached diff --git a/src/main/java/org/truffleruby/core/binding/BindingNodes.java b/src/main/java/org/truffleruby/core/binding/BindingNodes.java index f589c0eec9d5..3dab4d2745dc 100644 --- a/src/main/java/org/truffleruby/core/binding/BindingNodes.java +++ b/src/main/java/org/truffleruby/core/binding/BindingNodes.java @@ -213,13 +213,21 @@ protected int getCacheLimit() { @GenerateUncached @GenerateNodeFactory @CoreMethod(names = "local_variable_defined?", required = 1) - @NodeChild(value = "binding", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "bindingNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) public abstract static class LocalVariableDefinedNode extends RubySourceNode { + public static LocalVariableDefinedNode create(RubyNode bindingNode, RubyBaseNodeWithExecute nameNode) { + return BindingNodesFactory.LocalVariableDefinedNodeFactory.create(bindingNode, nameNode); + } + public abstract boolean execute(RubyBinding binding, String name); - @CreateCast("name") + abstract RubyNode getBindingNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -255,23 +263,42 @@ protected int getCacheLimit() { return getLanguage().options.BINDING_LOCAL_VARIABLE_CACHE; } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + return create( + getBindingNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized()); + } + } @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "binding", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) - @ImportStatic(BindingNodes.class) @CoreMethod(names = "local_variable_get", required = 1) + @NodeChild(value = "bindingNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @ImportStatic(BindingNodes.class) public abstract static class LocalVariableGetNode extends RubySourceNode { - public abstract Object execute(RubyBinding binding, String name); - public static LocalVariableGetNode create() { return BindingNodesFactory.LocalVariableGetNodeFactory.create(null, null); } - @CreateCast("name") + public static LocalVariableGetNode create(RubyNode bindingNode, RubyBaseNodeWithExecute nameNode) { + return BindingNodesFactory.LocalVariableGetNodeFactory.create(bindingNode, nameNode); + } + + public abstract Object execute(RubyBinding binding, String name); + + abstract RubyNode getBindingNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -301,15 +328,26 @@ protected int getCacheLimit() { return getLanguage().options.BINDING_LOCAL_VARIABLE_CACHE; } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + return create( + getBindingNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized()); + } + } @ReportPolymorphism @GenerateUncached @GenerateNodeFactory @CoreMethod(names = "local_variable_set", required = 2) - @NodeChild(value = "binding", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "bindingNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "valueNode", type = RubyNode.class) @ImportStatic({ BindingNodes.class, FindDeclarationVariableNodes.class }) public abstract static class LocalVariableSetNode extends RubySourceNode { @@ -317,9 +355,20 @@ public static LocalVariableSetNode create() { return BindingNodesFactory.LocalVariableSetNodeFactory.create(null, null, null); } + public static LocalVariableSetNode create(RubyNode bindingNode, RubyBaseNodeWithExecute nameNode, + RubyNode valueNode) { + return BindingNodesFactory.LocalVariableSetNodeFactory.create(bindingNode, nameNode, valueNode); + } + public abstract Object execute(RubyBinding binding, String name, Object value); - @CreateCast("name") + abstract RubyNode getBindingNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + abstract RubyNode getValueNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -396,6 +445,19 @@ protected WriteFrameSlotNode createWriteNode(int frameSlot) { protected int getCacheLimit() { return getLanguage().options.BINDING_LOCAL_VARIABLE_CACHE; } + + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + return create( + getBindingNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getValueNode().cloneUninitialized()); + } + } @Primitive(name = "local_variable_names") diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java index 8980efc2083a..2da10726321c 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java @@ -655,14 +655,28 @@ protected Object dup(Frame callerFrame, Object self, Object[] rubyArgs, RootCall } } - @NodeChild(value = "self", type = RubyNode.class) + @NodeChild(value = "selfNode", type = RubyNode.class) @GenerateNodeFactory public abstract static class DupASTNode extends RubyContextSourceNode { + + public static DupASTNode create(RubyNode selfNode) { + return KernelNodesFactory.DupASTNodeFactory.create(selfNode); + } + @Specialization protected Object execute(VirtualFrame frame, Object self, @Cached DupNode dupNode) { return dupNode.execute(frame, self, ArrayUtils.EMPTY_ARRAY, null); } + + abstract RubyNode getSelfNode(); + + @Override + public RubyNode cloneUninitialized() { + var copy = create(getSelfNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } } @GenerateUncached @@ -1827,7 +1841,7 @@ protected boolean isUntrusted(Object object, @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "valueNode", type = RubyNode.class) @Primitive(name = "kernel_to_hex") public abstract static class ToHexStringNode extends RubySourceNode { @@ -1835,12 +1849,18 @@ public static ToHexStringNode create() { return KernelNodesFactory.ToHexStringNodeFactory.create(null); } + public static ToHexStringNode create(RubyNode valueNode) { + return KernelNodesFactory.ToHexStringNodeFactory.create(valueNode); + } + public static ToHexStringNode getUncached() { return KernelNodesFactory.ToHexStringNodeFactory.getUncached(); } public abstract String executeToHexString(Object value); + abstract RubyNode getValueNode(); + @Specialization protected String toHexString(int value) { return toHexString((long) value); @@ -1857,20 +1877,31 @@ protected String toHexString(RubyBignum value) { return BigIntegerOps.toString(value.value, 16); } + @Override + public RubyNode cloneUninitialized() { + return create(getValueNode().cloneUninitialized()); + } + } @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "self", type = RubyNode.class) @CoreMethod(names = { "to_s", "inspect" }) // Basic #inspect, refined later in core + @NodeChild(value = "selfNode", type = RubyNode.class) public abstract static class ToSNode extends RubySourceNode { public static ToSNode create() { return KernelNodesFactory.ToSNodeFactory.create(null); } + public static ToSNode create(RubyNode selfNode) { + return KernelNodesFactory.ToSNodeFactory.create(selfNode); + } + public abstract RubyString executeToS(Object self); + abstract RubyNode getSelfNode(); + @Specialization protected RubyString toS(Object self, @Cached LogicalClassNode classNode, @@ -1907,6 +1938,11 @@ public static String uncachedBasicToS(RubyDynamicObject self) { return "#<" + className + ":0x" + hexID + ">"; } + @Override + public RubyNode cloneUninitialized() { + return create(getSelfNode().cloneUninitialized()); + } + } @CoreMethod(names = "untaint") diff --git a/src/main/java/org/truffleruby/core/range/RangeNodes.java b/src/main/java/org/truffleruby/core/range/RangeNodes.java index dae36c6d50da..f7bfe08e4186 100644 --- a/src/main/java/org/truffleruby/core/range/RangeNodes.java +++ b/src/main/java/org/truffleruby/core/range/RangeNodes.java @@ -425,13 +425,19 @@ protected RubyClass getRangeClass() { @GenerateUncached @GenerateNodeFactory @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - @NodeChild(value = "rubyClass", type = RubyNode.class) + @NodeChild(value = "rubyClassNode", type = RubyNode.class) public abstract static class AllocateNode extends RubySourceNode { public static AllocateNode create() { return RangeNodesFactory.AllocateNodeFactory.create(null); } + public static AllocateNode create(RubyNode rubyClassNode) { + return RangeNodesFactory.AllocateNodeFactory.create(rubyClassNode); + } + + abstract RubyNode getRubyClassNode(); + public abstract RubyObjectRange execute(RubyClass rubyClass); @Specialization @@ -441,6 +447,12 @@ protected RubyObjectRange allocate(RubyClass rubyClass) { AllocationTracing.trace(range, this); return range; } + + @Override + public RubyNode cloneUninitialized() { + return create(getRubyClassNode().cloneUninitialized()); + } + } @CoreMethod(names = "initialize_copy", required = 1, raiseIfFrozenSelf = true) diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java index f3f2e718613b..e83ee2ad9dec 100644 --- a/src/main/java/org/truffleruby/core/string/StringNodes.java +++ b/src/main/java/org/truffleruby/core/string/StringNodes.java @@ -185,15 +185,21 @@ public abstract class StringNodes { @GenerateUncached @GenerateNodeFactory @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - @NodeChild(value = "rubyClass", type = RubyNode.class) + @NodeChild(value = "rubyClassNode", type = RubyNode.class) public abstract static class AllocateNode extends RubySourceNode { public static AllocateNode create() { return StringNodesFactory.AllocateNodeFactory.create(null); } + public static AllocateNode create(RubyNode rubyClassNode) { + return StringNodesFactory.AllocateNodeFactory.create(rubyClassNode); + } + public abstract RubyString execute(RubyClass rubyClass); + abstract RubyNode getRubyClassNode(); + @Specialization protected RubyString allocate(RubyClass rubyClass) { final RubyString string = new RubyString( @@ -206,6 +212,11 @@ protected RubyString allocate(RubyClass rubyClass) { return string; } + @Override + public RubyNode cloneUninitialized() { + return create(getRubyClassNode().cloneUninitialized()); + } + } @CoreMethod(names = "+", required = 1) diff --git a/src/main/java/org/truffleruby/core/support/TypeNodes.java b/src/main/java/org/truffleruby/core/support/TypeNodes.java index d5c916269e12..a151431f83c4 100644 --- a/src/main/java/org/truffleruby/core/support/TypeNodes.java +++ b/src/main/java/org/truffleruby/core/support/TypeNodes.java @@ -385,7 +385,7 @@ protected Object toRubyInteger(Object value) { @GenerateUncached @GenerateNodeFactory @Primitive(name = "check_frozen") - @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "valueNode", type = RubyNode.class) public abstract static class CheckFrozenNode extends RubySourceNode { public static CheckFrozenNode create() { @@ -398,6 +398,8 @@ public static CheckFrozenNode create(RubyNode node) { public abstract void execute(Object object); + abstract RubyNode getValueNode(); + @Specialization(limit = "getRubyLibraryCacheLimit()") protected Object check(Object value, @CachedLibrary("value") RubyLibrary rubyLibrary, @@ -410,6 +412,12 @@ protected Object check(Object value, return value; } + + @Override + public RubyNode cloneUninitialized() { + return create(getValueNode().cloneUninitialized()); + } + } @Primitive(name = "check_mutable_string") diff --git a/src/main/java/org/truffleruby/interop/InteropNodes.java b/src/main/java/org/truffleruby/interop/InteropNodes.java index a46109960332..9886246df2d4 100644 --- a/src/main/java/org/truffleruby/interop/InteropNodes.java +++ b/src/main/java/org/truffleruby/interop/InteropNodes.java @@ -602,16 +602,22 @@ protected Object readArrayElement(Object receiver, long identifier, @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "arguments", type = RubyNode[].class) @CoreMethod(names = "write_array_element", onSingleton = true, required = 3) + @NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract static class WriteArrayElementNode extends RubySourceNode { public static WriteArrayElementNode create() { return InteropNodesFactory.WriteArrayElementNodeFactory.create(null); } + public static WriteArrayElementNode create(RubyNode[] argumentNodes) { + return InteropNodesFactory.WriteArrayElementNodeFactory.create(argumentNodes); + } + abstract Object execute(Object receiver, Object identifier, Object value); + abstract RubyNode[] getArgumentNodes(); + @Specialization(limit = "getInteropCacheLimit()") protected Object write(Object receiver, long identifier, Object value, @CachedLibrary("receiver") InteropLibrary receivers, @@ -624,20 +630,32 @@ protected Object write(Object receiver, long identifier, Object value, return value; } + + @Override + public RubyNode cloneUninitialized() { + return create(cloneUninitialized(getArgumentNodes())); + } + } @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "arguments", type = RubyNode[].class) @CoreMethod(names = "remove_array_element", onSingleton = true, required = 2) + @NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract static class RemoveArrayElementNode extends RubySourceNode { - public static ReadArrayElementNode create() { - return InteropNodesFactory.ReadArrayElementNodeFactory.create(null); + public static RemoveArrayElementNode create() { + return InteropNodesFactory.RemoveArrayElementNodeFactory.create(null); + } + + public static RemoveArrayElementNode create(RubyNode[] argumentNodes) { + return InteropNodesFactory.RemoveArrayElementNodeFactory.create(argumentNodes); } abstract Nil execute(Object receiver, Object identifier); + abstract RubyNode[] getArgumentNodes(); + @Specialization(limit = "getInteropCacheLimit()") protected Nil readArrayElement(Object receiver, long identifier, @CachedLibrary("receiver") InteropLibrary receivers, @@ -650,6 +668,12 @@ protected Nil readArrayElement(Object receiver, long identifier, return Nil.INSTANCE; } + + @Override + public RubyNode cloneUninitialized() { + return create(cloneUninitialized(getArgumentNodes())); + } + } @CoreMethod(names = "array_element_readable?", onSingleton = true, required = 2) @@ -1132,21 +1156,33 @@ protected double as(Object receiver, // region Null @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "arguments", type = RubyNode[].class) @CoreMethod(names = "null?", onSingleton = true, required = 1) + @NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract static class NullNode extends RubySourceNode { public static NullNode create() { return InteropNodesFactory.NullNodeFactory.create(null); } + public static NullNode create(RubyNode[] argumentNodes) { + return InteropNodesFactory.NullNodeFactory.create(argumentNodes); + } + abstract Object execute(Object receiver); + abstract RubyNode[] getArgumentNodes(); + @Specialization(limit = "getInteropCacheLimit()") protected boolean isNull(Object receiver, @CachedLibrary("receiver") InteropLibrary receivers) { return receivers.isNull(receiver); } + + @Override + public RubyNode cloneUninitialized() { + return create(cloneUninitialized(getArgumentNodes())); + } + } // endregion @@ -1226,16 +1262,22 @@ protected Object members(Object receiver, boolean internal, @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "arguments", type = RubyNode[].class) @CoreMethod(names = "read_member", onSingleton = true, required = 2) + @NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract static class ReadMemberNode extends RubySourceNode { public static ReadMemberNode create() { return InteropNodesFactory.ReadMemberNodeFactory.create(null); } + public static ReadMemberNode create(RubyNode[] argumentNodes) { + return InteropNodesFactory.ReadMemberNodeFactory.create(argumentNodes); + } + public abstract Object execute(Object receiver, Object identifier); + abstract RubyNode[] getArgumentNodes(); + @Specialization(limit = "getInteropCacheLimit()") protected Object readMember(Object receiver, Object identifier, @CachedLibrary("receiver") InteropLibrary receivers, @@ -1246,20 +1288,32 @@ protected Object readMember(Object receiver, Object identifier, final Object foreign = InteropNodes.readMember(receivers, receiver, name, translateInteropException); return foreignToRubyNode.executeConvert(foreign); } + + @Override + public RubyNode cloneUninitialized() { + return create(cloneUninitialized(getArgumentNodes())); + } + } @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "arguments", type = RubyNode[].class) @CoreMethod(names = "read_member_without_conversion", onSingleton = true, required = 2) + @NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract static class ReadMemberWithoutConversionNode extends RubySourceNode { - public static ReadMemberNode create() { - return InteropNodesFactory.ReadMemberNodeFactory.create(null); + public static ReadMemberWithoutConversionNode create() { + return InteropNodesFactory.ReadMemberWithoutConversionNodeFactory.create(null); + } + + public static ReadMemberWithoutConversionNode create(RubyNode[] argumentNodes) { + return InteropNodesFactory.ReadMemberWithoutConversionNodeFactory.create(argumentNodes); } abstract Object execute(Object receiver, Object identifier); + abstract RubyNode[] getArgumentNodes(); + @Specialization(limit = "getInteropCacheLimit()") protected Object readMember(Object receiver, Object identifier, @CachedLibrary("receiver") InteropLibrary receivers, @@ -1268,20 +1322,32 @@ protected Object readMember(Object receiver, Object identifier, final String name = toJavaStringNode.executeToJavaString(identifier); return InteropNodes.readMember(receivers, receiver, name, translateInteropException); } + + @Override + public RubyNode cloneUninitialized() { + return create(cloneUninitialized(getArgumentNodes())); + } + } @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "arguments", type = RubyNode[].class) @CoreMethod(names = "write_member", onSingleton = true, required = 3) + @NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract static class WriteMemberNode extends RubySourceNode { public static WriteMemberNode create() { return InteropNodesFactory.WriteMemberNodeFactory.create(null); } + public static WriteMemberNode create(RubyNode[] argumentNodes) { + return InteropNodesFactory.WriteMemberNodeFactory.create(argumentNodes); + } + public abstract Object execute(Object receiver, Object identifier, Object value); + abstract RubyNode[] getArgumentNodes(); + @Specialization(limit = "getInteropCacheLimit()") protected Object write(Object receiver, Object identifier, Object value, @CachedLibrary("receiver") InteropLibrary receivers, @@ -1296,20 +1362,32 @@ protected Object write(Object receiver, Object identifier, Object value, return value; } + + @Override + public RubyNode cloneUninitialized() { + return create(cloneUninitialized(getArgumentNodes())); + } + } @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "arguments", type = RubyNode[].class) @CoreMethod(names = "write_member_without_conversion", onSingleton = true, required = 3) + @NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract static class WriteMemberWithoutConversionNode extends RubySourceNode { public static WriteMemberWithoutConversionNode create() { return InteropNodesFactory.WriteMemberWithoutConversionNodeFactory.create(null); } + public static WriteMemberWithoutConversionNode create(RubyNode[] argumentNodes) { + return InteropNodesFactory.WriteMemberWithoutConversionNodeFactory.create(argumentNodes); + } + public abstract Object execute(Object receiver, Object identifier, Object value); + abstract RubyNode[] getArgumentNodes(); + @Specialization(limit = "getInteropCacheLimit()") protected Object write(Object receiver, Object identifier, Object value, @CachedLibrary("receiver") InteropLibrary receivers, @@ -1324,6 +1402,12 @@ protected Object write(Object receiver, Object identifier, Object value, return value; } + + @Override + public RubyNode cloneUninitialized() { + return create(cloneUninitialized(getArgumentNodes())); + } + } @CoreMethod(names = "remove_member", onSingleton = true, required = 2) @@ -1347,16 +1431,22 @@ protected Nil remove(Object receiver, Object identifier, @GenerateUncached @GenerateNodeFactory - @NodeChild(value = "arguments", type = RubyNode[].class) @CoreMethod(names = "invoke_member", onSingleton = true, required = 2, rest = true) + @NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract static class InvokeMemberNode extends RubySourceNode { public static InvokeMemberNode create() { return InteropNodesFactory.InvokeMemberNodeFactory.create(null); } + public static InvokeMemberNode create(RubyNode[] argumentNodes) { + return InteropNodesFactory.InvokeMemberNodeFactory.create(argumentNodes); + } + public abstract Object execute(Object receiver, Object identifier, Object[] args); + abstract RubyNode[] getArgumentNodes(); + @Specialization(limit = "getInteropCacheLimit()") protected Object invokeCached(Object receiver, Object identifier, Object[] args, @Cached ToJavaStringNode toJavaStringNode, @@ -1367,6 +1457,12 @@ protected Object invokeCached(Object receiver, Object identifier, Object[] args, final Object foreign = invoke(receivers, receiver, name, args, translateInteropException); return foreignToRubyNode.executeConvert(foreign); } + + @Override + public RubyNode cloneUninitialized() { + return create(cloneUninitialized(getArgumentNodes())); + } + } @CoreMethod(names = "member_readable?", onSingleton = true, required = 2) From 44a966affa431cefaf7058a11e2edbeae5b484d7 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Thu, 8 Sep 2022 17:40:36 +0300 Subject: [PATCH 04/46] Implement cloneUninitialized() using node -Gen classes --- .../core/array/ArrayAppendOneNode.java | 14 +++++++++- .../core/array/ArrayDropTailNode.java | 13 +++++++++- .../core/array/ArrayGetTailNode.java | 13 +++++++++- .../core/array/ArrayIndexNodes.java | 14 +++++++++- .../core/array/ArraySliceNode.java | 13 +++++++++- .../truffleruby/core/cast/HashCastNode.java | 17 +++++++++--- .../truffleruby/core/cast/SplatCastNode.java | 26 +++++++++++++++---- .../core/cast/StringToSymbolNode.java | 11 +++++++- .../org/truffleruby/core/cast/ToProcNode.java | 11 +++++++- .../inlined/BinaryInlinedOperationNode.java | 12 ++++----- .../core/inlined/InlinedAddNode.java | 13 ++++++++++ .../core/inlined/InlinedAtNode.java | 12 +++++++++ .../core/inlined/InlinedBitAndNode.java | 11 ++++++++ .../core/inlined/InlinedBitOrNode.java | 12 +++++++++ .../core/inlined/InlinedByteSizeNode.java | 11 ++++++++ .../core/inlined/InlinedCaseEqualNode.java | 12 +++++++++ .../core/inlined/InlinedDivNode.java | 12 +++++++++ .../core/inlined/InlinedEqualNode.java | 12 +++++++++ .../inlined/InlinedGreaterOrEqualNode.java | 12 +++++++++ .../core/inlined/InlinedGreaterThanNode.java | 12 +++++++++ .../core/inlined/InlinedIndexGetNode.java | 12 +++++++++ .../core/inlined/InlinedIndexSetNode.java | 18 +++++++++++-- .../core/inlined/InlinedIsANode.java | 12 +++++++++ .../core/inlined/InlinedIsNilNode.java | 11 ++++++++ .../core/inlined/InlinedKindOfNode.java | 12 +++++++++ .../core/inlined/InlinedLambdaNode.java | 16 ++++++++++-- .../core/inlined/InlinedLeftShiftNode.java | 12 +++++++++ .../core/inlined/InlinedLessOrEqualNode.java | 11 ++++++++ .../core/inlined/InlinedLessThanNode.java | 12 +++++++++ .../core/inlined/InlinedModNode.java | 12 +++++++++ .../core/inlined/InlinedMulNode.java | 12 +++++++++ .../core/inlined/InlinedNegNode.java | 11 ++++++++ .../core/inlined/InlinedNotNode.java | 11 ++++++++ .../core/inlined/InlinedReplaceableNode.java | 2 +- .../core/inlined/InlinedRightShiftNode.java | 12 +++++++++ .../core/inlined/InlinedSubNode.java | 13 ++++++++++ .../inlined/TernaryInlinedOperationNode.java | 10 +++---- .../inlined/UnaryInlinedOperationNode.java | 6 ++--- .../core/numeric/FixnumLowerNode.java | 16 +++++++++--- .../java/org/truffleruby/debug/ChaosNode.java | 16 +++++++++--- .../interop/SymbolToByteOrderNode.java | 11 +++++++- .../truffleruby/interop/ToJavaStringNode.java | 10 ++++++- .../interop/ToJavaStringWithDefaultNode.java | 13 +++++++++- .../arguments/ProfileArgumentNode.java | 13 +++++++--- .../globals/ReadGlobalVariableNode.java | 8 ++++++ .../globals/WriteGlobalVariableNode.java | 10 +++++++ .../language/objects/DefineModuleNode.java | 12 ++++++++- .../language/objects/SingletonClassNode.java | 8 +++++- 48 files changed, 537 insertions(+), 48 deletions(-) diff --git a/src/main/java/org/truffleruby/core/array/ArrayAppendOneNode.java b/src/main/java/org/truffleruby/core/array/ArrayAppendOneNode.java index 48138e450a5f..fd9765bc30f7 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayAppendOneNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayAppendOneNode.java @@ -24,7 +24,7 @@ import com.oracle.truffle.api.library.CachedLibrary; import com.oracle.truffle.api.profiles.ConditionProfile; -@NodeChild(value = "array", type = RubyNode.class) +@NodeChild(value = "arrayNode", type = RubyNode.class) @NodeChild(value = "valueNode", type = RubyNode.class) @ImportStatic(ArrayGuards.class) public abstract class ArrayAppendOneNode extends RubyContextSourceNode { @@ -35,6 +35,8 @@ public static ArrayAppendOneNode create() { public abstract RubyArray executeAppendOne(RubyArray array, Object value); + public abstract RubyNode getArrayNode(); + public abstract RubyNode getValueNode(); // Append of the correct type @@ -83,4 +85,14 @@ protected RubyArray appendOneGeneralizeNonMutable(RubyArray array, Object value, setStoreAndSize(array, newStore, newSize); return array; } + + @Override + public RubyNode cloneUninitialized() { + var copy = ArrayAppendOneNodeGen.create( + getArrayNode().cloneUninitialized(), + getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/array/ArrayDropTailNode.java b/src/main/java/org/truffleruby/core/array/ArrayDropTailNode.java index 95875280c23d..7a5d829581a8 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayDropTailNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayDropTailNode.java @@ -18,7 +18,7 @@ import com.oracle.truffle.api.dsl.Specialization; import com.oracle.truffle.api.profiles.ConditionProfile; -@NodeChild(value = "array", type = RubyNode.class) +@NodeChild(value = "arrayNode", type = RubyNode.class) @ImportStatic(ArrayGuards.class) public abstract class ArrayDropTailNode extends RubyContextSourceNode { @@ -28,6 +28,8 @@ public ArrayDropTailNode(int index) { this.index = index; } + public abstract RubyNode getArrayNode(); + @Specialization protected RubyArray dropTail(RubyArray array, @Cached ArrayCopyOnWriteNode cowNode, @@ -42,4 +44,13 @@ protected RubyArray dropTail(RubyArray array, } } + @Override + public RubyNode cloneUninitialized() { + var copy = ArrayDropTailNodeGen.create( + index, + getArrayNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/array/ArrayGetTailNode.java b/src/main/java/org/truffleruby/core/array/ArrayGetTailNode.java index 1bb7f90a6acd..6a008a465e4d 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayGetTailNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayGetTailNode.java @@ -18,7 +18,7 @@ import com.oracle.truffle.api.dsl.Specialization; import com.oracle.truffle.api.profiles.ConditionProfile; -@NodeChild(value = "array", type = RubyNode.class) +@NodeChild(value = "arrayNode", type = RubyNode.class) @ImportStatic(ArrayGuards.class) public abstract class ArrayGetTailNode extends RubyContextSourceNode { @@ -28,6 +28,8 @@ public ArrayGetTailNode(int index) { this.index = index; } + public abstract RubyNode getArrayNode(); + @Specialization protected RubyArray getTail(RubyArray array, @Cached ArrayCopyOnWriteNode cowNode, @@ -41,4 +43,13 @@ protected RubyArray getTail(RubyArray array, } } + @Override + public RubyNode cloneUninitialized() { + var copy = ArrayGetTailNodeGen.create( + index, + getArrayNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/array/ArrayIndexNodes.java b/src/main/java/org/truffleruby/core/array/ArrayIndexNodes.java index fa572a923560..82e65a7663e4 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayIndexNodes.java +++ b/src/main/java/org/truffleruby/core/array/ArrayIndexNodes.java @@ -27,7 +27,7 @@ @CoreModule(value = "Truffle::ArrayIndex", isClass = false) public abstract class ArrayIndexNodes { - @NodeChild(value = "array", type = RubyNode.class) + @NodeChild(value = "arrayNode", type = RubyNode.class) @ImportStatic(ArrayGuards.class) @ReportPolymorphism public abstract static class ReadConstantIndexNode extends RubyContextSourceNode { @@ -42,6 +42,8 @@ protected ReadConstantIndexNode(int index) { this.index = index; } + public abstract RubyNode getArrayNode(); + @Specialization(limit = "storageStrategyLimit()") protected Object readInBounds(RubyArray array, @Bind("array.getStore()") Object store, @@ -55,6 +57,16 @@ protected Object readInBounds(RubyArray array, return nil; } } + + @Override + public RubyNode cloneUninitialized() { + var copy = ReadConstantIndexNode.create( + getArrayNode().cloneUninitialized(), + index); + copy.copyFlags(this); + return copy; + } + } @ImportStatic(ArrayGuards.class) diff --git a/src/main/java/org/truffleruby/core/array/ArraySliceNode.java b/src/main/java/org/truffleruby/core/array/ArraySliceNode.java index daae662be784..c2e165a4b8ca 100644 --- a/src/main/java/org/truffleruby/core/array/ArraySliceNode.java +++ b/src/main/java/org/truffleruby/core/array/ArraySliceNode.java @@ -18,7 +18,7 @@ import com.oracle.truffle.api.dsl.Specialization; import com.oracle.truffle.api.profiles.ConditionProfile; -@NodeChild(value = "array", type = RubyNode.class) +@NodeChild(value = "arrayNode", type = RubyNode.class) @ImportStatic(ArrayGuards.class) public abstract class ArraySliceNode extends RubyContextSourceNode { @@ -34,6 +34,8 @@ public ArraySliceNode(int from, int to) { public abstract RubyArray execute(RubyArray array); + public abstract RubyNode getArrayNode(); + @Specialization protected RubyArray readSlice(RubyArray array, @Cached ArrayCopyOnWriteNode cowNode, @@ -46,7 +48,16 @@ protected RubyArray readSlice(RubyArray array, final Object slice = cowNode.execute(array, from, length); return createArray(slice, length); } + } + @Override + public RubyNode cloneUninitialized() { + var copy = ArraySliceNodeGen.create( + from, + to, + getArrayNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; } } diff --git a/src/main/java/org/truffleruby/core/cast/HashCastNode.java b/src/main/java/org/truffleruby/core/cast/HashCastNode.java index f74f80d165eb..0a26ba66132e 100644 --- a/src/main/java/org/truffleruby/core/cast/HashCastNode.java +++ b/src/main/java/org/truffleruby/core/cast/HashCastNode.java @@ -22,17 +22,21 @@ import com.oracle.truffle.api.profiles.BranchProfile; /** Must be a RubyNode because it's used for ** in the translator. */ -@NodeChild(value = "child", type = RubyNode.class) +@NodeChild(value = "childNode", type = RubyNode.class) public abstract class HashCastNode extends RubyContextSourceNode { public static HashCastNode create() { return HashCastNodeGen.create(null); } - protected abstract RubyNode getChild(); + public static HashCastNode create(RubyNode child) { + return HashCastNodeGen.create(child); + } public abstract RubyHash execute(Object value); + protected abstract RubyNode getChildNode(); + @Specialization protected RubyHash castHash(RubyHash hash) { return hash; @@ -63,7 +67,14 @@ protected RubyHash cast(Object object, @Override public void doExecuteVoid(VirtualFrame frame) { - getChild().doExecuteVoid(frame); + getChildNode().doExecuteVoid(frame); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create(getChildNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; } } diff --git a/src/main/java/org/truffleruby/core/cast/SplatCastNode.java b/src/main/java/org/truffleruby/core/cast/SplatCastNode.java index 49fe5355f82b..745bbc3766bb 100644 --- a/src/main/java/org/truffleruby/core/cast/SplatCastNode.java +++ b/src/main/java/org/truffleruby/core/cast/SplatCastNode.java @@ -29,7 +29,7 @@ /** Splat as used to cast a value to an array if it isn't already, as in {@code *value}. Must be a RubyNode because it's * used in the translator. */ -@NodeChild(value = "child", type = RubyNode.class) +@NodeChild(value = "childNode", type = RubyNode.class) public abstract class SplatCastNode extends RubyContextSourceNode { public enum NilBehavior { @@ -52,14 +52,19 @@ public SplatCastNode(RubyLanguage language, NilBehavior nilBehavior, boolean use conversionMethod = useToAry ? language.coreSymbols.TO_ARY : language.coreSymbols.TO_A; } - public void doNotCopy() { - copy = false; + public SplatCastNode(NilBehavior nilBehavior, RubySymbol conversionMethod) { + this.nilBehavior = nilBehavior; + this.conversionMethod = conversionMethod; } - public abstract RubyNode getChild(); - public abstract Object execute(Object value); + public abstract RubyNode getChildNode(); + + public void doNotCopy() { + copy = false; + } + @Specialization protected Object splatNil(Nil nil) { switch (nilBehavior) { @@ -127,4 +132,15 @@ private RubyArray executeDup(RubyArray array) { return dup.executeDup(array); } + @Override + public RubyNode cloneUninitialized() { + var childCopy = (getChildNode() == null) ? null : getChildNode().cloneUninitialized(); + var copy = SplatCastNodeGen.create( + nilBehavior, + conversionMethod, + childCopy); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/cast/StringToSymbolNode.java b/src/main/java/org/truffleruby/core/cast/StringToSymbolNode.java index b060923a08b9..82380304d510 100644 --- a/src/main/java/org/truffleruby/core/cast/StringToSymbolNode.java +++ b/src/main/java/org/truffleruby/core/cast/StringToSymbolNode.java @@ -19,13 +19,22 @@ import org.truffleruby.language.library.RubyStringLibrary; /** Creates a symbol from a string. Must be a RubyNode because it's used in the translator. */ -@NodeChild(value = "string", type = RubyNode.class) +@NodeChild(value = "stringNode", type = RubyNode.class) public abstract class StringToSymbolNode extends RubyContextSourceNode { + abstract RubyNode getStringNode(); + @Specialization protected RubySymbol doString(Object string, @Cached RubyStringLibrary libString) { return getSymbol(libString.getTString(string), libString.getEncoding(string)); } + @Override + public RubyNode cloneUninitialized() { + var copy = StringToSymbolNodeGen.create(getStringNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/cast/ToProcNode.java b/src/main/java/org/truffleruby/core/cast/ToProcNode.java index 93d66c5298ab..7c98c6c893f1 100644 --- a/src/main/java/org/truffleruby/core/cast/ToProcNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToProcNode.java @@ -35,10 +35,12 @@ /** The `&` in `foo(&block)`. Converts the passed block to a RubyProc or nil. Must be a RubyNode because it's used in * the translator. */ -@NodeChild(value = "child", type = RubyNode.class) +@NodeChild(value = "childNode", type = RubyNode.class) @ImportStatic(DeclarationContext.class) public abstract class ToProcNode extends RubyContextSourceNode { + abstract RubyNode getChildNode(); + @Specialization protected Nil doNil(Nil nil) { return nil; @@ -115,4 +117,11 @@ protected static Map getRefinements(VirtualFrame frame return RubyArguments.getDeclarationContext(frame).getRefinements(); } + @Override + public RubyNode cloneUninitialized() { + var copy = ToProcNodeGen.create(getChildNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/BinaryInlinedOperationNode.java b/src/main/java/org/truffleruby/core/inlined/BinaryInlinedOperationNode.java index 4bb39553886c..2504627978e7 100644 --- a/src/main/java/org/truffleruby/core/inlined/BinaryInlinedOperationNode.java +++ b/src/main/java/org/truffleruby/core/inlined/BinaryInlinedOperationNode.java @@ -16,8 +16,8 @@ import com.oracle.truffle.api.Assumption; import com.oracle.truffle.api.dsl.NodeChild; -@NodeChild(value = "left", type = RubyNode.class) -@NodeChild(value = "right", type = RubyNode.class) +@NodeChild(value = "leftNode", type = RubyNode.class) +@NodeChild(value = "rightNode", type = RubyNode.class) public abstract class BinaryInlinedOperationNode extends InlinedOperationNode { public BinaryInlinedOperationNode( @@ -27,18 +27,18 @@ public BinaryInlinedOperationNode( super(language, callNodeParameters, assumptions); } - protected abstract RubyNode getLeft(); + protected abstract RubyNode getLeftNode(); - protected abstract RubyNode getRight(); + protected abstract RubyNode getRightNode(); @Override protected RubyNode getReceiverNode() { - return getLeft(); + return getLeftNode(); } @Override protected RubyNode[] getArgumentNodes() { - return new RubyNode[]{ getRight() }; + return new RubyNode[]{ getRightNode() }; } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedAddNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedAddNode.java index 56750e536f31..378c41276b40 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedAddNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedAddNode.java @@ -12,6 +12,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.numeric.BigIntegerOps; import org.truffleruby.core.numeric.FixnumOrBignumNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Cached; @@ -70,4 +71,16 @@ protected double doubleLong(double a, long b) { protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedAddNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedAtNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedAtNode.java index c3992b38b248..c36de09cda70 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedAtNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedAtNode.java @@ -12,6 +12,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.array.ArrayIndexNodes; import org.truffleruby.core.array.RubyArray; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import org.truffleruby.language.methods.LookupMethodOnSelfNode; @@ -47,4 +48,15 @@ protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedAtNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedBitAndNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedBitAndNode.java index 23f3b8bb7d40..836cc8256890 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedBitAndNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedBitAndNode.java @@ -13,6 +13,7 @@ import org.truffleruby.core.numeric.IntegerNodes.BitAndNode; import org.truffleruby.core.numeric.IntegerNodesFactory.BitAndNodeFactory; import org.truffleruby.language.NoImplicitCastsToLong; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.CompilerDirectives; @@ -65,4 +66,14 @@ private BitAndNode getBitAndNode() { return fixnumBitAnd; } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedBitAndNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedBitOrNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedBitOrNode.java index 7531ceea0ccb..b84f55fe5bcd 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedBitOrNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedBitOrNode.java @@ -12,6 +12,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.numeric.IntegerNodes.BitOrNode; import org.truffleruby.core.numeric.IntegerNodesFactory.BitOrNodeFactory; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.CompilerDirectives; @@ -52,4 +53,15 @@ private BitOrNode getBitOrNode() { return fixnumBitOr; } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedBitOrNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedByteSizeNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedByteSizeNode.java index a8a440b8f0ca..3340a50fd6d5 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedByteSizeNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedByteSizeNode.java @@ -12,6 +12,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.string.RubyString; import org.truffleruby.core.string.ImmutableRubyString; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Cached; @@ -53,4 +54,14 @@ protected Object fallback(VirtualFrame frame, Object self) { return rewriteAndCall(frame, self); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedByteSizeNodeGen.create( + getLanguage(), + this.parameters, + getSelfNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedCaseEqualNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedCaseEqualNode.java index fdb6867d94b0..605b5e62be80 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedCaseEqualNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedCaseEqualNode.java @@ -13,6 +13,7 @@ import com.oracle.truffle.api.dsl.Cached; import org.truffleruby.RubyLanguage; import org.truffleruby.core.module.RubyModule; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Specialization; @@ -58,4 +59,15 @@ protected Object fallback(VirtualFrame frame, Object self, Object b) { return rewriteAndCall(frame, self, b); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedCaseEqualNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedDivNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedDivNode.java index 731242413f10..f807129a0134 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedDivNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedDivNode.java @@ -10,6 +10,7 @@ package org.truffleruby.core.inlined; import org.truffleruby.RubyLanguage; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Specialization; @@ -58,4 +59,15 @@ protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedDivNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedEqualNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedEqualNode.java index 99329946fd94..85ef530acd28 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedEqualNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedEqualNode.java @@ -14,6 +14,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.encoding.EncodingNodes; import org.truffleruby.core.string.StringHelperNodes; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Specialization; @@ -85,4 +86,15 @@ protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedEqualNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedGreaterOrEqualNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedGreaterOrEqualNode.java index 0cd38f4f1452..2b7524846416 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedGreaterOrEqualNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedGreaterOrEqualNode.java @@ -10,6 +10,7 @@ package org.truffleruby.core.inlined; import org.truffleruby.RubyLanguage; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Specialization; @@ -55,4 +56,15 @@ protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedGreaterOrEqualNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedGreaterThanNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedGreaterThanNode.java index dfd7e4b6abb0..333128febea0 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedGreaterThanNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedGreaterThanNode.java @@ -10,6 +10,7 @@ package org.truffleruby.core.inlined; import org.truffleruby.RubyLanguage; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Specialization; @@ -55,4 +56,15 @@ protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedGreaterThanNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedIndexGetNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedIndexGetNode.java index a4a7db20fef0..88b5989a4eee 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedIndexGetNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedIndexGetNode.java @@ -13,6 +13,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.array.ArrayIndexNodes; import org.truffleruby.core.array.RubyArray; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import org.truffleruby.language.methods.LookupMethodOnSelfNode; @@ -47,4 +48,15 @@ protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedIndexGetNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java index 6e4c2ffb40d3..73f9273a5c89 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java @@ -14,6 +14,7 @@ import org.truffleruby.core.array.ArrayWriteNormalizedNode; import org.truffleruby.core.array.AssignableNode; import org.truffleruby.core.array.RubyArray; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import org.truffleruby.language.literal.NilLiteralNode; import org.truffleruby.language.methods.LookupMethodOnSelfNode; @@ -62,13 +63,26 @@ protected int normalize(RubyArray array, int index, ConditionProfile denormalize @Override public void assign(VirtualFrame frame, Object value) { final Object receiver = getReceiver().execute(frame); - final Object index = getOperand1().execute(frame); + final Object index = getOperand1Node().execute(frame); execute(frame, receiver, index, value); } @Override public AssignableNode toAssignableNode() { - assert getOperand2() instanceof NilLiteralNode && ((NilLiteralNode) getOperand2()).isImplicit() : getOperand2(); + assert getOperand2Node() instanceof NilLiteralNode && ((NilLiteralNode) getOperand2Node()).isImplicit() + : getOperand2Node(); return this; } + + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedIndexSetNodeGen.create( + getLanguage(), + this.parameters, + getReceiver().cloneUninitialized(), + getOperand1Node().cloneUninitialized(), + getOperand2Node().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedIsANode.java b/src/main/java/org/truffleruby/core/inlined/InlinedIsANode.java index e73c7790b53d..e3490aaa849c 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedIsANode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedIsANode.java @@ -12,6 +12,7 @@ import com.oracle.truffle.api.dsl.Cached; import org.truffleruby.RubyLanguage; import org.truffleruby.core.module.RubyModule; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Specialization; @@ -42,4 +43,15 @@ protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedIsANodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedIsNilNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedIsNilNode.java index a089f66663dd..b3b58cfa026c 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedIsNilNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedIsNilNode.java @@ -12,6 +12,7 @@ import com.oracle.truffle.api.dsl.Cached; import org.truffleruby.RubyLanguage; import org.truffleruby.language.Nil; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Specialization; @@ -48,4 +49,14 @@ protected Object fallback(VirtualFrame frame, Object self) { return rewriteAndCall(frame, self); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedIsNilNodeGen.create( + getLanguage(), + this.parameters, + getSelfNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedKindOfNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedKindOfNode.java index 2c251cb8f4a2..3f3a137d5a35 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedKindOfNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedKindOfNode.java @@ -11,6 +11,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.module.RubyModule; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Cached; @@ -42,4 +43,15 @@ protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedKindOfNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedLambdaNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedLambdaNode.java index 5046835b8b71..86a59ed667b6 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedLambdaNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedLambdaNode.java @@ -31,6 +31,8 @@ public InlinedLambdaNode(RubyLanguage language, RubyCallNodeParameters callNodeP super(language, callNodeParameters); } + protected abstract RubyNode getBlock(); + @Specialization( guards = { "lookupNode.lookupIgnoringVisibility(frame, self, METHOD) == coreMethods().LAMBDA", }, assumptions = "assumptions", @@ -53,10 +55,20 @@ protected Object fallback(VirtualFrame frame, Object self, RubyProc block) { return rewriteAndCallWithBlock(frame, self, block); } - protected abstract RubyNode getBlock(); - @Override protected RubyNode getBlockNode() { return getBlock(); } + + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedLambdaNodeGen.create( + getLanguage(), + this.parameters, + getSelfNode().cloneUninitialized(), + getBlock().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedLeftShiftNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedLeftShiftNode.java index 9a828e8910ed..e5aef1ed41a1 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedLeftShiftNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedLeftShiftNode.java @@ -12,6 +12,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.numeric.IntegerNodes.LeftShiftNode; import org.truffleruby.core.numeric.IntegerNodesFactory.LeftShiftNodeFactory; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.CompilerDirectives; @@ -52,4 +53,15 @@ private LeftShiftNode getLeftShiftNode() { return fixnumLeftShift; } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedLeftShiftNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedLessOrEqualNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedLessOrEqualNode.java index 6209739c0bd6..6f5cbc8dd1b9 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedLessOrEqualNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedLessOrEqualNode.java @@ -10,6 +10,7 @@ package org.truffleruby.core.inlined; import org.truffleruby.RubyLanguage; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Specialization; @@ -55,4 +56,14 @@ protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + public RubyNode cloneUninitialized() { + var copy = InlinedLessOrEqualNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedLessThanNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedLessThanNode.java index 5a6529bc0f2a..1ad6f90e0ce6 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedLessThanNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedLessThanNode.java @@ -10,6 +10,7 @@ package org.truffleruby.core.inlined; import org.truffleruby.RubyLanguage; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Specialization; @@ -55,4 +56,15 @@ protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedLessThanNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedModNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedModNode.java index 173aa285c1f8..c7d34ba4496b 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedModNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedModNode.java @@ -13,6 +13,7 @@ import org.truffleruby.core.numeric.FloatNodes; import org.truffleruby.core.numeric.IntegerNodes.ModNode; import org.truffleruby.core.numeric.IntegerNodesFactory.ModNodeFactory; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.CompilerDirectives; @@ -65,4 +66,15 @@ private ModNode getModNode() { return fixnumMod; } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedModNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedMulNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedMulNode.java index 5254f7e34163..62557ab312e7 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedMulNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedMulNode.java @@ -12,6 +12,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.numeric.IntegerNodes.MulNode; import org.truffleruby.core.numeric.IntegerNodesFactory.MulNodeFactory; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.CompilerDirectives; @@ -68,4 +69,15 @@ private MulNode getMulNode() { return fixnumMul; } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedMulNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedNegNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedNegNode.java index 832acd1330b8..8d4d883e9d6c 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedNegNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedNegNode.java @@ -12,6 +12,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.numeric.IntegerNodes.NegNode; import org.truffleruby.core.numeric.IntegerNodesFactory.NegNodeFactory; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.CompilerDirectives; @@ -58,4 +59,14 @@ private NegNode getNegNode() { return fixnumNeg; } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedNegNodeGen.create( + getLanguage(), + this.parameters, + getSelfNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedNotNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedNotNode.java index b327a40177bb..919c6fccf94e 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedNotNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedNotNode.java @@ -11,6 +11,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.cast.BooleanCastNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Cached; @@ -41,4 +42,14 @@ protected Object fallback(VirtualFrame frame, Object self) { return rewriteAndCall(frame, self); } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedNotNodeGen.create( + getLanguage(), + this.parameters, + getSelfNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java index 20eb009aa698..701190e25f53 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java @@ -25,7 +25,7 @@ public abstract class InlinedReplaceableNode extends RubyContextSourceNode { - private final RubyCallNodeParameters parameters; + protected final RubyCallNodeParameters parameters; @CompilationFinal(dimensions = 1) protected final Assumption[] assumptions; diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedRightShiftNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedRightShiftNode.java index 808917b9ae4b..dab26b9f7a88 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedRightShiftNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedRightShiftNode.java @@ -12,6 +12,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.numeric.IntegerNodes.RightShiftNode; import org.truffleruby.core.numeric.IntegerNodesFactory.RightShiftNodeFactory; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.CompilerDirectives; @@ -52,4 +53,15 @@ private RightShiftNode getRightShiftNode() { return fixnumRightShift; } + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedRightShiftNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedSubNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedSubNode.java index 7d5652d0e332..c964671ef913 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedSubNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedSubNode.java @@ -13,6 +13,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.numeric.BigIntegerOps; import org.truffleruby.core.numeric.FixnumOrBignumNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import com.oracle.truffle.api.dsl.Specialization; @@ -70,4 +71,16 @@ protected double doubleLong(double a, long b) { protected Object fallback(VirtualFrame frame, Object a, Object b) { return rewriteAndCall(frame, a, b); } + + @Override + public RubyNode cloneUninitialized() { + var copy = InlinedSubNodeGen.create( + getLanguage(), + this.parameters, + getLeftNode().cloneUninitialized(), + getRightNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/TernaryInlinedOperationNode.java b/src/main/java/org/truffleruby/core/inlined/TernaryInlinedOperationNode.java index 9c5d15d899a9..225fabbb528a 100644 --- a/src/main/java/org/truffleruby/core/inlined/TernaryInlinedOperationNode.java +++ b/src/main/java/org/truffleruby/core/inlined/TernaryInlinedOperationNode.java @@ -17,8 +17,8 @@ import com.oracle.truffle.api.dsl.NodeChild; @NodeChild(value = "receiver", type = RubyNode.class) -@NodeChild(value = "operand1", type = RubyNode.class) -@NodeChild(value = "operand2", type = RubyNode.class) +@NodeChild(value = "operand1Node", type = RubyNode.class) +@NodeChild(value = "operand2Node", type = RubyNode.class) public abstract class TernaryInlinedOperationNode extends InlinedOperationNode { public TernaryInlinedOperationNode( @@ -30,9 +30,9 @@ public TernaryInlinedOperationNode( protected abstract RubyNode getReceiver(); - protected abstract RubyNode getOperand1(); + protected abstract RubyNode getOperand1Node(); - protected abstract RubyNode getOperand2(); + protected abstract RubyNode getOperand2Node(); @Override protected RubyNode getReceiverNode() { @@ -41,7 +41,7 @@ protected RubyNode getReceiverNode() { @Override protected RubyNode[] getArgumentNodes() { - return new RubyNode[]{ getOperand1(), getOperand2() }; + return new RubyNode[]{ getOperand1Node(), getOperand2Node() }; } } diff --git a/src/main/java/org/truffleruby/core/inlined/UnaryInlinedOperationNode.java b/src/main/java/org/truffleruby/core/inlined/UnaryInlinedOperationNode.java index 7ba10009291e..51728a1b6492 100644 --- a/src/main/java/org/truffleruby/core/inlined/UnaryInlinedOperationNode.java +++ b/src/main/java/org/truffleruby/core/inlined/UnaryInlinedOperationNode.java @@ -16,7 +16,7 @@ import com.oracle.truffle.api.Assumption; import com.oracle.truffle.api.dsl.NodeChild; -@NodeChild(value = "self", type = RubyNode.class) +@NodeChild(value = "selfNode", type = RubyNode.class) public abstract class UnaryInlinedOperationNode extends InlinedOperationNode { public UnaryInlinedOperationNode( @@ -26,11 +26,11 @@ public UnaryInlinedOperationNode( super(language, callNodeParameters, assumptions); } - protected abstract RubyNode getSelf(); + protected abstract RubyNode getSelfNode(); @Override protected RubyNode getReceiverNode() { - return getSelf(); + return getSelfNode(); } @Override diff --git a/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java b/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java index afa66d4f0fe6..f77f4ba33351 100644 --- a/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java +++ b/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java @@ -14,6 +14,7 @@ import com.oracle.truffle.api.dsl.NodeChild; import com.oracle.truffle.api.dsl.Specialization; +import org.truffleruby.language.RubyNode; /** Passes through {@code int} values unmodified, but will convert a {@code long} value to an {@code int}, if it fits * within the range of an {@code int}. Leaves all other values unmodified. Used where a specialization only accepts @@ -22,19 +23,21 @@ * *

* See {@link org.truffleruby.core.cast.ToIntNode} for a comparison of different integer conversion nodes. */ -@NodeChild(value = "value", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "valueNode", type = RubyBaseNodeWithExecute.class) public abstract class FixnumLowerNode extends RubyContextSourceNode { public static FixnumLowerNode create() { return FixnumLowerNodeGen.create(null); } - public static FixnumLowerNode create(RubyBaseNodeWithExecute child) { - return FixnumLowerNodeGen.create(child); + public static FixnumLowerNode create(RubyBaseNodeWithExecute value) { + return FixnumLowerNodeGen.create(value); } public abstract Object executeLower(Object value); + abstract RubyBaseNodeWithExecute getValueNode(); + @Specialization protected int lower(int value) { return value; @@ -54,5 +57,12 @@ protected long lowerFails(long value) { protected Object passThrough(Object value) { return value; } + + public RubyNode cloneUninitialized() { + var copy = create(getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/debug/ChaosNode.java b/src/main/java/org/truffleruby/debug/ChaosNode.java index a7045d127c24..36782e93f6e1 100644 --- a/src/main/java/org/truffleruby/debug/ChaosNode.java +++ b/src/main/java/org/truffleruby/debug/ChaosNode.java @@ -15,20 +15,23 @@ import com.oracle.truffle.api.dsl.Specialization; import org.truffleruby.language.RubyBaseNodeWithExecute; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import java.util.concurrent.ThreadLocalRandom; -@NodeChild(value = "value", type = RubyBaseNodeWithExecute.class) +@NodeChild(value = "valueNode", type = RubyBaseNodeWithExecute.class) public abstract class ChaosNode extends RubyContextSourceNode { public static ChaosNode create() { return ChaosNodeGen.create(null); } - public static ChaosNode create(RubyBaseNodeWithExecute child) { - return ChaosNodeGen.create(child); + public static ChaosNode create(RubyBaseNodeWithExecute value) { + return ChaosNodeGen.create(value); } + abstract RubyBaseNodeWithExecute getValueNode(); + @Specialization protected Object chaos(int value) { if (randomBoolean()) { @@ -62,5 +65,12 @@ private boolean randomBoolean() { return ThreadLocalRandom.current().nextBoolean(); } + @Override + public RubyNode cloneUninitialized() { + var copy = ChaosNodeGen.create(getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java b/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java index 16094fb3cdd6..11a5e5b6eff0 100644 --- a/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java +++ b/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java @@ -19,13 +19,15 @@ import java.nio.ByteOrder; -@NodeChild(value = "value", type = RubyNode.class) +@NodeChild(value = "valueNode", type = RubyNode.class) public abstract class SymbolToByteOrderNode extends RubyContextSourceNode { public static SymbolToByteOrderNode create(RubyNode value) { return SymbolToByteOrderNodeGen.create(value); } + abstract RubyNode getValueNode(); + @Specialization(guards = "symbol == coreSymbols().BIG") protected ByteOrder symbolToByteOrderBig(RubySymbol symbol) { return ByteOrder.BIG_ENDIAN; @@ -48,4 +50,11 @@ protected ByteOrder invalidByteOrder(Object value) { coreExceptions().argumentError("byte order must be :big, :little, or :native symbol", this)); } + @Override + public RubyNode cloneUninitialized() { + var copy = SymbolToByteOrderNodeGen.create(getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/interop/ToJavaStringNode.java b/src/main/java/org/truffleruby/interop/ToJavaStringNode.java index dbe0b5d55999..aeb51be1bb57 100644 --- a/src/main/java/org/truffleruby/interop/ToJavaStringNode.java +++ b/src/main/java/org/truffleruby/interop/ToJavaStringNode.java @@ -22,7 +22,7 @@ import org.truffleruby.language.control.RaiseException; @GenerateUncached -@NodeChild(value = "value", type = RubyNode.class) +@NodeChild(value = "valueNode", type = RubyNode.class) public abstract class ToJavaStringNode extends RubySourceNode { public static ToJavaStringNode create() { @@ -35,6 +35,8 @@ public static ToJavaStringNode create(RubyNode string) { public abstract String executeToJavaString(Object name); + abstract RubyNode getValueNode(); + @Specialization(guards = "interopLibrary.isString(value)", limit = "getLimit()") protected String interopString(Object value, @CachedLibrary("value") InteropLibrary interopLibrary, @@ -58,4 +60,10 @@ protected String notInteropString(Object value, protected int getLimit() { return getLanguage().options.INTEROP_CONVERT_CACHE; } + + @Override + public RubyNode cloneUninitialized() { + return ToJavaStringNodeGen.create(getValueNode().cloneUninitialized()); + } + } diff --git a/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java b/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java index faff56c812bd..e1c422159096 100644 --- a/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java +++ b/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java @@ -18,7 +18,7 @@ import com.oracle.truffle.api.dsl.Specialization; /** Convert a Ruby String or Symbol to a Java string, or return a default string if a value was not provided. */ -@NodeChild(value = "value", type = RubyNode.class) +@NodeChild(value = "valueNode", type = RubyNode.class) public abstract class ToJavaStringWithDefaultNode extends RubyContextSourceNode { private final String defaultValue; @@ -27,6 +27,8 @@ public ToJavaStringWithDefaultNode(String defaultValue) { this.defaultValue = defaultValue; } + abstract RubyNode getValueNode(); + @Specialization protected String doDefault(NotProvided value) { return defaultValue; @@ -38,4 +40,13 @@ protected String doProvided(Object value, return toJavaStringNode.executeToJavaString(value); } + @Override + public RubyNode cloneUninitialized() { + var copy = ToJavaStringWithDefaultNodeGen.create( + defaultValue, + getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ProfileArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ProfileArgumentNode.java index efb4f6e4b414..2a53deb5c0b6 100644 --- a/src/main/java/org/truffleruby/language/arguments/ProfileArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ProfileArgumentNode.java @@ -28,10 +28,10 @@ @TypeSystemReference(NoImplicitCastsToLong.class) @ImportStatic(CompilerDirectives.class) @NodeInfo(cost = NodeCost.NONE) -@NodeChild(value = "child", type = RubyNode.class) +@NodeChild(value = "childNode", type = RubyNode.class) public abstract class ProfileArgumentNode extends RubyContextSourceNode { - protected abstract RubyNode getChild(); + protected abstract RubyNode getChildNode(); @Specialization(guards = "value == cachedValue", limit = "1") protected boolean cacheBoolean(boolean value, @@ -87,7 +87,14 @@ protected static Class getClassOrObject(Object value) { @Override public String toString() { - return "Profiled(" + getChild() + ")"; + return "Profiled(" + getChildNode() + ")"; + } + + @Override + public RubyNode cloneUninitialized() { + var copy = ProfileArgumentNodeGen.create(getChildNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; } } diff --git a/src/main/java/org/truffleruby/language/globals/ReadGlobalVariableNode.java b/src/main/java/org/truffleruby/language/globals/ReadGlobalVariableNode.java index 8ff4eed56f1f..aff9a832412b 100644 --- a/src/main/java/org/truffleruby/language/globals/ReadGlobalVariableNode.java +++ b/src/main/java/org/truffleruby/language/globals/ReadGlobalVariableNode.java @@ -15,6 +15,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.kernel.TruffleKernelNodes.GetSpecialVariableStorage; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.yield.CallBlockNode; import com.oracle.truffle.api.CompilerDirectives; @@ -75,4 +76,11 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c return definedNode.executeIsDefined(frame); } + @Override + public RubyNode cloneUninitialized() { + var copy = ReadGlobalVariableNodeGen.create(name); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java b/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java index b025cfcac32c..9eefab25f5e6 100644 --- a/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java +++ b/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java @@ -93,4 +93,14 @@ public AssignableNode toAssignableNode() { node.copySourceSection(this); return node; } + + abstract RubyNode getValueNode(); + + @Override + public RubyNode cloneUninitialized() { + var valueNodeCopy = (getValueNode() == null) ? null : getValueNode().cloneUninitialized(); + var copy = WriteGlobalVariableNodeGen.create(name, valueNodeCopy); + copy.copyFlags(this); + return copy; + } } diff --git a/src/main/java/org/truffleruby/language/objects/DefineModuleNode.java b/src/main/java/org/truffleruby/language/objects/DefineModuleNode.java index ebafd9f9855b..fcd856202828 100644 --- a/src/main/java/org/truffleruby/language/objects/DefineModuleNode.java +++ b/src/main/java/org/truffleruby/language/objects/DefineModuleNode.java @@ -23,7 +23,7 @@ import com.oracle.truffle.api.profiles.BranchProfile; import com.oracle.truffle.api.profiles.ConditionProfile; -@NodeChild(value = "lexicalParentModule", type = RubyNode.class) +@NodeChild(value = "lexicalParentModuleNode", type = RubyNode.class) public abstract class DefineModuleNode extends RubyContextSourceNode { private final String name; @@ -76,4 +76,14 @@ private Object lookupForExistingModule(VirtualFrame frame, String name, RubyModu return lookupForExistingModuleNode.lookupForExistingModule(frame, name, lexicalParent); } + abstract RubyNode getLexicalParentModuleNode(); + + @Override + public RubyNode cloneUninitialized() { + var copy = DefineModuleNodeGen.create( + name, + getLexicalParentModuleNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } } diff --git a/src/main/java/org/truffleruby/language/objects/SingletonClassNode.java b/src/main/java/org/truffleruby/language/objects/SingletonClassNode.java index 9b02eaf8a180..17c3ee32708a 100644 --- a/src/main/java/org/truffleruby/language/objects/SingletonClassNode.java +++ b/src/main/java/org/truffleruby/language/objects/SingletonClassNode.java @@ -28,7 +28,7 @@ import com.oracle.truffle.api.dsl.Specialization; @GenerateUncached -@NodeChild(value = "value", type = RubyNode.class) +@NodeChild(value = "valueNode", type = RubyNode.class) public abstract class SingletonClassNode extends RubySourceNode { public static SingletonClassNode getUncached() { @@ -149,4 +149,10 @@ protected int getIdentityCacheContextLimit() { return getLanguage().options.CONTEXT_SPECIFIC_IDENTITY_CACHE; } + abstract RubyNode getValueNode(); + + @Override + public RubyNode cloneUninitialized() { + return SingletonClassNodeGen.create(getValueNode().cloneUninitialized()); + } } From fb5f50fe2277a02678016ba9d22b27d8c49ff20f Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Thu, 25 Aug 2022 17:27:09 +0300 Subject: [PATCH 05/46] Implement cloneUninitialized() using node constructor --- .../builtins/EnumeratorSizeNode.java | 14 +++- .../builtins/ReRaiseInlinedExceptionNode.java | 8 +++ .../ReturnEnumeratorIfNoBlockNode.java | 9 +++ .../java/org/truffleruby/core/IsNilNode.java | 7 ++ .../core/array/ArrayConcatNode.java | 6 ++ .../core/array/ArrayLiteralNode.java | 62 +++++++++++++++-- .../core/array/MultipleAssignmentNode.java | 28 ++++++++ .../binding/SetBindingFrameForEvalNode.java | 10 +++ .../core/cast/BooleanCastNode.java | 4 +- .../core/hash/ConcatHashLiteralNode.java | 7 ++ .../core/hash/library/BucketsHashStore.java | 8 +++ .../core/hash/library/EmptyHashStore.java | 8 +++ .../hash/library/PackedHashStoreLibrary.java | 8 +++ .../core/inlined/LambdaToProcNode.java | 9 +++ .../core/kernel/AutoSplitNode.java | 8 +++ .../core/kernel/ChompLoopNode.java | 8 +++ .../core/kernel/KernelGetsNode.java | 8 +++ .../core/kernel/KernelPrintLastLineNode.java | 8 +++ .../truffleruby/core/method/MethodNodes.java | 9 +++ .../truffleruby/core/module/ModuleNodes.java | 9 +++ .../core/regexp/InterpolatedRegexpNode.java | 21 +++++- .../core/string/InterpolatedStringNode.java | 19 +++++- .../truffleruby/debug/MetricsBodyNode.java | 8 +++ .../org/truffleruby/language/DataNode.java | 7 ++ .../language/EmitWarningsNode.java | 8 +++ .../language/RubyBaseNodeWithExecute.java | 9 +++ .../language/SetTopLevelBindingNode.java | 7 ++ .../ArrayIsAtLeastAsLargeAsNode.java | 9 +++ .../CheckNoKeywordArgumentsNode.java | 9 +++ .../arguments/MissingKeywordArgumentNode.java | 17 ++++- .../language/arguments/NotProvidedNode.java | 8 +++ ...eadBlockFromCurrentFrameArgumentsNode.java | 9 +++ .../arguments/ReadKeywordArgumentNode.java | 9 +++ .../ReadKeywordRestArgumentNode.java | 15 +++- .../arguments/ReadOptionalArgumentNode.java | 11 +++ .../arguments/ReadPostArgumentNode.java | 8 +++ .../arguments/ReadPreArgumentNode.java | 8 +++ .../arguments/ReadRemainingArgumentsNode.java | 8 +++ .../arguments/ReadRestArgumentNode.java | 20 ++++++ .../language/arguments/ReadSelfNode.java | 8 +++ .../arguments/SaveMethodBlockNode.java | 8 +++ .../arguments/ShouldDestructureNode.java | 8 +++ .../constants/OrAssignConstantNode.java | 10 +++ .../language/constants/ReadConstantNode.java | 9 +++ .../ReadConstantWithDynamicScopeNode.java | 8 +++ .../ReadConstantWithLexicalScopeNode.java | 7 ++ .../language/constants/WriteConstantNode.java | 11 +++ .../truffleruby/language/control/AndNode.java | 9 +++ .../language/control/BreakNode.java | 10 +++ .../language/control/DynamicReturnNode.java | 10 +++ .../language/control/ElidableResultNode.java | 9 +++ .../language/control/FrameOnStackNode.java | 9 +++ .../language/control/IfElseNode.java | 15 ++++ .../truffleruby/language/control/IfNode.java | 14 ++++ .../language/control/InvalidReturnNode.java | 7 ++ .../language/control/LocalReturnNode.java | 8 +++ .../language/control/NextNode.java | 7 ++ .../truffleruby/language/control/NotNode.java | 10 +++ .../language/control/OnceNode.java | 7 ++ .../control/OrLazyValueDefinedNode.java | 10 +++ .../truffleruby/language/control/OrNode.java | 9 +++ .../language/control/RedoNode.java | 8 +++ .../language/control/RetryNode.java | 8 +++ .../language/control/SequenceNode.java | 8 +++ .../language/control/UnlessNode.java | 13 ++++ .../language/control/WhileNode.java | 30 ++++++++ .../language/defined/DefinedNode.java | 7 ++ .../language/defined/DefinedWrapperNode.java | 9 +++ .../language/dispatch/RubyCallNode.java | 68 +++++++++++++++---- .../language/exceptions/EnsureNode.java | 9 +++ .../exceptions/RescueClassesNode.java | 9 +++ .../language/exceptions/RescueNode.java | 3 + .../language/exceptions/RescueSplatNode.java | 11 +++ .../exceptions/RescueStandardErrorNode.java | 7 ++ .../language/exceptions/TryNode.java | 15 ++++ .../language/globals/AliasGlobalVarNode.java | 8 +++ .../globals/ReadMatchReferenceNodes.java | 21 ++++++ .../language/literal/BooleanLiteralNode.java | 8 +++ .../language/literal/FloatLiteralNode.java | 8 +++ .../literal/FrozenStringLiteralNode.java | 9 +++ .../literal/IntegerFixnumLiteralNode.java | 8 +++ .../literal/LongFixnumLiteralNode.java | 8 +++ .../language/literal/NilLiteralNode.java | 8 +++ .../literal/ObjectClassLiteralNode.java | 8 +++ .../language/literal/ObjectLiteralNode.java | 7 ++ .../literal/RangeClassLiteralNode.java | 8 +++ .../language/literal/StringLiteralNode.java | 8 +++ .../TruffleInternalModuleLiteralNode.java | 8 +++ ...ffleKernelOperationsModuleLiteralNode.java | 8 +++ .../language/locals/FlipFlopNode.java | 11 +++ .../language/locals/InitFlipFlopSlotNode.java | 8 +++ .../locals/ReadDeclarationVariableNode.java | 7 ++ .../locals/ReadLocalVariableNode.java | 7 ++ .../locals/WriteDeclarationVariableNode.java | 12 ++++ .../locals/WriteLocalVariableNode.java | 9 +++ .../language/methods/BlockDefinitionNode.java | 9 +++ .../language/methods/CatchBreakNode.java | 10 +++ .../methods/GetDefaultDefineeNode.java | 9 +++ .../language/methods/GetMethodObjectNode.java | 8 +++ .../methods/LiteralMethodDefinitionNode.java | 13 ++++ .../language/methods/SymbolProcNode.java | 8 +++ .../language/objects/DefineClassNode.java | 10 +++ .../objects/DynamicLexicalScopeNode.java | 8 +++ .../objects/GetDynamicLexicalScopeNode.java | 8 +++ .../objects/InsideModuleDefinitionNode.java | 7 ++ .../language/objects/LexicalScopeNode.java | 8 +++ .../objects/ReadInstanceVariableNode.java | 9 +++ .../objects/RunModuleDefinitionNode.java | 9 +++ .../language/objects/SelfNode.java | 8 +++ .../objects/WriteInstanceVariableNode.java | 12 ++++ .../classvariables/ReadClassVariableNode.java | 9 +++ .../WriteClassVariableNode.java | 12 +++- .../supercall/ReadSuperArgumentsNode.java | 9 +++ .../supercall/ReadZSuperArgumentsNode.java | 9 +++ .../language/supercall/SuperCallNode.java | 11 +++ .../supercall/ZSuperOutsideMethodNode.java | 8 +++ .../language/yield/YieldExpressionNode.java | 12 ++++ .../java/org/truffleruby/parser/DeadNode.java | 9 +++ 118 files changed, 1222 insertions(+), 28 deletions(-) diff --git a/src/main/java/org/truffleruby/builtins/EnumeratorSizeNode.java b/src/main/java/org/truffleruby/builtins/EnumeratorSizeNode.java index 1a1bac1dc0d4..87164464c543 100644 --- a/src/main/java/org/truffleruby/builtins/EnumeratorSizeNode.java +++ b/src/main/java/org/truffleruby/builtins/EnumeratorSizeNode.java @@ -29,10 +29,10 @@ public class EnumeratorSizeNode extends RubyContextSourceNode { private final RubySymbol methodName; private final RubySymbol sizeMethodName; - public EnumeratorSizeNode(RubySymbol enumeratorSize, RubySymbol methodName, RubyNode method) { + public EnumeratorSizeNode(RubySymbol sizeMethodName, RubySymbol methodName, RubyNode method) { this.method = method; this.methodName = methodName; - this.sizeMethodName = enumeratorSize; + this.sizeMethodName = sizeMethodName; } @Override @@ -57,4 +57,14 @@ public Object execute(VirtualFrame frame) { } } + @Override + public RubyNode cloneUninitialized() { + var copy = new EnumeratorSizeNode( + sizeMethodName, + methodName, + method.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/builtins/ReRaiseInlinedExceptionNode.java b/src/main/java/org/truffleruby/builtins/ReRaiseInlinedExceptionNode.java index 0b2dca7e1978..ce61c937b362 100644 --- a/src/main/java/org/truffleruby/builtins/ReRaiseInlinedExceptionNode.java +++ b/src/main/java/org/truffleruby/builtins/ReRaiseInlinedExceptionNode.java @@ -14,6 +14,7 @@ import org.truffleruby.core.exception.RubyException; import org.truffleruby.language.RubyBaseNode; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.control.RaiseException; import com.oracle.truffle.api.CompilerDirectives; @@ -48,4 +49,11 @@ public Object execute(VirtualFrame frame) { throw new RaiseException(getContext(), rubyException); } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReRaiseInlinedExceptionNode(nodeFactory); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/builtins/ReturnEnumeratorIfNoBlockNode.java b/src/main/java/org/truffleruby/builtins/ReturnEnumeratorIfNoBlockNode.java index 4a8b0c0884ea..089dd72b1fde 100644 --- a/src/main/java/org/truffleruby/builtins/ReturnEnumeratorIfNoBlockNode.java +++ b/src/main/java/org/truffleruby/builtins/ReturnEnumeratorIfNoBlockNode.java @@ -58,4 +58,13 @@ public Object execute(VirtualFrame frame) { } } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReturnEnumeratorIfNoBlockNode( + methodName, + method.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/IsNilNode.java b/src/main/java/org/truffleruby/core/IsNilNode.java index 0d3aea39bb35..7430451803a0 100644 --- a/src/main/java/org/truffleruby/core/IsNilNode.java +++ b/src/main/java/org/truffleruby/core/IsNilNode.java @@ -27,4 +27,11 @@ public Object execute(VirtualFrame frame) { return child.execute(frame) == nil; } + @Override + public RubyNode cloneUninitialized() { + var copy = new IsNilNode(child.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/array/ArrayConcatNode.java b/src/main/java/org/truffleruby/core/array/ArrayConcatNode.java index 386b212dce3e..9f5842d2d7e8 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayConcatNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayConcatNode.java @@ -91,4 +91,10 @@ public void doExecuteVoid(VirtualFrame frame) { } } + public RubyNode cloneUninitialized() { + var copy = new ArrayConcatNode(cloneUninitialized(children)); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java index 59f2cced7759..2d9a1d717d14 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java @@ -86,13 +86,6 @@ public int getSize() { return values.length; } - public RubyNode stealNode(int index) { - final RubyNode node = values[index]; - // Nullify it here so we make sure it's only referenced by the caller. - values[index] = null; - return node; - } - private static class EmptyArrayLiteralNode extends ArrayLiteralNode { public EmptyArrayLiteralNode(RubyLanguage language, RubyNode[] values) { @@ -104,6 +97,15 @@ public RubyArray execute(VirtualFrame frame) { return cachedCreateArray(ArrayStoreLibrary.initialStorage(false), 0); } + @Override + public RubyNode cloneUninitialized() { + var copy = new EmptyArrayLiteralNode( + language, + cloneUninitialized(values)); + copy.copyFlags(this); + return copy; + } + } private static class FloatArrayLiteralNode extends ArrayLiteralNode { @@ -141,6 +143,15 @@ private RubyArray makeGeneric(VirtualFrame frame, final double[] executedValues, return makeGeneric(frame, executedObjects); } + @Override + public RubyNode cloneUninitialized() { + var copy = new FloatArrayLiteralNode( + language, + cloneUninitialized(values)); + copy.copyFlags(this); + return copy; + } + } private static class IntegerArrayLiteralNode extends ArrayLiteralNode { @@ -178,6 +189,15 @@ private RubyArray makeGeneric(VirtualFrame frame, final int[] executedValues, in return makeGeneric(frame, executedObjects); } + @Override + public RubyNode cloneUninitialized() { + var copy = new IntegerArrayLiteralNode( + language, + cloneUninitialized(values)); + copy.copyFlags(this); + return copy; + } + } private static class LongArrayLiteralNode extends ArrayLiteralNode { @@ -215,6 +235,15 @@ private RubyArray makeGeneric(VirtualFrame frame, final long[] executedValues, i return makeGeneric(frame, executedObjects); } + @Override + public RubyNode cloneUninitialized() { + var copy = new LongArrayLiteralNode( + language, + cloneUninitialized(values)); + copy.copyFlags(this); + return copy; + } + } private static class ObjectArrayLiteralNode extends ArrayLiteralNode { @@ -235,6 +264,15 @@ public RubyArray execute(VirtualFrame frame) { return cachedCreateArray(executedValues, values.length); } + @Override + public RubyNode cloneUninitialized() { + var copy = new ObjectArrayLiteralNode( + language, + cloneUninitialized(values)); + copy.copyFlags(this); + return copy; + } + } private static class UninitialisedArrayLiteralNode extends ArrayLiteralNode { @@ -346,5 +384,15 @@ public Object storeSpecialisedFromObjects(Object... objects) { } } + @Override + public RubyNode cloneUninitialized() { + var valuesCopy = (values == null) ? null : cloneUninitialized(values); + var copy = new UninitialisedArrayLiteralNode( + language, + valuesCopy); + copy.copyFlags(this); + return copy; + } + } } diff --git a/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java b/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java index 1303ae953087..5c467c78d447 100644 --- a/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java +++ b/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java @@ -113,4 +113,32 @@ public AssignableNode toAssignableNode() { this.rhsNode = null; return this; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new MultipleAssignmentNode( + cloneUninitializedAssignable(preNodes), + cloneUninitializedAssignable(restNode), + cloneUninitializedAssignable(postNodes), + (SplatCastNode) splatCastNode.cloneUninitialized(), + rhsNode.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + + protected AssignableNode[] cloneUninitializedAssignable(AssignableNode[] nodes) { + AssignableNode[] copies = new AssignableNode[nodes.length]; + for (int i = 0; i < nodes.length; i++) { + copies[i] = cloneUninitializedAssignable(nodes[i]); + } + return copies; + } + + protected AssignableNode cloneUninitializedAssignable(AssignableNode node) { + if (node instanceof RubyNode) { + return (AssignableNode) ((RubyNode) node).cloneUninitialized(); + } + return node; + } + } diff --git a/src/main/java/org/truffleruby/core/binding/SetBindingFrameForEvalNode.java b/src/main/java/org/truffleruby/core/binding/SetBindingFrameForEvalNode.java index 9cb664dce6e7..d1d569250d4d 100644 --- a/src/main/java/org/truffleruby/core/binding/SetBindingFrameForEvalNode.java +++ b/src/main/java/org/truffleruby/core/binding/SetBindingFrameForEvalNode.java @@ -40,4 +40,14 @@ public Object execute(VirtualFrame frame) { return body.execute(frame); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new SetBindingFrameForEvalNode( + descriptor, + body.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/cast/BooleanCastNode.java b/src/main/java/org/truffleruby/core/cast/BooleanCastNode.java index 500cedc8fa53..ad2620af922f 100644 --- a/src/main/java/org/truffleruby/core/cast/BooleanCastNode.java +++ b/src/main/java/org/truffleruby/core/cast/BooleanCastNode.java @@ -28,7 +28,7 @@ /** Casts a value into a boolean. */ @GenerateUncached -@NodeChild(value = "value", type = RubyNode.class) +@NodeChild(value = "valueNode", type = RubyNode.class) public abstract class BooleanCastNode extends RubyBaseNode { public static BooleanCastNode create() { @@ -38,6 +38,8 @@ public static BooleanCastNode create() { /** Execute with child node */ public abstract boolean execute(VirtualFrame frame); + public abstract RubyNode getValueNode(); + /** Execute with given value */ public abstract boolean execute(Object value); diff --git a/src/main/java/org/truffleruby/core/hash/ConcatHashLiteralNode.java b/src/main/java/org/truffleruby/core/hash/ConcatHashLiteralNode.java index 9bbf26fe998d..4a2da3bee23a 100644 --- a/src/main/java/org/truffleruby/core/hash/ConcatHashLiteralNode.java +++ b/src/main/java/org/truffleruby/core/hash/ConcatHashLiteralNode.java @@ -41,4 +41,11 @@ public Object execute(VirtualFrame frame) { return hash; } + @Override + public RubyNode cloneUninitialized() { + var copy = new ConcatHashLiteralNode(cloneUninitialized(children)); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/hash/library/BucketsHashStore.java b/src/main/java/org/truffleruby/core/hash/library/BucketsHashStore.java index bc3861d2e3cb..67abff5f985a 100644 --- a/src/main/java/org/truffleruby/core/hash/library/BucketsHashStore.java +++ b/src/main/java/org/truffleruby/core/hash/library/BucketsHashStore.java @@ -628,6 +628,14 @@ public Object execute(VirtualFrame frame) { return hash; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new GenericHashLiteralNode(cloneUninitialized(keyValues)); + copy.copyFlags(this); + return copy; + } + } // endregion diff --git a/src/main/java/org/truffleruby/core/hash/library/EmptyHashStore.java b/src/main/java/org/truffleruby/core/hash/library/EmptyHashStore.java index cd2deaf2c41a..f94504c50de2 100644 --- a/src/main/java/org/truffleruby/core/hash/library/EmptyHashStore.java +++ b/src/main/java/org/truffleruby/core/hash/library/EmptyHashStore.java @@ -118,5 +118,13 @@ public EmptyHashLiteralNode() { public Object execute(VirtualFrame frame) { return HashOperations.newEmptyHash(getContext(), getLanguage()); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new EmptyHashLiteralNode(); + copy.copyFlags(this); + return copy; + } + } } diff --git a/src/main/java/org/truffleruby/core/hash/library/PackedHashStoreLibrary.java b/src/main/java/org/truffleruby/core/hash/library/PackedHashStoreLibrary.java index 106f6df12232..006ecace41c0 100644 --- a/src/main/java/org/truffleruby/core/hash/library/PackedHashStoreLibrary.java +++ b/src/main/java/org/truffleruby/core/hash/library/PackedHashStoreLibrary.java @@ -549,6 +549,14 @@ private boolean callEqual(Object receiver, Object key) { return booleanCastNode.execute(equalNode.call(receiver, "eql?", key)); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new SmallHashLiteralNode(cloneUninitialized(keyValues)); + copy.copyFlags(this); + return copy; + } + } // endregion diff --git a/src/main/java/org/truffleruby/core/inlined/LambdaToProcNode.java b/src/main/java/org/truffleruby/core/inlined/LambdaToProcNode.java index ed8d0b6e6b93..c1115e00e580 100644 --- a/src/main/java/org/truffleruby/core/inlined/LambdaToProcNode.java +++ b/src/main/java/org/truffleruby/core/inlined/LambdaToProcNode.java @@ -14,6 +14,7 @@ import org.truffleruby.core.proc.ProcType; import org.truffleruby.core.proc.RubyProc; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.methods.BlockDefinitionNode; import org.truffleruby.parser.MethodTranslator; @@ -38,4 +39,12 @@ public RubyProc execute(VirtualFrame frame) { assert block.type == ProcType.LAMBDA; return ProcOperations.createProcFromBlock(getContext(), getLanguage(), block); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new LambdaToProcNode((BlockDefinitionNode) blockNode.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/kernel/AutoSplitNode.java b/src/main/java/org/truffleruby/core/kernel/AutoSplitNode.java index 55203ee16202..d51b423cac0d 100644 --- a/src/main/java/org/truffleruby/core/kernel/AutoSplitNode.java +++ b/src/main/java/org/truffleruby/core/kernel/AutoSplitNode.java @@ -11,6 +11,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.DispatchNode; import org.truffleruby.language.globals.ReadGlobalVariableNode; import org.truffleruby.language.globals.ReadGlobalVariableNodeGen; @@ -30,4 +31,11 @@ public Object execute(VirtualFrame frame) { return writeSimpleGlobalVariableNode.execute(callSplitNode.call(lastLine, "split")); } + @Override + public RubyNode cloneUninitialized() { + var copy = new AutoSplitNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/kernel/ChompLoopNode.java b/src/main/java/org/truffleruby/core/kernel/ChompLoopNode.java index 705537e2582c..6da509012b93 100644 --- a/src/main/java/org/truffleruby/core/kernel/ChompLoopNode.java +++ b/src/main/java/org/truffleruby/core/kernel/ChompLoopNode.java @@ -11,6 +11,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.DispatchNode; import org.truffleruby.language.globals.ReadGlobalVariableNode; import org.truffleruby.language.globals.ReadGlobalVariableNodeGen; @@ -27,4 +28,11 @@ public Object execute(VirtualFrame frame) { return callChompNode.call(lastLine, "chomp!"); } + @Override + public RubyNode cloneUninitialized() { + var copy = new ChompLoopNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/kernel/KernelGetsNode.java b/src/main/java/org/truffleruby/core/kernel/KernelGetsNode.java index af38e61e6fea..5e002e2d8d01 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelGetsNode.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelGetsNode.java @@ -10,6 +10,7 @@ package org.truffleruby.core.kernel; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.DispatchNode; import com.oracle.truffle.api.CompilerDirectives; @@ -28,4 +29,11 @@ public Object execute(VirtualFrame frame) { return callGetsNode.callWithFrame(frame, coreLibrary().kernelModule, "gets"); } + @Override + public RubyNode cloneUninitialized() { + var copy = new KernelGetsNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/kernel/KernelPrintLastLineNode.java b/src/main/java/org/truffleruby/core/kernel/KernelPrintLastLineNode.java index d2adf09fc880..e35b792ffa17 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelPrintLastLineNode.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelPrintLastLineNode.java @@ -10,6 +10,7 @@ package org.truffleruby.core.kernel; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.DispatchNode; import org.truffleruby.language.globals.ReadGlobalVariableNode; import org.truffleruby.language.globals.ReadGlobalVariableNodeGen; @@ -36,4 +37,11 @@ public Object execute(VirtualFrame frame) { return callPrintNode.call(coreLibrary().kernelModule, "print", lastLine); } + @Override + public RubyNode cloneUninitialized() { + var copy = new KernelPrintLastLineNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/core/method/MethodNodes.java b/src/main/java/org/truffleruby/core/method/MethodNodes.java index 0728c144cd71..44eaceaea899 100644 --- a/src/main/java/org/truffleruby/core/method/MethodNodes.java +++ b/src/main/java/org/truffleruby/core/method/MethodNodes.java @@ -35,6 +35,7 @@ import org.truffleruby.core.symbol.RubySymbol; import org.truffleruby.language.RubyContextSourceNode; import org.truffleruby.language.RubyLambdaRootNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.RubyRootNode; import org.truffleruby.language.Visibility; import org.truffleruby.language.arguments.ArgumentDescriptorUtils; @@ -361,6 +362,14 @@ public Object execute(VirtualFrame frame) { final InternalMethod method = RubyArguments.getMethod(declarationFrame); return CallNode.callBoundMethod(frame, method, receiver, frame.getArguments(), callInternalMethodNode); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new CallWithRubyMethodReceiverNode(); + copy.copyFlags(this); + return copy; + } + } } diff --git a/src/main/java/org/truffleruby/core/module/ModuleNodes.java b/src/main/java/org/truffleruby/core/module/ModuleNodes.java index ba9c624038d3..2d367817f58b 100644 --- a/src/main/java/org/truffleruby/core/module/ModuleNodes.java +++ b/src/main/java/org/truffleruby/core/module/ModuleNodes.java @@ -1390,6 +1390,15 @@ public Object execute(VirtualFrame frame) { return lambdaBody.execute(frame); } + public RubyNode cloneUninitialized() { + var copy = new CallMethodWithLambdaBody( + proc, + lambdaCallTarget, + lambdaBody.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @TruffleBoundary diff --git a/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java b/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java index dea21a0d92d9..3d390f5e529b 100644 --- a/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java +++ b/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java @@ -17,6 +17,7 @@ import org.truffleruby.language.NotOptimizedWarningNode; import org.truffleruby.language.RubyBaseNode; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.control.DeferredRaiseException; import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary; @@ -26,6 +27,8 @@ import com.oracle.truffle.api.nodes.ExplodeLoop; import org.truffleruby.language.library.RubyStringLibrary; +import java.util.Arrays; + public class InterpolatedRegexpNode extends RubyContextSourceNode { @Children private final ToSNode[] children; @@ -34,8 +37,12 @@ public class InterpolatedRegexpNode extends RubyContextSourceNode { @Child private AsTruffleStringNode asTruffleStringNode = AsTruffleStringNode.create(); public InterpolatedRegexpNode(ToSNode[] children, RegexpOptions options) { + this(children, RegexpBuilderNode.create(options)); + } + + public InterpolatedRegexpNode(ToSNode[] children, RegexpBuilderNode builderNode) { this.children = children; - builderNode = RegexpBuilderNode.create(options); + this.builderNode = builderNode; } @Override @@ -55,6 +62,16 @@ protected TStringWithEncoding[] executeChildren(VirtualFrame frame) { return values; } + @Override + public RubyNode cloneUninitialized() { + var childrenCopy = cloneUninitialized(children); + var copy = new InterpolatedRegexpNode( + Arrays.copyOf(childrenCopy, childrenCopy.length, ToSNode[].class), + builderNode); + copy.copyFlags(this); + return copy; + } + public abstract static class RegexpBuilderNode extends RubyBaseNode { @Child private TruffleString.EqualNode equalNode = TruffleString.EqualNode.create(); @@ -107,5 +124,7 @@ protected RubyRegexp createRegexp(TStringWithEncoding[] strings) { throw dre.getException(getContext()); } } + } + } diff --git a/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java b/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java index a7532eea8416..9addc8877707 100644 --- a/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java +++ b/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java @@ -19,6 +19,9 @@ import com.oracle.truffle.api.CompilerDirectives; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.nodes.ExplodeLoop; +import org.truffleruby.language.RubyNode; + +import java.util.Arrays; /** A list of expressions to build up into a string. */ public final class InterpolatedStringNode extends RubyContextSourceNode { @@ -31,9 +34,13 @@ public final class InterpolatedStringNode extends RubyContextSourceNode { private final TruffleString emptyTString; public InterpolatedStringNode(ToSNode[] children, Encoding encoding) { + this(children, Encodings.getBuiltInEncoding(encoding)); + } + + private InterpolatedStringNode(ToSNode[] children, RubyEncoding encoding) { assert children.length > 0; this.children = children; - this.encoding = Encodings.getBuiltInEncoding(encoding); + this.encoding = encoding; this.emptyTString = this.encoding.tencoding.getEmpty(); } @@ -62,4 +69,14 @@ private RubyString executeStringAppend(RubyString builder, Object string) { return appendNode.executeStringAppend(builder, string); } + @Override + public RubyNode cloneUninitialized() { + var childrenCopy = cloneUninitialized(children); + var copy = new InterpolatedStringNode( + Arrays.copyOf(childrenCopy, childrenCopy.length, ToSNode[].class), + encoding); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/debug/MetricsBodyNode.java b/src/main/java/org/truffleruby/debug/MetricsBodyNode.java index 730ed452b469..3b66da0429a0 100644 --- a/src/main/java/org/truffleruby/debug/MetricsBodyNode.java +++ b/src/main/java/org/truffleruby/debug/MetricsBodyNode.java @@ -15,6 +15,7 @@ import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; class MetricsBodyNode extends RubyContextSourceNode { @@ -28,4 +29,11 @@ private Object call(Supplier supplier) { return supplier.get(); } + @Override + public RubyNode cloneUninitialized() { + var copy = new MetricsBodyNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/DataNode.java b/src/main/java/org/truffleruby/language/DataNode.java index 2ceefdf50298..58d960804655 100644 --- a/src/main/java/org/truffleruby/language/DataNode.java +++ b/src/main/java/org/truffleruby/language/DataNode.java @@ -57,4 +57,11 @@ private String getPath() { return getLanguage().getSourcePath(getEncapsulatingSourceSection().getSource()); } + @Override + public RubyNode cloneUninitialized() { + var copy = new DataNode(endPosition); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/EmitWarningsNode.java b/src/main/java/org/truffleruby/language/EmitWarningsNode.java index 7808c873e7cb..fe8e25651975 100644 --- a/src/main/java/org/truffleruby/language/EmitWarningsNode.java +++ b/src/main/java/org/truffleruby/language/EmitWarningsNode.java @@ -78,4 +78,12 @@ private static void printWarning(RubyContext context, String message) { } } } + + @Override + public RubyNode cloneUninitialized() { + var copy = new EmitWarningsNode(warnings); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/RubyBaseNodeWithExecute.java b/src/main/java/org/truffleruby/language/RubyBaseNodeWithExecute.java index c1179a186f21..091069df35d5 100644 --- a/src/main/java/org/truffleruby/language/RubyBaseNodeWithExecute.java +++ b/src/main/java/org/truffleruby/language/RubyBaseNodeWithExecute.java @@ -25,4 +25,13 @@ public abstract class RubyBaseNodeWithExecute extends RubyBaseNode { public abstract Object execute(VirtualFrame frame); public abstract RubyBaseNodeWithExecute cloneUninitialized(); + + protected static RubyBaseNodeWithExecute[] cloneUninitialized(RubyBaseNodeWithExecute[] nodes) { + RubyBaseNodeWithExecute[] copies = new RubyBaseNodeWithExecute[nodes.length]; + for (int i = 0; i < nodes.length; i++) { + copies[i] = nodes[i].cloneUninitialized(); + } + return copies; + } + } diff --git a/src/main/java/org/truffleruby/language/SetTopLevelBindingNode.java b/src/main/java/org/truffleruby/language/SetTopLevelBindingNode.java index c8722677eb6d..bb0b1d10995c 100644 --- a/src/main/java/org/truffleruby/language/SetTopLevelBindingNode.java +++ b/src/main/java/org/truffleruby/language/SetTopLevelBindingNode.java @@ -33,4 +33,11 @@ private void updateTopLevelBindingFrame(MaterializedFrame mainScriptFrame) { BindingNodes.insertAncestorFrame(toplevelBinding, mainScriptFrame); } + @Override + public RubyNode cloneUninitialized() { + var copy = new SetTopLevelBindingNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ArrayIsAtLeastAsLargeAsNode.java b/src/main/java/org/truffleruby/language/arguments/ArrayIsAtLeastAsLargeAsNode.java index 8be65f3123c1..f4e72c1c6ac5 100644 --- a/src/main/java/org/truffleruby/language/arguments/ArrayIsAtLeastAsLargeAsNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ArrayIsAtLeastAsLargeAsNode.java @@ -32,4 +32,13 @@ public Object execute(VirtualFrame frame) { return actualSize >= requiredSize; } + @Override + public RubyNode cloneUninitialized() { + var copy = new ArrayIsAtLeastAsLargeAsNode( + requiredSize, + child.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/CheckNoKeywordArgumentsNode.java b/src/main/java/org/truffleruby/language/arguments/CheckNoKeywordArgumentsNode.java index 706fd43edd53..cf1feb744f6f 100644 --- a/src/main/java/org/truffleruby/language/arguments/CheckNoKeywordArgumentsNode.java +++ b/src/main/java/org/truffleruby/language/arguments/CheckNoKeywordArgumentsNode.java @@ -11,6 +11,7 @@ import org.truffleruby.core.hash.RubyHash; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.control.RaiseException; import com.oracle.truffle.api.frame.VirtualFrame; @@ -36,4 +37,12 @@ public Object execute(VirtualFrame frame) { return nil; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new CheckNoKeywordArgumentsNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/MissingKeywordArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/MissingKeywordArgumentNode.java index 039a10ef8fdd..cd5292717907 100644 --- a/src/main/java/org/truffleruby/language/arguments/MissingKeywordArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/MissingKeywordArgumentNode.java @@ -15,6 +15,7 @@ import org.truffleruby.core.hash.library.HashStoreLibrary; import org.truffleruby.core.symbol.RubySymbol; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.control.RaiseException; import com.oracle.truffle.api.CompilerDirectives.CompilationFinal; @@ -33,7 +34,11 @@ public class MissingKeywordArgumentNode extends RubyContextSourceNode { @Child private HashStoreLibrary hashes; public MissingKeywordArgumentNode(RubyLanguage language, Arity arity) { - requiredKeywords = requiredKeywordsAsSymbols(language, arity); + this(requiredKeywordsAsSymbols(language, arity)); + } + + private MissingKeywordArgumentNode(RubySymbol[] requiredKeywords) { + this.requiredKeywords = requiredKeywords; readUserKeywordsHashNode = new ReadUserKeywordsHashNode(); hashes = insert(HashStoreLibrary.createDispatched()); } @@ -44,7 +49,7 @@ public Object execute(VirtualFrame frame) { throw new RaiseException(getContext(), missingKeywordsError(actualKeywords)); } - private RubySymbol[] requiredKeywordsAsSymbols(RubyLanguage language, Arity arity) { + private static RubySymbol[] requiredKeywordsAsSymbols(RubyLanguage language, Arity arity) { final String[] requiredKeywords = arity.getRequiredKeywordArguments(); final RubySymbol[] symbols = new RubySymbol[requiredKeywords.length]; @@ -82,4 +87,12 @@ private Object[] findMissingKeywordArguments(RubyHash actualKeywords) { return missingKeywords.toArray(); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new MissingKeywordArgumentNode(requiredKeywords); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/NotProvidedNode.java b/src/main/java/org/truffleruby/language/arguments/NotProvidedNode.java index 54b4b50fb490..8a20909afb04 100644 --- a/src/main/java/org/truffleruby/language/arguments/NotProvidedNode.java +++ b/src/main/java/org/truffleruby/language/arguments/NotProvidedNode.java @@ -13,6 +13,7 @@ import org.truffleruby.language.NotProvided; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; public class NotProvidedNode extends RubyContextSourceNode { @@ -21,4 +22,11 @@ public Object execute(VirtualFrame frame) { return NotProvided.INSTANCE; } + @Override + public RubyNode cloneUninitialized() { + var copy = new NotProvidedNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadBlockFromCurrentFrameArgumentsNode.java b/src/main/java/org/truffleruby/language/arguments/ReadBlockFromCurrentFrameArgumentsNode.java index 3c09aeed4ef7..f7b1bd85179c 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadBlockFromCurrentFrameArgumentsNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadBlockFromCurrentFrameArgumentsNode.java @@ -12,6 +12,7 @@ import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; /** {@link SaveMethodBlockNode} should be preferred when writing the result to a frame slot. */ public class ReadBlockFromCurrentFrameArgumentsNode extends RubyContextSourceNode { @@ -19,4 +20,12 @@ public class ReadBlockFromCurrentFrameArgumentsNode extends RubyContextSourceNod public Object execute(VirtualFrame frame) { return RubyArguments.getBlock(frame); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadBlockFromCurrentFrameArgumentsNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java index fccf1a648ef2..d9448e31f22c 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java @@ -91,4 +91,13 @@ RubyNode getDefaultValue() { return defaultValue; } + + @Override + public RubyNode cloneUninitialized() { + final RubyNode defaultValueCopy = (defaultValue == null) ? null : defaultValue.cloneUninitialized(); + var copy = ReadKeywordArgumentNode.create(name, defaultValueCopy); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java index cbe8d329fd56..cbb03f83429b 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java @@ -16,6 +16,7 @@ import org.truffleruby.core.hash.library.HashStoreLibrary.EachEntryCallback; import org.truffleruby.core.symbol.RubySymbol; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.methods.Arity; import com.oracle.truffle.api.CompilerDirectives.CompilationFinal; @@ -33,7 +34,11 @@ public class ReadKeywordRestArgumentNode extends RubyContextSourceNode implement private final ConditionProfile noHash = ConditionProfile.create(); public ReadKeywordRestArgumentNode(RubyLanguage language, int minimum, Arity arity) { - this.excludedKeywords = CheckKeywordArityNode.keywordsAsSymbols(language, arity); + this(CheckKeywordArityNode.keywordsAsSymbols(language, arity)); + } + + private ReadKeywordRestArgumentNode(RubySymbol[] excludedKeywords) { + this.excludedKeywords = excludedKeywords; this.readUserKeywordsHashNode = new ReadUserKeywordsHashNode(); } @@ -71,4 +76,12 @@ private boolean keywordExcluded(Object keyword) { return false; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadKeywordRestArgumentNode(excludedKeywords); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadOptionalArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadOptionalArgumentNode.java index 9a670f68c59f..b373a4eabe45 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadOptionalArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadOptionalArgumentNode.java @@ -51,4 +51,15 @@ public String toString() { return getClass().getSimpleName() + " " + index; } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadOptionalArgumentNode( + index, + minimum, + keywordArguments, + defaultValue.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadPostArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadPostArgumentNode.java index a1b277b48126..8f97fecd5d34 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadPostArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadPostArgumentNode.java @@ -13,6 +13,7 @@ import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; public class ReadPostArgumentNode extends RubyContextSourceNode { @@ -45,4 +46,11 @@ public String toString() { return getClass().getSimpleName() + " -" + indexFromCount; } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadPostArgumentNode(indexFromCount, keywordArguments, required); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadPreArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadPreArgumentNode.java index af4c6874303b..7d884f182bb9 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadPreArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadPreArgumentNode.java @@ -14,6 +14,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.profiles.BranchProfile; +import org.truffleruby.language.RubyNode; import org.truffleruby.utils.Utils; public class ReadPreArgumentNode extends RubyContextSourceNode { @@ -63,4 +64,11 @@ public String toString() { return getClass().getSimpleName() + " " + index; } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadPreArgumentNode(index, keywordArguments, missingArgumentBehavior); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadRemainingArgumentsNode.java b/src/main/java/org/truffleruby/language/arguments/ReadRemainingArgumentsNode.java index b99253992c61..097441032333 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadRemainingArgumentsNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadRemainingArgumentsNode.java @@ -13,6 +13,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.profiles.ConditionProfile; +import org.truffleruby.language.RubyNode; /** Assumes no keyword parameters */ public class ReadRemainingArgumentsNode extends RubyContextSourceNode { @@ -35,4 +36,11 @@ public Object execute(VirtualFrame frame) { } } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadRemainingArgumentsNode(start); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadRestArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadRestArgumentNode.java index 68696b7888be..1fb26404bb46 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadRestArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadRestArgumentNode.java @@ -17,6 +17,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.profiles.BranchProfile; +import org.truffleruby.language.RubyNode; public class ReadRestArgumentNode extends RubyContextSourceNode { @@ -39,6 +40,17 @@ public ReadRestArgumentNode( this.keywordArguments = keywordArguments; } + private ReadRestArgumentNode( + int startIndex, + int postArgumentsCount, + boolean keywordArguments, + boolean markKeywordHashWithFlag) { + this.startIndex = startIndex; + this.postArgumentsCount = postArgumentsCount; + this.keywordArguments = keywordArguments; + this.markKeywordHashWithFlag = markKeywordHashWithFlag; + } + public void markKeywordHashWithFlag() { this.markKeywordHashWithFlag = true; } @@ -76,4 +88,12 @@ public Object execute(VirtualFrame frame) { } } } + + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadRestArgumentNode(startIndex, postArgumentsCount, keywordArguments, markKeywordHashWithFlag); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadSelfNode.java b/src/main/java/org/truffleruby/language/arguments/ReadSelfNode.java index 9102e98933ac..f9681b224cf7 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadSelfNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadSelfNode.java @@ -12,6 +12,7 @@ import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; public class ReadSelfNode extends RubyContextSourceNode { @@ -20,4 +21,11 @@ public Object execute(VirtualFrame frame) { return RubyArguments.getSelf(frame); } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadSelfNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/SaveMethodBlockNode.java b/src/main/java/org/truffleruby/language/arguments/SaveMethodBlockNode.java index ba32fedaea5b..06196b524d78 100644 --- a/src/main/java/org/truffleruby/language/arguments/SaveMethodBlockNode.java +++ b/src/main/java/org/truffleruby/language/arguments/SaveMethodBlockNode.java @@ -12,6 +12,7 @@ import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; public class SaveMethodBlockNode extends RubyContextSourceNode { @@ -27,4 +28,11 @@ public Object execute(VirtualFrame frame) { return nil; } + @Override + public RubyNode cloneUninitialized() { + var copy = new SaveMethodBlockNode(slot); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ShouldDestructureNode.java b/src/main/java/org/truffleruby/language/arguments/ShouldDestructureNode.java index f026b34d01ea..a3cdc3501a7b 100644 --- a/src/main/java/org/truffleruby/language/arguments/ShouldDestructureNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ShouldDestructureNode.java @@ -15,6 +15,7 @@ import com.oracle.truffle.api.CompilerDirectives; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.profiles.BranchProfile; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.InternalRespondToNode; public class ShouldDestructureNode extends RubyContextSourceNode { @@ -56,4 +57,11 @@ public Object execute(VirtualFrame frame) { return respondToToAry.execute(frame, firstArgument, "to_ary"); } + @Override + public RubyNode cloneUninitialized() { + var copy = new ShouldDestructureNode(keywordArguments); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/constants/OrAssignConstantNode.java b/src/main/java/org/truffleruby/language/constants/OrAssignConstantNode.java index 48bf52de4b85..b87503523608 100644 --- a/src/main/java/org/truffleruby/language/constants/OrAssignConstantNode.java +++ b/src/main/java/org/truffleruby/language/constants/OrAssignConstantNode.java @@ -17,6 +17,7 @@ import org.truffleruby.core.module.RubyModule; import org.truffleruby.language.RubyConstant; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.utils.RunTwiceBranchProfile; /** e.g. for {@code module::FOO ||= 1} @@ -83,4 +84,13 @@ private boolean castToBoolean(final Object value) { } return cast.execute(value); } + + public RubyNode cloneUninitialized() { + var copy = new OrAssignConstantNode( + (ReadConstantNode) readConstant.cloneUninitialized(), + (WriteConstantNode) writeConstant.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/constants/ReadConstantNode.java b/src/main/java/org/truffleruby/language/constants/ReadConstantNode.java index cfa35f6f41a1..b95d2ddf081b 100644 --- a/src/main/java/org/truffleruby/language/constants/ReadConstantNode.java +++ b/src/main/java/org/truffleruby/language/constants/ReadConstantNode.java @@ -128,4 +128,13 @@ private RubyModule checkModule(Object module) { } } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadConstantNode( + moduleNode.cloneUninitialized(), + name); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/constants/ReadConstantWithDynamicScopeNode.java b/src/main/java/org/truffleruby/language/constants/ReadConstantWithDynamicScopeNode.java index a0000e2ebe9a..46b740a36957 100644 --- a/src/main/java/org/truffleruby/language/constants/ReadConstantWithDynamicScopeNode.java +++ b/src/main/java/org/truffleruby/language/constants/ReadConstantWithDynamicScopeNode.java @@ -17,6 +17,7 @@ import org.truffleruby.language.RubyContextSourceNode; import org.truffleruby.language.LexicalScope; import org.truffleruby.language.RubyConstant; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.arguments.RubyArguments; import org.truffleruby.language.control.RaiseException; @@ -64,4 +65,11 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c } } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadConstantWithDynamicScopeNode(name); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/constants/ReadConstantWithLexicalScopeNode.java b/src/main/java/org/truffleruby/language/constants/ReadConstantWithLexicalScopeNode.java index bc54b21f477e..6048333f0ff4 100644 --- a/src/main/java/org/truffleruby/language/constants/ReadConstantWithLexicalScopeNode.java +++ b/src/main/java/org/truffleruby/language/constants/ReadConstantWithLexicalScopeNode.java @@ -17,6 +17,7 @@ import org.truffleruby.language.LexicalScope; import org.truffleruby.language.RubyConstant; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.control.RaiseException; import com.oracle.truffle.api.frame.VirtualFrame; @@ -62,4 +63,10 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c } } + public RubyNode cloneUninitialized() { + var copy = new ReadConstantWithLexicalScopeNode(lexicalScope, name); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java b/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java index 06462e720368..30126593d45e 100644 --- a/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java +++ b/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java @@ -83,4 +83,15 @@ public AssignableNode toAssignableNode() { this.valueNode = null; return this; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new WriteConstantNode( + name, + moduleNode.cloneUninitialized(), + valueNode.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/AndNode.java b/src/main/java/org/truffleruby/language/control/AndNode.java index 48362cd188a4..6d7bca096aef 100644 --- a/src/main/java/org/truffleruby/language/control/AndNode.java +++ b/src/main/java/org/truffleruby/language/control/AndNode.java @@ -51,4 +51,13 @@ private boolean castToBoolean(final Object value) { return leftCast.execute(value); } + @Override + public RubyNode cloneUninitialized() { + var copy = new AndNode( + left.cloneUninitialized(), + right.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/BreakNode.java b/src/main/java/org/truffleruby/language/control/BreakNode.java index 19d17ca15fb2..874679b4f48e 100644 --- a/src/main/java/org/truffleruby/language/control/BreakNode.java +++ b/src/main/java/org/truffleruby/language/control/BreakNode.java @@ -45,4 +45,14 @@ public Object execute(VirtualFrame frame) { throw new BreakException(breakID, child.execute(frame)); } + @Override + public RubyNode cloneUninitialized() { + var copy = new BreakNode( + breakID, + ignoreMarker, + child.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/DynamicReturnNode.java b/src/main/java/org/truffleruby/language/control/DynamicReturnNode.java index 8a4b51175aa9..c7b017c25f16 100644 --- a/src/main/java/org/truffleruby/language/control/DynamicReturnNode.java +++ b/src/main/java/org/truffleruby/language/control/DynamicReturnNode.java @@ -34,4 +34,14 @@ public Object execute(VirtualFrame frame) { public boolean isContinuable() { return false; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new DynamicReturnNode( + returnID, + value.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/ElidableResultNode.java b/src/main/java/org/truffleruby/language/control/ElidableResultNode.java index 4f3e6d8b78cc..e739ab1d5806 100644 --- a/src/main/java/org/truffleruby/language/control/ElidableResultNode.java +++ b/src/main/java/org/truffleruby/language/control/ElidableResultNode.java @@ -47,4 +47,13 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c return elidableResult.isDefined(frame, language, context); } + @Override + public RubyNode cloneUninitialized() { + var copy = new ElidableResultNode( + required.cloneUninitialized(), + elidableResult.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/FrameOnStackNode.java b/src/main/java/org/truffleruby/language/control/FrameOnStackNode.java index e4e33e60903c..66da2cd98e98 100644 --- a/src/main/java/org/truffleruby/language/control/FrameOnStackNode.java +++ b/src/main/java/org/truffleruby/language/control/FrameOnStackNode.java @@ -37,4 +37,13 @@ public Object execute(VirtualFrame frame) { } } + @Override + public RubyNode cloneUninitialized() { + var copy = new FrameOnStackNode( + child.cloneUninitialized(), + frameOnStackMarkerSlot); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/IfElseNode.java b/src/main/java/org/truffleruby/language/control/IfElseNode.java index c46c492587df..ee4b3cafad11 100644 --- a/src/main/java/org/truffleruby/language/control/IfElseNode.java +++ b/src/main/java/org/truffleruby/language/control/IfElseNode.java @@ -57,4 +57,19 @@ public RubyNode simplifyAsTailExpression() { final RubyNode newElse = elseBody.simplifyAsTailExpression(); return new IfElseNode(condition, newThen, newElse).copySourceSection(this); } + + private RubyNode getConditionBeforeCasting() { + return condition.getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = new IfElseNode( + getConditionBeforeCasting().cloneUninitialized(), + thenBody.cloneUninitialized(), + elseBody.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/IfNode.java b/src/main/java/org/truffleruby/language/control/IfNode.java index 995a3b4af880..b9d5507b77c2 100644 --- a/src/main/java/org/truffleruby/language/control/IfNode.java +++ b/src/main/java/org/truffleruby/language/control/IfNode.java @@ -56,4 +56,18 @@ public RubyNode subsumeFollowing(RubyNode following) { public RubyNode simplifyAsTailExpression() { return new IfNode(condition, thenBody.simplifyAsTailExpression()).copySourceSection(this); } + + private RubyNode getConditionBeforeCasting() { + return condition.getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = new IfNode( + getConditionBeforeCasting().cloneUninitialized(), + thenBody.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/InvalidReturnNode.java b/src/main/java/org/truffleruby/language/control/InvalidReturnNode.java index fea075cd9302..127d97da594f 100644 --- a/src/main/java/org/truffleruby/language/control/InvalidReturnNode.java +++ b/src/main/java/org/truffleruby/language/control/InvalidReturnNode.java @@ -28,4 +28,11 @@ public Object execute(VirtualFrame frame) { throw new RaiseException(getContext(), coreExceptions().unexpectedReturn(this)); } + @Override + public RubyNode cloneUninitialized() { + var copy = new InvalidReturnNode(value.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/LocalReturnNode.java b/src/main/java/org/truffleruby/language/control/LocalReturnNode.java index 9a8c4d80a6a8..99d5ba9d45dc 100644 --- a/src/main/java/org/truffleruby/language/control/LocalReturnNode.java +++ b/src/main/java/org/truffleruby/language/control/LocalReturnNode.java @@ -36,4 +36,12 @@ public boolean isContinuable() { public RubyNode simplifyAsTailExpression() { return value; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new LocalReturnNode(value.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/NextNode.java b/src/main/java/org/truffleruby/language/control/NextNode.java index 99c8182b8359..81ba9419c012 100644 --- a/src/main/java/org/truffleruby/language/control/NextNode.java +++ b/src/main/java/org/truffleruby/language/control/NextNode.java @@ -27,4 +27,11 @@ public Object execute(VirtualFrame frame) { throw new NextException(child.execute(frame)); } + @Override + public RubyNode cloneUninitialized() { + var copy = new NextNode(child.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/NotNode.java b/src/main/java/org/truffleruby/language/control/NotNode.java index 326f1632974b..d72b8e845be9 100644 --- a/src/main/java/org/truffleruby/language/control/NotNode.java +++ b/src/main/java/org/truffleruby/language/control/NotNode.java @@ -29,4 +29,14 @@ public Object execute(VirtualFrame frame) { return !child.execute(frame); } + private RubyNode getChildBeforeCasting() { + return child.getValueNode(); + } + + public RubyNode cloneUninitialized() { + var copy = new NotNode(getChildBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/OnceNode.java b/src/main/java/org/truffleruby/language/control/OnceNode.java index 4267356a792a..2f3716d35e92 100644 --- a/src/main/java/org/truffleruby/language/control/OnceNode.java +++ b/src/main/java/org/truffleruby/language/control/OnceNode.java @@ -54,4 +54,11 @@ public Object execute(VirtualFrame frame) { return value; } + @Override + public RubyNode cloneUninitialized() { + var copy = new OnceNode(child.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/OrLazyValueDefinedNode.java b/src/main/java/org/truffleruby/language/control/OrLazyValueDefinedNode.java index 40be7a1cdfc1..646eac452856 100644 --- a/src/main/java/org/truffleruby/language/control/OrLazyValueDefinedNode.java +++ b/src/main/java/org/truffleruby/language/control/OrLazyValueDefinedNode.java @@ -56,4 +56,14 @@ public Object execute(VirtualFrame frame) { public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext context) { return FrozenStrings.ASSIGNMENT; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new OrLazyValueDefinedNode( + left.cloneUninitialized(), + right.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/OrNode.java b/src/main/java/org/truffleruby/language/control/OrNode.java index 9e67ef7878c7..54501c14851d 100644 --- a/src/main/java/org/truffleruby/language/control/OrNode.java +++ b/src/main/java/org/truffleruby/language/control/OrNode.java @@ -41,4 +41,13 @@ public Object execute(VirtualFrame frame) { } } + @Override + public RubyNode cloneUninitialized() { + var copy = new OrNode( + left.cloneUninitialized(), + right.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/RedoNode.java b/src/main/java/org/truffleruby/language/control/RedoNode.java index 00205531c5f2..c6710e0884fc 100644 --- a/src/main/java/org/truffleruby/language/control/RedoNode.java +++ b/src/main/java/org/truffleruby/language/control/RedoNode.java @@ -12,6 +12,7 @@ import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; public class RedoNode extends RubyContextSourceNode { @@ -20,4 +21,11 @@ public Object execute(VirtualFrame frame) { throw new RedoException(); } + @Override + public RubyNode cloneUninitialized() { + var copy = new RedoNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/RetryNode.java b/src/main/java/org/truffleruby/language/control/RetryNode.java index 64ce6688a87b..e0f83abe4658 100644 --- a/src/main/java/org/truffleruby/language/control/RetryNode.java +++ b/src/main/java/org/truffleruby/language/control/RetryNode.java @@ -12,6 +12,7 @@ import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; public class RetryNode extends RubyContextSourceNode { @@ -20,4 +21,11 @@ public Object execute(VirtualFrame frame) { throw new RetryException(); } + @Override + public RubyNode cloneUninitialized() { + var copy = new RetryNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/SequenceNode.java b/src/main/java/org/truffleruby/language/control/SequenceNode.java index 5bd33496d59b..c4704c36d4ee 100644 --- a/src/main/java/org/truffleruby/language/control/SequenceNode.java +++ b/src/main/java/org/truffleruby/language/control/SequenceNode.java @@ -68,4 +68,12 @@ public RubyNode simplifyAsTailExpression() { } return this; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new SequenceNode(cloneUninitialized(body)); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/UnlessNode.java b/src/main/java/org/truffleruby/language/control/UnlessNode.java index 8e83aa1682b2..93fc9c1ecc21 100644 --- a/src/main/java/org/truffleruby/language/control/UnlessNode.java +++ b/src/main/java/org/truffleruby/language/control/UnlessNode.java @@ -57,4 +57,17 @@ public RubyNode subsumeFollowing(RubyNode following) { public RubyNode simplifyAsTailExpression() { return new UnlessNode(condition, thenBody.simplifyAsTailExpression()).copySourceSection(this); } + + private RubyNode getConditionBeforeCasting() { + return condition.getValueNode(); + } + + public RubyNode cloneUninitialized() { + var copy = new UnlessNode( + getConditionBeforeCasting().cloneUninitialized(), + thenBody.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/control/WhileNode.java b/src/main/java/org/truffleruby/language/control/WhileNode.java index c504af455618..0a63ef618ec2 100644 --- a/src/main/java/org/truffleruby/language/control/WhileNode.java +++ b/src/main/java/org/truffleruby/language/control/WhileNode.java @@ -31,12 +31,23 @@ public WhileNode(RepeatingNode repeatingNode) { loopNode = Truffle.getRuntime().createLoopNode(repeatingNode); } + private WhileNode(LoopNode loopNode) { + this.loopNode = loopNode; + } + @Override public Object execute(VirtualFrame frame) { loopNode.execute(frame); return nil; } + public RubyNode cloneUninitialized() { + var repeatingNode = (WhileRepeatingBaseNode) loopNode.getRepeatingNode(); + var copy = new WhileNode(repeatingNode.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + private abstract static class WhileRepeatingBaseNode extends RubyBaseNode implements RepeatingNode { @Child protected BooleanCastNode condition; @@ -55,6 +66,7 @@ public String toString() { return "while loop at " + RubyLanguage.filenameLine(getEncapsulatingSourceSection()); } + public abstract WhileRepeatingBaseNode cloneUninitialized(); } public static class WhileRepeatingNode extends WhileRepeatingBaseNode implements RepeatingNode { @@ -84,6 +96,13 @@ public boolean executeRepeating(VirtualFrame frame) { } } + @Override + public WhileRepeatingBaseNode cloneUninitialized() { + return new WhileRepeatingNode( + condition.getValueNode().cloneUninitialized(), + body.cloneUninitialized()); + } + } public static class DoWhileRepeatingNode extends WhileRepeatingBaseNode implements RepeatingNode { @@ -107,6 +126,17 @@ public boolean executeRepeating(VirtualFrame frame) { return condition.execute(frame); } + private RubyNode getConditionBeforeCasting() { + return condition.getValueNode(); + } + + @Override + public WhileRepeatingBaseNode cloneUninitialized() { + return new DoWhileRepeatingNode( + getConditionBeforeCasting().cloneUninitialized(), + body.cloneUninitialized()); + } + } } diff --git a/src/main/java/org/truffleruby/language/defined/DefinedNode.java b/src/main/java/org/truffleruby/language/defined/DefinedNode.java index ac425a6db37d..ffa2c66ba8c6 100644 --- a/src/main/java/org/truffleruby/language/defined/DefinedNode.java +++ b/src/main/java/org/truffleruby/language/defined/DefinedNode.java @@ -27,4 +27,11 @@ public Object execute(VirtualFrame frame) { return child.isDefined(frame, getLanguage(), getContext()); } + @Override + public RubyNode cloneUninitialized() { + var copy = new DefinedNode(child.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/defined/DefinedWrapperNode.java b/src/main/java/org/truffleruby/language/defined/DefinedWrapperNode.java index b113eca32995..177b03926785 100644 --- a/src/main/java/org/truffleruby/language/defined/DefinedWrapperNode.java +++ b/src/main/java/org/truffleruby/language/defined/DefinedWrapperNode.java @@ -38,4 +38,13 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c return definition.createInstance(context); } + @Override + public RubyNode cloneUninitialized() { + var copy = new DefinedWrapperNode( + definition, + child.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java index 49febfcb4445..05cd19d08a8f 100644 --- a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java +++ b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java @@ -66,18 +66,42 @@ public class RubyCallNode extends LiteralCallNode implements AssignableNode { @Child private SplatToArgsNode splatToArgs; public RubyCallNode(RubyCallNodeParameters parameters) { - super(parameters.isSplatted(), parameters.getDescriptor()); - this.methodName = parameters.getMethodName(); - this.receiver = parameters.getReceiver(); - this.arguments = parameters.getArguments(); - this.block = parameters.getBlock(); - - this.dispatchConfig = parameters.isIgnoreVisibility() ? PRIVATE : PROTECTED; - this.isVCall = parameters.isVCall(); - this.isSafeNavigation = parameters.isSafeNavigation(); - this.isAttrAssign = parameters.isAttrAssign(); - - if (parameters.isSafeNavigation()) { + this( + parameters.isSplatted(), + parameters.getDescriptor(), + parameters.getMethodName(), + parameters.getReceiver(), + parameters.getArguments(), + parameters.getBlock(), + parameters.isIgnoreVisibility() ? PRIVATE : PROTECTED, + parameters.isVCall(), + parameters.isSafeNavigation(), + parameters.isAttrAssign()); + } + + public RubyCallNode( + boolean isSplatted, + ArgumentsDescriptor descriptor, + String methodName, + RubyNode receiver, + RubyNode[] arguments, + RubyNode block, + DispatchConfiguration dispatchConfig, + boolean isVCall, + boolean isSafeNavigation, + boolean isAttrAssign) { + super(isSplatted, descriptor); + + this.methodName = methodName; + this.receiver = receiver; + this.arguments = arguments; + this.block = block; + this.dispatchConfig = dispatchConfig; + this.isVCall = isVCall; + this.isSafeNavigation = isSafeNavigation; + this.isAttrAssign = isAttrAssign; + + if (isSafeNavigation) { nilProfile = ConditionProfile.createCountingProfile(); } else { nilProfile = null; @@ -237,6 +261,24 @@ public Map getDebugProperties() { return map; } + @Override + public RubyNode cloneUninitialized() { + var blockCopy = (block == null) ? null : block.cloneUninitialized(); + var copy = new RubyCallNode( + isSplatted, + descriptor, + methodName, + receiver.cloneUninitialized(), + cloneUninitialized(arguments), + blockCopy, + dispatchConfig, + isVCall, + isSafeNavigation, + isAttrAssign); + copy.copyFlags(this); + return copy; + } + private class DefinedNode extends RubyBaseNode { private final RubySymbol methodNameSymbol = getSymbol(methodName); @@ -289,5 +331,7 @@ public Object isDefined(VirtualFrame frame, RubyContext context) { return FrozenStrings.METHOD; } + } + } diff --git a/src/main/java/org/truffleruby/language/exceptions/EnsureNode.java b/src/main/java/org/truffleruby/language/exceptions/EnsureNode.java index 85b2e4e088c7..2b632a884436 100644 --- a/src/main/java/org/truffleruby/language/exceptions/EnsureNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/EnsureNode.java @@ -94,4 +94,13 @@ public Object executeCommon(VirtualFrame frame, boolean executeVoid) { } } + @Override + public RubyNode cloneUninitialized() { + var copy = new EnsureNode( + tryPart.cloneUninitialized(), + ensurePart.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/exceptions/RescueClassesNode.java b/src/main/java/org/truffleruby/language/exceptions/RescueClassesNode.java index 5317189a9dc7..a3d4a1c017c0 100644 --- a/src/main/java/org/truffleruby/language/exceptions/RescueClassesNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/RescueClassesNode.java @@ -43,4 +43,13 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c return RubyNode.defaultIsDefined(this); } + @Override + public RubyNode cloneUninitialized() { + var copy = new RescueClassesNode( + cloneUninitialized(handlingClassNodes), + getRescueBody().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/exceptions/RescueNode.java b/src/main/java/org/truffleruby/language/exceptions/RescueNode.java index 88a937383282..189b48134be7 100644 --- a/src/main/java/org/truffleruby/language/exceptions/RescueNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/RescueNode.java @@ -88,4 +88,7 @@ public WrapperNode createWrapper(ProbeNode probe) { @Override public abstract Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext context); + protected RubyNode getRescueBody() { + return rescueBody; + } } diff --git a/src/main/java/org/truffleruby/language/exceptions/RescueSplatNode.java b/src/main/java/org/truffleruby/language/exceptions/RescueSplatNode.java index a97f7512890b..aa65fc2e3a8f 100644 --- a/src/main/java/org/truffleruby/language/exceptions/RescueSplatNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/RescueSplatNode.java @@ -62,4 +62,15 @@ public boolean canHandle(VirtualFrame frame, Object exceptionObject) { public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext context) { return RubyNode.defaultIsDefined(this); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new RescueSplatNode( + getLanguage(), + splatCastNode.getChildNode().cloneUninitialized(), + getRescueBody().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/exceptions/RescueStandardErrorNode.java b/src/main/java/org/truffleruby/language/exceptions/RescueStandardErrorNode.java index 1ad12763fce9..2d03c943aa22 100644 --- a/src/main/java/org/truffleruby/language/exceptions/RescueStandardErrorNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/RescueStandardErrorNode.java @@ -31,4 +31,11 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c return RubyNode.defaultIsDefined(this); } + @Override + public RubyNode cloneUninitialized() { + var copy = new RescueStandardErrorNode(getRescueBody().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/exceptions/TryNode.java b/src/main/java/org/truffleruby/language/exceptions/TryNode.java index 2282af8d5888..ef84e0dea2f6 100644 --- a/src/main/java/org/truffleruby/language/exceptions/TryNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/TryNode.java @@ -30,6 +30,8 @@ import org.truffleruby.language.methods.TranslateExceptionNode; import org.truffleruby.language.threadlocal.ThreadLocalGlobals; +import java.util.Arrays; + public class TryNode extends RubyContextSourceNode { @Child private RubyNode tryPart; @@ -142,4 +144,17 @@ private void printBacktraceOnRescue(RescueNode rescue, AbstractTruffleException getContext().getDefaultBacktraceFormatter().printRubyExceptionOnEnvStderr(info, exception); } + @Override + public RubyNode cloneUninitialized() { + var rescuePartsCopy = cloneUninitialized(rescueParts); + var elsePartCopy = (elsePart == null) ? null : elsePart.cloneUninitialized(); + var copy = new TryNode( + tryPart.cloneUninitialized(), + Arrays.copyOf(rescuePartsCopy, rescuePartsCopy.length, RescueNode[].class), + elsePartCopy, + canOmitBacktrace); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/globals/AliasGlobalVarNode.java b/src/main/java/org/truffleruby/language/globals/AliasGlobalVarNode.java index fb0b21324593..a8256b871a9f 100644 --- a/src/main/java/org/truffleruby/language/globals/AliasGlobalVarNode.java +++ b/src/main/java/org/truffleruby/language/globals/AliasGlobalVarNode.java @@ -12,6 +12,7 @@ import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; public class AliasGlobalVarNode extends RubyContextSourceNode { @@ -29,4 +30,11 @@ public Object execute(VirtualFrame frame) { return nil; } + @Override + public RubyNode cloneUninitialized() { + var copy = new AliasGlobalVarNode(oldName, newName); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/globals/ReadMatchReferenceNodes.java b/src/main/java/org/truffleruby/language/globals/ReadMatchReferenceNodes.java index e081106c697e..eb3a2a376335 100644 --- a/src/main/java/org/truffleruby/language/globals/ReadMatchReferenceNodes.java +++ b/src/main/java/org/truffleruby/language/globals/ReadMatchReferenceNodes.java @@ -62,6 +62,16 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c return FrozenStrings.GLOBAL_VARIABLE; } } + + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadNthMatchNode( + readMatchNode.cloneUninitialized(), + index); + copy.copyFlags(this); + return copy; + } + } public static class SetNamedVariablesMatchNode extends RubyContextSourceNode { @@ -110,5 +120,16 @@ private void setNamedForNil(VirtualFrame frame) { } } + @Override + public RubyNode cloneUninitialized() { + var copy = new SetNamedVariablesMatchNode( + matchDataNode.cloneUninitialized(), + readMatchNode.cloneUninitialized(), + cloneUninitialized(setters), + cloneUninitialized(nilSetters)); + copy.copyFlags(this); + return copy; + } + } } diff --git a/src/main/java/org/truffleruby/language/literal/BooleanLiteralNode.java b/src/main/java/org/truffleruby/language/literal/BooleanLiteralNode.java index 69d0ecd3ca72..f80a79e62832 100644 --- a/src/main/java/org/truffleruby/language/literal/BooleanLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/BooleanLiteralNode.java @@ -17,6 +17,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.nodes.NodeCost; import com.oracle.truffle.api.nodes.NodeInfo; +import org.truffleruby.language.RubyNode; @NodeInfo(cost = NodeCost.NONE) public class BooleanLiteralNode extends RubyContextSourceNode { @@ -41,4 +42,11 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c } } + @Override + public RubyNode cloneUninitialized() { + var copy = new BooleanLiteralNode(value); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/literal/FloatLiteralNode.java b/src/main/java/org/truffleruby/language/literal/FloatLiteralNode.java index d7bdce6e4e88..06cfd84f62ac 100644 --- a/src/main/java/org/truffleruby/language/literal/FloatLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/FloatLiteralNode.java @@ -14,6 +14,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.nodes.NodeCost; import com.oracle.truffle.api.nodes.NodeInfo; +import org.truffleruby.language.RubyNode; @NodeInfo(cost = NodeCost.NONE) public class FloatLiteralNode extends RubyContextSourceNode { @@ -29,4 +30,11 @@ public Object execute(VirtualFrame frame) { return value; } + @Override + public RubyNode cloneUninitialized() { + var copy = new FloatLiteralNode(value); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/literal/FrozenStringLiteralNode.java b/src/main/java/org/truffleruby/language/literal/FrozenStringLiteralNode.java index a44b2f94c682..09f87dc245f4 100644 --- a/src/main/java/org/truffleruby/language/literal/FrozenStringLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/FrozenStringLiteralNode.java @@ -15,6 +15,7 @@ import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; public class FrozenStringLiteralNode extends RubyContextSourceNode { @@ -35,4 +36,12 @@ public ImmutableRubyString execute(VirtualFrame frame) { public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext context) { return definition; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new FrozenStringLiteralNode(frozenString, definition); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/literal/IntegerFixnumLiteralNode.java b/src/main/java/org/truffleruby/language/literal/IntegerFixnumLiteralNode.java index a45bd799f944..f9c251dac240 100644 --- a/src/main/java/org/truffleruby/language/literal/IntegerFixnumLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/IntegerFixnumLiteralNode.java @@ -14,6 +14,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.nodes.NodeCost; import com.oracle.truffle.api.nodes.NodeInfo; +import org.truffleruby.language.RubyNode; @NodeInfo(cost = NodeCost.NONE) public class IntegerFixnumLiteralNode extends RubyContextSourceNode { @@ -29,4 +30,11 @@ public Object execute(VirtualFrame frame) { return value; } + @Override + public RubyNode cloneUninitialized() { + var copy = new IntegerFixnumLiteralNode(value); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/literal/LongFixnumLiteralNode.java b/src/main/java/org/truffleruby/language/literal/LongFixnumLiteralNode.java index 1dd53edb33e7..71b0bdc4e49f 100644 --- a/src/main/java/org/truffleruby/language/literal/LongFixnumLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/LongFixnumLiteralNode.java @@ -14,6 +14,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.nodes.NodeCost; import com.oracle.truffle.api.nodes.NodeInfo; +import org.truffleruby.language.RubyNode; @NodeInfo(cost = NodeCost.NONE) public class LongFixnumLiteralNode extends RubyContextSourceNode { @@ -29,4 +30,11 @@ public Object execute(VirtualFrame frame) { return value; } + @Override + public RubyNode cloneUninitialized() { + var copy = new LongFixnumLiteralNode(value); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/literal/NilLiteralNode.java b/src/main/java/org/truffleruby/language/literal/NilLiteralNode.java index e923c6064ac4..06163b7ddf14 100644 --- a/src/main/java/org/truffleruby/language/literal/NilLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/NilLiteralNode.java @@ -17,6 +17,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.nodes.NodeCost; import com.oracle.truffle.api.nodes.NodeInfo; +import org.truffleruby.language.RubyNode; @NodeInfo(cost = NodeCost.NONE) public class NilLiteralNode extends RubyContextSourceNode { @@ -41,4 +42,11 @@ public boolean isImplicit() { return isImplicit; } + @Override + public RubyNode cloneUninitialized() { + var copy = new NilLiteralNode(isImplicit); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/literal/ObjectClassLiteralNode.java b/src/main/java/org/truffleruby/language/literal/ObjectClassLiteralNode.java index ebababa1b15a..00d00d911bd9 100644 --- a/src/main/java/org/truffleruby/language/literal/ObjectClassLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/ObjectClassLiteralNode.java @@ -11,6 +11,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; public class ObjectClassLiteralNode extends RubyContextSourceNode { @@ -19,4 +20,11 @@ public Object execute(VirtualFrame frame) { return getContext().getCoreLibrary().objectClass; } + @Override + public RubyNode cloneUninitialized() { + var copy = new ObjectClassLiteralNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/literal/ObjectLiteralNode.java b/src/main/java/org/truffleruby/language/literal/ObjectLiteralNode.java index da2da0e2da8b..18bddf6fb371 100644 --- a/src/main/java/org/truffleruby/language/literal/ObjectLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/ObjectLiteralNode.java @@ -14,6 +14,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.nodes.NodeCost; import com.oracle.truffle.api.nodes.NodeInfo; +import org.truffleruby.language.RubyNode; @NodeInfo(cost = NodeCost.NONE) public class ObjectLiteralNode extends RubyContextSourceNode { @@ -33,4 +34,10 @@ public Object getObject() { return object; } + @Override + public RubyNode cloneUninitialized() { + var copy = new ObjectLiteralNode(object); + copy.copyFlags(this); + return copy; + } } diff --git a/src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java b/src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java index d990836418f9..8183ceb9623d 100644 --- a/src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java @@ -11,6 +11,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; public class RangeClassLiteralNode extends RubyContextSourceNode { @@ -19,4 +20,11 @@ public Object execute(VirtualFrame frame) { return getContext().getCoreLibrary().rangeClass; } + @Override + public RubyNode cloneUninitialized() { + var copy = new RangeClassLiteralNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/literal/StringLiteralNode.java b/src/main/java/org/truffleruby/language/literal/StringLiteralNode.java index 9e3a7f7f67ef..5e5452917e9f 100644 --- a/src/main/java/org/truffleruby/language/literal/StringLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/StringLiteralNode.java @@ -15,6 +15,7 @@ import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; public class StringLiteralNode extends RubyContextSourceNode { @@ -31,4 +32,11 @@ public RubyString execute(VirtualFrame frame) { return createString(tstring, encoding); } + @Override + public RubyNode cloneUninitialized() { + var copy = new StringLiteralNode(tstring, encoding); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/literal/TruffleInternalModuleLiteralNode.java b/src/main/java/org/truffleruby/language/literal/TruffleInternalModuleLiteralNode.java index f71902ec3530..69b8311c83ee 100644 --- a/src/main/java/org/truffleruby/language/literal/TruffleInternalModuleLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/TruffleInternalModuleLiteralNode.java @@ -11,6 +11,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; public class TruffleInternalModuleLiteralNode extends RubyContextSourceNode { @@ -19,4 +20,11 @@ public Object execute(VirtualFrame frame) { return getContext().getCoreLibrary().truffleInternalModule; } + @Override + public RubyNode cloneUninitialized() { + var copy = new TruffleInternalModuleLiteralNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/literal/TruffleKernelOperationsModuleLiteralNode.java b/src/main/java/org/truffleruby/language/literal/TruffleKernelOperationsModuleLiteralNode.java index 713e46c4f44f..f26940aae4fe 100644 --- a/src/main/java/org/truffleruby/language/literal/TruffleKernelOperationsModuleLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/TruffleKernelOperationsModuleLiteralNode.java @@ -11,6 +11,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; public class TruffleKernelOperationsModuleLiteralNode extends RubyContextSourceNode { @@ -19,4 +20,11 @@ public Object execute(VirtualFrame frame) { return getContext().getCoreLibrary().truffleKernelOperationsModule; } + @Override + public RubyNode cloneUninitialized() { + var copy = new TruffleKernelOperationsModuleLiteralNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/locals/FlipFlopNode.java b/src/main/java/org/truffleruby/language/locals/FlipFlopNode.java index 11a5c15274f0..37df4427729b 100644 --- a/src/main/java/org/truffleruby/language/locals/FlipFlopNode.java +++ b/src/main/java/org/truffleruby/language/locals/FlipFlopNode.java @@ -67,4 +67,15 @@ public Object execute(VirtualFrame frame) { } } + @Override + public RubyNode cloneUninitialized() { + var copy = new FlipFlopNode( + begin.getValueNode().cloneUninitialized(), + end.getValueNode().cloneUninitialized(), + stateNode, + exclusive); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/locals/InitFlipFlopSlotNode.java b/src/main/java/org/truffleruby/language/locals/InitFlipFlopSlotNode.java index d80d816dacc0..5a5d6003b410 100644 --- a/src/main/java/org/truffleruby/language/locals/InitFlipFlopSlotNode.java +++ b/src/main/java/org/truffleruby/language/locals/InitFlipFlopSlotNode.java @@ -12,6 +12,7 @@ import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; public class InitFlipFlopSlotNode extends RubyContextSourceNode { @@ -32,4 +33,11 @@ public Object execute(VirtualFrame frame) { return null; } + @Override + public RubyNode cloneUninitialized() { + var copy = new InitFlipFlopSlotNode(frameSlot); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/locals/ReadDeclarationVariableNode.java b/src/main/java/org/truffleruby/language/locals/ReadDeclarationVariableNode.java index cc692848a2d0..19e5d8f610f3 100644 --- a/src/main/java/org/truffleruby/language/locals/ReadDeclarationVariableNode.java +++ b/src/main/java/org/truffleruby/language/locals/ReadDeclarationVariableNode.java @@ -62,4 +62,11 @@ protected String getVariableName() { return descriptor.getSlotName(frameSlot).toString(); } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadDeclarationVariableNode(type, frameDepth, frameSlot); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/locals/ReadLocalVariableNode.java b/src/main/java/org/truffleruby/language/locals/ReadLocalVariableNode.java index c7e2502aa534..e8a98704a99a 100644 --- a/src/main/java/org/truffleruby/language/locals/ReadLocalVariableNode.java +++ b/src/main/java/org/truffleruby/language/locals/ReadLocalVariableNode.java @@ -45,4 +45,11 @@ protected String getVariableName() { return getRootNode().getFrameDescriptor().getSlotName(frameSlot).toString(); } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadLocalVariableNode(type, frameSlot); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java b/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java index c29d004f797a..f6051769ba74 100644 --- a/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java +++ b/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java @@ -60,4 +60,16 @@ protected String getVariableName() { return descriptor.getSlotName(frameSlot).toString(); } + + @Override + public RubyNode cloneUninitialized() { + var valueNodeCopy = (valueNode == null) ? null : valueNode.cloneUninitialized(); + var copy = new WriteDeclarationVariableNode( + frameSlot, + frameDepth, + valueNodeCopy); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java b/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java index 7435b3be6d8f..d4d1a7c31067 100644 --- a/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java +++ b/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java @@ -57,4 +57,13 @@ public String toString() { return super.toString() + " " + getVariableName() + " = " + valueNode; } + @Override + public RubyNode cloneUninitialized() { + var copy = new WriteLocalVariableNode( + frameSlot, + valueNode.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java b/src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java index 67feab609f9a..72218578980d 100644 --- a/src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java +++ b/src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java @@ -15,6 +15,7 @@ import org.truffleruby.core.proc.ProcType; import org.truffleruby.core.proc.RubyProc; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.arguments.RubyArguments; import org.truffleruby.language.control.BreakID; import org.truffleruby.language.control.FrameOnStackMarker; @@ -86,4 +87,12 @@ private DeclarationContext executeWithoutVisibility(DeclarationContext ctxIn) { } return withoutVisibilityNode.executeWithoutVisibility(ctxIn); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new BlockDefinitionNode(type, sharedMethodInfo, callTargets, breakID, frameOnStackMarkerSlot); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/methods/CatchBreakNode.java b/src/main/java/org/truffleruby/language/methods/CatchBreakNode.java index 06d45f14079a..ad149c9063fc 100644 --- a/src/main/java/org/truffleruby/language/methods/CatchBreakNode.java +++ b/src/main/java/org/truffleruby/language/methods/CatchBreakNode.java @@ -50,4 +50,14 @@ public Object execute(VirtualFrame frame) { } } + @Override + public RubyNode cloneUninitialized() { + var copy = new CatchBreakNode( + breakID, + body.cloneUninitialized(), + isWhile); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/methods/GetDefaultDefineeNode.java b/src/main/java/org/truffleruby/language/methods/GetDefaultDefineeNode.java index 88ba766b6fda..6ad224979186 100644 --- a/src/main/java/org/truffleruby/language/methods/GetDefaultDefineeNode.java +++ b/src/main/java/org/truffleruby/language/methods/GetDefaultDefineeNode.java @@ -11,6 +11,7 @@ import org.truffleruby.core.module.RubyModule; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.arguments.RubyArguments; import com.oracle.truffle.api.frame.VirtualFrame; @@ -20,4 +21,12 @@ public class GetDefaultDefineeNode extends RubyContextSourceNode { public RubyModule execute(VirtualFrame frame) { return RubyArguments.getDeclarationContext(frame).getModuleToDefineMethods(); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new GetDefaultDefineeNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/methods/GetMethodObjectNode.java b/src/main/java/org/truffleruby/language/methods/GetMethodObjectNode.java index 0724b299a011..3c12d1472285 100644 --- a/src/main/java/org/truffleruby/language/methods/GetMethodObjectNode.java +++ b/src/main/java/org/truffleruby/language/methods/GetMethodObjectNode.java @@ -140,5 +140,13 @@ public Object execute(VirtualFrame frame) { RubyArguments.getDescriptor(frame), newUserArguments); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new CallMethodMissingWithStaticName(methodName); + copy.copyFlags(this); + return copy; + } + } } diff --git a/src/main/java/org/truffleruby/language/methods/LiteralMethodDefinitionNode.java b/src/main/java/org/truffleruby/language/methods/LiteralMethodDefinitionNode.java index 6e624e183a26..359ab5d872ff 100644 --- a/src/main/java/org/truffleruby/language/methods/LiteralMethodDefinitionNode.java +++ b/src/main/java/org/truffleruby/language/methods/LiteralMethodDefinitionNode.java @@ -99,4 +99,17 @@ public InstrumentableNode materializeInstrumentableNodes(Set tag) { return super.hasTag(tag); } + @Override + public RubyNode cloneUninitialized() { + var copy = new InsideModuleDefinitionNode(body.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/objects/LexicalScopeNode.java b/src/main/java/org/truffleruby/language/objects/LexicalScopeNode.java index 85f3323e42ca..29082b5cf3cf 100644 --- a/src/main/java/org/truffleruby/language/objects/LexicalScopeNode.java +++ b/src/main/java/org/truffleruby/language/objects/LexicalScopeNode.java @@ -13,6 +13,7 @@ import org.truffleruby.language.LexicalScope; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; public class LexicalScopeNode extends RubyContextSourceNode { @@ -27,4 +28,11 @@ public Object execute(VirtualFrame frame) { return lexicalScope.getLiveModule(); } + @Override + public RubyNode cloneUninitialized() { + var copy = new LexicalScopeNode(lexicalScope); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/objects/ReadInstanceVariableNode.java b/src/main/java/org/truffleruby/language/objects/ReadInstanceVariableNode.java index ee76aa7f00c3..f62394caf22a 100644 --- a/src/main/java/org/truffleruby/language/objects/ReadInstanceVariableNode.java +++ b/src/main/java/org/truffleruby/language/objects/ReadInstanceVariableNode.java @@ -76,4 +76,13 @@ private DynamicObjectLibrary getObjectLibrary() { return objectLibrary; } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadInstanceVariableNode( + name, + receiver.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java b/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java index 487723486763..1b05bd2798e7 100644 --- a/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java +++ b/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java @@ -48,4 +48,13 @@ public Object execute(VirtualFrame frame) { EMPTY_ARGUMENTS)); } + @Override + public RubyNode cloneUninitialized() { + var copy = new RunModuleDefinitionNode( + definitionMethod, + definingModule.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/objects/SelfNode.java b/src/main/java/org/truffleruby/language/objects/SelfNode.java index 4c0e831a26a4..23ce51acab4c 100644 --- a/src/main/java/org/truffleruby/language/objects/SelfNode.java +++ b/src/main/java/org/truffleruby/language/objects/SelfNode.java @@ -14,6 +14,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.string.FrozenStrings; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.locals.ReadFrameSlotNode; import org.truffleruby.language.locals.ReadFrameSlotNodeGen; @@ -47,4 +48,11 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c return FrozenStrings.SELF; } + @Override + public RubyNode cloneUninitialized() { + var copy = new SelfNode(); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java b/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java index 69103ec62338..bbc1764e8781 100644 --- a/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java +++ b/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java @@ -89,4 +89,16 @@ public AssignableNode toAssignableNode() { this.rhs = null; return this; } + + @Override + public RubyNode cloneUninitialized() { + var rhsCopy = (rhs == null) ? null : rhs.cloneUninitialized(); + var copy = new WriteInstanceVariableNode( + name, + receiver.cloneUninitialized(), + rhsCopy); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/objects/classvariables/ReadClassVariableNode.java b/src/main/java/org/truffleruby/language/objects/classvariables/ReadClassVariableNode.java index a83ca9bb3596..dbbab3b58cb5 100644 --- a/src/main/java/org/truffleruby/language/objects/classvariables/ReadClassVariableNode.java +++ b/src/main/java/org/truffleruby/language/objects/classvariables/ReadClassVariableNode.java @@ -71,4 +71,13 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c } } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadClassVariableNode( + lexicalScopeNode.cloneUninitialized(), + name); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java b/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java index b2f7323f6f87..d1785aa15f0f 100644 --- a/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java +++ b/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java @@ -46,7 +46,6 @@ public Object execute(VirtualFrame frame) { return value; } - @Override public void assign(VirtualFrame frame, Object value) { final LexicalScope lexicalScope = (LexicalScope) lexicalScopeNode.execute(frame); @@ -69,4 +68,15 @@ public AssignableNode toAssignableNode() { this.rhs = null; return this; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new WriteClassVariableNode( + lexicalScopeNode.cloneUninitialized(), + name, + rhs.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/supercall/ReadSuperArgumentsNode.java b/src/main/java/org/truffleruby/language/supercall/ReadSuperArgumentsNode.java index 1e2eca83d5b5..6888fc962076 100644 --- a/src/main/java/org/truffleruby/language/supercall/ReadSuperArgumentsNode.java +++ b/src/main/java/org/truffleruby/language/supercall/ReadSuperArgumentsNode.java @@ -59,4 +59,13 @@ private Object[] unsplat(Object[] argumentsObjects) { return unsplatNode.unsplat(argumentsObjects); } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadSuperArgumentsNode( + cloneUninitialized(arguments), + isSplatted); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/supercall/ReadZSuperArgumentsNode.java b/src/main/java/org/truffleruby/language/supercall/ReadZSuperArgumentsNode.java index 4c1c5ab38fa9..00f3b49ab89f 100644 --- a/src/main/java/org/truffleruby/language/supercall/ReadZSuperArgumentsNode.java +++ b/src/main/java/org/truffleruby/language/supercall/ReadZSuperArgumentsNode.java @@ -77,4 +77,13 @@ private Object[] unsplat(RubyArray array) { return unsplatNode.executeToObjectArray(array); } + @Override + public RubyNode cloneUninitialized() { + var copy = new ReadZSuperArgumentsNode( + restArgIndex, + cloneUninitialized(reloadNodes)); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/supercall/SuperCallNode.java b/src/main/java/org/truffleruby/language/supercall/SuperCallNode.java index 32e2aa7af49a..1e500ece38bb 100644 --- a/src/main/java/org/truffleruby/language/supercall/SuperCallNode.java +++ b/src/main/java/org/truffleruby/language/supercall/SuperCallNode.java @@ -94,4 +94,15 @@ private InternalMethod executeLookupSuperMethod(VirtualFrame frame, Object self) return lookupSuperMethodNode.executeLookupSuperMethod(frame, self); } + @Override + public RubyNode cloneUninitialized() { + var copy = new SuperCallNode( + isSplatted, + arguments.cloneUninitialized(), + block.cloneUninitialized(), + descriptor); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/supercall/ZSuperOutsideMethodNode.java b/src/main/java/org/truffleruby/language/supercall/ZSuperOutsideMethodNode.java index cf5af84c4788..4cc060f2618a 100644 --- a/src/main/java/org/truffleruby/language/supercall/ZSuperOutsideMethodNode.java +++ b/src/main/java/org/truffleruby/language/supercall/ZSuperOutsideMethodNode.java @@ -13,6 +13,7 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.core.string.FrozenStrings; import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.arguments.RubyArguments; import org.truffleruby.language.control.RaiseException; import org.truffleruby.language.methods.InternalMethod; @@ -54,4 +55,11 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c } } + @Override + public RubyNode cloneUninitialized() { + var copy = new ZSuperOutsideMethodNode(insideDefineMethod); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/language/yield/YieldExpressionNode.java b/src/main/java/org/truffleruby/language/yield/YieldExpressionNode.java index 2e34d8e6d09a..a0942ca5a72a 100644 --- a/src/main/java/org/truffleruby/language/yield/YieldExpressionNode.java +++ b/src/main/java/org/truffleruby/language/yield/YieldExpressionNode.java @@ -105,4 +105,16 @@ private CallBlockNode getYieldNode() { return yieldNode; } + + @Override + public RubyNode cloneUninitialized() { + var copy = new YieldExpressionNode( + isSplatted, + descriptor, + cloneUninitialized(arguments), + readBlockNode.cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } diff --git a/src/main/java/org/truffleruby/parser/DeadNode.java b/src/main/java/org/truffleruby/parser/DeadNode.java index 0b60c1c9ff3e..c3f8d0a2e732 100644 --- a/src/main/java/org/truffleruby/parser/DeadNode.java +++ b/src/main/java/org/truffleruby/parser/DeadNode.java @@ -13,6 +13,7 @@ import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary; import com.oracle.truffle.api.frame.VirtualFrame; +import org.truffleruby.language.RubyNode; /** Dead nodes are removed wherever they are found during translation. They fill in for some missing nodes when we're * processing the AST. */ @@ -33,4 +34,12 @@ public Object execute(VirtualFrame frame) { private RuntimeException exception() { return new UnsupportedOperationException(reason); } + + @Override + public RubyNode cloneUninitialized() { + var copy = new DeadNode(reason); + copy.copyFlags(this); + return copy; + } + } From e01d7162ade1107b9278306ff904788b37f6ec77 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Mon, 29 Aug 2022 21:10:53 +0300 Subject: [PATCH 06/46] Implement cloneUninitialized() for Root nodes --- .../language/RubyCoreMethodRootNode.java | 14 +++++++++ .../language/RubyEvalRootNode.java | 12 ++++++++ .../language/RubyLambdaRootNode.java | 15 ++++++++++ .../language/RubyMethodRootNode.java | 14 +++++++++ .../language/RubyProcRootNode.java | 30 +++++++++++++++++++ .../language/RubyTopLevelRootNode.java | 14 +++++++++ .../arguments/CheckKeywordArityNode.java | 5 ++++ 7 files changed, 104 insertions(+) diff --git a/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java b/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java index 549e0ad534ea..8ea3a9a84442 100644 --- a/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java @@ -10,6 +10,7 @@ package org.truffleruby.language; import com.oracle.truffle.api.TruffleSafepoint; +import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.control.ReturnID; import org.truffleruby.language.methods.Arity; @@ -55,4 +56,17 @@ public Object execute(VirtualFrame frame) { } } + @Override + protected RootNode cloneUninitialized() { + return new RubyCoreMethodRootNode( + getLanguage(), + getSourceSection(), + getFrameDescriptor(), + getSharedMethodInfo(), + body.cloneUninitialized(), + getSplit(), + returnID, + arityForCheck); + } + } diff --git a/src/main/java/org/truffleruby/language/RubyEvalRootNode.java b/src/main/java/org/truffleruby/language/RubyEvalRootNode.java index e32266fc9265..60985b2311e3 100644 --- a/src/main/java/org/truffleruby/language/RubyEvalRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyEvalRootNode.java @@ -9,6 +9,7 @@ */ package org.truffleruby.language; +import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.control.DynamicReturnException; import org.truffleruby.language.control.LocalReturnException; @@ -82,4 +83,15 @@ public Object execute(VirtualFrame frame) { } } + @Override + protected RootNode cloneUninitialized() { + return new RubyEvalRootNode( + getLanguage(), + getSourceSection(), + getFrameDescriptor(), + getSharedMethodInfo(), + body.cloneUninitialized(), + getSplit(), + returnID); + } } diff --git a/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java b/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java index 3c35234312bd..787dd4b54662 100644 --- a/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java @@ -12,6 +12,7 @@ import com.oracle.truffle.api.CompilerDirectives.CompilationFinal; import com.oracle.truffle.api.RootCallTarget; import com.oracle.truffle.api.TruffleSafepoint; +import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.control.BreakException; import org.truffleruby.language.control.BreakID; @@ -150,4 +151,18 @@ public Object execute(VirtualFrame frame) { } } + @Override + protected RootNode cloneUninitialized() { + return new RubyLambdaRootNode( + getLanguage(), + getSourceSection(), + getFrameDescriptor(), + getSharedMethodInfo(), + body.cloneUninitialized(), + getSplit(), + returnID, + breakID, + arityForCheck); + } + } diff --git a/src/main/java/org/truffleruby/language/RubyMethodRootNode.java b/src/main/java/org/truffleruby/language/RubyMethodRootNode.java index 4cce15903e64..911a82acb0d6 100644 --- a/src/main/java/org/truffleruby/language/RubyMethodRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyMethodRootNode.java @@ -13,6 +13,7 @@ import com.oracle.truffle.api.CompilerDirectives; import com.oracle.truffle.api.CompilerDirectives.CompilationFinal; import com.oracle.truffle.api.TruffleSafepoint; +import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.control.DynamicReturnException; import org.truffleruby.language.control.LocalReturnException; @@ -100,4 +101,17 @@ public Object execute(VirtualFrame frame) { } } + @Override + protected RootNode cloneUninitialized() { + return new RubyMethodRootNode( + getLanguage(), + getSourceSection(), + getFrameDescriptor(), + getSharedMethodInfo(), + body.cloneUninitialized(), + getSplit(), + returnID, + arityForCheck); + } + } diff --git a/src/main/java/org/truffleruby/language/RubyProcRootNode.java b/src/main/java/org/truffleruby/language/RubyProcRootNode.java index 4f63564027a7..e13e821b8a5e 100644 --- a/src/main/java/org/truffleruby/language/RubyProcRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyProcRootNode.java @@ -11,6 +11,7 @@ import com.oracle.truffle.api.CompilerDirectives.CompilationFinal; import com.oracle.truffle.api.TruffleSafepoint; +import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.arguments.CheckKeywordArityNode; import org.truffleruby.language.control.NextException; @@ -50,6 +51,19 @@ public RubyProcRootNode( : null; } + private RubyProcRootNode( + RubyLanguage language, + SourceSection sourceSection, + FrameDescriptor frameDescriptor, + SharedMethodInfo sharedMethodInfo, + RubyNode body, + Split split, + ReturnID returnID, + CheckKeywordArityNode checkKeywordArityNode) { + super(language, sourceSection, frameDescriptor, sharedMethodInfo, body, split, returnID); + this.checkKeywordArityNode = checkKeywordArityNode; + } + @Override public Object execute(VirtualFrame frame) { TruffleSafepoint.poll(this); @@ -95,4 +109,20 @@ public Object execute(VirtualFrame frame) { } } + @Override + protected RootNode cloneUninitialized() { + // CheckKeywordArityNode uses branch profiling, so it should be copied without gathered data + var checkKeywordArityNodeCopy = (checkKeywordArityNode == null) + ? null + : checkKeywordArityNode.cloneUninitialized(); + return new RubyProcRootNode( + getLanguage(), + getSourceSection(), + getFrameDescriptor(), + getSharedMethodInfo(), + body.cloneUninitialized(), + getSplit(), + returnID, + checkKeywordArityNodeCopy); + } } diff --git a/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java b/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java index ea778a0f4ff8..51bf93017b58 100644 --- a/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java @@ -9,6 +9,7 @@ */ package org.truffleruby.language; +import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.control.NextException; import org.truffleruby.language.control.ReturnID; @@ -52,4 +53,17 @@ public Object execute(VirtualFrame frame) { } } + @Override + protected RootNode cloneUninitialized() { + return new RubyTopLevelRootNode( + getLanguage(), + getSourceSection(), + getFrameDescriptor(), + getSharedMethodInfo(), + body.cloneUninitialized(), + getSplit(), + returnID, + arityForCheck); + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/CheckKeywordArityNode.java b/src/main/java/org/truffleruby/language/arguments/CheckKeywordArityNode.java index 8d4fc394740c..9ee8523eb4dc 100644 --- a/src/main/java/org/truffleruby/language/arguments/CheckKeywordArityNode.java +++ b/src/main/java/org/truffleruby/language/arguments/CheckKeywordArityNode.java @@ -130,4 +130,9 @@ static RubySymbol[] keywordsAsSymbols(RubyLanguage language, Arity arity) { } return symbols; } + + public CheckKeywordArityNode cloneUninitialized() { + return new CheckKeywordArityNode(arity); + } + } From 97b7629d797311b521b9358e2a9f2f8cbd54c522 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Tue, 30 Aug 2022 20:22:14 +0300 Subject: [PATCH 07/46] Switch from CoreMethodNode to CoreMethodArrayArgumentsNode when it's possible --- .../truffleruby/builtins/UnaryCoreMethodNode.java | 8 +------- .../org/truffleruby/core/array/ArrayNodes.java | 15 ++++----------- .../org/truffleruby/core/kernel/KernelNodes.java | 4 +--- 3 files changed, 6 insertions(+), 21 deletions(-) diff --git a/src/main/java/org/truffleruby/builtins/UnaryCoreMethodNode.java b/src/main/java/org/truffleruby/builtins/UnaryCoreMethodNode.java index 115c9ac096bb..3de5a0c79404 100644 --- a/src/main/java/org/truffleruby/builtins/UnaryCoreMethodNode.java +++ b/src/main/java/org/truffleruby/builtins/UnaryCoreMethodNode.java @@ -9,16 +9,10 @@ */ package org.truffleruby.builtins; -import org.truffleruby.language.RubyNode; -import com.oracle.truffle.api.dsl.NodeChild; - -@NodeChild(value = "operand", type = RubyNode.class) -public abstract class UnaryCoreMethodNode extends CoreMethodNode { +public abstract class UnaryCoreMethodNode extends CoreMethodArrayArgumentsNode { public UnaryCoreMethodNode() { } - public abstract RubyNode getOperand(); - } diff --git a/src/main/java/org/truffleruby/core/array/ArrayNodes.java b/src/main/java/org/truffleruby/core/array/ArrayNodes.java index 95a1d00f2c7f..c3b4dcc910d1 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayNodes.java +++ b/src/main/java/org/truffleruby/core/array/ArrayNodes.java @@ -216,14 +216,12 @@ protected Object fallback(RubyArray array, Object count) { } @CoreMethod(names = { "at" }, required = 1, lowerFixnum = 1) - @NodeChild(value = "array", type = RubyNode.class) - @NodeChild(value = "index", type = RubyNode.class) - public abstract static class AtNode extends CoreMethodNode { + public abstract static class AtNode extends CoreMethodArrayArgumentsNode { abstract Object executeAt(RubyArray array, Object index); public static AtNode create() { - return ArrayNodesFactory.AtNodeFactory.create(null, null); + return ArrayNodesFactory.AtNodeFactory.create(new RubyNode[]{ null, null }); } @Specialization @@ -585,10 +583,7 @@ protected Object compactObjects(RubyArray array, @CoreMethod(names = "concat", optional = 1, rest = true, raiseIfFrozenSelf = true) @ImportStatic(ArrayGuards.class) - @NodeChild(value = "array", type = RubyNode.class) - @NodeChild(value = "first", type = RubyNode.class) - @NodeChild(value = "rest", type = RubyNode.class) - public abstract static class ConcatNode extends CoreMethodNode { + public abstract static class ConcatNode extends CoreMethodArrayArgumentsNode { @Specialization(guards = "rest.length == 0") protected RubyArray concatZero(RubyArray array, NotProvided first, Object[] rest) { @@ -2073,11 +2068,9 @@ protected Object select(RubyArray array, RubyProc block, } @CoreMethod(names = "shift", raiseIfFrozenSelf = true, optional = 1, lowerFixnum = 1) - @NodeChild(value = "array", type = RubyNode.class) - @NodeChild(value = "n", type = RubyNode.class) @ImportStatic(ArrayGuards.class) @ReportPolymorphism - public abstract static class ShiftNode extends CoreMethodNode { + public abstract static class ShiftNode extends CoreMethodArrayArgumentsNode { public abstract Object executeShift(RubyArray array, Object n); diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java index 2da10726321c..8c2c764fbc80 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java @@ -1002,9 +1002,7 @@ protected boolean instanceOf(Object self, RubyModule module) { } @CoreMethod(names = "instance_variable_defined?", required = 1) - @NodeChild(value = "object", type = RubyNode.class) - @NodeChild(value = "name", type = RubyNode.class) - public abstract static class InstanceVariableDefinedNode extends CoreMethodNode { + public abstract static class InstanceVariableDefinedNode extends CoreMethodArrayArgumentsNode { @Specialization protected boolean isInstanceVariableDefined(RubyDynamicObject object, Object name, From 1bd5a3aaf6f58a4620d3bb1286b7b2af69cef1ca Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Wed, 31 Aug 2022 17:16:49 +0300 Subject: [PATCH 08/46] Implement cloneUninitialized() for CoreMethod ancestors --- .../java/org/truffleruby/cext/CExtNodes.java | 85 ++- .../truffleruby/core/array/ArrayNodes.java | 136 +++- .../core/cast/BooleanCastWithDefaultNode.java | 2 +- .../core/cast/NameToJavaStringNode.java | 2 +- .../org/truffleruby/core/cast/ToAryNode.java | 2 +- .../org/truffleruby/core/cast/ToIntNode.java | 2 +- .../org/truffleruby/core/cast/ToLongNode.java | 2 +- .../org/truffleruby/core/cast/ToPathNode.java | 2 +- .../truffleruby/core/cast/ToSymbolNode.java | 2 +- .../core/encoding/EncodingConverterNodes.java | 29 +- .../truffleruby/core/kernel/KernelNodes.java | 190 ++++- .../core/kernel/TruffleKernelNodes.java | 27 +- .../truffleruby/core/module/ModuleNodes.java | 655 ++++++++++++++++-- .../core/numeric/FixnumLowerNode.java | 2 +- .../truffleruby/core/queue/QueueNodes.java | 27 +- .../core/queue/SizedQueueNodes.java | 59 +- .../truffleruby/core/range/RangeNodes.java | 39 +- .../truffleruby/core/string/StringNodes.java | 198 +++++- .../org/truffleruby/interop/InteropNodes.java | 398 +++++++++-- .../interop/SymbolToByteOrderNode.java | 2 +- .../truffleruby/interop/ToJavaStringNode.java | 2 +- .../interop/ToJavaStringWithDefaultNode.java | 2 +- .../stdlib/readline/ReadlineHistoryNodes.java | 33 +- .../stdlib/readline/ReadlineNodes.java | 83 ++- 24 files changed, 1744 insertions(+), 237 deletions(-) diff --git a/src/main/java/org/truffleruby/cext/CExtNodes.java b/src/main/java/org/truffleruby/cext/CExtNodes.java index fae0fef58d1d..b453dfdc6e05 100644 --- a/src/main/java/org/truffleruby/cext/CExtNodes.java +++ b/src/main/java/org/truffleruby/cext/CExtNodes.java @@ -975,64 +975,129 @@ protected ImmutableRubyString rbStrUnlockTmpImmutable(ImmutableRubyString string } @CoreMethod(names = "rb_const_get", onSingleton = true, required = 2) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyNode.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyNode.class) public abstract static class RbConstGetNode extends CoreMethodNode { @Child private LookupConstantNode lookupConstantNode = LookupConstantNode.create(true, true); @Child private GetConstantNode getConstantNode = GetConstantNode.create(); - @CreateCast("name") + @CreateCast("nameNode") protected RubyNode coerceToString(RubyNode name) { return ToJavaStringNode.create(name); } + abstract RubyNode getModuleNode(); + + abstract RubyNode getNameNode(); + + public static RbConstGetNode create(RubyNode module, RubyNode name) { + return CExtNodesFactory.RbConstGetNodeFactory.create(module, name); + } + @Specialization protected Object rbConstGet(RubyModule module, String name) { return getConstantNode .lookupAndResolveConstant(LexicalScope.IGNORE, module, name, false, lookupConstantNode); } + private RubyNode getNameNodeBeforeCasting() { + return ((ToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "rb_const_get_from", onSingleton = true, required = 2) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyNode.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyNode.class) public abstract static class RbConstGetFromNode extends CoreMethodNode { @Child private LookupConstantNode lookupConstantNode = LookupConstantNode.create(true, false); @Child private GetConstantNode getConstantNode = GetConstantNode.create(); - @CreateCast("name") + @CreateCast("nameNode") protected RubyNode coerceToString(RubyNode name) { return ToJavaStringNode.create(name); } + public static RbConstGetFromNode create(RubyNode moduleNode, RubyNode nameNode) { + return CExtNodesFactory.RbConstGetFromNodeFactory.create(moduleNode, nameNode); + } + + abstract RubyNode getModuleNode(); + + abstract RubyNode getNameNode(); + @Specialization protected Object rbConstGetFrom(RubyModule module, String name) { return getConstantNode .lookupAndResolveConstant(LexicalScope.IGNORE, module, name, false, lookupConstantNode); } + private RubyNode getNameNodeBeforeCasting() { + return ((ToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "rb_const_set", onSingleton = true, required = 3) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyNode.class) - @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyNode.class) + @NodeChild(value = "valueNode", type = RubyNode.class) public abstract static class RbConstSetNode extends CoreMethodNode { - @CreateCast("name") + @CreateCast("nameNode") protected RubyNode coerceToString(RubyNode name) { return ToJavaStringNode.create(name); } + public static RbConstSetNode create(RubyNode moduleNode, RubyNode nameNode, RubyNode valueNode) { + return CExtNodesFactory.RbConstSetNodeFactory.create(moduleNode, nameNode, valueNode); + } + + abstract RubyNode getModuleNode(); + + abstract RubyNode getNameNode(); + + abstract RubyNode getValueNode(); + @Specialization protected Object rbConstSet(RubyModule module, String name, Object value, @Cached ConstSetUncheckedNode constSetUncheckedNode) { return constSetUncheckedNode.execute(module, name, value); } + private RubyNode getNameNodeBeforeCasting() { + return ((ToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } } @CoreMethod(names = "cext_module_function", onSingleton = true, required = 2) diff --git a/src/main/java/org/truffleruby/core/array/ArrayNodes.java b/src/main/java/org/truffleruby/core/array/ArrayNodes.java index c3b4dcc910d1..ce353f4fa487 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayNodes.java +++ b/src/main/java/org/truffleruby/core/array/ArrayNodes.java @@ -123,13 +123,21 @@ protected RubyArray allocate(RubyClass rubyClass) { } @CoreMethod(names = "+", required = 1) - @NodeChild(value = "a", type = RubyNode.class) - @NodeChild(value = "b", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "aNode", type = RubyNode.class) + @NodeChild(value = "bNode", type = RubyBaseNodeWithExecute.class) @ImportStatic(ArrayGuards.class) @ReportPolymorphism public abstract static class AddNode extends CoreMethodNode { - @CreateCast("b") + public static AddNode create(RubyNode a, RubyBaseNodeWithExecute b) { + return ArrayNodesFactory.AddNodeFactory.create(a, b); + } + + abstract RubyNode getANode(); + + abstract RubyBaseNodeWithExecute getBNode(); + + @CreateCast("bNode") protected RubyBaseNodeWithExecute coerceOtherToAry(RubyBaseNodeWithExecute other) { return ToAryNodeGen.create(other); } @@ -152,6 +160,19 @@ protected RubyArray addGeneralize(RubyArray a, RubyArray b, return createArray(newStore, combinedSize); } + private RubyBaseNodeWithExecute getBNodeBeforeCasting() { + return ((ToAryNode) getBNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getANode().cloneUninitialized(), + getBNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @Primitive(name = "array_mul", lowerFixnum = 1) @@ -750,13 +771,21 @@ public void checkFrozen(Object object) { } @CoreMethod(names = "delete_at", required = 1, raiseIfFrozenSelf = true, lowerFixnum = 1) - @NodeChild(value = "array", type = RubyNode.class) - @NodeChild(value = "index", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "arrayNode", type = RubyNode.class) + @NodeChild(value = "indexNode", type = RubyBaseNodeWithExecute.class) @ImportStatic(ArrayGuards.class) @ReportPolymorphism public abstract static class DeleteAtNode extends CoreMethodNode { - @CreateCast("index") + public static DeleteAtNode create(RubyNode array, RubyBaseNodeWithExecute index) { + return ArrayNodesFactory.DeleteAtNodeFactory.create(array, index); + } + + abstract RubyNode getArrayNode(); + + abstract RubyBaseNodeWithExecute getIndexNode(); + + @CreateCast("indexNode") protected ToIntNode coerceOtherToInt(RubyBaseNodeWithExecute index) { return ToIntNode.create(index); } @@ -813,6 +842,20 @@ protected Object deleteAtCopying(RubyArray array, int index, return value; } } + + private RubyBaseNodeWithExecute getIndexNodeBeforeCasting() { + return ((ToIntNode) getIndexNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getArrayNode().cloneUninitialized(), + getIndexNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "each", needsBlock = true, enumeratorSize = "size") @@ -1300,12 +1343,20 @@ protected int toInt(Object value) { } @CoreMethod(names = "initialize_copy", required = 1, raiseIfFrozenSelf = true) - @NodeChild(value = "self", type = RubyNode.class) - @NodeChild(value = "from", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "selfNode", type = RubyNode.class) + @NodeChild(value = "fromNode", type = RubyBaseNodeWithExecute.class) @ImportStatic(ArrayGuards.class) public abstract static class InitializeCopyNode extends CoreMethodNode { - @CreateCast("from") + public static InitializeCopyNode create(RubyNode self, RubyBaseNodeWithExecute from) { + return ArrayNodesFactory.InitializeCopyNodeFactory.create(self, from); + } + + abstract RubyNode getSelfNode(); + + abstract RubyBaseNodeWithExecute getFromNode(); + + @CreateCast("fromNode") protected RubyBaseNodeWithExecute coerceOtherToAry(RubyBaseNodeWithExecute other) { return ToAryNodeGen.create(other); } @@ -1320,6 +1371,19 @@ protected RubyArray initializeCopy(RubyArray self, RubyArray from, return self; } + private RubyBaseNodeWithExecute getFromNodeBeforeCasting() { + return ((ToAryNode) getFromNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getSelfNode().cloneUninitialized(), + getFromNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @Primitive(name = "array_inject") @@ -1519,9 +1583,9 @@ public void accept(RubyArray array, RubyProc block, Object element, int index) { } - @NodeChild(value = "array", type = RubyNode.class) - @NodeChild(value = "format", type = RubyBaseNodeWithExecute.class) @CoreMethod(names = "pack", required = 1) + @NodeChild(value = "arrayNode", type = RubyNode.class) + @NodeChild(value = "formatNode", type = RubyBaseNodeWithExecute.class) @ReportPolymorphism public abstract static class PackNode extends CoreMethodNode { @@ -1531,7 +1595,15 @@ public abstract static class PackNode extends CoreMethodNode { private final BranchProfile exceptionProfile = BranchProfile.create(); private final ConditionProfile resizeProfile = ConditionProfile.create(); - @CreateCast("format") + public static PackNode create(RubyNode array, RubyBaseNodeWithExecute format) { + return ArrayNodesFactory.PackNodeFactory.create(array, format); + } + + abstract RubyNode getArrayNode(); + + abstract RubyBaseNodeWithExecute getFormatNode(); + + @CreateCast("formatNode") protected ToStrNode coerceFormat(RubyBaseNodeWithExecute format) { return ToStrNodeGen.create(format); } @@ -1616,6 +1688,19 @@ protected int getCacheLimit() { return getLanguage().options.PACK_CACHE; } + private RubyBaseNodeWithExecute getFormatNodeBeforeCasting() { + return ((ToStrNode) getFormatNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getArrayNode().cloneUninitialized(), + getFormatNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "pop", raiseIfFrozenSelf = true, optional = 1, lowerFixnum = 1) @@ -1866,8 +1951,8 @@ private Object rejectInPlaceInternal(RubyArray array, RubyProc block, ArrayStore } @CoreMethod(names = "replace", required = 1, raiseIfFrozenSelf = true) - @NodeChild(value = "array", type = RubyNode.class) - @NodeChild(value = "other", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "arrayNode", type = RubyNode.class) + @NodeChild(value = "otherNode", type = RubyBaseNodeWithExecute.class) @ImportStatic(ArrayGuards.class) @ReportPolymorphism public abstract static class ReplaceNode extends CoreMethodNode { @@ -1876,9 +1961,17 @@ public static ReplaceNode create() { return ReplaceNodeFactory.create(null, null); } + public static ReplaceNode create(RubyNode array, RubyBaseNodeWithExecute other) { + return ReplaceNodeFactory.create(array, other); + } + public abstract RubyArray executeReplace(RubyArray array, RubyArray other); - @CreateCast("other") + abstract RubyNode getArrayNode(); + + abstract RubyBaseNodeWithExecute getOtherNode(); + + @CreateCast("otherNode") protected RubyBaseNodeWithExecute coerceOtherToAry(RubyBaseNodeWithExecute index) { return ToAryNodeGen.create(index); } @@ -1898,6 +1991,19 @@ protected RubyArray replace(RubyArray array, RubyArray other, return array; } + private RubyBaseNodeWithExecute getOtherNodeBeforeCasting() { + return ((ToAryNode) getOtherNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getArrayNode().cloneUninitialized(), + getOtherNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @Primitive(name = "array_rotate", lowerFixnum = 1) diff --git a/src/main/java/org/truffleruby/core/cast/BooleanCastWithDefaultNode.java b/src/main/java/org/truffleruby/core/cast/BooleanCastWithDefaultNode.java index f70aa76ab5e3..42e26ab615fd 100644 --- a/src/main/java/org/truffleruby/core/cast/BooleanCastWithDefaultNode.java +++ b/src/main/java/org/truffleruby/core/cast/BooleanCastWithDefaultNode.java @@ -31,7 +31,7 @@ public BooleanCastWithDefaultNode(boolean defaultValue) { this.defaultValue = defaultValue; } - abstract RubyBaseNodeWithExecute getValueNode(); + public abstract RubyBaseNodeWithExecute getValueNode(); @Specialization protected boolean doDefault(NotProvided value) { diff --git a/src/main/java/org/truffleruby/core/cast/NameToJavaStringNode.java b/src/main/java/org/truffleruby/core/cast/NameToJavaStringNode.java index a06a88b8c71f..a90fdaca33f1 100644 --- a/src/main/java/org/truffleruby/core/cast/NameToJavaStringNode.java +++ b/src/main/java/org/truffleruby/core/cast/NameToJavaStringNode.java @@ -44,7 +44,7 @@ public static NameToJavaStringNode getUncached() { public abstract String execute(Object name); - abstract RubyBaseNodeWithExecute getValueNode(); + public abstract RubyBaseNodeWithExecute getValueNode(); @Specialization(guards = "strings.isRubyString(value)", limit = "1") protected String stringNameToJavaString(Object value, diff --git a/src/main/java/org/truffleruby/core/cast/ToAryNode.java b/src/main/java/org/truffleruby/core/cast/ToAryNode.java index 2f3fd7e3ea4f..000c572c1295 100644 --- a/src/main/java/org/truffleruby/core/cast/ToAryNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToAryNode.java @@ -32,7 +32,7 @@ public static ToAryNode create(RubyBaseNodeWithExecute child) { public abstract RubyArray executeToAry(Object object); - abstract RubyBaseNodeWithExecute getChildNode(); + public abstract RubyBaseNodeWithExecute getChildNode(); @Specialization protected RubyArray coerceRubyArray(RubyArray array) { diff --git a/src/main/java/org/truffleruby/core/cast/ToIntNode.java b/src/main/java/org/truffleruby/core/cast/ToIntNode.java index 75ae9a595178..ad477f8a15b5 100644 --- a/src/main/java/org/truffleruby/core/cast/ToIntNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToIntNode.java @@ -60,7 +60,7 @@ public static ToIntNode create(RubyBaseNodeWithExecute child) { public abstract int execute(Object object); - abstract RubyBaseNodeWithExecute getChildNode(); + public abstract RubyBaseNodeWithExecute getChildNode(); @Specialization protected int coerceInt(int value) { diff --git a/src/main/java/org/truffleruby/core/cast/ToLongNode.java b/src/main/java/org/truffleruby/core/cast/ToLongNode.java index 8bcb8a50b466..7391d5513415 100644 --- a/src/main/java/org/truffleruby/core/cast/ToLongNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToLongNode.java @@ -37,7 +37,7 @@ public static ToLongNode create(RubyBaseNodeWithExecute child) { public abstract long execute(Object object); - abstract RubyBaseNodeWithExecute getChildNode(); + public abstract RubyBaseNodeWithExecute getChildNode(); @Specialization protected long coerceInt(int value) { diff --git a/src/main/java/org/truffleruby/core/cast/ToPathNode.java b/src/main/java/org/truffleruby/core/cast/ToPathNode.java index 083f8e079763..5b51b3045e9a 100644 --- a/src/main/java/org/truffleruby/core/cast/ToPathNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToPathNode.java @@ -25,7 +25,7 @@ public static ToPathNode create(RubyBaseNodeWithExecute child) { return ToPathNodeGen.create(child); } - abstract RubyBaseNodeWithExecute getChildNode(); + public abstract RubyBaseNodeWithExecute getChildNode(); @Specialization protected RubyString coerceRubyString(RubyString path) { diff --git a/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java b/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java index 6e84689458a2..d044207e8aa0 100644 --- a/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java @@ -43,7 +43,7 @@ public static ToSymbolNode getUncached() { public abstract RubySymbol execute(Object object); - abstract RubyBaseNodeWithExecute getValueNode(); + public abstract RubyBaseNodeWithExecute getValueNode(); @Specialization protected RubySymbol symbol(RubySymbol symbol) { diff --git a/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java b/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java index 2877aa9ffc70..dbe00aac66eb 100644 --- a/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java +++ b/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java @@ -443,15 +443,25 @@ protected RubyString getReplacement(RubyEncodingConverter encodingConverter) { } @CoreMethod(names = "replacement=", required = 1) - @NodeChild(value = "encodingConverter", type = RubyNode.class) - @NodeChild(value = "replacement", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "encodingConverterNode", type = RubyNode.class) + @NodeChild(value = "replacementNode", type = RubyBaseNodeWithExecute.class) public abstract static class EncodingConverterSetReplacementNode extends CoreMethodNode { - @CreateCast("replacement") + @CreateCast("replacementNode") protected ToStrNode coerceReplacementToString(RubyBaseNodeWithExecute replacement) { return ToStrNodeGen.create(replacement); } + abstract RubyNode getEncodingConverterNode(); + + abstract RubyBaseNodeWithExecute getReplacementNode(); + + public static EncodingConverterSetReplacementNode create(RubyNode encodingConverter, + RubyBaseNodeWithExecute replacement) { + return EncodingConverterNodesFactory.EncodingConverterSetReplacementNodeFactory.create(encodingConverter, + replacement); + } + @Specialization(guards = "libReplacement.isRubyString(replacement)", limit = "1") protected Object setReplacement(RubyEncodingConverter encodingConverter, Object replacement, @Cached BranchProfile errorProfile, @@ -479,6 +489,19 @@ private int setReplacement(EConv ec, byte[] bytes, int offset, int len, byte[] e return ec.setReplacement(bytes, offset, len, encodingName); } + private RubyBaseNodeWithExecute getReplacementNodeBeforeCasting() { + return ((ToStrNode) getReplacementNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getEncodingConverterNode().cloneUninitialized(), + getReplacementNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } } diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java index 8c2c764fbc80..3917240a31f6 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java @@ -1253,11 +1253,19 @@ 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) + @NodeChild(value = "objectNode", type = RubyNode.class) + @NodeChild(value = "regularNode", type = RubyBaseNodeWithExecute.class) public abstract static class MethodsNode extends CoreMethodNode { - @CreateCast("regular") + public static MethodsNode create(RubyNode object, RubyBaseNodeWithExecute regular) { + return KernelNodesFactory.MethodsNodeFactory.create(object, regular); + } + + abstract RubyNode getObjectNode(); + + abstract RubyBaseNodeWithExecute getRegularNode(); + + @CreateCast("regularNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute regular) { return BooleanCastWithDefaultNode.create(true, regular); } @@ -1280,6 +1288,19 @@ protected RubyArray methodsSingleton(VirtualFrame frame, Object self, boolean re return singletonMethodsNode.executeSingletonMethods(frame, self, false); } + private RubyBaseNodeWithExecute getRegularNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getRegularNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getObjectNode().cloneUninitialized(), + getRegularNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "nil?", needsSelf = false) @@ -1312,13 +1333,21 @@ private void print(Object inspected) { } @CoreMethod(names = "private_methods", optional = 1) - @NodeChild(value = "object", type = RubyNode.class) - @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "objectNode", type = RubyNode.class) + @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) public abstract static class PrivateMethodsNode extends CoreMethodNode { @Child private MetaClassNode metaClassNode = MetaClassNode.create(); - @CreateCast("includeAncestors") + public static PrivateMethodsNode create(RubyNode object, RubyBaseNodeWithExecute includeAncestors) { + return KernelNodesFactory.PrivateMethodsNodeFactory.create(object, includeAncestors); + } + + abstract RubyNode getObjectNode(); + + abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); + + @CreateCast("includeAncestorsNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -1334,6 +1363,19 @@ protected RubyArray privateMethods(Object self, boolean includeAncestors) { return createArray(objects); } + private RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getObjectNode().cloneUninitialized(), + getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "proc", isModuleFunction = true, needsBlock = true, split = Split.HEURISTIC) @@ -1348,13 +1390,21 @@ protected RubyProc proc(VirtualFrame frame, Object maybeBlock, } @CoreMethod(names = "protected_methods", optional = 1) - @NodeChild(value = "object", type = RubyNode.class) - @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "objectNode", type = RubyNode.class) + @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) public abstract static class ProtectedMethodsNode extends CoreMethodNode { @Child private MetaClassNode metaClassNode = MetaClassNode.create(); - @CreateCast("includeAncestors") + public static ProtectedMethodsNode create(RubyNode object, RubyBaseNodeWithExecute includeAncestors) { + return KernelNodesFactory.ProtectedMethodsNodeFactory.create(object, includeAncestors); + } + + abstract RubyNode getObjectNode(); + + abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); + + @CreateCast("includeAncestorsNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -1370,6 +1420,19 @@ protected RubyArray protectedMethods(Object self, boolean includeAncestors) { return createArray(objects); } + private RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getObjectNode().cloneUninitialized(), + getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @GenerateUncached @@ -1388,13 +1451,21 @@ protected RubyMethod method(Frame callerFrame, Object self, Object[] rubyArgs, R } @CoreMethod(names = "public_methods", optional = 1) - @NodeChild(value = "object", type = RubyNode.class) - @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "objectNode", type = RubyNode.class) + @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) public abstract static class PublicMethodsNode extends CoreMethodNode { @Child private MetaClassNode metaClassNode = MetaClassNode.create(); - @CreateCast("includeAncestors") + public static PublicMethodsNode create(RubyNode object, RubyBaseNodeWithExecute includeAncestors) { + return KernelNodesFactory.PublicMethodsNodeFactory.create(object, includeAncestors); + } + + abstract RubyNode getObjectNode(); + + abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); + + @CreateCast("includeAncestorsNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -1410,6 +1481,19 @@ protected RubyArray publicMethods(Object self, boolean includeAncestors) { return createArray(objects); } + private RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getObjectNode().cloneUninitialized(), + getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @GenerateUncached @@ -1525,13 +1609,21 @@ protected RubyClass singletonClass(Object self) { } @CoreMethod(names = "singleton_method", required = 1) - @NodeChild(value = "object", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "objectNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) public abstract static class SingletonMethodNode extends CoreMethodNode { @Child private MetaClassNode metaClassNode = MetaClassNode.create(); - @CreateCast("name") + public static SingletonMethodNode create(RubyNode object, RubyBaseNodeWithExecute name) { + return KernelNodesFactory.SingletonMethodNodeFactory.create(object, name); + } + + abstract RubyNode getObjectNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -1562,20 +1654,42 @@ protected RubyMethod singletonMethod(Object self, String name, coreExceptions().nameErrorUndefinedSingletonMethod(name, self, this)); } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getObjectNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "singleton_methods", optional = 1) - @NodeChild(value = "object", type = RubyNode.class) - @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "objectNode", type = RubyNode.class) + @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) public abstract static class SingletonMethodsNode extends CoreMethodNode { public static SingletonMethodsNode create() { return SingletonMethodsNodeFactory.create(null, null); } + public static SingletonMethodsNode create(RubyNode object, RubyBaseNodeWithExecute includeAncestors) { + return SingletonMethodsNodeFactory.create(object, includeAncestors); + } + public abstract RubyArray executeSingletonMethods(VirtualFrame frame, Object self, boolean includeAncestors); - @CreateCast("includeAncestors") + + abstract RubyNode getObjectNode(); + + abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); + + @CreateCast("includeAncestorsNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -1596,6 +1710,19 @@ protected RubyArray singletonMethods(Object self, boolean includeAncestors, return createArray(objects); } + private RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getObjectNode().cloneUninitialized(), + getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @Primitive(name = "singleton_methods?") @@ -1661,8 +1788,8 @@ public static long sleepFor(RubyContext context, RubyThread thread, long duratio @CoreMethod(names = { "format", "sprintf" }, isModuleFunction = true, rest = true, required = 1) @ReportPolymorphism - @NodeChild(value = "format", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "arguments", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "formatNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "argumentsNode", type = RubyBaseNodeWithExecute.class) public abstract static class SprintfNode extends CoreMethodNode { @Child private TruffleString.FromByteArrayNode fromByteArrayNode; @@ -1672,7 +1799,15 @@ public abstract static class SprintfNode extends CoreMethodNode { private final BranchProfile exceptionProfile = BranchProfile.create(); private final ConditionProfile resizeProfile = ConditionProfile.create(); - @CreateCast("format") + public static SprintfNode create(RubyBaseNodeWithExecute format, RubyBaseNodeWithExecute arguments) { + return KernelNodesFactory.SprintfNodeFactory.create(format, arguments); + } + + abstract RubyBaseNodeWithExecute getFormatNode(); + + abstract RubyBaseNodeWithExecute getArgumentsNode(); + + @CreateCast("formatNode") protected ToStrNode coerceFormatToString(RubyBaseNodeWithExecute format) { return ToStrNodeGen.create(format); } @@ -1755,6 +1890,19 @@ protected boolean isDebug(VirtualFrame frame) { return readDebugGlobalNode.execute(frame); } + private RubyBaseNodeWithExecute getFormatNodeBeforeCasting() { + return ((ToStrNode) getFormatNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getFormatNodeBeforeCasting().cloneUninitialized(), + getArgumentsNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "global_variables", isModuleFunction = true) diff --git a/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java b/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java index 324cbfd25d90..7bbb48df9580 100644 --- a/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java @@ -84,16 +84,24 @@ protected Object atExit(boolean always, RubyProc block) { } } - @NodeChild(value = "file", type = RubyNode.class) - @NodeChild(value = "wrap", type = RubyBaseNodeWithExecute.class) @CoreMethod(names = "load", onSingleton = true, required = 1, optional = 1) + @NodeChild(value = "fileNode", type = RubyNode.class) + @NodeChild(value = "wrapNode", type = RubyBaseNodeWithExecute.class) public abstract static class LoadNode extends CoreMethodNode { - @CreateCast("wrap") + @CreateCast("wrapNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(false, inherit); } + abstract RubyNode getFileNode(); + + abstract RubyBaseNodeWithExecute getWrapNode(); + + public static LoadNode create(RubyNode file, RubyBaseNodeWithExecute wrap) { + return TruffleKernelNodesFactory.LoadNodeFactory.create(file, wrap); + } + @TruffleBoundary @Specialization(guards = "strings.isRubyString(file)", limit = "1") protected boolean load(Object file, boolean wrap, @@ -150,6 +158,19 @@ protected boolean load(Object file, boolean wrap, return true; } + private RubyBaseNodeWithExecute getWrapNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getWrapNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getFileNode().cloneUninitialized(), + getWrapNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } // Only used internally with a constant literal name, does not trigger hooks diff --git a/src/main/java/org/truffleruby/core/module/ModuleNodes.java b/src/main/java/org/truffleruby/core/module/ModuleNodes.java index 2d367817f58b..ce2229b21d0c 100644 --- a/src/main/java/org/truffleruby/core/module/ModuleNodes.java +++ b/src/main/java/org/truffleruby/core/module/ModuleNodes.java @@ -47,6 +47,7 @@ import org.truffleruby.core.cast.BooleanCastWithDefaultNode; import org.truffleruby.core.cast.NameToJavaStringNode; import org.truffleruby.core.cast.ToIntNode; +import org.truffleruby.core.cast.ToPathNode; import org.truffleruby.core.cast.ToPathNodeGen; import org.truffleruby.core.cast.ToStrNode; import org.truffleruby.core.cast.ToStringOrSymbolNodeGen; @@ -325,17 +326,28 @@ protected Object compareOther(RubyModule self, Object other) { } @CoreMethod(names = "alias_method", required = 2, raiseIfFrozenSelf = true, split = Split.NEVER) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "newName", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "oldName", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "newNameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "oldNameNode", type = RubyBaseNodeWithExecute.class) public abstract static class AliasMethodNode extends CoreMethodNode { - @CreateCast("newName") + public static AliasMethodNode create(RubyNode module, RubyBaseNodeWithExecute newName, + RubyBaseNodeWithExecute oldName) { + return ModuleNodesFactory.AliasMethodNodeFactory.create(module, newName, oldName); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNewNameNode(); + + abstract RubyBaseNodeWithExecute getOldNameNode(); + + @CreateCast("newNameNode") protected RubyBaseNodeWithExecute coerceNewNameToSymbol(RubyBaseNodeWithExecute newName) { return ToSymbolNode.create(newName); } - @CreateCast("oldName") + @CreateCast("oldNameNode") protected RubyBaseNodeWithExecute coerceOldNameToSymbol(RubyBaseNodeWithExecute oldName) { return ToSymbolNode.create(oldName); } @@ -359,6 +371,24 @@ protected RubySymbol aliasMethod(RubyModule module, RubySymbol newName, RubySymb return newName; } + private RubyBaseNodeWithExecute getNewNameNodeBeforeCasting() { + return ((ToSymbolNode) getNewNameNode()).getValueNode(); + } + + private RubyBaseNodeWithExecute getOldNameNodeBeforeCasting() { + return ((ToSymbolNode) getOldNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNewNameNodeBeforeCasting().cloneUninitialized(), + getOldNameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "ancestors") @@ -584,17 +614,28 @@ protected Object attrWriter(Frame callerFrame, RubyModule module, Object[] rubyA } @CoreMethod(names = "autoload", required = 2) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "filename", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "filenameNode", type = RubyBaseNodeWithExecute.class) public abstract static class AutoloadNode extends CoreMethodNode { - @CreateCast("name") + public static AutoloadNode create(RubyNode module, RubyBaseNodeWithExecute name, + RubyBaseNodeWithExecute filename) { + return ModuleNodesFactory.AutoloadNodeFactory.create(module, name, filename); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + abstract RubyBaseNodeWithExecute getFilenameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceNameToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } - @CreateCast("filename") + @CreateCast("filenameNode") protected RubyBaseNodeWithExecute coerceFilenameToPath(RubyBaseNodeWithExecute filename) { return ToPathNodeGen.create(filename); } @@ -621,20 +662,50 @@ protected Object autoload(RubyModule module, String name, Object filename, module.fields.setAutoloadConstant(getContext(), this, name, filename, javaStringFilename); return nil; } + + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + private RubyBaseNodeWithExecute getFilenameNodeBeforeCasting() { + return ((ToPathNode) getFilenameNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getFilenameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "autoload?", required = 1, optional = 1) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) public abstract static class IsAutoloadNode extends CoreMethodNode { - @CreateCast("name") + public static IsAutoloadNode create(RubyNode module, RubyBaseNodeWithExecute name, + RubyBaseNodeWithExecute inherit) { + return ModuleNodesFactory.IsAutoloadNodeFactory.create(module, name, inherit); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + abstract RubyBaseNodeWithExecute getInheritNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } - @CreateCast("inherit") + @CreateCast("inheritNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -657,6 +728,25 @@ protected Object isAutoload(RubyModule module, String name, boolean inherit) { return nil; } } + + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + private RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getInheritNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @GenerateUncached @@ -791,11 +881,19 @@ protected Object classExec(ArgumentsDescriptor descriptor, RubyModule self, Obje } @CoreMethod(names = "class_variable_defined?", required = 1) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) public abstract static class ClassVariableDefinedNode extends CoreMethodNode { - @CreateCast("name") + public static ClassVariableDefinedNode create(RubyNode module, RubyBaseNodeWithExecute name) { + return ModuleNodesFactory.ClassVariableDefinedNodeFactory.create(module, name); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -808,14 +906,35 @@ protected boolean isClassVariableDefinedString(RubyModule module, String name, return lookupClassVariableNode.execute(module, name) != null; } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "class_variable_get", required = 1) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) public abstract static class ClassVariableGetNode extends CoreMethodNode { - @CreateCast("name") + public static ClassVariableGetNode create(RubyNode module, RubyBaseNodeWithExecute name) { + return ModuleNodesFactory.ClassVariableGetNodeFactory.create(module, name); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -837,15 +956,38 @@ protected Object getClassVariable(RubyModule module, String name, } } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "class_variable_set", required = 2, raiseIfFrozenSelf = true) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "valueNode", type = RubyNode.class) public abstract static class ClassVariableSetNode extends CoreMethodNode { - @CreateCast("name") + public static ClassVariableSetNode create(RubyNode module, RubyBaseNodeWithExecute name, RubyNode value) { + return ModuleNodesFactory.ClassVariableSetNodeFactory.create(module, name, value); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + abstract RubyNode getValueNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -859,14 +1001,36 @@ protected Object setClassVariable(RubyModule module, String name, Object value, return value; } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "class_variables", optional = 1) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) public abstract static class ClassVariablesNode extends CoreMethodNode { - @CreateCast("inherit") + public static ClassVariablesNode create(RubyNode module, RubyBaseNodeWithExecute inherit) { + return ModuleNodesFactory.ClassVariablesNodeFactory.create(module, inherit); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getInheritNode(); + + @CreateCast("inheritNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -886,14 +1050,36 @@ protected RubyArray getClassVariables(RubyModule module, boolean inherit) { return createArray(variables.toArray()); } + + private RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getInheritNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "constants", optional = 1) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) public abstract static class ConstantsNode extends CoreMethodNode { - @CreateCast("inherit") + public static ConstantsNode create(RubyNode module, RubyBaseNodeWithExecute inherit) { + return ModuleNodesFactory.ConstantsNodeFactory.create(module, inherit); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getInheritNode(); + + @CreateCast("inheritNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -920,21 +1106,47 @@ protected RubyArray constants(RubyModule module, boolean inherit) { return createArray(constantsArray.toArray()); } + private RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getInheritNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @Primitive(name = "module_const_defined?") - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "check_name", type = RubyNode.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "checkNameNode", type = RubyNode.class) public abstract static class ConstDefinedNode extends PrimitiveNode { - @CreateCast("name") + public static ConstDefinedNode create(RubyNode module, RubyBaseNodeWithExecute name, + RubyBaseNodeWithExecute inherit, RubyNode checkName) { + return ModuleNodesFactory.ConstDefinedNodeFactory.create(module, name, inherit, checkName); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + abstract RubyBaseNodeWithExecute getInheritNode(); + + abstract RubyNode getCheckNameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } - @CreateCast("inherit") + @CreateCast("inheritNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -947,6 +1159,25 @@ protected boolean isConstDefined(RubyModule module, String fullName, boolean inh return constant.isFound(); } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + private RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getInheritNodeBeforeCasting().cloneUninitialized(), + getCheckNameNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @Primitive(name = "module_const_get") @@ -1081,11 +1312,19 @@ protected int getLimit() { } @CoreMethod(names = "const_missing", required = 1) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) public abstract static class ConstMissingNode extends CoreMethodNode { - @CreateCast("name") + public static ConstMissingNode create(RubyNode module, RubyBaseNodeWithExecute name) { + return ModuleNodesFactory.ConstMissingNodeFactory.create(module, name); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -1095,22 +1334,46 @@ protected Object constMissing(RubyModule module, String name) { throw new RaiseException(getContext(), coreExceptions().nameErrorUninitializedConstant(module, name, this)); } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "const_source_location", required = 1, optional = 1) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) public abstract static class ConstSourceLocationNode extends CoreMethodNode { @Child private TruffleString.FromJavaStringNode fromJavaStringNode = TruffleString.FromJavaStringNode.create(); - @CreateCast("name") + public static ConstSourceLocationNode create(RubyNode module, RubyBaseNodeWithExecute name, + RubyBaseNodeWithExecute inherit) { + return ModuleNodesFactory.ConstSourceLocationNodeFactory.create(module, name, inherit); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + abstract RubyBaseNodeWithExecute getInheritNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToStringOrSymbol(RubyBaseNodeWithExecute name) { return ToStringOrSymbolNodeGen.create(name); } - @CreateCast("inherit") + @CreateCast("inheritNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -1151,21 +1414,49 @@ private Object getLocation(ConstantLookupResult lookupResult) { } } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((ToStringOrSymbolNode) getNameNode()).getChildNode(); + } + + private RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getInheritNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "const_set", required = 2) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "valueNode", type = RubyNode.class) public abstract static class ConstSetNode extends CoreMethodNode { + @Child private ConstSetUncheckedNode uncheckedSetNode = ConstSetUncheckedNode.create(); + public static ConstSetNode create() { return ConstSetNodeFactory.create(null, null, null); } - @Child private ConstSetUncheckedNode uncheckedSetNode = ConstSetUncheckedNode.create(); + public static ConstSetNode create(RubyNode module, RubyBaseNodeWithExecute name, RubyNode value) { + return ModuleNodesFactory.ConstSetNodeFactory.create(module, name, value); + } - @CreateCast("name") + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + abstract RubyNode getValueNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -1182,6 +1473,21 @@ protected Object setConstant(RubyModule module, String name, Object value) { return uncheckedSetNode.execute(module, name, value); } + + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @NodeChild(value = "module", type = RubyNode.class) @@ -1556,17 +1862,28 @@ protected RubyArray includedModules(RubyModule module) { } @CoreMethod(names = "method_defined?", required = 1, optional = 1) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) public abstract static class MethodDefinedNode extends CoreMethodNode { - @CreateCast("name") + public static MethodDefinedNode create(RubyNode module, RubyBaseNodeWithExecute name, + RubyBaseNodeWithExecute inherit) { + return ModuleNodesFactory.MethodDefinedNodeFactory.create(module, name, inherit); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + abstract RubyBaseNodeWithExecute getInheritNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } - @CreateCast("inherit") + @CreateCast("inheritNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -1584,6 +1901,24 @@ protected boolean isMethodDefined(RubyModule module, String name, boolean inheri return method != null && !method.isUndefined() && !(method.getVisibility() == Visibility.PRIVATE); } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + private RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getInheritNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @GenerateUncached @@ -1773,11 +2108,19 @@ protected RubyModule privateClassMethod(VirtualFrame frame, RubyModule module, O } @CoreMethod(names = "public_instance_method", required = 1) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) public abstract static class PublicInstanceMethodNode extends CoreMethodNode { - @CreateCast("name") + public static PublicInstanceMethodNode create(RubyNode module, RubyBaseNodeWithExecute name) { + return ModuleNodesFactory.PublicInstanceMethodNodeFactory.create(module, name); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -1805,10 +2148,23 @@ protected RubyUnboundMethod publicInstanceMethod(RubyModule module, String name, return instance; } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) protected abstract static class AbstractInstanceMethodsNode extends CoreMethodNode { final Visibility visibility; @@ -1817,7 +2173,11 @@ public AbstractInstanceMethodsNode(Visibility visibility) { this.visibility = visibility; } - @CreateCast("includeAncestors") + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); + + @CreateCast("includeAncestorsNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -1831,39 +2191,81 @@ protected RubyArray getInstanceMethods(RubyModule module, boolean includeAncesto return createArray(objects); } + protected RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); + } + } @CoreMethod(names = "public_instance_methods", optional = 1) public abstract static class PublicInstanceMethodsNode extends AbstractInstanceMethodsNode { + public static PublicInstanceMethodsNode create(RubyNode module, RubyBaseNodeWithExecute includeAncestors) { + return ModuleNodesFactory.PublicInstanceMethodsNodeFactory.create(module, includeAncestors); + } + public PublicInstanceMethodsNode() { super(Visibility.PUBLIC); } + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "protected_instance_methods", optional = 1) public abstract static class ProtectedInstanceMethodsNode extends AbstractInstanceMethodsNode { + public static ProtectedInstanceMethodsNode create(RubyNode module, RubyBaseNodeWithExecute includeAncestors) { + return ModuleNodesFactory.ProtectedInstanceMethodsNodeFactory.create(module, includeAncestors); + } + public ProtectedInstanceMethodsNode() { super(Visibility.PROTECTED); } + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "private_instance_methods", optional = 1) public abstract static class PrivateInstanceMethodsNode extends AbstractInstanceMethodsNode { + public static PrivateInstanceMethodsNode create(RubyNode module, RubyBaseNodeWithExecute includeAncestors) { + return ModuleNodesFactory.PrivateInstanceMethodsNodeFactory.create(module, includeAncestors); + } + public PrivateInstanceMethodsNode() { super(Visibility.PRIVATE); } - } + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) protected abstract static class AbstractMethodDefinedNode extends CoreMethodNode { final Visibility visibility; @@ -1872,12 +2274,18 @@ public AbstractMethodDefinedNode(Visibility visibility) { this.visibility = visibility; } - @CreateCast("name") + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + abstract RubyBaseNodeWithExecute getInheritNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } - @CreateCast("inherit") + @CreateCast("inheritNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -1898,35 +2306,101 @@ protected boolean isMethodDefinedDontInherit(RubyModule module, String name, boo return method != null && !method.isUndefined() && !method.isUnimplemented() && method.getVisibility() == visibility; } + + protected RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + protected RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); + } + } @CoreMethod(names = "public_method_defined?", required = 1, optional = 1) public abstract static class PublicMethodDefinedNode extends AbstractMethodDefinedNode { + + public static PublicMethodDefinedNode create(RubyNode module, RubyBaseNodeWithExecute name, + RubyBaseNodeWithExecute inherit) { + return ModuleNodesFactory.PublicMethodDefinedNodeFactory.create(module, name, inherit); + } + public PublicMethodDefinedNode() { super(Visibility.PUBLIC); } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getInheritNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "protected_method_defined?", required = 1, optional = 1) public abstract static class ProtectedMethodDefinedNode extends AbstractMethodDefinedNode { + + public static ProtectedMethodDefinedNode create(RubyNode module, RubyBaseNodeWithExecute name, + RubyBaseNodeWithExecute inherit) { + return ModuleNodesFactory.ProtectedMethodDefinedNodeFactory.create(module, name, inherit); + } + public ProtectedMethodDefinedNode() { super(Visibility.PROTECTED); } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getInheritNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "private_method_defined?", required = 1, optional = 1) public abstract static class PrivateMethodDefinedNode extends AbstractMethodDefinedNode { + public static PrivateMethodDefinedNode create(RubyNode module, RubyBaseNodeWithExecute name, + RubyBaseNodeWithExecute inherit) { + return ModuleNodesFactory.PrivateMethodDefinedNodeFactory.create(module, name, inherit); + } + public PrivateMethodDefinedNode() { super(Visibility.PRIVATE); } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized(), + getInheritNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } } @CoreMethod(names = "instance_methods", optional = 1) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) public abstract static class InstanceMethodsNode extends CoreMethodNode { - @CreateCast("includeAncestors") + public static InstanceMethodsNode create(RubyNode module, RubyBaseNodeWithExecute includeAncestors) { + return ModuleNodesFactory.InstanceMethodsNodeFactory.create(module, includeAncestors); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); + + @CreateCast("includeAncestorsNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -1939,6 +2413,20 @@ protected RubyArray instanceMethods(RubyModule module, boolean includeAncestors) .toArray(); return createArray(objects); } + + protected RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @GenerateUncached @@ -2042,11 +2530,19 @@ protected RubyModule methods(Frame callerFrame, RubyModule module, Object[] ruby } @CoreMethod(names = "remove_class_variable", required = 1) - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) public abstract static class RemoveClassVariableNode extends CoreMethodNode { - @CreateCast("name") + public static RemoveClassVariableNode create(RubyNode module, RubyBaseNodeWithExecute name) { + return ModuleNodesFactory.RemoveClassVariableNodeFactory.create(module, name); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -2058,6 +2554,19 @@ protected Object removeClassVariableString(RubyModule module, String name, return ModuleOperations.removeClassVariable(module.fields, getContext(), this, name); } + private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @Primitive(name = "module_remove_const") diff --git a/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java b/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java index f77f4ba33351..09a432fe9d60 100644 --- a/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java +++ b/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java @@ -36,7 +36,7 @@ public static FixnumLowerNode create(RubyBaseNodeWithExecute value) { public abstract Object executeLower(Object value); - abstract RubyBaseNodeWithExecute getValueNode(); + public abstract RubyBaseNodeWithExecute getValueNode(); @Specialization protected int lower(int value) { diff --git a/src/main/java/org/truffleruby/core/queue/QueueNodes.java b/src/main/java/org/truffleruby/core/queue/QueueNodes.java index 07abd8d1a80e..bd839f4189ff 100644 --- a/src/main/java/org/truffleruby/core/queue/QueueNodes.java +++ b/src/main/java/org/truffleruby/core/queue/QueueNodes.java @@ -66,15 +66,23 @@ protected RubyQueue push(RubyQueue self, final Object value) { } @CoreMethod(names = { "pop", "shift", "deq" }, optional = 1) - @NodeChild(value = "queue", type = RubyNode.class) - @NodeChild(value = "nonBlocking", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "queueNode", type = RubyNode.class) + @NodeChild(value = "nonBlockingNode", type = RubyBaseNodeWithExecute.class) public abstract static class PopNode extends CoreMethodNode { - @CreateCast("nonBlocking") + @CreateCast("nonBlockingNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute nonBlocking) { return BooleanCastWithDefaultNode.create(false, nonBlocking); } + abstract RubyNode getQueueNode(); + + abstract RubyBaseNodeWithExecute getNonBlockingNode(); + + public static PopNode create(RubyNode queue, RubyBaseNodeWithExecute nonBlocking) { + return QueueNodesFactory.PopNodeFactory.create(queue, nonBlocking); + } + @Specialization(guards = "!nonBlocking") protected Object popBlocking(RubyQueue self, boolean nonBlocking, @Cached BranchProfile closedProfile) { @@ -110,6 +118,19 @@ protected Object popNonBlock(RubyQueue self, boolean nonBlocking, } } + private RubyBaseNodeWithExecute getNonBlockingNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getNonBlockingNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getQueueNode().cloneUninitialized(), + getNonBlockingNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @NonStandard diff --git a/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java b/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java index 2301bd5a20fc..70f04222893b 100644 --- a/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java +++ b/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java @@ -98,18 +98,28 @@ protected int max(RubySizedQueue self) { } @CoreMethod(names = { "push", "<<", "enq" }, required = 1, optional = 1) - @NodeChild(value = "queue", type = RubyNode.class) - @NodeChild(value = "value", type = RubyNode.class) - @NodeChild(value = "nonBlocking", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "queueNode", type = RubyNode.class) + @NodeChild(value = "valueNode", type = RubyNode.class) + @NodeChild(value = "nonBlockingNode", type = RubyBaseNodeWithExecute.class) public abstract static class PushNode extends CoreMethodNode { @Child PropagateSharingNode propagateSharingNode = PropagateSharingNode.create(); - @CreateCast("nonBlocking") + @CreateCast("nonBlockingNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute nonBlocking) { return BooleanCastWithDefaultNode.create(false, nonBlocking); } + abstract RubyNode getQueueNode(); + + abstract RubyNode getValueNode(); + + abstract RubyBaseNodeWithExecute getNonBlockingNode(); + + public static PushNode create(RubyNode queue, RubyNode value, RubyBaseNodeWithExecute nonBlocking) { + return SizedQueueNodesFactory.PushNodeFactory.create(queue, value, nonBlocking); + } + @Specialization(guards = "!nonBlocking") protected RubySizedQueue pushBlocking(RubySizedQueue self, final Object value, boolean nonBlocking) { final SizedQueue queue = self.queue; @@ -152,18 +162,40 @@ protected RubySizedQueue pushNonBlock(RubySizedQueue self, final Object value, b return self; } + private RubyBaseNodeWithExecute getNonBlockingNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getNonBlockingNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getQueueNode().cloneUninitialized(), + getValueNode().cloneUninitialized(), + getNonBlockingNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = { "pop", "shift", "deq" }, optional = 1) - @NodeChild(value = "queue", type = RubyNode.class) - @NodeChild(value = "nonBlocking", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "queueNode", type = RubyNode.class) + @NodeChild(value = "nonBlockingNode", type = RubyBaseNodeWithExecute.class) public abstract static class PopNode extends CoreMethodNode { - @CreateCast("nonBlocking") + @CreateCast("nonBlockingNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute nonBlocking) { return BooleanCastWithDefaultNode.create(false, nonBlocking); } + abstract RubyNode getQueueNode(); + + abstract RubyBaseNodeWithExecute getNonBlockingNode(); + + public static PopNode create(RubyNode queue, RubyBaseNodeWithExecute nonBlocking) { + return SizedQueueNodesFactory.PopNodeFactory.create(queue, nonBlocking); + } + @Specialization(guards = "!nonBlocking") protected Object popBlocking(RubySizedQueue self, boolean nonBlocking) { final SizedQueue queue = self.queue; @@ -197,6 +229,19 @@ protected Object popNonBlock(RubySizedQueue self, boolean nonBlocking, return value; } + private RubyBaseNodeWithExecute getNonBlockingNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getNonBlockingNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getQueueNode().cloneUninitialized(), + getNonBlockingNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "empty?") diff --git a/src/main/java/org/truffleruby/core/range/RangeNodes.java b/src/main/java/org/truffleruby/core/range/RangeNodes.java index f7bfe08e4186..592e78f072ed 100644 --- a/src/main/java/org/truffleruby/core/range/RangeNodes.java +++ b/src/main/java/org/truffleruby/core/range/RangeNodes.java @@ -375,17 +375,30 @@ protected RubyObjectRange initialize(RubyObjectRange range, Object begin, Object } @CoreMethod(names = "new", constructor = true, required = 2, optional = 1) - @NodeChild(value = "rubyClass", type = RubyNode.class) - @NodeChild(value = "begin", type = RubyNode.class) - @NodeChild(value = "end", type = RubyNode.class) - @NodeChild(value = "excludeEnd", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "rubyClassNode", type = RubyNode.class) + @NodeChild(value = "beginNode", type = RubyNode.class) + @NodeChild(value = "endNode", type = RubyNode.class) + @NodeChild(value = "excludeEndNode", type = RubyBaseNodeWithExecute.class) public abstract static class NewNode extends CoreMethodNode { - @CreateCast("excludeEnd") + @CreateCast("excludeEndNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute excludeEnd) { return BooleanCastWithDefaultNode.create(false, excludeEnd); } + abstract RubyNode getRubyClassNode(); + + abstract RubyNode getBeginNode(); + + abstract RubyNode getEndNode(); + + abstract RubyBaseNodeWithExecute getExcludeEndNode(); + + public static NewNode create(RubyNode rubyClass, RubyNode begin, RubyNode end, + RubyBaseNodeWithExecute excludeEnd) { + return RangeNodesFactory.NewNodeFactory.create(rubyClass, begin, end, excludeEnd); + } + @Specialization(guards = "rubyClass == getRangeClass()") protected RubyIntRange intRange(RubyClass rubyClass, int begin, int end, boolean excludeEnd) { return new RubyIntRange(excludeEnd, begin, end); @@ -420,6 +433,22 @@ protected RubyObjectRange objectRange(RubyClass rubyClass, Object begin, Object protected RubyClass getRangeClass() { return coreLibrary().rangeClass; } + + private RubyBaseNodeWithExecute getExcludeEndNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getExcludeEndNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getRubyClassNode().cloneUninitialized(), + getBeginNode().cloneUninitialized(), + getEndNode().cloneUninitialized(), + getExcludeEndNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @GenerateUncached diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java index e83ee2ad9dec..dbb200e2f444 100644 --- a/src/main/java/org/truffleruby/core/string/StringNodes.java +++ b/src/main/java/org/truffleruby/core/string/StringNodes.java @@ -220,36 +220,66 @@ public RubyNode cloneUninitialized() { } @CoreMethod(names = "+", required = 1) - @NodeChild(value = "string", type = RubyNode.class) - @NodeChild(value = "other", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "stringNode", type = RubyNode.class) + @NodeChild(value = "otherNode", type = RubyBaseNodeWithExecute.class) @ImportStatic(StringGuards.class) public abstract static class AddNode extends CoreMethodNode { - @CreateCast("other") + @CreateCast("otherNode") protected ToStrNode coerceOtherToString(RubyBaseNodeWithExecute other) { return ToStrNodeGen.create(other); } + abstract RubyNode getStringNode(); + + abstract RubyBaseNodeWithExecute getOtherNode(); + + public static AddNode create(RubyNode string, RubyBaseNodeWithExecute other) { + return StringNodesFactory.AddNodeFactory.create(string, other); + } + @Specialization protected RubyString add(Object string, Object other, @Cached StringHelperNodes.StringAppendNode stringAppendNode) { return stringAppendNode.executeStringAppend(string, other); } + + private RubyBaseNodeWithExecute getOtherNodeBeforeCasting() { + return ((ToStrNode) getOtherNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getStringNode().cloneUninitialized(), + getOtherNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "*", required = 1) - @NodeChild(value = "string", type = RubyNode.class) - @NodeChild(value = "times", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "stringNode", type = RubyNode.class) + @NodeChild(value = "timesNode", type = RubyBaseNodeWithExecute.class) @ImportStatic(StringGuards.class) public abstract static class MulNode extends CoreMethodNode { - @CreateCast("times") + @CreateCast("timesNode") protected RubyBaseNodeWithExecute coerceToInteger(RubyBaseNodeWithExecute times) { // Not ToIntNode, because this works with empty strings, and must throw a different error // for long values that don't fit in an int. return FixnumLowerNode.create(ToLongNode.create(times)); } + abstract RubyNode getStringNode(); + + abstract RubyBaseNodeWithExecute getTimesNode(); + + public static MulNode create(RubyNode string, RubyBaseNodeWithExecute times) { + return StringNodesFactory.MulNodeFactory.create(string, times); + } + @Specialization(guards = "times == 0") protected RubyString multiplyZero(Object string, int times, @Cached RubyStringLibrary libString) { @@ -298,6 +328,20 @@ private RaiseException tooBig() { // In TruffleRuby, strings have max length Integer.MAX_VALUE. return new RaiseException(getContext(), coreExceptions().argumentError("argument too big", this)); } + + private RubyBaseNodeWithExecute getTimesNodeBeforeCasting() { + var toLongNode = ((FixnumLowerNode) getTimesNode()).getValueNode(); + return ((ToLongNode) toLongNode).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getStringNode().cloneUninitialized(), + getTimesNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } } @CoreMethod(names = { "==", "===", "eql?" }, required = 1) @@ -2268,25 +2312,35 @@ protected RubyString undumpNonAsciiCompatible(Object string, } @CoreMethod(names = "setbyte", required = 2, raiseIfNotMutableSelf = true, lowerFixnum = { 1, 2 }) - @NodeChild(value = "string", type = RubyNode.class) - @NodeChild(value = "index", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "value", type = RubyBaseNodeWithExecute.class) - @ImportStatic(StringGuards.class) + @NodeChild(value = "stringNode", type = RubyNode.class) + @NodeChild(value = "indexNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "valueNode", type = RubyBaseNodeWithExecute.class) public abstract static class SetByteNode extends CoreMethodNode { @Child private StringHelperNodes.CheckIndexNode checkIndexNode = StringHelperNodesFactory.CheckIndexNodeGen .create(); - @CreateCast("index") + @CreateCast("indexNode") protected ToIntNode coerceIndexToInt(RubyBaseNodeWithExecute index) { return ToIntNode.create(index); } - @CreateCast("value") + @CreateCast("valueNode") protected ToIntNode coerceValueToInt(RubyBaseNodeWithExecute value) { return ToIntNode.create(value); } + abstract RubyNode getStringNode(); + + abstract RubyBaseNodeWithExecute getIndexNode(); + + abstract RubyBaseNodeWithExecute getValueNode(); + + public static SetByteNode create(RubyNode string, RubyBaseNodeWithExecute index, + RubyBaseNodeWithExecute value) { + return StringNodesFactory.SetByteNodeFactory.create(string, index, value); + } + @Specialization(guards = "tstring.isMutable()") protected int mutable(RubyString string, int index, int value, @Cached RubyStringLibrary libString, @@ -2313,6 +2367,25 @@ protected int immutable(RubyString string, int index, int value, string.setTString(mutableTString); return value; } + + private RubyBaseNodeWithExecute getIndexNodeBeforeCasting() { + return ((ToIntNode) getIndexNode()).getChildNode(); + } + + private RubyBaseNodeWithExecute getValueNodeBeforeCasting() { + return ((ToIntNode) getValueNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getStringNode().cloneUninitialized(), + getIndexNodeBeforeCasting().cloneUninitialized(), + getValueNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = { "size", "length" }) @@ -2701,25 +2774,35 @@ public static boolean reverseIsEqualToSelf(AbstractTruffleString tstring, RubyEn } @CoreMethod(names = "tr!", required = 2, raiseIfNotMutableSelf = true) - @NodeChild(value = "self", type = RubyNode.class) - @NodeChild(value = "fromStr", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "toStr", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "selfNode", type = RubyNode.class) + @NodeChild(value = "fromStrNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "toStrNode", type = RubyBaseNodeWithExecute.class) @ImportStatic(StringGuards.class) public abstract static class TrBangNode extends CoreMethodNode { @Child private CheckEncodingNode checkEncodingNode; @Child private DeleteBangNode deleteBangNode; - @CreateCast("fromStr") + @CreateCast("fromStrNode") protected ToStrNode coerceFromStrToString(RubyBaseNodeWithExecute fromStr) { return ToStrNodeGen.create(fromStr); } - @CreateCast("toStr") + @CreateCast("toStrNode") protected ToStrNode coerceToStrToString(RubyBaseNodeWithExecute toStr) { return ToStrNodeGen.create(toStr); } + abstract RubyNode getSelfNode(); + + abstract RubyBaseNodeWithExecute getFromStrNode(); + + abstract RubyBaseNodeWithExecute getToStrNode(); + + public static TrBangNode create(RubyNode self, RubyBaseNodeWithExecute fromStr, RubyBaseNodeWithExecute toStr) { + return StringNodesFactory.TrBangNodeFactory.create(self, fromStr, toStr); + } + @Specialization(guards = "isEmpty(self.tstring)") protected Object trBangSelfEmpty(RubyString self, Object fromStr, Object toStr) { return nil; @@ -2756,11 +2839,30 @@ protected Object trBangNoEmpty(RubyString self, Object fromStr, Object toStr, return StringHelperNodes.trTransHelper(checkEncodingNode, self, libFromStr, fromStr, libToStr, toStr, false, this); } + + private RubyBaseNodeWithExecute getFromStrNodeBeforeCasting() { + return ((ToStrNode) getFromStrNode()).getChildNode(); + } + + private RubyBaseNodeWithExecute getToStrNodeBeforeCasting() { + return ((ToStrNode) getToStrNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getSelfNode().cloneUninitialized(), + getFromStrNodeBeforeCasting().cloneUninitialized(), + getToStrNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "tr_s!", required = 2, raiseIfNotMutableSelf = true) - @NodeChild(value = "self", type = RubyNode.class) - @NodeChild(value = "fromStr", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "selfNode", type = RubyNode.class) + @NodeChild(value = "fromStrNode", type = RubyBaseNodeWithExecute.class) @NodeChild(value = "toStrNode", type = RubyBaseNodeWithExecute.class) @ImportStatic(StringGuards.class) public abstract static class TrSBangNode extends CoreMethodNode { @@ -2768,7 +2870,7 @@ public abstract static class TrSBangNode extends CoreMethodNode { @Child private CheckEncodingNode checkEncodingNode; @Child private DeleteBangNode deleteBangNode; - @CreateCast("fromStr") + @CreateCast("fromStrNode") protected ToStrNode coerceFromStrToString(RubyBaseNodeWithExecute fromStr) { return ToStrNodeGen.create(fromStr); } @@ -2778,6 +2880,17 @@ protected ToStrNode coerceToStrToString(RubyBaseNodeWithExecute toStr) { return ToStrNodeGen.create(toStr); } + abstract RubyNode getSelfNode(); + + abstract RubyBaseNodeWithExecute getFromStrNode(); + + abstract RubyBaseNodeWithExecute getToStrNode(); + + public static TrSBangNode create(RubyNode self, RubyBaseNodeWithExecute fromStr, + RubyBaseNodeWithExecute toStr) { + return StringNodesFactory.TrSBangNodeFactory.create(self, fromStr, toStr); + } + @Specialization( guards = { "isEmpty(self.tstring)" }) protected Object trSBangEmpty(RubyString self, Object fromStr, Object toStr) { @@ -2810,21 +2923,48 @@ protected Object trSBang(RubyString self, Object fromStr, Object toStr, return StringHelperNodes.trTransHelper(checkEncodingNode, self, libFromStr, fromStr, libToStr, toStr, true, this); } + + private RubyBaseNodeWithExecute getFromStrNodeBeforeCasting() { + return ((ToStrNode) getFromStrNode()).getChildNode(); + } + + private RubyBaseNodeWithExecute getToStrNodeBeforeCasting() { + return ((ToStrNode) getToStrNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getSelfNode().cloneUninitialized(), + getFromStrNodeBeforeCasting().cloneUninitialized(), + getToStrNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } - @NodeChild(value = "string", type = RubyNode.class) - @NodeChild(value = "format", type = RubyBaseNodeWithExecute.class) @CoreMethod(names = "unpack", required = 1) + @NodeChild(value = "stringNode", type = RubyNode.class) + @NodeChild(value = "formatNode", type = RubyBaseNodeWithExecute.class) @ReportPolymorphism public abstract static class UnpackNode extends CoreMethodNode { private final BranchProfile exceptionProfile = BranchProfile.create(); - @CreateCast("format") + @CreateCast("formatNode") protected ToStrNode coerceFormat(RubyBaseNodeWithExecute format) { return ToStrNodeGen.create(format); } + abstract RubyNode getStringNode(); + + abstract RubyBaseNodeWithExecute getFormatNode(); + + public static UnpackNode create(RubyNode string, RubyBaseNodeWithExecute format) { + return StringNodesFactory.UnpackNodeFactory.create(string, format); + } + @Specialization(guards = { "equalNode.execute(libFormat, format, cachedFormat, cachedEncoding)" }) protected RubyArray unpackCached(Object string, Object format, @Cached RubyStringLibrary libString, @@ -2901,6 +3041,18 @@ protected int getCacheLimit() { return getLanguage().options.UNPACK_CACHE; } + private RubyBaseNodeWithExecute getFormatNodeBeforeCasting() { + return ((ToStrNode) getFormatNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getStringNode().cloneUninitialized(), + getFormatNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } } @Primitive(name = "string_upcase!", raiseIfNotMutable = 0, lowerFixnum = 1) diff --git a/src/main/java/org/truffleruby/interop/InteropNodes.java b/src/main/java/org/truffleruby/interop/InteropNodes.java index 9886246df2d4..6b32fe3978b6 100644 --- a/src/main/java/org/truffleruby/interop/InteropNodes.java +++ b/src/main/java/org/truffleruby/interop/InteropNodes.java @@ -1568,32 +1568,60 @@ protected boolean hasMemberWriteSideEffects(Object receiver, Object name, // region Import/Export @CoreMethod(names = "export", onSingleton = true, required = 2) - @NodeChild(value = "name", type = RubyNode.class) - @NodeChild(value = "object", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyNode.class) + @NodeChild(value = "objectNode", type = RubyNode.class) public abstract static class ExportNode extends CoreMethodNode { - @CreateCast("name") + @CreateCast("nameNode") protected RubyNode coerceNameToString(RubyNode name) { return ToJavaStringNode.create(name); } + abstract RubyNode getNameNode(); + + abstract RubyNode getObjectNode(); + + public static ExportNode create(RubyNode name, RubyNode object) { + return InteropNodesFactory.ExportNodeFactory.create(name, object); + } + @TruffleBoundary @Specialization protected Object export(String name, Object object) { getContext().getEnv().exportSymbol(name, object); return object; } + + private RubyNode getNameNodeBeforeCasting() { + return ((ToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getNameNodeBeforeCasting().cloneUninitialized(), + getObjectNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "import", onSingleton = true, required = 1) - @NodeChild(value = "name", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyNode.class) public abstract static class ImportNode extends CoreMethodNode { - @CreateCast("name") + @CreateCast("nameNode") protected RubyNode coerceNameToString(RubyNode name) { return ToJavaStringNode.create(name); } + abstract RubyNode getNameNode(); + + public static ImportNode create(RubyNode name) { + return InteropNodesFactory.ImportNodeFactory.create(name); + } + @Specialization protected Object importObject(String name, @Cached BranchProfile errorProfile, @@ -1612,6 +1640,17 @@ private Object doImport(String name) { return getContext().getEnv().importSymbol(name); } + private RubyNode getNameNodeBeforeCasting() { + return ((ToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create(getNameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } // endregion @@ -2350,16 +2389,26 @@ protected Object writeBufferByte(Object receiver, long byteOffset, Object value, } @CoreMethod(names = "read_buffer_short", onSingleton = true, required = 3) - @NodeChild(value = "receiver", type = RubyNode.class) - @NodeChild(value = "byteOrder", type = RubyNode.class) - @NodeChild(value = "byteOffset", type = RubyNode.class) + @NodeChild(value = "receiverNode", type = RubyNode.class) + @NodeChild(value = "byteOrderNode", type = RubyNode.class) + @NodeChild(value = "byteOffsetNode", type = RubyNode.class) public abstract static class ReadBufferShortNode extends CoreMethodNode { - @CreateCast("byteOrder") + @CreateCast("byteOrderNode") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } + abstract RubyNode getReceiverNode(); + + abstract RubyNode getByteOrderNode(); + + abstract RubyNode getByteOffsetNode(); + + public static ReadBufferShortNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset) { + return InteropNodesFactory.ReadBufferShortNodeFactory.create(receiver, byteOrder, byteOffset); + } + @Specialization(limit = "getInteropCacheLimit()") protected short readBufferShort(Object receiver, ByteOrder byteOrder, long byteOffset, @CachedLibrary("receiver") InteropLibrary interop, @@ -2371,20 +2420,47 @@ protected short readBufferShort(Object receiver, ByteOrder byteOrder, long byteO } } + private RubyNode getByteOrderNodeBeforeCasting() { + return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getReceiverNode().cloneUninitialized(), + getByteOrderNodeBeforeCasting().cloneUninitialized(), + getByteOffsetNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "write_buffer_short", onSingleton = true, required = 4) - @NodeChild(value = "receiver", type = RubyNode.class) - @NodeChild(value = "byteOrder", type = RubyNode.class) - @NodeChild(value = "byteOffset", type = RubyNode.class) - @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "receiverNode", type = RubyNode.class) + @NodeChild(value = "byteOrderNode", type = RubyNode.class) + @NodeChild(value = "byteOffsetNode", type = RubyNode.class) + @NodeChild(value = "valueNode", type = RubyNode.class) public abstract static class WriteBufferShortNode extends CoreMethodNode { - @CreateCast("byteOrder") + @CreateCast("byteOrderNode") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } + abstract RubyNode getReceiverNode(); + + abstract RubyNode getByteOrderNode(); + + abstract RubyNode getByteOffsetNode(); + + abstract RubyNode getValueNode(); + + public static WriteBufferShortNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset, + RubyNode value) { + return InteropNodesFactory.WriteBufferShortNodeFactory.create(receiver, byteOrder, byteOffset, value); + } + @Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInShort(value)") protected Object writeBufferShort(Object receiver, ByteOrder byteOrder, long byteOffset, Object value, @CachedLibrary("receiver") InteropLibrary interop, @@ -2399,19 +2475,44 @@ protected Object writeBufferShort(Object receiver, ByteOrder byteOrder, long byt return value; } + private RubyNode getByteOrderNodeBeforeCasting() { + return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getReceiverNode().cloneUninitialized(), + getByteOrderNodeBeforeCasting().cloneUninitialized(), + getByteOffsetNode().cloneUninitialized(), + getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "read_buffer_int", onSingleton = true, required = 3) - @NodeChild(value = "receiver", type = RubyNode.class) - @NodeChild(value = "byteOrder", type = RubyNode.class) - @NodeChild(value = "byteOffset", type = RubyNode.class) + @NodeChild(value = "receiverNode", type = RubyNode.class) + @NodeChild(value = "byteOrderNode", type = RubyNode.class) + @NodeChild(value = "byteOffsetNode", type = RubyNode.class) public abstract static class ReadBufferIntNode extends CoreMethodNode { - @CreateCast("byteOrder") + @CreateCast("byteOrderNode") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } + abstract RubyNode getReceiverNode(); + + abstract RubyNode getByteOrderNode(); + + abstract RubyNode getByteOffsetNode(); + + public static ReadBufferIntNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset) { + return InteropNodesFactory.ReadBufferIntNodeFactory.create(receiver, byteOrder, byteOffset); + } + @Specialization(limit = "getInteropCacheLimit()") protected int readBufferInt(Object receiver, ByteOrder byteOrder, long byteOffset, @CachedLibrary("receiver") InteropLibrary interop, @@ -2423,20 +2524,47 @@ protected int readBufferInt(Object receiver, ByteOrder byteOrder, long byteOffse } } + private RubyNode getByteOrderNodeBeforeCasting() { + return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getReceiverNode().cloneUninitialized(), + getByteOrderNodeBeforeCasting().cloneUninitialized(), + getByteOffsetNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "write_buffer_int", onSingleton = true, required = 4, lowerFixnum = 4) - @NodeChild(value = "receiver", type = RubyNode.class) - @NodeChild(value = "byteOrder", type = RubyNode.class) - @NodeChild(value = "byteOffset", type = RubyNode.class) - @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "receiverNode", type = RubyNode.class) + @NodeChild(value = "byteOrderNode", type = RubyNode.class) + @NodeChild(value = "byteOffsetNode", type = RubyNode.class) + @NodeChild(value = "valueNode", type = RubyNode.class) public abstract static class WriteBufferIntNode extends CoreMethodNode { - @CreateCast("byteOrder") + @CreateCast("byteOrderNode") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } + abstract RubyNode getReceiverNode(); + + abstract RubyNode getByteOrderNode(); + + abstract RubyNode getByteOffsetNode(); + + abstract RubyNode getValueNode(); + + public static WriteBufferIntNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset, + RubyNode value) { + return InteropNodesFactory.WriteBufferIntNodeFactory.create(receiver, byteOrder, byteOffset, value); + } + @Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInInt(value)") protected Object writeBufferInt(Object receiver, ByteOrder order, long byteOffset, Object value, @CachedLibrary("receiver") InteropLibrary interop, @@ -2451,19 +2579,44 @@ protected Object writeBufferInt(Object receiver, ByteOrder order, long byteOffse return value; } + private RubyNode getByteOrderNodeBeforeCasting() { + return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getReceiverNode().cloneUninitialized(), + getByteOrderNodeBeforeCasting().cloneUninitialized(), + getByteOffsetNode().cloneUninitialized(), + getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "read_buffer_long", onSingleton = true, required = 3) - @NodeChild(value = "receiver", type = RubyNode.class) - @NodeChild(value = "byteOrder", type = RubyNode.class) - @NodeChild(value = "byteOffset", type = RubyNode.class) + @NodeChild(value = "receiverNode", type = RubyNode.class) + @NodeChild(value = "byteOrderNode", type = RubyNode.class) + @NodeChild(value = "byteOffsetNode", type = RubyNode.class) public abstract static class ReadBufferLongNode extends CoreMethodNode { - @CreateCast("byteOrder") + @CreateCast("byteOrderNode") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } + abstract RubyNode getReceiverNode(); + + abstract RubyNode getByteOrderNode(); + + abstract RubyNode getByteOffsetNode(); + + public static ReadBufferLongNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset) { + return InteropNodesFactory.ReadBufferLongNodeFactory.create(receiver, byteOrder, byteOffset); + } + @Specialization(limit = "getInteropCacheLimit()") protected long readBufferLong(Object receiver, ByteOrder byteOrder, long byteOffset, @CachedLibrary("receiver") InteropLibrary interop, @@ -2475,20 +2628,47 @@ protected long readBufferLong(Object receiver, ByteOrder byteOrder, long byteOff } } + private RubyNode getByteOrderNodeBeforeCasting() { + return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getReceiverNode().cloneUninitialized(), + getByteOrderNodeBeforeCasting().cloneUninitialized(), + getByteOffsetNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "write_buffer_long", onSingleton = true, required = 4) - @NodeChild(value = "receiver", type = RubyNode.class) - @NodeChild(value = "byteOrder", type = RubyNode.class) - @NodeChild(value = "byteOffset", type = RubyNode.class) - @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "receiverNode", type = RubyNode.class) + @NodeChild(value = "byteOrderNode", type = RubyNode.class) + @NodeChild(value = "byteOffsetNode", type = RubyNode.class) + @NodeChild(value = "valueNode", type = RubyNode.class) public abstract static class WriteBufferLongNode extends CoreMethodNode { - @CreateCast("byteOrder") + @CreateCast("byteOrderNode") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } + abstract RubyNode getReceiverNode(); + + abstract RubyNode getByteOrderNode(); + + abstract RubyNode getByteOffsetNode(); + + abstract RubyNode getValueNode(); + + public static WriteBufferLongNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset, + RubyNode value) { + return InteropNodesFactory.WriteBufferLongNodeFactory.create(receiver, byteOrder, byteOffset, value); + } + @Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInLong(value)") protected Object writeBufferLong(Object receiver, ByteOrder order, long byteOffset, Object value, @CachedLibrary("receiver") InteropLibrary interop, @@ -2503,19 +2683,44 @@ protected Object writeBufferLong(Object receiver, ByteOrder order, long byteOffs return value; } + private RubyNode getByteOrderNodeBeforeCasting() { + return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getReceiverNode().cloneUninitialized(), + getByteOrderNodeBeforeCasting().cloneUninitialized(), + getByteOffsetNode().cloneUninitialized(), + getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "read_buffer_float", onSingleton = true, required = 3) - @NodeChild(value = "receiver", type = RubyNode.class) - @NodeChild(value = "byteOrder", type = RubyNode.class) - @NodeChild(value = "byteOffset", type = RubyNode.class) + @NodeChild(value = "receiverNode", type = RubyNode.class) + @NodeChild(value = "byteOrderNode", type = RubyNode.class) + @NodeChild(value = "byteOffsetNode", type = RubyNode.class) public abstract static class ReadBufferFloatNode extends CoreMethodNode { - @CreateCast("byteOrder") + @CreateCast("byteOrderNode") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } + abstract RubyNode getReceiverNode(); + + abstract RubyNode getByteOrderNode(); + + abstract RubyNode getByteOffsetNode(); + + public static ReadBufferFloatNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset) { + return InteropNodesFactory.ReadBufferFloatNodeFactory.create(receiver, byteOrder, byteOffset); + } + // must return double so Ruby nodes can deal with it @Specialization(limit = "getInteropCacheLimit()") protected double readBufferFloat(Object receiver, ByteOrder byteOrder, long byteOffset, @@ -2528,20 +2733,47 @@ protected double readBufferFloat(Object receiver, ByteOrder byteOrder, long byte } } + private RubyNode getByteOrderNodeBeforeCasting() { + return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getReceiverNode().cloneUninitialized(), + getByteOrderNodeBeforeCasting().cloneUninitialized(), + getByteOffsetNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "write_buffer_float", onSingleton = true, required = 4) - @NodeChild(value = "receiver", type = RubyNode.class) - @NodeChild(value = "byteOrder", type = RubyNode.class) - @NodeChild(value = "byteOffset", type = RubyNode.class) - @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "receiverNode", type = RubyNode.class) + @NodeChild(value = "byteOrderNode", type = RubyNode.class) + @NodeChild(value = "byteOffsetNode", type = RubyNode.class) + @NodeChild(value = "valueNode", type = RubyNode.class) public abstract static class WriteBufferFloatNode extends CoreMethodNode { - @CreateCast("byteOrder") + @CreateCast("byteOrderNode") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } + abstract RubyNode getReceiverNode(); + + abstract RubyNode getByteOrderNode(); + + abstract RubyNode getByteOffsetNode(); + + abstract RubyNode getValueNode(); + + public static WriteBufferFloatNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset, + RubyNode value) { + return InteropNodesFactory.WriteBufferFloatNodeFactory.create(receiver, byteOrder, byteOffset, value); + } + @Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInDouble(value)") protected Object writeBufferFloat(Object receiver, ByteOrder order, long byteOffset, Object value, @CachedLibrary("receiver") InteropLibrary interop, @@ -2556,19 +2788,43 @@ protected Object writeBufferFloat(Object receiver, ByteOrder order, long byteOff return value; } + private RubyNode getByteOrderNodeBeforeCasting() { + return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getReceiverNode().cloneUninitialized(), + getByteOrderNodeBeforeCasting().cloneUninitialized(), + getByteOffsetNode().cloneUninitialized(), + getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } } @CoreMethod(names = "read_buffer_double", onSingleton = true, required = 3) - @NodeChild(value = "receiver", type = RubyNode.class) - @NodeChild(value = "byteOrder", type = RubyNode.class) - @NodeChild(value = "byteOffset", type = RubyNode.class) + @NodeChild(value = "receiverNode", type = RubyNode.class) + @NodeChild(value = "byteOrderNode", type = RubyNode.class) + @NodeChild(value = "byteOffsetNode", type = RubyNode.class) public abstract static class ReadBufferDoubleNode extends CoreMethodNode { - @CreateCast("byteOrder") + @CreateCast("byteOrderNode") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } + abstract RubyNode getReceiverNode(); + + abstract RubyNode getByteOrderNode(); + + abstract RubyNode getByteOffsetNode(); + + public static ReadBufferDoubleNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset) { + return InteropNodesFactory.ReadBufferDoubleNodeFactory.create(receiver, byteOrder, byteOffset); + } + @Specialization(limit = "getInteropCacheLimit()") protected double readBufferDouble(Object receiver, ByteOrder byteOrder, long byteOffset, @CachedLibrary("receiver") InteropLibrary interop, @@ -2580,20 +2836,47 @@ protected double readBufferDouble(Object receiver, ByteOrder byteOrder, long byt } } + private RubyNode getByteOrderNodeBeforeCasting() { + return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getReceiverNode().cloneUninitialized(), + getByteOrderNodeBeforeCasting().cloneUninitialized(), + getByteOffsetNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "write_buffer_double", onSingleton = true, required = 4) - @NodeChild(value = "receiver", type = RubyNode.class) - @NodeChild(value = "byteOrder", type = RubyNode.class) - @NodeChild(value = "byteOffset", type = RubyNode.class) - @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "receiverNode", type = RubyNode.class) + @NodeChild(value = "byteOrderNode", type = RubyNode.class) + @NodeChild(value = "byteOffsetNode", type = RubyNode.class) + @NodeChild(value = "valueNode", type = RubyNode.class) public abstract static class WriteBufferDoubleNode extends CoreMethodNode { - @CreateCast("byteOrder") + @CreateCast("byteOrderNode") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } + abstract RubyNode getReceiverNode(); + + abstract RubyNode getByteOrderNode(); + + abstract RubyNode getByteOffsetNode(); + + abstract RubyNode getValueNode(); + + public static WriteBufferDoubleNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset, + RubyNode value) { + return InteropNodesFactory.WriteBufferDoubleNodeFactory.create(receiver, byteOrder, byteOffset, value); + } + @Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInDouble(value)") protected Object writeBufferDouble(Object receiver, ByteOrder order, long byteOffset, Object value, @CachedLibrary("receiver") InteropLibrary interop, @@ -2608,6 +2891,21 @@ protected Object writeBufferDouble(Object receiver, ByteOrder order, long byteOf return value; } + private RubyNode getByteOrderNodeBeforeCasting() { + return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getReceiverNode().cloneUninitialized(), + getByteOrderNodeBeforeCasting().cloneUninitialized(), + getByteOffsetNode().cloneUninitialized(), + getValueNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } // endregion diff --git a/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java b/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java index 11a5e5b6eff0..f3c4c733a8fa 100644 --- a/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java +++ b/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java @@ -26,7 +26,7 @@ public static SymbolToByteOrderNode create(RubyNode value) { return SymbolToByteOrderNodeGen.create(value); } - abstract RubyNode getValueNode(); + public abstract RubyNode getValueNode(); @Specialization(guards = "symbol == coreSymbols().BIG") protected ByteOrder symbolToByteOrderBig(RubySymbol symbol) { diff --git a/src/main/java/org/truffleruby/interop/ToJavaStringNode.java b/src/main/java/org/truffleruby/interop/ToJavaStringNode.java index aeb51be1bb57..9c8d700a5d37 100644 --- a/src/main/java/org/truffleruby/interop/ToJavaStringNode.java +++ b/src/main/java/org/truffleruby/interop/ToJavaStringNode.java @@ -35,7 +35,7 @@ public static ToJavaStringNode create(RubyNode string) { public abstract String executeToJavaString(Object name); - abstract RubyNode getValueNode(); + public abstract RubyNode getValueNode(); @Specialization(guards = "interopLibrary.isString(value)", limit = "getLimit()") protected String interopString(Object value, diff --git a/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java b/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java index e1c422159096..8cf47e7e4457 100644 --- a/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java +++ b/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java @@ -27,7 +27,7 @@ public ToJavaStringWithDefaultNode(String defaultValue) { this.defaultValue = defaultValue; } - abstract RubyNode getValueNode(); + public abstract RubyNode getValueNode(); @Specialization protected String doDefault(NotProvided value) { diff --git a/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java b/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java index 90c65d3a9b52..7d49d12daf8c 100644 --- a/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java +++ b/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java @@ -215,20 +215,28 @@ protected Object getIndex(int index) { } @CoreMethod(names = "[]=", needsSelf = false, lowerFixnum = 1, required = 2) - @NodeChild(value = "index", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "line", type = RubyNode.class) + @NodeChild(value = "indexNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "lineNode", type = RubyNode.class) public abstract static class SetIndexNode extends CoreMethodNode { - @CreateCast("index") + @CreateCast("indexNode") protected ToIntNode coerceIndexToInt(RubyBaseNodeWithExecute index) { return ToIntNode.create(index); } - @CreateCast("line") + @CreateCast("lineNode") protected RubyNode coerceLineToJavaString(RubyNode line) { return ToJavaStringNode.create(line); } + abstract RubyBaseNodeWithExecute getIndexNode(); + + abstract RubyNode getLineNode(); + + public static SetIndexNode create(RubyBaseNodeWithExecute index, RubyNode line) { + return ReadlineHistoryNodesFactory.SetIndexNodeFactory.create(index, line); + } + @TruffleBoundary @Specialization protected Object setIndex(int index, String line) { @@ -244,6 +252,23 @@ protected Object setIndex(int index, String line) { } } + private RubyBaseNodeWithExecute getIndexNodeBeforeCasting() { + return ((ToIntNode) getIndexNode()).getChildNode(); + } + + private RubyNode getLineNodeBeforeCasting() { + return ((ToJavaStringNode) getLineNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getIndexNodeBeforeCasting().cloneUninitialized(), + getLineNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "delete_at", needsSelf = false, required = 1, lowerFixnum = 1) diff --git a/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java b/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java index 649502d5e2d1..fdcf0561c83e 100644 --- a/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java +++ b/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java @@ -43,6 +43,7 @@ import org.truffleruby.core.support.RubyIO; import org.truffleruby.core.thread.ThreadManager.BlockingAction; import org.truffleruby.interop.ToJavaStringNode; +import org.truffleruby.interop.ToJavaStringWithDefaultNode; import org.truffleruby.interop.ToJavaStringWithDefaultNodeGen; import org.truffleruby.language.RubyBaseNodeWithExecute; import org.truffleruby.language.RubyGuards; @@ -73,14 +74,20 @@ protected RubyString basicWordBreakCharacters() { } @CoreMethod(names = "basic_word_break_characters=", onSingleton = true, required = 1) - @NodeChild(value = "characters", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "charactersNode", type = RubyBaseNodeWithExecute.class) public abstract static class SetBasicWordBreakCharactersNode extends CoreMethodNode { - @CreateCast("characters") + @CreateCast("charactersNode") protected ToStrNode coerceCharactersToString(RubyBaseNodeWithExecute characters) { return ToStrNodeGen.create(characters); } + abstract RubyBaseNodeWithExecute getCharactersNode(); + + public SetBasicWordBreakCharactersNode create(RubyBaseNodeWithExecute characters) { + return ReadlineNodesFactory.SetBasicWordBreakCharactersNodeFactory.create(characters); + } + @TruffleBoundary @Specialization(guards = "strings.isRubyString(characters)", limit = "1") protected Object setBasicWordBreakCharacters(Object characters, @@ -90,6 +97,18 @@ protected Object setBasicWordBreakCharacters(Object characters, return characters; } + private RubyBaseNodeWithExecute getCharactersNodeBeforeCasting() { + return ((ToStrNode) getCharactersNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getCharactersNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @Primitive(name = "readline_set_completion_proc") @@ -123,22 +142,30 @@ protected RubyArray getScreenSize() { } @CoreMethod(names = "readline", isModuleFunction = true, optional = 2) - @NodeChild(value = "prompt", type = RubyNode.class) - @NodeChild(value = "addToHistory", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "promptNode", type = RubyNode.class) + @NodeChild(value = "addToHistoryNode", type = RubyBaseNodeWithExecute.class) public abstract static class ReadlineNode extends CoreMethodNode { @Child private TruffleString.FromJavaStringNode fromJavaStringNode = TruffleString.FromJavaStringNode.create(); - @CreateCast("prompt") + @CreateCast("promptNode") protected RubyNode coercePromptToJavaString(RubyNode prompt) { return ToJavaStringWithDefaultNodeGen.create("", prompt); } - @CreateCast("addToHistory") + @CreateCast("addToHistoryNode") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute addToHistory) { return BooleanCastWithDefaultNode.create(false, addToHistory); } + abstract RubyNode getPromptNode(); + + abstract RubyBaseNodeWithExecute getAddToHistoryNode(); + + public static ReadlineNode create(RubyNode prompt, RubyBaseNodeWithExecute addToHistory) { + return ReadlineNodesFactory.ReadlineNodeFactory.create(prompt, addToHistory); + } + @TruffleBoundary @Specialization protected Object readline(String prompt, boolean addToHistory) { @@ -175,6 +202,23 @@ protected Object readline(String prompt, boolean addToHistory) { } } + private RubyNode getPromptNodeBeforeCasting() { + return ((ToJavaStringWithDefaultNode) getPromptNode()).getValueNode(); + } + + private RubyBaseNodeWithExecute getAddToHistoryNodeBeforeCasting() { + return ((BooleanCastWithDefaultNode) getAddToHistoryNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getPromptNodeBeforeCasting().cloneUninitialized(), + getAddToHistoryNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "point", onSingleton = true) @@ -189,15 +233,23 @@ protected int point() { } @CoreMethod(names = "insert_text", constructor = true, required = 1) - @NodeChild(value = "self", type = RubyNode.class) - @NodeChild(value = "text", type = RubyNode.class) + @NodeChild(value = "selfNode", type = RubyNode.class) + @NodeChild(value = "textNode", type = RubyNode.class) public abstract static class InsertTextNode extends CoreMethodNode { - @CreateCast("text") + @CreateCast("textNode") protected RubyNode coerceTextToString(RubyNode text) { return ToJavaStringNode.create(text); } + abstract RubyNode getSelfNode(); + + abstract RubyNode getTextNode(); + + public static InsertTextNode create(RubyNode self, RubyNode text) { + return ReadlineNodesFactory.InsertTextNodeFactory.create(self, text); + } + @TruffleBoundary @Specialization protected RubyBasicObject insertText(RubyBasicObject readline, String text) { @@ -205,6 +257,19 @@ protected RubyBasicObject insertText(RubyBasicObject readline, String text) { return readline; } + private RubyNode getTextNodeBeforeCasting() { + return ((ToJavaStringWithDefaultNode) getTextNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getSelfNode().cloneUninitialized(), + getTextNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "delete_text", constructor = true) From ea09bf43bbceb1d441b30dcbfada49a3c0f1e254 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Thu, 1 Sep 2022 20:13:45 +0300 Subject: [PATCH 09/46] Switch from PrimitiveNode to PrimitiveArrayArgumentsNode when it's possible --- .../org/truffleruby/core/kernel/KernelNodes.java | 5 +---- .../org/truffleruby/core/range/RangeNodes.java | 5 +---- .../org/truffleruby/core/string/StringNodes.java | 6 +----- .../org/truffleruby/core/support/TypeNodes.java | 15 +++++---------- .../org/truffleruby/extra/TruffleGraalNodes.java | 11 ++++------- 5 files changed, 12 insertions(+), 30 deletions(-) diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java index 3917240a31f6..1383e08e5ce1 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java @@ -34,7 +34,6 @@ import org.truffleruby.builtins.NonStandard; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.PrimitiveNode; import org.truffleruby.core.array.ArrayUtils; import org.truffleruby.core.array.RubyArray; import org.truffleruby.core.basicobject.BasicObjectNodes.ObjectIDNode; @@ -543,9 +542,7 @@ protected RubyDynamicObject copy(RubyIntOrLongRange range, } @Primitive(name = "object_clone") // "clone" - @NodeChild(value = "object", type = RubyNode.class) - @NodeChild(value = "freeze", type = RubyBaseNodeWithExecute.class) - public abstract static class CloneNode extends PrimitiveNode { + public abstract static class CloneNode extends PrimitiveArrayArgumentsNode { @Child IsCopyableObjectNode isCopyableObjectNode = IsCopyableObjectNodeGen.create(); @Child SingletonClassNode singletonClassNode; diff --git a/src/main/java/org/truffleruby/core/range/RangeNodes.java b/src/main/java/org/truffleruby/core/range/RangeNodes.java index 592e78f072ed..02345c563dfd 100644 --- a/src/main/java/org/truffleruby/core/range/RangeNodes.java +++ b/src/main/java/org/truffleruby/core/range/RangeNodes.java @@ -19,7 +19,6 @@ import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.PrimitiveNode; import org.truffleruby.builtins.YieldingCoreMethodNode; import org.truffleruby.core.array.ArrayBuilderNode; import org.truffleruby.core.array.ArrayBuilderNode.BuilderState; @@ -521,9 +520,7 @@ protected RubyObjectRange initializeCopy(RubyObjectRange self, RubyObjectRange f *

* {@code size} is assumed to be normalized: fitting in an int, and positive. */ @Primitive(name = "range_normalized_start_length", lowerFixnum = 1) - @NodeChild(value = "range", type = RubyNode.class) - @NodeChild(value = "size", type = RubyNode.class) - public abstract static class NormalizedStartLengthPrimitiveNode extends PrimitiveNode { + public abstract static class NormalizedStartLengthPrimitiveNode extends PrimitiveArrayArgumentsNode { @Child NormalizedStartLengthNode startLengthNode = NormalizedStartLengthNode.create(); diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java index dbb200e2f444..57792901b85b 100644 --- a/src/main/java/org/truffleruby/core/string/StringNodes.java +++ b/src/main/java/org/truffleruby/core/string/StringNodes.java @@ -4266,11 +4266,7 @@ protected RubyString splice( } @Primitive(name = "string_to_inum", lowerFixnum = 1) - @NodeChild(value = "string", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "fixBase", type = RubyNode.class) - @NodeChild(value = "strict", type = RubyNode.class) - @NodeChild(value = "raiseOnError", type = RubyNode.class) - public abstract static class StringToInumPrimitiveNode extends PrimitiveNode { + public abstract static class StringToInumPrimitiveNode extends PrimitiveArrayArgumentsNode { @Specialization(guards = "base == 10") protected Object base10(Object string, int base, boolean strict, boolean raiseOnError, diff --git a/src/main/java/org/truffleruby/core/support/TypeNodes.java b/src/main/java/org/truffleruby/core/support/TypeNodes.java index a151431f83c4..d77e84373c56 100644 --- a/src/main/java/org/truffleruby/core/support/TypeNodes.java +++ b/src/main/java/org/truffleruby/core/support/TypeNodes.java @@ -19,7 +19,6 @@ import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.PrimitiveNode; import org.truffleruby.core.array.ArrayGuards; import org.truffleruby.core.array.RubyArray; import org.truffleruby.core.array.library.ArrayStoreLibrary; @@ -421,15 +420,14 @@ public RubyNode cloneUninitialized() { } @Primitive(name = "check_mutable_string") - @NodeChild(value = "value", type = RubyNode.class) - public abstract static class CheckMutableStringNode extends PrimitiveNode { + public abstract static class CheckMutableStringNode extends PrimitiveArrayArgumentsNode { public static CheckMutableStringNode create() { return create(null); } public static CheckMutableStringNode create(RubyNode node) { - return TypeNodesFactory.CheckMutableStringNodeFactory.create(node); + return TypeNodesFactory.CheckMutableStringNodeFactory.create(new RubyNode[]{ node }); } public abstract void execute(Object object); @@ -457,8 +455,7 @@ protected Object checkImmutable(ImmutableRubyString value) { } @Primitive(name = "check_real?") - @NodeChild(value = "value", type = RubyNode.class) - public abstract static class CheckRealNode extends PrimitiveNode { + public abstract static class CheckRealNode extends PrimitiveArrayArgumentsNode { @Specialization protected boolean check(int value) { return true; @@ -486,8 +483,7 @@ protected boolean other(Object value, } @Primitive(name = "undefined?") - @NodeChild(value = "value", type = RubyNode.class) - public abstract static class IsUndefinedNode extends PrimitiveNode { + public abstract static class IsUndefinedNode extends PrimitiveArrayArgumentsNode { @Specialization protected boolean isUndefined(Object value) { @@ -496,8 +492,7 @@ protected boolean isUndefined(Object value) { } @Primitive(name = "as_boolean") - @NodeChild(value = "value", type = RubyNode.class) - public abstract static class AsBooleanNode extends PrimitiveNode { + public abstract static class AsBooleanNode extends PrimitiveArrayArgumentsNode { @Specialization protected boolean asBoolean(Object value, diff --git a/src/main/java/org/truffleruby/extra/TruffleGraalNodes.java b/src/main/java/org/truffleruby/extra/TruffleGraalNodes.java index 83c2daa02c34..c2caa8eb2fad 100644 --- a/src/main/java/org/truffleruby/extra/TruffleGraalNodes.java +++ b/src/main/java/org/truffleruby/extra/TruffleGraalNodes.java @@ -14,6 +14,7 @@ import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; +import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; import org.truffleruby.builtins.PrimitiveNode; import org.truffleruby.core.cast.ToCallTargetNode; import org.truffleruby.core.proc.ProcCallTargets; @@ -36,7 +37,6 @@ import com.oracle.truffle.api.CompilerDirectives; import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary; import com.oracle.truffle.api.RootCallTarget; -import com.oracle.truffle.api.dsl.NodeChild; import com.oracle.truffle.api.dsl.Specialization; import com.oracle.truffle.api.frame.MaterializedFrame; import com.oracle.truffle.api.nodes.NodeUtil; @@ -140,9 +140,8 @@ protected RubyProc copyCapturedLocals(RubyProc proc) { } - @NodeChild(value = "value", type = RubyNode.class) @Primitive(name = "assert_compilation_constant") - public abstract static class AssertCompilationConstantNode extends PrimitiveNode { + public abstract static class AssertCompilationConstantNode extends PrimitiveArrayArgumentsNode { @Specialization protected Object assertCompilationConstant(Object value) { @@ -178,8 +177,7 @@ private void compiledBoundary() { } @Primitive(name = "compiler_bailout") - @NodeChild(value = "value", type = RubyNode.class) - public abstract static class BailoutNode extends PrimitiveNode { + public abstract static class BailoutNode extends PrimitiveArrayArgumentsNode { @Specialization(guards = "strings.isRubyString(message)", limit = "1") protected Object bailout(Object message, @@ -190,9 +188,8 @@ protected Object bailout(Object message, } } - @NodeChild(value = "value", type = RubyNode.class) @Primitive(name = "blackhole") - public abstract static class BlackholeNode extends PrimitiveNode { + public abstract static class BlackholeNode extends PrimitiveArrayArgumentsNode { @Specialization protected Object blackhole(boolean value) { From fca32cbe4fef30720d52a9927dbe2279bc723327 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Thu, 1 Sep 2022 20:43:50 +0300 Subject: [PATCH 10/46] Implement cloneUninitialized() for PrimitiveNode direct ancestors --- .../core/cast/BigIntegerCastNode.java | 2 +- .../org/truffleruby/core/cast/ToStrNode.java | 2 +- .../core/cast/ToStringOrSymbolNode.java | 2 +- .../truffleruby/core/module/ModuleNodes.java | 70 ++++++++++++++++--- .../core/numeric/IntegerNodes.java | 46 ++++++++++-- .../truffleruby/core/string/StringNodes.java | 56 +++++++++++++-- 6 files changed, 154 insertions(+), 24 deletions(-) diff --git a/src/main/java/org/truffleruby/core/cast/BigIntegerCastNode.java b/src/main/java/org/truffleruby/core/cast/BigIntegerCastNode.java index b3c26dbd803b..18e5978a6aa5 100644 --- a/src/main/java/org/truffleruby/core/cast/BigIntegerCastNode.java +++ b/src/main/java/org/truffleruby/core/cast/BigIntegerCastNode.java @@ -28,7 +28,7 @@ public static BigIntegerCastNode create(RubyBaseNodeWithExecute value) { return BigIntegerCastNodeGen.create(value); } - abstract RubyBaseNodeWithExecute getValueNode(); + public abstract RubyBaseNodeWithExecute getValueNode(); @Specialization protected BigInteger doInt(int value) { diff --git a/src/main/java/org/truffleruby/core/cast/ToStrNode.java b/src/main/java/org/truffleruby/core/cast/ToStrNode.java index ee1e84f9a4ac..f876a95e6700 100644 --- a/src/main/java/org/truffleruby/core/cast/ToStrNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToStrNode.java @@ -37,7 +37,7 @@ public static ToStrNode create(RubyBaseNodeWithExecute child) { public abstract Object execute(Object object); - abstract RubyBaseNodeWithExecute getChildNode(); + public abstract RubyBaseNodeWithExecute getChildNode(); @Specialization protected RubyString coerceRubyString(RubyString string) { diff --git a/src/main/java/org/truffleruby/core/cast/ToStringOrSymbolNode.java b/src/main/java/org/truffleruby/core/cast/ToStringOrSymbolNode.java index 5bb0fdf3b7c4..d42a5767290b 100644 --- a/src/main/java/org/truffleruby/core/cast/ToStringOrSymbolNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToStringOrSymbolNode.java @@ -38,7 +38,7 @@ public static ToStringOrSymbolNode create(RubyBaseNodeWithExecute child) { public abstract Object execute(Object value); - abstract RubyBaseNodeWithExecute getChildNode(); + public abstract RubyBaseNodeWithExecute getChildNode(); @Specialization protected RubySymbol coerceRubySymbol(RubySymbol symbol) { diff --git a/src/main/java/org/truffleruby/core/module/ModuleNodes.java b/src/main/java/org/truffleruby/core/module/ModuleNodes.java index ce2229b21d0c..177f5dc55b6a 100644 --- a/src/main/java/org/truffleruby/core/module/ModuleNodes.java +++ b/src/main/java/org/truffleruby/core/module/ModuleNodes.java @@ -50,6 +50,7 @@ import org.truffleruby.core.cast.ToPathNode; import org.truffleruby.core.cast.ToPathNodeGen; import org.truffleruby.core.cast.ToStrNode; +import org.truffleruby.core.cast.ToStringOrSymbolNode; import org.truffleruby.core.cast.ToStringOrSymbolNodeGen; import org.truffleruby.core.cast.ToSymbolNode; import org.truffleruby.core.constant.WarnAlreadyInitializedNode; @@ -1181,11 +1182,11 @@ public RubyNode cloneUninitialized() { } @Primitive(name = "module_const_get") - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "inherit", type = RubyNode.class) - @NodeChild(value = "look_in_object", type = RubyNode.class) - @NodeChild(value = "check_name", type = RubyNode.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "inheritNode", type = RubyNode.class) + @NodeChild(value = "lookInObjectNode", type = RubyNode.class) + @NodeChild(value = "checkNameNode", type = RubyNode.class) public abstract static class ConstGetNode extends PrimitiveNode { @Child private LookupConstantNode lookupConstantLookInObjectNode = LookupConstantNode.create(true, true); @@ -1193,7 +1194,22 @@ public abstract static class ConstGetNode extends PrimitiveNode { @Child private GetConstantNode getConstantNode = GetConstantNode.create(); @Child private ByteIndexOfStringNode byteIndexOfStringNode; - @CreateCast("name") + public static ConstGetNode create(RubyNode module, RubyBaseNodeWithExecute name, RubyNode inherit, + RubyNode lookInObject, RubyNode checkName) { + return ModuleNodesFactory.ConstGetNodeFactory.create(module, name, inherit, lookInObject, checkName); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + abstract RubyNode getInheritNode(); + + abstract RubyNode getLookInObjectNode(); + + abstract RubyNode getCheckNameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToSymbolOrString(RubyBaseNodeWithExecute name) { // We want to know if the name is a Symbol, as then scoped lookup is not tried return ToStringOrSymbolNodeGen.create(name); @@ -1309,6 +1325,22 @@ protected int getLimit() { return getLanguage().options.CONSTANT_CACHE; } + RubyBaseNodeWithExecute getNameBeforeCasting() { + return ((ToStringOrSymbolNode) getNameNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameBeforeCasting().cloneUninitialized(), + getInheritNode().cloneUninitialized(), + getLookInObjectNode().cloneUninitialized(), + getCheckNameNode().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "const_missing", required = 1) @@ -2570,11 +2602,19 @@ public RubyNode cloneUninitialized() { } @Primitive(name = "module_remove_const") - @NodeChild(value = "module", type = RubyNode.class) - @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduleNode", type = RubyNode.class) + @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) public abstract static class RemoveConstNode extends PrimitiveNode { - @CreateCast("name") + public static RemoveConstNode create(RubyNode module, RubyBaseNodeWithExecute name) { + return ModuleNodesFactory.RemoveConstNodeFactory.create(module, name); + } + + abstract RubyNode getModuleNode(); + + abstract RubyBaseNodeWithExecute getNameNode(); + + @CreateCast("nameNode") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -2595,6 +2635,18 @@ protected Object removeConstant(RubyModule module, String name) { } } + RubyBaseNodeWithExecute getNameNodeBeforeCasting() { + return ((NameToJavaStringNode) getNameNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getModuleNode().cloneUninitialized(), + getNameNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } } @CoreMethod(names = "remove_method", rest = true) diff --git a/src/main/java/org/truffleruby/core/numeric/IntegerNodes.java b/src/main/java/org/truffleruby/core/numeric/IntegerNodes.java index e227860a435a..484e9f8c1ace 100644 --- a/src/main/java/org/truffleruby/core/numeric/IntegerNodes.java +++ b/src/main/java/org/truffleruby/core/numeric/IntegerNodes.java @@ -39,6 +39,7 @@ import org.truffleruby.language.NoImplicitCastsToLong; import org.truffleruby.language.NotProvided; import org.truffleruby.language.RubyBaseNodeWithExecute; +import org.truffleruby.language.RubyNode; import org.truffleruby.language.WarnNode; import org.truffleruby.language.control.RaiseException; import org.truffleruby.language.dispatch.DispatchNode; @@ -1867,24 +1868,35 @@ protected int getLimit() { } @Primitive(name = "mod_pow") - @NodeChild(value = "base", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "exponent", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "modulo", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "baseNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "exponentNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "moduloNode", type = RubyBaseNodeWithExecute.class) public abstract static class ModPowNode extends PrimitiveNode { @Child private FixnumOrBignumNode fixnumOrBignum = new FixnumOrBignumNode(); - @CreateCast("base") + public static ModPowNode create(RubyBaseNodeWithExecute base, RubyBaseNodeWithExecute exponent, + RubyBaseNodeWithExecute modulo) { + return IntegerNodesFactory.ModPowNodeFactory.create(base, exponent, modulo); + } + + abstract RubyBaseNodeWithExecute getBaseNode(); + + abstract RubyBaseNodeWithExecute getExponentNode(); + + abstract RubyBaseNodeWithExecute getModuloNode(); + + @CreateCast("baseNode") protected RubyBaseNodeWithExecute baseToBigInteger(RubyBaseNodeWithExecute base) { return BigIntegerCastNode.create(base); } - @CreateCast("exponent") + @CreateCast("exponentNode") protected RubyBaseNodeWithExecute exponentToBigInteger(RubyBaseNodeWithExecute exponent) { return BigIntegerCastNode.create(exponent); } - @CreateCast("modulo") + @CreateCast("moduloNode") protected RubyBaseNodeWithExecute moduloToBigInteger(RubyBaseNodeWithExecute modulo) { return BigIntegerCastNode.create(modulo); } @@ -1905,6 +1917,28 @@ protected Object mod_pow_pos(BigInteger base, BigInteger exponent, BigInteger mo protected Object mod_pow_zero(BigInteger base, BigInteger exponent, BigInteger modulo) { throw new RaiseException(getContext(), coreExceptions().zeroDivisionError(this)); } + + RubyBaseNodeWithExecute getBaseNodeBeforeCasting() { + return ((BigIntegerCastNode) getBaseNode()).getValueNode(); + } + + RubyBaseNodeWithExecute getExponentNodeBeforeCasting() { + return ((BigIntegerCastNode) getExponentNode()).getValueNode(); + } + + RubyBaseNodeWithExecute getModuloNodeBeforeCasting() { + return ((BigIntegerCastNode) getModuloNode()).getValueNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getBaseNodeBeforeCasting().cloneUninitialized(), + getExponentNodeBeforeCasting().cloneUninitialized(), + getModuloNodeBeforeCasting().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } } @CoreMethod(names = "downto", needsBlock = true, required = 1, returnsEnumeratorIfNoBlock = true) diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java index 57792901b85b..19362f86634c 100644 --- a/src/main/java/org/truffleruby/core/string/StringNodes.java +++ b/src/main/java/org/truffleruby/core/string/StringNodes.java @@ -850,8 +850,8 @@ protected int byteSize(Object string, } @Primitive(name = "string_casecmp") - @NodeChild(value = "string", type = RubyNode.class) - @NodeChild(value = "other", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "stringNode", type = RubyNode.class) + @NodeChild(value = "otherNode", type = RubyBaseNodeWithExecute.class) public abstract static class CaseCmpNode extends PrimitiveNode { @Child private NegotiateCompatibleEncodingNode negotiateCompatibleEncodingNode = NegotiateCompatibleEncodingNode @@ -860,7 +860,15 @@ public abstract static class CaseCmpNode extends PrimitiveNode { private final ConditionProfile incompatibleEncodingProfile = ConditionProfile.create(); private final ConditionProfile sameProfile = ConditionProfile.create(); - @CreateCast("other") + public static CaseCmpNode create(RubyNode string, RubyBaseNodeWithExecute other) { + return StringNodesFactory.CaseCmpNodeFactory.create(string, other); + } + + abstract RubyNode getStringNode(); + + abstract RubyBaseNodeWithExecute getOtherNode(); + + @CreateCast("otherNode") protected ToStrNode coerceOtherToString(RubyBaseNodeWithExecute other) { return ToStrNodeGen.create(other); } @@ -942,6 +950,21 @@ private static int caseInsensitiveCmp(InternalByteArray value, InternalByteArray return size == other.getLength() ? 0 : size == len ? -1 : 1; } + + + private RubyBaseNodeWithExecute getOtherNodeBeforeCast() { + return ((ToStrNode) getOtherNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getStringNode().cloneUninitialized(), + getOtherNodeBeforeCast().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } /** Returns true if the first bytes in string are equal to the bytes in prefix. */ @@ -1775,11 +1798,19 @@ protected int ord(Object string, } @Primitive(name = "string_replace", raiseIfNotMutable = 0) - @NodeChild(value = "string", type = RubyNode.class) - @NodeChild(value = "other", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "stringNode", type = RubyNode.class) + @NodeChild(value = "otherNode", type = RubyBaseNodeWithExecute.class) public abstract static class ReplaceNode extends PrimitiveNode { - @CreateCast("other") + public static ReplaceNode create(RubyNode string, RubyBaseNodeWithExecute other) { + return StringNodesFactory.ReplaceNodeFactory.create(string, other); + } + + abstract RubyNode getStringNode(); + + abstract RubyBaseNodeWithExecute getOtherNode(); + + @CreateCast("otherNode") protected ToStrNode coerceOtherToString(RubyBaseNodeWithExecute other) { return ToStrNodeGen.create(other); } @@ -1806,6 +1837,19 @@ protected RubyString replace(RubyString string, ImmutableRubyString other, return string; } + private RubyBaseNodeWithExecute getOtherNodeBeforeCast() { + return ((ToStrNode) getOtherNode()).getChildNode(); + } + + @Override + public RubyNode cloneUninitialized() { + var copy = create( + getStringNode().cloneUninitialized(), + getOtherNodeBeforeCast().cloneUninitialized()); + copy.copyFlags(this); + return copy; + } + } @CoreMethod(names = "rstrip!", raiseIfNotMutableSelf = true) From 1bd2bd1d5d8c8529f572748242766fd6f257048a Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Fri, 2 Sep 2022 17:57:06 +0300 Subject: [PATCH 11/46] Refactoring: remove not used ReadKeywordRestArgumentNode's constructor argument --- .../language/arguments/ReadKeywordRestArgumentNode.java | 2 +- .../java/org/truffleruby/parser/LoadArgumentsTranslator.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java index cbb03f83429b..5c744a4ef5b7 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java @@ -33,7 +33,7 @@ public class ReadKeywordRestArgumentNode extends RubyContextSourceNode implement private final ConditionProfile noHash = ConditionProfile.create(); - public ReadKeywordRestArgumentNode(RubyLanguage language, int minimum, Arity arity) { + public ReadKeywordRestArgumentNode(RubyLanguage language, Arity arity) { this(CheckKeywordArityNode.keywordsAsSymbols(language, arity)); } diff --git a/src/main/java/org/truffleruby/parser/LoadArgumentsTranslator.java b/src/main/java/org/truffleruby/parser/LoadArgumentsTranslator.java index e7608a9f1770..3e447c0b3d1a 100644 --- a/src/main/java/org/truffleruby/parser/LoadArgumentsTranslator.java +++ b/src/main/java/org/truffleruby/parser/LoadArgumentsTranslator.java @@ -251,7 +251,7 @@ public RubyNode translate() { @Override public RubyNode visitKeywordRestArgNode(KeywordRestArgParseNode node) { - final RubyNode readNode = new ReadKeywordRestArgumentNode(language, required, argsNode.getArity()); + final RubyNode readNode = new ReadKeywordRestArgumentNode(language, argsNode.getArity()); final int slot = methodBodyTranslator.getEnvironment().declareVar(node.getName()); return new WriteLocalVariableNode(slot, readNode); From 742b60ccdd877ae58e4eec50461d1e44774a7c81 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Thu, 8 Sep 2022 15:20:02 +0300 Subject: [PATCH 12/46] Nullify receiver, block and arguments in InlinedReplaceableNode --- .../core/inlined/InlinedReplaceableNode.java | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java index 701190e25f53..f849c43aefa5 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java @@ -35,7 +35,19 @@ protected InlinedReplaceableNode( RubyLanguage language, RubyCallNodeParameters callNodeParameters, Assumption... assumptions) { - this.parameters = callNodeParameters; + // nullify receiver, arguments and block for clarity + // because they should be overriden in subclasses. + this.parameters = new RubyCallNodeParameters( + null, + callNodeParameters.getMethodName(), + null, + callNodeParameters.getDescriptor(), + null, + callNodeParameters.isSplatted(), + callNodeParameters.isIgnoreVisibility(), + callNodeParameters.isVCall(), + callNodeParameters.isSafeNavigation(), + callNodeParameters.isAttrAssign()); this.assumptions = new Assumption[1 + assumptions.length]; this.assumptions[0] = language.traceFuncUnusedAssumption.getAssumption(); @@ -69,7 +81,8 @@ protected RubyCallNode rewriteToCallNode() { protected abstract RubyNode[] getArgumentNodes(); protected RubyNode getBlockNode() { - return parameters.getBlock(); + assert parameters.getBlock() == null; + return null; } @Override From 1a2f95d0a1232ed58f6c4606716286d55591efb2 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Tue, 13 Sep 2022 20:25:54 +0300 Subject: [PATCH 13/46] Refactoring: Remove UnaryCoreMethodNode and use CoreMethodArrayArgumentsNode instead --- .../builtins/UnaryCoreMethodNode.java | 18 ----------------- .../core/basicobject/BasicObjectNodes.java | 3 +-- .../core/binding/BindingNodes.java | 10 +++++----- .../core/bool/FalseClassNodes.java | 6 +++--- .../truffleruby/core/bool/TrueClassNodes.java | 5 ++--- .../core/encoding/EncodingNodes.java | 3 +-- .../truffleruby/core/fiber/FiberNodes.java | 3 +-- .../truffleruby/core/klass/ClassNodes.java | 3 +-- .../truffleruby/core/method/MethodNodes.java | 3 +-- .../core/method/UnboundMethodNodes.java | 3 +-- .../truffleruby/core/mutex/MutexNodes.java | 11 +++++----- .../core/objectspace/WeakMapNodes.java | 9 ++++----- .../org/truffleruby/core/proc/ProcNodes.java | 5 ++--- .../core/regexp/MatchDataNodes.java | 3 +-- .../core/support/ByteArrayNodes.java | 3 +-- .../core/support/CustomRandomizerNodes.java | 4 ++-- .../org/truffleruby/core/support/IONodes.java | 3 +-- .../core/support/PRNGRandomizerNodes.java | 3 +-- .../core/support/SecureRandomizerNodes.java | 4 ++-- .../truffleruby/core/symbol/SymbolNodes.java | 3 +-- .../thread/ThreadBacktraceLocationNodes.java | 14 ++++++------- .../truffleruby/core/thread/ThreadNodes.java | 3 +-- .../core/tracepoint/TracePointNodes.java | 3 +-- .../truffleruby/extra/ffi/PointerNodes.java | 3 +-- .../interop/SourceLocationNodes.java | 20 +++++++++---------- 25 files changed, 56 insertions(+), 92 deletions(-) delete mode 100644 src/main/java/org/truffleruby/builtins/UnaryCoreMethodNode.java diff --git a/src/main/java/org/truffleruby/builtins/UnaryCoreMethodNode.java b/src/main/java/org/truffleruby/builtins/UnaryCoreMethodNode.java deleted file mode 100644 index 3de5a0c79404..000000000000 --- a/src/main/java/org/truffleruby/builtins/UnaryCoreMethodNode.java +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2013, 2019 Oracle and/or its affiliates. All rights reserved. This - * code is released under a tri EPL/GPL/LGPL license. You can use it, - * redistribute it and/or modify it under the terms of the: - * - * Eclipse Public License version 2.0, or - * GNU General Public License version 2, or - * GNU Lesser General Public License version 2.1. - */ -package org.truffleruby.builtins; - - -public abstract class UnaryCoreMethodNode extends CoreMethodArrayArgumentsNode { - - public UnaryCoreMethodNode() { - } - -} diff --git a/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java b/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java index 3930e1189daf..cc230a9fb35d 100644 --- a/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java +++ b/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java @@ -19,7 +19,6 @@ import org.truffleruby.builtins.CoreMethod; import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.basicobject.BasicObjectNodesFactory.InstanceExecNodeFactory; import org.truffleruby.core.basicobject.BasicObjectNodesFactory.ReferenceEqualNodeFactory; import org.truffleruby.core.cast.BooleanCastNode; @@ -92,7 +91,7 @@ public abstract class BasicObjectNodes { @CoreMethod(names = "!") - public abstract static class NotNode extends UnaryCoreMethodNode { + public abstract static class NotNode extends CoreMethodArrayArgumentsNode { @Specialization protected boolean not(Object value, diff --git a/src/main/java/org/truffleruby/core/binding/BindingNodes.java b/src/main/java/org/truffleruby/core/binding/BindingNodes.java index 3dab4d2745dc..50982114a981 100644 --- a/src/main/java/org/truffleruby/core/binding/BindingNodes.java +++ b/src/main/java/org/truffleruby/core/binding/BindingNodes.java @@ -23,10 +23,10 @@ import org.truffleruby.RubyContext; import org.truffleruby.RubyLanguage; import org.truffleruby.builtins.CoreMethod; +import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.array.ArrayHelpers; import org.truffleruby.core.array.RubyArray; import org.truffleruby.core.cast.NameToJavaStringNode; @@ -162,7 +162,7 @@ private static boolean isHiddenVariable(String name) { } @CoreMethod(names = { "dup", "clone" }) - public abstract static class DupNode extends UnaryCoreMethodNode { + public abstract static class DupNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyBinding dup(RubyBinding binding) { return new RubyBinding( @@ -519,7 +519,7 @@ protected int getCacheLimit() { } @CoreMethod(names = "receiver") - public abstract static class ReceiverNode extends UnaryCoreMethodNode { + public abstract static class ReceiverNode extends CoreMethodArrayArgumentsNode { @Specialization protected Object receiver(RubyBinding binding) { @@ -529,7 +529,7 @@ protected Object receiver(RubyBinding binding) { // NOTE: Introduced in Ruby 2.6, but already useful for Binding#eval @CoreMethod(names = "source_location") - public abstract static class SourceLocationNode extends UnaryCoreMethodNode { + public abstract static class SourceLocationNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization @@ -549,7 +549,7 @@ protected Object sourceLocation(RubyBinding binding, } @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected Object allocate(RubyClass rubyClass) { diff --git a/src/main/java/org/truffleruby/core/bool/FalseClassNodes.java b/src/main/java/org/truffleruby/core/bool/FalseClassNodes.java index 69904155084b..4bc4daa0b7be 100644 --- a/src/main/java/org/truffleruby/core/bool/FalseClassNodes.java +++ b/src/main/java/org/truffleruby/core/bool/FalseClassNodes.java @@ -10,8 +10,8 @@ package org.truffleruby.core.bool; import org.truffleruby.builtins.CoreMethod; +import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.cast.BooleanCastNode; import com.oracle.truffle.api.dsl.Cached; @@ -21,7 +21,7 @@ public abstract class FalseClassNodes { @CoreMethod(names = "&", needsSelf = false, required = 1) - public abstract static class AndNode extends UnaryCoreMethodNode { + public abstract static class AndNode extends CoreMethodArrayArgumentsNode { @Specialization protected boolean and(Object other) { @@ -30,7 +30,7 @@ protected boolean and(Object other) { } @CoreMethod(names = { "|", "^" }, needsSelf = false, required = 1) - public abstract static class OrXorNode extends UnaryCoreMethodNode { + public abstract static class OrXorNode extends CoreMethodArrayArgumentsNode { @Specialization protected boolean orXor(Object other, diff --git a/src/main/java/org/truffleruby/core/bool/TrueClassNodes.java b/src/main/java/org/truffleruby/core/bool/TrueClassNodes.java index 700a10b4d3b0..07705deb6b29 100644 --- a/src/main/java/org/truffleruby/core/bool/TrueClassNodes.java +++ b/src/main/java/org/truffleruby/core/bool/TrueClassNodes.java @@ -12,7 +12,6 @@ import org.truffleruby.builtins.CoreMethod; import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.cast.BooleanCastNode; import com.oracle.truffle.api.dsl.Cached; @@ -22,7 +21,7 @@ public abstract class TrueClassNodes { @CoreMethod(names = "&", needsSelf = false, required = 1) - public abstract static class AndNode extends UnaryCoreMethodNode { + public abstract static class AndNode extends CoreMethodArrayArgumentsNode { @Specialization protected boolean and(Object other, @@ -41,7 +40,7 @@ protected boolean or(Object other) { } @CoreMethod(names = "^", needsSelf = false, required = 1) - public abstract static class XorNode extends UnaryCoreMethodNode { + public abstract static class XorNode extends CoreMethodArrayArgumentsNode { @Specialization protected boolean xor(Object other, diff --git a/src/main/java/org/truffleruby/core/encoding/EncodingNodes.java b/src/main/java/org/truffleruby/core/encoding/EncodingNodes.java index 7dd33035b1e7..d37f23ac5488 100644 --- a/src/main/java/org/truffleruby/core/encoding/EncodingNodes.java +++ b/src/main/java/org/truffleruby/core/encoding/EncodingNodes.java @@ -20,7 +20,6 @@ import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.array.ArrayUtils; import org.truffleruby.core.array.RubyArray; import org.truffleruby.core.cast.ToRubyEncodingNode; @@ -479,7 +478,7 @@ protected ImmutableRubyString toS(RubyEncoding encoding) { } @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected Object allocate(RubyClass rubyClass) { throw new RaiseException(getContext(), coreExceptions().typeErrorAllocatorUndefinedFor(rubyClass, this)); diff --git a/src/main/java/org/truffleruby/core/fiber/FiberNodes.java b/src/main/java/org/truffleruby/core/fiber/FiberNodes.java index 40bc6cfd97f5..bf6f5c27cf0c 100644 --- a/src/main/java/org/truffleruby/core/fiber/FiberNodes.java +++ b/src/main/java/org/truffleruby/core/fiber/FiberNodes.java @@ -17,7 +17,6 @@ import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.array.RubyArray; import org.truffleruby.core.cast.SingleValueCastNode; import org.truffleruby.core.cast.SingleValueCastNodeGen; @@ -313,7 +312,7 @@ protected Object fiberYield(VirtualFrame frame, Object[] rawArgs, } @CoreMethod(names = "alive?") - public abstract static class AliveNode extends UnaryCoreMethodNode { + public abstract static class AliveNode extends CoreMethodArrayArgumentsNode { @Specialization protected boolean alive(RubyFiber fiber) { diff --git a/src/main/java/org/truffleruby/core/klass/ClassNodes.java b/src/main/java/org/truffleruby/core/klass/ClassNodes.java index b044af1d9d92..80caa9b2c530 100644 --- a/src/main/java/org/truffleruby/core/klass/ClassNodes.java +++ b/src/main/java/org/truffleruby/core/klass/ClassNodes.java @@ -19,7 +19,6 @@ import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.CoreLibrary; import org.truffleruby.core.inlined.AlwaysInlinedMethodNode; import org.truffleruby.core.module.RubyModule; @@ -310,7 +309,7 @@ protected Object getSuperClass(RubyClass rubyClass) { } @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected Object allocate(RubyClass rubyClass) { throw new RaiseException(getContext(), coreExceptions().typeErrorAllocatorUndefinedFor(rubyClass, this)); diff --git a/src/main/java/org/truffleruby/core/method/MethodNodes.java b/src/main/java/org/truffleruby/core/method/MethodNodes.java index 44eaceaea899..df35ceb37b86 100644 --- a/src/main/java/org/truffleruby/core/method/MethodNodes.java +++ b/src/main/java/org/truffleruby/core/method/MethodNodes.java @@ -17,7 +17,6 @@ import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.Hashing; import org.truffleruby.core.array.RubyArray; import org.truffleruby.core.basicobject.BasicObjectNodes.ReferenceEqualNode; @@ -410,7 +409,7 @@ protected boolean unbound(RubyUnboundMethod rubyMethod) { } @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization diff --git a/src/main/java/org/truffleruby/core/method/UnboundMethodNodes.java b/src/main/java/org/truffleruby/core/method/UnboundMethodNodes.java index 10ea2fa9d237..5891305701ff 100644 --- a/src/main/java/org/truffleruby/core/method/UnboundMethodNodes.java +++ b/src/main/java/org/truffleruby/core/method/UnboundMethodNodes.java @@ -17,7 +17,6 @@ import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.Hashing; import org.truffleruby.core.array.RubyArray; import org.truffleruby.core.encoding.Encodings; @@ -249,7 +248,7 @@ public static Object ruby2Keywords(SharedMethodInfo sharedMethodInfo, RootCallTa } @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization diff --git a/src/main/java/org/truffleruby/core/mutex/MutexNodes.java b/src/main/java/org/truffleruby/core/mutex/MutexNodes.java index 7180ce4b8d04..c94e08be6705 100644 --- a/src/main/java/org/truffleruby/core/mutex/MutexNodes.java +++ b/src/main/java/org/truffleruby/core/mutex/MutexNodes.java @@ -16,7 +16,6 @@ import org.truffleruby.builtins.CoreMethod; import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.builtins.YieldingCoreMethodNode; import org.truffleruby.core.cast.DurationToNanoSecondsNode; import org.truffleruby.core.kernel.KernelNodes; @@ -46,7 +45,7 @@ protected RubyMutex allocate(RubyClass rubyClass) { } @CoreMethod(names = "lock") - public abstract static class LockNode extends UnaryCoreMethodNode { + public abstract static class LockNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyMutex lock(RubyMutex mutex, @@ -66,7 +65,7 @@ protected RubyMutex lock(RubyMutex mutex, } @CoreMethod(names = "locked?") - public abstract static class IsLockedNode extends UnaryCoreMethodNode { + public abstract static class IsLockedNode extends CoreMethodArrayArgumentsNode { @Specialization protected boolean isLocked(RubyMutex mutex) { @@ -76,7 +75,7 @@ protected boolean isLocked(RubyMutex mutex) { } @CoreMethod(names = "owned?") - public abstract static class IsOwnedNode extends UnaryCoreMethodNode { + public abstract static class IsOwnedNode extends CoreMethodArrayArgumentsNode { @Specialization protected boolean isOwned(RubyMutex mutex) { return mutex.lock.isHeldByCurrentThread(); @@ -84,7 +83,7 @@ protected boolean isOwned(RubyMutex mutex) { } @CoreMethod(names = "try_lock") - public abstract static class TryLockNode extends UnaryCoreMethodNode { + public abstract static class TryLockNode extends CoreMethodArrayArgumentsNode { @Specialization protected boolean tryLock(RubyMutex mutex, @@ -101,7 +100,7 @@ protected boolean tryLock(RubyMutex mutex, } @CoreMethod(names = "unlock") - public abstract static class UnlockNode extends UnaryCoreMethodNode { + public abstract static class UnlockNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyMutex unlock(RubyMutex mutex, diff --git a/src/main/java/org/truffleruby/core/objectspace/WeakMapNodes.java b/src/main/java/org/truffleruby/core/objectspace/WeakMapNodes.java index 72910e41f640..96d40e47d5fe 100644 --- a/src/main/java/org/truffleruby/core/objectspace/WeakMapNodes.java +++ b/src/main/java/org/truffleruby/core/objectspace/WeakMapNodes.java @@ -14,7 +14,6 @@ import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.builtins.YieldingCoreMethodNode; import org.truffleruby.collections.SimpleEntry; import org.truffleruby.core.array.RubyArray; @@ -37,7 +36,7 @@ public abstract class WeakMapNodes { @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyWeakMap allocate(RubyClass rubyClass) { @@ -48,7 +47,7 @@ protected RubyWeakMap allocate(RubyClass rubyClass) { } @CoreMethod(names = { "size", "length" }) - public abstract static class SizeNode extends UnaryCoreMethodNode { + public abstract static class SizeNode extends CoreMethodArrayArgumentsNode { @Specialization protected int size(RubyWeakMap map) { @@ -86,7 +85,7 @@ protected Object set(RubyWeakMap map, Object key, Object value) { } @CoreMethod(names = { "keys" }) - public abstract static class KeysNode extends UnaryCoreMethodNode { + public abstract static class KeysNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyArray getKeys(RubyWeakMap map) { @@ -95,7 +94,7 @@ protected RubyArray getKeys(RubyWeakMap map) { } @CoreMethod(names = { "values" }) - public abstract static class ValuesNode extends UnaryCoreMethodNode { + public abstract static class ValuesNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyArray getValues(RubyWeakMap map) { diff --git a/src/main/java/org/truffleruby/core/proc/ProcNodes.java b/src/main/java/org/truffleruby/core/proc/ProcNodes.java index d96b336008d5..13b3f1ae337c 100644 --- a/src/main/java/org/truffleruby/core/proc/ProcNodes.java +++ b/src/main/java/org/truffleruby/core/proc/ProcNodes.java @@ -19,7 +19,6 @@ import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; import org.truffleruby.builtins.PrimitiveNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.array.RubyArray; import org.truffleruby.core.binding.BindingNodes; import org.truffleruby.core.binding.RubyBinding; @@ -53,7 +52,7 @@ public abstract class ProcNodes { @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyProc allocate(RubyClass rubyClass) { @@ -109,7 +108,7 @@ protected RubyClass metaClass(RubyProc object) { } @CoreMethod(names = { "dup", "clone" }) - public abstract static class DupNode extends UnaryCoreMethodNode { + public abstract static class DupNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyProc dup(RubyProc proc) { diff --git a/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java b/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java index 0b03c007bcb4..dc0479bf1f75 100644 --- a/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java +++ b/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java @@ -27,7 +27,6 @@ import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.array.ArrayOperations; import org.truffleruby.core.array.ArrayUtils; import org.truffleruby.core.array.RubyArray; @@ -707,7 +706,7 @@ protected RubyRegexp regexp(RubyMatchData matchData, // Defined only so that #initialize_copy works for #dup and #clone. // MatchData.allocate is undefined, see regexp.rb. @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class InternalAllocateNode extends UnaryCoreMethodNode { + public abstract static class InternalAllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyMatchData allocate(RubyClass rubyClass) { diff --git a/src/main/java/org/truffleruby/core/support/ByteArrayNodes.java b/src/main/java/org/truffleruby/core/support/ByteArrayNodes.java index f27cb7661624..89d0f2c38c43 100644 --- a/src/main/java/org/truffleruby/core/support/ByteArrayNodes.java +++ b/src/main/java/org/truffleruby/core/support/ByteArrayNodes.java @@ -16,7 +16,6 @@ import org.truffleruby.builtins.CoreMethod; import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.encoding.TStringUtils; import org.truffleruby.core.klass.RubyClass; import org.truffleruby.core.string.RubyString; @@ -38,7 +37,7 @@ public abstract class ByteArrayNodes { @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyByteArray allocate(RubyClass rubyClass) { diff --git a/src/main/java/org/truffleruby/core/support/CustomRandomizerNodes.java b/src/main/java/org/truffleruby/core/support/CustomRandomizerNodes.java index 80e98b14c9ae..c6a2ad0a3875 100644 --- a/src/main/java/org/truffleruby/core/support/CustomRandomizerNodes.java +++ b/src/main/java/org/truffleruby/core/support/CustomRandomizerNodes.java @@ -10,8 +10,8 @@ package org.truffleruby.core.support; import org.truffleruby.builtins.CoreMethod; +import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.klass.RubyClass; import org.truffleruby.language.Visibility; @@ -21,7 +21,7 @@ public abstract class CustomRandomizerNodes { @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyCustomRandomizer randomizerAllocate(RubyClass customRandomizerClass) { diff --git a/src/main/java/org/truffleruby/core/support/IONodes.java b/src/main/java/org/truffleruby/core/support/IONodes.java index 17fd4d57f3b6..4803d38f8cd0 100644 --- a/src/main/java/org/truffleruby/core/support/IONodes.java +++ b/src/main/java/org/truffleruby/core/support/IONodes.java @@ -74,7 +74,6 @@ import org.truffleruby.builtins.NonStandard; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.encoding.Encodings; import org.truffleruby.core.klass.RubyClass; import org.truffleruby.core.thread.RubyThread; @@ -98,7 +97,7 @@ public abstract class IONodes { @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyIO allocate(RubyClass rubyClass) { diff --git a/src/main/java/org/truffleruby/core/support/PRNGRandomizerNodes.java b/src/main/java/org/truffleruby/core/support/PRNGRandomizerNodes.java index 8e96f875d9e5..923618d8d33b 100644 --- a/src/main/java/org/truffleruby/core/support/PRNGRandomizerNodes.java +++ b/src/main/java/org/truffleruby/core/support/PRNGRandomizerNodes.java @@ -44,7 +44,6 @@ import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.encoding.Encodings; import org.truffleruby.core.klass.RubyClass; import org.truffleruby.core.numeric.BignumOperations; @@ -76,7 +75,7 @@ public static void resetSeed(RubyContext context, RubyPRNGRandomizer random) { } @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyPRNGRandomizer randomizerAllocate(RubyClass randomizerClass) { diff --git a/src/main/java/org/truffleruby/core/support/SecureRandomizerNodes.java b/src/main/java/org/truffleruby/core/support/SecureRandomizerNodes.java index da0d0b6f68cd..75f19e3def82 100644 --- a/src/main/java/org/truffleruby/core/support/SecureRandomizerNodes.java +++ b/src/main/java/org/truffleruby/core/support/SecureRandomizerNodes.java @@ -10,8 +10,8 @@ package org.truffleruby.core.support; import org.truffleruby.builtins.CoreMethod; +import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.klass.RubyClass; import org.truffleruby.language.Visibility; @@ -21,7 +21,7 @@ public abstract class SecureRandomizerNodes { @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubySecureRandomizer randomizerAllocate(RubyClass secureRandomizerClass) { diff --git a/src/main/java/org/truffleruby/core/symbol/SymbolNodes.java b/src/main/java/org/truffleruby/core/symbol/SymbolNodes.java index 91cea034032c..ba7b2a8e9930 100644 --- a/src/main/java/org/truffleruby/core/symbol/SymbolNodes.java +++ b/src/main/java/org/truffleruby/core/symbol/SymbolNodes.java @@ -18,7 +18,6 @@ import org.truffleruby.builtins.CoreMethod; import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.collections.ConcurrentOperations; import org.truffleruby.core.CoreLibrary; import org.truffleruby.core.array.RubyArray; @@ -275,7 +274,7 @@ protected ImmutableRubyString toS(RubySymbol symbol) { } @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected Object allocate(RubyClass rubyClass) { throw new RaiseException(getContext(), coreExceptions().typeErrorAllocatorUndefinedFor(rubyClass, this)); diff --git a/src/main/java/org/truffleruby/core/thread/ThreadBacktraceLocationNodes.java b/src/main/java/org/truffleruby/core/thread/ThreadBacktraceLocationNodes.java index 1548434405d7..51aa931ff188 100644 --- a/src/main/java/org/truffleruby/core/thread/ThreadBacktraceLocationNodes.java +++ b/src/main/java/org/truffleruby/core/thread/ThreadBacktraceLocationNodes.java @@ -12,8 +12,8 @@ import com.oracle.truffle.api.strings.TruffleString; import org.truffleruby.RubyContext; import org.truffleruby.builtins.CoreMethod; +import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.encoding.Encodings; import org.truffleruby.core.encoding.TStringUtils; import org.truffleruby.core.string.RubyString; @@ -43,7 +43,7 @@ private static SourceSection getAvailableSourceSection(RubyContext context, } @CoreMethod(names = "absolute_path") - public abstract static class AbsolutePathNode extends UnaryCoreMethodNode { + public abstract static class AbsolutePathNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization @@ -80,7 +80,7 @@ public static Object getAbsolutePath(SourceSection sourceSection, RubyBaseNode n } @CoreMethod(names = "path") - public abstract static class PathNode extends UnaryCoreMethodNode { + public abstract static class PathNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization @@ -98,7 +98,7 @@ protected RubyString path(RubyBacktraceLocation threadBacktraceLocation) { } @CoreMethod(names = "label") - public abstract static class LabelNode extends UnaryCoreMethodNode { + public abstract static class LabelNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyString label(RubyBacktraceLocation threadBacktraceLocation, @@ -113,7 +113,7 @@ protected RubyString label(RubyBacktraceLocation threadBacktraceLocation, } @CoreMethod(names = "base_label") - public abstract static class BaseLabelNode extends UnaryCoreMethodNode { + public abstract static class BaseLabelNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyString label(RubyBacktraceLocation threadBacktraceLocation, @Cached TruffleString.FromJavaStringNode fromJavaStringNode) { @@ -127,7 +127,7 @@ protected RubyString label(RubyBacktraceLocation threadBacktraceLocation, } @CoreMethod(names = "lineno") - public abstract static class LinenoNode extends UnaryCoreMethodNode { + public abstract static class LinenoNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization @@ -140,7 +140,7 @@ protected int lineno(RubyBacktraceLocation threadBacktraceLocation) { } @CoreMethod(names = "to_s") - public abstract static class ToSNode extends UnaryCoreMethodNode { + public abstract static class ToSNode extends CoreMethodArrayArgumentsNode { @Child private TruffleString.FromJavaStringNode fromJavaStringNode = TruffleString.FromJavaStringNode.create(); diff --git a/src/main/java/org/truffleruby/core/thread/ThreadNodes.java b/src/main/java/org/truffleruby/core/thread/ThreadNodes.java index e82c8512fe26..c5163ec2ee82 100644 --- a/src/main/java/org/truffleruby/core/thread/ThreadNodes.java +++ b/src/main/java/org/truffleruby/core/thread/ThreadNodes.java @@ -59,7 +59,6 @@ import org.truffleruby.builtins.NonStandard; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.builtins.YieldingCoreMethodNode; import org.truffleruby.collections.Memo; import org.truffleruby.core.InterruptMode; @@ -119,7 +118,7 @@ public abstract class ThreadNodes { @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected Object allocate(RubyClass rubyClass) { diff --git a/src/main/java/org/truffleruby/core/tracepoint/TracePointNodes.java b/src/main/java/org/truffleruby/core/tracepoint/TracePointNodes.java index 5ca16a2e9056..b236a07cff0a 100644 --- a/src/main/java/org/truffleruby/core/tracepoint/TracePointNodes.java +++ b/src/main/java/org/truffleruby/core/tracepoint/TracePointNodes.java @@ -16,7 +16,6 @@ import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.builtins.YieldingCoreMethodNode; import org.truffleruby.core.array.ArrayToObjectArrayNode; import org.truffleruby.core.array.RubyArray; @@ -69,7 +68,7 @@ public static boolean disposeEventBindings(RubyTracePoint tracePoint) { } @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyTracePoint allocate(RubyClass rubyClass) { final RubyTracePoint instance = new RubyTracePoint(rubyClass, getLanguage().tracePointShape, null, null); diff --git a/src/main/java/org/truffleruby/extra/ffi/PointerNodes.java b/src/main/java/org/truffleruby/extra/ffi/PointerNodes.java index 213d8bb7c2d6..0392a2870112 100644 --- a/src/main/java/org/truffleruby/extra/ffi/PointerNodes.java +++ b/src/main/java/org/truffleruby/extra/ffi/PointerNodes.java @@ -22,7 +22,6 @@ import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.encoding.Encodings; import org.truffleruby.core.klass.RubyClass; import org.truffleruby.core.numeric.BigIntegerOps; @@ -74,7 +73,7 @@ protected void checkNull(Pointer ptr) { } @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE) - public abstract static class AllocateNode extends UnaryCoreMethodNode { + public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode { @Specialization protected RubyPointer allocate(RubyClass pointerClass) { diff --git a/src/main/java/org/truffleruby/interop/SourceLocationNodes.java b/src/main/java/org/truffleruby/interop/SourceLocationNodes.java index 318ccfb3becc..d2d2dddafc94 100644 --- a/src/main/java/org/truffleruby/interop/SourceLocationNodes.java +++ b/src/main/java/org/truffleruby/interop/SourceLocationNodes.java @@ -14,8 +14,8 @@ import com.oracle.truffle.api.dsl.Specialization; import com.oracle.truffle.api.strings.TruffleString; import org.truffleruby.builtins.CoreMethod; +import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; -import org.truffleruby.builtins.UnaryCoreMethodNode; import org.truffleruby.core.encoding.Encodings; import org.truffleruby.core.string.RubyString; @@ -26,7 +26,7 @@ public class SourceLocationNodes { @CoreMethod(names = "absolute_path") - public abstract static class AbsolutePathNode extends UnaryCoreMethodNode { + public abstract static class AbsolutePathNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization protected Object absolutePath(RubySourceLocation location) { @@ -40,7 +40,7 @@ protected Object absolutePath(RubySourceLocation location) { } @CoreMethod(names = "path") - public abstract static class PathNode extends UnaryCoreMethodNode { + public abstract static class PathNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization protected RubyString path(RubySourceLocation location) { @@ -56,7 +56,7 @@ protected RubyString path(RubySourceLocation location) { } @CoreMethod(names = { "first_lineno", "lineno" }) - public abstract static class LinenoNode extends UnaryCoreMethodNode { + public abstract static class LinenoNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization protected int lineno(RubySourceLocation location) { @@ -65,7 +65,7 @@ protected int lineno(RubySourceLocation location) { } @CoreMethod(names = "last_lineno") - public abstract static class LastLinenoNode extends UnaryCoreMethodNode { + public abstract static class LastLinenoNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization protected int lastLine(RubySourceLocation location) { @@ -74,7 +74,7 @@ protected int lastLine(RubySourceLocation location) { } @CoreMethod(names = "first_column") - public abstract static class FirstColumnNode extends UnaryCoreMethodNode { + public abstract static class FirstColumnNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization protected int firstCol(RubySourceLocation location) { @@ -83,7 +83,7 @@ protected int firstCol(RubySourceLocation location) { } @CoreMethod(names = "last_column") - public abstract static class LastColumnNode extends UnaryCoreMethodNode { + public abstract static class LastColumnNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization protected int lastCol(RubySourceLocation location) { @@ -92,7 +92,7 @@ protected int lastCol(RubySourceLocation location) { } @CoreMethod(names = "available?") - public abstract static class IsAvailableNode extends UnaryCoreMethodNode { + public abstract static class IsAvailableNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization protected boolean isAvailable(RubySourceLocation location) { @@ -101,7 +101,7 @@ protected boolean isAvailable(RubySourceLocation location) { } @CoreMethod(names = "internal?") - public abstract static class IsInternalNode extends UnaryCoreMethodNode { + public abstract static class IsInternalNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization protected boolean isInternal(RubySourceLocation location) { @@ -110,7 +110,7 @@ protected boolean isInternal(RubySourceLocation location) { } @CoreMethod(names = "language") - public abstract static class LanguageNode extends UnaryCoreMethodNode { + public abstract static class LanguageNode extends CoreMethodArrayArgumentsNode { @TruffleBoundary @Specialization protected RubyString language(RubySourceLocation location, From 36a2bd838a4ad12e0a9a0e2ca50ed12835a71aa8 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Tue, 13 Sep 2022 20:51:59 +0300 Subject: [PATCH 14/46] Add #cloneUninitializedAssignable to Assignable interface --- .../org/truffleruby/core/array/AssignableNode.java | 2 ++ .../core/array/MultipleAssignmentNode.java | 12 +++++++----- .../truffleruby/core/array/NoopAssignableNode.java | 6 ++++++ .../core/inlined/InlinedIndexSetNode.java | 6 ++++++ .../language/constants/WriteConstantNode.java | 5 +++++ .../truffleruby/language/dispatch/RubyCallNode.java | 5 +++++ .../language/globals/WriteGlobalVariableNode.java | 5 +++++ .../locals/WriteDeclarationVariableNode.java | 5 +++++ .../language/locals/WriteFrameSlotNode.java | 6 ++++++ .../language/locals/WriteLocalVariableNode.java | 5 +++++ .../language/objects/WriteInstanceVariableNode.java | 5 +++++ .../classvariables/WriteClassVariableNode.java | 5 +++++ 12 files changed, 62 insertions(+), 5 deletions(-) diff --git a/src/main/java/org/truffleruby/core/array/AssignableNode.java b/src/main/java/org/truffleruby/core/array/AssignableNode.java index 367d3d6ecba3..7ee35b440544 100644 --- a/src/main/java/org/truffleruby/core/array/AssignableNode.java +++ b/src/main/java/org/truffleruby/core/array/AssignableNode.java @@ -23,4 +23,6 @@ public interface AssignableNode extends NodeInterface { /** Execute the node and assign the given value */ void assign(VirtualFrame frame, Object value); + AssignableNode cloneUninitializedAssignable(); + } diff --git a/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java b/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java index 5c467c78d447..563caf9a5a64 100644 --- a/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java +++ b/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java @@ -114,6 +114,11 @@ public AssignableNode toAssignableNode() { return this; } + @Override + public AssignableNode cloneUninitializedAssignable() { + return (AssignableNode) cloneUninitialized(); + } + @Override public RubyNode cloneUninitialized() { var copy = new MultipleAssignmentNode( @@ -129,16 +134,13 @@ public RubyNode cloneUninitialized() { protected AssignableNode[] cloneUninitializedAssignable(AssignableNode[] nodes) { AssignableNode[] copies = new AssignableNode[nodes.length]; for (int i = 0; i < nodes.length; i++) { - copies[i] = cloneUninitializedAssignable(nodes[i]); + copies[i] = nodes[i].cloneUninitializedAssignable(); } return copies; } protected AssignableNode cloneUninitializedAssignable(AssignableNode node) { - if (node instanceof RubyNode) { - return (AssignableNode) ((RubyNode) node).cloneUninitialized(); - } - return node; + return (node == null) ? null : node.cloneUninitializedAssignable(); } } diff --git a/src/main/java/org/truffleruby/core/array/NoopAssignableNode.java b/src/main/java/org/truffleruby/core/array/NoopAssignableNode.java index cc42ca508d2b..69b38ae787e4 100644 --- a/src/main/java/org/truffleruby/core/array/NoopAssignableNode.java +++ b/src/main/java/org/truffleruby/core/array/NoopAssignableNode.java @@ -23,4 +23,10 @@ public void assign(VirtualFrame frame, Object value) { public AssignableNode toAssignableNode() { return this; } + + @Override + public AssignableNode cloneUninitializedAssignable() { + return new NoopAssignableNode(); + } + } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java index 73f9273a5c89..2a1418d91259 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java @@ -74,6 +74,11 @@ assert getOperand2Node() instanceof NilLiteralNode && ((NilLiteralNode) getOpera return this; } + @Override + public AssignableNode cloneUninitializedAssignable() { + return (AssignableNode) cloneUninitialized(); + } + @Override public RubyNode cloneUninitialized() { var copy = InlinedIndexSetNodeGen.create( @@ -85,4 +90,5 @@ public RubyNode cloneUninitialized() { copy.copyFlags(this); return copy; } + } diff --git a/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java b/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java index 30126593d45e..fbd3803ee5c1 100644 --- a/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java +++ b/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java @@ -84,6 +84,11 @@ public AssignableNode toAssignableNode() { return this; } + @Override + public AssignableNode cloneUninitializedAssignable() { + return (AssignableNode) cloneUninitialized(); + } + @Override public RubyNode cloneUninitialized() { var copy = new WriteConstantNode( diff --git a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java index 05cd19d08a8f..a0cf16636753 100644 --- a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java +++ b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java @@ -254,6 +254,11 @@ public AssignableNode toAssignableNode() { return this; } + @Override + public AssignableNode cloneUninitializedAssignable() { + return (AssignableNode) cloneUninitialized(); + } + @Override public Map getDebugProperties() { final Map map = super.getDebugProperties(); diff --git a/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java b/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java index 9eefab25f5e6..c7407d887ef6 100644 --- a/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java +++ b/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java @@ -94,6 +94,11 @@ public AssignableNode toAssignableNode() { return node; } + @Override + public AssignableNode cloneUninitializedAssignable() { + return (AssignableNode) cloneUninitialized(); + } + abstract RubyNode getValueNode(); @Override diff --git a/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java b/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java index f6051769ba74..88cb3e052b7e 100644 --- a/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java +++ b/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java @@ -53,6 +53,11 @@ public AssignableNode toAssignableNode() { return this; } + @Override + public AssignableNode cloneUninitializedAssignable() { + return (AssignableNode) cloneUninitialized(); + } + @Override protected String getVariableName() { var descriptor = ParentFrameDescriptor.getDeclarationFrameDescriptor( diff --git a/src/main/java/org/truffleruby/language/locals/WriteFrameSlotNode.java b/src/main/java/org/truffleruby/language/locals/WriteFrameSlotNode.java index b903f65f55b4..14b896b620f7 100644 --- a/src/main/java/org/truffleruby/language/locals/WriteFrameSlotNode.java +++ b/src/main/java/org/truffleruby/language/locals/WriteFrameSlotNode.java @@ -97,4 +97,10 @@ private FrameDescriptor getFrameDescriptor(Frame frame) { public AssignableNode toAssignableNode() { return this; } + + @Override + public AssignableNode cloneUninitializedAssignable() { + return WriteFrameSlotNodeGen.create(frameSlot); + } + } diff --git a/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java b/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java index d4d1a7c31067..56624f91ec27 100644 --- a/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java +++ b/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java @@ -47,6 +47,11 @@ public AssignableNode toAssignableNode() { return WriteFrameSlotNodeGen.create(frameSlot); } + @Override + public AssignableNode cloneUninitializedAssignable() { + return (AssignableNode) cloneUninitialized(); + } + @Override protected String getVariableName() { return getRootNode().getFrameDescriptor().getSlotName(frameSlot).toString(); diff --git a/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java b/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java index bbc1764e8781..c09f3e8fac0e 100644 --- a/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java +++ b/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java @@ -90,6 +90,11 @@ public AssignableNode toAssignableNode() { return this; } + @Override + public AssignableNode cloneUninitializedAssignable() { + return (AssignableNode) cloneUninitialized(); + } + @Override public RubyNode cloneUninitialized() { var rhsCopy = (rhs == null) ? null : rhs.cloneUninitialized(); diff --git a/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java b/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java index d1785aa15f0f..7f7c43589b20 100644 --- a/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java +++ b/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java @@ -69,6 +69,11 @@ public AssignableNode toAssignableNode() { return this; } + @Override + public AssignableNode cloneUninitializedAssignable() { + return (AssignableNode) cloneUninitialized(); + } + @Override public RubyNode cloneUninitialized() { var copy = new WriteClassVariableNode( From 41cf44ea85b90a1965fa15a2a396b2296347bf6f Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Tue, 13 Sep 2022 21:13:06 +0300 Subject: [PATCH 15/46] Refactoring: Add #cloneUninitialized(RubyNode node) to RubyNode --- .../org/truffleruby/core/array/ArrayLiteralNode.java | 3 +-- src/main/java/org/truffleruby/language/RubyNode.java | 9 +++++++++ .../language/arguments/ReadKeywordArgumentNode.java | 3 +-- .../org/truffleruby/language/dispatch/RubyCallNode.java | 3 +-- .../org/truffleruby/language/exceptions/TryNode.java | 3 +-- .../language/globals/WriteGlobalVariableNode.java | 3 +-- .../language/locals/WriteDeclarationVariableNode.java | 3 +-- .../language/objects/WriteInstanceVariableNode.java | 3 +-- 8 files changed, 16 insertions(+), 14 deletions(-) diff --git a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java index 2d9a1d717d14..0b9075483552 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java @@ -386,10 +386,9 @@ public Object storeSpecialisedFromObjects(Object... objects) { @Override public RubyNode cloneUninitialized() { - var valuesCopy = (values == null) ? null : cloneUninitialized(values); var copy = new UninitialisedArrayLiteralNode( language, - valuesCopy); + cloneUninitialized(values)); copy.copyFlags(this); return copy; } diff --git a/src/main/java/org/truffleruby/language/RubyNode.java b/src/main/java/org/truffleruby/language/RubyNode.java index 545a67d80320..3c26f1bdc463 100644 --- a/src/main/java/org/truffleruby/language/RubyNode.java +++ b/src/main/java/org/truffleruby/language/RubyNode.java @@ -320,10 +320,19 @@ Object getRootInstance(Frame frame, public abstract RubyNode cloneUninitialized(); protected static RubyNode[] cloneUninitialized(RubyNode[] nodes) { + if (nodes == null) { + return null; + } + RubyNode[] copies = new RubyNode[nodes.length]; for (int i = 0; i < nodes.length; i++) { copies[i] = nodes[i].cloneUninitialized(); } return copies; } + + protected static RubyNode cloneUninitialized(RubyNode node) { + return (node == null) ? null : node.cloneUninitialized(); + } + } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java index d9448e31f22c..6d5e1d163800 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java @@ -94,8 +94,7 @@ RubyNode getDefaultValue() { @Override public RubyNode cloneUninitialized() { - final RubyNode defaultValueCopy = (defaultValue == null) ? null : defaultValue.cloneUninitialized(); - var copy = ReadKeywordArgumentNode.create(name, defaultValueCopy); + var copy = ReadKeywordArgumentNode.create(name, cloneUninitialized(defaultValue)); copy.copyFlags(this); return copy; } diff --git a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java index a0cf16636753..b63c37fbdc34 100644 --- a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java +++ b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java @@ -268,14 +268,13 @@ public Map getDebugProperties() { @Override public RubyNode cloneUninitialized() { - var blockCopy = (block == null) ? null : block.cloneUninitialized(); var copy = new RubyCallNode( isSplatted, descriptor, methodName, receiver.cloneUninitialized(), cloneUninitialized(arguments), - blockCopy, + cloneUninitialized(block), dispatchConfig, isVCall, isSafeNavigation, diff --git a/src/main/java/org/truffleruby/language/exceptions/TryNode.java b/src/main/java/org/truffleruby/language/exceptions/TryNode.java index ef84e0dea2f6..9437306a3af2 100644 --- a/src/main/java/org/truffleruby/language/exceptions/TryNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/TryNode.java @@ -147,11 +147,10 @@ private void printBacktraceOnRescue(RescueNode rescue, AbstractTruffleException @Override public RubyNode cloneUninitialized() { var rescuePartsCopy = cloneUninitialized(rescueParts); - var elsePartCopy = (elsePart == null) ? null : elsePart.cloneUninitialized(); var copy = new TryNode( tryPart.cloneUninitialized(), Arrays.copyOf(rescuePartsCopy, rescuePartsCopy.length, RescueNode[].class), - elsePartCopy, + cloneUninitialized(elsePart), canOmitBacktrace); copy.copyFlags(this); return copy; diff --git a/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java b/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java index c7407d887ef6..cb92f8bb814c 100644 --- a/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java +++ b/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java @@ -103,8 +103,7 @@ public AssignableNode cloneUninitializedAssignable() { @Override public RubyNode cloneUninitialized() { - var valueNodeCopy = (getValueNode() == null) ? null : getValueNode().cloneUninitialized(); - var copy = WriteGlobalVariableNodeGen.create(name, valueNodeCopy); + var copy = WriteGlobalVariableNodeGen.create(name, cloneUninitialized(getValueNode())); copy.copyFlags(this); return copy; } diff --git a/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java b/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java index 88cb3e052b7e..02a20466ad6b 100644 --- a/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java +++ b/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java @@ -68,11 +68,10 @@ protected String getVariableName() { @Override public RubyNode cloneUninitialized() { - var valueNodeCopy = (valueNode == null) ? null : valueNode.cloneUninitialized(); var copy = new WriteDeclarationVariableNode( frameSlot, frameDepth, - valueNodeCopy); + cloneUninitialized(valueNode)); copy.copyFlags(this); return copy; } diff --git a/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java b/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java index c09f3e8fac0e..0d15dfde27e1 100644 --- a/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java +++ b/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java @@ -97,11 +97,10 @@ public AssignableNode cloneUninitializedAssignable() { @Override public RubyNode cloneUninitialized() { - var rhsCopy = (rhs == null) ? null : rhs.cloneUninitialized(); var copy = new WriteInstanceVariableNode( name, receiver.cloneUninitialized(), - rhsCopy); + cloneUninitialized(rhs)); copy.copyFlags(this); return copy; } From 4e0667f6e87c60d0327b5e11260b3f560550ce61 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Wed, 14 Sep 2022 14:32:10 +0300 Subject: [PATCH 16/46] Refactoring: Replace Array.copyOf with ad hoc #cloneUninitialized(nodes) --- .../core/regexp/InterpolatedRegexpNode.java | 13 +++++++++---- .../core/string/InterpolatedStringNode.java | 13 +++++++++---- .../truffleruby/language/exceptions/TryNode.java | 13 +++++++++---- 3 files changed, 27 insertions(+), 12 deletions(-) diff --git a/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java b/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java index 3d390f5e529b..06f5c9941060 100644 --- a/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java +++ b/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java @@ -27,8 +27,6 @@ import com.oracle.truffle.api.nodes.ExplodeLoop; import org.truffleruby.language.library.RubyStringLibrary; -import java.util.Arrays; - public class InterpolatedRegexpNode extends RubyContextSourceNode { @Children private final ToSNode[] children; @@ -64,14 +62,21 @@ protected TStringWithEncoding[] executeChildren(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { - var childrenCopy = cloneUninitialized(children); var copy = new InterpolatedRegexpNode( - Arrays.copyOf(childrenCopy, childrenCopy.length, ToSNode[].class), + cloneUninitialized(children), builderNode); copy.copyFlags(this); return copy; } + protected static ToSNode[] cloneUninitialized(ToSNode[] nodes) { + ToSNode[] copies = new ToSNode[nodes.length]; + for (int i = 0; i < nodes.length; i++) { + copies[i] = (ToSNode) nodes[i].cloneUninitialized(); + } + return copies; + } + public abstract static class RegexpBuilderNode extends RubyBaseNode { @Child private TruffleString.EqualNode equalNode = TruffleString.EqualNode.create(); diff --git a/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java b/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java index 9addc8877707..4a496f3d95d6 100644 --- a/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java +++ b/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java @@ -21,8 +21,6 @@ import com.oracle.truffle.api.nodes.ExplodeLoop; import org.truffleruby.language.RubyNode; -import java.util.Arrays; - /** A list of expressions to build up into a string. */ public final class InterpolatedStringNode extends RubyContextSourceNode { @@ -71,12 +69,19 @@ private RubyString executeStringAppend(RubyString builder, Object string) { @Override public RubyNode cloneUninitialized() { - var childrenCopy = cloneUninitialized(children); var copy = new InterpolatedStringNode( - Arrays.copyOf(childrenCopy, childrenCopy.length, ToSNode[].class), + cloneUninitialized(children), encoding); copy.copyFlags(this); return copy; } + protected static ToSNode[] cloneUninitialized(ToSNode[] nodes) { + ToSNode[] copies = new ToSNode[nodes.length]; + for (int i = 0; i < nodes.length; i++) { + copies[i] = (ToSNode) nodes[i].cloneUninitialized(); + } + return copies; + } + } diff --git a/src/main/java/org/truffleruby/language/exceptions/TryNode.java b/src/main/java/org/truffleruby/language/exceptions/TryNode.java index 9437306a3af2..e252bd21afc2 100644 --- a/src/main/java/org/truffleruby/language/exceptions/TryNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/TryNode.java @@ -30,8 +30,6 @@ import org.truffleruby.language.methods.TranslateExceptionNode; import org.truffleruby.language.threadlocal.ThreadLocalGlobals; -import java.util.Arrays; - public class TryNode extends RubyContextSourceNode { @Child private RubyNode tryPart; @@ -146,14 +144,21 @@ private void printBacktraceOnRescue(RescueNode rescue, AbstractTruffleException @Override public RubyNode cloneUninitialized() { - var rescuePartsCopy = cloneUninitialized(rescueParts); var copy = new TryNode( tryPart.cloneUninitialized(), - Arrays.copyOf(rescuePartsCopy, rescuePartsCopy.length, RescueNode[].class), + cloneUninitialized(rescueParts), cloneUninitialized(elsePart), canOmitBacktrace); copy.copyFlags(this); return copy; } + protected static RescueNode[] cloneUninitialized(RescueNode[] nodes) { + RescueNode[] copies = new RescueNode[nodes.length]; + for (int i = 0; i < nodes.length; i++) { + copies[i] = (RescueNode) nodes[i].cloneUninitialized(); + } + return copies; + } + } From 39348e7c1ea5de3061b54d3bde30e972ae770766 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Wed, 14 Sep 2022 14:39:31 +0300 Subject: [PATCH 17/46] Refactoring: Introduce RubyCallNodeParameters.withoutNodes() method to copy object without receiver/block/arguments nodes --- .../core/inlined/InlinedReplaceableNode.java | 12 +----------- .../language/dispatch/RubyCallNodeParameters.java | 14 ++++++++++++++ 2 files changed, 15 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java index f849c43aefa5..f7844056f91b 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java @@ -37,17 +37,7 @@ protected InlinedReplaceableNode( Assumption... assumptions) { // nullify receiver, arguments and block for clarity // because they should be overriden in subclasses. - this.parameters = new RubyCallNodeParameters( - null, - callNodeParameters.getMethodName(), - null, - callNodeParameters.getDescriptor(), - null, - callNodeParameters.isSplatted(), - callNodeParameters.isIgnoreVisibility(), - callNodeParameters.isVCall(), - callNodeParameters.isSafeNavigation(), - callNodeParameters.isAttrAssign()); + this.parameters = callNodeParameters.withoutNodes(); this.assumptions = new Assumption[1 + assumptions.length]; this.assumptions[0] = language.traceFuncUnusedAssumption.getAssumption(); diff --git a/src/main/java/org/truffleruby/language/dispatch/RubyCallNodeParameters.java b/src/main/java/org/truffleruby/language/dispatch/RubyCallNodeParameters.java index 1118eb27d1ea..3385e9fdbefa 100644 --- a/src/main/java/org/truffleruby/language/dispatch/RubyCallNodeParameters.java +++ b/src/main/java/org/truffleruby/language/dispatch/RubyCallNodeParameters.java @@ -77,6 +77,20 @@ public RubyCallNodeParameters withBlock(RubyNode block) { return withReceiverAndArguments(receiver, arguments, block); } + public RubyCallNodeParameters withoutNodes() { + return new RubyCallNodeParameters( + null, + methodName, + null, + descriptor, + null, + isSplatted, + ignoreVisibility, + isVCall, + isSafeNavigation, + isAttrAssign); + } + public RubyNode getReceiver() { return receiver; } From 00f846217dbd107bf058a9bb604c0c2ad883e058 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Wed, 14 Sep 2022 19:01:28 +0300 Subject: [PATCH 18/46] Refactoring: RubyContextSourceNode.copyFlags returns this to chain calls --- .../CoreMethodArrayArgumentsNode.java | 3 +- .../truffleruby/builtins/CoreMethodNode.java | 3 +- .../builtins/EnumeratorSizeNode.java | 3 +- .../builtins/PrimitiveArrayArgumentsNode.java | 3 +- .../truffleruby/builtins/PrimitiveNode.java | 3 +- .../builtins/ReRaiseInlinedExceptionNode.java | 3 +- .../ReturnEnumeratorIfNoBlockNode.java | 3 +- .../java/org/truffleruby/cext/CExtNodes.java | 9 +-- .../java/org/truffleruby/core/IsNilNode.java | 3 +- .../core/array/ArrayAppendOneNode.java | 3 +- .../core/array/ArrayConcatNode.java | 3 +- .../core/array/ArrayDropTailNode.java | 3 +- .../core/array/ArrayGetTailNode.java | 3 +- .../core/array/ArrayIndexNodes.java | 3 +- .../core/array/ArrayLiteralNode.java | 18 ++--- .../truffleruby/core/array/ArrayNodes.java | 15 ++-- .../core/array/ArraySliceNode.java | 3 +- .../core/array/MultipleAssignmentNode.java | 3 +- .../binding/SetBindingFrameForEvalNode.java | 3 +- .../truffleruby/core/cast/HashCastNode.java | 3 +- .../truffleruby/core/cast/SplatCastNode.java | 3 +- .../core/cast/StringToSymbolNode.java | 3 +- .../org/truffleruby/core/cast/ToProcNode.java | 3 +- .../core/encoding/EncodingConverterNodes.java | 3 +- .../core/hash/ConcatHashLiteralNode.java | 3 +- .../core/hash/library/BucketsHashStore.java | 3 +- .../core/hash/library/EmptyHashStore.java | 3 +- .../hash/library/PackedHashStoreLibrary.java | 3 +- .../core/inlined/InlinedAddNode.java | 3 +- .../core/inlined/InlinedAtNode.java | 3 +- .../core/inlined/InlinedBitAndNode.java | 3 +- .../core/inlined/InlinedBitOrNode.java | 3 +- .../core/inlined/InlinedByteSizeNode.java | 3 +- .../core/inlined/InlinedCaseEqualNode.java | 3 +- .../core/inlined/InlinedDivNode.java | 3 +- .../core/inlined/InlinedEqualNode.java | 3 +- .../inlined/InlinedGreaterOrEqualNode.java | 3 +- .../core/inlined/InlinedGreaterThanNode.java | 3 +- .../core/inlined/InlinedIndexGetNode.java | 3 +- .../core/inlined/InlinedIndexSetNode.java | 3 +- .../core/inlined/InlinedIsANode.java | 3 +- .../core/inlined/InlinedIsNilNode.java | 3 +- .../core/inlined/InlinedKindOfNode.java | 3 +- .../core/inlined/InlinedLambdaNode.java | 3 +- .../core/inlined/InlinedLeftShiftNode.java | 3 +- .../core/inlined/InlinedLessOrEqualNode.java | 3 +- .../core/inlined/InlinedLessThanNode.java | 3 +- .../core/inlined/InlinedModNode.java | 3 +- .../core/inlined/InlinedMulNode.java | 3 +- .../core/inlined/InlinedNegNode.java | 3 +- .../core/inlined/InlinedNotNode.java | 3 +- .../core/inlined/InlinedRightShiftNode.java | 3 +- .../core/inlined/InlinedSubNode.java | 3 +- .../core/inlined/LambdaToProcNode.java | 3 +- .../core/kernel/AutoSplitNode.java | 3 +- .../core/kernel/ChompLoopNode.java | 3 +- .../core/kernel/KernelGetsNode.java | 3 +- .../truffleruby/core/kernel/KernelNodes.java | 24 ++---- .../core/kernel/KernelPrintLastLineNode.java | 3 +- .../core/kernel/TruffleKernelNodes.java | 3 +- .../truffleruby/core/method/MethodNodes.java | 3 +- .../truffleruby/core/module/ModuleNodes.java | 75 +++++++------------ .../core/numeric/FixnumLowerNode.java | 3 +- .../core/numeric/IntegerNodes.java | 3 +- .../truffleruby/core/queue/QueueNodes.java | 3 +- .../core/queue/SizedQueueNodes.java | 6 +- .../truffleruby/core/range/RangeNodes.java | 3 +- .../core/regexp/InterpolatedRegexpNode.java | 3 +- .../core/string/InterpolatedStringNode.java | 3 +- .../truffleruby/core/string/StringNodes.java | 24 ++---- .../java/org/truffleruby/debug/ChaosNode.java | 3 +- .../truffleruby/debug/MetricsBodyNode.java | 3 +- .../org/truffleruby/interop/InteropNodes.java | 36 +++------ .../interop/SymbolToByteOrderNode.java | 3 +- .../interop/ToJavaStringWithDefaultNode.java | 3 +- .../org/truffleruby/language/DataNode.java | 3 +- .../language/EmitWarningsNode.java | 3 +- .../language/RubyContextSourceNode.java | 3 +- .../language/SetTopLevelBindingNode.java | 3 +- .../ArrayIsAtLeastAsLargeAsNode.java | 3 +- .../CheckNoKeywordArgumentsNode.java | 3 +- .../arguments/MissingKeywordArgumentNode.java | 3 +- .../language/arguments/NotProvidedNode.java | 3 +- .../arguments/ProfileArgumentNode.java | 3 +- ...eadBlockFromCurrentFrameArgumentsNode.java | 3 +- .../arguments/ReadKeywordArgumentNode.java | 3 +- .../ReadKeywordRestArgumentNode.java | 3 +- .../arguments/ReadOptionalArgumentNode.java | 3 +- .../arguments/ReadPostArgumentNode.java | 3 +- .../arguments/ReadPreArgumentNode.java | 3 +- .../arguments/ReadRemainingArgumentsNode.java | 3 +- .../arguments/ReadRestArgumentNode.java | 3 +- .../language/arguments/ReadSelfNode.java | 3 +- .../arguments/SaveMethodBlockNode.java | 3 +- .../arguments/ShouldDestructureNode.java | 3 +- .../constants/OrAssignConstantNode.java | 3 +- .../language/constants/ReadConstantNode.java | 3 +- .../ReadConstantWithDynamicScopeNode.java | 3 +- .../ReadConstantWithLexicalScopeNode.java | 3 +- .../language/constants/WriteConstantNode.java | 3 +- .../truffleruby/language/control/AndNode.java | 3 +- .../language/control/BreakNode.java | 3 +- .../language/control/DynamicReturnNode.java | 3 +- .../language/control/ElidableResultNode.java | 3 +- .../language/control/FrameOnStackNode.java | 3 +- .../language/control/IfElseNode.java | 3 +- .../truffleruby/language/control/IfNode.java | 3 +- .../language/control/InvalidReturnNode.java | 3 +- .../language/control/LocalReturnNode.java | 3 +- .../language/control/NextNode.java | 3 +- .../truffleruby/language/control/NotNode.java | 3 +- .../language/control/OnceNode.java | 3 +- .../control/OrLazyValueDefinedNode.java | 3 +- .../truffleruby/language/control/OrNode.java | 3 +- .../language/control/RedoNode.java | 3 +- .../language/control/RetryNode.java | 3 +- .../language/control/SequenceNode.java | 3 +- .../language/control/UnlessNode.java | 3 +- .../language/control/WhileNode.java | 3 +- .../language/defined/DefinedNode.java | 3 +- .../language/defined/DefinedWrapperNode.java | 3 +- .../language/dispatch/RubyCallNode.java | 3 +- .../language/exceptions/EnsureNode.java | 3 +- .../exceptions/RescueClassesNode.java | 3 +- .../language/exceptions/RescueSplatNode.java | 3 +- .../exceptions/RescueStandardErrorNode.java | 3 +- .../language/exceptions/TryNode.java | 3 +- .../language/globals/AliasGlobalVarNode.java | 3 +- .../globals/ReadGlobalVariableNode.java | 3 +- .../globals/ReadMatchReferenceNodes.java | 6 +- .../globals/WriteGlobalVariableNode.java | 3 +- .../language/literal/BooleanLiteralNode.java | 3 +- .../language/literal/FloatLiteralNode.java | 3 +- .../literal/FrozenStringLiteralNode.java | 3 +- .../literal/IntegerFixnumLiteralNode.java | 3 +- .../literal/LongFixnumLiteralNode.java | 3 +- .../language/literal/NilLiteralNode.java | 3 +- .../literal/ObjectClassLiteralNode.java | 3 +- .../language/literal/ObjectLiteralNode.java | 3 +- .../literal/RangeClassLiteralNode.java | 3 +- .../language/literal/StringLiteralNode.java | 3 +- .../TruffleInternalModuleLiteralNode.java | 3 +- ...ffleKernelOperationsModuleLiteralNode.java | 3 +- .../language/locals/FlipFlopNode.java | 3 +- .../language/locals/InitFlipFlopSlotNode.java | 3 +- .../locals/ReadDeclarationVariableNode.java | 3 +- .../locals/ReadLocalVariableNode.java | 3 +- .../locals/WriteDeclarationVariableNode.java | 3 +- .../locals/WriteLocalVariableNode.java | 3 +- .../language/methods/BlockDefinitionNode.java | 3 +- .../language/methods/CatchBreakNode.java | 3 +- .../methods/GetDefaultDefineeNode.java | 3 +- .../language/methods/GetMethodObjectNode.java | 3 +- .../methods/LiteralMethodDefinitionNode.java | 3 +- .../language/methods/SymbolProcNode.java | 3 +- .../language/objects/DefineClassNode.java | 3 +- .../language/objects/DefineModuleNode.java | 3 +- .../objects/DynamicLexicalScopeNode.java | 3 +- .../objects/GetDynamicLexicalScopeNode.java | 3 +- .../objects/InsideModuleDefinitionNode.java | 3 +- .../language/objects/LexicalScopeNode.java | 3 +- .../objects/ReadInstanceVariableNode.java | 3 +- .../objects/RunModuleDefinitionNode.java | 3 +- .../language/objects/SelfNode.java | 3 +- .../objects/WriteInstanceVariableNode.java | 3 +- .../classvariables/ReadClassVariableNode.java | 3 +- .../WriteClassVariableNode.java | 3 +- .../supercall/ReadSuperArgumentsNode.java | 3 +- .../supercall/ReadZSuperArgumentsNode.java | 3 +- .../language/supercall/SuperCallNode.java | 3 +- .../supercall/ZSuperOutsideMethodNode.java | 3 +- .../language/yield/YieldExpressionNode.java | 3 +- .../java/org/truffleruby/parser/DeadNode.java | 3 +- .../stdlib/readline/ReadlineHistoryNodes.java | 3 +- .../stdlib/readline/ReadlineNodes.java | 9 +-- 175 files changed, 240 insertions(+), 477 deletions(-) diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java b/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java index 645a05b8be24..6b1dcf4862b3 100644 --- a/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java +++ b/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java @@ -24,8 +24,7 @@ public RubyNode cloneUninitialized() { NodeFactory factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass()); RubyNode[] copiedArguments = cloneUninitialized(getArgumentNodes()); var copy = (CoreMethodArrayArgumentsNode) CoreMethodNodeManager.createNodeFromFactory(factory, copiedArguments); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodNode.java b/src/main/java/org/truffleruby/builtins/CoreMethodNode.java index 13a9b51ff1da..5e71840d6b74 100644 --- a/src/main/java/org/truffleruby/builtins/CoreMethodNode.java +++ b/src/main/java/org/truffleruby/builtins/CoreMethodNode.java @@ -22,8 +22,7 @@ public abstract class CoreMethodNode extends RubyContextSourceNode { public RubyNode cloneUninitialized() { NodeFactory factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass()); var copy = (CoreMethodNode) CoreMethodNodeManager.createNodeFromFactory(factory, RubyNode.EMPTY_ARRAY); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/builtins/EnumeratorSizeNode.java b/src/main/java/org/truffleruby/builtins/EnumeratorSizeNode.java index 87164464c543..95b5de82bd66 100644 --- a/src/main/java/org/truffleruby/builtins/EnumeratorSizeNode.java +++ b/src/main/java/org/truffleruby/builtins/EnumeratorSizeNode.java @@ -63,8 +63,7 @@ public RubyNode cloneUninitialized() { sizeMethodName, methodName, method.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/builtins/PrimitiveArrayArgumentsNode.java b/src/main/java/org/truffleruby/builtins/PrimitiveArrayArgumentsNode.java index 08dde73f119d..ae39a2949caa 100644 --- a/src/main/java/org/truffleruby/builtins/PrimitiveArrayArgumentsNode.java +++ b/src/main/java/org/truffleruby/builtins/PrimitiveArrayArgumentsNode.java @@ -24,8 +24,7 @@ public RubyNode cloneUninitialized() { NodeFactory factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass()); RubyNode[] copiedArguments = cloneUninitialized(getArgumentNodes()); var copy = (PrimitiveArrayArgumentsNode) CoreMethodNodeManager.createNodeFromFactory(factory, copiedArguments); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/builtins/PrimitiveNode.java b/src/main/java/org/truffleruby/builtins/PrimitiveNode.java index 4ece4710c1c9..e2912bb1f2e5 100644 --- a/src/main/java/org/truffleruby/builtins/PrimitiveNode.java +++ b/src/main/java/org/truffleruby/builtins/PrimitiveNode.java @@ -27,8 +27,7 @@ public abstract class PrimitiveNode extends RubyContextSourceNode { public RubyNode cloneUninitialized() { NodeFactory factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass()); var copy = (PrimitiveNode) CoreMethodNodeManager.createNodeFromFactory(factory, RubyNode.EMPTY_ARRAY); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/builtins/ReRaiseInlinedExceptionNode.java b/src/main/java/org/truffleruby/builtins/ReRaiseInlinedExceptionNode.java index ce61c937b362..c4d40b2d280e 100644 --- a/src/main/java/org/truffleruby/builtins/ReRaiseInlinedExceptionNode.java +++ b/src/main/java/org/truffleruby/builtins/ReRaiseInlinedExceptionNode.java @@ -52,8 +52,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new ReRaiseInlinedExceptionNode(nodeFactory); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/builtins/ReturnEnumeratorIfNoBlockNode.java b/src/main/java/org/truffleruby/builtins/ReturnEnumeratorIfNoBlockNode.java index 089dd72b1fde..6e915631a8d5 100644 --- a/src/main/java/org/truffleruby/builtins/ReturnEnumeratorIfNoBlockNode.java +++ b/src/main/java/org/truffleruby/builtins/ReturnEnumeratorIfNoBlockNode.java @@ -63,8 +63,7 @@ public RubyNode cloneUninitialized() { var copy = new ReturnEnumeratorIfNoBlockNode( methodName, method.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/cext/CExtNodes.java b/src/main/java/org/truffleruby/cext/CExtNodes.java index b453dfdc6e05..4dac4621aaae 100644 --- a/src/main/java/org/truffleruby/cext/CExtNodes.java +++ b/src/main/java/org/truffleruby/cext/CExtNodes.java @@ -1010,8 +1010,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1052,8 +1051,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1095,8 +1093,7 @@ public RubyNode cloneUninitialized() { getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized(), getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/IsNilNode.java b/src/main/java/org/truffleruby/core/IsNilNode.java index 7430451803a0..f3f10f791342 100644 --- a/src/main/java/org/truffleruby/core/IsNilNode.java +++ b/src/main/java/org/truffleruby/core/IsNilNode.java @@ -30,8 +30,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new IsNilNode(child.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/array/ArrayAppendOneNode.java b/src/main/java/org/truffleruby/core/array/ArrayAppendOneNode.java index fd9765bc30f7..bf78076aff46 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayAppendOneNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayAppendOneNode.java @@ -91,8 +91,7 @@ public RubyNode cloneUninitialized() { var copy = ArrayAppendOneNodeGen.create( getArrayNode().cloneUninitialized(), getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/array/ArrayConcatNode.java b/src/main/java/org/truffleruby/core/array/ArrayConcatNode.java index 9f5842d2d7e8..0bcae8c6219b 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayConcatNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayConcatNode.java @@ -93,8 +93,7 @@ public void doExecuteVoid(VirtualFrame frame) { public RubyNode cloneUninitialized() { var copy = new ArrayConcatNode(cloneUninitialized(children)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/array/ArrayDropTailNode.java b/src/main/java/org/truffleruby/core/array/ArrayDropTailNode.java index 7a5d829581a8..5fab335d46c0 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayDropTailNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayDropTailNode.java @@ -49,8 +49,7 @@ public RubyNode cloneUninitialized() { var copy = ArrayDropTailNodeGen.create( index, getArrayNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/array/ArrayGetTailNode.java b/src/main/java/org/truffleruby/core/array/ArrayGetTailNode.java index 6a008a465e4d..a59e88cc1810 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayGetTailNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayGetTailNode.java @@ -48,8 +48,7 @@ public RubyNode cloneUninitialized() { var copy = ArrayGetTailNodeGen.create( index, getArrayNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/array/ArrayIndexNodes.java b/src/main/java/org/truffleruby/core/array/ArrayIndexNodes.java index 82e65a7663e4..bdf5b635d298 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayIndexNodes.java +++ b/src/main/java/org/truffleruby/core/array/ArrayIndexNodes.java @@ -63,8 +63,7 @@ public RubyNode cloneUninitialized() { var copy = ReadConstantIndexNode.create( getArrayNode().cloneUninitialized(), index); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java index 0b9075483552..83da4d2dfce3 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java @@ -102,8 +102,7 @@ public RubyNode cloneUninitialized() { var copy = new EmptyArrayLiteralNode( language, cloneUninitialized(values)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -148,8 +147,7 @@ public RubyNode cloneUninitialized() { var copy = new FloatArrayLiteralNode( language, cloneUninitialized(values)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -194,8 +192,7 @@ public RubyNode cloneUninitialized() { var copy = new IntegerArrayLiteralNode( language, cloneUninitialized(values)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -240,8 +237,7 @@ public RubyNode cloneUninitialized() { var copy = new LongArrayLiteralNode( language, cloneUninitialized(values)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -269,8 +265,7 @@ public RubyNode cloneUninitialized() { var copy = new ObjectArrayLiteralNode( language, cloneUninitialized(values)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -389,8 +384,7 @@ public RubyNode cloneUninitialized() { var copy = new UninitialisedArrayLiteralNode( language, cloneUninitialized(values)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/array/ArrayNodes.java b/src/main/java/org/truffleruby/core/array/ArrayNodes.java index ce353f4fa487..ad866eeaca0a 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayNodes.java +++ b/src/main/java/org/truffleruby/core/array/ArrayNodes.java @@ -169,8 +169,7 @@ public RubyNode cloneUninitialized() { var copy = create( getANode().cloneUninitialized(), getBNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -852,8 +851,7 @@ public RubyNode cloneUninitialized() { var copy = create( getArrayNode().cloneUninitialized(), getIndexNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1380,8 +1378,7 @@ public RubyNode cloneUninitialized() { var copy = create( getSelfNode().cloneUninitialized(), getFromNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1697,8 +1694,7 @@ public RubyNode cloneUninitialized() { var copy = create( getArrayNode().cloneUninitialized(), getFormatNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2000,8 +1996,7 @@ public RubyNode cloneUninitialized() { var copy = create( getArrayNode().cloneUninitialized(), getOtherNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/array/ArraySliceNode.java b/src/main/java/org/truffleruby/core/array/ArraySliceNode.java index c2e165a4b8ca..cdaec7050946 100644 --- a/src/main/java/org/truffleruby/core/array/ArraySliceNode.java +++ b/src/main/java/org/truffleruby/core/array/ArraySliceNode.java @@ -56,8 +56,7 @@ public RubyNode cloneUninitialized() { from, to, getArrayNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java b/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java index 563caf9a5a64..34ec41675e17 100644 --- a/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java +++ b/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java @@ -127,8 +127,7 @@ public RubyNode cloneUninitialized() { cloneUninitializedAssignable(postNodes), (SplatCastNode) splatCastNode.cloneUninitialized(), rhsNode.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } protected AssignableNode[] cloneUninitializedAssignable(AssignableNode[] nodes) { diff --git a/src/main/java/org/truffleruby/core/binding/SetBindingFrameForEvalNode.java b/src/main/java/org/truffleruby/core/binding/SetBindingFrameForEvalNode.java index d1d569250d4d..97d8050f2330 100644 --- a/src/main/java/org/truffleruby/core/binding/SetBindingFrameForEvalNode.java +++ b/src/main/java/org/truffleruby/core/binding/SetBindingFrameForEvalNode.java @@ -46,8 +46,7 @@ public RubyNode cloneUninitialized() { var copy = new SetBindingFrameForEvalNode( descriptor, body.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/cast/HashCastNode.java b/src/main/java/org/truffleruby/core/cast/HashCastNode.java index 0a26ba66132e..3681bc2073dd 100644 --- a/src/main/java/org/truffleruby/core/cast/HashCastNode.java +++ b/src/main/java/org/truffleruby/core/cast/HashCastNode.java @@ -73,8 +73,7 @@ public void doExecuteVoid(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = create(getChildNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/cast/SplatCastNode.java b/src/main/java/org/truffleruby/core/cast/SplatCastNode.java index 745bbc3766bb..b1e4748967af 100644 --- a/src/main/java/org/truffleruby/core/cast/SplatCastNode.java +++ b/src/main/java/org/truffleruby/core/cast/SplatCastNode.java @@ -139,8 +139,7 @@ public RubyNode cloneUninitialized() { nilBehavior, conversionMethod, childCopy); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/cast/StringToSymbolNode.java b/src/main/java/org/truffleruby/core/cast/StringToSymbolNode.java index 82380304d510..3a46461fa37d 100644 --- a/src/main/java/org/truffleruby/core/cast/StringToSymbolNode.java +++ b/src/main/java/org/truffleruby/core/cast/StringToSymbolNode.java @@ -33,8 +33,7 @@ protected RubySymbol doString(Object string, @Override public RubyNode cloneUninitialized() { var copy = StringToSymbolNodeGen.create(getStringNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/cast/ToProcNode.java b/src/main/java/org/truffleruby/core/cast/ToProcNode.java index 7c98c6c893f1..6839ae407648 100644 --- a/src/main/java/org/truffleruby/core/cast/ToProcNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToProcNode.java @@ -120,8 +120,7 @@ protected static Map getRefinements(VirtualFrame frame @Override public RubyNode cloneUninitialized() { var copy = ToProcNodeGen.create(getChildNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java b/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java index dbe00aac66eb..35fac931976f 100644 --- a/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java +++ b/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java @@ -498,8 +498,7 @@ public RubyNode cloneUninitialized() { var copy = create( getEncodingConverterNode().cloneUninitialized(), getReplacementNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/hash/ConcatHashLiteralNode.java b/src/main/java/org/truffleruby/core/hash/ConcatHashLiteralNode.java index 4a2da3bee23a..de5e39f725f7 100644 --- a/src/main/java/org/truffleruby/core/hash/ConcatHashLiteralNode.java +++ b/src/main/java/org/truffleruby/core/hash/ConcatHashLiteralNode.java @@ -44,8 +44,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new ConcatHashLiteralNode(cloneUninitialized(children)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/hash/library/BucketsHashStore.java b/src/main/java/org/truffleruby/core/hash/library/BucketsHashStore.java index 67abff5f985a..9427b2bb16b2 100644 --- a/src/main/java/org/truffleruby/core/hash/library/BucketsHashStore.java +++ b/src/main/java/org/truffleruby/core/hash/library/BucketsHashStore.java @@ -632,8 +632,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new GenericHashLiteralNode(cloneUninitialized(keyValues)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/hash/library/EmptyHashStore.java b/src/main/java/org/truffleruby/core/hash/library/EmptyHashStore.java index f94504c50de2..9c38aff8215a 100644 --- a/src/main/java/org/truffleruby/core/hash/library/EmptyHashStore.java +++ b/src/main/java/org/truffleruby/core/hash/library/EmptyHashStore.java @@ -122,8 +122,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new EmptyHashLiteralNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/hash/library/PackedHashStoreLibrary.java b/src/main/java/org/truffleruby/core/hash/library/PackedHashStoreLibrary.java index 006ecace41c0..ed6b1a89a5a6 100644 --- a/src/main/java/org/truffleruby/core/hash/library/PackedHashStoreLibrary.java +++ b/src/main/java/org/truffleruby/core/hash/library/PackedHashStoreLibrary.java @@ -553,8 +553,7 @@ private boolean callEqual(Object receiver, Object key) { @Override public RubyNode cloneUninitialized() { var copy = new SmallHashLiteralNode(cloneUninitialized(keyValues)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedAddNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedAddNode.java index 378c41276b40..efaa7eba66d0 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedAddNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedAddNode.java @@ -79,8 +79,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedAtNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedAtNode.java index c36de09cda70..35f5143aa508 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedAtNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedAtNode.java @@ -55,8 +55,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedBitAndNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedBitAndNode.java index 836cc8256890..bde368e35d66 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedBitAndNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedBitAndNode.java @@ -73,7 +73,6 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedBitOrNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedBitOrNode.java index b84f55fe5bcd..5ebbf2d9e46c 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedBitOrNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedBitOrNode.java @@ -60,8 +60,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedByteSizeNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedByteSizeNode.java index 3340a50fd6d5..da497776e0d6 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedByteSizeNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedByteSizeNode.java @@ -60,8 +60,7 @@ public RubyNode cloneUninitialized() { getLanguage(), this.parameters, getSelfNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedCaseEqualNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedCaseEqualNode.java index 605b5e62be80..6396a9c16308 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedCaseEqualNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedCaseEqualNode.java @@ -66,8 +66,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedDivNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedDivNode.java index f807129a0134..4ae1827e67d3 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedDivNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedDivNode.java @@ -66,8 +66,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedEqualNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedEqualNode.java index 85ef530acd28..98530a910145 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedEqualNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedEqualNode.java @@ -93,8 +93,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedGreaterOrEqualNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedGreaterOrEqualNode.java index 2b7524846416..781a522cc830 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedGreaterOrEqualNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedGreaterOrEqualNode.java @@ -63,8 +63,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedGreaterThanNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedGreaterThanNode.java index 333128febea0..47b7521e9044 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedGreaterThanNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedGreaterThanNode.java @@ -63,8 +63,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedIndexGetNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedIndexGetNode.java index 88b5989a4eee..d1594171488b 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedIndexGetNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedIndexGetNode.java @@ -55,8 +55,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java index 2a1418d91259..b4aba5d9c3b5 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedIndexSetNode.java @@ -87,8 +87,7 @@ public RubyNode cloneUninitialized() { getReceiver().cloneUninitialized(), getOperand1Node().cloneUninitialized(), getOperand2Node().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedIsANode.java b/src/main/java/org/truffleruby/core/inlined/InlinedIsANode.java index e3490aaa849c..90803574fb76 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedIsANode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedIsANode.java @@ -50,8 +50,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedIsNilNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedIsNilNode.java index b3b58cfa026c..71b1d6a54c66 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedIsNilNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedIsNilNode.java @@ -55,8 +55,7 @@ public RubyNode cloneUninitialized() { getLanguage(), this.parameters, getSelfNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedKindOfNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedKindOfNode.java index 3f3a137d5a35..0ff6a14f4fcd 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedKindOfNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedKindOfNode.java @@ -50,8 +50,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedLambdaNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedLambdaNode.java index 86a59ed667b6..54c642a513fe 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedLambdaNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedLambdaNode.java @@ -67,8 +67,7 @@ public RubyNode cloneUninitialized() { this.parameters, getSelfNode().cloneUninitialized(), getBlock().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedLeftShiftNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedLeftShiftNode.java index e5aef1ed41a1..3a7c29bcbf63 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedLeftShiftNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedLeftShiftNode.java @@ -60,8 +60,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedLessOrEqualNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedLessOrEqualNode.java index 6f5cbc8dd1b9..28e92294b24b 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedLessOrEqualNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedLessOrEqualNode.java @@ -62,8 +62,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedLessThanNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedLessThanNode.java index 1ad6f90e0ce6..f07ffd0ca592 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedLessThanNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedLessThanNode.java @@ -63,8 +63,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedModNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedModNode.java index c7d34ba4496b..c9d0448c4e46 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedModNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedModNode.java @@ -73,8 +73,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedMulNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedMulNode.java index 62557ab312e7..15046aea5801 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedMulNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedMulNode.java @@ -76,8 +76,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedNegNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedNegNode.java index 8d4d883e9d6c..e45085906b08 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedNegNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedNegNode.java @@ -65,8 +65,7 @@ public RubyNode cloneUninitialized() { getLanguage(), this.parameters, getSelfNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedNotNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedNotNode.java index 919c6fccf94e..13b4e7716540 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedNotNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedNotNode.java @@ -48,8 +48,7 @@ public RubyNode cloneUninitialized() { getLanguage(), this.parameters, getSelfNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedRightShiftNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedRightShiftNode.java index dab26b9f7a88..feefb9855b76 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedRightShiftNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedRightShiftNode.java @@ -60,8 +60,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedSubNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedSubNode.java index c964671ef913..7bdaacf7d750 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedSubNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedSubNode.java @@ -79,8 +79,7 @@ public RubyNode cloneUninitialized() { this.parameters, getLeftNode().cloneUninitialized(), getRightNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/LambdaToProcNode.java b/src/main/java/org/truffleruby/core/inlined/LambdaToProcNode.java index c1115e00e580..cef831c03f35 100644 --- a/src/main/java/org/truffleruby/core/inlined/LambdaToProcNode.java +++ b/src/main/java/org/truffleruby/core/inlined/LambdaToProcNode.java @@ -43,8 +43,7 @@ public RubyProc execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new LambdaToProcNode((BlockDefinitionNode) blockNode.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/kernel/AutoSplitNode.java b/src/main/java/org/truffleruby/core/kernel/AutoSplitNode.java index d51b423cac0d..e477cc83488f 100644 --- a/src/main/java/org/truffleruby/core/kernel/AutoSplitNode.java +++ b/src/main/java/org/truffleruby/core/kernel/AutoSplitNode.java @@ -34,8 +34,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new AutoSplitNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/kernel/ChompLoopNode.java b/src/main/java/org/truffleruby/core/kernel/ChompLoopNode.java index 6da509012b93..9a40e3a5c051 100644 --- a/src/main/java/org/truffleruby/core/kernel/ChompLoopNode.java +++ b/src/main/java/org/truffleruby/core/kernel/ChompLoopNode.java @@ -31,8 +31,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new ChompLoopNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/kernel/KernelGetsNode.java b/src/main/java/org/truffleruby/core/kernel/KernelGetsNode.java index 5e002e2d8d01..38068436da27 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelGetsNode.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelGetsNode.java @@ -32,8 +32,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new KernelGetsNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java index 1383e08e5ce1..c71c705ff2f4 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java @@ -671,8 +671,7 @@ protected Object execute(VirtualFrame frame, Object self, @Override public RubyNode cloneUninitialized() { var copy = create(getSelfNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1294,8 +1293,7 @@ public RubyNode cloneUninitialized() { var copy = create( getObjectNode().cloneUninitialized(), getRegularNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1369,8 +1367,7 @@ public RubyNode cloneUninitialized() { var copy = create( getObjectNode().cloneUninitialized(), getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1426,8 +1423,7 @@ public RubyNode cloneUninitialized() { var copy = create( getObjectNode().cloneUninitialized(), getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1487,8 +1483,7 @@ public RubyNode cloneUninitialized() { var copy = create( getObjectNode().cloneUninitialized(), getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1660,8 +1655,7 @@ public RubyNode cloneUninitialized() { var copy = create( getObjectNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1716,8 +1710,7 @@ public RubyNode cloneUninitialized() { var copy = create( getObjectNode().cloneUninitialized(), getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1896,8 +1889,7 @@ public RubyNode cloneUninitialized() { var copy = create( getFormatNodeBeforeCasting().cloneUninitialized(), getArgumentsNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/kernel/KernelPrintLastLineNode.java b/src/main/java/org/truffleruby/core/kernel/KernelPrintLastLineNode.java index e35b792ffa17..a96e257e909c 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelPrintLastLineNode.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelPrintLastLineNode.java @@ -40,8 +40,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new KernelPrintLastLineNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java b/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java index 7bbb48df9580..bde06a4f5279 100644 --- a/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java @@ -167,8 +167,7 @@ public RubyNode cloneUninitialized() { var copy = create( getFileNode().cloneUninitialized(), getWrapNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/method/MethodNodes.java b/src/main/java/org/truffleruby/core/method/MethodNodes.java index df35ceb37b86..f9003d335cf0 100644 --- a/src/main/java/org/truffleruby/core/method/MethodNodes.java +++ b/src/main/java/org/truffleruby/core/method/MethodNodes.java @@ -365,8 +365,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new CallWithRubyMethodReceiverNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/module/ModuleNodes.java b/src/main/java/org/truffleruby/core/module/ModuleNodes.java index 177f5dc55b6a..507ac08b6a65 100644 --- a/src/main/java/org/truffleruby/core/module/ModuleNodes.java +++ b/src/main/java/org/truffleruby/core/module/ModuleNodes.java @@ -386,8 +386,7 @@ public RubyNode cloneUninitialized() { getModuleNode().cloneUninitialized(), getNewNameNodeBeforeCasting().cloneUninitialized(), getOldNameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -678,8 +677,7 @@ public RubyNode cloneUninitialized() { getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized(), getFilenameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -744,8 +742,7 @@ public RubyNode cloneUninitialized() { getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized(), getInheritNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -916,8 +913,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -966,8 +962,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1012,8 +1007,7 @@ public RubyNode cloneUninitialized() { getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized(), getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1061,8 +1055,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getInheritNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1116,8 +1109,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getInheritNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1175,8 +1167,7 @@ public RubyNode cloneUninitialized() { getNameNodeBeforeCasting().cloneUninitialized(), getInheritNodeBeforeCasting().cloneUninitialized(), getCheckNameNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1337,8 +1328,7 @@ public RubyNode cloneUninitialized() { getInheritNode().cloneUninitialized(), getLookInObjectNode().cloneUninitialized(), getCheckNameNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1375,8 +1365,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1460,8 +1449,7 @@ public RubyNode cloneUninitialized() { getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized(), getInheritNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1516,8 +1504,7 @@ public RubyNode cloneUninitialized() { getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized(), getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1733,8 +1720,7 @@ public RubyNode cloneUninitialized() { proc, lambdaCallTarget, lambdaBody.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1947,8 +1933,7 @@ public RubyNode cloneUninitialized() { getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized(), getInheritNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2189,8 +2174,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2245,8 +2229,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2267,8 +2250,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2289,8 +2271,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2367,8 +2348,7 @@ public RubyNode cloneUninitialized() { getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized(), getInheritNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2391,8 +2371,7 @@ public RubyNode cloneUninitialized() { getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized(), getInheritNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2414,8 +2393,7 @@ public RubyNode cloneUninitialized() { getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized(), getInheritNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2455,8 +2433,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2595,8 +2572,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2644,8 +2620,7 @@ public RubyNode cloneUninitialized() { var copy = create( getModuleNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java b/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java index 09a432fe9d60..f89e7cf04d01 100644 --- a/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java +++ b/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java @@ -60,8 +60,7 @@ protected Object passThrough(Object value) { public RubyNode cloneUninitialized() { var copy = create(getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/numeric/IntegerNodes.java b/src/main/java/org/truffleruby/core/numeric/IntegerNodes.java index 484e9f8c1ace..6c56a5ec042e 100644 --- a/src/main/java/org/truffleruby/core/numeric/IntegerNodes.java +++ b/src/main/java/org/truffleruby/core/numeric/IntegerNodes.java @@ -1936,8 +1936,7 @@ public RubyNode cloneUninitialized() { getBaseNodeBeforeCasting().cloneUninitialized(), getExponentNodeBeforeCasting().cloneUninitialized(), getModuloNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/queue/QueueNodes.java b/src/main/java/org/truffleruby/core/queue/QueueNodes.java index bd839f4189ff..f516725fce8d 100644 --- a/src/main/java/org/truffleruby/core/queue/QueueNodes.java +++ b/src/main/java/org/truffleruby/core/queue/QueueNodes.java @@ -127,8 +127,7 @@ public RubyNode cloneUninitialized() { var copy = create( getQueueNode().cloneUninitialized(), getNonBlockingNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java b/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java index 70f04222893b..3ca0215a9ece 100644 --- a/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java +++ b/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java @@ -172,8 +172,7 @@ public RubyNode cloneUninitialized() { getQueueNode().cloneUninitialized(), getValueNode().cloneUninitialized(), getNonBlockingNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -238,8 +237,7 @@ public RubyNode cloneUninitialized() { var copy = create( getQueueNode().cloneUninitialized(), getNonBlockingNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/range/RangeNodes.java b/src/main/java/org/truffleruby/core/range/RangeNodes.java index 02345c563dfd..f236e652fb7d 100644 --- a/src/main/java/org/truffleruby/core/range/RangeNodes.java +++ b/src/main/java/org/truffleruby/core/range/RangeNodes.java @@ -444,8 +444,7 @@ public RubyNode cloneUninitialized() { getBeginNode().cloneUninitialized(), getEndNode().cloneUninitialized(), getExcludeEndNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java b/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java index 06f5c9941060..f6f1963584e3 100644 --- a/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java +++ b/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java @@ -65,8 +65,7 @@ public RubyNode cloneUninitialized() { var copy = new InterpolatedRegexpNode( cloneUninitialized(children), builderNode); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } protected static ToSNode[] cloneUninitialized(ToSNode[] nodes) { diff --git a/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java b/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java index 4a496f3d95d6..793d0c849945 100644 --- a/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java +++ b/src/main/java/org/truffleruby/core/string/InterpolatedStringNode.java @@ -72,8 +72,7 @@ public RubyNode cloneUninitialized() { var copy = new InterpolatedStringNode( cloneUninitialized(children), encoding); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } protected static ToSNode[] cloneUninitialized(ToSNode[] nodes) { diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java index 19362f86634c..ee4af6eb5bce 100644 --- a/src/main/java/org/truffleruby/core/string/StringNodes.java +++ b/src/main/java/org/truffleruby/core/string/StringNodes.java @@ -253,8 +253,7 @@ public RubyNode cloneUninitialized() { var copy = create( getStringNode().cloneUninitialized(), getOtherNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -339,8 +338,7 @@ public RubyNode cloneUninitialized() { var copy = create( getStringNode().cloneUninitialized(), getTimesNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -961,8 +959,7 @@ public RubyNode cloneUninitialized() { var copy = create( getStringNode().cloneUninitialized(), getOtherNodeBeforeCast().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1846,8 +1843,7 @@ public RubyNode cloneUninitialized() { var copy = create( getStringNode().cloneUninitialized(), getOtherNodeBeforeCast().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2426,8 +2422,7 @@ public RubyNode cloneUninitialized() { getStringNode().cloneUninitialized(), getIndexNodeBeforeCasting().cloneUninitialized(), getValueNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2898,8 +2893,7 @@ public RubyNode cloneUninitialized() { getSelfNode().cloneUninitialized(), getFromStrNodeBeforeCasting().cloneUninitialized(), getToStrNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2982,8 +2976,7 @@ public RubyNode cloneUninitialized() { getSelfNode().cloneUninitialized(), getFromStrNodeBeforeCasting().cloneUninitialized(), getToStrNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -3094,8 +3087,7 @@ public RubyNode cloneUninitialized() { var copy = create( getStringNode().cloneUninitialized(), getFormatNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/debug/ChaosNode.java b/src/main/java/org/truffleruby/debug/ChaosNode.java index 36782e93f6e1..d65a0cd0aa55 100644 --- a/src/main/java/org/truffleruby/debug/ChaosNode.java +++ b/src/main/java/org/truffleruby/debug/ChaosNode.java @@ -68,8 +68,7 @@ private boolean randomBoolean() { @Override public RubyNode cloneUninitialized() { var copy = ChaosNodeGen.create(getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/debug/MetricsBodyNode.java b/src/main/java/org/truffleruby/debug/MetricsBodyNode.java index 3b66da0429a0..77ccede491c9 100644 --- a/src/main/java/org/truffleruby/debug/MetricsBodyNode.java +++ b/src/main/java/org/truffleruby/debug/MetricsBodyNode.java @@ -32,8 +32,7 @@ private Object call(Supplier supplier) { @Override public RubyNode cloneUninitialized() { var copy = new MetricsBodyNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/interop/InteropNodes.java b/src/main/java/org/truffleruby/interop/InteropNodes.java index 6b32fe3978b6..1ab6992fd4bf 100644 --- a/src/main/java/org/truffleruby/interop/InteropNodes.java +++ b/src/main/java/org/truffleruby/interop/InteropNodes.java @@ -1601,8 +1601,7 @@ public RubyNode cloneUninitialized() { var copy = create( getNameNodeBeforeCasting().cloneUninitialized(), getObjectNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -1647,8 +1646,7 @@ private RubyNode getNameNodeBeforeCasting() { @Override public RubyNode cloneUninitialized() { var copy = create(getNameNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2430,8 +2428,7 @@ public RubyNode cloneUninitialized() { getReceiverNode().cloneUninitialized(), getByteOrderNodeBeforeCasting().cloneUninitialized(), getByteOffsetNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2486,8 +2483,7 @@ public RubyNode cloneUninitialized() { getByteOrderNodeBeforeCasting().cloneUninitialized(), getByteOffsetNode().cloneUninitialized(), getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2534,8 +2530,7 @@ public RubyNode cloneUninitialized() { getReceiverNode().cloneUninitialized(), getByteOrderNodeBeforeCasting().cloneUninitialized(), getByteOffsetNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2590,8 +2585,7 @@ public RubyNode cloneUninitialized() { getByteOrderNodeBeforeCasting().cloneUninitialized(), getByteOffsetNode().cloneUninitialized(), getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2638,8 +2632,7 @@ public RubyNode cloneUninitialized() { getReceiverNode().cloneUninitialized(), getByteOrderNodeBeforeCasting().cloneUninitialized(), getByteOffsetNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2694,8 +2687,7 @@ public RubyNode cloneUninitialized() { getByteOrderNodeBeforeCasting().cloneUninitialized(), getByteOffsetNode().cloneUninitialized(), getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2743,8 +2735,7 @@ public RubyNode cloneUninitialized() { getReceiverNode().cloneUninitialized(), getByteOrderNodeBeforeCasting().cloneUninitialized(), getByteOffsetNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2799,8 +2790,7 @@ public RubyNode cloneUninitialized() { getByteOrderNodeBeforeCasting().cloneUninitialized(), getByteOffsetNode().cloneUninitialized(), getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2846,8 +2836,7 @@ public RubyNode cloneUninitialized() { getReceiverNode().cloneUninitialized(), getByteOrderNodeBeforeCasting().cloneUninitialized(), getByteOffsetNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -2902,8 +2891,7 @@ public RubyNode cloneUninitialized() { getByteOrderNodeBeforeCasting().cloneUninitialized(), getByteOffsetNode().cloneUninitialized(), getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java b/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java index f3c4c733a8fa..8cde83782554 100644 --- a/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java +++ b/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java @@ -53,8 +53,7 @@ protected ByteOrder invalidByteOrder(Object value) { @Override public RubyNode cloneUninitialized() { var copy = SymbolToByteOrderNodeGen.create(getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java b/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java index 8cf47e7e4457..fcc11de540e1 100644 --- a/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java +++ b/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java @@ -45,8 +45,7 @@ public RubyNode cloneUninitialized() { var copy = ToJavaStringWithDefaultNodeGen.create( defaultValue, getValueNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/DataNode.java b/src/main/java/org/truffleruby/language/DataNode.java index 58d960804655..8d6564006bbc 100644 --- a/src/main/java/org/truffleruby/language/DataNode.java +++ b/src/main/java/org/truffleruby/language/DataNode.java @@ -60,8 +60,7 @@ private String getPath() { @Override public RubyNode cloneUninitialized() { var copy = new DataNode(endPosition); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/EmitWarningsNode.java b/src/main/java/org/truffleruby/language/EmitWarningsNode.java index fe8e25651975..0c130662cb69 100644 --- a/src/main/java/org/truffleruby/language/EmitWarningsNode.java +++ b/src/main/java/org/truffleruby/language/EmitWarningsNode.java @@ -82,8 +82,7 @@ private static void printWarning(RubyContext context, String message) { @Override public RubyNode cloneUninitialized() { var copy = new EmitWarningsNode(warnings); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/RubyContextSourceNode.java b/src/main/java/org/truffleruby/language/RubyContextSourceNode.java index 1f47cd6b8a86..aa0dc411864b 100644 --- a/src/main/java/org/truffleruby/language/RubyContextSourceNode.java +++ b/src/main/java/org/truffleruby/language/RubyContextSourceNode.java @@ -61,9 +61,10 @@ public String toString() { return super.toString() + " at " + RubyLanguage.fileLine(getSourceSection()); } - public void copyFlags(RubyContextSourceNode original) { + public RubyContextSourceNode copyFlags(RubyContextSourceNode original) { this.sourceCharIndex = original.sourceCharIndex; this.sourceLength = original.sourceLength; this.flags = original.flags; + return this; } } diff --git a/src/main/java/org/truffleruby/language/SetTopLevelBindingNode.java b/src/main/java/org/truffleruby/language/SetTopLevelBindingNode.java index bb0b1d10995c..97de2a84154b 100644 --- a/src/main/java/org/truffleruby/language/SetTopLevelBindingNode.java +++ b/src/main/java/org/truffleruby/language/SetTopLevelBindingNode.java @@ -36,8 +36,7 @@ private void updateTopLevelBindingFrame(MaterializedFrame mainScriptFrame) { @Override public RubyNode cloneUninitialized() { var copy = new SetTopLevelBindingNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ArrayIsAtLeastAsLargeAsNode.java b/src/main/java/org/truffleruby/language/arguments/ArrayIsAtLeastAsLargeAsNode.java index f4e72c1c6ac5..40dbcbbdd13c 100644 --- a/src/main/java/org/truffleruby/language/arguments/ArrayIsAtLeastAsLargeAsNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ArrayIsAtLeastAsLargeAsNode.java @@ -37,8 +37,7 @@ public RubyNode cloneUninitialized() { var copy = new ArrayIsAtLeastAsLargeAsNode( requiredSize, child.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/CheckNoKeywordArgumentsNode.java b/src/main/java/org/truffleruby/language/arguments/CheckNoKeywordArgumentsNode.java index cf1feb744f6f..e29708ff74dd 100644 --- a/src/main/java/org/truffleruby/language/arguments/CheckNoKeywordArgumentsNode.java +++ b/src/main/java/org/truffleruby/language/arguments/CheckNoKeywordArgumentsNode.java @@ -41,8 +41,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new CheckNoKeywordArgumentsNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/MissingKeywordArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/MissingKeywordArgumentNode.java index cd5292717907..e55ab20d306b 100644 --- a/src/main/java/org/truffleruby/language/arguments/MissingKeywordArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/MissingKeywordArgumentNode.java @@ -91,8 +91,7 @@ private Object[] findMissingKeywordArguments(RubyHash actualKeywords) { @Override public RubyNode cloneUninitialized() { var copy = new MissingKeywordArgumentNode(requiredKeywords); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/NotProvidedNode.java b/src/main/java/org/truffleruby/language/arguments/NotProvidedNode.java index 8a20909afb04..fb7bd9426f87 100644 --- a/src/main/java/org/truffleruby/language/arguments/NotProvidedNode.java +++ b/src/main/java/org/truffleruby/language/arguments/NotProvidedNode.java @@ -25,8 +25,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new NotProvidedNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ProfileArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ProfileArgumentNode.java index 2a53deb5c0b6..f9bd2f81e0a5 100644 --- a/src/main/java/org/truffleruby/language/arguments/ProfileArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ProfileArgumentNode.java @@ -93,8 +93,7 @@ public String toString() { @Override public RubyNode cloneUninitialized() { var copy = ProfileArgumentNodeGen.create(getChildNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadBlockFromCurrentFrameArgumentsNode.java b/src/main/java/org/truffleruby/language/arguments/ReadBlockFromCurrentFrameArgumentsNode.java index f7b1bd85179c..c18071af5117 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadBlockFromCurrentFrameArgumentsNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadBlockFromCurrentFrameArgumentsNode.java @@ -24,8 +24,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new ReadBlockFromCurrentFrameArgumentsNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java index 6d5e1d163800..5709a6a7d189 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadKeywordArgumentNode.java @@ -95,8 +95,7 @@ RubyNode getDefaultValue() { @Override public RubyNode cloneUninitialized() { var copy = ReadKeywordArgumentNode.create(name, cloneUninitialized(defaultValue)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java index 5c744a4ef5b7..fdf06cd5185c 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadKeywordRestArgumentNode.java @@ -80,8 +80,7 @@ private boolean keywordExcluded(Object keyword) { @Override public RubyNode cloneUninitialized() { var copy = new ReadKeywordRestArgumentNode(excludedKeywords); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadOptionalArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadOptionalArgumentNode.java index b373a4eabe45..b0efdb48eeeb 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadOptionalArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadOptionalArgumentNode.java @@ -58,8 +58,7 @@ public RubyNode cloneUninitialized() { minimum, keywordArguments, defaultValue.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadPostArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadPostArgumentNode.java index 8f97fecd5d34..5bb9e6034813 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadPostArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadPostArgumentNode.java @@ -49,8 +49,7 @@ public String toString() { @Override public RubyNode cloneUninitialized() { var copy = new ReadPostArgumentNode(indexFromCount, keywordArguments, required); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadPreArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadPreArgumentNode.java index 7d884f182bb9..be4f0a9785dc 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadPreArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadPreArgumentNode.java @@ -67,8 +67,7 @@ public String toString() { @Override public RubyNode cloneUninitialized() { var copy = new ReadPreArgumentNode(index, keywordArguments, missingArgumentBehavior); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadRemainingArgumentsNode.java b/src/main/java/org/truffleruby/language/arguments/ReadRemainingArgumentsNode.java index 097441032333..8951c971df8b 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadRemainingArgumentsNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadRemainingArgumentsNode.java @@ -39,8 +39,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new ReadRemainingArgumentsNode(start); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadRestArgumentNode.java b/src/main/java/org/truffleruby/language/arguments/ReadRestArgumentNode.java index 1fb26404bb46..e5fa0ff84940 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadRestArgumentNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadRestArgumentNode.java @@ -92,8 +92,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new ReadRestArgumentNode(startIndex, postArgumentsCount, keywordArguments, markKeywordHashWithFlag); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ReadSelfNode.java b/src/main/java/org/truffleruby/language/arguments/ReadSelfNode.java index f9681b224cf7..bdcd04c34758 100644 --- a/src/main/java/org/truffleruby/language/arguments/ReadSelfNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ReadSelfNode.java @@ -24,8 +24,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new ReadSelfNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/SaveMethodBlockNode.java b/src/main/java/org/truffleruby/language/arguments/SaveMethodBlockNode.java index 06196b524d78..e2f6111dca98 100644 --- a/src/main/java/org/truffleruby/language/arguments/SaveMethodBlockNode.java +++ b/src/main/java/org/truffleruby/language/arguments/SaveMethodBlockNode.java @@ -31,8 +31,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new SaveMethodBlockNode(slot); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/arguments/ShouldDestructureNode.java b/src/main/java/org/truffleruby/language/arguments/ShouldDestructureNode.java index a3cdc3501a7b..b0a5b8802ce5 100644 --- a/src/main/java/org/truffleruby/language/arguments/ShouldDestructureNode.java +++ b/src/main/java/org/truffleruby/language/arguments/ShouldDestructureNode.java @@ -60,8 +60,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new ShouldDestructureNode(keywordArguments); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/constants/OrAssignConstantNode.java b/src/main/java/org/truffleruby/language/constants/OrAssignConstantNode.java index b87503523608..3b308d8d671d 100644 --- a/src/main/java/org/truffleruby/language/constants/OrAssignConstantNode.java +++ b/src/main/java/org/truffleruby/language/constants/OrAssignConstantNode.java @@ -89,8 +89,7 @@ public RubyNode cloneUninitialized() { var copy = new OrAssignConstantNode( (ReadConstantNode) readConstant.cloneUninitialized(), (WriteConstantNode) writeConstant.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/constants/ReadConstantNode.java b/src/main/java/org/truffleruby/language/constants/ReadConstantNode.java index b95d2ddf081b..842f55aec6cd 100644 --- a/src/main/java/org/truffleruby/language/constants/ReadConstantNode.java +++ b/src/main/java/org/truffleruby/language/constants/ReadConstantNode.java @@ -133,8 +133,7 @@ public RubyNode cloneUninitialized() { var copy = new ReadConstantNode( moduleNode.cloneUninitialized(), name); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/constants/ReadConstantWithDynamicScopeNode.java b/src/main/java/org/truffleruby/language/constants/ReadConstantWithDynamicScopeNode.java index 46b740a36957..c6f93303059f 100644 --- a/src/main/java/org/truffleruby/language/constants/ReadConstantWithDynamicScopeNode.java +++ b/src/main/java/org/truffleruby/language/constants/ReadConstantWithDynamicScopeNode.java @@ -68,8 +68,7 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c @Override public RubyNode cloneUninitialized() { var copy = new ReadConstantWithDynamicScopeNode(name); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/constants/ReadConstantWithLexicalScopeNode.java b/src/main/java/org/truffleruby/language/constants/ReadConstantWithLexicalScopeNode.java index 6048333f0ff4..1060327f4538 100644 --- a/src/main/java/org/truffleruby/language/constants/ReadConstantWithLexicalScopeNode.java +++ b/src/main/java/org/truffleruby/language/constants/ReadConstantWithLexicalScopeNode.java @@ -65,8 +65,7 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c public RubyNode cloneUninitialized() { var copy = new ReadConstantWithLexicalScopeNode(lexicalScope, name); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java b/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java index fbd3803ee5c1..a7e4a75733dc 100644 --- a/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java +++ b/src/main/java/org/truffleruby/language/constants/WriteConstantNode.java @@ -95,8 +95,7 @@ public RubyNode cloneUninitialized() { name, moduleNode.cloneUninitialized(), valueNode.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/AndNode.java b/src/main/java/org/truffleruby/language/control/AndNode.java index 6d7bca096aef..1f1d722e9a22 100644 --- a/src/main/java/org/truffleruby/language/control/AndNode.java +++ b/src/main/java/org/truffleruby/language/control/AndNode.java @@ -56,8 +56,7 @@ public RubyNode cloneUninitialized() { var copy = new AndNode( left.cloneUninitialized(), right.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/BreakNode.java b/src/main/java/org/truffleruby/language/control/BreakNode.java index 874679b4f48e..6b8402da1efc 100644 --- a/src/main/java/org/truffleruby/language/control/BreakNode.java +++ b/src/main/java/org/truffleruby/language/control/BreakNode.java @@ -51,8 +51,7 @@ public RubyNode cloneUninitialized() { breakID, ignoreMarker, child.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/DynamicReturnNode.java b/src/main/java/org/truffleruby/language/control/DynamicReturnNode.java index c7b017c25f16..a27e073cd858 100644 --- a/src/main/java/org/truffleruby/language/control/DynamicReturnNode.java +++ b/src/main/java/org/truffleruby/language/control/DynamicReturnNode.java @@ -40,8 +40,7 @@ public RubyNode cloneUninitialized() { var copy = new DynamicReturnNode( returnID, value.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/ElidableResultNode.java b/src/main/java/org/truffleruby/language/control/ElidableResultNode.java index e739ab1d5806..dd2dd4b882c1 100644 --- a/src/main/java/org/truffleruby/language/control/ElidableResultNode.java +++ b/src/main/java/org/truffleruby/language/control/ElidableResultNode.java @@ -52,8 +52,7 @@ public RubyNode cloneUninitialized() { var copy = new ElidableResultNode( required.cloneUninitialized(), elidableResult.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/FrameOnStackNode.java b/src/main/java/org/truffleruby/language/control/FrameOnStackNode.java index 66da2cd98e98..e520fc281b64 100644 --- a/src/main/java/org/truffleruby/language/control/FrameOnStackNode.java +++ b/src/main/java/org/truffleruby/language/control/FrameOnStackNode.java @@ -42,8 +42,7 @@ public RubyNode cloneUninitialized() { var copy = new FrameOnStackNode( child.cloneUninitialized(), frameOnStackMarkerSlot); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/IfElseNode.java b/src/main/java/org/truffleruby/language/control/IfElseNode.java index ee4b3cafad11..a273402a46d8 100644 --- a/src/main/java/org/truffleruby/language/control/IfElseNode.java +++ b/src/main/java/org/truffleruby/language/control/IfElseNode.java @@ -68,8 +68,7 @@ public RubyNode cloneUninitialized() { getConditionBeforeCasting().cloneUninitialized(), thenBody.cloneUninitialized(), elseBody.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/IfNode.java b/src/main/java/org/truffleruby/language/control/IfNode.java index b9d5507b77c2..902ff7d4d7c0 100644 --- a/src/main/java/org/truffleruby/language/control/IfNode.java +++ b/src/main/java/org/truffleruby/language/control/IfNode.java @@ -66,8 +66,7 @@ public RubyNode cloneUninitialized() { var copy = new IfNode( getConditionBeforeCasting().cloneUninitialized(), thenBody.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/InvalidReturnNode.java b/src/main/java/org/truffleruby/language/control/InvalidReturnNode.java index 127d97da594f..f41cc5867b0c 100644 --- a/src/main/java/org/truffleruby/language/control/InvalidReturnNode.java +++ b/src/main/java/org/truffleruby/language/control/InvalidReturnNode.java @@ -31,8 +31,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new InvalidReturnNode(value.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/LocalReturnNode.java b/src/main/java/org/truffleruby/language/control/LocalReturnNode.java index 99d5ba9d45dc..80b1e7b856ae 100644 --- a/src/main/java/org/truffleruby/language/control/LocalReturnNode.java +++ b/src/main/java/org/truffleruby/language/control/LocalReturnNode.java @@ -40,8 +40,7 @@ public RubyNode simplifyAsTailExpression() { @Override public RubyNode cloneUninitialized() { var copy = new LocalReturnNode(value.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/NextNode.java b/src/main/java/org/truffleruby/language/control/NextNode.java index 81ba9419c012..75994b547e5f 100644 --- a/src/main/java/org/truffleruby/language/control/NextNode.java +++ b/src/main/java/org/truffleruby/language/control/NextNode.java @@ -30,8 +30,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new NextNode(child.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/NotNode.java b/src/main/java/org/truffleruby/language/control/NotNode.java index d72b8e845be9..64bc1f8b78bc 100644 --- a/src/main/java/org/truffleruby/language/control/NotNode.java +++ b/src/main/java/org/truffleruby/language/control/NotNode.java @@ -35,8 +35,7 @@ private RubyNode getChildBeforeCasting() { public RubyNode cloneUninitialized() { var copy = new NotNode(getChildBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/OnceNode.java b/src/main/java/org/truffleruby/language/control/OnceNode.java index 2f3716d35e92..a35f45386b02 100644 --- a/src/main/java/org/truffleruby/language/control/OnceNode.java +++ b/src/main/java/org/truffleruby/language/control/OnceNode.java @@ -57,8 +57,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new OnceNode(child.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/OrLazyValueDefinedNode.java b/src/main/java/org/truffleruby/language/control/OrLazyValueDefinedNode.java index 646eac452856..624f22a6d4c1 100644 --- a/src/main/java/org/truffleruby/language/control/OrLazyValueDefinedNode.java +++ b/src/main/java/org/truffleruby/language/control/OrLazyValueDefinedNode.java @@ -62,8 +62,7 @@ public RubyNode cloneUninitialized() { var copy = new OrLazyValueDefinedNode( left.cloneUninitialized(), right.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/OrNode.java b/src/main/java/org/truffleruby/language/control/OrNode.java index 54501c14851d..748c62ca1ad7 100644 --- a/src/main/java/org/truffleruby/language/control/OrNode.java +++ b/src/main/java/org/truffleruby/language/control/OrNode.java @@ -46,8 +46,7 @@ public RubyNode cloneUninitialized() { var copy = new OrNode( left.cloneUninitialized(), right.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/RedoNode.java b/src/main/java/org/truffleruby/language/control/RedoNode.java index c6710e0884fc..426534c2b636 100644 --- a/src/main/java/org/truffleruby/language/control/RedoNode.java +++ b/src/main/java/org/truffleruby/language/control/RedoNode.java @@ -24,8 +24,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new RedoNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/RetryNode.java b/src/main/java/org/truffleruby/language/control/RetryNode.java index e0f83abe4658..7b06a2b1821f 100644 --- a/src/main/java/org/truffleruby/language/control/RetryNode.java +++ b/src/main/java/org/truffleruby/language/control/RetryNode.java @@ -24,8 +24,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new RetryNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/SequenceNode.java b/src/main/java/org/truffleruby/language/control/SequenceNode.java index c4704c36d4ee..a0abd8a46c4d 100644 --- a/src/main/java/org/truffleruby/language/control/SequenceNode.java +++ b/src/main/java/org/truffleruby/language/control/SequenceNode.java @@ -72,8 +72,7 @@ public RubyNode simplifyAsTailExpression() { @Override public RubyNode cloneUninitialized() { var copy = new SequenceNode(cloneUninitialized(body)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/UnlessNode.java b/src/main/java/org/truffleruby/language/control/UnlessNode.java index 93fc9c1ecc21..20330edb384b 100644 --- a/src/main/java/org/truffleruby/language/control/UnlessNode.java +++ b/src/main/java/org/truffleruby/language/control/UnlessNode.java @@ -66,8 +66,7 @@ public RubyNode cloneUninitialized() { var copy = new UnlessNode( getConditionBeforeCasting().cloneUninitialized(), thenBody.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/control/WhileNode.java b/src/main/java/org/truffleruby/language/control/WhileNode.java index 0a63ef618ec2..517f2e2f0f4b 100644 --- a/src/main/java/org/truffleruby/language/control/WhileNode.java +++ b/src/main/java/org/truffleruby/language/control/WhileNode.java @@ -44,8 +44,7 @@ public Object execute(VirtualFrame frame) { public RubyNode cloneUninitialized() { var repeatingNode = (WhileRepeatingBaseNode) loopNode.getRepeatingNode(); var copy = new WhileNode(repeatingNode.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } private abstract static class WhileRepeatingBaseNode extends RubyBaseNode implements RepeatingNode { diff --git a/src/main/java/org/truffleruby/language/defined/DefinedNode.java b/src/main/java/org/truffleruby/language/defined/DefinedNode.java index ffa2c66ba8c6..6c308976d3ce 100644 --- a/src/main/java/org/truffleruby/language/defined/DefinedNode.java +++ b/src/main/java/org/truffleruby/language/defined/DefinedNode.java @@ -30,8 +30,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new DefinedNode(child.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/defined/DefinedWrapperNode.java b/src/main/java/org/truffleruby/language/defined/DefinedWrapperNode.java index 177b03926785..dace192465bd 100644 --- a/src/main/java/org/truffleruby/language/defined/DefinedWrapperNode.java +++ b/src/main/java/org/truffleruby/language/defined/DefinedWrapperNode.java @@ -43,8 +43,7 @@ public RubyNode cloneUninitialized() { var copy = new DefinedWrapperNode( definition, child.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java index b63c37fbdc34..86357e9f1f44 100644 --- a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java +++ b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java @@ -279,8 +279,7 @@ public RubyNode cloneUninitialized() { isVCall, isSafeNavigation, isAttrAssign); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } private class DefinedNode extends RubyBaseNode { diff --git a/src/main/java/org/truffleruby/language/exceptions/EnsureNode.java b/src/main/java/org/truffleruby/language/exceptions/EnsureNode.java index 2b632a884436..5e73424e99ad 100644 --- a/src/main/java/org/truffleruby/language/exceptions/EnsureNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/EnsureNode.java @@ -99,8 +99,7 @@ public RubyNode cloneUninitialized() { var copy = new EnsureNode( tryPart.cloneUninitialized(), ensurePart.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/exceptions/RescueClassesNode.java b/src/main/java/org/truffleruby/language/exceptions/RescueClassesNode.java index a3d4a1c017c0..dc3419123041 100644 --- a/src/main/java/org/truffleruby/language/exceptions/RescueClassesNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/RescueClassesNode.java @@ -48,8 +48,7 @@ public RubyNode cloneUninitialized() { var copy = new RescueClassesNode( cloneUninitialized(handlingClassNodes), getRescueBody().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/exceptions/RescueSplatNode.java b/src/main/java/org/truffleruby/language/exceptions/RescueSplatNode.java index aa65fc2e3a8f..f7f49aade228 100644 --- a/src/main/java/org/truffleruby/language/exceptions/RescueSplatNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/RescueSplatNode.java @@ -69,8 +69,7 @@ public RubyNode cloneUninitialized() { getLanguage(), splatCastNode.getChildNode().cloneUninitialized(), getRescueBody().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/exceptions/RescueStandardErrorNode.java b/src/main/java/org/truffleruby/language/exceptions/RescueStandardErrorNode.java index 2d03c943aa22..d33232f17e24 100644 --- a/src/main/java/org/truffleruby/language/exceptions/RescueStandardErrorNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/RescueStandardErrorNode.java @@ -34,8 +34,7 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c @Override public RubyNode cloneUninitialized() { var copy = new RescueStandardErrorNode(getRescueBody().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/exceptions/TryNode.java b/src/main/java/org/truffleruby/language/exceptions/TryNode.java index e252bd21afc2..7949d5ce6232 100644 --- a/src/main/java/org/truffleruby/language/exceptions/TryNode.java +++ b/src/main/java/org/truffleruby/language/exceptions/TryNode.java @@ -149,8 +149,7 @@ public RubyNode cloneUninitialized() { cloneUninitialized(rescueParts), cloneUninitialized(elsePart), canOmitBacktrace); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } protected static RescueNode[] cloneUninitialized(RescueNode[] nodes) { diff --git a/src/main/java/org/truffleruby/language/globals/AliasGlobalVarNode.java b/src/main/java/org/truffleruby/language/globals/AliasGlobalVarNode.java index a8256b871a9f..bb815ebf0d91 100644 --- a/src/main/java/org/truffleruby/language/globals/AliasGlobalVarNode.java +++ b/src/main/java/org/truffleruby/language/globals/AliasGlobalVarNode.java @@ -33,8 +33,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new AliasGlobalVarNode(oldName, newName); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/globals/ReadGlobalVariableNode.java b/src/main/java/org/truffleruby/language/globals/ReadGlobalVariableNode.java index aff9a832412b..7f0bd549da1e 100644 --- a/src/main/java/org/truffleruby/language/globals/ReadGlobalVariableNode.java +++ b/src/main/java/org/truffleruby/language/globals/ReadGlobalVariableNode.java @@ -79,8 +79,7 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c @Override public RubyNode cloneUninitialized() { var copy = ReadGlobalVariableNodeGen.create(name); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/globals/ReadMatchReferenceNodes.java b/src/main/java/org/truffleruby/language/globals/ReadMatchReferenceNodes.java index eb3a2a376335..c298de463ba6 100644 --- a/src/main/java/org/truffleruby/language/globals/ReadMatchReferenceNodes.java +++ b/src/main/java/org/truffleruby/language/globals/ReadMatchReferenceNodes.java @@ -68,8 +68,7 @@ public RubyNode cloneUninitialized() { var copy = new ReadNthMatchNode( readMatchNode.cloneUninitialized(), index); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -127,8 +126,7 @@ public RubyNode cloneUninitialized() { readMatchNode.cloneUninitialized(), cloneUninitialized(setters), cloneUninitialized(nilSetters)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java b/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java index cb92f8bb814c..afe8d2cc8186 100644 --- a/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java +++ b/src/main/java/org/truffleruby/language/globals/WriteGlobalVariableNode.java @@ -104,7 +104,6 @@ public AssignableNode cloneUninitializedAssignable() { @Override public RubyNode cloneUninitialized() { var copy = WriteGlobalVariableNodeGen.create(name, cloneUninitialized(getValueNode())); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/BooleanLiteralNode.java b/src/main/java/org/truffleruby/language/literal/BooleanLiteralNode.java index f80a79e62832..7f70ab13dcab 100644 --- a/src/main/java/org/truffleruby/language/literal/BooleanLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/BooleanLiteralNode.java @@ -45,8 +45,7 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c @Override public RubyNode cloneUninitialized() { var copy = new BooleanLiteralNode(value); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/FloatLiteralNode.java b/src/main/java/org/truffleruby/language/literal/FloatLiteralNode.java index 06cfd84f62ac..1253713cbb76 100644 --- a/src/main/java/org/truffleruby/language/literal/FloatLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/FloatLiteralNode.java @@ -33,8 +33,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new FloatLiteralNode(value); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/FrozenStringLiteralNode.java b/src/main/java/org/truffleruby/language/literal/FrozenStringLiteralNode.java index 09f87dc245f4..167ab76b7b22 100644 --- a/src/main/java/org/truffleruby/language/literal/FrozenStringLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/FrozenStringLiteralNode.java @@ -40,8 +40,7 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c @Override public RubyNode cloneUninitialized() { var copy = new FrozenStringLiteralNode(frozenString, definition); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/IntegerFixnumLiteralNode.java b/src/main/java/org/truffleruby/language/literal/IntegerFixnumLiteralNode.java index f9c251dac240..265691fc8392 100644 --- a/src/main/java/org/truffleruby/language/literal/IntegerFixnumLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/IntegerFixnumLiteralNode.java @@ -33,8 +33,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new IntegerFixnumLiteralNode(value); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/LongFixnumLiteralNode.java b/src/main/java/org/truffleruby/language/literal/LongFixnumLiteralNode.java index 71b0bdc4e49f..42554690fd7d 100644 --- a/src/main/java/org/truffleruby/language/literal/LongFixnumLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/LongFixnumLiteralNode.java @@ -33,8 +33,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new LongFixnumLiteralNode(value); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/NilLiteralNode.java b/src/main/java/org/truffleruby/language/literal/NilLiteralNode.java index 06163b7ddf14..ab34121b945c 100644 --- a/src/main/java/org/truffleruby/language/literal/NilLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/NilLiteralNode.java @@ -45,8 +45,7 @@ public boolean isImplicit() { @Override public RubyNode cloneUninitialized() { var copy = new NilLiteralNode(isImplicit); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/ObjectClassLiteralNode.java b/src/main/java/org/truffleruby/language/literal/ObjectClassLiteralNode.java index 00d00d911bd9..7dcd5abda06e 100644 --- a/src/main/java/org/truffleruby/language/literal/ObjectClassLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/ObjectClassLiteralNode.java @@ -23,8 +23,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new ObjectClassLiteralNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/ObjectLiteralNode.java b/src/main/java/org/truffleruby/language/literal/ObjectLiteralNode.java index 18bddf6fb371..311c8f72eda0 100644 --- a/src/main/java/org/truffleruby/language/literal/ObjectLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/ObjectLiteralNode.java @@ -37,7 +37,6 @@ public Object getObject() { @Override public RubyNode cloneUninitialized() { var copy = new ObjectLiteralNode(object); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java b/src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java index 8183ceb9623d..40c9fe5e0092 100644 --- a/src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java @@ -23,8 +23,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new RangeClassLiteralNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/StringLiteralNode.java b/src/main/java/org/truffleruby/language/literal/StringLiteralNode.java index 5e5452917e9f..879bb6372d1d 100644 --- a/src/main/java/org/truffleruby/language/literal/StringLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/StringLiteralNode.java @@ -35,8 +35,7 @@ public RubyString execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new StringLiteralNode(tstring, encoding); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/TruffleInternalModuleLiteralNode.java b/src/main/java/org/truffleruby/language/literal/TruffleInternalModuleLiteralNode.java index 69b8311c83ee..2b88cdf28a8c 100644 --- a/src/main/java/org/truffleruby/language/literal/TruffleInternalModuleLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/TruffleInternalModuleLiteralNode.java @@ -23,8 +23,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new TruffleInternalModuleLiteralNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/literal/TruffleKernelOperationsModuleLiteralNode.java b/src/main/java/org/truffleruby/language/literal/TruffleKernelOperationsModuleLiteralNode.java index f26940aae4fe..d3b3b7ff61ce 100644 --- a/src/main/java/org/truffleruby/language/literal/TruffleKernelOperationsModuleLiteralNode.java +++ b/src/main/java/org/truffleruby/language/literal/TruffleKernelOperationsModuleLiteralNode.java @@ -23,8 +23,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new TruffleKernelOperationsModuleLiteralNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/locals/FlipFlopNode.java b/src/main/java/org/truffleruby/language/locals/FlipFlopNode.java index 37df4427729b..8ce782e64505 100644 --- a/src/main/java/org/truffleruby/language/locals/FlipFlopNode.java +++ b/src/main/java/org/truffleruby/language/locals/FlipFlopNode.java @@ -74,8 +74,7 @@ public RubyNode cloneUninitialized() { end.getValueNode().cloneUninitialized(), stateNode, exclusive); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/locals/InitFlipFlopSlotNode.java b/src/main/java/org/truffleruby/language/locals/InitFlipFlopSlotNode.java index 5a5d6003b410..4a547f8b4c06 100644 --- a/src/main/java/org/truffleruby/language/locals/InitFlipFlopSlotNode.java +++ b/src/main/java/org/truffleruby/language/locals/InitFlipFlopSlotNode.java @@ -36,8 +36,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new InitFlipFlopSlotNode(frameSlot); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/locals/ReadDeclarationVariableNode.java b/src/main/java/org/truffleruby/language/locals/ReadDeclarationVariableNode.java index 19e5d8f610f3..c5d31e96ca0b 100644 --- a/src/main/java/org/truffleruby/language/locals/ReadDeclarationVariableNode.java +++ b/src/main/java/org/truffleruby/language/locals/ReadDeclarationVariableNode.java @@ -65,8 +65,7 @@ protected String getVariableName() { @Override public RubyNode cloneUninitialized() { var copy = new ReadDeclarationVariableNode(type, frameDepth, frameSlot); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/locals/ReadLocalVariableNode.java b/src/main/java/org/truffleruby/language/locals/ReadLocalVariableNode.java index e8a98704a99a..4a43f24cdf25 100644 --- a/src/main/java/org/truffleruby/language/locals/ReadLocalVariableNode.java +++ b/src/main/java/org/truffleruby/language/locals/ReadLocalVariableNode.java @@ -48,8 +48,7 @@ protected String getVariableName() { @Override public RubyNode cloneUninitialized() { var copy = new ReadLocalVariableNode(type, frameSlot); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java b/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java index 02a20466ad6b..6319fc15237f 100644 --- a/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java +++ b/src/main/java/org/truffleruby/language/locals/WriteDeclarationVariableNode.java @@ -72,8 +72,7 @@ public RubyNode cloneUninitialized() { frameSlot, frameDepth, cloneUninitialized(valueNode)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java b/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java index 56624f91ec27..767601cc5310 100644 --- a/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java +++ b/src/main/java/org/truffleruby/language/locals/WriteLocalVariableNode.java @@ -67,8 +67,7 @@ public RubyNode cloneUninitialized() { var copy = new WriteLocalVariableNode( frameSlot, valueNode.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java b/src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java index 72218578980d..e8bab5fcb7ce 100644 --- a/src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java +++ b/src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java @@ -91,8 +91,7 @@ private DeclarationContext executeWithoutVisibility(DeclarationContext ctxIn) { @Override public RubyNode cloneUninitialized() { var copy = new BlockDefinitionNode(type, sharedMethodInfo, callTargets, breakID, frameOnStackMarkerSlot); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/methods/CatchBreakNode.java b/src/main/java/org/truffleruby/language/methods/CatchBreakNode.java index ad149c9063fc..299a4302548b 100644 --- a/src/main/java/org/truffleruby/language/methods/CatchBreakNode.java +++ b/src/main/java/org/truffleruby/language/methods/CatchBreakNode.java @@ -56,8 +56,7 @@ public RubyNode cloneUninitialized() { breakID, body.cloneUninitialized(), isWhile); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/methods/GetDefaultDefineeNode.java b/src/main/java/org/truffleruby/language/methods/GetDefaultDefineeNode.java index 6ad224979186..1b4b9cd4c03b 100644 --- a/src/main/java/org/truffleruby/language/methods/GetDefaultDefineeNode.java +++ b/src/main/java/org/truffleruby/language/methods/GetDefaultDefineeNode.java @@ -25,8 +25,7 @@ public RubyModule execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new GetDefaultDefineeNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/methods/GetMethodObjectNode.java b/src/main/java/org/truffleruby/language/methods/GetMethodObjectNode.java index 3c12d1472285..76e8cdb9d152 100644 --- a/src/main/java/org/truffleruby/language/methods/GetMethodObjectNode.java +++ b/src/main/java/org/truffleruby/language/methods/GetMethodObjectNode.java @@ -144,8 +144,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new CallMethodMissingWithStaticName(methodName); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/methods/LiteralMethodDefinitionNode.java b/src/main/java/org/truffleruby/language/methods/LiteralMethodDefinitionNode.java index 359ab5d872ff..b67b2508a3ed 100644 --- a/src/main/java/org/truffleruby/language/methods/LiteralMethodDefinitionNode.java +++ b/src/main/java/org/truffleruby/language/methods/LiteralMethodDefinitionNode.java @@ -108,8 +108,7 @@ public RubyNode cloneUninitialized() { sharedMethodInfo, isDefSingleton, callTargetSupplier); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/methods/SymbolProcNode.java b/src/main/java/org/truffleruby/language/methods/SymbolProcNode.java index 2c40507ac5f6..4a169f9ffe57 100644 --- a/src/main/java/org/truffleruby/language/methods/SymbolProcNode.java +++ b/src/main/java/org/truffleruby/language/methods/SymbolProcNode.java @@ -51,8 +51,7 @@ private DispatchNode getCallNode() { @Override public RubyNode cloneUninitialized() { var copy = new SymbolProcNode(symbol); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/DefineClassNode.java b/src/main/java/org/truffleruby/language/objects/DefineClassNode.java index 83b32b48a125..76c272742218 100644 --- a/src/main/java/org/truffleruby/language/objects/DefineClassNode.java +++ b/src/main/java/org/truffleruby/language/objects/DefineClassNode.java @@ -140,8 +140,7 @@ public RubyNode cloneUninitialized() { name, lexicalParentModule.cloneUninitialized(), superClassNode.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/DefineModuleNode.java b/src/main/java/org/truffleruby/language/objects/DefineModuleNode.java index fcd856202828..2ccb3e38398b 100644 --- a/src/main/java/org/truffleruby/language/objects/DefineModuleNode.java +++ b/src/main/java/org/truffleruby/language/objects/DefineModuleNode.java @@ -83,7 +83,6 @@ public RubyNode cloneUninitialized() { var copy = DefineModuleNodeGen.create( name, getLexicalParentModuleNode().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/DynamicLexicalScopeNode.java b/src/main/java/org/truffleruby/language/objects/DynamicLexicalScopeNode.java index e0dcbea30fd5..76798d04e5fd 100644 --- a/src/main/java/org/truffleruby/language/objects/DynamicLexicalScopeNode.java +++ b/src/main/java/org/truffleruby/language/objects/DynamicLexicalScopeNode.java @@ -25,8 +25,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new DynamicLexicalScopeNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/GetDynamicLexicalScopeNode.java b/src/main/java/org/truffleruby/language/objects/GetDynamicLexicalScopeNode.java index 2e38946876fa..17227d978825 100644 --- a/src/main/java/org/truffleruby/language/objects/GetDynamicLexicalScopeNode.java +++ b/src/main/java/org/truffleruby/language/objects/GetDynamicLexicalScopeNode.java @@ -25,8 +25,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new GetDynamicLexicalScopeNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/InsideModuleDefinitionNode.java b/src/main/java/org/truffleruby/language/objects/InsideModuleDefinitionNode.java index 8e4cd97aec43..bcd91de5257d 100644 --- a/src/main/java/org/truffleruby/language/objects/InsideModuleDefinitionNode.java +++ b/src/main/java/org/truffleruby/language/objects/InsideModuleDefinitionNode.java @@ -40,8 +40,7 @@ public boolean hasTag(Class tag) { @Override public RubyNode cloneUninitialized() { var copy = new InsideModuleDefinitionNode(body.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/LexicalScopeNode.java b/src/main/java/org/truffleruby/language/objects/LexicalScopeNode.java index 29082b5cf3cf..3b237bbbdd31 100644 --- a/src/main/java/org/truffleruby/language/objects/LexicalScopeNode.java +++ b/src/main/java/org/truffleruby/language/objects/LexicalScopeNode.java @@ -31,8 +31,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new LexicalScopeNode(lexicalScope); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/ReadInstanceVariableNode.java b/src/main/java/org/truffleruby/language/objects/ReadInstanceVariableNode.java index f62394caf22a..f50a87e5a11c 100644 --- a/src/main/java/org/truffleruby/language/objects/ReadInstanceVariableNode.java +++ b/src/main/java/org/truffleruby/language/objects/ReadInstanceVariableNode.java @@ -81,8 +81,7 @@ public RubyNode cloneUninitialized() { var copy = new ReadInstanceVariableNode( name, receiver.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java b/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java index 1b05bd2798e7..cfed24d3156b 100644 --- a/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java +++ b/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java @@ -53,8 +53,7 @@ public RubyNode cloneUninitialized() { var copy = new RunModuleDefinitionNode( definitionMethod, definingModule.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/SelfNode.java b/src/main/java/org/truffleruby/language/objects/SelfNode.java index 23ce51acab4c..1128589a28c3 100644 --- a/src/main/java/org/truffleruby/language/objects/SelfNode.java +++ b/src/main/java/org/truffleruby/language/objects/SelfNode.java @@ -51,8 +51,7 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c @Override public RubyNode cloneUninitialized() { var copy = new SelfNode(); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java b/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java index 0d15dfde27e1..ae29e564f7aa 100644 --- a/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java +++ b/src/main/java/org/truffleruby/language/objects/WriteInstanceVariableNode.java @@ -101,8 +101,7 @@ public RubyNode cloneUninitialized() { name, receiver.cloneUninitialized(), cloneUninitialized(rhs)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/classvariables/ReadClassVariableNode.java b/src/main/java/org/truffleruby/language/objects/classvariables/ReadClassVariableNode.java index dbbab3b58cb5..91c60088559c 100644 --- a/src/main/java/org/truffleruby/language/objects/classvariables/ReadClassVariableNode.java +++ b/src/main/java/org/truffleruby/language/objects/classvariables/ReadClassVariableNode.java @@ -76,8 +76,7 @@ public RubyNode cloneUninitialized() { var copy = new ReadClassVariableNode( lexicalScopeNode.cloneUninitialized(), name); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java b/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java index 7f7c43589b20..050ddd8f31a6 100644 --- a/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java +++ b/src/main/java/org/truffleruby/language/objects/classvariables/WriteClassVariableNode.java @@ -80,8 +80,7 @@ public RubyNode cloneUninitialized() { lexicalScopeNode.cloneUninitialized(), name, rhs.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/supercall/ReadSuperArgumentsNode.java b/src/main/java/org/truffleruby/language/supercall/ReadSuperArgumentsNode.java index 6888fc962076..a90b0e2edc1d 100644 --- a/src/main/java/org/truffleruby/language/supercall/ReadSuperArgumentsNode.java +++ b/src/main/java/org/truffleruby/language/supercall/ReadSuperArgumentsNode.java @@ -64,8 +64,7 @@ public RubyNode cloneUninitialized() { var copy = new ReadSuperArgumentsNode( cloneUninitialized(arguments), isSplatted); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/supercall/ReadZSuperArgumentsNode.java b/src/main/java/org/truffleruby/language/supercall/ReadZSuperArgumentsNode.java index 00f3b49ab89f..8e4b8f3db742 100644 --- a/src/main/java/org/truffleruby/language/supercall/ReadZSuperArgumentsNode.java +++ b/src/main/java/org/truffleruby/language/supercall/ReadZSuperArgumentsNode.java @@ -82,8 +82,7 @@ public RubyNode cloneUninitialized() { var copy = new ReadZSuperArgumentsNode( restArgIndex, cloneUninitialized(reloadNodes)); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/supercall/SuperCallNode.java b/src/main/java/org/truffleruby/language/supercall/SuperCallNode.java index 1e500ece38bb..54a1ad296811 100644 --- a/src/main/java/org/truffleruby/language/supercall/SuperCallNode.java +++ b/src/main/java/org/truffleruby/language/supercall/SuperCallNode.java @@ -101,8 +101,7 @@ public RubyNode cloneUninitialized() { arguments.cloneUninitialized(), block.cloneUninitialized(), descriptor); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/supercall/ZSuperOutsideMethodNode.java b/src/main/java/org/truffleruby/language/supercall/ZSuperOutsideMethodNode.java index 4cc060f2618a..2ef141c7099c 100644 --- a/src/main/java/org/truffleruby/language/supercall/ZSuperOutsideMethodNode.java +++ b/src/main/java/org/truffleruby/language/supercall/ZSuperOutsideMethodNode.java @@ -58,8 +58,7 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c @Override public RubyNode cloneUninitialized() { var copy = new ZSuperOutsideMethodNode(insideDefineMethod); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/yield/YieldExpressionNode.java b/src/main/java/org/truffleruby/language/yield/YieldExpressionNode.java index a0942ca5a72a..2539352efb38 100644 --- a/src/main/java/org/truffleruby/language/yield/YieldExpressionNode.java +++ b/src/main/java/org/truffleruby/language/yield/YieldExpressionNode.java @@ -113,8 +113,7 @@ public RubyNode cloneUninitialized() { descriptor, cloneUninitialized(arguments), readBlockNode.cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/parser/DeadNode.java b/src/main/java/org/truffleruby/parser/DeadNode.java index c3f8d0a2e732..8d399d6ca511 100644 --- a/src/main/java/org/truffleruby/parser/DeadNode.java +++ b/src/main/java/org/truffleruby/parser/DeadNode.java @@ -38,8 +38,7 @@ private RuntimeException exception() { @Override public RubyNode cloneUninitialized() { var copy = new DeadNode(reason); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java b/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java index 7d49d12daf8c..eb9d1e6564ce 100644 --- a/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java +++ b/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java @@ -265,8 +265,7 @@ public RubyNode cloneUninitialized() { var copy = create( getIndexNodeBeforeCasting().cloneUninitialized(), getLineNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java b/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java index fdcf0561c83e..c3e227034b82 100644 --- a/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java +++ b/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java @@ -105,8 +105,7 @@ private RubyBaseNodeWithExecute getCharactersNodeBeforeCasting() { public RubyNode cloneUninitialized() { var copy = create( getCharactersNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -215,8 +214,7 @@ public RubyNode cloneUninitialized() { var copy = create( getPromptNodeBeforeCasting().cloneUninitialized(), getAddToHistoryNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } @@ -266,8 +264,7 @@ public RubyNode cloneUninitialized() { var copy = create( getSelfNode().cloneUninitialized(), getTextNodeBeforeCasting().cloneUninitialized()); - copy.copyFlags(this); - return copy; + return copy.copyFlags(this); } } From 8c2d02c78cccb9f4b9f93defd5baa12412190cdf Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Fri, 30 Sep 2022 16:14:03 +0300 Subject: [PATCH 19/46] Refactoring: remove parameter that is not used --- .../core/inlined/CoreMethodAssumptions.java | 3 +-- .../org/truffleruby/parser/BodyTranslator.java | 16 ++++++++-------- 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/src/main/java/org/truffleruby/core/inlined/CoreMethodAssumptions.java b/src/main/java/org/truffleruby/core/inlined/CoreMethodAssumptions.java index 7ffde90e1802..14903f15ba70 100644 --- a/src/main/java/org/truffleruby/core/inlined/CoreMethodAssumptions.java +++ b/src/main/java/org/truffleruby/core/inlined/CoreMethodAssumptions.java @@ -23,7 +23,6 @@ import org.truffleruby.language.dispatch.RubyCallNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import org.truffleruby.language.methods.BlockDefinitionNode; -import org.truffleruby.parser.TranslatorEnvironment; /** We inline basic operations directly in the AST (instead of a method call) as it makes little sense to compile them * in isolation without the surrounding method and it delays more interesting compilations by filling the compilation @@ -149,7 +148,7 @@ public void registerAssumptions(CoreLibrary coreLibrary) { } } - public RubyNode createCallNode(RubyCallNodeParameters callParameters, TranslatorEnvironment environment) { + public RubyNode createCallNode(RubyCallNodeParameters callParameters) { if (!language.options.BASICOPS_INLINE || callParameters.isSplatted() || callParameters.isSafeNavigation()) { return new RubyCallNode(callParameters); } diff --git a/src/main/java/org/truffleruby/parser/BodyTranslator.java b/src/main/java/org/truffleruby/parser/BodyTranslator.java index d31e608bcb56..daabe2e08b9e 100644 --- a/src/main/java/org/truffleruby/parser/BodyTranslator.java +++ b/src/main/java/org/truffleruby/parser/BodyTranslator.java @@ -611,7 +611,7 @@ private RubyNode translateCallNode(CallParseNode node, boolean ignoreVisibility, isAttrAssign); RubyNode translated = Translator.withSourceSection( enclosingSourceSection, - language.coreMethodAssumptions.createCallNode(callParameters, environment)); + language.coreMethodAssumptions.createCallNode(callParameters)); translated = wrapCallWithLiteralBlock(argumentsAndBlock, translated); @@ -806,7 +806,7 @@ public RubyNode visitCaseNode(CaseParseNode node) { false, true); final RubyNode conditionNode = language.coreMethodAssumptions - .createCallNode(callParameters, environment); + .createCallNode(callParameters); // Create the if node final RubyNode thenNode = translateNodeOrNil(sourceSection, when.getBodyNode()); @@ -947,7 +947,7 @@ private RubyNode caseInPatternMatch(ParseNode patternNode, ParseNode expressionN false, true); deconstructed = language.coreMethodAssumptions - .createCallNode(deconstructCallParameters, environment); + .createCallNode(deconstructCallParameters); receiver = new TruffleInternalModuleLiteralNode(); receiver.unsafeSetSourceSection(sourceSection); @@ -961,7 +961,7 @@ private RubyNode caseInPatternMatch(ParseNode patternNode, ParseNode expressionN false, true); return language.coreMethodAssumptions - .createCallNode(matcherCallParameters, environment); + .createCallNode(matcherCallParameters); case HASHNODE: deconstructCallParameters = new RubyCallNodeParameters( expressionValue, @@ -972,7 +972,7 @@ private RubyNode caseInPatternMatch(ParseNode patternNode, ParseNode expressionN false, true); deconstructed = language.coreMethodAssumptions - .createCallNode(deconstructCallParameters, environment); + .createCallNode(deconstructCallParameters); receiver = new TruffleInternalModuleLiteralNode(); receiver.unsafeSetSourceSection(sourceSection); @@ -986,7 +986,7 @@ private RubyNode caseInPatternMatch(ParseNode patternNode, ParseNode expressionN false, true); return language.coreMethodAssumptions - .createCallNode(matcherCallParameters, environment); + .createCallNode(matcherCallParameters); case LOCALVARNODE: // Assigns the value of an existing variable pattern as the value of the expression. // May need to add a case with same/similar logic for new variables. @@ -1006,7 +1006,7 @@ private RubyNode caseInPatternMatch(ParseNode patternNode, ParseNode expressionN false, true); return language.coreMethodAssumptions - .createCallNode(matcherCallParameters, environment); + .createCallNode(matcherCallParameters); } } @@ -2366,7 +2366,7 @@ public RubyNode visitOpAsgnConstDeclNode(OpAsgnConstDeclParseNode node) { new RubyNode[]{ rhs }, false, true); - final RubyNode opNode = language.coreMethodAssumptions.createCallNode(callParameters, environment); + final RubyNode opNode = language.coreMethodAssumptions.createCallNode(callParameters); final RubyNode ret = lhs.makeWriteNode(opNode); ret.unsafeSetSourceSection(sourceSection); return addNewlineIfNeeded(node, ret); From 67e5ba7190e1cc91e3e1d8705633af1fd867753c Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Fri, 30 Sep 2022 20:41:58 +0300 Subject: [PATCH 20/46] Add cloned AST correctness check --- .../core/array/ArrayLiteralNode.java | 59 +++------------ .../language/RubyCoreMethodRootNode.java | 10 ++- .../language/RubyEvalRootNode.java | 10 ++- .../language/RubyLambdaRootNode.java | 10 ++- .../language/RubyMethodRootNode.java | 10 ++- .../language/RubyProcRootNode.java | 12 ++- .../truffleruby/language/RubyRootNode.java | 75 +++++++++++++++++++ .../language/RubyTopLevelRootNode.java | 10 ++- .../language/dispatch/RubyCallNode.java | 14 ++-- .../java/org/truffleruby/options/Options.java | 5 ++ src/options.yml | 1 + .../shared/options/OptionsCatalog.java | 12 +++ 12 files changed, 167 insertions(+), 61 deletions(-) diff --git a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java index 83da4d2dfce3..7cf1a6a58139 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java @@ -59,6 +59,16 @@ protected RubyArray cachedCreateArray(Object store, int size) { return array; } + // Do not override #cloneUninitialized() in subclasses. + // In runtime any literal array node may be replaced with UninitializedArrayLiteralNode. + @Override + public RubyNode cloneUninitialized() { + var copy = new UninitialisedArrayLiteralNode( + language, + cloneUninitialized(values)); + return copy.copyFlags(this); + } + @Override public abstract RubyArray execute(VirtualFrame frame); @@ -97,14 +107,6 @@ public RubyArray execute(VirtualFrame frame) { return cachedCreateArray(ArrayStoreLibrary.initialStorage(false), 0); } - @Override - public RubyNode cloneUninitialized() { - var copy = new EmptyArrayLiteralNode( - language, - cloneUninitialized(values)); - return copy.copyFlags(this); - } - } private static class FloatArrayLiteralNode extends ArrayLiteralNode { @@ -142,14 +144,6 @@ private RubyArray makeGeneric(VirtualFrame frame, final double[] executedValues, return makeGeneric(frame, executedObjects); } - @Override - public RubyNode cloneUninitialized() { - var copy = new FloatArrayLiteralNode( - language, - cloneUninitialized(values)); - return copy.copyFlags(this); - } - } private static class IntegerArrayLiteralNode extends ArrayLiteralNode { @@ -187,14 +181,6 @@ private RubyArray makeGeneric(VirtualFrame frame, final int[] executedValues, in return makeGeneric(frame, executedObjects); } - @Override - public RubyNode cloneUninitialized() { - var copy = new IntegerArrayLiteralNode( - language, - cloneUninitialized(values)); - return copy.copyFlags(this); - } - } private static class LongArrayLiteralNode extends ArrayLiteralNode { @@ -232,14 +218,6 @@ private RubyArray makeGeneric(VirtualFrame frame, final long[] executedValues, i return makeGeneric(frame, executedObjects); } - @Override - public RubyNode cloneUninitialized() { - var copy = new LongArrayLiteralNode( - language, - cloneUninitialized(values)); - return copy.copyFlags(this); - } - } private static class ObjectArrayLiteralNode extends ArrayLiteralNode { @@ -260,14 +238,6 @@ public RubyArray execute(VirtualFrame frame) { return cachedCreateArray(executedValues, values.length); } - @Override - public RubyNode cloneUninitialized() { - var copy = new ObjectArrayLiteralNode( - language, - cloneUninitialized(values)); - return copy.copyFlags(this); - } - } private static class UninitialisedArrayLiteralNode extends ArrayLiteralNode { @@ -379,13 +349,6 @@ public Object storeSpecialisedFromObjects(Object... objects) { } } - @Override - public RubyNode cloneUninitialized() { - var copy = new UninitialisedArrayLiteralNode( - language, - cloneUninitialized(values)); - return copy.copyFlags(this); - } - } + } diff --git a/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java b/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java index 8ea3a9a84442..99fffaa83f2e 100644 --- a/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java @@ -22,6 +22,7 @@ import com.oracle.truffle.api.frame.FrameDescriptor; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; +import org.truffleruby.options.Options; public class RubyCoreMethodRootNode extends RubyCheckArityRootNode { @@ -58,7 +59,7 @@ public Object execute(VirtualFrame frame) { @Override protected RootNode cloneUninitialized() { - return new RubyCoreMethodRootNode( + var clone = new RubyCoreMethodRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -67,6 +68,13 @@ protected RootNode cloneUninitialized() { getSplit(), returnID, arityForCheck); + + Options options = getContext().getOptions(); + if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + ensureCloneUninitializedCorrectness(clone); + } + + return clone; } } diff --git a/src/main/java/org/truffleruby/language/RubyEvalRootNode.java b/src/main/java/org/truffleruby/language/RubyEvalRootNode.java index 60985b2311e3..db41f7a282fd 100644 --- a/src/main/java/org/truffleruby/language/RubyEvalRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyEvalRootNode.java @@ -27,6 +27,7 @@ import com.oracle.truffle.api.frame.FrameDescriptor; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; +import org.truffleruby.options.Options; /** A RootNode for an eval. Similar to a block (and not a method) once parsed since it can access the surrounding * variables and it is as well in another CallTarget. */ @@ -85,7 +86,7 @@ public Object execute(VirtualFrame frame) { @Override protected RootNode cloneUninitialized() { - return new RubyEvalRootNode( + var clone = new RubyEvalRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -93,5 +94,12 @@ protected RootNode cloneUninitialized() { body.cloneUninitialized(), getSplit(), returnID); + + Options options = getContext().getOptions(); + if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + ensureCloneUninitializedCorrectness(clone); + } + + return clone; } } diff --git a/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java b/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java index 787dd4b54662..2ad0099c0a4e 100644 --- a/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java @@ -32,6 +32,7 @@ import com.oracle.truffle.api.frame.FrameDescriptor; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; +import org.truffleruby.options.Options; public class RubyLambdaRootNode extends RubyCheckArityRootNode { @@ -153,7 +154,7 @@ public Object execute(VirtualFrame frame) { @Override protected RootNode cloneUninitialized() { - return new RubyLambdaRootNode( + var clone = new RubyLambdaRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -163,6 +164,13 @@ protected RootNode cloneUninitialized() { returnID, breakID, arityForCheck); + + Options options = getContext().getOptions(); + if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + ensureCloneUninitializedCorrectness(clone); + } + + return clone; } } diff --git a/src/main/java/org/truffleruby/language/RubyMethodRootNode.java b/src/main/java/org/truffleruby/language/RubyMethodRootNode.java index 911a82acb0d6..3e8e619536b9 100644 --- a/src/main/java/org/truffleruby/language/RubyMethodRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyMethodRootNode.java @@ -29,6 +29,7 @@ import com.oracle.truffle.api.source.SourceSection; import org.truffleruby.language.methods.TranslateExceptionNode; import org.truffleruby.language.threadlocal.SpecialVariableStorage; +import org.truffleruby.options.Options; public class RubyMethodRootNode extends RubyCheckArityRootNode { @@ -103,7 +104,7 @@ public Object execute(VirtualFrame frame) { @Override protected RootNode cloneUninitialized() { - return new RubyMethodRootNode( + var clone = new RubyMethodRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -112,6 +113,13 @@ protected RootNode cloneUninitialized() { getSplit(), returnID, arityForCheck); + + Options options = getContext().getOptions(); + if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + ensureCloneUninitializedCorrectness(clone); + } + + return clone; } } diff --git a/src/main/java/org/truffleruby/language/RubyProcRootNode.java b/src/main/java/org/truffleruby/language/RubyProcRootNode.java index e13e821b8a5e..d4010b2880fd 100644 --- a/src/main/java/org/truffleruby/language/RubyProcRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyProcRootNode.java @@ -28,6 +28,7 @@ import com.oracle.truffle.api.frame.FrameDescriptor; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; +import org.truffleruby.options.Options; public class RubyProcRootNode extends RubyRootNode { @@ -111,11 +112,11 @@ public Object execute(VirtualFrame frame) { @Override protected RootNode cloneUninitialized() { - // CheckKeywordArityNode uses branch profiling, so it should be copied without gathered data + // CheckKeywordArityNode uses branch profiling, so it should be copied without profiling data var checkKeywordArityNodeCopy = (checkKeywordArityNode == null) ? null : checkKeywordArityNode.cloneUninitialized(); - return new RubyProcRootNode( + var clone = new RubyProcRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -124,5 +125,12 @@ protected RootNode cloneUninitialized() { getSplit(), returnID, checkKeywordArityNodeCopy); + + Options options = getContext().getOptions(); + if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + ensureCloneUninitializedCorrectness(clone); + } + + return clone; } } diff --git a/src/main/java/org/truffleruby/language/RubyRootNode.java b/src/main/java/org/truffleruby/language/RubyRootNode.java index 0e45b376f815..d10a5c1076f2 100644 --- a/src/main/java/org/truffleruby/language/RubyRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyRootNode.java @@ -12,6 +12,8 @@ import com.oracle.truffle.api.CompilerDirectives; import com.oracle.truffle.api.RootCallTarget; import com.oracle.truffle.api.dsl.NodeFactory; +import com.oracle.truffle.api.instrumentation.InstrumentableNode.WrapperNode; +import com.oracle.truffle.api.nodes.Node; import com.oracle.truffle.api.nodes.NodeUtil; import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; @@ -23,8 +25,12 @@ import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; import org.truffleruby.language.methods.Split; +import org.truffleruby.options.Options; import org.truffleruby.parser.ParentFrameDescriptor; +import java.util.ArrayList; +import java.util.List; + public class RubyRootNode extends RubyBaseRootNode { public static RubyRootNode of(RootCallTarget callTarget) { @@ -36,6 +42,7 @@ public static RubyRootNode of(RootCallTarget callTarget) { public final ReturnID returnID; @Child protected RubyNode body; + @Child protected RubyNode bodyCopy; public RubyRootNode( RubyLanguage language, @@ -61,6 +68,11 @@ public RubyRootNode( body.unsafeSetIsCall(); body.unsafeSetIsRoot(); + + Options options = getContext().getOptions(); + if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + this.bodyCopy = copyBody(); + } } @Override @@ -132,4 +144,67 @@ protected RootNode cloneUninitialized() { return new RubyRootNode(getLanguage(), getSourceSection(), getFrameDescriptor(), sharedMethodInfo, body.cloneUninitialized(), split, returnID); } + + protected void ensureCloneUninitializedCorrectness(RubyRootNode clone) { + if (!isClonedCorrectly(bodyCopy, clone.bodyCopy)) { + System.err.println(); + System.err.println("Original copy of body (bodyCopy) AST:"); + NodeUtil.printCompactTree(System.err, bodyCopy); + + System.err.println("Cloned body (clone.bodyCopy) AST:"); + NodeUtil.printCompactTree(System.err, clone.bodyCopy); + + throw new Error("#cloneUninitialized for RubyRootNode " + getName() + " created not identical AST"); + } + } + + private boolean isClonedCorrectly(Node original, Node clone) { + // A clone should be a new instance + if (original == clone) { + return false; + } + + // Ignore instrumental wrappers (e.g. RubyNodeWrapper) + if (WrapperNode.class.isInstance(original)) { + return isClonedCorrectly(((WrapperNode) original).getDelegateNode(), clone); + } + + // Should be instances of the same class + if (original.getClass() != clone.getClass()) { + return false; + } + + Node[] originalChildren = childrenToArray(original); + Node[] cloneChildren = childrenToArray(clone); + + // Should have the same number of children + if (cloneChildren.length != originalChildren.length) { + return false; + } + + // Should have the same children + for (int i = 0; i < cloneChildren.length; i++) { + if (!isClonedCorrectly(originalChildren[i], cloneChildren[i])) { + return false; + } + } + + return true; + } + + private Node[] childrenToArray(Node node) { + final List childrenList = new ArrayList<>(); + for (Node child : node.getChildren()) { + childrenList.add(child); + } + + final Object[] arrayOfObjects = childrenList.toArray(); + final Node[] array = new Node[arrayOfObjects.length]; + + for (int i = 0; i < array.length; i++) { + array[i] = (Node) arrayOfObjects[i]; + } + + return array; + } } diff --git a/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java b/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java index 51bf93017b58..22f390d39130 100644 --- a/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java @@ -22,6 +22,7 @@ import com.oracle.truffle.api.frame.FrameDescriptor; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; +import org.truffleruby.options.Options; public class RubyTopLevelRootNode extends RubyMethodRootNode { @@ -55,7 +56,7 @@ public Object execute(VirtualFrame frame) { @Override protected RootNode cloneUninitialized() { - return new RubyTopLevelRootNode( + var clone = new RubyTopLevelRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -64,6 +65,13 @@ protected RootNode cloneUninitialized() { getSplit(), returnID, arityForCheck); + + Options options = getContext().getOptions(); + if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + ensureCloneUninitializedCorrectness(clone); + } + + return clone; } } diff --git a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java index 86357e9f1f44..83b6ac7910b8 100644 --- a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java +++ b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java @@ -20,6 +20,7 @@ import org.truffleruby.core.string.FrozenStrings; import org.truffleruby.core.symbol.RubySymbol; import org.truffleruby.language.RubyBaseNode; +import org.truffleruby.language.RubyContextSourceNode; import org.truffleruby.language.RubyGuards; import org.truffleruby.language.RubyNode; import org.truffleruby.language.arguments.ArgumentsDescriptor; @@ -268,17 +269,18 @@ public Map getDebugProperties() { @Override public RubyNode cloneUninitialized() { - var copy = new RubyCallNode( - isSplatted, - descriptor, - methodName, + RubyCallNodeParameters parameters = new RubyCallNodeParameters( receiver.cloneUninitialized(), - cloneUninitialized(arguments), + methodName, cloneUninitialized(block), - dispatchConfig, + descriptor, + cloneUninitialized(arguments), + isSplatted, + dispatchConfig == PRIVATE, isVCall, isSafeNavigation, isAttrAssign); + var copy = (RubyContextSourceNode) getLanguage().coreMethodAssumptions.createCallNode(parameters); return copy.copyFlags(this); } diff --git a/src/main/java/org/truffleruby/options/Options.java b/src/main/java/org/truffleruby/options/Options.java index f03d03a96f5a..6e2b5b6f1537 100644 --- a/src/main/java/org/truffleruby/options/Options.java +++ b/src/main/java/org/truffleruby/options/Options.java @@ -194,6 +194,8 @@ public class Options { public final boolean METHODMISSING_ALWAYS_CLONE; /** --method-missing-always-inline=INLINE_DEFAULT */ public final boolean METHODMISSING_ALWAYS_INLINE; + /** --check-clone-uninitialized-correctness=false */ + public final boolean CHECK_CLONE_UNINITIALIZED_CORRECTNESS; /** --regexp-instrument-match=false */ public final boolean REGEXP_INSTRUMENT_MATCH; /** --regexp-instrument-match-detailed=false */ @@ -295,6 +297,7 @@ public Options(Env env, OptionValues options, LanguageOptions languageOptions) { YIELD_ALWAYS_INLINE = options.hasBeenSet(OptionsCatalog.YIELD_ALWAYS_INLINE_KEY) ? options.get(OptionsCatalog.YIELD_ALWAYS_INLINE_KEY) : INLINE_DEFAULT; METHODMISSING_ALWAYS_CLONE = options.hasBeenSet(OptionsCatalog.METHODMISSING_ALWAYS_CLONE_KEY) ? options.get(OptionsCatalog.METHODMISSING_ALWAYS_CLONE_KEY) : CLONE_DEFAULT; METHODMISSING_ALWAYS_INLINE = options.hasBeenSet(OptionsCatalog.METHODMISSING_ALWAYS_INLINE_KEY) ? options.get(OptionsCatalog.METHODMISSING_ALWAYS_INLINE_KEY) : INLINE_DEFAULT; + CHECK_CLONE_UNINITIALIZED_CORRECTNESS = options.get(OptionsCatalog.CHECK_CLONE_UNINITIALIZED_CORRECTNESS_KEY); REGEXP_INSTRUMENT_MATCH = options.get(OptionsCatalog.REGEXP_INSTRUMENT_MATCH_KEY); REGEXP_INSTRUMENT_MATCH_DETAILED = options.get(OptionsCatalog.REGEXP_INSTRUMENT_MATCH_DETAILED_KEY); REGEXP_INSTRUMENT_OUTPUT_FORMAT = options.get(OptionsCatalog.REGEXP_INSTRUMENT_OUTPUT_FORMAT_KEY); @@ -476,6 +479,8 @@ public Object fromDescriptor(OptionDescriptor descriptor) { return METHODMISSING_ALWAYS_CLONE; case "ruby.method-missing-always-inline": return METHODMISSING_ALWAYS_INLINE; + case "ruby.check-clone-uninitialized-correctness": + return CHECK_CLONE_UNINITIALIZED_CORRECTNESS; case "ruby.regexp-instrument-match": return REGEXP_INSTRUMENT_MATCH; case "ruby.regexp-instrument-match-detailed": diff --git a/src/options.yml b/src/options.yml index 0118d856fce4..b8bd678791bc 100644 --- a/src/options.yml +++ b/src/options.yml @@ -233,6 +233,7 @@ INTERNAL: # Options for debugging the TruffleRuby implementation YIELD_ALWAYS_INLINE: [yield-always-inline, boolean, INLINE_DEFAULT, Always inline yields] METHODMISSING_ALWAYS_CLONE: [method-missing-always-clone, boolean, CLONE_DEFAULT, 'Always clone #method_missing'] METHODMISSING_ALWAYS_INLINE: [method-missing-always-inline, boolean, INLINE_DEFAULT, 'Always inline #method_missing'] + CHECK_CLONE_UNINITIALIZED_CORRECTNESS: [check-clone-uninitialized-correctness, boolean, false, 'Check whether #cloneUninitialized correctly clones a root node AST'] # Instrumentation to debug performance REGEXP_INSTRUMENT_CREATION: [regexp-instrument-creation, boolean, false, Enable instrumentation to gather stats on regexp creation] diff --git a/src/shared/java/org/truffleruby/shared/options/OptionsCatalog.java b/src/shared/java/org/truffleruby/shared/options/OptionsCatalog.java index 713d21171698..5483c08fcc90 100644 --- a/src/shared/java/org/truffleruby/shared/options/OptionsCatalog.java +++ b/src/shared/java/org/truffleruby/shared/options/OptionsCatalog.java @@ -150,6 +150,7 @@ public class OptionsCatalog { public static final OptionKey YIELD_ALWAYS_INLINE_KEY = new OptionKey<>(INLINE_DEFAULT_KEY.getDefaultValue()); public static final OptionKey METHODMISSING_ALWAYS_CLONE_KEY = new OptionKey<>(CLONE_DEFAULT_KEY.getDefaultValue()); public static final OptionKey METHODMISSING_ALWAYS_INLINE_KEY = new OptionKey<>(INLINE_DEFAULT_KEY.getDefaultValue()); + public static final OptionKey CHECK_CLONE_UNINITIALIZED_CORRECTNESS_KEY = new OptionKey<>(false); public static final OptionKey REGEXP_INSTRUMENT_CREATION_KEY = new OptionKey<>(false); public static final OptionKey REGEXP_INSTRUMENT_MATCH_KEY = new OptionKey<>(false); public static final OptionKey REGEXP_INSTRUMENT_MATCH_DETAILED_KEY = new OptionKey<>(false); @@ -1204,6 +1205,14 @@ public class OptionsCatalog { .usageSyntax("") .build(); + public static final OptionDescriptor CHECK_CLONE_UNINITIALIZED_CORRECTNESS = OptionDescriptor + .newBuilder(CHECK_CLONE_UNINITIALIZED_CORRECTNESS_KEY, "ruby.check-clone-uninitialized-correctness") + .help("Check whether #cloneUninitialized correctly clones a root node AST") + .category(OptionCategory.INTERNAL) + .stability(OptionStability.EXPERIMENTAL) + .usageSyntax("") + .build(); + public static final OptionDescriptor REGEXP_INSTRUMENT_CREATION = OptionDescriptor .newBuilder(REGEXP_INSTRUMENT_CREATION_KEY, "ruby.regexp-instrument-creation") .help("Enable instrumentation to gather stats on regexp creation") @@ -1570,6 +1579,8 @@ public static OptionDescriptor fromName(String name) { return METHODMISSING_ALWAYS_CLONE; case "ruby.method-missing-always-inline": return METHODMISSING_ALWAYS_INLINE; + case "ruby.check-clone-uninitialized-correctness": + return CHECK_CLONE_UNINITIALIZED_CORRECTNESS; case "ruby.regexp-instrument-creation": return REGEXP_INSTRUMENT_CREATION; case "ruby.regexp-instrument-match": @@ -1733,6 +1744,7 @@ public static OptionDescriptor[] allDescriptors() { YIELD_ALWAYS_INLINE, METHODMISSING_ALWAYS_CLONE, METHODMISSING_ALWAYS_INLINE, + CHECK_CLONE_UNINITIALIZED_CORRECTNESS, REGEXP_INSTRUMENT_CREATION, REGEXP_INSTRUMENT_MATCH, REGEXP_INSTRUMENT_MATCH_DETAILED, From cdd2f2a3b3f83afd51aa09099f84069ede604eab Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Mon, 3 Oct 2022 16:28:45 +0300 Subject: [PATCH 21/46] Add integration test --- .../integration/clone-uninitialized-checks.sh | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 test/truffle/integration/clone-uninitialized-checks.sh diff --git a/test/truffle/integration/clone-uninitialized-checks.sh b/test/truffle/integration/clone-uninitialized-checks.sh new file mode 100644 index 000000000000..cf12d723fb9d --- /dev/null +++ b/test/truffle/integration/clone-uninitialized-checks.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash + +source test/truffle/common.sh.inc + +ruby_version=$(jt ruby -v) +if [[ $ruby_version =~ "GraalVM CE JVM" ]] || [[ $ruby_version =~ "GraalVM CE Native" ]]; then + echo "The checks are only meaningful when splitting is performed so GraalVM compiler is required." + exit 0 +fi + +export JT_SPECS_COMPILATION=false +jt test fast -- --check-clone-uninitialized-correctness From fcd2d3fe9d9d5e0abff16ab53a738e1d3ef38baf Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Mon, 3 Oct 2022 18:21:59 +0200 Subject: [PATCH 22/46] Cleanup with cloneUninitializedRootNode() --- .../language/RubyCoreMethodRootNode.java | 13 +---- .../language/RubyEvalRootNode.java | 13 +---- .../language/RubyLambdaRootNode.java | 13 +---- .../language/RubyMethodRootNode.java | 13 +---- .../language/RubyProcRootNode.java | 13 +---- .../truffleruby/language/RubyRootNode.java | 53 +++++++++++-------- .../language/RubyTopLevelRootNode.java | 13 +---- .../truffleruby/options/LanguageOptions.java | 13 +++++ .../java/org/truffleruby/options/Options.java | 5 -- src/options.yml | 1 + 10 files changed, 56 insertions(+), 94 deletions(-) diff --git a/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java b/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java index 99fffaa83f2e..ebb3bd232515 100644 --- a/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java @@ -10,7 +10,6 @@ package org.truffleruby.language; import com.oracle.truffle.api.TruffleSafepoint; -import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.control.ReturnID; import org.truffleruby.language.methods.Arity; @@ -22,7 +21,6 @@ import com.oracle.truffle.api.frame.FrameDescriptor; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; -import org.truffleruby.options.Options; public class RubyCoreMethodRootNode extends RubyCheckArityRootNode { @@ -58,8 +56,8 @@ public Object execute(VirtualFrame frame) { } @Override - protected RootNode cloneUninitialized() { - var clone = new RubyCoreMethodRootNode( + protected RubyRootNode cloneUninitializedRootNode() { + return new RubyCoreMethodRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -68,13 +66,6 @@ protected RootNode cloneUninitialized() { getSplit(), returnID, arityForCheck); - - Options options = getContext().getOptions(); - if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { - ensureCloneUninitializedCorrectness(clone); - } - - return clone; } } diff --git a/src/main/java/org/truffleruby/language/RubyEvalRootNode.java b/src/main/java/org/truffleruby/language/RubyEvalRootNode.java index db41f7a282fd..fdf55f296fe7 100644 --- a/src/main/java/org/truffleruby/language/RubyEvalRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyEvalRootNode.java @@ -9,7 +9,6 @@ */ package org.truffleruby.language; -import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.control.DynamicReturnException; import org.truffleruby.language.control.LocalReturnException; @@ -27,7 +26,6 @@ import com.oracle.truffle.api.frame.FrameDescriptor; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; -import org.truffleruby.options.Options; /** A RootNode for an eval. Similar to a block (and not a method) once parsed since it can access the surrounding * variables and it is as well in another CallTarget. */ @@ -85,8 +83,8 @@ public Object execute(VirtualFrame frame) { } @Override - protected RootNode cloneUninitialized() { - var clone = new RubyEvalRootNode( + protected RubyRootNode cloneUninitializedRootNode() { + return new RubyEvalRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -94,12 +92,5 @@ protected RootNode cloneUninitialized() { body.cloneUninitialized(), getSplit(), returnID); - - Options options = getContext().getOptions(); - if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { - ensureCloneUninitializedCorrectness(clone); - } - - return clone; } } diff --git a/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java b/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java index 2ad0099c0a4e..06137dff8373 100644 --- a/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyLambdaRootNode.java @@ -12,7 +12,6 @@ import com.oracle.truffle.api.CompilerDirectives.CompilationFinal; import com.oracle.truffle.api.RootCallTarget; import com.oracle.truffle.api.TruffleSafepoint; -import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.control.BreakException; import org.truffleruby.language.control.BreakID; @@ -32,7 +31,6 @@ import com.oracle.truffle.api.frame.FrameDescriptor; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; -import org.truffleruby.options.Options; public class RubyLambdaRootNode extends RubyCheckArityRootNode { @@ -153,8 +151,8 @@ public Object execute(VirtualFrame frame) { } @Override - protected RootNode cloneUninitialized() { - var clone = new RubyLambdaRootNode( + protected RubyRootNode cloneUninitializedRootNode() { + return new RubyLambdaRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -164,13 +162,6 @@ protected RootNode cloneUninitialized() { returnID, breakID, arityForCheck); - - Options options = getContext().getOptions(); - if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { - ensureCloneUninitializedCorrectness(clone); - } - - return clone; } } diff --git a/src/main/java/org/truffleruby/language/RubyMethodRootNode.java b/src/main/java/org/truffleruby/language/RubyMethodRootNode.java index 3e8e619536b9..02410f3ea06d 100644 --- a/src/main/java/org/truffleruby/language/RubyMethodRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyMethodRootNode.java @@ -13,7 +13,6 @@ import com.oracle.truffle.api.CompilerDirectives; import com.oracle.truffle.api.CompilerDirectives.CompilationFinal; import com.oracle.truffle.api.TruffleSafepoint; -import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.control.DynamicReturnException; import org.truffleruby.language.control.LocalReturnException; @@ -29,7 +28,6 @@ import com.oracle.truffle.api.source.SourceSection; import org.truffleruby.language.methods.TranslateExceptionNode; import org.truffleruby.language.threadlocal.SpecialVariableStorage; -import org.truffleruby.options.Options; public class RubyMethodRootNode extends RubyCheckArityRootNode { @@ -103,8 +101,8 @@ public Object execute(VirtualFrame frame) { } @Override - protected RootNode cloneUninitialized() { - var clone = new RubyMethodRootNode( + protected RubyRootNode cloneUninitializedRootNode() { + return new RubyMethodRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -113,13 +111,6 @@ protected RootNode cloneUninitialized() { getSplit(), returnID, arityForCheck); - - Options options = getContext().getOptions(); - if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { - ensureCloneUninitializedCorrectness(clone); - } - - return clone; } } diff --git a/src/main/java/org/truffleruby/language/RubyProcRootNode.java b/src/main/java/org/truffleruby/language/RubyProcRootNode.java index d4010b2880fd..a387a7c6a0bd 100644 --- a/src/main/java/org/truffleruby/language/RubyProcRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyProcRootNode.java @@ -11,7 +11,6 @@ import com.oracle.truffle.api.CompilerDirectives.CompilationFinal; import com.oracle.truffle.api.TruffleSafepoint; -import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.arguments.CheckKeywordArityNode; import org.truffleruby.language.control.NextException; @@ -28,7 +27,6 @@ import com.oracle.truffle.api.frame.FrameDescriptor; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; -import org.truffleruby.options.Options; public class RubyProcRootNode extends RubyRootNode { @@ -111,12 +109,12 @@ public Object execute(VirtualFrame frame) { } @Override - protected RootNode cloneUninitialized() { + protected RubyRootNode cloneUninitializedRootNode() { // CheckKeywordArityNode uses branch profiling, so it should be copied without profiling data var checkKeywordArityNodeCopy = (checkKeywordArityNode == null) ? null : checkKeywordArityNode.cloneUninitialized(); - var clone = new RubyProcRootNode( + return new RubyProcRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -125,12 +123,5 @@ protected RootNode cloneUninitialized() { getSplit(), returnID, checkKeywordArityNodeCopy); - - Options options = getContext().getOptions(); - if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { - ensureCloneUninitializedCorrectness(clone); - } - - return clone; } } diff --git a/src/main/java/org/truffleruby/language/RubyRootNode.java b/src/main/java/org/truffleruby/language/RubyRootNode.java index d10a5c1076f2..ea4ff71c4f47 100644 --- a/src/main/java/org/truffleruby/language/RubyRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyRootNode.java @@ -25,11 +25,9 @@ import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; import org.truffleruby.language.methods.Split; -import org.truffleruby.options.Options; import org.truffleruby.parser.ParentFrameDescriptor; import java.util.ArrayList; -import java.util.List; public class RubyRootNode extends RubyBaseRootNode { @@ -42,7 +40,7 @@ public static RubyRootNode of(RootCallTarget callTarget) { public final ReturnID returnID; @Child protected RubyNode body; - @Child protected RubyNode bodyCopy; + protected final RubyNode bodyCopy; public RubyRootNode( RubyLanguage language, @@ -69,9 +67,10 @@ public RubyRootNode( body.unsafeSetIsCall(); body.unsafeSetIsRoot(); - Options options = getContext().getOptions(); - if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + if (getLanguage().options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { this.bodyCopy = copyBody(); + } else { + this.bodyCopy = null; } } @@ -134,19 +133,32 @@ protected boolean isCloneUninitializedSupported() { return true; } + protected RubyRootNode cloneUninitializedRootNode() { + return new RubyRootNode(getLanguage(), getSourceSection(), getFrameDescriptor(), sharedMethodInfo, + body.cloneUninitialized(), split, returnID); + } + @Override - protected RootNode cloneUninitialized() { - if (getClass() != RubyRootNode.class) { - throw CompilerDirectives.shouldNotReachHere( - "TODO need to implement cloneUninitialized() on a subclass of RubyRootNode " + getClass()); + protected final RootNode cloneUninitialized() { + RubyRootNode clone = cloneUninitializedRootNode(); + + if (getLanguage().options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + ensureCloneUninitializedCorrectness(clone); } - return new RubyRootNode(getLanguage(), getSourceSection(), getFrameDescriptor(), sharedMethodInfo, - body.cloneUninitialized(), split, returnID); + return clone; } - protected void ensureCloneUninitializedCorrectness(RubyRootNode clone) { - if (!isClonedCorrectly(bodyCopy, clone.bodyCopy)) { + private void ensureCloneUninitializedCorrectness(RubyRootNode clone) { + if (this == clone) { + throw CompilerDirectives.shouldNotReachHere("clone same as this"); + } + if (this.getClass() != clone.getClass()) { + throw CompilerDirectives + .shouldNotReachHere("different clone class: " + this.getClass() + " vs " + clone.getClass()); + } + + if (!isClonedCorrectly(bodyCopy, clone.body)) { System.err.println(); System.err.println("Original copy of body (bodyCopy) AST:"); NodeUtil.printCompactTree(System.err, bodyCopy); @@ -165,7 +177,7 @@ private boolean isClonedCorrectly(Node original, Node clone) { } // Ignore instrumental wrappers (e.g. RubyNodeWrapper) - if (WrapperNode.class.isInstance(original)) { + if (original instanceof WrapperNode) { return isClonedCorrectly(((WrapperNode) original).getDelegateNode(), clone); } @@ -192,19 +204,14 @@ private boolean isClonedCorrectly(Node original, Node clone) { return true; } + private static final Node[] EMPTY_NODE_ARRAY = new Node[0]; + private Node[] childrenToArray(Node node) { - final List childrenList = new ArrayList<>(); + var childrenList = new ArrayList(); for (Node child : node.getChildren()) { childrenList.add(child); } - final Object[] arrayOfObjects = childrenList.toArray(); - final Node[] array = new Node[arrayOfObjects.length]; - - for (int i = 0; i < array.length; i++) { - array[i] = (Node) arrayOfObjects[i]; - } - - return array; + return childrenList.toArray(EMPTY_NODE_ARRAY); } } diff --git a/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java b/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java index 22f390d39130..c04fbe3a9518 100644 --- a/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyTopLevelRootNode.java @@ -9,7 +9,6 @@ */ package org.truffleruby.language; -import com.oracle.truffle.api.nodes.RootNode; import org.truffleruby.RubyLanguage; import org.truffleruby.language.control.NextException; import org.truffleruby.language.control.ReturnID; @@ -22,7 +21,6 @@ import com.oracle.truffle.api.frame.FrameDescriptor; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.source.SourceSection; -import org.truffleruby.options.Options; public class RubyTopLevelRootNode extends RubyMethodRootNode { @@ -55,8 +53,8 @@ public Object execute(VirtualFrame frame) { } @Override - protected RootNode cloneUninitialized() { - var clone = new RubyTopLevelRootNode( + protected RubyRootNode cloneUninitializedRootNode() { + return new RubyTopLevelRootNode( getLanguage(), getSourceSection(), getFrameDescriptor(), @@ -65,13 +63,6 @@ protected RootNode cloneUninitialized() { getSplit(), returnID, arityForCheck); - - Options options = getContext().getOptions(); - if (options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { - ensureCloneUninitializedCorrectness(clone); - } - - return clone; } } diff --git a/src/main/java/org/truffleruby/options/LanguageOptions.java b/src/main/java/org/truffleruby/options/LanguageOptions.java index 1ec92ac7595b..4183350df5d8 100644 --- a/src/main/java/org/truffleruby/options/LanguageOptions.java +++ b/src/main/java/org/truffleruby/options/LanguageOptions.java @@ -112,6 +112,8 @@ public class LanguageOptions { public final int PACK_UNROLL_LIMIT; /** --pack-recover=32 */ public final int PACK_RECOVER_LOOP_MIN; + /** --check-clone-uninitialized-correctness=false */ + public final boolean CHECK_CLONE_UNINITIALIZED_CORRECTNESS; /** --regexp-instrument-creation=false */ public final boolean REGEXP_INSTRUMENT_CREATION; /** --shared-objects=true */ @@ -171,6 +173,7 @@ public LanguageOptions(Env env, OptionValues options, boolean singleContext) { ARRAY_UNINITIALIZED_SIZE = options.get(OptionsCatalog.ARRAY_UNINITIALIZED_SIZE_KEY); PACK_UNROLL_LIMIT = options.get(OptionsCatalog.PACK_UNROLL_LIMIT_KEY); PACK_RECOVER_LOOP_MIN = options.get(OptionsCatalog.PACK_RECOVER_LOOP_MIN_KEY); + CHECK_CLONE_UNINITIALIZED_CORRECTNESS = options.get(OptionsCatalog.CHECK_CLONE_UNINITIALIZED_CORRECTNESS_KEY); REGEXP_INSTRUMENT_CREATION = options.get(OptionsCatalog.REGEXP_INSTRUMENT_CREATION_KEY); SHARED_OBJECTS_ENABLED = options.get(OptionsCatalog.SHARED_OBJECTS_ENABLED_KEY); SHARED_OBJECTS_DEBUG = options.get(OptionsCatalog.SHARED_OBJECTS_DEBUG_KEY); @@ -271,6 +274,8 @@ public Object fromDescriptor(OptionDescriptor descriptor) { return PACK_UNROLL_LIMIT; case "ruby.pack-recover": return PACK_RECOVER_LOOP_MIN; + case "ruby.check-clone-uninitialized-correctness": + return CHECK_CLONE_UNINITIALIZED_CORRECTNESS; case "ruby.regexp-instrument-creation": return REGEXP_INSTRUMENT_CREATION; case "ruby.shared-objects": @@ -334,6 +339,7 @@ public static boolean areOptionsCompatible(OptionValues one, OptionValues two) { one.get(OptionsCatalog.ARRAY_UNINITIALIZED_SIZE_KEY).equals(two.get(OptionsCatalog.ARRAY_UNINITIALIZED_SIZE_KEY)) && one.get(OptionsCatalog.PACK_UNROLL_LIMIT_KEY).equals(two.get(OptionsCatalog.PACK_UNROLL_LIMIT_KEY)) && one.get(OptionsCatalog.PACK_RECOVER_LOOP_MIN_KEY).equals(two.get(OptionsCatalog.PACK_RECOVER_LOOP_MIN_KEY)) && + one.get(OptionsCatalog.CHECK_CLONE_UNINITIALIZED_CORRECTNESS_KEY).equals(two.get(OptionsCatalog.CHECK_CLONE_UNINITIALIZED_CORRECTNESS_KEY)) && one.get(OptionsCatalog.REGEXP_INSTRUMENT_CREATION_KEY).equals(two.get(OptionsCatalog.REGEXP_INSTRUMENT_CREATION_KEY)) && one.get(OptionsCatalog.SHARED_OBJECTS_ENABLED_KEY).equals(two.get(OptionsCatalog.SHARED_OBJECTS_ENABLED_KEY)) && one.get(OptionsCatalog.SHARED_OBJECTS_DEBUG_KEY).equals(two.get(OptionsCatalog.SHARED_OBJECTS_DEBUG_KEY)) && @@ -661,6 +667,13 @@ public static boolean areOptionsCompatibleOrLog(TruffleLogger logger, LanguageOp return false; } + oldValue = oldOptions.CHECK_CLONE_UNINITIALIZED_CORRECTNESS; + newValue = newOptions.CHECK_CLONE_UNINITIALIZED_CORRECTNESS; + if (!newValue.equals(oldValue)) { + logger.fine("not reusing pre-initialized context: --check-clone-uninitialized-correctness differs, was: " + oldValue + " and is now: " + newValue); + return false; + } + oldValue = oldOptions.REGEXP_INSTRUMENT_CREATION; newValue = newOptions.REGEXP_INSTRUMENT_CREATION; if (!newValue.equals(oldValue)) { diff --git a/src/main/java/org/truffleruby/options/Options.java b/src/main/java/org/truffleruby/options/Options.java index 6e2b5b6f1537..f03d03a96f5a 100644 --- a/src/main/java/org/truffleruby/options/Options.java +++ b/src/main/java/org/truffleruby/options/Options.java @@ -194,8 +194,6 @@ public class Options { public final boolean METHODMISSING_ALWAYS_CLONE; /** --method-missing-always-inline=INLINE_DEFAULT */ public final boolean METHODMISSING_ALWAYS_INLINE; - /** --check-clone-uninitialized-correctness=false */ - public final boolean CHECK_CLONE_UNINITIALIZED_CORRECTNESS; /** --regexp-instrument-match=false */ public final boolean REGEXP_INSTRUMENT_MATCH; /** --regexp-instrument-match-detailed=false */ @@ -297,7 +295,6 @@ public Options(Env env, OptionValues options, LanguageOptions languageOptions) { YIELD_ALWAYS_INLINE = options.hasBeenSet(OptionsCatalog.YIELD_ALWAYS_INLINE_KEY) ? options.get(OptionsCatalog.YIELD_ALWAYS_INLINE_KEY) : INLINE_DEFAULT; METHODMISSING_ALWAYS_CLONE = options.hasBeenSet(OptionsCatalog.METHODMISSING_ALWAYS_CLONE_KEY) ? options.get(OptionsCatalog.METHODMISSING_ALWAYS_CLONE_KEY) : CLONE_DEFAULT; METHODMISSING_ALWAYS_INLINE = options.hasBeenSet(OptionsCatalog.METHODMISSING_ALWAYS_INLINE_KEY) ? options.get(OptionsCatalog.METHODMISSING_ALWAYS_INLINE_KEY) : INLINE_DEFAULT; - CHECK_CLONE_UNINITIALIZED_CORRECTNESS = options.get(OptionsCatalog.CHECK_CLONE_UNINITIALIZED_CORRECTNESS_KEY); REGEXP_INSTRUMENT_MATCH = options.get(OptionsCatalog.REGEXP_INSTRUMENT_MATCH_KEY); REGEXP_INSTRUMENT_MATCH_DETAILED = options.get(OptionsCatalog.REGEXP_INSTRUMENT_MATCH_DETAILED_KEY); REGEXP_INSTRUMENT_OUTPUT_FORMAT = options.get(OptionsCatalog.REGEXP_INSTRUMENT_OUTPUT_FORMAT_KEY); @@ -479,8 +476,6 @@ public Object fromDescriptor(OptionDescriptor descriptor) { return METHODMISSING_ALWAYS_CLONE; case "ruby.method-missing-always-inline": return METHODMISSING_ALWAYS_INLINE; - case "ruby.check-clone-uninitialized-correctness": - return CHECK_CLONE_UNINITIALIZED_CORRECTNESS; case "ruby.regexp-instrument-match": return REGEXP_INSTRUMENT_MATCH; case "ruby.regexp-instrument-match-detailed": diff --git a/src/options.yml b/src/options.yml index b8bd678791bc..0c970c61ca85 100644 --- a/src/options.yml +++ b/src/options.yml @@ -51,6 +51,7 @@ LANGUAGE_OPTIONS: - ARRAY_STRATEGY_CACHE - EXPERIMENTAL_ENGINE_CACHING - RUN_TWICE +- CHECK_CLONE_UNINITIALIZED_CORRECTNESS USER: STABLE: From 8026cdc4e278d22dada5d29403dece38d960fbed Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Mon, 3 Oct 2022 18:30:37 +0200 Subject: [PATCH 23/46] Move test and add executable bit --- test/truffle/compiler/clone-uninitialized-checks.sh | 6 ++++++ test/truffle/compiler/compile-immediately.sh | 2 +- .../integration/clone-uninitialized-checks.sh | 12 ------------ 3 files changed, 7 insertions(+), 13 deletions(-) create mode 100755 test/truffle/compiler/clone-uninitialized-checks.sh delete mode 100644 test/truffle/integration/clone-uninitialized-checks.sh diff --git a/test/truffle/compiler/clone-uninitialized-checks.sh b/test/truffle/compiler/clone-uninitialized-checks.sh new file mode 100755 index 000000000000..00bb50d48908 --- /dev/null +++ b/test/truffle/compiler/clone-uninitialized-checks.sh @@ -0,0 +1,6 @@ +#!/usr/bin/env bash + +source test/truffle/common.sh.inc + +export JT_SPECS_COMPILATION=false +jt test fast -- --check-clone-uninitialized-correctness diff --git a/test/truffle/compiler/compile-immediately.sh b/test/truffle/compiler/compile-immediately.sh index fa0f668c9698..3065fcd1599f 100755 --- a/test/truffle/compiler/compile-immediately.sh +++ b/test/truffle/compiler/compile-immediately.sh @@ -2,7 +2,7 @@ source test/truffle/common.sh.inc -code="abort 'not running the GraalVM Compiler' unless TruffleRuby.jit?; puts 'hello'" +code="puts 'hello'" # Test both without and with BackgroundCompilation, it catches different issues diff --git a/test/truffle/integration/clone-uninitialized-checks.sh b/test/truffle/integration/clone-uninitialized-checks.sh deleted file mode 100644 index cf12d723fb9d..000000000000 --- a/test/truffle/integration/clone-uninitialized-checks.sh +++ /dev/null @@ -1,12 +0,0 @@ -#!/usr/bin/env bash - -source test/truffle/common.sh.inc - -ruby_version=$(jt ruby -v) -if [[ $ruby_version =~ "GraalVM CE JVM" ]] || [[ $ruby_version =~ "GraalVM CE Native" ]]; then - echo "The checks are only meaningful when splitting is performed so GraalVM compiler is required." - exit 0 -fi - -export JT_SPECS_COMPILATION=false -jt test fast -- --check-clone-uninitialized-correctness From d28aa06526eaf599a0f1ca372b3a3cab94bd8d20 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Mon, 3 Oct 2022 18:55:25 +0200 Subject: [PATCH 24/46] Fix test --- test/truffle/compiler/clone-uninitialized-checks.sh | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/test/truffle/compiler/clone-uninitialized-checks.sh b/test/truffle/compiler/clone-uninitialized-checks.sh index 00bb50d48908..4875e3260041 100755 --- a/test/truffle/compiler/clone-uninitialized-checks.sh +++ b/test/truffle/compiler/clone-uninitialized-checks.sh @@ -2,5 +2,4 @@ source test/truffle/common.sh.inc -export JT_SPECS_COMPILATION=false -jt test fast -- --check-clone-uninitialized-correctness +jt test fast -- --vm.XX:-UseJVMCICompiler --engine.Compilation=false --core-always-clone --check-clone-uninitialized-correctness From e79466f446f532c842024c33693be61c6e6d26e2 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Tue, 4 Oct 2022 17:18:24 +0300 Subject: [PATCH 25/46] More detailed error description when root node is cloned incorrectly --- .../truffleruby/language/RubyRootNode.java | 55 ++++++++++++++----- 1 file changed, 41 insertions(+), 14 deletions(-) diff --git a/src/main/java/org/truffleruby/language/RubyRootNode.java b/src/main/java/org/truffleruby/language/RubyRootNode.java index ea4ff71c4f47..18e6018c0318 100644 --- a/src/main/java/org/truffleruby/language/RubyRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyRootNode.java @@ -149,6 +149,20 @@ protected final RootNode cloneUninitialized() { return clone; } + private class CloningError extends Error { + + public final Node original; + public final Node clone; + + CloningError(String message, Node original, Node clone) { + super(message); + + this.original = original; + this.clone = clone; + } + + } + private void ensureCloneUninitializedCorrectness(RubyRootNode clone) { if (this == clone) { throw CompilerDirectives.shouldNotReachHere("clone same as this"); @@ -158,32 +172,49 @@ private void ensureCloneUninitializedCorrectness(RubyRootNode clone) { .shouldNotReachHere("different clone class: " + this.getClass() + " vs " + clone.getClass()); } - if (!isClonedCorrectly(bodyCopy, clone.body)) { + try { + ensureClonedCorrectly(bodyCopy, clone.body); + } catch (CloningError e) { System.err.println(); - System.err.println("Original copy of body (bodyCopy) AST:"); + + System.err.println("#cloneUninitialized for RubyRootNode " + getName() + " created not identical AST"); + System.err.println(e.getMessage()); + + System.err.println(); + + System.err.println("Original node:"); + NodeUtil.printCompactTree(System.err, e.original); + + System.err.println("Cloned node:"); + NodeUtil.printCompactTree(System.err, e.clone); + + System.err.println(); + + System.err.println("Original root node body:"); NodeUtil.printCompactTree(System.err, bodyCopy); - System.err.println("Cloned body (clone.bodyCopy) AST:"); - NodeUtil.printCompactTree(System.err, clone.bodyCopy); + System.err.println("Cloned root node body:"); + NodeUtil.printCompactTree(System.err, clone.body); throw new Error("#cloneUninitialized for RubyRootNode " + getName() + " created not identical AST"); } } - private boolean isClonedCorrectly(Node original, Node clone) { + private void ensureClonedCorrectly(Node original, Node clone) { // A clone should be a new instance if (original == clone) { - return false; + throw new CloningError("Original node equals a clone", original, clone); } // Ignore instrumental wrappers (e.g. RubyNodeWrapper) if (original instanceof WrapperNode) { - return isClonedCorrectly(((WrapperNode) original).getDelegateNode(), clone); + ensureClonedCorrectly(((WrapperNode) original).getDelegateNode(), clone); + return; } // Should be instances of the same class if (original.getClass() != clone.getClass()) { - return false; + throw new CloningError("Nodes are instances of different classes", original, clone); } Node[] originalChildren = childrenToArray(original); @@ -191,17 +222,13 @@ private boolean isClonedCorrectly(Node original, Node clone) { // Should have the same number of children if (cloneChildren.length != originalChildren.length) { - return false; + throw new CloningError("Nodes have different number of children", original, clone); } // Should have the same children for (int i = 0; i < cloneChildren.length; i++) { - if (!isClonedCorrectly(originalChildren[i], cloneChildren[i])) { - return false; - } + ensureClonedCorrectly(originalChildren[i], cloneChildren[i]); } - - return true; } private static final Node[] EMPTY_NODE_ARRAY = new Node[0]; From 6d102639889a5cecc5570127e7f1ebbc5e16e48d Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Tue, 4 Oct 2022 17:21:39 +0300 Subject: [PATCH 26/46] Avoid upcasting of returned value by CoreMethodAssumption#createCallNode --- .../org/truffleruby/core/inlined/CoreMethodAssumptions.java | 3 ++- .../java/org/truffleruby/language/dispatch/RubyCallNode.java | 3 +-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/truffleruby/core/inlined/CoreMethodAssumptions.java b/src/main/java/org/truffleruby/core/inlined/CoreMethodAssumptions.java index 14903f15ba70..a4314fe68bf3 100644 --- a/src/main/java/org/truffleruby/core/inlined/CoreMethodAssumptions.java +++ b/src/main/java/org/truffleruby/core/inlined/CoreMethodAssumptions.java @@ -19,6 +19,7 @@ import org.truffleruby.core.CoreLibrary; import org.truffleruby.core.klass.RubyClass; import org.truffleruby.core.module.ModuleFields; +import org.truffleruby.language.RubyContextSourceNode; import org.truffleruby.language.RubyNode; import org.truffleruby.language.dispatch.RubyCallNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; @@ -148,7 +149,7 @@ public void registerAssumptions(CoreLibrary coreLibrary) { } } - public RubyNode createCallNode(RubyCallNodeParameters callParameters) { + public RubyContextSourceNode createCallNode(RubyCallNodeParameters callParameters) { if (!language.options.BASICOPS_INLINE || callParameters.isSplatted() || callParameters.isSafeNavigation()) { return new RubyCallNode(callParameters); } diff --git a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java index 83b6ac7910b8..78861345d387 100644 --- a/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java +++ b/src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java @@ -20,7 +20,6 @@ import org.truffleruby.core.string.FrozenStrings; import org.truffleruby.core.symbol.RubySymbol; import org.truffleruby.language.RubyBaseNode; -import org.truffleruby.language.RubyContextSourceNode; import org.truffleruby.language.RubyGuards; import org.truffleruby.language.RubyNode; import org.truffleruby.language.arguments.ArgumentsDescriptor; @@ -280,7 +279,7 @@ public RubyNode cloneUninitialized() { isVCall, isSafeNavigation, isAttrAssign); - var copy = (RubyContextSourceNode) getLanguage().coreMethodAssumptions.createCallNode(parameters); + var copy = getLanguage().coreMethodAssumptions.createCallNode(parameters); return copy.copyFlags(this); } From 44f2026025dae00bc2fdb4a6a727523f26726348 Mon Sep 17 00:00:00 2001 From: Andrew Konchin Date: Tue, 4 Oct 2022 17:22:33 +0300 Subject: [PATCH 27/46] Prevent overriding of ArrayLiteralNode#cloneUninitialized() in subclasses --- src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java index 7cf1a6a58139..e3e7ebe1b444 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java @@ -62,7 +62,7 @@ protected RubyArray cachedCreateArray(Object store, int size) { // Do not override #cloneUninitialized() in subclasses. // In runtime any literal array node may be replaced with UninitializedArrayLiteralNode. @Override - public RubyNode cloneUninitialized() { + public final RubyNode cloneUninitialized() { var copy = new UninitialisedArrayLiteralNode( language, cloneUninitialized(values)); From 83409b67d1cac6a582d8b2f2805230ed56789615 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 14:19:10 +0200 Subject: [PATCH 28/46] Do not print all java exceptions for jt test compiler * Does not seem needed and prints stacktraces while running specs. --- tool/jt.rb | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tool/jt.rb b/tool/jt.rb index 441c11c4a51e..508016831b13 100755 --- a/tool/jt.rb +++ b/tool/jt.rb @@ -1332,11 +1332,9 @@ def retag(*args) private def test_compiler(*args) truffleruby_compiler! - env = {} - env['TRUFFLERUBYOPT'] = [*ENV['TRUFFLERUBYOPT'], '--experimental-options', '--exceptions-print-java=true'].join(' ') run_tests('test/truffle/compiler', args) do |test_script| - sh env, test_script + sh test_script end end From dfed7e9c47930ee3bd87ad90a1d7c8f996fa9f82 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 14:22:41 +0200 Subject: [PATCH 29/46] Cleanup new error class --- src/main/java/org/truffleruby/language/RubyRootNode.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/org/truffleruby/language/RubyRootNode.java b/src/main/java/org/truffleruby/language/RubyRootNode.java index 18e6018c0318..8d4bcca06cb2 100644 --- a/src/main/java/org/truffleruby/language/RubyRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyRootNode.java @@ -149,7 +149,8 @@ protected final RootNode cloneUninitialized() { return clone; } - private class CloningError extends Error { + @SuppressWarnings("serial") + private static class CloningError extends Error { public final Node original; public final Node clone; From 8a613c88d1d6ea171fe9e18d83146c81f82d4343 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 14:08:32 +0200 Subject: [PATCH 30/46] Use CoreMethodNodeManager.createCoreMethodRootNode() for RubyCoreMethodRootNode#cloneUninitialized() --- .../truffleruby/builtins/CoreMethodNode.java | 7 +++--- .../builtins/CoreMethodNodeManager.java | 25 ++++++++++++------- .../language/RubyCoreMethodRootNode.java | 23 +++++++++-------- .../methods/CallInternalMethodNode.java | 2 +- 4 files changed, 33 insertions(+), 24 deletions(-) diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodNode.java b/src/main/java/org/truffleruby/builtins/CoreMethodNode.java index 5e71840d6b74..5adc2582aa8d 100644 --- a/src/main/java/org/truffleruby/builtins/CoreMethodNode.java +++ b/src/main/java/org/truffleruby/builtins/CoreMethodNode.java @@ -9,7 +9,7 @@ */ package org.truffleruby.builtins; -import com.oracle.truffle.api.dsl.NodeFactory; +import com.oracle.truffle.api.CompilerDirectives; import org.truffleruby.language.RubyContextSourceNode; import com.oracle.truffle.api.dsl.GenerateNodeFactory; @@ -20,9 +20,8 @@ public abstract class CoreMethodNode extends RubyContextSourceNode { @Override public RubyNode cloneUninitialized() { - NodeFactory factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass()); - var copy = (CoreMethodNode) CoreMethodNodeManager.createNodeFromFactory(factory, RubyNode.EMPTY_ARRAY); - return copy.copyFlags(this); + throw CompilerDirectives.shouldNotReachHere( + getClass() + " should be handled by RubyCoreMethodRootNode#cloneUninitializedRootNode()"); } } diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java b/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java index ec7d646ce0c2..d7ae375fc757 100644 --- a/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java +++ b/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java @@ -147,7 +147,7 @@ private void addCoreMethod(RubyModule module, MethodDetails methodDetails) { final Split split = effectiveSplit(annotation.split(), annotation.needsBlock()); final Function callTargetFactory = sharedMethodInfo -> { - return createCoreMethodRootNode(nodeFactory, language, sharedMethodInfo, split, annotation); + return createCoreMethodCallTarget(nodeFactory, language, sharedMethodInfo, split, annotation); }; addMethods( @@ -189,7 +189,7 @@ public void addLazyCoreMethod( final Function callTargetFactory = sharedMethodInfo -> { final NodeFactory nodeFactory = loadNodeFactory(nodeFactoryName); final CoreMethod annotation = nodeFactory.getNodeClass().getAnnotation(CoreMethod.class); - return createCoreMethodRootNode(nodeFactory, language, sharedMethodInfo, finalSplit, annotation); + return createCoreMethodCallTarget(nodeFactory, language, sharedMethodInfo, finalSplit, annotation); }; addMethods( @@ -319,9 +319,8 @@ private static SharedMethodInfo makeSharedMethodInfo(String moduleName, boolean null); } - public RootCallTarget createCoreMethodRootNode(NodeFactory nodeFactory, + public static RootCallTarget createCoreMethodCallTarget(NodeFactory nodeFactory, RubyLanguage language, SharedMethodInfo sharedMethodInfo, Split split, CoreMethod method) { - // It's fine to load the node class here, this is only called when resolving the lazy CallTarget var nodeClass = nodeFactory.getNodeClass(); @@ -355,6 +354,13 @@ public RootCallTarget createCoreMethodRootNode(NodeFactory nodeFactory, + RubyLanguage language, SharedMethodInfo sharedMethodInfo, Split split, CoreMethod method) { + assert !method.alwaysInlined(); + final RubyNode[] argumentsNodes = new RubyNode[nodeFactory.getExecutionSignature().size()]; int i = 0; @@ -384,9 +390,9 @@ public RootCallTarget createCoreMethodRootNode(NodeFactory nodeFactory, @@ -438,7 +445,7 @@ private static RubyNode transformArgument(CoreMethod method, RubyNode argument, return argument; } - private RubyNode transformResult(CoreMethod method, RubyNode node) { + private static RubyNode transformResult(RubyLanguage language, CoreMethod method, RubyNode node) { if (!method.enumeratorSize().isEmpty()) { assert !method.returnsEnumeratorIfNoBlock() : "Only one of enumeratorSize or returnsEnumeratorIfNoBlock can be specified"; diff --git a/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java b/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java index ebb3bd232515..43d313d8eaf1 100644 --- a/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyCoreMethodRootNode.java @@ -10,7 +10,10 @@ package org.truffleruby.language; import com.oracle.truffle.api.TruffleSafepoint; +import com.oracle.truffle.api.dsl.NodeFactory; import org.truffleruby.RubyLanguage; +import org.truffleruby.builtins.CoreMethod; +import org.truffleruby.builtins.CoreMethodNodeManager; import org.truffleruby.language.control.ReturnID; import org.truffleruby.language.methods.Arity; import org.truffleruby.language.methods.SharedMethodInfo; @@ -24,6 +27,9 @@ public class RubyCoreMethodRootNode extends RubyCheckArityRootNode { + private final NodeFactory nodeFactory; + private final CoreMethod coreMethod; + @Child private TranslateExceptionNode translateExceptionNode; public RubyCoreMethodRootNode( @@ -34,8 +40,12 @@ public RubyCoreMethodRootNode( RubyNode body, Split split, ReturnID returnID, - Arity arityForCheck) { + Arity arityForCheck, + NodeFactory nodeFactory, + CoreMethod coreMethod) { super(language, sourceSection, frameDescriptor, sharedMethodInfo, body, split, returnID, arityForCheck); + this.nodeFactory = nodeFactory; + this.coreMethod = coreMethod; } @Override @@ -57,15 +67,8 @@ public Object execute(VirtualFrame frame) { @Override protected RubyRootNode cloneUninitializedRootNode() { - return new RubyCoreMethodRootNode( - getLanguage(), - getSourceSection(), - getFrameDescriptor(), - getSharedMethodInfo(), - body.cloneUninitialized(), - getSplit(), - returnID, - arityForCheck); + return CoreMethodNodeManager.createCoreMethodRootNode(nodeFactory, getLanguage(), getSharedMethodInfo(), + getSplit(), coreMethod); } } diff --git a/src/main/java/org/truffleruby/language/methods/CallInternalMethodNode.java b/src/main/java/org/truffleruby/language/methods/CallInternalMethodNode.java index 455f399dc3c3..b265d190870b 100644 --- a/src/main/java/org/truffleruby/language/methods/CallInternalMethodNode.java +++ b/src/main/java/org/truffleruby/language/methods/CallInternalMethodNode.java @@ -179,7 +179,7 @@ protected AlwaysInlinedMethodNode createAlwaysInlinedMethodNode(InternalMethod m .createNodeFromFactory(method.alwaysInlinedNodeFactory, RubyNode.EMPTY_ARRAY); } - /** Asserted in {@link CoreMethodNodeManager#createCoreMethodRootNode} */ + /** Asserted in {@link CoreMethodNodeManager#createCoreMethodCallTarget} */ protected AlwaysInlinedMethodNode getUncachedAlwaysInlinedMethodNode(InternalMethod method) { return (AlwaysInlinedMethodNode) method.alwaysInlinedNodeFactory.getUncachedInstance(); } From 9ffe6d2fe6c739e53c4f0ee5e78a544b412c3819 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 14:51:03 +0200 Subject: [PATCH 31/46] No need for CoreMethodArrayArgumentsNode#cloneUninitialized() anymore --- .../builtins/CoreMethodArrayArgumentsNode.java | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java b/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java index 6b1dcf4862b3..8b4477f46663 100644 --- a/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java +++ b/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java @@ -9,7 +9,6 @@ */ package org.truffleruby.builtins; -import com.oracle.truffle.api.dsl.NodeFactory; import org.truffleruby.language.RubyNode; import com.oracle.truffle.api.dsl.NodeChild; @@ -19,12 +18,4 @@ public abstract class CoreMethodArrayArgumentsNode extends CoreMethodNode { public abstract RubyNode[] getArgumentNodes(); - @Override - public RubyNode cloneUninitialized() { - NodeFactory factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass()); - RubyNode[] copiedArguments = cloneUninitialized(getArgumentNodes()); - var copy = (CoreMethodArrayArgumentsNode) CoreMethodNodeManager.createNodeFromFactory(factory, copiedArguments); - return copy.copyFlags(this); - } - } From 516afc57fb63ed2a311939001f46bc8216fe4424 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 14:37:15 +0200 Subject: [PATCH 32/46] Revert "Implement cloneUninitialized() for CoreMethod ancestors" * This reverts commit ee9e1e5fc9be399dc114c1580fdd9715e271fbd2. * RubyCoreMethodRootNode#cloneUninitializedRootNode makes this unnecessary. --- .../java/org/truffleruby/cext/CExtNodes.java | 82 +-- .../truffleruby/core/array/ArrayNodes.java | 131 +--- .../org/truffleruby/core/cast/ToAryNode.java | 2 +- .../org/truffleruby/core/cast/ToIntNode.java | 2 +- .../org/truffleruby/core/cast/ToLongNode.java | 2 +- .../org/truffleruby/core/cast/ToPathNode.java | 2 +- .../truffleruby/core/cast/ToSymbolNode.java | 2 +- .../core/encoding/EncodingConverterNodes.java | 28 +- .../truffleruby/core/kernel/KernelNodes.java | 183 +----- .../core/kernel/TruffleKernelNodes.java | 26 +- .../truffleruby/core/module/ModuleNodes.java | 590 ++---------------- .../core/numeric/FixnumLowerNode.java | 2 +- .../truffleruby/core/queue/QueueNodes.java | 26 +- .../core/queue/SizedQueueNodes.java | 57 +- .../truffleruby/core/range/RangeNodes.java | 2 + .../truffleruby/core/string/StringNodes.java | 192 +----- .../org/truffleruby/interop/InteropNodes.java | 386 ++---------- .../interop/SymbolToByteOrderNode.java | 2 +- .../truffleruby/interop/ToJavaStringNode.java | 2 +- .../interop/ToJavaStringWithDefaultNode.java | 2 +- .../truffleruby/parser/BodyTranslator.java | 4 +- .../stdlib/readline/ReadlineHistoryNodes.java | 32 +- .../stdlib/readline/ReadlineNodes.java | 80 +-- 23 files changed, 228 insertions(+), 1609 deletions(-) diff --git a/src/main/java/org/truffleruby/cext/CExtNodes.java b/src/main/java/org/truffleruby/cext/CExtNodes.java index 4dac4621aaae..fae0fef58d1d 100644 --- a/src/main/java/org/truffleruby/cext/CExtNodes.java +++ b/src/main/java/org/truffleruby/cext/CExtNodes.java @@ -975,126 +975,64 @@ protected ImmutableRubyString rbStrUnlockTmpImmutable(ImmutableRubyString string } @CoreMethod(names = "rb_const_get", onSingleton = true, required = 2) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyNode.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyNode.class) public abstract static class RbConstGetNode extends CoreMethodNode { @Child private LookupConstantNode lookupConstantNode = LookupConstantNode.create(true, true); @Child private GetConstantNode getConstantNode = GetConstantNode.create(); - @CreateCast("nameNode") + @CreateCast("name") protected RubyNode coerceToString(RubyNode name) { return ToJavaStringNode.create(name); } - abstract RubyNode getModuleNode(); - - abstract RubyNode getNameNode(); - - public static RbConstGetNode create(RubyNode module, RubyNode name) { - return CExtNodesFactory.RbConstGetNodeFactory.create(module, name); - } - @Specialization protected Object rbConstGet(RubyModule module, String name) { return getConstantNode .lookupAndResolveConstant(LexicalScope.IGNORE, module, name, false, lookupConstantNode); } - private RubyNode getNameNodeBeforeCasting() { - return ((ToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "rb_const_get_from", onSingleton = true, required = 2) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyNode.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyNode.class) public abstract static class RbConstGetFromNode extends CoreMethodNode { @Child private LookupConstantNode lookupConstantNode = LookupConstantNode.create(true, false); @Child private GetConstantNode getConstantNode = GetConstantNode.create(); - @CreateCast("nameNode") + @CreateCast("name") protected RubyNode coerceToString(RubyNode name) { return ToJavaStringNode.create(name); } - public static RbConstGetFromNode create(RubyNode moduleNode, RubyNode nameNode) { - return CExtNodesFactory.RbConstGetFromNodeFactory.create(moduleNode, nameNode); - } - - abstract RubyNode getModuleNode(); - - abstract RubyNode getNameNode(); - @Specialization protected Object rbConstGetFrom(RubyModule module, String name) { return getConstantNode .lookupAndResolveConstant(LexicalScope.IGNORE, module, name, false, lookupConstantNode); } - private RubyNode getNameNodeBeforeCasting() { - return ((ToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "rb_const_set", onSingleton = true, required = 3) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyNode.class) - @NodeChild(value = "valueNode", type = RubyNode.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyNode.class) + @NodeChild(value = "value", type = RubyNode.class) public abstract static class RbConstSetNode extends CoreMethodNode { - @CreateCast("nameNode") + @CreateCast("name") protected RubyNode coerceToString(RubyNode name) { return ToJavaStringNode.create(name); } - public static RbConstSetNode create(RubyNode moduleNode, RubyNode nameNode, RubyNode valueNode) { - return CExtNodesFactory.RbConstSetNodeFactory.create(moduleNode, nameNode, valueNode); - } - - abstract RubyNode getModuleNode(); - - abstract RubyNode getNameNode(); - - abstract RubyNode getValueNode(); - @Specialization protected Object rbConstSet(RubyModule module, String name, Object value, @Cached ConstSetUncheckedNode constSetUncheckedNode) { return constSetUncheckedNode.execute(module, name, value); } - private RubyNode getNameNodeBeforeCasting() { - return ((ToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized(), - getValueNode().cloneUninitialized()); - return copy.copyFlags(this); - } } @CoreMethod(names = "cext_module_function", onSingleton = true, required = 2) diff --git a/src/main/java/org/truffleruby/core/array/ArrayNodes.java b/src/main/java/org/truffleruby/core/array/ArrayNodes.java index ad866eeaca0a..c3b4dcc910d1 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayNodes.java +++ b/src/main/java/org/truffleruby/core/array/ArrayNodes.java @@ -123,21 +123,13 @@ protected RubyArray allocate(RubyClass rubyClass) { } @CoreMethod(names = "+", required = 1) - @NodeChild(value = "aNode", type = RubyNode.class) - @NodeChild(value = "bNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "a", type = RubyNode.class) + @NodeChild(value = "b", type = RubyBaseNodeWithExecute.class) @ImportStatic(ArrayGuards.class) @ReportPolymorphism public abstract static class AddNode extends CoreMethodNode { - public static AddNode create(RubyNode a, RubyBaseNodeWithExecute b) { - return ArrayNodesFactory.AddNodeFactory.create(a, b); - } - - abstract RubyNode getANode(); - - abstract RubyBaseNodeWithExecute getBNode(); - - @CreateCast("bNode") + @CreateCast("b") protected RubyBaseNodeWithExecute coerceOtherToAry(RubyBaseNodeWithExecute other) { return ToAryNodeGen.create(other); } @@ -160,18 +152,6 @@ protected RubyArray addGeneralize(RubyArray a, RubyArray b, return createArray(newStore, combinedSize); } - private RubyBaseNodeWithExecute getBNodeBeforeCasting() { - return ((ToAryNode) getBNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getANode().cloneUninitialized(), - getBNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @Primitive(name = "array_mul", lowerFixnum = 1) @@ -770,21 +750,13 @@ public void checkFrozen(Object object) { } @CoreMethod(names = "delete_at", required = 1, raiseIfFrozenSelf = true, lowerFixnum = 1) - @NodeChild(value = "arrayNode", type = RubyNode.class) - @NodeChild(value = "indexNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "array", type = RubyNode.class) + @NodeChild(value = "index", type = RubyBaseNodeWithExecute.class) @ImportStatic(ArrayGuards.class) @ReportPolymorphism public abstract static class DeleteAtNode extends CoreMethodNode { - public static DeleteAtNode create(RubyNode array, RubyBaseNodeWithExecute index) { - return ArrayNodesFactory.DeleteAtNodeFactory.create(array, index); - } - - abstract RubyNode getArrayNode(); - - abstract RubyBaseNodeWithExecute getIndexNode(); - - @CreateCast("indexNode") + @CreateCast("index") protected ToIntNode coerceOtherToInt(RubyBaseNodeWithExecute index) { return ToIntNode.create(index); } @@ -841,19 +813,6 @@ protected Object deleteAtCopying(RubyArray array, int index, return value; } } - - private RubyBaseNodeWithExecute getIndexNodeBeforeCasting() { - return ((ToIntNode) getIndexNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getArrayNode().cloneUninitialized(), - getIndexNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "each", needsBlock = true, enumeratorSize = "size") @@ -1341,20 +1300,12 @@ protected int toInt(Object value) { } @CoreMethod(names = "initialize_copy", required = 1, raiseIfFrozenSelf = true) - @NodeChild(value = "selfNode", type = RubyNode.class) - @NodeChild(value = "fromNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "self", type = RubyNode.class) + @NodeChild(value = "from", type = RubyBaseNodeWithExecute.class) @ImportStatic(ArrayGuards.class) public abstract static class InitializeCopyNode extends CoreMethodNode { - public static InitializeCopyNode create(RubyNode self, RubyBaseNodeWithExecute from) { - return ArrayNodesFactory.InitializeCopyNodeFactory.create(self, from); - } - - abstract RubyNode getSelfNode(); - - abstract RubyBaseNodeWithExecute getFromNode(); - - @CreateCast("fromNode") + @CreateCast("from") protected RubyBaseNodeWithExecute coerceOtherToAry(RubyBaseNodeWithExecute other) { return ToAryNodeGen.create(other); } @@ -1369,18 +1320,6 @@ protected RubyArray initializeCopy(RubyArray self, RubyArray from, return self; } - private RubyBaseNodeWithExecute getFromNodeBeforeCasting() { - return ((ToAryNode) getFromNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getSelfNode().cloneUninitialized(), - getFromNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @Primitive(name = "array_inject") @@ -1580,9 +1519,9 @@ public void accept(RubyArray array, RubyProc block, Object element, int index) { } + @NodeChild(value = "array", type = RubyNode.class) + @NodeChild(value = "format", type = RubyBaseNodeWithExecute.class) @CoreMethod(names = "pack", required = 1) - @NodeChild(value = "arrayNode", type = RubyNode.class) - @NodeChild(value = "formatNode", type = RubyBaseNodeWithExecute.class) @ReportPolymorphism public abstract static class PackNode extends CoreMethodNode { @@ -1592,15 +1531,7 @@ public abstract static class PackNode extends CoreMethodNode { private final BranchProfile exceptionProfile = BranchProfile.create(); private final ConditionProfile resizeProfile = ConditionProfile.create(); - public static PackNode create(RubyNode array, RubyBaseNodeWithExecute format) { - return ArrayNodesFactory.PackNodeFactory.create(array, format); - } - - abstract RubyNode getArrayNode(); - - abstract RubyBaseNodeWithExecute getFormatNode(); - - @CreateCast("formatNode") + @CreateCast("format") protected ToStrNode coerceFormat(RubyBaseNodeWithExecute format) { return ToStrNodeGen.create(format); } @@ -1685,18 +1616,6 @@ protected int getCacheLimit() { return getLanguage().options.PACK_CACHE; } - private RubyBaseNodeWithExecute getFormatNodeBeforeCasting() { - return ((ToStrNode) getFormatNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getArrayNode().cloneUninitialized(), - getFormatNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "pop", raiseIfFrozenSelf = true, optional = 1, lowerFixnum = 1) @@ -1947,8 +1866,8 @@ private Object rejectInPlaceInternal(RubyArray array, RubyProc block, ArrayStore } @CoreMethod(names = "replace", required = 1, raiseIfFrozenSelf = true) - @NodeChild(value = "arrayNode", type = RubyNode.class) - @NodeChild(value = "otherNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "array", type = RubyNode.class) + @NodeChild(value = "other", type = RubyBaseNodeWithExecute.class) @ImportStatic(ArrayGuards.class) @ReportPolymorphism public abstract static class ReplaceNode extends CoreMethodNode { @@ -1957,17 +1876,9 @@ public static ReplaceNode create() { return ReplaceNodeFactory.create(null, null); } - public static ReplaceNode create(RubyNode array, RubyBaseNodeWithExecute other) { - return ReplaceNodeFactory.create(array, other); - } - public abstract RubyArray executeReplace(RubyArray array, RubyArray other); - abstract RubyNode getArrayNode(); - - abstract RubyBaseNodeWithExecute getOtherNode(); - - @CreateCast("otherNode") + @CreateCast("other") protected RubyBaseNodeWithExecute coerceOtherToAry(RubyBaseNodeWithExecute index) { return ToAryNodeGen.create(index); } @@ -1987,18 +1898,6 @@ protected RubyArray replace(RubyArray array, RubyArray other, return array; } - private RubyBaseNodeWithExecute getOtherNodeBeforeCasting() { - return ((ToAryNode) getOtherNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getArrayNode().cloneUninitialized(), - getOtherNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @Primitive(name = "array_rotate", lowerFixnum = 1) diff --git a/src/main/java/org/truffleruby/core/cast/ToAryNode.java b/src/main/java/org/truffleruby/core/cast/ToAryNode.java index 000c572c1295..2f3fd7e3ea4f 100644 --- a/src/main/java/org/truffleruby/core/cast/ToAryNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToAryNode.java @@ -32,7 +32,7 @@ public static ToAryNode create(RubyBaseNodeWithExecute child) { public abstract RubyArray executeToAry(Object object); - public abstract RubyBaseNodeWithExecute getChildNode(); + abstract RubyBaseNodeWithExecute getChildNode(); @Specialization protected RubyArray coerceRubyArray(RubyArray array) { diff --git a/src/main/java/org/truffleruby/core/cast/ToIntNode.java b/src/main/java/org/truffleruby/core/cast/ToIntNode.java index ad477f8a15b5..75ae9a595178 100644 --- a/src/main/java/org/truffleruby/core/cast/ToIntNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToIntNode.java @@ -60,7 +60,7 @@ public static ToIntNode create(RubyBaseNodeWithExecute child) { public abstract int execute(Object object); - public abstract RubyBaseNodeWithExecute getChildNode(); + abstract RubyBaseNodeWithExecute getChildNode(); @Specialization protected int coerceInt(int value) { diff --git a/src/main/java/org/truffleruby/core/cast/ToLongNode.java b/src/main/java/org/truffleruby/core/cast/ToLongNode.java index 7391d5513415..8bcb8a50b466 100644 --- a/src/main/java/org/truffleruby/core/cast/ToLongNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToLongNode.java @@ -37,7 +37,7 @@ public static ToLongNode create(RubyBaseNodeWithExecute child) { public abstract long execute(Object object); - public abstract RubyBaseNodeWithExecute getChildNode(); + abstract RubyBaseNodeWithExecute getChildNode(); @Specialization protected long coerceInt(int value) { diff --git a/src/main/java/org/truffleruby/core/cast/ToPathNode.java b/src/main/java/org/truffleruby/core/cast/ToPathNode.java index 5b51b3045e9a..083f8e079763 100644 --- a/src/main/java/org/truffleruby/core/cast/ToPathNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToPathNode.java @@ -25,7 +25,7 @@ public static ToPathNode create(RubyBaseNodeWithExecute child) { return ToPathNodeGen.create(child); } - public abstract RubyBaseNodeWithExecute getChildNode(); + abstract RubyBaseNodeWithExecute getChildNode(); @Specialization protected RubyString coerceRubyString(RubyString path) { diff --git a/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java b/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java index d044207e8aa0..6e84689458a2 100644 --- a/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java +++ b/src/main/java/org/truffleruby/core/cast/ToSymbolNode.java @@ -43,7 +43,7 @@ public static ToSymbolNode getUncached() { public abstract RubySymbol execute(Object object); - public abstract RubyBaseNodeWithExecute getValueNode(); + abstract RubyBaseNodeWithExecute getValueNode(); @Specialization protected RubySymbol symbol(RubySymbol symbol) { diff --git a/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java b/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java index 35fac931976f..2877aa9ffc70 100644 --- a/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java +++ b/src/main/java/org/truffleruby/core/encoding/EncodingConverterNodes.java @@ -443,25 +443,15 @@ protected RubyString getReplacement(RubyEncodingConverter encodingConverter) { } @CoreMethod(names = "replacement=", required = 1) - @NodeChild(value = "encodingConverterNode", type = RubyNode.class) - @NodeChild(value = "replacementNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "encodingConverter", type = RubyNode.class) + @NodeChild(value = "replacement", type = RubyBaseNodeWithExecute.class) public abstract static class EncodingConverterSetReplacementNode extends CoreMethodNode { - @CreateCast("replacementNode") + @CreateCast("replacement") protected ToStrNode coerceReplacementToString(RubyBaseNodeWithExecute replacement) { return ToStrNodeGen.create(replacement); } - abstract RubyNode getEncodingConverterNode(); - - abstract RubyBaseNodeWithExecute getReplacementNode(); - - public static EncodingConverterSetReplacementNode create(RubyNode encodingConverter, - RubyBaseNodeWithExecute replacement) { - return EncodingConverterNodesFactory.EncodingConverterSetReplacementNodeFactory.create(encodingConverter, - replacement); - } - @Specialization(guards = "libReplacement.isRubyString(replacement)", limit = "1") protected Object setReplacement(RubyEncodingConverter encodingConverter, Object replacement, @Cached BranchProfile errorProfile, @@ -489,18 +479,6 @@ private int setReplacement(EConv ec, byte[] bytes, int offset, int len, byte[] e return ec.setReplacement(bytes, offset, len, encodingName); } - private RubyBaseNodeWithExecute getReplacementNodeBeforeCasting() { - return ((ToStrNode) getReplacementNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getEncodingConverterNode().cloneUninitialized(), - getReplacementNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } } diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java index c71c705ff2f4..a0563406cfd4 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java @@ -1249,19 +1249,11 @@ protected RubyMethod method(Frame callerFrame, Object self, Object[] rubyArgs, R } @CoreMethod(names = "methods", optional = 1) - @NodeChild(value = "objectNode", type = RubyNode.class) - @NodeChild(value = "regularNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "object", type = RubyNode.class) + @NodeChild(value = "regular", type = RubyBaseNodeWithExecute.class) public abstract static class MethodsNode extends CoreMethodNode { - public static MethodsNode create(RubyNode object, RubyBaseNodeWithExecute regular) { - return KernelNodesFactory.MethodsNodeFactory.create(object, regular); - } - - abstract RubyNode getObjectNode(); - - abstract RubyBaseNodeWithExecute getRegularNode(); - - @CreateCast("regularNode") + @CreateCast("regular") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute regular) { return BooleanCastWithDefaultNode.create(true, regular); } @@ -1284,18 +1276,6 @@ protected RubyArray methodsSingleton(VirtualFrame frame, Object self, boolean re return singletonMethodsNode.executeSingletonMethods(frame, self, false); } - private RubyBaseNodeWithExecute getRegularNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getRegularNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getObjectNode().cloneUninitialized(), - getRegularNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "nil?", needsSelf = false) @@ -1328,21 +1308,13 @@ private void print(Object inspected) { } @CoreMethod(names = "private_methods", optional = 1) - @NodeChild(value = "objectNode", type = RubyNode.class) - @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "object", type = RubyNode.class) + @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) public abstract static class PrivateMethodsNode extends CoreMethodNode { @Child private MetaClassNode metaClassNode = MetaClassNode.create(); - public static PrivateMethodsNode create(RubyNode object, RubyBaseNodeWithExecute includeAncestors) { - return KernelNodesFactory.PrivateMethodsNodeFactory.create(object, includeAncestors); - } - - abstract RubyNode getObjectNode(); - - abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); - - @CreateCast("includeAncestorsNode") + @CreateCast("includeAncestors") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -1358,18 +1330,6 @@ protected RubyArray privateMethods(Object self, boolean includeAncestors) { return createArray(objects); } - private RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getObjectNode().cloneUninitialized(), - getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "proc", isModuleFunction = true, needsBlock = true, split = Split.HEURISTIC) @@ -1384,21 +1344,13 @@ protected RubyProc proc(VirtualFrame frame, Object maybeBlock, } @CoreMethod(names = "protected_methods", optional = 1) - @NodeChild(value = "objectNode", type = RubyNode.class) - @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "object", type = RubyNode.class) + @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) public abstract static class ProtectedMethodsNode extends CoreMethodNode { @Child private MetaClassNode metaClassNode = MetaClassNode.create(); - public static ProtectedMethodsNode create(RubyNode object, RubyBaseNodeWithExecute includeAncestors) { - return KernelNodesFactory.ProtectedMethodsNodeFactory.create(object, includeAncestors); - } - - abstract RubyNode getObjectNode(); - - abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); - - @CreateCast("includeAncestorsNode") + @CreateCast("includeAncestors") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -1414,18 +1366,6 @@ protected RubyArray protectedMethods(Object self, boolean includeAncestors) { return createArray(objects); } - private RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getObjectNode().cloneUninitialized(), - getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @GenerateUncached @@ -1444,21 +1384,13 @@ protected RubyMethod method(Frame callerFrame, Object self, Object[] rubyArgs, R } @CoreMethod(names = "public_methods", optional = 1) - @NodeChild(value = "objectNode", type = RubyNode.class) - @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "object", type = RubyNode.class) + @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) public abstract static class PublicMethodsNode extends CoreMethodNode { @Child private MetaClassNode metaClassNode = MetaClassNode.create(); - public static PublicMethodsNode create(RubyNode object, RubyBaseNodeWithExecute includeAncestors) { - return KernelNodesFactory.PublicMethodsNodeFactory.create(object, includeAncestors); - } - - abstract RubyNode getObjectNode(); - - abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); - - @CreateCast("includeAncestorsNode") + @CreateCast("includeAncestors") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -1474,18 +1406,6 @@ protected RubyArray publicMethods(Object self, boolean includeAncestors) { return createArray(objects); } - private RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getObjectNode().cloneUninitialized(), - getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @GenerateUncached @@ -1601,21 +1521,13 @@ protected RubyClass singletonClass(Object self) { } @CoreMethod(names = "singleton_method", required = 1) - @NodeChild(value = "objectNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "object", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) public abstract static class SingletonMethodNode extends CoreMethodNode { @Child private MetaClassNode metaClassNode = MetaClassNode.create(); - public static SingletonMethodNode create(RubyNode object, RubyBaseNodeWithExecute name) { - return KernelNodesFactory.SingletonMethodNodeFactory.create(object, name); - } - - abstract RubyNode getObjectNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -1646,41 +1558,20 @@ protected RubyMethod singletonMethod(Object self, String name, coreExceptions().nameErrorUndefinedSingletonMethod(name, self, this)); } - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getObjectNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "singleton_methods", optional = 1) - @NodeChild(value = "objectNode", type = RubyNode.class) - @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "object", type = RubyNode.class) + @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) public abstract static class SingletonMethodsNode extends CoreMethodNode { public static SingletonMethodsNode create() { return SingletonMethodsNodeFactory.create(null, null); } - public static SingletonMethodsNode create(RubyNode object, RubyBaseNodeWithExecute includeAncestors) { - return SingletonMethodsNodeFactory.create(object, includeAncestors); - } - public abstract RubyArray executeSingletonMethods(VirtualFrame frame, Object self, boolean includeAncestors); - - abstract RubyNode getObjectNode(); - - abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); - - @CreateCast("includeAncestorsNode") + @CreateCast("includeAncestors") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -1701,18 +1592,6 @@ protected RubyArray singletonMethods(Object self, boolean includeAncestors, return createArray(objects); } - private RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getObjectNode().cloneUninitialized(), - getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @Primitive(name = "singleton_methods?") @@ -1778,8 +1657,8 @@ public static long sleepFor(RubyContext context, RubyThread thread, long duratio @CoreMethod(names = { "format", "sprintf" }, isModuleFunction = true, rest = true, required = 1) @ReportPolymorphism - @NodeChild(value = "formatNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "argumentsNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "format", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "arguments", type = RubyBaseNodeWithExecute.class) public abstract static class SprintfNode extends CoreMethodNode { @Child private TruffleString.FromByteArrayNode fromByteArrayNode; @@ -1789,15 +1668,7 @@ public abstract static class SprintfNode extends CoreMethodNode { private final BranchProfile exceptionProfile = BranchProfile.create(); private final ConditionProfile resizeProfile = ConditionProfile.create(); - public static SprintfNode create(RubyBaseNodeWithExecute format, RubyBaseNodeWithExecute arguments) { - return KernelNodesFactory.SprintfNodeFactory.create(format, arguments); - } - - abstract RubyBaseNodeWithExecute getFormatNode(); - - abstract RubyBaseNodeWithExecute getArgumentsNode(); - - @CreateCast("formatNode") + @CreateCast("format") protected ToStrNode coerceFormatToString(RubyBaseNodeWithExecute format) { return ToStrNodeGen.create(format); } @@ -1880,18 +1751,6 @@ protected boolean isDebug(VirtualFrame frame) { return readDebugGlobalNode.execute(frame); } - private RubyBaseNodeWithExecute getFormatNodeBeforeCasting() { - return ((ToStrNode) getFormatNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getFormatNodeBeforeCasting().cloneUninitialized(), - getArgumentsNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "global_variables", isModuleFunction = true) diff --git a/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java b/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java index bde06a4f5279..324cbfd25d90 100644 --- a/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java @@ -84,24 +84,16 @@ protected Object atExit(boolean always, RubyProc block) { } } + @NodeChild(value = "file", type = RubyNode.class) + @NodeChild(value = "wrap", type = RubyBaseNodeWithExecute.class) @CoreMethod(names = "load", onSingleton = true, required = 1, optional = 1) - @NodeChild(value = "fileNode", type = RubyNode.class) - @NodeChild(value = "wrapNode", type = RubyBaseNodeWithExecute.class) public abstract static class LoadNode extends CoreMethodNode { - @CreateCast("wrapNode") + @CreateCast("wrap") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(false, inherit); } - abstract RubyNode getFileNode(); - - abstract RubyBaseNodeWithExecute getWrapNode(); - - public static LoadNode create(RubyNode file, RubyBaseNodeWithExecute wrap) { - return TruffleKernelNodesFactory.LoadNodeFactory.create(file, wrap); - } - @TruffleBoundary @Specialization(guards = "strings.isRubyString(file)", limit = "1") protected boolean load(Object file, boolean wrap, @@ -158,18 +150,6 @@ protected boolean load(Object file, boolean wrap, return true; } - private RubyBaseNodeWithExecute getWrapNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getWrapNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getFileNode().cloneUninitialized(), - getWrapNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } // Only used internally with a constant literal name, does not trigger hooks diff --git a/src/main/java/org/truffleruby/core/module/ModuleNodes.java b/src/main/java/org/truffleruby/core/module/ModuleNodes.java index 507ac08b6a65..4ed72c487a21 100644 --- a/src/main/java/org/truffleruby/core/module/ModuleNodes.java +++ b/src/main/java/org/truffleruby/core/module/ModuleNodes.java @@ -47,7 +47,6 @@ import org.truffleruby.core.cast.BooleanCastWithDefaultNode; import org.truffleruby.core.cast.NameToJavaStringNode; import org.truffleruby.core.cast.ToIntNode; -import org.truffleruby.core.cast.ToPathNode; import org.truffleruby.core.cast.ToPathNodeGen; import org.truffleruby.core.cast.ToStrNode; import org.truffleruby.core.cast.ToStringOrSymbolNode; @@ -327,28 +326,17 @@ protected Object compareOther(RubyModule self, Object other) { } @CoreMethod(names = "alias_method", required = 2, raiseIfFrozenSelf = true, split = Split.NEVER) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "newNameNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "oldNameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "newName", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "oldName", type = RubyBaseNodeWithExecute.class) public abstract static class AliasMethodNode extends CoreMethodNode { - public static AliasMethodNode create(RubyNode module, RubyBaseNodeWithExecute newName, - RubyBaseNodeWithExecute oldName) { - return ModuleNodesFactory.AliasMethodNodeFactory.create(module, newName, oldName); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNewNameNode(); - - abstract RubyBaseNodeWithExecute getOldNameNode(); - - @CreateCast("newNameNode") + @CreateCast("newName") protected RubyBaseNodeWithExecute coerceNewNameToSymbol(RubyBaseNodeWithExecute newName) { return ToSymbolNode.create(newName); } - @CreateCast("oldNameNode") + @CreateCast("oldName") protected RubyBaseNodeWithExecute coerceOldNameToSymbol(RubyBaseNodeWithExecute oldName) { return ToSymbolNode.create(oldName); } @@ -372,23 +360,6 @@ protected RubySymbol aliasMethod(RubyModule module, RubySymbol newName, RubySymb return newName; } - private RubyBaseNodeWithExecute getNewNameNodeBeforeCasting() { - return ((ToSymbolNode) getNewNameNode()).getValueNode(); - } - - private RubyBaseNodeWithExecute getOldNameNodeBeforeCasting() { - return ((ToSymbolNode) getOldNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNewNameNodeBeforeCasting().cloneUninitialized(), - getOldNameNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "ancestors") @@ -614,28 +585,17 @@ protected Object attrWriter(Frame callerFrame, RubyModule module, Object[] rubyA } @CoreMethod(names = "autoload", required = 2) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "filenameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "filename", type = RubyBaseNodeWithExecute.class) public abstract static class AutoloadNode extends CoreMethodNode { - public static AutoloadNode create(RubyNode module, RubyBaseNodeWithExecute name, - RubyBaseNodeWithExecute filename) { - return ModuleNodesFactory.AutoloadNodeFactory.create(module, name, filename); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - abstract RubyBaseNodeWithExecute getFilenameNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceNameToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } - @CreateCast("filenameNode") + @CreateCast("filename") protected RubyBaseNodeWithExecute coerceFilenameToPath(RubyBaseNodeWithExecute filename) { return ToPathNodeGen.create(filename); } @@ -662,49 +622,20 @@ protected Object autoload(RubyModule module, String name, Object filename, module.fields.setAutoloadConstant(getContext(), this, name, filename, javaStringFilename); return nil; } - - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - private RubyBaseNodeWithExecute getFilenameNodeBeforeCasting() { - return ((ToPathNode) getFilenameNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized(), - getFilenameNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "autoload?", required = 1, optional = 1) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) public abstract static class IsAutoloadNode extends CoreMethodNode { - public static IsAutoloadNode create(RubyNode module, RubyBaseNodeWithExecute name, - RubyBaseNodeWithExecute inherit) { - return ModuleNodesFactory.IsAutoloadNodeFactory.create(module, name, inherit); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - abstract RubyBaseNodeWithExecute getInheritNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } - @CreateCast("inheritNode") + @CreateCast("inherit") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -727,24 +658,6 @@ protected Object isAutoload(RubyModule module, String name, boolean inherit) { return nil; } } - - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - private RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized(), - getInheritNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @GenerateUncached @@ -879,19 +792,11 @@ protected Object classExec(ArgumentsDescriptor descriptor, RubyModule self, Obje } @CoreMethod(names = "class_variable_defined?", required = 1) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) public abstract static class ClassVariableDefinedNode extends CoreMethodNode { - public static ClassVariableDefinedNode create(RubyNode module, RubyBaseNodeWithExecute name) { - return ModuleNodesFactory.ClassVariableDefinedNodeFactory.create(module, name); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -904,34 +809,14 @@ protected boolean isClassVariableDefinedString(RubyModule module, String name, return lookupClassVariableNode.execute(module, name) != null; } - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "class_variable_get", required = 1) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) public abstract static class ClassVariableGetNode extends CoreMethodNode { - public static ClassVariableGetNode create(RubyNode module, RubyBaseNodeWithExecute name) { - return ModuleNodesFactory.ClassVariableGetNodeFactory.create(module, name); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -953,37 +838,15 @@ protected Object getClassVariable(RubyModule module, String name, } } - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "class_variable_set", required = 2, raiseIfFrozenSelf = true) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "valueNode", type = RubyNode.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "value", type = RubyNode.class) public abstract static class ClassVariableSetNode extends CoreMethodNode { - public static ClassVariableSetNode create(RubyNode module, RubyBaseNodeWithExecute name, RubyNode value) { - return ModuleNodesFactory.ClassVariableSetNodeFactory.create(module, name, value); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - abstract RubyNode getValueNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -997,35 +860,14 @@ protected Object setClassVariable(RubyModule module, String name, Object value, return value; } - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized(), - getValueNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "class_variables", optional = 1) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) public abstract static class ClassVariablesNode extends CoreMethodNode { - public static ClassVariablesNode create(RubyNode module, RubyBaseNodeWithExecute inherit) { - return ModuleNodesFactory.ClassVariablesNodeFactory.create(module, inherit); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getInheritNode(); - - @CreateCast("inheritNode") + @CreateCast("inherit") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -1045,35 +887,14 @@ protected RubyArray getClassVariables(RubyModule module, boolean inherit) { return createArray(variables.toArray()); } - - private RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getInheritNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "constants", optional = 1) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) public abstract static class ConstantsNode extends CoreMethodNode { - public static ConstantsNode create(RubyNode module, RubyBaseNodeWithExecute inherit) { - return ModuleNodesFactory.ConstantsNodeFactory.create(module, inherit); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getInheritNode(); - - @CreateCast("inheritNode") + @CreateCast("inherit") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -1100,18 +921,6 @@ protected RubyArray constants(RubyModule module, boolean inherit) { return createArray(constantsArray.toArray()); } - private RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getInheritNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @Primitive(name = "module_const_defined?") @@ -1334,19 +1143,11 @@ public RubyNode cloneUninitialized() { } @CoreMethod(names = "const_missing", required = 1) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) public abstract static class ConstMissingNode extends CoreMethodNode { - public static ConstMissingNode create(RubyNode module, RubyBaseNodeWithExecute name) { - return ModuleNodesFactory.ConstMissingNodeFactory.create(module, name); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -1356,45 +1157,22 @@ protected Object constMissing(RubyModule module, String name) { throw new RaiseException(getContext(), coreExceptions().nameErrorUninitializedConstant(module, name, this)); } - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "const_source_location", required = 1, optional = 1) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) public abstract static class ConstSourceLocationNode extends CoreMethodNode { @Child private TruffleString.FromJavaStringNode fromJavaStringNode = TruffleString.FromJavaStringNode.create(); - public static ConstSourceLocationNode create(RubyNode module, RubyBaseNodeWithExecute name, - RubyBaseNodeWithExecute inherit) { - return ModuleNodesFactory.ConstSourceLocationNodeFactory.create(module, name, inherit); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - abstract RubyBaseNodeWithExecute getInheritNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToStringOrSymbol(RubyBaseNodeWithExecute name) { return ToStringOrSymbolNodeGen.create(name); } - @CreateCast("inheritNode") + @CreateCast("inherit") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -1435,48 +1213,21 @@ private Object getLocation(ConstantLookupResult lookupResult) { } } - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((ToStringOrSymbolNode) getNameNode()).getChildNode(); - } - - private RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized(), - getInheritNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "const_set", required = 2) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "valueNode", type = RubyNode.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "value", type = RubyNode.class) public abstract static class ConstSetNode extends CoreMethodNode { - @Child private ConstSetUncheckedNode uncheckedSetNode = ConstSetUncheckedNode.create(); - public static ConstSetNode create() { return ConstSetNodeFactory.create(null, null, null); } - public static ConstSetNode create(RubyNode module, RubyBaseNodeWithExecute name, RubyNode value) { - return ModuleNodesFactory.ConstSetNodeFactory.create(module, name, value); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - abstract RubyNode getValueNode(); + @Child private ConstSetUncheckedNode uncheckedSetNode = ConstSetUncheckedNode.create(); - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -1493,20 +1244,6 @@ protected Object setConstant(RubyModule module, String name, Object value) { return uncheckedSetNode.execute(module, name, value); } - - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized(), - getValueNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @NodeChild(value = "module", type = RubyNode.class) @@ -1880,28 +1617,17 @@ protected RubyArray includedModules(RubyModule module) { } @CoreMethod(names = "method_defined?", required = 1, optional = 1) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) public abstract static class MethodDefinedNode extends CoreMethodNode { - public static MethodDefinedNode create(RubyNode module, RubyBaseNodeWithExecute name, - RubyBaseNodeWithExecute inherit) { - return ModuleNodesFactory.MethodDefinedNodeFactory.create(module, name, inherit); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - abstract RubyBaseNodeWithExecute getInheritNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } - @CreateCast("inheritNode") + @CreateCast("inherit") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -1919,23 +1645,6 @@ protected boolean isMethodDefined(RubyModule module, String name, boolean inheri return method != null && !method.isUndefined() && !(method.getVisibility() == Visibility.PRIVATE); } - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - private RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized(), - getInheritNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @GenerateUncached @@ -2125,19 +1834,11 @@ protected RubyModule privateClassMethod(VirtualFrame frame, RubyModule module, O } @CoreMethod(names = "public_instance_method", required = 1) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) public abstract static class PublicInstanceMethodNode extends CoreMethodNode { - public static PublicInstanceMethodNode create(RubyNode module, RubyBaseNodeWithExecute name) { - return ModuleNodesFactory.PublicInstanceMethodNodeFactory.create(module, name); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -2165,22 +1866,10 @@ protected RubyUnboundMethod publicInstanceMethod(RubyModule module, String name, return instance; } - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) protected abstract static class AbstractInstanceMethodsNode extends CoreMethodNode { final Visibility visibility; @@ -2189,11 +1878,7 @@ public AbstractInstanceMethodsNode(Visibility visibility) { this.visibility = visibility; } - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); - - @CreateCast("includeAncestorsNode") + @CreateCast("includeAncestors") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -2207,78 +1892,39 @@ protected RubyArray getInstanceMethods(RubyModule module, boolean includeAncesto return createArray(objects); } - protected RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); - } - } @CoreMethod(names = "public_instance_methods", optional = 1) public abstract static class PublicInstanceMethodsNode extends AbstractInstanceMethodsNode { - public static PublicInstanceMethodsNode create(RubyNode module, RubyBaseNodeWithExecute includeAncestors) { - return ModuleNodesFactory.PublicInstanceMethodsNodeFactory.create(module, includeAncestors); - } - public PublicInstanceMethodsNode() { super(Visibility.PUBLIC); } - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "protected_instance_methods", optional = 1) public abstract static class ProtectedInstanceMethodsNode extends AbstractInstanceMethodsNode { - public static ProtectedInstanceMethodsNode create(RubyNode module, RubyBaseNodeWithExecute includeAncestors) { - return ModuleNodesFactory.ProtectedInstanceMethodsNodeFactory.create(module, includeAncestors); - } - public ProtectedInstanceMethodsNode() { super(Visibility.PROTECTED); } - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "private_instance_methods", optional = 1) public abstract static class PrivateInstanceMethodsNode extends AbstractInstanceMethodsNode { - public static PrivateInstanceMethodsNode create(RubyNode module, RubyBaseNodeWithExecute includeAncestors) { - return ModuleNodesFactory.PrivateInstanceMethodsNodeFactory.create(module, includeAncestors); - } - public PrivateInstanceMethodsNode() { super(Visibility.PRIVATE); } - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "inheritNode", type = RubyBaseNodeWithExecute.class) + + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "inherit", type = RubyBaseNodeWithExecute.class) protected abstract static class AbstractMethodDefinedNode extends CoreMethodNode { final Visibility visibility; @@ -2287,18 +1933,12 @@ public AbstractMethodDefinedNode(Visibility visibility) { this.visibility = visibility; } - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - abstract RubyBaseNodeWithExecute getInheritNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } - @CreateCast("inheritNode") + @CreateCast("inherit") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute inherit) { return BooleanCastWithDefaultNode.create(true, inherit); } @@ -2319,98 +1959,35 @@ protected boolean isMethodDefinedDontInherit(RubyModule module, String name, boo return method != null && !method.isUndefined() && !method.isUnimplemented() && method.getVisibility() == visibility; } - - protected RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - protected RubyBaseNodeWithExecute getInheritNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getInheritNode()).getValueNode(); - } - } @CoreMethod(names = "public_method_defined?", required = 1, optional = 1) public abstract static class PublicMethodDefinedNode extends AbstractMethodDefinedNode { - - public static PublicMethodDefinedNode create(RubyNode module, RubyBaseNodeWithExecute name, - RubyBaseNodeWithExecute inherit) { - return ModuleNodesFactory.PublicMethodDefinedNodeFactory.create(module, name, inherit); - } - public PublicMethodDefinedNode() { super(Visibility.PUBLIC); } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized(), - getInheritNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "protected_method_defined?", required = 1, optional = 1) public abstract static class ProtectedMethodDefinedNode extends AbstractMethodDefinedNode { - - public static ProtectedMethodDefinedNode create(RubyNode module, RubyBaseNodeWithExecute name, - RubyBaseNodeWithExecute inherit) { - return ModuleNodesFactory.ProtectedMethodDefinedNodeFactory.create(module, name, inherit); - } - public ProtectedMethodDefinedNode() { super(Visibility.PROTECTED); } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized(), - getInheritNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "private_method_defined?", required = 1, optional = 1) public abstract static class PrivateMethodDefinedNode extends AbstractMethodDefinedNode { - public static PrivateMethodDefinedNode create(RubyNode module, RubyBaseNodeWithExecute name, - RubyBaseNodeWithExecute inherit) { - return ModuleNodesFactory.PrivateMethodDefinedNodeFactory.create(module, name, inherit); - } - public PrivateMethodDefinedNode() { super(Visibility.PRIVATE); } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized(), - getInheritNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } } @CoreMethod(names = "instance_methods", optional = 1) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "includeAncestorsNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "includeAncestors", type = RubyBaseNodeWithExecute.class) public abstract static class InstanceMethodsNode extends CoreMethodNode { - public static InstanceMethodsNode create(RubyNode module, RubyBaseNodeWithExecute includeAncestors) { - return ModuleNodesFactory.InstanceMethodsNodeFactory.create(module, includeAncestors); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getIncludeAncestorsNode(); - - @CreateCast("includeAncestorsNode") + @CreateCast("includeAncestors") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute includeAncestors) { return BooleanCastWithDefaultNode.create(true, includeAncestors); } @@ -2423,19 +2000,6 @@ protected RubyArray instanceMethods(RubyModule module, boolean includeAncestors) .toArray(); return createArray(objects); } - - protected RubyBaseNodeWithExecute getIncludeAncestorsNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getIncludeAncestorsNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getIncludeAncestorsNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @GenerateUncached @@ -2539,19 +2103,11 @@ protected RubyModule methods(Frame callerFrame, RubyModule module, Object[] ruby } @CoreMethod(names = "remove_class_variable", required = 1) - @NodeChild(value = "moduleNode", type = RubyNode.class) - @NodeChild(value = "nameNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "module", type = RubyNode.class) + @NodeChild(value = "name", type = RubyBaseNodeWithExecute.class) public abstract static class RemoveClassVariableNode extends CoreMethodNode { - public static RemoveClassVariableNode create(RubyNode module, RubyBaseNodeWithExecute name) { - return ModuleNodesFactory.RemoveClassVariableNodeFactory.create(module, name); - } - - abstract RubyNode getModuleNode(); - - abstract RubyBaseNodeWithExecute getNameNode(); - - @CreateCast("nameNode") + @CreateCast("name") protected RubyBaseNodeWithExecute coerceToString(RubyBaseNodeWithExecute name) { return NameToJavaStringNode.create(name); } @@ -2563,18 +2119,6 @@ protected Object removeClassVariableString(RubyModule module, String name, return ModuleOperations.removeClassVariable(module.fields, getContext(), this, name); } - private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { - return ((NameToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getModuleNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @Primitive(name = "module_remove_const") diff --git a/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java b/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java index f89e7cf04d01..c5395fbd5bd9 100644 --- a/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java +++ b/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java @@ -36,7 +36,7 @@ public static FixnumLowerNode create(RubyBaseNodeWithExecute value) { public abstract Object executeLower(Object value); - public abstract RubyBaseNodeWithExecute getValueNode(); + abstract RubyBaseNodeWithExecute getValueNode(); @Specialization protected int lower(int value) { diff --git a/src/main/java/org/truffleruby/core/queue/QueueNodes.java b/src/main/java/org/truffleruby/core/queue/QueueNodes.java index f516725fce8d..07abd8d1a80e 100644 --- a/src/main/java/org/truffleruby/core/queue/QueueNodes.java +++ b/src/main/java/org/truffleruby/core/queue/QueueNodes.java @@ -66,23 +66,15 @@ protected RubyQueue push(RubyQueue self, final Object value) { } @CoreMethod(names = { "pop", "shift", "deq" }, optional = 1) - @NodeChild(value = "queueNode", type = RubyNode.class) - @NodeChild(value = "nonBlockingNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "queue", type = RubyNode.class) + @NodeChild(value = "nonBlocking", type = RubyBaseNodeWithExecute.class) public abstract static class PopNode extends CoreMethodNode { - @CreateCast("nonBlockingNode") + @CreateCast("nonBlocking") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute nonBlocking) { return BooleanCastWithDefaultNode.create(false, nonBlocking); } - abstract RubyNode getQueueNode(); - - abstract RubyBaseNodeWithExecute getNonBlockingNode(); - - public static PopNode create(RubyNode queue, RubyBaseNodeWithExecute nonBlocking) { - return QueueNodesFactory.PopNodeFactory.create(queue, nonBlocking); - } - @Specialization(guards = "!nonBlocking") protected Object popBlocking(RubyQueue self, boolean nonBlocking, @Cached BranchProfile closedProfile) { @@ -118,18 +110,6 @@ protected Object popNonBlock(RubyQueue self, boolean nonBlocking, } } - private RubyBaseNodeWithExecute getNonBlockingNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getNonBlockingNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getQueueNode().cloneUninitialized(), - getNonBlockingNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @NonStandard diff --git a/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java b/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java index 3ca0215a9ece..2301bd5a20fc 100644 --- a/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java +++ b/src/main/java/org/truffleruby/core/queue/SizedQueueNodes.java @@ -98,28 +98,18 @@ protected int max(RubySizedQueue self) { } @CoreMethod(names = { "push", "<<", "enq" }, required = 1, optional = 1) - @NodeChild(value = "queueNode", type = RubyNode.class) - @NodeChild(value = "valueNode", type = RubyNode.class) - @NodeChild(value = "nonBlockingNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "queue", type = RubyNode.class) + @NodeChild(value = "value", type = RubyNode.class) + @NodeChild(value = "nonBlocking", type = RubyBaseNodeWithExecute.class) public abstract static class PushNode extends CoreMethodNode { @Child PropagateSharingNode propagateSharingNode = PropagateSharingNode.create(); - @CreateCast("nonBlockingNode") + @CreateCast("nonBlocking") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute nonBlocking) { return BooleanCastWithDefaultNode.create(false, nonBlocking); } - abstract RubyNode getQueueNode(); - - abstract RubyNode getValueNode(); - - abstract RubyBaseNodeWithExecute getNonBlockingNode(); - - public static PushNode create(RubyNode queue, RubyNode value, RubyBaseNodeWithExecute nonBlocking) { - return SizedQueueNodesFactory.PushNodeFactory.create(queue, value, nonBlocking); - } - @Specialization(guards = "!nonBlocking") protected RubySizedQueue pushBlocking(RubySizedQueue self, final Object value, boolean nonBlocking) { final SizedQueue queue = self.queue; @@ -162,39 +152,18 @@ protected RubySizedQueue pushNonBlock(RubySizedQueue self, final Object value, b return self; } - private RubyBaseNodeWithExecute getNonBlockingNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getNonBlockingNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getQueueNode().cloneUninitialized(), - getValueNode().cloneUninitialized(), - getNonBlockingNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = { "pop", "shift", "deq" }, optional = 1) - @NodeChild(value = "queueNode", type = RubyNode.class) - @NodeChild(value = "nonBlockingNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "queue", type = RubyNode.class) + @NodeChild(value = "nonBlocking", type = RubyBaseNodeWithExecute.class) public abstract static class PopNode extends CoreMethodNode { - @CreateCast("nonBlockingNode") + @CreateCast("nonBlocking") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute nonBlocking) { return BooleanCastWithDefaultNode.create(false, nonBlocking); } - abstract RubyNode getQueueNode(); - - abstract RubyBaseNodeWithExecute getNonBlockingNode(); - - public static PopNode create(RubyNode queue, RubyBaseNodeWithExecute nonBlocking) { - return SizedQueueNodesFactory.PopNodeFactory.create(queue, nonBlocking); - } - @Specialization(guards = "!nonBlocking") protected Object popBlocking(RubySizedQueue self, boolean nonBlocking) { final SizedQueue queue = self.queue; @@ -228,18 +197,6 @@ protected Object popNonBlock(RubySizedQueue self, boolean nonBlocking, return value; } - private RubyBaseNodeWithExecute getNonBlockingNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getNonBlockingNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getQueueNode().cloneUninitialized(), - getNonBlockingNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "empty?") diff --git a/src/main/java/org/truffleruby/core/range/RangeNodes.java b/src/main/java/org/truffleruby/core/range/RangeNodes.java index f236e652fb7d..83c495779be1 100644 --- a/src/main/java/org/truffleruby/core/range/RangeNodes.java +++ b/src/main/java/org/truffleruby/core/range/RangeNodes.java @@ -38,6 +38,7 @@ import org.truffleruby.language.dispatch.DispatchNode; import org.truffleruby.language.objects.AllocationTracing; import org.truffleruby.language.yield.CallBlockNode; +import org.truffleruby.parser.BodyTranslator; import com.oracle.truffle.api.CompilerDirectives; import com.oracle.truffle.api.dsl.Cached; @@ -437,6 +438,7 @@ private RubyBaseNodeWithExecute getExcludeEndNodeBeforeCasting() { return ((BooleanCastWithDefaultNode) getExcludeEndNode()).getValueNode(); } + /** Needed because it is used by {@link BodyTranslator#visitDotNode} */ @Override public RubyNode cloneUninitialized() { var copy = create( diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java index ee4af6eb5bce..1df2577f0516 100644 --- a/src/main/java/org/truffleruby/core/string/StringNodes.java +++ b/src/main/java/org/truffleruby/core/string/StringNodes.java @@ -220,65 +220,36 @@ public RubyNode cloneUninitialized() { } @CoreMethod(names = "+", required = 1) - @NodeChild(value = "stringNode", type = RubyNode.class) - @NodeChild(value = "otherNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "string", type = RubyNode.class) + @NodeChild(value = "other", type = RubyBaseNodeWithExecute.class) @ImportStatic(StringGuards.class) public abstract static class AddNode extends CoreMethodNode { - @CreateCast("otherNode") + @CreateCast("other") protected ToStrNode coerceOtherToString(RubyBaseNodeWithExecute other) { return ToStrNodeGen.create(other); } - abstract RubyNode getStringNode(); - - abstract RubyBaseNodeWithExecute getOtherNode(); - - public static AddNode create(RubyNode string, RubyBaseNodeWithExecute other) { - return StringNodesFactory.AddNodeFactory.create(string, other); - } - @Specialization protected RubyString add(Object string, Object other, @Cached StringHelperNodes.StringAppendNode stringAppendNode) { return stringAppendNode.executeStringAppend(string, other); } - - private RubyBaseNodeWithExecute getOtherNodeBeforeCasting() { - return ((ToStrNode) getOtherNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getStringNode().cloneUninitialized(), - getOtherNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "*", required = 1) - @NodeChild(value = "stringNode", type = RubyNode.class) - @NodeChild(value = "timesNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "string", type = RubyNode.class) + @NodeChild(value = "times", type = RubyBaseNodeWithExecute.class) @ImportStatic(StringGuards.class) public abstract static class MulNode extends CoreMethodNode { - @CreateCast("timesNode") + @CreateCast("times") protected RubyBaseNodeWithExecute coerceToInteger(RubyBaseNodeWithExecute times) { // Not ToIntNode, because this works with empty strings, and must throw a different error // for long values that don't fit in an int. return FixnumLowerNode.create(ToLongNode.create(times)); } - abstract RubyNode getStringNode(); - - abstract RubyBaseNodeWithExecute getTimesNode(); - - public static MulNode create(RubyNode string, RubyBaseNodeWithExecute times) { - return StringNodesFactory.MulNodeFactory.create(string, times); - } - @Specialization(guards = "times == 0") protected RubyString multiplyZero(Object string, int times, @Cached RubyStringLibrary libString) { @@ -327,19 +298,6 @@ private RaiseException tooBig() { // In TruffleRuby, strings have max length Integer.MAX_VALUE. return new RaiseException(getContext(), coreExceptions().argumentError("argument too big", this)); } - - private RubyBaseNodeWithExecute getTimesNodeBeforeCasting() { - var toLongNode = ((FixnumLowerNode) getTimesNode()).getValueNode(); - return ((ToLongNode) toLongNode).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getStringNode().cloneUninitialized(), - getTimesNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } } @CoreMethod(names = { "==", "===", "eql?" }, required = 1) @@ -2352,35 +2310,25 @@ protected RubyString undumpNonAsciiCompatible(Object string, } @CoreMethod(names = "setbyte", required = 2, raiseIfNotMutableSelf = true, lowerFixnum = { 1, 2 }) - @NodeChild(value = "stringNode", type = RubyNode.class) - @NodeChild(value = "indexNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "valueNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "string", type = RubyNode.class) + @NodeChild(value = "index", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "value", type = RubyBaseNodeWithExecute.class) + @ImportStatic(StringGuards.class) public abstract static class SetByteNode extends CoreMethodNode { @Child private StringHelperNodes.CheckIndexNode checkIndexNode = StringHelperNodesFactory.CheckIndexNodeGen .create(); - @CreateCast("indexNode") + @CreateCast("index") protected ToIntNode coerceIndexToInt(RubyBaseNodeWithExecute index) { return ToIntNode.create(index); } - @CreateCast("valueNode") + @CreateCast("value") protected ToIntNode coerceValueToInt(RubyBaseNodeWithExecute value) { return ToIntNode.create(value); } - abstract RubyNode getStringNode(); - - abstract RubyBaseNodeWithExecute getIndexNode(); - - abstract RubyBaseNodeWithExecute getValueNode(); - - public static SetByteNode create(RubyNode string, RubyBaseNodeWithExecute index, - RubyBaseNodeWithExecute value) { - return StringNodesFactory.SetByteNodeFactory.create(string, index, value); - } - @Specialization(guards = "tstring.isMutable()") protected int mutable(RubyString string, int index, int value, @Cached RubyStringLibrary libString, @@ -2407,24 +2355,6 @@ protected int immutable(RubyString string, int index, int value, string.setTString(mutableTString); return value; } - - private RubyBaseNodeWithExecute getIndexNodeBeforeCasting() { - return ((ToIntNode) getIndexNode()).getChildNode(); - } - - private RubyBaseNodeWithExecute getValueNodeBeforeCasting() { - return ((ToIntNode) getValueNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getStringNode().cloneUninitialized(), - getIndexNodeBeforeCasting().cloneUninitialized(), - getValueNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = { "size", "length" }) @@ -2813,35 +2743,25 @@ public static boolean reverseIsEqualToSelf(AbstractTruffleString tstring, RubyEn } @CoreMethod(names = "tr!", required = 2, raiseIfNotMutableSelf = true) - @NodeChild(value = "selfNode", type = RubyNode.class) - @NodeChild(value = "fromStrNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "toStrNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "self", type = RubyNode.class) + @NodeChild(value = "fromStr", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "toStr", type = RubyBaseNodeWithExecute.class) @ImportStatic(StringGuards.class) public abstract static class TrBangNode extends CoreMethodNode { @Child private CheckEncodingNode checkEncodingNode; @Child private DeleteBangNode deleteBangNode; - @CreateCast("fromStrNode") + @CreateCast("fromStr") protected ToStrNode coerceFromStrToString(RubyBaseNodeWithExecute fromStr) { return ToStrNodeGen.create(fromStr); } - @CreateCast("toStrNode") + @CreateCast("toStr") protected ToStrNode coerceToStrToString(RubyBaseNodeWithExecute toStr) { return ToStrNodeGen.create(toStr); } - abstract RubyNode getSelfNode(); - - abstract RubyBaseNodeWithExecute getFromStrNode(); - - abstract RubyBaseNodeWithExecute getToStrNode(); - - public static TrBangNode create(RubyNode self, RubyBaseNodeWithExecute fromStr, RubyBaseNodeWithExecute toStr) { - return StringNodesFactory.TrBangNodeFactory.create(self, fromStr, toStr); - } - @Specialization(guards = "isEmpty(self.tstring)") protected Object trBangSelfEmpty(RubyString self, Object fromStr, Object toStr) { return nil; @@ -2878,29 +2798,11 @@ protected Object trBangNoEmpty(RubyString self, Object fromStr, Object toStr, return StringHelperNodes.trTransHelper(checkEncodingNode, self, libFromStr, fromStr, libToStr, toStr, false, this); } - - private RubyBaseNodeWithExecute getFromStrNodeBeforeCasting() { - return ((ToStrNode) getFromStrNode()).getChildNode(); - } - - private RubyBaseNodeWithExecute getToStrNodeBeforeCasting() { - return ((ToStrNode) getToStrNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getSelfNode().cloneUninitialized(), - getFromStrNodeBeforeCasting().cloneUninitialized(), - getToStrNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "tr_s!", required = 2, raiseIfNotMutableSelf = true) - @NodeChild(value = "selfNode", type = RubyNode.class) - @NodeChild(value = "fromStrNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "self", type = RubyNode.class) + @NodeChild(value = "fromStr", type = RubyBaseNodeWithExecute.class) @NodeChild(value = "toStrNode", type = RubyBaseNodeWithExecute.class) @ImportStatic(StringGuards.class) public abstract static class TrSBangNode extends CoreMethodNode { @@ -2908,7 +2810,7 @@ public abstract static class TrSBangNode extends CoreMethodNode { @Child private CheckEncodingNode checkEncodingNode; @Child private DeleteBangNode deleteBangNode; - @CreateCast("fromStrNode") + @CreateCast("fromStr") protected ToStrNode coerceFromStrToString(RubyBaseNodeWithExecute fromStr) { return ToStrNodeGen.create(fromStr); } @@ -2918,17 +2820,6 @@ protected ToStrNode coerceToStrToString(RubyBaseNodeWithExecute toStr) { return ToStrNodeGen.create(toStr); } - abstract RubyNode getSelfNode(); - - abstract RubyBaseNodeWithExecute getFromStrNode(); - - abstract RubyBaseNodeWithExecute getToStrNode(); - - public static TrSBangNode create(RubyNode self, RubyBaseNodeWithExecute fromStr, - RubyBaseNodeWithExecute toStr) { - return StringNodesFactory.TrSBangNodeFactory.create(self, fromStr, toStr); - } - @Specialization( guards = { "isEmpty(self.tstring)" }) protected Object trSBangEmpty(RubyString self, Object fromStr, Object toStr) { @@ -2961,47 +2852,21 @@ protected Object trSBang(RubyString self, Object fromStr, Object toStr, return StringHelperNodes.trTransHelper(checkEncodingNode, self, libFromStr, fromStr, libToStr, toStr, true, this); } - - private RubyBaseNodeWithExecute getFromStrNodeBeforeCasting() { - return ((ToStrNode) getFromStrNode()).getChildNode(); - } - - private RubyBaseNodeWithExecute getToStrNodeBeforeCasting() { - return ((ToStrNode) getToStrNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getSelfNode().cloneUninitialized(), - getFromStrNodeBeforeCasting().cloneUninitialized(), - getToStrNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } + @NodeChild(value = "string", type = RubyNode.class) + @NodeChild(value = "format", type = RubyBaseNodeWithExecute.class) @CoreMethod(names = "unpack", required = 1) - @NodeChild(value = "stringNode", type = RubyNode.class) - @NodeChild(value = "formatNode", type = RubyBaseNodeWithExecute.class) @ReportPolymorphism public abstract static class UnpackNode extends CoreMethodNode { private final BranchProfile exceptionProfile = BranchProfile.create(); - @CreateCast("formatNode") + @CreateCast("format") protected ToStrNode coerceFormat(RubyBaseNodeWithExecute format) { return ToStrNodeGen.create(format); } - abstract RubyNode getStringNode(); - - abstract RubyBaseNodeWithExecute getFormatNode(); - - public static UnpackNode create(RubyNode string, RubyBaseNodeWithExecute format) { - return StringNodesFactory.UnpackNodeFactory.create(string, format); - } - @Specialization(guards = { "equalNode.execute(libFormat, format, cachedFormat, cachedEncoding)" }) protected RubyArray unpackCached(Object string, Object format, @Cached RubyStringLibrary libString, @@ -3078,17 +2943,6 @@ protected int getCacheLimit() { return getLanguage().options.UNPACK_CACHE; } - private RubyBaseNodeWithExecute getFormatNodeBeforeCasting() { - return ((ToStrNode) getFormatNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getStringNode().cloneUninitialized(), - getFormatNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } } @Primitive(name = "string_upcase!", raiseIfNotMutable = 0, lowerFixnum = 1) diff --git a/src/main/java/org/truffleruby/interop/InteropNodes.java b/src/main/java/org/truffleruby/interop/InteropNodes.java index 1ab6992fd4bf..9886246df2d4 100644 --- a/src/main/java/org/truffleruby/interop/InteropNodes.java +++ b/src/main/java/org/truffleruby/interop/InteropNodes.java @@ -1568,59 +1568,32 @@ protected boolean hasMemberWriteSideEffects(Object receiver, Object name, // region Import/Export @CoreMethod(names = "export", onSingleton = true, required = 2) - @NodeChild(value = "nameNode", type = RubyNode.class) - @NodeChild(value = "objectNode", type = RubyNode.class) + @NodeChild(value = "name", type = RubyNode.class) + @NodeChild(value = "object", type = RubyNode.class) public abstract static class ExportNode extends CoreMethodNode { - @CreateCast("nameNode") + @CreateCast("name") protected RubyNode coerceNameToString(RubyNode name) { return ToJavaStringNode.create(name); } - abstract RubyNode getNameNode(); - - abstract RubyNode getObjectNode(); - - public static ExportNode create(RubyNode name, RubyNode object) { - return InteropNodesFactory.ExportNodeFactory.create(name, object); - } - @TruffleBoundary @Specialization protected Object export(String name, Object object) { getContext().getEnv().exportSymbol(name, object); return object; } - - private RubyNode getNameNodeBeforeCasting() { - return ((ToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getNameNodeBeforeCasting().cloneUninitialized(), - getObjectNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "import", onSingleton = true, required = 1) - @NodeChild(value = "nameNode", type = RubyNode.class) + @NodeChild(value = "name", type = RubyNode.class) public abstract static class ImportNode extends CoreMethodNode { - @CreateCast("nameNode") + @CreateCast("name") protected RubyNode coerceNameToString(RubyNode name) { return ToJavaStringNode.create(name); } - abstract RubyNode getNameNode(); - - public static ImportNode create(RubyNode name) { - return InteropNodesFactory.ImportNodeFactory.create(name); - } - @Specialization protected Object importObject(String name, @Cached BranchProfile errorProfile, @@ -1639,16 +1612,6 @@ private Object doImport(String name) { return getContext().getEnv().importSymbol(name); } - private RubyNode getNameNodeBeforeCasting() { - return ((ToJavaStringNode) getNameNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create(getNameNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } // endregion @@ -2387,26 +2350,16 @@ protected Object writeBufferByte(Object receiver, long byteOffset, Object value, } @CoreMethod(names = "read_buffer_short", onSingleton = true, required = 3) - @NodeChild(value = "receiverNode", type = RubyNode.class) - @NodeChild(value = "byteOrderNode", type = RubyNode.class) - @NodeChild(value = "byteOffsetNode", type = RubyNode.class) + @NodeChild(value = "receiver", type = RubyNode.class) + @NodeChild(value = "byteOrder", type = RubyNode.class) + @NodeChild(value = "byteOffset", type = RubyNode.class) public abstract static class ReadBufferShortNode extends CoreMethodNode { - @CreateCast("byteOrderNode") + @CreateCast("byteOrder") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } - abstract RubyNode getReceiverNode(); - - abstract RubyNode getByteOrderNode(); - - abstract RubyNode getByteOffsetNode(); - - public static ReadBufferShortNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset) { - return InteropNodesFactory.ReadBufferShortNodeFactory.create(receiver, byteOrder, byteOffset); - } - @Specialization(limit = "getInteropCacheLimit()") protected short readBufferShort(Object receiver, ByteOrder byteOrder, long byteOffset, @CachedLibrary("receiver") InteropLibrary interop, @@ -2418,46 +2371,20 @@ protected short readBufferShort(Object receiver, ByteOrder byteOrder, long byteO } } - private RubyNode getByteOrderNodeBeforeCasting() { - return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getReceiverNode().cloneUninitialized(), - getByteOrderNodeBeforeCasting().cloneUninitialized(), - getByteOffsetNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "write_buffer_short", onSingleton = true, required = 4) - @NodeChild(value = "receiverNode", type = RubyNode.class) - @NodeChild(value = "byteOrderNode", type = RubyNode.class) - @NodeChild(value = "byteOffsetNode", type = RubyNode.class) - @NodeChild(value = "valueNode", type = RubyNode.class) + @NodeChild(value = "receiver", type = RubyNode.class) + @NodeChild(value = "byteOrder", type = RubyNode.class) + @NodeChild(value = "byteOffset", type = RubyNode.class) + @NodeChild(value = "value", type = RubyNode.class) public abstract static class WriteBufferShortNode extends CoreMethodNode { - @CreateCast("byteOrderNode") + @CreateCast("byteOrder") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } - abstract RubyNode getReceiverNode(); - - abstract RubyNode getByteOrderNode(); - - abstract RubyNode getByteOffsetNode(); - - abstract RubyNode getValueNode(); - - public static WriteBufferShortNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset, - RubyNode value) { - return InteropNodesFactory.WriteBufferShortNodeFactory.create(receiver, byteOrder, byteOffset, value); - } - @Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInShort(value)") protected Object writeBufferShort(Object receiver, ByteOrder byteOrder, long byteOffset, Object value, @CachedLibrary("receiver") InteropLibrary interop, @@ -2472,43 +2399,19 @@ protected Object writeBufferShort(Object receiver, ByteOrder byteOrder, long byt return value; } - private RubyNode getByteOrderNodeBeforeCasting() { - return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getReceiverNode().cloneUninitialized(), - getByteOrderNodeBeforeCasting().cloneUninitialized(), - getByteOffsetNode().cloneUninitialized(), - getValueNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "read_buffer_int", onSingleton = true, required = 3) - @NodeChild(value = "receiverNode", type = RubyNode.class) - @NodeChild(value = "byteOrderNode", type = RubyNode.class) - @NodeChild(value = "byteOffsetNode", type = RubyNode.class) + @NodeChild(value = "receiver", type = RubyNode.class) + @NodeChild(value = "byteOrder", type = RubyNode.class) + @NodeChild(value = "byteOffset", type = RubyNode.class) public abstract static class ReadBufferIntNode extends CoreMethodNode { - @CreateCast("byteOrderNode") + @CreateCast("byteOrder") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } - abstract RubyNode getReceiverNode(); - - abstract RubyNode getByteOrderNode(); - - abstract RubyNode getByteOffsetNode(); - - public static ReadBufferIntNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset) { - return InteropNodesFactory.ReadBufferIntNodeFactory.create(receiver, byteOrder, byteOffset); - } - @Specialization(limit = "getInteropCacheLimit()") protected int readBufferInt(Object receiver, ByteOrder byteOrder, long byteOffset, @CachedLibrary("receiver") InteropLibrary interop, @@ -2520,46 +2423,20 @@ protected int readBufferInt(Object receiver, ByteOrder byteOrder, long byteOffse } } - private RubyNode getByteOrderNodeBeforeCasting() { - return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getReceiverNode().cloneUninitialized(), - getByteOrderNodeBeforeCasting().cloneUninitialized(), - getByteOffsetNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "write_buffer_int", onSingleton = true, required = 4, lowerFixnum = 4) - @NodeChild(value = "receiverNode", type = RubyNode.class) - @NodeChild(value = "byteOrderNode", type = RubyNode.class) - @NodeChild(value = "byteOffsetNode", type = RubyNode.class) - @NodeChild(value = "valueNode", type = RubyNode.class) + @NodeChild(value = "receiver", type = RubyNode.class) + @NodeChild(value = "byteOrder", type = RubyNode.class) + @NodeChild(value = "byteOffset", type = RubyNode.class) + @NodeChild(value = "value", type = RubyNode.class) public abstract static class WriteBufferIntNode extends CoreMethodNode { - @CreateCast("byteOrderNode") + @CreateCast("byteOrder") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } - abstract RubyNode getReceiverNode(); - - abstract RubyNode getByteOrderNode(); - - abstract RubyNode getByteOffsetNode(); - - abstract RubyNode getValueNode(); - - public static WriteBufferIntNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset, - RubyNode value) { - return InteropNodesFactory.WriteBufferIntNodeFactory.create(receiver, byteOrder, byteOffset, value); - } - @Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInInt(value)") protected Object writeBufferInt(Object receiver, ByteOrder order, long byteOffset, Object value, @CachedLibrary("receiver") InteropLibrary interop, @@ -2574,43 +2451,19 @@ protected Object writeBufferInt(Object receiver, ByteOrder order, long byteOffse return value; } - private RubyNode getByteOrderNodeBeforeCasting() { - return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getReceiverNode().cloneUninitialized(), - getByteOrderNodeBeforeCasting().cloneUninitialized(), - getByteOffsetNode().cloneUninitialized(), - getValueNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "read_buffer_long", onSingleton = true, required = 3) - @NodeChild(value = "receiverNode", type = RubyNode.class) - @NodeChild(value = "byteOrderNode", type = RubyNode.class) - @NodeChild(value = "byteOffsetNode", type = RubyNode.class) + @NodeChild(value = "receiver", type = RubyNode.class) + @NodeChild(value = "byteOrder", type = RubyNode.class) + @NodeChild(value = "byteOffset", type = RubyNode.class) public abstract static class ReadBufferLongNode extends CoreMethodNode { - @CreateCast("byteOrderNode") + @CreateCast("byteOrder") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } - abstract RubyNode getReceiverNode(); - - abstract RubyNode getByteOrderNode(); - - abstract RubyNode getByteOffsetNode(); - - public static ReadBufferLongNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset) { - return InteropNodesFactory.ReadBufferLongNodeFactory.create(receiver, byteOrder, byteOffset); - } - @Specialization(limit = "getInteropCacheLimit()") protected long readBufferLong(Object receiver, ByteOrder byteOrder, long byteOffset, @CachedLibrary("receiver") InteropLibrary interop, @@ -2622,46 +2475,20 @@ protected long readBufferLong(Object receiver, ByteOrder byteOrder, long byteOff } } - private RubyNode getByteOrderNodeBeforeCasting() { - return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getReceiverNode().cloneUninitialized(), - getByteOrderNodeBeforeCasting().cloneUninitialized(), - getByteOffsetNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "write_buffer_long", onSingleton = true, required = 4) - @NodeChild(value = "receiverNode", type = RubyNode.class) - @NodeChild(value = "byteOrderNode", type = RubyNode.class) - @NodeChild(value = "byteOffsetNode", type = RubyNode.class) - @NodeChild(value = "valueNode", type = RubyNode.class) + @NodeChild(value = "receiver", type = RubyNode.class) + @NodeChild(value = "byteOrder", type = RubyNode.class) + @NodeChild(value = "byteOffset", type = RubyNode.class) + @NodeChild(value = "value", type = RubyNode.class) public abstract static class WriteBufferLongNode extends CoreMethodNode { - @CreateCast("byteOrderNode") + @CreateCast("byteOrder") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } - abstract RubyNode getReceiverNode(); - - abstract RubyNode getByteOrderNode(); - - abstract RubyNode getByteOffsetNode(); - - abstract RubyNode getValueNode(); - - public static WriteBufferLongNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset, - RubyNode value) { - return InteropNodesFactory.WriteBufferLongNodeFactory.create(receiver, byteOrder, byteOffset, value); - } - @Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInLong(value)") protected Object writeBufferLong(Object receiver, ByteOrder order, long byteOffset, Object value, @CachedLibrary("receiver") InteropLibrary interop, @@ -2676,43 +2503,19 @@ protected Object writeBufferLong(Object receiver, ByteOrder order, long byteOffs return value; } - private RubyNode getByteOrderNodeBeforeCasting() { - return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getReceiverNode().cloneUninitialized(), - getByteOrderNodeBeforeCasting().cloneUninitialized(), - getByteOffsetNode().cloneUninitialized(), - getValueNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "read_buffer_float", onSingleton = true, required = 3) - @NodeChild(value = "receiverNode", type = RubyNode.class) - @NodeChild(value = "byteOrderNode", type = RubyNode.class) - @NodeChild(value = "byteOffsetNode", type = RubyNode.class) + @NodeChild(value = "receiver", type = RubyNode.class) + @NodeChild(value = "byteOrder", type = RubyNode.class) + @NodeChild(value = "byteOffset", type = RubyNode.class) public abstract static class ReadBufferFloatNode extends CoreMethodNode { - @CreateCast("byteOrderNode") + @CreateCast("byteOrder") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } - abstract RubyNode getReceiverNode(); - - abstract RubyNode getByteOrderNode(); - - abstract RubyNode getByteOffsetNode(); - - public static ReadBufferFloatNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset) { - return InteropNodesFactory.ReadBufferFloatNodeFactory.create(receiver, byteOrder, byteOffset); - } - // must return double so Ruby nodes can deal with it @Specialization(limit = "getInteropCacheLimit()") protected double readBufferFloat(Object receiver, ByteOrder byteOrder, long byteOffset, @@ -2725,46 +2528,20 @@ protected double readBufferFloat(Object receiver, ByteOrder byteOrder, long byte } } - private RubyNode getByteOrderNodeBeforeCasting() { - return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getReceiverNode().cloneUninitialized(), - getByteOrderNodeBeforeCasting().cloneUninitialized(), - getByteOffsetNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "write_buffer_float", onSingleton = true, required = 4) - @NodeChild(value = "receiverNode", type = RubyNode.class) - @NodeChild(value = "byteOrderNode", type = RubyNode.class) - @NodeChild(value = "byteOffsetNode", type = RubyNode.class) - @NodeChild(value = "valueNode", type = RubyNode.class) + @NodeChild(value = "receiver", type = RubyNode.class) + @NodeChild(value = "byteOrder", type = RubyNode.class) + @NodeChild(value = "byteOffset", type = RubyNode.class) + @NodeChild(value = "value", type = RubyNode.class) public abstract static class WriteBufferFloatNode extends CoreMethodNode { - @CreateCast("byteOrderNode") + @CreateCast("byteOrder") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } - abstract RubyNode getReceiverNode(); - - abstract RubyNode getByteOrderNode(); - - abstract RubyNode getByteOffsetNode(); - - abstract RubyNode getValueNode(); - - public static WriteBufferFloatNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset, - RubyNode value) { - return InteropNodesFactory.WriteBufferFloatNodeFactory.create(receiver, byteOrder, byteOffset, value); - } - @Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInDouble(value)") protected Object writeBufferFloat(Object receiver, ByteOrder order, long byteOffset, Object value, @CachedLibrary("receiver") InteropLibrary interop, @@ -2779,42 +2556,19 @@ protected Object writeBufferFloat(Object receiver, ByteOrder order, long byteOff return value; } - private RubyNode getByteOrderNodeBeforeCasting() { - return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getReceiverNode().cloneUninitialized(), - getByteOrderNodeBeforeCasting().cloneUninitialized(), - getByteOffsetNode().cloneUninitialized(), - getValueNode().cloneUninitialized()); - return copy.copyFlags(this); - } } @CoreMethod(names = "read_buffer_double", onSingleton = true, required = 3) - @NodeChild(value = "receiverNode", type = RubyNode.class) - @NodeChild(value = "byteOrderNode", type = RubyNode.class) - @NodeChild(value = "byteOffsetNode", type = RubyNode.class) + @NodeChild(value = "receiver", type = RubyNode.class) + @NodeChild(value = "byteOrder", type = RubyNode.class) + @NodeChild(value = "byteOffset", type = RubyNode.class) public abstract static class ReadBufferDoubleNode extends CoreMethodNode { - @CreateCast("byteOrderNode") + @CreateCast("byteOrder") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } - abstract RubyNode getReceiverNode(); - - abstract RubyNode getByteOrderNode(); - - abstract RubyNode getByteOffsetNode(); - - public static ReadBufferDoubleNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset) { - return InteropNodesFactory.ReadBufferDoubleNodeFactory.create(receiver, byteOrder, byteOffset); - } - @Specialization(limit = "getInteropCacheLimit()") protected double readBufferDouble(Object receiver, ByteOrder byteOrder, long byteOffset, @CachedLibrary("receiver") InteropLibrary interop, @@ -2826,46 +2580,20 @@ protected double readBufferDouble(Object receiver, ByteOrder byteOrder, long byt } } - private RubyNode getByteOrderNodeBeforeCasting() { - return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getReceiverNode().cloneUninitialized(), - getByteOrderNodeBeforeCasting().cloneUninitialized(), - getByteOffsetNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "write_buffer_double", onSingleton = true, required = 4) - @NodeChild(value = "receiverNode", type = RubyNode.class) - @NodeChild(value = "byteOrderNode", type = RubyNode.class) - @NodeChild(value = "byteOffsetNode", type = RubyNode.class) - @NodeChild(value = "valueNode", type = RubyNode.class) + @NodeChild(value = "receiver", type = RubyNode.class) + @NodeChild(value = "byteOrder", type = RubyNode.class) + @NodeChild(value = "byteOffset", type = RubyNode.class) + @NodeChild(value = "value", type = RubyNode.class) public abstract static class WriteBufferDoubleNode extends CoreMethodNode { - @CreateCast("byteOrderNode") + @CreateCast("byteOrder") protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) { return SymbolToByteOrderNode.create(byteOrder); } - abstract RubyNode getReceiverNode(); - - abstract RubyNode getByteOrderNode(); - - abstract RubyNode getByteOffsetNode(); - - abstract RubyNode getValueNode(); - - public static WriteBufferDoubleNode create(RubyNode receiver, RubyNode byteOrder, RubyNode byteOffset, - RubyNode value) { - return InteropNodesFactory.WriteBufferDoubleNodeFactory.create(receiver, byteOrder, byteOffset, value); - } - @Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInDouble(value)") protected Object writeBufferDouble(Object receiver, ByteOrder order, long byteOffset, Object value, @CachedLibrary("receiver") InteropLibrary interop, @@ -2880,20 +2608,6 @@ protected Object writeBufferDouble(Object receiver, ByteOrder order, long byteOf return value; } - private RubyNode getByteOrderNodeBeforeCasting() { - return ((SymbolToByteOrderNode) getByteOrderNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getReceiverNode().cloneUninitialized(), - getByteOrderNodeBeforeCasting().cloneUninitialized(), - getByteOffsetNode().cloneUninitialized(), - getValueNode().cloneUninitialized()); - return copy.copyFlags(this); - } - } // endregion diff --git a/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java b/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java index 8cde83782554..c658996120ed 100644 --- a/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java +++ b/src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java @@ -26,7 +26,7 @@ public static SymbolToByteOrderNode create(RubyNode value) { return SymbolToByteOrderNodeGen.create(value); } - public abstract RubyNode getValueNode(); + abstract RubyNode getValueNode(); @Specialization(guards = "symbol == coreSymbols().BIG") protected ByteOrder symbolToByteOrderBig(RubySymbol symbol) { diff --git a/src/main/java/org/truffleruby/interop/ToJavaStringNode.java b/src/main/java/org/truffleruby/interop/ToJavaStringNode.java index 9c8d700a5d37..aeb51be1bb57 100644 --- a/src/main/java/org/truffleruby/interop/ToJavaStringNode.java +++ b/src/main/java/org/truffleruby/interop/ToJavaStringNode.java @@ -35,7 +35,7 @@ public static ToJavaStringNode create(RubyNode string) { public abstract String executeToJavaString(Object name); - public abstract RubyNode getValueNode(); + abstract RubyNode getValueNode(); @Specialization(guards = "interopLibrary.isString(value)", limit = "getLimit()") protected String interopString(Object value, diff --git a/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java b/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java index fcc11de540e1..850ca6433526 100644 --- a/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java +++ b/src/main/java/org/truffleruby/interop/ToJavaStringWithDefaultNode.java @@ -27,7 +27,7 @@ public ToJavaStringWithDefaultNode(String defaultValue) { this.defaultValue = defaultValue; } - public abstract RubyNode getValueNode(); + abstract RubyNode getValueNode(); @Specialization protected String doDefault(NotProvided value) { diff --git a/src/main/java/org/truffleruby/parser/BodyTranslator.java b/src/main/java/org/truffleruby/parser/BodyTranslator.java index daabe2e08b9e..ed995cfdf38f 100644 --- a/src/main/java/org/truffleruby/parser/BodyTranslator.java +++ b/src/main/java/org/truffleruby/parser/BodyTranslator.java @@ -50,7 +50,7 @@ import org.truffleruby.core.kernel.KernelNodesFactory; import org.truffleruby.core.module.ModuleNodesFactory; import org.truffleruby.core.numeric.BignumOperations; -import org.truffleruby.core.range.RangeNodesFactory; +import org.truffleruby.core.range.RangeNodes; import org.truffleruby.core.range.RubyIntRange; import org.truffleruby.core.range.RubyLongRange; import org.truffleruby.core.regexp.ClassicRegexp; @@ -1535,7 +1535,7 @@ public RubyNode visitDotNode(DotParseNode node) { final RubyNode rangeClass = new RangeClassLiteralNode(); final RubyNode isExclusive = new ObjectLiteralNode(node.isExclusive()); - ret = RangeNodesFactory.NewNodeFactory.create(rangeClass, begin, end, isExclusive); + ret = RangeNodes.NewNode.create(rangeClass, begin, end, isExclusive); } ret.unsafeSetSourceSection(sourceSection); return addNewlineIfNeeded(node, ret); diff --git a/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java b/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java index eb9d1e6564ce..90c65d3a9b52 100644 --- a/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java +++ b/src/main/java/org/truffleruby/stdlib/readline/ReadlineHistoryNodes.java @@ -215,28 +215,20 @@ protected Object getIndex(int index) { } @CoreMethod(names = "[]=", needsSelf = false, lowerFixnum = 1, required = 2) - @NodeChild(value = "indexNode", type = RubyBaseNodeWithExecute.class) - @NodeChild(value = "lineNode", type = RubyNode.class) + @NodeChild(value = "index", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "line", type = RubyNode.class) public abstract static class SetIndexNode extends CoreMethodNode { - @CreateCast("indexNode") + @CreateCast("index") protected ToIntNode coerceIndexToInt(RubyBaseNodeWithExecute index) { return ToIntNode.create(index); } - @CreateCast("lineNode") + @CreateCast("line") protected RubyNode coerceLineToJavaString(RubyNode line) { return ToJavaStringNode.create(line); } - abstract RubyBaseNodeWithExecute getIndexNode(); - - abstract RubyNode getLineNode(); - - public static SetIndexNode create(RubyBaseNodeWithExecute index, RubyNode line) { - return ReadlineHistoryNodesFactory.SetIndexNodeFactory.create(index, line); - } - @TruffleBoundary @Specialization protected Object setIndex(int index, String line) { @@ -252,22 +244,6 @@ protected Object setIndex(int index, String line) { } } - private RubyBaseNodeWithExecute getIndexNodeBeforeCasting() { - return ((ToIntNode) getIndexNode()).getChildNode(); - } - - private RubyNode getLineNodeBeforeCasting() { - return ((ToJavaStringNode) getLineNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getIndexNodeBeforeCasting().cloneUninitialized(), - getLineNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "delete_at", needsSelf = false, required = 1, lowerFixnum = 1) diff --git a/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java b/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java index c3e227034b82..649502d5e2d1 100644 --- a/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java +++ b/src/main/java/org/truffleruby/stdlib/readline/ReadlineNodes.java @@ -43,7 +43,6 @@ import org.truffleruby.core.support.RubyIO; import org.truffleruby.core.thread.ThreadManager.BlockingAction; import org.truffleruby.interop.ToJavaStringNode; -import org.truffleruby.interop.ToJavaStringWithDefaultNode; import org.truffleruby.interop.ToJavaStringWithDefaultNodeGen; import org.truffleruby.language.RubyBaseNodeWithExecute; import org.truffleruby.language.RubyGuards; @@ -74,20 +73,14 @@ protected RubyString basicWordBreakCharacters() { } @CoreMethod(names = "basic_word_break_characters=", onSingleton = true, required = 1) - @NodeChild(value = "charactersNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "characters", type = RubyBaseNodeWithExecute.class) public abstract static class SetBasicWordBreakCharactersNode extends CoreMethodNode { - @CreateCast("charactersNode") + @CreateCast("characters") protected ToStrNode coerceCharactersToString(RubyBaseNodeWithExecute characters) { return ToStrNodeGen.create(characters); } - abstract RubyBaseNodeWithExecute getCharactersNode(); - - public SetBasicWordBreakCharactersNode create(RubyBaseNodeWithExecute characters) { - return ReadlineNodesFactory.SetBasicWordBreakCharactersNodeFactory.create(characters); - } - @TruffleBoundary @Specialization(guards = "strings.isRubyString(characters)", limit = "1") protected Object setBasicWordBreakCharacters(Object characters, @@ -97,17 +90,6 @@ protected Object setBasicWordBreakCharacters(Object characters, return characters; } - private RubyBaseNodeWithExecute getCharactersNodeBeforeCasting() { - return ((ToStrNode) getCharactersNode()).getChildNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getCharactersNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @Primitive(name = "readline_set_completion_proc") @@ -141,30 +123,22 @@ protected RubyArray getScreenSize() { } @CoreMethod(names = "readline", isModuleFunction = true, optional = 2) - @NodeChild(value = "promptNode", type = RubyNode.class) - @NodeChild(value = "addToHistoryNode", type = RubyBaseNodeWithExecute.class) + @NodeChild(value = "prompt", type = RubyNode.class) + @NodeChild(value = "addToHistory", type = RubyBaseNodeWithExecute.class) public abstract static class ReadlineNode extends CoreMethodNode { @Child private TruffleString.FromJavaStringNode fromJavaStringNode = TruffleString.FromJavaStringNode.create(); - @CreateCast("promptNode") + @CreateCast("prompt") protected RubyNode coercePromptToJavaString(RubyNode prompt) { return ToJavaStringWithDefaultNodeGen.create("", prompt); } - @CreateCast("addToHistoryNode") + @CreateCast("addToHistory") protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute addToHistory) { return BooleanCastWithDefaultNode.create(false, addToHistory); } - abstract RubyNode getPromptNode(); - - abstract RubyBaseNodeWithExecute getAddToHistoryNode(); - - public static ReadlineNode create(RubyNode prompt, RubyBaseNodeWithExecute addToHistory) { - return ReadlineNodesFactory.ReadlineNodeFactory.create(prompt, addToHistory); - } - @TruffleBoundary @Specialization protected Object readline(String prompt, boolean addToHistory) { @@ -201,22 +175,6 @@ protected Object readline(String prompt, boolean addToHistory) { } } - private RubyNode getPromptNodeBeforeCasting() { - return ((ToJavaStringWithDefaultNode) getPromptNode()).getValueNode(); - } - - private RubyBaseNodeWithExecute getAddToHistoryNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getAddToHistoryNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getPromptNodeBeforeCasting().cloneUninitialized(), - getAddToHistoryNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "point", onSingleton = true) @@ -231,23 +189,15 @@ protected int point() { } @CoreMethod(names = "insert_text", constructor = true, required = 1) - @NodeChild(value = "selfNode", type = RubyNode.class) - @NodeChild(value = "textNode", type = RubyNode.class) + @NodeChild(value = "self", type = RubyNode.class) + @NodeChild(value = "text", type = RubyNode.class) public abstract static class InsertTextNode extends CoreMethodNode { - @CreateCast("textNode") + @CreateCast("text") protected RubyNode coerceTextToString(RubyNode text) { return ToJavaStringNode.create(text); } - abstract RubyNode getSelfNode(); - - abstract RubyNode getTextNode(); - - public static InsertTextNode create(RubyNode self, RubyNode text) { - return ReadlineNodesFactory.InsertTextNodeFactory.create(self, text); - } - @TruffleBoundary @Specialization protected RubyBasicObject insertText(RubyBasicObject readline, String text) { @@ -255,18 +205,6 @@ protected RubyBasicObject insertText(RubyBasicObject readline, String text) { return readline; } - private RubyNode getTextNodeBeforeCasting() { - return ((ToJavaStringWithDefaultNode) getTextNode()).getValueNode(); - } - - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getSelfNode().cloneUninitialized(), - getTextNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @CoreMethod(names = "delete_text", constructor = true) From 317a604dafaa11b66a676512c44ce9b5c869cf29 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 16:48:02 +0200 Subject: [PATCH 33/46] Ensure all Primitives inherit from PrimitiveNode or RubySourceNode --- .../truffleruby/builtins/PrimitiveManager.java | 9 +++++++++ .../java/org/truffleruby/cext/CExtNodes.java | 2 +- .../java/org/truffleruby/core/MathNodes.java | 4 ++-- .../org/truffleruby/core/TruffleSystemNodes.java | 2 +- .../org/truffleruby/core/array/ArrayNodes.java | 5 +++-- .../truffleruby/core/encoding/EncodingNodes.java | 4 ++-- .../core/exception/ExceptionNodes.java | 2 +- .../org/truffleruby/core/fiber/FiberNodes.java | 4 ++-- .../org/truffleruby/core/hash/HashNodes.java | 2 +- .../org/truffleruby/core/kernel/KernelNodes.java | 2 +- .../core/kernel/TruffleKernelNodes.java | 6 +++--- .../core/monitor/TruffleMonitorNodes.java | 10 +++++----- .../core/objectspace/WeakMapNodes.java | 3 ++- .../org/truffleruby/core/string/StringNodes.java | 16 ++++++++-------- .../org/truffleruby/core/thread/ThreadNodes.java | 4 ++-- .../truffleruby/extra/ConcurrentMapNodes.java | 3 ++- .../org/truffleruby/extra/TrufflePosixNodes.java | 4 ++-- .../org/truffleruby/interop/PolyglotNodes.java | 2 +- src/main/ruby/truffleruby/core/math.rb | 2 +- .../processor/CoreModuleProcessor.java | 9 +++++++++ .../processor/TruffleRubyProcessor.java | 4 ++++ 21 files changed, 62 insertions(+), 37 deletions(-) diff --git a/src/main/java/org/truffleruby/builtins/PrimitiveManager.java b/src/main/java/org/truffleruby/builtins/PrimitiveManager.java index 1f1e01f700a2..535cc7a7736e 100644 --- a/src/main/java/org/truffleruby/builtins/PrimitiveManager.java +++ b/src/main/java/org/truffleruby/builtins/PrimitiveManager.java @@ -20,6 +20,7 @@ import com.oracle.truffle.api.TruffleOptions; import com.oracle.truffle.api.dsl.NodeFactory; +import org.truffleruby.language.RubySourceNode; import org.truffleruby.options.LanguageOptions; /** Manages the available primitive calls. */ @@ -57,12 +58,20 @@ private PrimitiveNodeConstructor loadLazyPrimitive(String lazyPrimitive) { public PrimitiveNodeConstructor addPrimitive(NodeFactory nodeFactory, Primitive annotation) { + assert assertNodeClass(nodeFactory.getNodeClass()); return ConcurrentOperations.getOrCompute( primitives, annotation.name(), k -> new PrimitiveNodeConstructor(annotation, nodeFactory)); } + private boolean assertNodeClass(Class nodeClass) { + // Note already checked in CoreModuleProcessor + assert PrimitiveNode.class.isAssignableFrom(nodeClass) || RubySourceNode.class.isAssignableFrom(nodeClass) + : nodeClass + " should inherit from PrimitiveArrayArgumentsNode, PrimitiveNode or RubySourceNode"; + return true; + } + public void loadCoreMethodNodes(LanguageOptions languageOptions) { if (!TruffleOptions.AOT && languageOptions.LAZY_BUILTINS) { BuiltinsClasses.setupBuiltinsLazyPrimitives(this); diff --git a/src/main/java/org/truffleruby/cext/CExtNodes.java b/src/main/java/org/truffleruby/cext/CExtNodes.java index fae0fef58d1d..5db62d179171 100644 --- a/src/main/java/org/truffleruby/cext/CExtNodes.java +++ b/src/main/java/org/truffleruby/cext/CExtNodes.java @@ -620,7 +620,7 @@ protected int bitLength(RubyBignum num) { } @Primitive(name = "rb_int_singlebit_p") - public abstract static class IntSinglebitPPrimitiveNode extends CoreMethodArrayArgumentsNode { + public abstract static class IntSinglebitPPrimitiveNode extends PrimitiveArrayArgumentsNode { @Specialization protected int intSinglebitP(int num) { diff --git a/src/main/java/org/truffleruby/core/MathNodes.java b/src/main/java/org/truffleruby/core/MathNodes.java index 22e41ce57acb..1ec8c0fa0b26 100644 --- a/src/main/java/org/truffleruby/core/MathNodes.java +++ b/src/main/java/org/truffleruby/core/MathNodes.java @@ -387,9 +387,9 @@ protected double doFunction(double a) { } @Primitive(name = "math_hypot") - public abstract static class HypotNode extends SimpleDyadicMathNode { + public abstract static class HypotNode extends PrimitiveArrayArgumentsNode { - @Override + @Specialization protected double doFunction(double a, double b) { return Math.hypot(a, b); } diff --git a/src/main/java/org/truffleruby/core/TruffleSystemNodes.java b/src/main/java/org/truffleruby/core/TruffleSystemNodes.java index d993deac423a..4df67d413522 100644 --- a/src/main/java/org/truffleruby/core/TruffleSystemNodes.java +++ b/src/main/java/org/truffleruby/core/TruffleSystemNodes.java @@ -98,7 +98,7 @@ protected RubyArray envVars() { } @Primitive(name = "java_get_env") - public abstract static class JavaGetEnv extends CoreMethodArrayArgumentsNode { + public abstract static class JavaGetEnv extends PrimitiveArrayArgumentsNode { @Specialization(guards = "strings.isRubyString(name)", limit = "1") protected Object javaGetEnv(Object name, diff --git a/src/main/java/org/truffleruby/core/array/ArrayNodes.java b/src/main/java/org/truffleruby/core/array/ArrayNodes.java index c3b4dcc910d1..6926010f5a28 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayNodes.java +++ b/src/main/java/org/truffleruby/core/array/ArrayNodes.java @@ -1324,9 +1324,10 @@ protected RubyArray initializeCopy(RubyArray self, RubyArray from, @Primitive(name = "array_inject") @ImportStatic(ArrayGuards.class) - public abstract static class InjectNode extends YieldingCoreMethodNode { + public abstract static class InjectNode extends PrimitiveArrayArgumentsNode { @Child private DispatchNode dispatch = DispatchNode.create(PUBLIC); + @Child private CallBlockNode yieldNode = CallBlockNode.create(); // Uses block @@ -1374,7 +1375,7 @@ public Object injectBlockHelper(ArrayStoreLibrary stores, RubyArray array, int n = start; try { for (; loopProfile.inject(n < arraySizeProfile.profile(array.size)); n++) { - accumulator = callBlock(block, accumulator, stores.read(store, n)); + accumulator = yieldNode.yield(block, accumulator, stores.read(store, n)); } } finally { profileAndReportLoopCount(loopProfile, n - start); diff --git a/src/main/java/org/truffleruby/core/encoding/EncodingNodes.java b/src/main/java/org/truffleruby/core/encoding/EncodingNodes.java index d37f23ac5488..b3b5853ee8a4 100644 --- a/src/main/java/org/truffleruby/core/encoding/EncodingNodes.java +++ b/src/main/java/org/truffleruby/core/encoding/EncodingNodes.java @@ -394,7 +394,7 @@ protected int getCacheLimit() { // MRI: rb_enc_compatible @Primitive(name = "encoding_compatible?") - public abstract static class CompatibleQueryNode extends CoreMethodArrayArgumentsNode { + public abstract static class CompatibleQueryNode extends PrimitiveArrayArgumentsNode { @Child private NegotiateCompatibleEncodingNode negotiateCompatibleEncodingNode = NegotiateCompatibleEncodingNode .create(); @@ -418,7 +418,7 @@ protected Object isCompatible(Object first, Object second, // encoding_compatible? but only accepting Strings for better footprint @Primitive(name = "strings_compatible?") - public abstract static class AreStringsCompatibleNode extends CoreMethodArrayArgumentsNode { + public abstract static class AreStringsCompatibleNode extends PrimitiveArrayArgumentsNode { public static AreStringsCompatibleNode create() { return EncodingNodesFactory.AreStringsCompatibleNodeFactory.create(null); } diff --git a/src/main/java/org/truffleruby/core/exception/ExceptionNodes.java b/src/main/java/org/truffleruby/core/exception/ExceptionNodes.java index d6f037605cc5..1fad8919196a 100644 --- a/src/main/java/org/truffleruby/core/exception/ExceptionNodes.java +++ b/src/main/java/org/truffleruby/core/exception/ExceptionNodes.java @@ -221,7 +221,7 @@ protected boolean foreignException(Object exception, } @Primitive(name = "exception_capture_backtrace", lowerFixnum = 1) - public abstract static class CaptureBacktraceNode extends CoreMethodArrayArgumentsNode { + public abstract static class CaptureBacktraceNode extends PrimitiveArrayArgumentsNode { @Specialization protected Object captureBacktrace(RubyException exception, int offset) { diff --git a/src/main/java/org/truffleruby/core/fiber/FiberNodes.java b/src/main/java/org/truffleruby/core/fiber/FiberNodes.java index bf6f5c27cf0c..d7a7ef0f2103 100644 --- a/src/main/java/org/truffleruby/core/fiber/FiberNodes.java +++ b/src/main/java/org/truffleruby/core/fiber/FiberNodes.java @@ -13,10 +13,10 @@ import com.oracle.truffle.api.strings.TruffleString; import org.truffleruby.builtins.CoreMethod; import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; -import org.truffleruby.builtins.CoreMethodNode; import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; +import org.truffleruby.builtins.PrimitiveNode; import org.truffleruby.core.array.RubyArray; import org.truffleruby.core.cast.SingleValueCastNode; import org.truffleruby.core.cast.SingleValueCastNodeGen; @@ -322,7 +322,7 @@ protected boolean alive(RubyFiber fiber) { } @Primitive(name = "fiber_current") - public abstract static class CurrentNode extends CoreMethodNode { + public abstract static class CurrentNode extends PrimitiveNode { @Specialization protected RubyFiber current() { diff --git a/src/main/java/org/truffleruby/core/hash/HashNodes.java b/src/main/java/org/truffleruby/core/hash/HashNodes.java index 2984e1808de3..790358fbc18d 100644 --- a/src/main/java/org/truffleruby/core/hash/HashNodes.java +++ b/src/main/java/org/truffleruby/core/hash/HashNodes.java @@ -183,7 +183,7 @@ protected RubyHash copyAndSetRuby2Keywords(RubyHash self, boolean ruby2_keywords } @Primitive(name = "hash_copy_and_mark_as_ruby2_keywords") - public abstract static class HashCopyAndMarkAsRuby2KeywordsNode extends CoreMethodArrayArgumentsNode { + public abstract static class HashCopyAndMarkAsRuby2KeywordsNode extends PrimitiveArrayArgumentsNode { @Specialization protected RubyHash copyAndMarkAsRuby2Keywords(RubyHash hash, @Cached CopyHashAndSetRuby2KeywordsNode copyHashAndSetRuby2KeywordsNode) { diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java index a0563406cfd4..4e28dbae1d57 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java @@ -402,7 +402,7 @@ protected RubyString canonicalPath(Object string, } @Primitive(name = "kernel_caller_locations", lowerFixnum = { 0, 1 }) - public abstract static class CallerLocationsNode extends CoreMethodArrayArgumentsNode { + public abstract static class CallerLocationsNode extends PrimitiveArrayArgumentsNode { @Specialization protected Object callerLocations(int omit, NotProvided length) { diff --git a/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java b/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java index 324cbfd25d90..b3a672f53034 100644 --- a/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java @@ -155,7 +155,7 @@ protected boolean load(Object file, boolean wrap, // Only used internally with a constant literal name, does not trigger hooks @Primitive(name = "global_variable_set") @ImportStatic(Layouts.class) - public abstract static class WriteGlobalVariableNode extends CoreMethodArrayArgumentsNode { + public abstract static class WriteGlobalVariableNode extends PrimitiveArrayArgumentsNode { @Specialization(guards = "name == cachedName", limit = "1") protected Object write(RubySymbol name, Object value, @@ -168,7 +168,7 @@ protected Object write(RubySymbol name, Object value, // Only used internally with a constant literal name, does not trigger hooks @Primitive(name = "global_variable_get") @ImportStatic(Layouts.class) - public abstract static class ReadGlobalVariableNode extends CoreMethodArrayArgumentsNode { + public abstract static class ReadGlobalVariableNode extends PrimitiveArrayArgumentsNode { @Specialization(guards = "name == cachedName", limit = "1") protected Object read(RubySymbol name, @@ -321,7 +321,7 @@ protected Object storage(VirtualFrame frame, @Primitive(name = "get_original_require") @ImportStatic(Layouts.class) - public abstract static class GetOriginalRequireNode extends CoreMethodArrayArgumentsNode { + public abstract static class GetOriginalRequireNode extends PrimitiveArrayArgumentsNode { @Child private TruffleString.FromJavaStringNode fromJavaStringNode = TruffleString.FromJavaStringNode.create(); diff --git a/src/main/java/org/truffleruby/core/monitor/TruffleMonitorNodes.java b/src/main/java/org/truffleruby/core/monitor/TruffleMonitorNodes.java index 78e2d3604b84..ddcb801c7f61 100644 --- a/src/main/java/org/truffleruby/core/monitor/TruffleMonitorNodes.java +++ b/src/main/java/org/truffleruby/core/monitor/TruffleMonitorNodes.java @@ -13,9 +13,9 @@ import com.oracle.truffle.api.dsl.Specialization; import com.oracle.truffle.api.profiles.BranchProfile; -import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; +import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; import org.truffleruby.core.mutex.MutexOperations; import org.truffleruby.core.mutex.RubyMutex; import org.truffleruby.core.proc.RubyProc; @@ -27,7 +27,7 @@ public abstract class TruffleMonitorNodes { @Primitive(name = "monitor_synchronize") - public abstract static class SynchronizeNode extends CoreMethodArrayArgumentsNode { + public abstract static class SynchronizeNode extends PrimitiveArrayArgumentsNode { @Child private CallBlockNode yieldNode = CallBlockNode.create(); @@ -54,7 +54,7 @@ protected Object synchronizeOnMutexNoBlock(RubyMutex mutex, Object block) { } @Primitive(name = "monitor_try_enter") - public abstract static class MonitorTryEnter extends CoreMethodArrayArgumentsNode { + public abstract static class MonitorTryEnter extends PrimitiveArrayArgumentsNode { @Specialization protected Object tryEnter(RubyMutex mutex) { @@ -64,7 +64,7 @@ protected Object tryEnter(RubyMutex mutex) { } @Primitive(name = "monitor_enter") - public abstract static class MonitorEnter extends CoreMethodArrayArgumentsNode { + public abstract static class MonitorEnter extends PrimitiveArrayArgumentsNode { @Specialization protected Object enter(RubyMutex mutex) { @@ -75,7 +75,7 @@ protected Object enter(RubyMutex mutex) { } @Primitive(name = "monitor_exit") - public abstract static class MonitorExit extends CoreMethodArrayArgumentsNode { + public abstract static class MonitorExit extends PrimitiveArrayArgumentsNode { @Specialization protected Object exit(RubyMutex mutex) { diff --git a/src/main/java/org/truffleruby/core/objectspace/WeakMapNodes.java b/src/main/java/org/truffleruby/core/objectspace/WeakMapNodes.java index 96d40e47d5fe..e7849433193a 100644 --- a/src/main/java/org/truffleruby/core/objectspace/WeakMapNodes.java +++ b/src/main/java/org/truffleruby/core/objectspace/WeakMapNodes.java @@ -14,6 +14,7 @@ import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; +import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; import org.truffleruby.builtins.YieldingCoreMethodNode; import org.truffleruby.collections.SimpleEntry; import org.truffleruby.core.array.RubyArray; @@ -75,7 +76,7 @@ protected Object get(RubyWeakMap map, Object key) { } @Primitive(name = "weakmap_aset") - public abstract static class SetIndexNode extends CoreMethodArrayArgumentsNode { + public abstract static class SetIndexNode extends PrimitiveArrayArgumentsNode { @Specialization protected Object set(RubyWeakMap map, Object key, Object value) { diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java index 1df2577f0516..5eb4dbc2dc83 100644 --- a/src/main/java/org/truffleruby/core/string/StringNodes.java +++ b/src/main/java/org/truffleruby/core/string/StringNodes.java @@ -349,7 +349,7 @@ protected boolean equal(Object a, Object b) { // compatibleEncoding is RubyEncoding or Nil in this node @Primitive(name = "string_cmp") - public abstract static class CompareNode extends CoreMethodArrayArgumentsNode { + public abstract static class CompareNode extends PrimitiveArrayArgumentsNode { @Specialization(guards = "first.isEmpty() || second.isEmpty()") protected int empty(Object a, Object b, RubyEncoding compatibleEncoding, @@ -1506,7 +1506,7 @@ protected long hash(Object string, } @Primitive(name = "string_initialize") - public abstract static class InitializeNode extends CoreMethodArrayArgumentsNode { + public abstract static class InitializeNode extends PrimitiveArrayArgumentsNode { @Specialization protected RubyString initializeJavaString(RubyString string, String from, RubyEncoding encoding, @@ -3167,7 +3167,7 @@ protected boolean isMBCPrintable(Encoding encoding, int codePoint) { } @Primitive(name = "string_append") - public abstract static class StringAppendPrimitiveNode extends CoreMethodArrayArgumentsNode { + public abstract static class StringAppendPrimitiveNode extends PrimitiveArrayArgumentsNode { @Child private StringHelperNodes.StringAppendNode stringAppendNode = StringHelperNodes.StringAppendNode .create(); @@ -3438,7 +3438,7 @@ protected Object stringByteSubstring(Object string, Object range, Object length) /** Like {@code string.byteslice(byteIndex)} but returns nil if the character is broken. */ @Primitive(name = "string_chr_at", lowerFixnum = 1) @ImportStatic(StringGuards.class) - public abstract static class StringChrAtPrimitiveNode extends CoreMethodArrayArgumentsNode { + public abstract static class StringChrAtPrimitiveNode extends PrimitiveArrayArgumentsNode { @Specialization( guards = { "indexOutOfBounds(strings.byteLength(string), byteIndex)" }) @@ -3620,7 +3620,7 @@ private static String escapedCharFormat(int c, boolean isUnicode) { @Primitive(name = "string_find_character", lowerFixnum = 1) @ImportStatic(StringGuards.class) - public abstract static class StringFindCharacterNode extends CoreMethodArrayArgumentsNode { + public abstract static class StringFindCharacterNode extends PrimitiveArrayArgumentsNode { @Specialization(guards = "offset < 0") protected Object stringFindCharacterNegativeOffset(Object string, int offset) { @@ -4026,7 +4026,7 @@ protected Object other(Object string, int index, @Primitive(name = "find_string_reverse", lowerFixnum = 2) @ImportStatic(StringGuards.class) - public abstract static class StringRindexPrimitiveNode extends CoreMethodArrayArgumentsNode { + public abstract static class StringRindexPrimitiveNode extends PrimitiveArrayArgumentsNode { @Specialization protected Object stringRindex(Object rubyString, Object rubyPattern, int byteOffset, @@ -4242,7 +4242,7 @@ private Object bytesToInum(AbstractTruffleString rope, RubyEncoding encoding, in } @Primitive(name = "string_byte_append") - public abstract static class StringByteAppendPrimitiveNode extends CoreMethodArrayArgumentsNode { + public abstract static class StringByteAppendPrimitiveNode extends PrimitiveArrayArgumentsNode { @Specialization(guards = "libOther.isRubyString(other)", limit = "1") protected RubyString stringByteAppend(RubyString string, Object other, @Cached RubyStringLibrary libString, @@ -4262,7 +4262,7 @@ protected RubyString stringByteAppend(RubyString string, Object other, @Primitive(name = "string_substring", lowerFixnum = { 1, 2 }) @ImportStatic(StringGuards.class) - public abstract static class StringSubstringPrimitiveNode extends CoreMethodArrayArgumentsNode { + public abstract static class StringSubstringPrimitiveNode extends PrimitiveArrayArgumentsNode { public abstract Object execute(Object string, int codePointOffset, int codePointLength); diff --git a/src/main/java/org/truffleruby/core/thread/ThreadNodes.java b/src/main/java/org/truffleruby/core/thread/ThreadNodes.java index c5163ec2ee82..0e5d49f0b360 100644 --- a/src/main/java/org/truffleruby/core/thread/ThreadNodes.java +++ b/src/main/java/org/truffleruby/core/thread/ThreadNodes.java @@ -139,7 +139,7 @@ protected boolean alive(RubyThread thread) { } @Primitive(name = "thread_backtrace", lowerFixnum = { 1, 2 }) - public abstract static class BacktraceNode extends CoreMethodArrayArgumentsNode { + public abstract static class BacktraceNode extends PrimitiveArrayArgumentsNode { @Specialization protected Object backtrace(RubyThread rubyThread, int omit, NotProvided length) { @@ -182,7 +182,7 @@ public void run(RubyThread rubyThread, Node currentNode) { } @Primitive(name = "all_fibers_backtraces") - public abstract static class AllFibersBacktracesNode extends CoreMethodArrayArgumentsNode { + public abstract static class AllFibersBacktracesNode extends PrimitiveArrayArgumentsNode { @TruffleBoundary @Specialization diff --git a/src/main/java/org/truffleruby/extra/ConcurrentMapNodes.java b/src/main/java/org/truffleruby/extra/ConcurrentMapNodes.java index 8bd0ed5b0874..394b22672106 100644 --- a/src/main/java/org/truffleruby/extra/ConcurrentMapNodes.java +++ b/src/main/java/org/truffleruby/extra/ConcurrentMapNodes.java @@ -17,6 +17,7 @@ import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; +import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; import org.truffleruby.builtins.YieldingCoreMethodNode; import org.truffleruby.collections.ConcurrentOperations; import org.truffleruby.collections.SimpleEntry; @@ -56,7 +57,7 @@ protected RubyConcurrentMap allocate(RubyClass rubyClass) { } @Primitive(name = "concurrent_map_initialize", lowerFixnum = { 1, 2 }) - public abstract static class InitializeNode extends CoreMethodArrayArgumentsNode { + public abstract static class InitializeNode extends PrimitiveArrayArgumentsNode { @Specialization protected RubyConcurrentMap initializeWithOptions(RubyConcurrentMap self, int initialCapacity, int loadFactor) { diff --git a/src/main/java/org/truffleruby/extra/TrufflePosixNodes.java b/src/main/java/org/truffleruby/extra/TrufflePosixNodes.java index 5b1092cfb98c..8c861609f4d6 100644 --- a/src/main/java/org/truffleruby/extra/TrufflePosixNodes.java +++ b/src/main/java/org/truffleruby/extra/TrufflePosixNodes.java @@ -10,9 +10,9 @@ package org.truffleruby.extra; import com.oracle.truffle.api.dsl.Cached; -import org.truffleruby.builtins.CoreMethodArrayArgumentsNode; import org.truffleruby.builtins.CoreModule; import org.truffleruby.builtins.Primitive; +import org.truffleruby.builtins.PrimitiveArrayArgumentsNode; import org.truffleruby.core.time.GetTimeZoneNode; import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary; @@ -31,7 +31,7 @@ private static void invalidateENV(String name) { } @Primitive(name = "posix_invalidate_env") - public abstract static class InvalidateEnvNode extends CoreMethodArrayArgumentsNode { + public abstract static class InvalidateEnvNode extends PrimitiveArrayArgumentsNode { @TruffleBoundary @Specialization(guards = "libEnvVar.isRubyString(envVar)", limit = "1") diff --git a/src/main/java/org/truffleruby/interop/PolyglotNodes.java b/src/main/java/org/truffleruby/interop/PolyglotNodes.java index 444655758c27..ce0100d7d41a 100644 --- a/src/main/java/org/truffleruby/interop/PolyglotNodes.java +++ b/src/main/java/org/truffleruby/interop/PolyglotNodes.java @@ -212,7 +212,7 @@ protected RubyInnerContext newInnerContext( } @Primitive(name = "inner_context_eval") - public abstract static class InnerContextEvalNode extends CoreMethodArrayArgumentsNode { + public abstract static class InnerContextEvalNode extends PrimitiveArrayArgumentsNode { @Specialization(guards = { "idLib.isRubyString(langId)", "codeLib.isRubyString(code)", diff --git a/src/main/ruby/truffleruby/core/math.rb b/src/main/ruby/truffleruby/core/math.rb index 87349a0acb25..3f9846847ff1 100644 --- a/src/main/ruby/truffleruby/core/math.rb +++ b/src/main/ruby/truffleruby/core/math.rb @@ -20,7 +20,7 @@ def hypot(a, b) # Much faster (~10x) than calling the Math.hypot() / hypot(3) Math.sqrt(a*a + b*b) else - Primitive.math_hypot a, b + Primitive.math_hypot Truffle::Type.rb_num2dbl(a), Truffle::Type.rb_num2dbl(b) end end diff --git a/src/processor/java/org/truffleruby/processor/CoreModuleProcessor.java b/src/processor/java/org/truffleruby/processor/CoreModuleProcessor.java index 549369f1e8ce..b64ec704b938 100644 --- a/src/processor/java/org/truffleruby/processor/CoreModuleProcessor.java +++ b/src/processor/java/org/truffleruby/processor/CoreModuleProcessor.java @@ -95,6 +95,8 @@ public class CoreModuleProcessor extends TruffleRubyProcessor { // node types TypeMirror rubyNodeType; TypeMirror rubyBaseNodeType; + TypeMirror primitiveNodeType; + TypeMirror rubySourceNodeType; @Override public boolean process(Set annotations, RoundEnvironment roundEnvironment) { @@ -107,6 +109,8 @@ public boolean process(Set annotations, RoundEnvironment rootCallTargetType = elementUtils.getTypeElement("com.oracle.truffle.api.RootCallTarget").asType(); rubyNodeType = elementUtils.getTypeElement("org.truffleruby.language.RubyNode").asType(); rubyBaseNodeType = elementUtils.getTypeElement("org.truffleruby.language.RubyBaseNode").asType(); + primitiveNodeType = elementUtils.getTypeElement("org.truffleruby.builtins.PrimitiveNode").asType(); + rubySourceNodeType = elementUtils.getTypeElement("org.truffleruby.language.RubySourceNode").asType(); if (!annotations.isEmpty()) { for (Element element : roundEnvironment.getElementsAnnotatedWith(CoreModule.class)) { @@ -208,6 +212,11 @@ private void processCoreModule(TypeElement coreModuleElement) throws IOException if (primitive != null) { processPrimitive(stream, rubyPrimitives, coreModuleElement, klass, primitive); coreModuleChecks.checks(primitive.lowerFixnum(), null, klass, true); + if (!inherits(e.asType(), primitiveNodeType) && !inherits(e.asType(), rubySourceNodeType)) { + error(e + + " should inherit from PrimitiveArrayArgumentsNode, PrimitiveNode or RubySourceNode", + e); + } } } } diff --git a/src/processor/java/org/truffleruby/processor/TruffleRubyProcessor.java b/src/processor/java/org/truffleruby/processor/TruffleRubyProcessor.java index de8bb1f4ce2f..312136e95e81 100644 --- a/src/processor/java/org/truffleruby/processor/TruffleRubyProcessor.java +++ b/src/processor/java/org/truffleruby/processor/TruffleRubyProcessor.java @@ -31,6 +31,10 @@ boolean isSameType(TypeMirror type1, TypeMirror type2) { return processingEnv.getTypeUtils().isSameType(type1, type2); } + boolean inherits(TypeMirror type, TypeMirror base) { + return processingEnv.getTypeUtils().isSubtype(type, base); + } + void error(String message, Element element) { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, message, element); } From 44fb267151210b879b19a2f0f30e5773f5a206b9 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 16:54:22 +0200 Subject: [PATCH 34/46] Ensure all CoreMethods inherit from the right class --- .../java/org/truffleruby/interop/InteropNodes.java | 2 +- .../truffleruby/processor/CoreModuleProcessor.java | 13 +++++++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/src/main/java/org/truffleruby/interop/InteropNodes.java b/src/main/java/org/truffleruby/interop/InteropNodes.java index 9886246df2d4..5ba87fa01e73 100644 --- a/src/main/java/org/truffleruby/interop/InteropNodes.java +++ b/src/main/java/org/truffleruby/interop/InteropNodes.java @@ -1238,7 +1238,7 @@ protected boolean hasMembers(Object receiver, } @CoreMethod(names = "members", onSingleton = true, required = 1, optional = 1) - public abstract static class GetMembersNode extends PrimitiveArrayArgumentsNode { + public abstract static class GetMembersNode extends CoreMethodArrayArgumentsNode { protected abstract Object executeMembers(Object receiver, boolean internal); diff --git a/src/processor/java/org/truffleruby/processor/CoreModuleProcessor.java b/src/processor/java/org/truffleruby/processor/CoreModuleProcessor.java index b64ec704b938..1fa0f7346e3d 100644 --- a/src/processor/java/org/truffleruby/processor/CoreModuleProcessor.java +++ b/src/processor/java/org/truffleruby/processor/CoreModuleProcessor.java @@ -96,6 +96,8 @@ public class CoreModuleProcessor extends TruffleRubyProcessor { TypeMirror rubyNodeType; TypeMirror rubyBaseNodeType; TypeMirror primitiveNodeType; + TypeMirror coreMethodNodeType; + TypeMirror alwaysInlinedMethodNodeType; TypeMirror rubySourceNodeType; @Override @@ -110,8 +112,12 @@ public boolean process(Set annotations, RoundEnvironment rubyNodeType = elementUtils.getTypeElement("org.truffleruby.language.RubyNode").asType(); rubyBaseNodeType = elementUtils.getTypeElement("org.truffleruby.language.RubyBaseNode").asType(); primitiveNodeType = elementUtils.getTypeElement("org.truffleruby.builtins.PrimitiveNode").asType(); + coreMethodNodeType = elementUtils.getTypeElement("org.truffleruby.builtins.CoreMethodNode").asType(); + alwaysInlinedMethodNodeType = elementUtils + .getTypeElement("org.truffleruby.core.inlined.AlwaysInlinedMethodNode").asType(); rubySourceNodeType = elementUtils.getTypeElement("org.truffleruby.language.RubySourceNode").asType(); + if (!annotations.isEmpty()) { for (Element element : roundEnvironment.getElementsAnnotatedWith(CoreModule.class)) { try { @@ -193,6 +199,13 @@ private void processCoreModule(TypeElement coreModuleElement) throws IOException ? coreMethod : null; coreModuleChecks.checks(coreMethod.lowerFixnum(), checkAmbiguous, klass, needsSelf); + if (!inherits(e.asType(), coreMethodNodeType) && + !inherits(e.asType(), alwaysInlinedMethodNodeType) && + !inherits(e.asType(), rubySourceNodeType)) { + error(e + + " should inherit from CoreMethodArrayArgumentsNode, CoreMethodNode, AlwaysInlinedMethodNode or RubySourceNode", + e); + } processCoreMethod(stream, rubyStream, coreModuleElement, coreModule, klass, coreMethod, needsSelf); } From 18e5eef0069f5c663aac74b5948afde2a72466ef Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 17:11:15 +0200 Subject: [PATCH 35/46] Separate the Range.new core method and the RangeLiteralNode --- .../truffleruby/builtins/CoreMethodNode.java | 2 +- .../truffleruby/core/range/RangeNodes.java | 59 +++++++++++-------- .../literal/RangeClassLiteralNode.java | 29 --------- .../truffleruby/parser/BodyTranslator.java | 6 +- 4 files changed, 35 insertions(+), 61 deletions(-) delete mode 100644 src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodNode.java b/src/main/java/org/truffleruby/builtins/CoreMethodNode.java index 5adc2582aa8d..959bc3a295a8 100644 --- a/src/main/java/org/truffleruby/builtins/CoreMethodNode.java +++ b/src/main/java/org/truffleruby/builtins/CoreMethodNode.java @@ -19,7 +19,7 @@ public abstract class CoreMethodNode extends RubyContextSourceNode { @Override - public RubyNode cloneUninitialized() { + public final RubyNode cloneUninitialized() { throw CompilerDirectives.shouldNotReachHere( getClass() + " should be handled by RubyCoreMethodRootNode#cloneUninitializedRootNode()"); } diff --git a/src/main/java/org/truffleruby/core/range/RangeNodes.java b/src/main/java/org/truffleruby/core/range/RangeNodes.java index 83c495779be1..8d09b2b552a6 100644 --- a/src/main/java/org/truffleruby/core/range/RangeNodes.java +++ b/src/main/java/org/truffleruby/core/range/RangeNodes.java @@ -29,6 +29,7 @@ import org.truffleruby.core.proc.RubyProc; import org.truffleruby.language.RubyBaseNode; import org.truffleruby.language.RubyBaseNodeWithExecute; +import org.truffleruby.language.RubyContextSourceNode; import org.truffleruby.language.RubyGuards; import org.truffleruby.language.RubyNode; import org.truffleruby.language.RubySourceNode; @@ -38,7 +39,6 @@ import org.truffleruby.language.dispatch.DispatchNode; import org.truffleruby.language.objects.AllocationTracing; import org.truffleruby.language.yield.CallBlockNode; -import org.truffleruby.parser.BodyTranslator; import com.oracle.truffle.api.CompilerDirectives; import com.oracle.truffle.api.dsl.Cached; @@ -386,18 +386,42 @@ protected RubyBaseNodeWithExecute coerceToBoolean(RubyBaseNodeWithExecute exclud return BooleanCastWithDefaultNode.create(false, excludeEnd); } - abstract RubyNode getRubyClassNode(); + @Specialization + protected Object newRange(RubyClass rubyClass, Object begin, Object end, boolean excludeEnd, + @Cached NewRangeNode newRangeNode) { + return newRangeNode.execute(rubyClass, begin, end, excludeEnd); + } + } + + public static class RangeLiteralNode extends RubyContextSourceNode { - abstract RubyNode getBeginNode(); + @Child RubyNode beginNode; + @Child RubyNode endNode; + @Child NewRangeNode newRangeNode = RangeNodesFactory.NewRangeNodeGen.create(); + private final boolean excludeEnd; - abstract RubyNode getEndNode(); + public RangeLiteralNode(RubyNode beginNode, RubyNode endNode, boolean excludeEnd) { + this.beginNode = beginNode; + this.endNode = endNode; + this.excludeEnd = excludeEnd; + } - abstract RubyBaseNodeWithExecute getExcludeEndNode(); + @Override + public Object execute(VirtualFrame frame) { + Object begin = beginNode.execute(frame); + Object end = endNode.execute(frame); + return newRangeNode.execute(coreLibrary().rangeClass, begin, end, excludeEnd); + } - public static NewNode create(RubyNode rubyClass, RubyNode begin, RubyNode end, - RubyBaseNodeWithExecute excludeEnd) { - return RangeNodesFactory.NewNodeFactory.create(rubyClass, begin, end, excludeEnd); + @Override + public RubyNode cloneUninitialized() { + return new RangeLiteralNode(beginNode.cloneUninitialized(), endNode.cloneUninitialized(), excludeEnd); } + } + + public abstract static class NewRangeNode extends RubyBaseNode { + + public abstract Object execute(RubyClass rubyClass, Object begin, Object end, boolean excludeEnd); @Specialization(guards = "rubyClass == getRangeClass()") protected RubyIntRange intRange(RubyClass rubyClass, int begin, int end, boolean excludeEnd) { @@ -424,8 +448,7 @@ protected RubyObjectRange objectRange(RubyClass rubyClass, Object begin, Object } final Shape shape = getLanguage().objectRangeShape; - final RubyObjectRange range = new RubyObjectRange(rubyClass, shape, excludeEnd, begin, end, - standardClass); + final RubyObjectRange range = new RubyObjectRange(rubyClass, shape, excludeEnd, begin, end, standardClass); AllocationTracing.trace(range, this); return range; } @@ -433,22 +456,6 @@ protected RubyObjectRange objectRange(RubyClass rubyClass, Object begin, Object protected RubyClass getRangeClass() { return coreLibrary().rangeClass; } - - private RubyBaseNodeWithExecute getExcludeEndNodeBeforeCasting() { - return ((BooleanCastWithDefaultNode) getExcludeEndNode()).getValueNode(); - } - - /** Needed because it is used by {@link BodyTranslator#visitDotNode} */ - @Override - public RubyNode cloneUninitialized() { - var copy = create( - getRubyClassNode().cloneUninitialized(), - getBeginNode().cloneUninitialized(), - getEndNode().cloneUninitialized(), - getExcludeEndNodeBeforeCasting().cloneUninitialized()); - return copy.copyFlags(this); - } - } @GenerateUncached diff --git a/src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java b/src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java deleted file mode 100644 index 40c9fe5e0092..000000000000 --- a/src/main/java/org/truffleruby/language/literal/RangeClassLiteralNode.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved. This - * code is released under a tri EPL/GPL/LGPL license. You can use it, - * redistribute it and/or modify it under the terms of the: - * - * Eclipse Public License version 2.0, or - * GNU General Public License version 2, or - * GNU Lesser General Public License version 2.1. - */ -package org.truffleruby.language.literal; - -import com.oracle.truffle.api.frame.VirtualFrame; -import org.truffleruby.language.RubyContextSourceNode; -import org.truffleruby.language.RubyNode; - -public class RangeClassLiteralNode extends RubyContextSourceNode { - - @Override - public Object execute(VirtualFrame frame) { - return getContext().getCoreLibrary().rangeClass; - } - - @Override - public RubyNode cloneUninitialized() { - var copy = new RangeClassLiteralNode(); - return copy.copyFlags(this); - } - -} diff --git a/src/main/java/org/truffleruby/parser/BodyTranslator.java b/src/main/java/org/truffleruby/parser/BodyTranslator.java index ed995cfdf38f..9f71cd2ce759 100644 --- a/src/main/java/org/truffleruby/parser/BodyTranslator.java +++ b/src/main/java/org/truffleruby/parser/BodyTranslator.java @@ -122,7 +122,6 @@ import org.truffleruby.language.literal.NilLiteralNode; import org.truffleruby.language.literal.ObjectClassLiteralNode; import org.truffleruby.language.literal.ObjectLiteralNode; -import org.truffleruby.language.literal.RangeClassLiteralNode; import org.truffleruby.language.literal.StringLiteralNode; import org.truffleruby.language.literal.TruffleInternalModuleLiteralNode; import org.truffleruby.language.literal.TruffleKernelOperationsModuleLiteralNode; @@ -1532,10 +1531,7 @@ public RubyNode visitDotNode(DotParseNode node) { } else { final RubyNode begin = node.getBeginNode().accept(this); final RubyNode end = node.getEndNode().accept(this); - final RubyNode rangeClass = new RangeClassLiteralNode(); - final RubyNode isExclusive = new ObjectLiteralNode(node.isExclusive()); - - ret = RangeNodes.NewNode.create(rangeClass, begin, end, isExclusive); + ret = new RangeNodes.RangeLiteralNode(begin, end, node.isExclusive()); } ret.unsafeSetSourceSection(sourceSection); return addNewlineIfNeeded(node, ret); From 197ca790c94288f0a2e450a07ac9f0627187e1bd Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 17:36:04 +0200 Subject: [PATCH 36/46] Cleanup --- .../builtins/CoreMethodArrayArgumentsNode.java | 2 -- .../java/org/truffleruby/builtins/PrimitiveManager.java | 9 --------- 2 files changed, 11 deletions(-) diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java b/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java index 8b4477f46663..636cad3c7285 100644 --- a/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java +++ b/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java @@ -16,6 +16,4 @@ @NodeChild(value = "argumentNodes", type = RubyNode[].class) public abstract class CoreMethodArrayArgumentsNode extends CoreMethodNode { - public abstract RubyNode[] getArgumentNodes(); - } diff --git a/src/main/java/org/truffleruby/builtins/PrimitiveManager.java b/src/main/java/org/truffleruby/builtins/PrimitiveManager.java index 535cc7a7736e..1f1e01f700a2 100644 --- a/src/main/java/org/truffleruby/builtins/PrimitiveManager.java +++ b/src/main/java/org/truffleruby/builtins/PrimitiveManager.java @@ -20,7 +20,6 @@ import com.oracle.truffle.api.TruffleOptions; import com.oracle.truffle.api.dsl.NodeFactory; -import org.truffleruby.language.RubySourceNode; import org.truffleruby.options.LanguageOptions; /** Manages the available primitive calls. */ @@ -58,20 +57,12 @@ private PrimitiveNodeConstructor loadLazyPrimitive(String lazyPrimitive) { public PrimitiveNodeConstructor addPrimitive(NodeFactory nodeFactory, Primitive annotation) { - assert assertNodeClass(nodeFactory.getNodeClass()); return ConcurrentOperations.getOrCompute( primitives, annotation.name(), k -> new PrimitiveNodeConstructor(annotation, nodeFactory)); } - private boolean assertNodeClass(Class nodeClass) { - // Note already checked in CoreModuleProcessor - assert PrimitiveNode.class.isAssignableFrom(nodeClass) || RubySourceNode.class.isAssignableFrom(nodeClass) - : nodeClass + " should inherit from PrimitiveArrayArgumentsNode, PrimitiveNode or RubySourceNode"; - return true; - } - public void loadCoreMethodNodes(LanguageOptions languageOptions) { if (!TruffleOptions.AOT && languageOptions.LAZY_BUILTINS) { BuiltinsClasses.setupBuiltinsLazyPrimitives(this); From 819319df635736460278b4ea64048d87a9e754ec Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 17:39:59 +0200 Subject: [PATCH 37/46] ReRaiseInlinedExceptionNode should never be split --- .../java/org/truffleruby/builtins/CoreMethodNodeManager.java | 2 +- .../org/truffleruby/builtins/ReRaiseInlinedExceptionNode.java | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java b/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java index d7ae375fc757..93b70bf0ab5e 100644 --- a/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java +++ b/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java @@ -349,7 +349,7 @@ public static RootCallTarget createCoreMethodCallTarget(NodeFactory Date: Fri, 7 Oct 2022 18:08:24 +0200 Subject: [PATCH 38/46] Ensure cloneUninitialized() does not return a node from the initialized AST --- .../core/regexp/InterpolatedRegexpNode.java | 8 ++----- .../truffleruby/language/RubyRootNode.java | 23 +++++++++++++++---- 2 files changed, 20 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java b/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java index f6f1963584e3..a55fa887d363 100644 --- a/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java +++ b/src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java @@ -35,12 +35,8 @@ public class InterpolatedRegexpNode extends RubyContextSourceNode { @Child private AsTruffleStringNode asTruffleStringNode = AsTruffleStringNode.create(); public InterpolatedRegexpNode(ToSNode[] children, RegexpOptions options) { - this(children, RegexpBuilderNode.create(options)); - } - - public InterpolatedRegexpNode(ToSNode[] children, RegexpBuilderNode builderNode) { this.children = children; - this.builderNode = builderNode; + this.builderNode = RegexpBuilderNode.create(options); } @Override @@ -64,7 +60,7 @@ protected TStringWithEncoding[] executeChildren(VirtualFrame frame) { public RubyNode cloneUninitialized() { var copy = new InterpolatedRegexpNode( cloneUninitialized(children), - builderNode); + builderNode.options); return copy.copyFlags(this); } diff --git a/src/main/java/org/truffleruby/language/RubyRootNode.java b/src/main/java/org/truffleruby/language/RubyRootNode.java index 8d4bcca06cb2..822d924bc1ea 100644 --- a/src/main/java/org/truffleruby/language/RubyRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyRootNode.java @@ -28,6 +28,7 @@ import org.truffleruby.parser.ParentFrameDescriptor; import java.util.ArrayList; +import java.util.IdentityHashMap; public class RubyRootNode extends RubyBaseRootNode { @@ -173,8 +174,14 @@ private void ensureCloneUninitializedCorrectness(RubyRootNode clone) { .shouldNotReachHere("different clone class: " + this.getClass() + " vs " + clone.getClass()); } + IdentityHashMap specializedNodes = new IdentityHashMap<>(); + this.body.accept((node) -> { + specializedNodes.put(node, true); + return true; + }); + try { - ensureClonedCorrectly(bodyCopy, clone.body); + ensureClonedCorrectly(bodyCopy, clone.body, specializedNodes); } catch (CloningError e) { System.err.println(); @@ -201,15 +208,21 @@ private void ensureCloneUninitializedCorrectness(RubyRootNode clone) { } } - private void ensureClonedCorrectly(Node original, Node clone) { + private void ensureClonedCorrectly(Node original, Node clone, IdentityHashMap specializedNodes) { // A clone should be a new instance + // Actually this should never happen since the bodyCopy is separate from the initialized AST if (original == clone) { - throw new CloningError("Original node equals a clone", original, clone); + throw new CloningError("Clone is the same instance as the original node", original, clone); + } + + // A clone should never be a node from the initialized/specialized AST + if (specializedNodes.containsKey(clone)) { + throw new CloningError("Clone is a node from the initialized AST", clone, clone); } // Ignore instrumental wrappers (e.g. RubyNodeWrapper) if (original instanceof WrapperNode) { - ensureClonedCorrectly(((WrapperNode) original).getDelegateNode(), clone); + ensureClonedCorrectly(((WrapperNode) original).getDelegateNode(), clone, specializedNodes); return; } @@ -228,7 +241,7 @@ private void ensureClonedCorrectly(Node original, Node clone) { // Should have the same children for (int i = 0; i < cloneChildren.length; i++) { - ensureClonedCorrectly(originalChildren[i], cloneChildren[i]); + ensureClonedCorrectly(originalChildren[i], cloneChildren[i], specializedNodes); } } From 61d75945bb2ff0f32b8e31af3ca9ed1b75595132 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 18:19:24 +0200 Subject: [PATCH 39/46] Make ModuleBodyDefinition not a Node since it should not be copied and has no state nor execute() --- ...finitionNode.java => ModuleBodyDefinition.java} | 14 +++++++------- .../language/objects/RunModuleDefinitionNode.java | 12 ++++++------ .../org/truffleruby/parser/BodyTranslator.java | 8 ++++---- 3 files changed, 17 insertions(+), 17 deletions(-) rename src/main/java/org/truffleruby/language/methods/{ModuleBodyDefinitionNode.java => ModuleBodyDefinition.java} (91%) diff --git a/src/main/java/org/truffleruby/language/methods/ModuleBodyDefinitionNode.java b/src/main/java/org/truffleruby/language/methods/ModuleBodyDefinition.java similarity index 91% rename from src/main/java/org/truffleruby/language/methods/ModuleBodyDefinitionNode.java rename to src/main/java/org/truffleruby/language/methods/ModuleBodyDefinition.java index e97d0a0b0559..f64c24f09c86 100644 --- a/src/main/java/org/truffleruby/language/methods/ModuleBodyDefinitionNode.java +++ b/src/main/java/org/truffleruby/language/methods/ModuleBodyDefinition.java @@ -24,7 +24,7 @@ import com.oracle.truffle.api.frame.VirtualFrame; /** Define a method from a module body (module/class/class << self ... end). */ -public class ModuleBodyDefinitionNode extends RubyBaseNode { +public final class ModuleBodyDefinition { private final String name; private final SharedMethodInfo sharedMethodInfo; @@ -33,7 +33,7 @@ public class ModuleBodyDefinitionNode extends RubyBaseNode { private final LexicalScope staticLexicalScope; private final Map dynamicLexicalScopes; - public ModuleBodyDefinitionNode( + public ModuleBodyDefinition( String name, SharedMethodInfo sharedMethodInfo, RootCallTarget callTarget, @@ -45,15 +45,15 @@ public ModuleBodyDefinitionNode( this.dynamicLexicalScopes = staticLexicalScope != null ? null : new ConcurrentHashMap<>(); } - public InternalMethod createMethod(VirtualFrame frame, RubyModule module) { + public InternalMethod createMethod(VirtualFrame frame, RubyModule module, RubyBaseNode node) { final LexicalScope parentLexicalScope = RubyArguments.getMethod(frame).getLexicalScope(); - final LexicalScope lexicalScope = prepareLexicalScope(staticLexicalScope, parentLexicalScope, module); + final LexicalScope lexicalScope = prepareLexicalScope(staticLexicalScope, parentLexicalScope, module, node); final DeclarationContext declarationContext = new DeclarationContext( Visibility.PUBLIC, new DeclarationContext.FixedDefaultDefinee(module), RubyArguments.getDeclarationContext(frame).getRefinements()); return new InternalMethod( - getContext(), + node.getContext(), sharedMethodInfo, lexicalScope, declarationContext, @@ -69,11 +69,11 @@ public InternalMethod createMethod(VirtualFrame frame, RubyModule module) { @TruffleBoundary private LexicalScope prepareLexicalScope(LexicalScope staticLexicalScope, LexicalScope parentLexicalScope, - RubyModule module) { + RubyModule module, RubyBaseNode node) { if (staticLexicalScope != null) { staticLexicalScope.unsafeSetLiveModule(module); return staticLexicalScope; - } else if (getLanguage().singleContext) { + } else if (node.getLanguage().singleContext) { // Cache the scope per module in case the module body is run multiple times. // This allows dynamic constant lookup to cache better. return ConcurrentOperations.getOrCompute( diff --git a/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java b/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java index cfed24d3156b..5872450b4643 100644 --- a/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java +++ b/src/main/java/org/truffleruby/language/objects/RunModuleDefinitionNode.java @@ -15,7 +15,7 @@ import org.truffleruby.language.arguments.EmptyArgumentsDescriptor; import org.truffleruby.language.arguments.RubyArguments; import org.truffleruby.language.methods.InternalMethod; -import org.truffleruby.language.methods.ModuleBodyDefinitionNode; +import org.truffleruby.language.methods.ModuleBodyDefinition; import com.oracle.truffle.api.Truffle; import com.oracle.truffle.api.frame.VirtualFrame; @@ -24,18 +24,18 @@ public class RunModuleDefinitionNode extends RubyContextSourceNode { @Child private RubyNode definingModule; - @Child private ModuleBodyDefinitionNode definitionMethod; + private final ModuleBodyDefinition moduleBodyDefinition; @Child private IndirectCallNode callModuleDefinitionNode = Truffle.getRuntime().createIndirectCallNode(); - public RunModuleDefinitionNode(ModuleBodyDefinitionNode definition, RubyNode definingModule) { + public RunModuleDefinitionNode(ModuleBodyDefinition definition, RubyNode definingModule) { this.definingModule = definingModule; - this.definitionMethod = definition; + this.moduleBodyDefinition = definition; } @Override public Object execute(VirtualFrame frame) { final RubyModule module = (RubyModule) definingModule.execute(frame); - final InternalMethod definition = definitionMethod.createMethod(frame, module); + final InternalMethod definition = moduleBodyDefinition.createMethod(frame, module, this); return callModuleDefinitionNode.call(definition.getCallTarget(), RubyArguments.pack( null, @@ -51,7 +51,7 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { var copy = new RunModuleDefinitionNode( - definitionMethod, + moduleBodyDefinition, definingModule.cloneUninitialized()); return copy.copyFlags(this); } diff --git a/src/main/java/org/truffleruby/parser/BodyTranslator.java b/src/main/java/org/truffleruby/parser/BodyTranslator.java index 9f71cd2ce759..e3bb01f2c216 100644 --- a/src/main/java/org/truffleruby/parser/BodyTranslator.java +++ b/src/main/java/org/truffleruby/parser/BodyTranslator.java @@ -137,7 +137,7 @@ import org.truffleruby.language.methods.CatchBreakNode; import org.truffleruby.language.methods.GetDefaultDefineeNode; import org.truffleruby.language.methods.LiteralMethodDefinitionNode; -import org.truffleruby.language.methods.ModuleBodyDefinitionNode; +import org.truffleruby.language.methods.ModuleBodyDefinition; import org.truffleruby.language.methods.SharedMethodInfo; import org.truffleruby.language.methods.Split; import org.truffleruby.language.objects.DefineClassNode; @@ -1056,7 +1056,7 @@ private RubyNode openModule(SourceIndexLength sourceSection, RubyNode defineOrGe currentNode, rubyWarnings); - final ModuleBodyDefinitionNode definition = moduleTranslator.compileClassNode(sourceSection, bodyNode); + final ModuleBodyDefinition definition = moduleTranslator.compileClassNode(sourceSection, bodyNode); return Translator.withSourceSection(sourceSection, new RunModuleDefinitionNode(definition, defineOrGetNode)); } @@ -1068,7 +1068,7 @@ private RubyNode openModule(SourceIndexLength sourceSection, RubyNode defineOrGe * a special method. We run that method with self set to be the newly allocated module or class. *

*/ - private ModuleBodyDefinitionNode compileClassNode(SourceIndexLength sourceSection, ParseNode bodyNode) { + private ModuleBodyDefinition compileClassNode(SourceIndexLength sourceSection, ParseNode bodyNode) { RubyNode body = translateNodeOrNil(sourceSection, bodyNode); body = new InsideModuleDefinitionNode(body); @@ -1092,7 +1092,7 @@ private ModuleBodyDefinitionNode compileClassNode(SourceIndexLength sourceSectio Split.NEVER, environment.getReturnID()); - return new ModuleBodyDefinitionNode( + return new ModuleBodyDefinition( environment.getSharedMethodInfo().getBacktraceName(), environment.getSharedMethodInfo(), rootNode.getCallTarget(), From fc803588535f7b129a5582da099577f18161bd01 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 19:15:05 +0200 Subject: [PATCH 40/46] Clone all call targets which allow it with --check-clone-uninitialized-correctness --- .../truffleruby/core/inlined/InlinedReplaceableNode.java | 2 +- src/main/java/org/truffleruby/language/RubyNode.java | 8 ++++---- src/main/java/org/truffleruby/language/RubyRootNode.java | 6 ++++++ .../org/truffleruby/language/yield/CallBlockNode.java | 2 +- 4 files changed, 12 insertions(+), 6 deletions(-) diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java index f7844056f91b..6d9407ea8cff 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java @@ -36,7 +36,7 @@ protected InlinedReplaceableNode( RubyCallNodeParameters callNodeParameters, Assumption... assumptions) { // nullify receiver, arguments and block for clarity - // because they should be overriden in subclasses. + // because they should be overridden in subclasses. this.parameters = callNodeParameters.withoutNodes(); this.assumptions = new Assumption[1 + assumptions.length]; diff --git a/src/main/java/org/truffleruby/language/RubyNode.java b/src/main/java/org/truffleruby/language/RubyNode.java index 3c26f1bdc463..8c01bda73248 100644 --- a/src/main/java/org/truffleruby/language/RubyNode.java +++ b/src/main/java/org/truffleruby/language/RubyNode.java @@ -319,6 +319,10 @@ Object getRootInstance(Frame frame, public abstract RubyNode cloneUninitialized(); + protected static RubyNode cloneUninitialized(RubyNode node) { + return (node == null) ? null : node.cloneUninitialized(); + } + protected static RubyNode[] cloneUninitialized(RubyNode[] nodes) { if (nodes == null) { return null; @@ -331,8 +335,4 @@ protected static RubyNode[] cloneUninitialized(RubyNode[] nodes) { return copies; } - protected static RubyNode cloneUninitialized(RubyNode node) { - return (node == null) ? null : node.cloneUninitialized(); - } - } diff --git a/src/main/java/org/truffleruby/language/RubyRootNode.java b/src/main/java/org/truffleruby/language/RubyRootNode.java index 822d924bc1ea..f130c3fcf78a 100644 --- a/src/main/java/org/truffleruby/language/RubyRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyRootNode.java @@ -96,6 +96,12 @@ public boolean isCloningAllowed() { } public boolean shouldAlwaysClone() { + assert isCloningAllowed(); + + if (getLanguage().options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + return split != Split.NEVER; + } + return split == Split.ALWAYS; } diff --git a/src/main/java/org/truffleruby/language/yield/CallBlockNode.java b/src/main/java/org/truffleruby/language/yield/CallBlockNode.java index 050d32a82d40..723f7bc87888 100644 --- a/src/main/java/org/truffleruby/language/yield/CallBlockNode.java +++ b/src/main/java/org/truffleruby/language/yield/CallBlockNode.java @@ -111,7 +111,7 @@ private Object[] packArguments(DeclarationContext declarationContext, RubyProc b protected DirectCallNode createBlockCallNode(RootCallTarget callTarget) { final DirectCallNode callNode = Truffle.getRuntime().createDirectCallNode(callTarget); - if (RubyRootNode.of(callTarget).shouldAlwaysClone() && callNode.isCallTargetCloningAllowed()) { + if (callNode.isCallTargetCloningAllowed() && RubyRootNode.of(callTarget).shouldAlwaysClone()) { callNode.cloneCallTarget(); } From 47a28720beefa97ad639b1f530b62dfbefb2dadd Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 19:17:58 +0200 Subject: [PATCH 41/46] Fix issues discovered by the improved check --- .../core/array/ArrayLiteralNode.java | 6 +- .../core/array/MultipleAssignmentNode.java | 2 +- .../core/basicobject/BasicObjectNodes.java | 4 +- .../core/binding/BindingNodes.java | 6 +- .../core/inlined/InlinedReplaceableNode.java | 2 +- .../truffleruby/core/kernel/KernelNodes.java | 4 +- .../truffleruby/core/module/ModuleNodes.java | 62 +++++++++++++++---- .../truffleruby/core/range/RangeNodes.java | 5 +- .../core/regexp/MatchDataNodes.java | 58 ++++++++++++----- .../truffleruby/core/string/StringNodes.java | 2 +- .../truffleruby/core/support/TypeNodes.java | 2 +- .../org/truffleruby/interop/InteropNodes.java | 26 ++++---- .../truffleruby/interop/ToJavaStringNode.java | 2 +- .../language/RubyContextSourceNode.java | 10 +-- .../org/truffleruby/language/RubyNode.java | 2 +- .../truffleruby/language/RubyRootNode.java | 27 ++++++-- .../truffleruby/language/RubySourceNode.java | 7 +++ .../locals/DeclarationFlipFlopStateNode.java | 39 ------------ .../language/locals/FlipFlopNode.java | 40 ++++++++---- .../language/locals/FlipFlopStateNode.java | 22 ------- .../locals/LocalFlipFlopStateNode.java | 32 ---------- .../methods/GetDefaultDefineeNode.java | 31 ---------- .../methods/LiteralMethodDefinitionNode.java | 6 +- .../language/objects/DefineClassNode.java | 2 +- .../language/objects/SingletonClassNode.java | 2 +- .../truffleruby/parser/BodyTranslator.java | 52 ++++++---------- .../truffleruby/parser/MethodTranslator.java | 4 +- 27 files changed, 217 insertions(+), 240 deletions(-) delete mode 100644 src/main/java/org/truffleruby/language/locals/DeclarationFlipFlopStateNode.java delete mode 100644 src/main/java/org/truffleruby/language/locals/FlipFlopStateNode.java delete mode 100644 src/main/java/org/truffleruby/language/locals/LocalFlipFlopStateNode.java delete mode 100644 src/main/java/org/truffleruby/language/methods/GetDefaultDefineeNode.java diff --git a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java index e3e7ebe1b444..b53a0cdd370b 100644 --- a/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java +++ b/src/main/java/org/truffleruby/core/array/ArrayLiteralNode.java @@ -37,7 +37,7 @@ public ArrayLiteralNode(RubyLanguage language, RubyNode[] values) { protected RubyArray makeGeneric(VirtualFrame frame, Object[] alreadyExecuted) { final ArrayLiteralNode newNode = new ObjectArrayLiteralNode(language, values); - newNode.unsafeSetSourceSection(getSourceIndexLength()); + newNode.copyFlags(this); replace(newNode); final Object[] executedValues = new Object[values.length]; @@ -261,7 +261,7 @@ public RubyArray execute(VirtualFrame frame) { executedValues.length); final Object store = array.getStore(); - final RubyNode newNode; + final ArrayLiteralNode newNode; if (store == ArrayStoreLibrary.initialStorage(false)) { newNode = new EmptyArrayLiteralNode(language, values); @@ -275,7 +275,7 @@ public RubyArray execute(VirtualFrame frame) { newNode = new ObjectArrayLiteralNode(language, values); } - newNode.unsafeSetSourceSection(getSourceIndexLength()); + newNode.copyFlags(this); replace(newNode); return array; diff --git a/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java b/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java index 34ec41675e17..907a2dc87a57 100644 --- a/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java +++ b/src/main/java/org/truffleruby/core/array/MultipleAssignmentNode.java @@ -126,7 +126,7 @@ public RubyNode cloneUninitialized() { cloneUninitializedAssignable(restNode), cloneUninitializedAssignable(postNodes), (SplatCastNode) splatCastNode.cloneUninitialized(), - rhsNode.cloneUninitialized()); + RubyNode.cloneUninitialized(rhsNode)); return copy.copyFlags(this); } diff --git a/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java b/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java index cc230a9fb35d..18947f8c121e 100644 --- a/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java +++ b/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java @@ -202,7 +202,7 @@ protected static boolean comparablePrimitives(Object a, Object b) { @Override public RubyNode cloneUninitialized() { - return create(cloneUninitialized(getArgumentNodes())); + return create(cloneUninitialized(getArgumentNodes())).copyFlags(this); } } @@ -329,7 +329,7 @@ protected int objectIDForeign(Object value, @Override public RubyNode cloneUninitialized() { - return create(getValueNode().cloneUninitialized()); + return create(getValueNode().cloneUninitialized()).copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/binding/BindingNodes.java b/src/main/java/org/truffleruby/core/binding/BindingNodes.java index 50982114a981..914d73e17948 100644 --- a/src/main/java/org/truffleruby/core/binding/BindingNodes.java +++ b/src/main/java/org/truffleruby/core/binding/BindingNodes.java @@ -271,7 +271,7 @@ private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { public RubyNode cloneUninitialized() { return create( getBindingNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized()); + getNameNodeBeforeCasting().cloneUninitialized()).copyFlags(this); } } @@ -336,7 +336,7 @@ private RubyBaseNodeWithExecute getNameNodeBeforeCasting() { public RubyNode cloneUninitialized() { return create( getBindingNode().cloneUninitialized(), - getNameNodeBeforeCasting().cloneUninitialized()); + getNameNodeBeforeCasting().cloneUninitialized()).copyFlags(this); } } @@ -455,7 +455,7 @@ public RubyNode cloneUninitialized() { return create( getBindingNode().cloneUninitialized(), getNameNodeBeforeCasting().cloneUninitialized(), - getValueNode().cloneUninitialized()); + getValueNode().cloneUninitialized()).copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java b/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java index 6d9407ea8cff..dfdae8b08f3f 100644 --- a/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java +++ b/src/main/java/org/truffleruby/core/inlined/InlinedReplaceableNode.java @@ -57,7 +57,7 @@ protected RubyCallNode rewriteToCallNode() { getReceiverNode(), getArgumentNodes(), getBlockNode())); - callNode.unsafeSetSourceSection(getSourceIndexLength()); + callNode.copyFlags(this); replacedBy = callNode; return replace(callNode, this + " could not be executed inline"); } else { diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java index 4e28dbae1d57..7bf3f99704fd 100644 --- a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java +++ b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java @@ -1873,7 +1873,7 @@ protected String toHexString(RubyBignum value) { @Override public RubyNode cloneUninitialized() { - return create(getValueNode().cloneUninitialized()); + return create(getValueNode().cloneUninitialized()).copyFlags(this); } } @@ -1934,7 +1934,7 @@ public static String uncachedBasicToS(RubyDynamicObject self) { @Override public RubyNode cloneUninitialized() { - return create(getSelfNode().cloneUninitialized()); + return create(getSelfNode().cloneUninitialized()).copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/module/ModuleNodes.java b/src/main/java/org/truffleruby/core/module/ModuleNodes.java index 4ed72c487a21..a925e9ce992a 100644 --- a/src/main/java/org/truffleruby/core/module/ModuleNodes.java +++ b/src/main/java/org/truffleruby/core/module/ModuleNodes.java @@ -342,26 +342,54 @@ protected RubyBaseNodeWithExecute coerceOldNameToSymbol(RubyBaseNodeWithExecute } @Specialization - protected RubySymbol aliasMethod(RubyModule module, RubySymbol newName, RubySymbol oldName, - @Cached BranchProfile errorProfile) { + protected RubySymbol aliasMethod(RubyModule module, RubySymbol newName, RubySymbol oldName) { + return aliasMethod(module, newName, oldName, this); + } + + @TruffleBoundary + static RubySymbol aliasMethod(RubyModule module, RubySymbol newName, RubySymbol oldName, RubyNode node) { + RubyContext context = node.getContext(); + module.fields.checkFrozen(context, node); + final InternalMethod method = module.fields - .deepMethodSearch(getContext(), oldName.getString()); + .deepMethodSearch(context, oldName.getString()); if (method == null) { - errorProfile.enter(); - throw new RaiseException(getContext(), getContext().getCoreExceptions().nameErrorUndefinedMethod( + throw new RaiseException(context, context.getCoreExceptions().nameErrorUndefinedMethod( oldName.getString(), module, - this)); + node)); } final InternalMethod aliasMethod = method.withName(newName.getString()); - module.addMethodConsiderNameVisibility(getContext(), aliasMethod, aliasMethod.getVisibility(), this); + module.addMethodConsiderNameVisibility(context, aliasMethod, aliasMethod.getVisibility(), node); return newName; } } + public static class AliasKeywordNode extends RubyContextSourceNode { + + private final RubySymbol newName; + private final RubySymbol oldName; + + public AliasKeywordNode(RubySymbol newName, RubySymbol oldName) { + this.newName = newName; + this.oldName = oldName; + } + + @Override + public Object execute(VirtualFrame frame) { + var module = RubyArguments.getDeclarationContext(frame).getModuleToDefineMethods(); + return AliasMethodNode.aliasMethod(module, newName, oldName, this); + } + + @Override + public RubyNode cloneUninitialized() { + return new AliasKeywordNode(newName, oldName).copyFlags(this); + } + } + @CoreMethod(names = "ancestors") public abstract static class AncestorsNode extends CoreMethodArrayArgumentsNode { @@ -2232,15 +2260,27 @@ protected RubyModule undefMethods(RubyModule module, Object[] names, } return module; } + } - /** Used only by undef keyword {@link org.truffleruby.parser.BodyTranslator#visitUndefNode} */ - @TruffleBoundary - @Specialization - protected RubyModule undefKeyword(RubyModule module, RubySymbol name) { + public static class UndefKeywordNode extends RubyContextSourceNode { + + private final RubySymbol name; + + public UndefKeywordNode(RubySymbol name) { + this.name = name; + } + + @Override + public Object execute(VirtualFrame frame) { + var module = RubyArguments.getDeclarationContext(frame).getModuleToDefineMethods(); module.fields.undefMethod(getLanguage(), getContext(), this, name.getString()); return module; } + @Override + public RubyNode cloneUninitialized() { + return new UndefKeywordNode(name).copyFlags(this); + } } @CoreMethod(names = "used_modules", onSingleton = true) diff --git a/src/main/java/org/truffleruby/core/range/RangeNodes.java b/src/main/java/org/truffleruby/core/range/RangeNodes.java index 8d09b2b552a6..e3e849471ae6 100644 --- a/src/main/java/org/truffleruby/core/range/RangeNodes.java +++ b/src/main/java/org/truffleruby/core/range/RangeNodes.java @@ -415,7 +415,8 @@ public Object execute(VirtualFrame frame) { @Override public RubyNode cloneUninitialized() { - return new RangeLiteralNode(beginNode.cloneUninitialized(), endNode.cloneUninitialized(), excludeEnd); + return new RangeLiteralNode(beginNode.cloneUninitialized(), endNode.cloneUninitialized(), excludeEnd) + .copyFlags(this); } } @@ -486,7 +487,7 @@ protected RubyObjectRange allocate(RubyClass rubyClass) { @Override public RubyNode cloneUninitialized() { - return create(getRubyClassNode().cloneUninitialized()); + return create(getRubyClassNode().cloneUninitialized()).copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java b/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java index dc0479bf1f75..920ddd3a5c88 100644 --- a/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java +++ b/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java @@ -13,6 +13,7 @@ import java.util.Iterator; import com.oracle.truffle.api.TruffleSafepoint; +import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.interop.InteropException; import com.oracle.truffle.api.interop.InteropLibrary; import com.oracle.truffle.api.profiles.LoopConditionProfile; @@ -34,13 +35,14 @@ import org.truffleruby.core.encoding.RubyEncoding; import org.truffleruby.core.klass.RubyClass; import org.truffleruby.core.range.RubyIntRange; -import org.truffleruby.core.regexp.MatchDataNodesFactory.ValuesNodeFactory; import org.truffleruby.core.string.RubyString; import org.truffleruby.core.string.StringHelperNodes.SingleByteOptimizableNode; import org.truffleruby.core.string.StringSupport; import org.truffleruby.core.string.StringUtils; import org.truffleruby.core.symbol.RubySymbol; import org.truffleruby.language.NotProvided; +import org.truffleruby.language.RubyBaseNode; +import org.truffleruby.language.RubyContextSourceNode; import org.truffleruby.language.RubyNode; import org.truffleruby.language.Visibility; import org.truffleruby.language.control.RaiseException; @@ -229,20 +231,12 @@ protected Object create(Object regexp, Object string, int start, int end) { } - @CoreMethod( - names = "[]", - required = 1, - optional = 1, - lowerFixnum = { 1, 2 }, - argumentNames = { "index_start_range_or_name", "length" }) - public abstract static class GetIndexNode extends CoreMethodArrayArgumentsNode { + public abstract static class GetIndexNode extends RubyBaseNode { @Child private RegexpNode regexpNode; @Child private ValuesNode getValuesNode = ValuesNode.create(); - public static GetIndexNode create(RubyNode... nodes) { - return MatchDataNodesFactory.GetIndexNodeFactory.create(nodes); - } + protected abstract Object execute(RubyMatchData matchData, Object index, Object length); protected abstract Object executeGetIndex(Object matchData, int index, NotProvided length); @@ -323,7 +317,7 @@ protected Object getIndexSymbolKnownRegexp(RubyMatchData matchData, RubySymbol s } } - @Specialization + @Specialization(replaces = "getIndexSymbolKnownRegexp") protected Object getIndexSymbol(RubyMatchData matchData, RubySymbol symbol, NotProvided length, @Cached ConditionProfile lazyProfile, @CachedLibrary(limit = "getInteropCacheLimit()") InteropLibrary libInterop) { @@ -444,6 +438,42 @@ protected static int backRefIndex(NameEntry nameEntry) { } } + @CoreMethod(names = "[]", required = 1, optional = 1, lowerFixnum = { 1, 2 }) + public abstract static class GetIndexCoreMethodNode extends CoreMethodArrayArgumentsNode { + public static GetIndexCoreMethodNode create(RubyNode... nodes) { + return MatchDataNodesFactory.GetIndexCoreMethodNodeFactory.create(nodes); + } + + @Specialization + protected Object getIndex(RubyMatchData matchData, Object index, Object maybeLength, + @Cached GetIndexNode getIndexNode) { + return getIndexNode.execute(matchData, index, maybeLength); + } + } + + public static class GetFixedNameMatchNode extends RubyContextSourceNode { + + @Child RubyNode readMatchNode; + private final RubySymbol symbol; + @Child GetIndexNode getIndexNode = MatchDataNodesFactory.GetIndexNodeGen.create(); + + public GetFixedNameMatchNode(RubyNode readMatchNode, RubySymbol symbol) { + this.readMatchNode = readMatchNode; + this.symbol = symbol; + } + + @Override + public Object execute(VirtualFrame frame) { + RubyMatchData matchData = (RubyMatchData) readMatchNode.execute(frame); + return getIndexNode.execute(matchData, symbol, NotProvided.INSTANCE); + } + + @Override + public RubyNode cloneUninitialized() { + return new GetFixedNameMatchNode(readMatchNode.cloneUninitialized(), symbol); + } + } + @Primitive(name = "match_data_begin", lowerFixnum = 1) public abstract static class BeginNode extends PrimitiveArrayArgumentsNode { @@ -486,10 +516,10 @@ protected boolean inBounds(RubyMatchData matchData, int index) { } - public abstract static class ValuesNode extends CoreMethodArrayArgumentsNode { + public abstract static class ValuesNode extends RubyBaseNode { public static ValuesNode create() { - return ValuesNodeFactory.create(null); + return MatchDataNodesFactory.ValuesNodeGen.create(); } public abstract Object[] execute(RubyMatchData matchData); diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java index 5eb4dbc2dc83..77886c5570d5 100644 --- a/src/main/java/org/truffleruby/core/string/StringNodes.java +++ b/src/main/java/org/truffleruby/core/string/StringNodes.java @@ -214,7 +214,7 @@ protected RubyString allocate(RubyClass rubyClass) { @Override public RubyNode cloneUninitialized() { - return create(getRubyClassNode().cloneUninitialized()); + return create(getRubyClassNode().cloneUninitialized()).copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/core/support/TypeNodes.java b/src/main/java/org/truffleruby/core/support/TypeNodes.java index d77e84373c56..b44a37348bf2 100644 --- a/src/main/java/org/truffleruby/core/support/TypeNodes.java +++ b/src/main/java/org/truffleruby/core/support/TypeNodes.java @@ -414,7 +414,7 @@ protected Object check(Object value, @Override public RubyNode cloneUninitialized() { - return create(getValueNode().cloneUninitialized()); + return create(getValueNode().cloneUninitialized()).copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/interop/InteropNodes.java b/src/main/java/org/truffleruby/interop/InteropNodes.java index 5ba87fa01e73..dd2a5a1cbce3 100644 --- a/src/main/java/org/truffleruby/interop/InteropNodes.java +++ b/src/main/java/org/truffleruby/interop/InteropNodes.java @@ -633,7 +633,7 @@ protected Object write(Object receiver, long identifier, Object value, @Override public RubyNode cloneUninitialized() { - return create(cloneUninitialized(getArgumentNodes())); + return create(cloneUninitialized(getArgumentNodes())).copyFlags(this); } } @@ -671,7 +671,7 @@ protected Nil readArrayElement(Object receiver, long identifier, @Override public RubyNode cloneUninitialized() { - return create(cloneUninitialized(getArgumentNodes())); + return create(cloneUninitialized(getArgumentNodes())).copyFlags(this); } } @@ -1158,14 +1158,14 @@ protected double as(Object receiver, @GenerateNodeFactory @CoreMethod(names = "null?", onSingleton = true, required = 1) @NodeChild(value = "argumentNodes", type = RubyNode[].class) - public abstract static class NullNode extends RubySourceNode { + public abstract static class IsNullNode extends RubySourceNode { - public static NullNode create() { - return InteropNodesFactory.NullNodeFactory.create(null); + public static IsNullNode create() { + return InteropNodesFactory.IsNullNodeFactory.create(null); } - public static NullNode create(RubyNode[] argumentNodes) { - return InteropNodesFactory.NullNodeFactory.create(argumentNodes); + public static IsNullNode create(RubyNode[] argumentNodes) { + return InteropNodesFactory.IsNullNodeFactory.create(argumentNodes); } abstract Object execute(Object receiver); @@ -1180,7 +1180,7 @@ protected boolean isNull(Object receiver, @Override public RubyNode cloneUninitialized() { - return create(cloneUninitialized(getArgumentNodes())); + return create(cloneUninitialized(getArgumentNodes())).copyFlags(this); } } @@ -1291,7 +1291,7 @@ protected Object readMember(Object receiver, Object identifier, @Override public RubyNode cloneUninitialized() { - return create(cloneUninitialized(getArgumentNodes())); + return create(cloneUninitialized(getArgumentNodes())).copyFlags(this); } } @@ -1325,7 +1325,7 @@ protected Object readMember(Object receiver, Object identifier, @Override public RubyNode cloneUninitialized() { - return create(cloneUninitialized(getArgumentNodes())); + return create(cloneUninitialized(getArgumentNodes())).copyFlags(this); } } @@ -1365,7 +1365,7 @@ protected Object write(Object receiver, Object identifier, Object value, @Override public RubyNode cloneUninitialized() { - return create(cloneUninitialized(getArgumentNodes())); + return create(cloneUninitialized(getArgumentNodes())).copyFlags(this); } } @@ -1405,7 +1405,7 @@ protected Object write(Object receiver, Object identifier, Object value, @Override public RubyNode cloneUninitialized() { - return create(cloneUninitialized(getArgumentNodes())); + return create(cloneUninitialized(getArgumentNodes())).copyFlags(this); } } @@ -1460,7 +1460,7 @@ protected Object invokeCached(Object receiver, Object identifier, Object[] args, @Override public RubyNode cloneUninitialized() { - return create(cloneUninitialized(getArgumentNodes())); + return create(cloneUninitialized(getArgumentNodes())).copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/interop/ToJavaStringNode.java b/src/main/java/org/truffleruby/interop/ToJavaStringNode.java index aeb51be1bb57..cd855dea0d54 100644 --- a/src/main/java/org/truffleruby/interop/ToJavaStringNode.java +++ b/src/main/java/org/truffleruby/interop/ToJavaStringNode.java @@ -63,7 +63,7 @@ protected int getLimit() { @Override public RubyNode cloneUninitialized() { - return ToJavaStringNodeGen.create(getValueNode().cloneUninitialized()); + return ToJavaStringNodeGen.create(getValueNode().cloneUninitialized()).copyFlags(this); } } diff --git a/src/main/java/org/truffleruby/language/RubyContextSourceNode.java b/src/main/java/org/truffleruby/language/RubyContextSourceNode.java index aa0dc411864b..07daeb5505f7 100644 --- a/src/main/java/org/truffleruby/language/RubyContextSourceNode.java +++ b/src/main/java/org/truffleruby/language/RubyContextSourceNode.java @@ -56,15 +56,15 @@ protected void setSourceLength(int sourceLength) { this.sourceLength = sourceLength; } - @Override - public String toString() { - return super.toString() + " at " + RubyLanguage.fileLine(getSourceSection()); - } - public RubyContextSourceNode copyFlags(RubyContextSourceNode original) { this.sourceCharIndex = original.sourceCharIndex; this.sourceLength = original.sourceLength; this.flags = original.flags; return this; } + + @Override + public String toString() { + return super.toString() + " at " + RubyLanguage.fileLine(getSourceSection()); + } } diff --git a/src/main/java/org/truffleruby/language/RubyNode.java b/src/main/java/org/truffleruby/language/RubyNode.java index 8c01bda73248..08c537a906c5 100644 --- a/src/main/java/org/truffleruby/language/RubyNode.java +++ b/src/main/java/org/truffleruby/language/RubyNode.java @@ -319,7 +319,7 @@ Object getRootInstance(Frame frame, public abstract RubyNode cloneUninitialized(); - protected static RubyNode cloneUninitialized(RubyNode node) { + public static RubyNode cloneUninitialized(RubyNode node) { return (node == null) ? null : node.cloneUninitialized(); } diff --git a/src/main/java/org/truffleruby/language/RubyRootNode.java b/src/main/java/org/truffleruby/language/RubyRootNode.java index f130c3fcf78a..2bd0e49835ed 100644 --- a/src/main/java/org/truffleruby/language/RubyRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyRootNode.java @@ -175,10 +175,11 @@ private void ensureCloneUninitializedCorrectness(RubyRootNode clone) { if (this == clone) { throw CompilerDirectives.shouldNotReachHere("clone same as this"); } - if (this.getClass() != clone.getClass()) { - throw CompilerDirectives - .shouldNotReachHere("different clone class: " + this.getClass() + " vs " + clone.getClass()); - } + assertSame(this.getClass(), clone.getClass()); + assertSame(getSourceSection(), clone.getSourceSection()); + assertSame(sharedMethodInfo, clone.sharedMethodInfo); + assertSame(getSplit(), clone.getSplit()); + assertSame(returnID, clone.returnID); IdentityHashMap specializedNodes = new IdentityHashMap<>(); this.body.accept((node) -> { @@ -214,6 +215,12 @@ private void ensureCloneUninitializedCorrectness(RubyRootNode clone) { } } + private void assertSame(Object a, Object b) { + if (a != b) { + throw CompilerDirectives.shouldNotReachHere("different " + a + " vs " + b + " for: " + this); + } + } + private void ensureClonedCorrectly(Node original, Node clone, IdentityHashMap specializedNodes) { // A clone should be a new instance // Actually this should never happen since the bodyCopy is separate from the initialized AST @@ -237,6 +244,18 @@ private void ensureClonedCorrectly(Node original, Node clone, IdentityHashMap Date: Fri, 7 Oct 2022 21:03:20 +0200 Subject: [PATCH 42/46] Add --always-clone-all option --- .../java/org/truffleruby/language/RubyRootNode.java | 2 +- .../org/truffleruby/options/LanguageOptions.java | 13 +++++++++++++ src/options.yml | 2 ++ .../truffleruby/shared/options/OptionsCatalog.java | 12 ++++++++++++ test/truffle/compiler/clone-uninitialized-checks.sh | 1 + 5 files changed, 29 insertions(+), 1 deletion(-) diff --git a/src/main/java/org/truffleruby/language/RubyRootNode.java b/src/main/java/org/truffleruby/language/RubyRootNode.java index 2bd0e49835ed..0551d8f0bf30 100644 --- a/src/main/java/org/truffleruby/language/RubyRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyRootNode.java @@ -98,7 +98,7 @@ public boolean isCloningAllowed() { public boolean shouldAlwaysClone() { assert isCloningAllowed(); - if (getLanguage().options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + if (getLanguage().options.ALWAYS_CLONE_ALL) { return split != Split.NEVER; } diff --git a/src/main/java/org/truffleruby/options/LanguageOptions.java b/src/main/java/org/truffleruby/options/LanguageOptions.java index 4183350df5d8..880f9cf1a8a7 100644 --- a/src/main/java/org/truffleruby/options/LanguageOptions.java +++ b/src/main/java/org/truffleruby/options/LanguageOptions.java @@ -112,6 +112,8 @@ public class LanguageOptions { public final int PACK_UNROLL_LIMIT; /** --pack-recover=32 */ public final int PACK_RECOVER_LOOP_MIN; + /** --always-clone-all=false */ + public final boolean ALWAYS_CLONE_ALL; /** --check-clone-uninitialized-correctness=false */ public final boolean CHECK_CLONE_UNINITIALIZED_CORRECTNESS; /** --regexp-instrument-creation=false */ @@ -173,6 +175,7 @@ public LanguageOptions(Env env, OptionValues options, boolean singleContext) { ARRAY_UNINITIALIZED_SIZE = options.get(OptionsCatalog.ARRAY_UNINITIALIZED_SIZE_KEY); PACK_UNROLL_LIMIT = options.get(OptionsCatalog.PACK_UNROLL_LIMIT_KEY); PACK_RECOVER_LOOP_MIN = options.get(OptionsCatalog.PACK_RECOVER_LOOP_MIN_KEY); + ALWAYS_CLONE_ALL = options.get(OptionsCatalog.ALWAYS_CLONE_ALL_KEY); CHECK_CLONE_UNINITIALIZED_CORRECTNESS = options.get(OptionsCatalog.CHECK_CLONE_UNINITIALIZED_CORRECTNESS_KEY); REGEXP_INSTRUMENT_CREATION = options.get(OptionsCatalog.REGEXP_INSTRUMENT_CREATION_KEY); SHARED_OBJECTS_ENABLED = options.get(OptionsCatalog.SHARED_OBJECTS_ENABLED_KEY); @@ -274,6 +277,8 @@ public Object fromDescriptor(OptionDescriptor descriptor) { return PACK_UNROLL_LIMIT; case "ruby.pack-recover": return PACK_RECOVER_LOOP_MIN; + case "ruby.always-clone-all": + return ALWAYS_CLONE_ALL; case "ruby.check-clone-uninitialized-correctness": return CHECK_CLONE_UNINITIALIZED_CORRECTNESS; case "ruby.regexp-instrument-creation": @@ -339,6 +344,7 @@ public static boolean areOptionsCompatible(OptionValues one, OptionValues two) { one.get(OptionsCatalog.ARRAY_UNINITIALIZED_SIZE_KEY).equals(two.get(OptionsCatalog.ARRAY_UNINITIALIZED_SIZE_KEY)) && one.get(OptionsCatalog.PACK_UNROLL_LIMIT_KEY).equals(two.get(OptionsCatalog.PACK_UNROLL_LIMIT_KEY)) && one.get(OptionsCatalog.PACK_RECOVER_LOOP_MIN_KEY).equals(two.get(OptionsCatalog.PACK_RECOVER_LOOP_MIN_KEY)) && + one.get(OptionsCatalog.ALWAYS_CLONE_ALL_KEY).equals(two.get(OptionsCatalog.ALWAYS_CLONE_ALL_KEY)) && one.get(OptionsCatalog.CHECK_CLONE_UNINITIALIZED_CORRECTNESS_KEY).equals(two.get(OptionsCatalog.CHECK_CLONE_UNINITIALIZED_CORRECTNESS_KEY)) && one.get(OptionsCatalog.REGEXP_INSTRUMENT_CREATION_KEY).equals(two.get(OptionsCatalog.REGEXP_INSTRUMENT_CREATION_KEY)) && one.get(OptionsCatalog.SHARED_OBJECTS_ENABLED_KEY).equals(two.get(OptionsCatalog.SHARED_OBJECTS_ENABLED_KEY)) && @@ -667,6 +673,13 @@ public static boolean areOptionsCompatibleOrLog(TruffleLogger logger, LanguageOp return false; } + oldValue = oldOptions.ALWAYS_CLONE_ALL; + newValue = newOptions.ALWAYS_CLONE_ALL; + if (!newValue.equals(oldValue)) { + logger.fine("not reusing pre-initialized context: --always-clone-all differs, was: " + oldValue + " and is now: " + newValue); + return false; + } + oldValue = oldOptions.CHECK_CLONE_UNINITIALIZED_CORRECTNESS; newValue = newOptions.CHECK_CLONE_UNINITIALIZED_CORRECTNESS; if (!newValue.equals(oldValue)) { diff --git a/src/options.yml b/src/options.yml index 0c970c61ca85..6cf3d61bc7e0 100644 --- a/src/options.yml +++ b/src/options.yml @@ -52,6 +52,7 @@ LANGUAGE_OPTIONS: - EXPERIMENTAL_ENGINE_CACHING - RUN_TWICE - CHECK_CLONE_UNINITIALIZED_CORRECTNESS +- ALWAYS_CLONE_ALL USER: STABLE: @@ -228,6 +229,7 @@ INTERNAL: # Options for debugging the TruffleRuby implementation CLONE_DEFAULT: [clone-default, boolean, true, Default option for cloning] INLINE_DEFAULT: [inline-default, boolean, true, Default option for inlining] CORE_ALWAYS_CLONE: [core-always-clone, boolean, false, Always clone built-in core methods] + ALWAYS_CLONE_ALL: [always-clone-all, boolean, false, 'Always clone all call targets (very slow, only for debugging)'] ALWAYS_SPLIT_HONOR: [always-split-honor, boolean, CLONE_DEFAULT, 'Honor Truffle::Graal.always_split annotations'] NEVER_SPLIT_HONOR: [never-split-honor, boolean, true, 'Honor Truffle::Graal.never_split annotations'] INLINE_NEEDS_CALLER_FRAME: [inline-needs-caller-frame, boolean, INLINE_DEFAULT, Inline methods that need their caller frame] diff --git a/src/shared/java/org/truffleruby/shared/options/OptionsCatalog.java b/src/shared/java/org/truffleruby/shared/options/OptionsCatalog.java index 5483c08fcc90..4d6fa7e3ecf1 100644 --- a/src/shared/java/org/truffleruby/shared/options/OptionsCatalog.java +++ b/src/shared/java/org/truffleruby/shared/options/OptionsCatalog.java @@ -144,6 +144,7 @@ public class OptionsCatalog { public static final OptionKey CLONE_DEFAULT_KEY = new OptionKey<>(true); public static final OptionKey INLINE_DEFAULT_KEY = new OptionKey<>(true); public static final OptionKey CORE_ALWAYS_CLONE_KEY = new OptionKey<>(false); + public static final OptionKey ALWAYS_CLONE_ALL_KEY = new OptionKey<>(false); public static final OptionKey ALWAYS_SPLIT_HONOR_KEY = new OptionKey<>(CLONE_DEFAULT_KEY.getDefaultValue()); public static final OptionKey NEVER_SPLIT_HONOR_KEY = new OptionKey<>(true); public static final OptionKey INLINE_NEEDS_CALLER_FRAME_KEY = new OptionKey<>(INLINE_DEFAULT_KEY.getDefaultValue()); @@ -1157,6 +1158,14 @@ public class OptionsCatalog { .usageSyntax("") .build(); + public static final OptionDescriptor ALWAYS_CLONE_ALL = OptionDescriptor + .newBuilder(ALWAYS_CLONE_ALL_KEY, "ruby.always-clone-all") + .help("Always clone all call targets (very slow, only for debugging)") + .category(OptionCategory.INTERNAL) + .stability(OptionStability.EXPERIMENTAL) + .usageSyntax("") + .build(); + public static final OptionDescriptor ALWAYS_SPLIT_HONOR = OptionDescriptor .newBuilder(ALWAYS_SPLIT_HONOR_KEY, "ruby.always-split-honor") .help("Honor Truffle::Graal.always_split annotations") @@ -1567,6 +1576,8 @@ public static OptionDescriptor fromName(String name) { return INLINE_DEFAULT; case "ruby.core-always-clone": return CORE_ALWAYS_CLONE; + case "ruby.always-clone-all": + return ALWAYS_CLONE_ALL; case "ruby.always-split-honor": return ALWAYS_SPLIT_HONOR; case "ruby.never-split-honor": @@ -1738,6 +1749,7 @@ public static OptionDescriptor[] allDescriptors() { CLONE_DEFAULT, INLINE_DEFAULT, CORE_ALWAYS_CLONE, + ALWAYS_CLONE_ALL, ALWAYS_SPLIT_HONOR, NEVER_SPLIT_HONOR, INLINE_NEEDS_CALLER_FRAME, diff --git a/test/truffle/compiler/clone-uninitialized-checks.sh b/test/truffle/compiler/clone-uninitialized-checks.sh index 4875e3260041..2c183c26c473 100755 --- a/test/truffle/compiler/clone-uninitialized-checks.sh +++ b/test/truffle/compiler/clone-uninitialized-checks.sh @@ -2,4 +2,5 @@ source test/truffle/common.sh.inc +# --always-clone-all covers more than just --core-always-clone, but is much slower (6 min vs 1 min) jt test fast -- --vm.XX:-UseJVMCICompiler --engine.Compilation=false --core-always-clone --check-clone-uninitialized-correctness From d69ece762437062196eaedb1ee87231289589d92 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 21:14:33 +0200 Subject: [PATCH 43/46] Add ChangeLog entry --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index e6e0c7221bb7..b24fc38e2897 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,7 @@ Compatibility: Performance: * Marking of native structures wrapped in objects is now done on C call exit to reduce memory overhead (@aardvark179). +* Splitting (copying) of call targets has been optimized by implementing `cloneUninitialized()` (@andrykonchin, @eregon). Changes: From b5e21e7fd07bcc12f84f8396950fa73ece4522c7 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Fri, 7 Oct 2022 21:25:54 +0200 Subject: [PATCH 44/46] Fixes for cloneUninitialized after rebase --- .../java/org/truffleruby/core/exception/ExceptionNodes.java | 2 +- src/main/java/org/truffleruby/core/string/StringNodes.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/truffleruby/core/exception/ExceptionNodes.java b/src/main/java/org/truffleruby/core/exception/ExceptionNodes.java index 1fad8919196a..33a61b278f51 100644 --- a/src/main/java/org/truffleruby/core/exception/ExceptionNodes.java +++ b/src/main/java/org/truffleruby/core/exception/ExceptionNodes.java @@ -354,7 +354,7 @@ protected int limit() { } @Primitive(name = "exception_get_raise_exception") - public abstract static class GetRaiseExceptionNode extends CoreMethodArrayArgumentsNode { + public abstract static class GetRaiseExceptionNode extends PrimitiveArrayArgumentsNode { @Specialization protected Object getRaiseException(RubyException exception) { diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java index 77886c5570d5..7729ec16bccc 100644 --- a/src/main/java/org/truffleruby/core/string/StringNodes.java +++ b/src/main/java/org/truffleruby/core/string/StringNodes.java @@ -2618,7 +2618,7 @@ public boolean isStringSubclass(RubyString string) { @Primitive(name = "string_to_symbol") @ImportStatic(StringGuards.class) - public abstract static class ToSymNode extends CoreMethodArrayArgumentsNode { + public abstract static class ToSymNode extends PrimitiveArrayArgumentsNode { @Child GetByteCodeRangeNode codeRangeNode = GetByteCodeRangeNode.create(); From ad51ea4c0a58e3468ad6c75a0a58049d5891f50f Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Mon, 10 Oct 2022 14:50:34 +0200 Subject: [PATCH 45/46] [GR-41666] getLanguage() does not work in RubyRootNode constructor --- src/main/java/org/truffleruby/language/RubyRootNode.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/truffleruby/language/RubyRootNode.java b/src/main/java/org/truffleruby/language/RubyRootNode.java index 0551d8f0bf30..d0bbb063e0b1 100644 --- a/src/main/java/org/truffleruby/language/RubyRootNode.java +++ b/src/main/java/org/truffleruby/language/RubyRootNode.java @@ -68,7 +68,7 @@ public RubyRootNode( body.unsafeSetIsCall(); body.unsafeSetIsRoot(); - if (getLanguage().options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { + if (language.options.CHECK_CLONE_UNINITIALIZED_CORRECTNESS) { this.bodyCopy = copyBody(); } else { this.bodyCopy = null; From 9924cd7172375678fa8d394293be6271d2792f1a Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Mon, 10 Oct 2022 15:17:10 +0200 Subject: [PATCH 46/46] The preinit context is not used with --check-clone-uninitialized-correctness --- test/truffle/compiler/clone-uninitialized-checks.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/truffle/compiler/clone-uninitialized-checks.sh b/test/truffle/compiler/clone-uninitialized-checks.sh index 2c183c26c473..20455dff6e5c 100755 --- a/test/truffle/compiler/clone-uninitialized-checks.sh +++ b/test/truffle/compiler/clone-uninitialized-checks.sh @@ -2,5 +2,7 @@ source test/truffle/common.sh.inc +export TRUFFLERUBY_CHECK_PREINITIALIZED_SPEC=false + # --always-clone-all covers more than just --core-always-clone, but is much slower (6 min vs 1 min) jt test fast -- --vm.XX:-UseJVMCICompiler --engine.Compilation=false --core-always-clone --check-clone-uninitialized-correctness