WhileNode is converted to DSL node

Author: horakivo

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

@@ -10,9 +10,11 @@
 package org.truffleruby.language.control;
 
 import com.oracle.truffle.api.TruffleSafepoint;
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.profiles.InlinedBranchProfile;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.core.cast.BooleanCastNode;
-import org.truffleruby.core.cast.BooleanCastNodeGen;
 import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.RubyContextSourceNode;
 import org.truffleruby.language.RubyNode;
@@ -21,7 +23,6 @@
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.LoopNode;
 import com.oracle.truffle.api.nodes.RepeatingNode;
-import com.oracle.truffle.api.profiles.BranchProfile;
 
 public final class WhileNode extends RubyContextSourceNode {
 
@@ -45,17 +46,30 @@ public RubyNode cloneUninitialized() {
 
     private abstract static class WhileRepeatingBaseNode extends RubyBaseNode implements RepeatingNode {
 
-        @Child protected BooleanCastNode condition;
+        @Child protected RubyNode condition;
         @Child protected RubyNode body;
 
-        protected final BranchProfile redoUsed = BranchProfile.create();
-        protected final BranchProfile nextUsed = BranchProfile.create();
-
         public WhileRepeatingBaseNode(RubyNode condition, RubyNode body) {
-            this.condition = BooleanCastNodeGen.create(condition);
+            this.condition = condition;
             this.body = body;
         }
 
+        protected abstract boolean execute(VirtualFrame frame);
+
+        @Override
+        public final boolean executeRepeating(VirtualFrame frame) {
+            return execute(frame);
+        }
+
+        @Override
+        public final Object executeRepeatingWithValue(VirtualFrame frame) {
+            if (executeRepeating(frame)) {
+                return CONTINUE_LOOP_STATUS;
+            } else {
+                return BREAK_LOOP_STATUS;
+            }
+        }
+
         @Override
         public String toString() {
             return "while loop at " + RubyLanguage.filenameLine(getEncapsulatingSourceSection());
@@ -64,15 +78,19 @@ public String toString() {
         public abstract WhileRepeatingBaseNode cloneUninitialized();
     }
 
-    public static class WhileRepeatingNode extends WhileRepeatingBaseNode implements RepeatingNode {
+    public abstract static class WhileRepeatingNode extends WhileRepeatingBaseNode {
 
         public WhileRepeatingNode(RubyNode condition, RubyNode body) {
             super(condition, body);
         }
 
-        @Override
-        public boolean executeRepeating(VirtualFrame frame) {
-            if (!condition.execute(frame)) {
+        @Specialization
+        protected boolean doRepeating(VirtualFrame frame,
+                @Cached BooleanCastNode booleanCastNode,
+                @Cached InlinedBranchProfile redoUsed,
+                @Cached InlinedBranchProfile nextUsed) {
+            var conditionAsBoolean = booleanCastNode.execute(condition.execute(frame));
+            if (!conditionAsBoolean) {
                 return false;
             }
 
@@ -81,54 +99,53 @@ public boolean executeRepeating(VirtualFrame frame) {
                     body.doExecuteVoid(frame);
                     return true;
                 } catch (NextException e) {
-                    nextUsed.enter();
+                    nextUsed.enter(this);
                     return true;
                 } catch (RedoException e) {
                     // Just continue in the while(true) loop.
-                    redoUsed.enter();
+                    redoUsed.enter(this);
                     TruffleSafepoint.poll(this);
                 }
             }
         }
 
         @Override
         public WhileRepeatingBaseNode cloneUninitialized() {
-            return new WhileRepeatingNode(
-                    condition.getValueNode().cloneUninitialized(),
+            return WhileNodeFactory.WhileRepeatingNodeGen.create(
+                    condition.cloneUninitialized(),
                     body.cloneUninitialized());
         }
 
     }
 
-    public static class DoWhileRepeatingNode extends WhileRepeatingBaseNode implements RepeatingNode {
+    public abstract static class DoWhileRepeatingNode extends WhileRepeatingBaseNode {
 
         public DoWhileRepeatingNode(RubyNode condition, RubyNode body) {
             super(condition, body);
         }
 
-        @Override
-        public boolean executeRepeating(VirtualFrame frame) {
+        @Specialization
+        protected boolean doRepeating(VirtualFrame frame,
+                @Cached BooleanCastNode booleanCastNode,
+                @Cached InlinedBranchProfile redoUsed,
+                @Cached InlinedBranchProfile nextUsed) {
             try {
                 body.doExecuteVoid(frame);
             } catch (NextException e) {
-                nextUsed.enter();
+                nextUsed.enter(this);
             } catch (RedoException e) {
                 // Just continue to next iteration without executing the condition.
-                redoUsed.enter();
+                redoUsed.enter(this);
                 return true;
             }
 
-            return condition.execute(frame);
-        }
-
-        private RubyNode getConditionBeforeCasting() {
-            return condition.getValueNode();
+            return booleanCastNode.execute(condition.execute(frame));
         }
 
         @Override
         public WhileRepeatingBaseNode cloneUninitialized() {
-            return new DoWhileRepeatingNode(
-                    getConditionBeforeCasting().cloneUninitialized(),
+            return WhileNodeFactory.DoWhileRepeatingNodeGen.create(
+                    condition.cloneUninitialized(),
                     body.cloneUninitialized());
         }
 

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

@@ -91,6 +91,7 @@
 import org.truffleruby.language.control.ReturnID;
 import org.truffleruby.language.control.UnlessNodeGen;
 import org.truffleruby.language.control.WhileNode;
+import org.truffleruby.language.control.WhileNodeFactory;
 import org.truffleruby.language.defined.DefinedNode;
 import org.truffleruby.language.defined.DefinedWrapperNode;
 import org.truffleruby.language.dispatch.RubyCallNodeParameters;
@@ -2912,9 +2913,9 @@ private RubyNode translateWhileNode(WhileParseNode node, boolean conditionInvers
         final RubyNode loop;
 
         if (node.evaluateAtStart()) {
-            loop = new WhileNode(new WhileNode.WhileRepeatingNode(condition, body));
+            loop = new WhileNode(WhileNodeFactory.WhileRepeatingNodeGen.create(condition, body));
         } else {
-            loop = new WhileNode(new WhileNode.DoWhileRepeatingNode(condition, body));
+            loop = new WhileNode(WhileNodeFactory.DoWhileRepeatingNodeGen.create(condition, body));
         }
 
         final RubyNode ret = new CatchBreakNode(whileBreakID, loop, true);

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

@@ -70,6 +70,7 @@
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.language.control.WhileNode;
+import org.truffleruby.language.control.WhileNodeFactory;
 import org.truffleruby.language.locals.FrameDescriptorNamesIterator;
 import org.truffleruby.language.locals.WriteLocalVariableNode;
 import org.truffleruby.language.methods.Arity;
@@ -296,7 +297,8 @@ public RootCallTarget parse(RubySource rubySource, ParserContext parserContext,
                         sourceIndexLength,
                         Arrays.asList(new ChompLoopNode(), truffleNode));
             }
-            truffleNode = new WhileNode(new WhileNode.WhileRepeatingNode(new KernelGetsNode(), truffleNode));
+            truffleNode = new WhileNode(
+                    WhileNodeFactory.WhileRepeatingNodeGen.create(new KernelGetsNode(), truffleNode));
         }
 
         if (beginNode != null) {