AndNode is converted to DSL node

Author: horakivo

src/main/java/org/truffleruby/language/control/AndNode.java

@@ -9,51 +9,40 @@
  */
 package org.truffleruby.language.control;
 
-import com.oracle.truffle.api.profiles.CountingConditionProfile;
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.profiles.InlinedCountingConditionProfile;
 import org.truffleruby.core.cast.BooleanCastNode;
-import org.truffleruby.core.cast.BooleanCastNodeGen;
 import org.truffleruby.language.RubyContextSourceNode;
 import org.truffleruby.language.RubyNode;
 
-import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.VirtualFrame;
 
-public class AndNode extends RubyContextSourceNode {
+public abstract class AndNode extends RubyContextSourceNode {
 
     @Child private RubyNode left;
     @Child private RubyNode right;
 
-    @Child private BooleanCastNode leftCast;
-
-    private final CountingConditionProfile conditionProfile = CountingConditionProfile.create();
-
     public AndNode(RubyNode left, RubyNode right) {
         this.left = left;
         this.right = right;
     }
 
-    @Override
-    public Object execute(VirtualFrame frame) {
-        final Object leftValue = left.execute(frame);
-
-        if (conditionProfile.profile(castToBoolean(leftValue))) {
+    @Specialization
+    protected Object doAnd(VirtualFrame frame,
+            @Cached BooleanCastNode leftCast,
+            @Cached InlinedCountingConditionProfile conditionProfile) {
+        final var leftValue = left.execute(frame);
+        if (conditionProfile.profile(this, leftCast.execute(this, leftValue))) {
             return right.execute(frame);
         } else {
             return leftValue;
         }
     }
 
-    private boolean castToBoolean(final Object value) {
-        if (leftCast == null) {
-            CompilerDirectives.transferToInterpreterAndInvalidate();
-            leftCast = insert(BooleanCastNodeGen.create(null));
-        }
-        return leftCast.execute(value);
-    }
-
     @Override
     public RubyNode cloneUninitialized() {
-        var copy = new AndNode(
+        var copy = AndNodeGen.create(
                 left.cloneUninitialized(),
                 right.cloneUninitialized());
         return copy.copyFlags(this);

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

@@ -69,7 +69,7 @@
 import org.truffleruby.language.constants.ReadConstantWithDynamicScopeNode;
 import org.truffleruby.language.constants.ReadConstantWithLexicalScopeNode;
 import org.truffleruby.language.constants.WriteConstantNode;
-import org.truffleruby.language.control.AndNode;
+import org.truffleruby.language.control.AndNodeGen;
 import org.truffleruby.language.control.BreakID;
 import org.truffleruby.language.control.BreakNode;
 import org.truffleruby.language.control.DeferredRaiseException;
@@ -340,7 +340,7 @@ public RubyNode visitAndNode(AndParseNode node) {
         final RubyNode x = translateNodeOrNil(sourceSection, node.getFirstNode());
         final RubyNode y = translateNodeOrNil(sourceSection, node.getSecondNode());
 
-        final RubyNode ret = new AndNode(x, y);
+        final RubyNode ret = AndNodeGen.create(x, y);
         ret.unsafeSetSourceSection(sourceSection);
         return addNewlineIfNeeded(node, ret);
     }
@@ -2209,7 +2209,7 @@ private RubyNode translateOpAsgnAndNode(ParseNode node, RubyNode lhs, RubyNode r
 
         final SourceIndexLength sourceSection = node.getPosition();
 
-        final RubyNode andNode = new AndNode(lhs, rhs);
+        final RubyNode andNode = AndNodeGen.create(lhs, rhs);
         andNode.unsafeSetSourceSection(sourceSection);
 
         final RubyNode ret = new DefinedWrapperNode(language.coreStrings.ASSIGNMENT, andNode);
@@ -2275,7 +2275,7 @@ public RubyNode visitOpAsgnNode(OpAsgnParseNode node) {
             RubyNode lhs = readMethod.accept(this);
             RubyNode rhs = writeMethod.accept(this);
 
-            final RubyNode controlNode = isOrOperator ? OrNodeGen.create(lhs, rhs) : new AndNode(lhs, rhs);
+            final RubyNode controlNode = isOrOperator ? OrNodeGen.create(lhs, rhs) : AndNodeGen.create(lhs, rhs);
 
             final RubyNode ret = new DefinedWrapperNode(
                     language.coreStrings.ASSIGNMENT,
@@ -2327,7 +2327,7 @@ public RubyNode visitOpAsgnOrNode(OpAsgnOrParseNode node) {
         // This is needed for class variables. Constants are handled separately in visitOpAsgnConstDeclNode.
         if (node.getFirstNode().needsDefinitionCheck()) {
             RubyNode defined = new DefinedNode(lhs);
-            lhs = new AndNode(defined, lhs);
+            lhs = AndNodeGen.create(defined, lhs);
         }
 
         return translateOpAsgOrNode(node, lhs, rhs);

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

@@ -13,6 +13,7 @@
 import java.util.function.Supplier;
 
 import org.truffleruby.RubyLanguage;
+import org.truffleruby.language.control.AndNodeGen;
 import org.truffleruby.language.control.IfElseNodeGen;
 import org.truffleruby.language.control.NotNodeGen;
 import org.truffleruby.language.locals.FindDeclarationVariableNodes.FrameSlotAndDepth;
@@ -34,7 +35,6 @@
 import org.truffleruby.language.arguments.MissingArgumentBehavior;
 import org.truffleruby.language.arguments.ReadPreArgumentNode;
 import org.truffleruby.language.arguments.ShouldDestructureNode;
-import org.truffleruby.language.control.AndNode;
 import org.truffleruby.language.control.DynamicReturnNode;
 import org.truffleruby.language.control.InvalidReturnNode;
 import org.truffleruby.language.control.ReturnID;
@@ -226,7 +226,7 @@ private RubyNode preludeProc(
                                     new IsNilNode(
                                             new ReadLocalVariableNode(LocalVariableType.FRAME_LOCAL, arraySlot)))));
 
-            final RubyNode shouldDestructureAndArrayWasNotNil = new AndNode(
+            final RubyNode shouldDestructureAndArrayWasNotNil = AndNodeGen.create(
                     new ShouldDestructureNode(arity.acceptsKeywords()),
                     arrayWasNotNil);
 

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

@@ -17,7 +17,7 @@
 import org.truffleruby.core.array.ArraySliceNodeGen;
 import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.SourceIndexLength;
-import org.truffleruby.language.control.AndNode;
+import org.truffleruby.language.control.AndNodeGen;
 import org.truffleruby.language.control.ExecuteAndReturnTrueNode;
 import org.truffleruby.language.control.NotNodeGen;
 import org.truffleruby.language.control.RaiseException;
@@ -98,7 +98,7 @@ public RubyNode translatePatternNode(ParseNode patternNode, RubyNode expressionV
                     condition = NotNodeGen.create(condition);
                 }
 
-                return new AndNode(pattern, condition);
+                return AndNodeGen.create(pattern, condition);
             default:
                 return createCallNode(patternNode.accept(this), "===", NodeUtil.cloneNode(expressionValue));
         }
@@ -141,7 +141,7 @@ public RubyNode visitArrayPatternNode(ArrayPatternParseNode arrayPatternParseNod
             ConstParseNode constant = (ConstParseNode) arrayPatternParseNode.getConstant();
             RubyNode constVal = constant.accept(this);
             var isInstance = createCallNode(constVal, "===", currentValueToMatch);
-            condition = new AndNode(isInstance, condition);
+            condition = AndNodeGen.create(isInstance, condition);
         }
 
         for (int i = 0; i < preSize; i++) {
@@ -157,7 +157,7 @@ public RubyNode visitArrayPatternNode(ArrayPatternParseNode arrayPatternParseNod
             }
 
             var callNode = createCallNode(translatedPatternElement, "===", NodeUtil.cloneNode(exprElement));
-            condition = new AndNode(condition, callNode);
+            condition = AndNodeGen.create(condition, callNode);
         }
 
         if (restNode != null) {
@@ -178,7 +178,7 @@ public RubyNode visitArrayPatternNode(ArrayPatternParseNode arrayPatternParseNod
                     currentValueToMatch = prev;
                 }
                 var seq = new ExecuteAndReturnTrueNode(restAccept);
-                condition = new AndNode(condition, seq);
+                condition = AndNodeGen.create(condition, seq);
             }
         }
 
@@ -201,7 +201,7 @@ public RubyNode visitArrayPatternNode(ArrayPatternParseNode arrayPatternParseNod
                         "===",
                         NodeUtil.cloneNode(exprElement));
 
-                condition = new AndNode(condition, callNode);
+                condition = AndNodeGen.create(condition, callNode);
             }
         }