Fold DefEndless into Def and Defs nodes

kddnewton · kddnewton · commit a99d08124ade · 2022-11-02T12:02:42.000-04:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -15,6 +15,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
   - `Yield0` is no longer a node. Instead if has been folded into the `Yield` node. The `Yield` node can now have its `arguments` field be `nil`. Consequently, the `visit_yield0` method has been removed from the visitor interface. If you were previously using this method, you should now use `visit_yield` instead.
   - `FCall` is no longer a node. Instead it has been folded into the `Call` node. The `Call` node can now have its `receiver` and `operator` fields be `nil`. Consequently, the `visit_fcall` method has been removed from the visitor interface. If you were previously using this method, you should now use `visit_call` instead.
   - `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` has been folded into the `Def` and `Defs` nodes.
 
 ## [4.3.0] - 2022-10-28
 
diff --git a/lib/syntax_tree/node.rb b/lib/syntax_tree/node.rb
@@ -3108,7 +3108,7 @@ def align(q, node, &block)
           part = parts.first
 
           case part
-          when Def, Defs, DefEndless
+          when Def, Defs
             q.text(" ")
             yield
           when IfOp
@@ -3540,10 +3540,10 @@ class Def < Node
     # [Backtick | Const | Ident | Kw | Op] the name of the method
     attr_reader :name
 
-    # [Params | Paren] the parameter declaration for the method
+    # [nil | Params | Paren] the parameter declaration for the method
     attr_reader :params
 
-    # [BodyStmt] the expressions to be executed by the method
+    # [BodyStmt | untyped] the expressions to be executed by the method
     attr_reader :bodystmt
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -3583,112 +3583,41 @@ def format(q)
           q.text("def ")
           q.format(name)
 
-          if !params.is_a?(Params) || !params.empty? || params.comments.any?
+          case params
+          when Paren
             q.format(params)
+          when Params
+            q.format(params) if !params.empty? || params.comments.any?
           end
         end
 
-        unless bodystmt.empty?
-          q.indent do
-            q.breakable_force
-            q.format(bodystmt)
+        if endless?
+          q.text(" =")
+          q.group do
+            q.indent do
+              q.breakable_space
+              q.format(bodystmt)
+            end
+          end
+        else
+          unless bodystmt.empty?
+            q.indent do
+              q.breakable_force
+              q.format(bodystmt)
+            end
           end
-        end
 
-        q.breakable_force
-        q.text("end")
+          q.breakable_force
+          q.text("end")
+        end
       end
     end
-  end
-
-  # DefEndless represents defining a single-line method since Ruby 3.0+.
-  #
-  #     def method = result
-  #
-  class DefEndless < Node
-    # [untyped] the target where the method is being defined
-    attr_reader :target
-
-    # [Op | Period] the operator being used to declare the method
-    attr_reader :operator
-
-    # [Backtick | Const | Ident | Kw | Op] the name of the method
-    attr_reader :name
-
-    # [nil | Params | Paren] the parameter declaration for the method
-    attr_reader :paren
-
-    # [untyped] the expression to be executed by the method
-    attr_reader :statement
-
-    # [Array[ Comment | EmbDoc ]] the comments attached to this node
-    attr_reader :comments
-
-    def initialize(
-      target:,
-      operator:,
-      name:,
-      paren:,
-      statement:,
-      location:,
-      comments: []
-    )
-      @target = target
-      @operator = operator
-      @name = name
-      @paren = paren
-      @statement = statement
-      @location = location
-      @comments = []
-    end
-
-    def accept(visitor)
-      visitor.visit_def_endless(self)
-    end
 
-    def child_nodes
-      [target, operator, name, paren, statement]
-    end
-
-    alias deconstruct child_nodes
-
-    def deconstruct_keys(_keys)
-      {
-        target: target,
-        operator: operator,
-        name: name,
-        paren: paren,
-        statement: statement,
-        location: location,
-        comments: comments
-      }
-    end
-
-    def format(q)
-      q.group do
-        q.text("def ")
-
-        if target
-          q.format(target)
-          q.format(CallOperatorFormatter.new(operator), stackable: false)
-        end
-
-        q.format(name)
-
-        if paren
-          params = paren
-          params = params.contents if params.is_a?(Paren)
-          q.format(paren) unless params.empty?
-        end
-
-        q.text(" =")
-        q.group do
-          q.indent do
-            q.breakable_space
-            q.format(statement)
-          end
-        end
-      end
+    # Returns true if the method was found in the source in the "endless" form,
+    # i.e. where the method body is defined using the `=` operator after the
+    # method name and parameters.
+    def endless?
+      !bodystmt.is_a?(BodyStmt)
     end
   end
 
@@ -3751,10 +3680,10 @@ class Defs < Node
     # [Backtick | Const | Ident | Kw | Op] the name of the method
     attr_reader :name
 
-    # [Params | Paren] the parameter declaration for the method
+    # [nil | Params | Paren] the parameter declaration for the method
     attr_reader :params
 
-    # [BodyStmt] the expressions to be executed by the method
+    # [BodyStmt | untyped] the expressions to be executed by the method
     attr_reader :bodystmt
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -3808,22 +3737,42 @@ def format(q)
           q.format(CallOperatorFormatter.new(operator), stackable: false)
           q.format(name)
 
