Fold Def and DefEndless

Author: kddnewton

CHANGELOG.md

@@ -15,7 +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.
+  - `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.
 
 ## [4.3.0] - 2022-10-28
 

lib/syntax_tree/node.rb

@@ -3108,7 +3108,7 @@ def align(q, node, &block)
           part = parts.first
 
           case part
-          when Def, Defs
+          when Def
             q.text(" ")
             yield
           when IfOp
@@ -3535,8 +3535,15 @@ def format(q)
   # Def represents defining a regular method on the current self object.
   #
   #     def method(param) result end
+  #     def object.method(param) result end
   #
   class Def < Node
+    # [nil | untyped] the target where the method is being defined
+    attr_reader :target
+
+    # [nil | 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
 
@@ -3549,7 +3556,9 @@ class Def < Node
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
     attr_reader :comments
 
-    def initialize(name:, params:, bodystmt:, location:)
+    def initialize(target:, operator:, name:, params:, bodystmt:, location:)
+      @target = target
+      @operator = operator
       @name = name
       @params = params
       @bodystmt = bodystmt
@@ -3562,13 +3571,15 @@ def accept(visitor)
     end
 
     def child_nodes
-      [name, params, bodystmt]
+      [target, operator, name, params, bodystmt]
     end
 
     alias deconstruct child_nodes
 
     def deconstruct_keys(_keys)
       {
+        target: target,
+        operator: operator,
         name: name,
         params: params,
         bodystmt: bodystmt,
@@ -3581,6 +3592,12 @@ def format(q)
       q.group do
         q.group do
           q.text("def ")
+
+          if target
+            q.format(target)
+            q.format(CallOperatorFormatter.new(operator), stackable: false)
+          end
+
           q.format(name)
 
           case params
@@ -3666,115 +3683,6 @@ def format(q)
     end
   end
 
-  # Defs represents defining a singleton method on an object.
-  #
-  #     def object.method(param) result end
-  #
-  class Defs < 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 :params
-
-    # [BodyStmt | untyped] the expressions to be executed by the method
-    attr_reader :bodystmt
-
-    # [Array[ Comment | EmbDoc ]] the comments attached to this node
-    attr_reader :comments
-
-    def initialize(
-      target:,
-      operator:,
-      name:,
-      params:,
-      bodystmt:,
-      location:,
-      comments: []
-    )
-      @target = target
-      @operator = operator
-      @name = name
-      @params = params
-      @bodystmt = bodystmt
-      @location = location
-      @comments = []
-    end
-
-    def accept(visitor)
-      visitor.visit_defs(self)
-    end
-
-    def child_nodes
-      [target, operator, name, params, bodystmt]
-    end
-
-    alias deconstruct child_nodes
-
-    def deconstruct_keys(_keys)
-      {
-        target: target,
-        operator: operator,
-        name: name,
-        params: params,
-        bodystmt: bodystmt,
-        location: location,
-        comments: comments
-      }
-    end
-
-    def format(q)
-      q.group do
-        q.group do
-          q.text("def ")
-          q.format(target)
-          q.format(CallOperatorFormatter.new(operator), stackable: false)
-          q.format(name)
-
-          case params
-          when Paren
-            q.format(params)
-          when Params
-            q.format(params) if !params.empty? || params.comments.any?
-          end
-        end
-
-        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
-
-          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+
   # keywords.
   #
@@ -6919,8 +6827,7 @@ def format(q)
         return
       end
 
-      case q.parent
-      when Def, Defs
+      if q.parent.is_a?(Def)
         q.nest(0) do
           q.text("(")
           q.group do

lib/syntax_tree/parser.rb

@@ -1224,6 +1224,8 @@ def on_def(name, params, bodystmt)
         )
 
         Def.new(
+          target: nil,
+          operator: nil,
           name: name,
           params: params,
           bodystmt: bodystmt,
@@ -1235,6 +1237,8 @@ def on_def(name, params, bodystmt)
         statement = bodystmt.is_a?(BodyStmt) ? bodystmt.statements : bodystmt
 
         Def.new(
+          target: nil,
+          operator: nil,
           name: name,
           params: params,
           bodystmt: statement,
@@ -1268,7 +1272,7 @@ def on_defined(value)
     #     (Backtick | Const | Ident | Kw | Op) name,
     #     (Params | Paren) params,
     #     BodyStmt bodystmt
-    #   ) -> Defs
+    #   ) -> Def
     def on_defs(target, operator, 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
@@ -1307,7 +1311,7 @@ def on_defs(target, operator, name, params, bodystmt)
           ending.location.start_column
         )
 
-        Defs.new(
+        Def.new(
           target: target,
           operator: operator,
           name: name,
@@ -1320,7 +1324,7 @@ 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
 
-        Defs.new(
+        Def.new(
           target: target,
           operator: operator,
           name: name,

lib/syntax_tree/visitor.rb

@@ -122,9 +122,6 @@ class Visitor < BasicVisitor
     # Visit a Defined node.
     alias visit_defined visit_child_nodes
 
-    # Visit a Defs node.
-    alias visit_defs visit_child_nodes
-
     # Visit a DoBlock node.
     alias visit_do_block visit_child_nodes
 

lib/syntax_tree/visitor/field_visitor.rb

@@ -315,6 +315,8 @@ def visit_cvar(node)
 
       def visit_def(node)
         node(node, "def") do
+          field("target", node.target)
+          field("operator", node.operator)
           field("name", node.name)
           field("params", node.params)
           field("bodystmt", node.bodystmt)
@@ -329,17 +331,6 @@ def visit_defined(node)
         end
       end
 
-      def visit_defs(node)
-        node(node, "defs") do
-          field("target", node.target)
-          field("operator", node.operator)
-          field("name", node.name)
-          field("params", node.params)
-          field("bodystmt", node.bodystmt)
-          comments(node)
-        end
-      end
-
       def visit_do_block(node)
         node(node, "do_block") do
           field("block_var", node.block_var) if node.block_var

lib/syntax_tree/visitor/with_environment.rb

@@ -56,10 +56,6 @@ def visit_def(node)
       with_new_environment { super }
     end
 
-    def visit_defs(node)
-      with_new_environment { super }
-    end
-
     # Visit for keeping track of local arguments, such as method and block
     # arguments
     def visit_params(node)

test/node_test.rb

@@ -394,7 +394,7 @@ def test_defined
     end
 
     def test_defs
-      assert_node(Defs, "def object.method(param) result end")
+      assert_node(Def, "def object.method(param) result end")
     end
 
     def test_defs_paramless
@@ -403,7 +403,7 @@ def object.method
         end
       SOURCE
 
-      assert_node(Defs, source)
+      assert_node(Def, source)
     end
 
     def test_do_block