Fold Return0 into Return

Author: kddnewton

CHANGELOG.md

@@ -17,6 +17,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
   - `Dot2` and `Dot3` are no longer nodes. Instead they have become a single new `RangeLiteral` node. This node looks the same as `Dot2` and `Dot3`, except that it additionally has an `operator` field that contains the operator that created the node. Consequently, the `visit_dot2` and `visit_dot3` methods have been removed from the visitor interface. If you were previously using these methods, you should now use `visit_range_literal` instead.
   - `DefEndless` and `Defs` have both been folded into the `Def` node. The `Def` node now has the `target` and `operator` fields which originally came from `Defs` which can both be `nil`. It also now has an `endless?` method on it to tell if the original node was found in the endless form. Finally the `bodystmt` field can now either be a `BodyStmt` as it was or any other kind of node since that was the body of the `DefEndless` node. The `visit_defs` and `visit_def_endless` methods on the visitor have therefore been removed.
   - `DoBlock` and `BraceBlock` have now been folded into a `Block` node. The `Block` node now has a `keywords?` method on it that returns true if the block was constructed with the `do`..`end` keywords. The `visit_do_block` and `visit_brace_block` methods on the visitor have therefore been removed and replaced with the `visit_block` method.
+  - `Return0` is no longer a node. Instead if has been folded into the `Return` node. The `Return` node can now have its `arguments` field be `nil`. Consequently, the `visit_return0` method has been removed from the visitor interface. If you were previously using this method, you should now use `visit_return` instead.
 - The `ZSuper` node no longer has a `value` field associated with it (which was always a "super" string literal).
 
 ## [4.3.0] - 2022-10-28

lib/syntax_tree/node.rb

@@ -1975,6 +1975,13 @@ def initialize(keyword, node)
     end
 
     def format(q)
+      # If there are no arguments associated with this flow control, then we can
+      # safely just print the keyword and return.
+      if node.arguments.nil?
+        q.text(keyword)
+        return
+      end
+
       q.group do
         q.text(keyword)
 
@@ -5077,8 +5084,8 @@ def call(q, node)
       def ternaryable?(statement)
         case statement
         when Alias, Assign, Break, Command, CommandCall, Heredoc, If, IfOp,
-             Lambda, MAssign, Next, OpAssign, RescueMod, Return, Return0, Super,
-             Undef, Unless, Until, VoidStmt, While, Yield, ZSuper
+             Lambda, MAssign, Next, OpAssign, RescueMod, Return, Super, Undef,
+             Unless, Until, VoidStmt, While, Yield, ZSuper
           # This is a list of nodes that should not be allowed to be a part of a
           # ternary clause.
           false
@@ -5351,8 +5358,8 @@ def deconstruct_keys(_keys)
     def format(q)
       force_flat = [
         Alias, Assign, Break, Command, CommandCall, Heredoc, If, IfOp, Lambda,
-        MAssign, Next, OpAssign, RescueMod, Return, Return0, Super, Undef,
-        Unless, VoidStmt, Yield, ZSuper
+        MAssign, Next, OpAssign, RescueMod, Return, Super, Undef, Unless,
+        VoidStmt, Yield, ZSuper
       ]
 
       if q.parent.is_a?(Paren) || force_flat.include?(truthy.class) ||
@@ -7739,7 +7746,7 @@ def format(q)
   #     return value
   #
   class Return < Node
-    # [Args] the arguments being passed to the keyword
+    # [nil | Args] the arguments being passed to the keyword
     attr_reader :arguments
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -7770,42 +7777,6 @@ def format(q)
     end
   end
 
-  # Return0 represents the bare +return+ keyword with no arguments.
-  #
-  #     return
-  #
-  class Return0 < Node
-    # [String] the value of the keyword
-    attr_reader :value
-
-    # [Array[ Comment | EmbDoc ]] the comments attached to this node
-    attr_reader :comments
-
-    def initialize(value:, location:)
-      @value = value
-      @location = location
-      @comments = []
-    end
-
-    def accept(visitor)
-      visitor.visit_return0(self)
-    end
-
-    def child_nodes
-      []
-    end
-
-    alias deconstruct child_nodes
-
-    def deconstruct_keys(_keys)
-      { value: value, location: location, comments: comments }
-    end
-
-    def format(q)
-      q.text(value)
-    end
-  end
-
   # RParen represents the use of a right parenthesis, i.e., +)+.
   class RParen < Node
     # [String] the parenthesis

lib/syntax_tree/parser.rb

@@ -3084,11 +3084,11 @@ def on_return(arguments)
     end
 
     # :call-seq:
-    #   on_return0: () -> Return0
+    #   on_return0: () -> Return
     def on_return0
       keyword = consume_keyword(:return)
 
-      Return0.new(value: keyword.value, location: keyword.location)
+      Return.new(arguments: nil, location: keyword.location)
     end
 
     # :call-seq:

lib/syntax_tree/visitor.rb

@@ -338,9 +338,6 @@ class Visitor < BasicVisitor
     # Visit a Return node.
     alias visit_return visit_child_nodes
 
-    # Visit a Return0 node.
-    alias visit_return0 visit_child_nodes
-
     # Visit a RParen node.
     alias visit_rparen visit_child_nodes
 

lib/syntax_tree/visitor/field_visitor.rb

@@ -789,10 +789,6 @@ def visit_return(node)
         end
       end
 
-      def visit_return0(node)
-        visit_token(node, "return0")
-      end
-
       def visit_rparen(node)
         node(node, "rparen") { field("value", node.value) }
       end

test/node_test.rb

@@ -841,7 +841,7 @@ def test_return
     end
 
     def test_return0
-      assert_node(Return0, "return")
+      assert_node(Return, "return")
     end
 
     def test_sclass