-          if !params.is_a?(Params) || !params.empty? || params.comments.any?
+          case params
+          when Paren
             q.format(params)
+          when Params
+            q.format(params) if !params.empty? || params.comments.any?
           end
         end
 
-        unless bodystmt.empty?
-          q.indent do
-            q.breakable_force
-            q.format(bodystmt)
+        if endless?
+          q.text(" =")
+          q.group do
+            q.indent do
+              q.breakable_space
+              q.format(bodystmt)
+            end
+          end
+        else
+          unless bodystmt.empty?
+            q.indent do
+              q.breakable_force
+              q.format(bodystmt)
+            end
           end
-        end
 
-        q.breakable_force
-        q.text("end")
+          q.breakable_force
+          q.text("end")
+        end
       end
     end
+
+    # Returns true if the method was found in the source in the "endless" form,
+    # i.e. where the method body is defined using the `=` operator after the
+    # method name and parameters.
+    def endless?
+      !bodystmt.is_a?(BodyStmt)
+    end
   end
 
   # DoBlock represents passing a block to a method call using the +do+ and +end+
@@ -6971,7 +6920,7 @@ def format(q)
       end
 
       case q.parent
-      when Def, Defs, DefEndless
+      when Def, Defs
         q.nest(0) do
           q.text("(")
           q.group do
diff --git a/lib/syntax_tree/parser.rb b/lib/syntax_tree/parser.rb
@@ -1181,7 +1181,7 @@ def on_cvar(value)
     #     (Backtick | Const | Ident | Kw | Op) name,
     #     (nil | Params | Paren) params,
     #     untyped bodystmt
-    #   ) -> Def | DefEndless
+    #   ) -> Def
     def on_def(name, params, bodystmt)
       # Make sure to delete this token in case you're defining something like
       # def class which would lead to this being a kw and causing all kinds of
@@ -1234,12 +1234,10 @@ def on_def(name, params, bodystmt)
         # the statements list. Before, it was just the individual statement.
         statement = bodystmt.is_a?(BodyStmt) ? bodystmt.statements : bodystmt
 
-        DefEndless.new(
-          target: nil,
-          operator: nil,
+        Def.new(
           name: name,
-          paren: params,
-          statement: statement,
+          params: params,
+          bodystmt: statement,
           location: beginning.location.to(bodystmt.location)
         )
       end
@@ -1322,12 +1320,12 @@ def on_defs(target, operator, name, params, bodystmt)
         # the statements list. Before, it was just the individual statement.
         statement = bodystmt.is_a?(BodyStmt) ? bodystmt.statements : bodystmt
 
-        DefEndless.new(
+        Defs.new(
           target: target,
           operator: operator,
           name: name,
-          paren: params,
-          statement: statement,
+          params: params,
+          bodystmt: statement,
           location: beginning.location.to(bodystmt.location)
         )
       end
diff --git a/lib/syntax_tree/visitor.rb b/lib/syntax_tree/visitor.rb
@@ -119,9 +119,6 @@ class Visitor < BasicVisitor
     # Visit a Def node.
     alias visit_def visit_child_nodes
 
-    # Visit a DefEndless node.
-    alias visit_def_endless visit_child_nodes
-
     # Visit a Defined node.
     alias visit_defined visit_child_nodes
 
diff --git a/lib/syntax_tree/visitor/field_visitor.rb b/lib/syntax_tree/visitor/field_visitor.rb
@@ -322,20 +322,6 @@ def visit_def(node)
         end
       end
 
-      def visit_def_endless(node)
-        node(node, "def_endless") do
-          if node.target
-            field("target", node.target)
-            field("operator", node.operator)
-          end
-
-          field("name", node.name)
-          field("paren", node.paren) if node.paren
-          field("statement", node.statement)
-          comments(node)
-        end
-      end
-
       def visit_defined(node)
         node(node, "defined") do
           field("value", node.value)
diff --git a/lib/syntax_tree/visitor/with_environment.rb b/lib/syntax_tree/visitor/with_environment.rb
@@ -60,10 +60,6 @@ def visit_defs(node)
       with_new_environment { super }
     end
 
-    def visit_def_endless(node)
-      with_new_environment { super }
-    end
-
     # Visit for keeping track of local arguments, such as method and block
     # arguments
     def visit_params(node)
diff --git a/test/fixtures/def_endless.rb b/test/fixtures/def_endless.rb
@@ -4,8 +4,6 @@ def foo = bar
 def foo(bar) = baz
 %
 def foo() = bar
--
-def foo = bar
 % # >= 3.1.0
 def foo = bar baz
 % # >= 3.1.0
@@ -14,8 +12,6 @@ def self.foo = bar
 def self.foo(bar) = baz
 % # >= 3.1.0
 def self.foo() = bar
--
-def self.foo = bar
 % # >= 3.1.0
 def self.foo = bar baz
 %
diff --git a/test/node_test.rb b/test/node_test.rb
@@ -379,13 +379,13 @@ def method
 
     guard_version("3.0.0") do
       def test_def_endless
-        assert_node(DefEndless, "def method = result")
+        assert_node(Def, "def method = result")
       end
     end
 
     guard_version("3.1.0") do
       def test_def_endless_command
-        assert_node(DefEndless, "def method = result argument")
+        assert_node(Def, "def method = result argument")
       end
     end
 
