Fold Dot2 and Dot3 into RangeLiteral

Author: kddnewton

CHANGELOG.md

@@ -9,11 +9,12 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 ### Changed
 
 - Nodes no longer have a `comments:` keyword on their initializers. By default, they initialize to an empty array. If you were previously passing comments into the initializer, you should now create the node first, then call `node.comments.concat` to add your comments.
-- `IfMod` and `UnlessMod` are no longer nodes. Instead, they have been folded into `If` and `Unless`, respectively. The `If` and `Unless` nodes now have a `modifier?` method to tell you if they were original found in the modifier form.
-- `WhileMod` and `UntilMod` are no longer nodes. Instead, they have been folded into `While` and `Until`, respectively. The `While` and `Until` nodes now have a `modifier?` method to tell you if they were originally found in the modifier form.
-- `VarAlias` is no longer a node. Instead it has been folded into the `Alias` node. The `Alias` node now has a `var_alias?` method to tell you if it is aliasing a global variable.
-- `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`.
-- `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`.
+- A lot of nodes have been folded into other nodes to make it easier to interact with the AST. This means that a lot of visit methods have been removed from the visitor and a lot of class definitions are no longer present. This also means that the nodes that received more function now have additional methods or fields to be able to differentiate them. Note that none of these changes have resulted in different formatting. The changes are listed below:
+  - `IfMod`, `UnlessMod`, `WhileMod`, `UntilMod` have been folded into `If`, `Unless`, `While`, and `Until`. Each of the nodes now have a `modifier?` method to tell if it was originally in the modifier form. Consequently, the `visit_if_mod`, `visit_unless_mod`, `visit_while_mod`, and `visit_until_mod` methods have been removed from the visitor.
+  - `VarAlias` is no longer a node. Instead it has been folded into the `Alias` node. The `Alias` node now has a `var_alias?` method to tell you if it is aliasing a global variable. Consequently, the `visit_var_alias` method has been removed from the visitor interface. If you were previously using this method, you should now use `visit_alias` instead.
+  - `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.
 
 ## [4.3.0] - 2022-10-28
 

lib/syntax_tree/node.rb

@@ -3878,38 +3878,8 @@ def format(q)
     end
   end
 
-  # Responsible for formatting Dot2 and Dot3 nodes.
-  class DotFormatter
-    # [String] the operator to display
-    attr_reader :operator
-
-    # [Dot2 | Dot3] the node that is being formatter
-    attr_reader :node
-
-    def initialize(operator, node)
-      @operator = operator
-      @node = node
-    end
-
-    def format(q)
-      left = node.left
-      right = node.right
-
-      q.format(left) if left
-
-      case q.parent
-      when If, Unless
-        q.text(" #{operator} ")
-      else
-        q.text(operator)
-      end
-
-      q.format(right) if right
-    end
-  end
-
-  # Dot2 represents using the .. operator between two expressions. Usually this
-  # is to create a range object.
+  # RangeLiteral represents using the .. or the ... operator between two
+  # expressions. Usually this is to create a range object.
   #
   #     1..2
   #
@@ -3919,25 +3889,29 @@ def format(q)
   #     end
   #
   # One of the sides of the expression may be nil, but not both.
-  class Dot2 < Node
+  class RangeLiteral < Node
     # [nil | untyped] the left side of the expression
     attr_reader :left
 
+    # [Op] the operator used for this range
+    attr_reader :operator
+
     # [nil | untyped] the right side of the expression
     attr_reader :right
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
     attr_reader :comments
 
-    def initialize(left:, right:, location:)
+    def initialize(left:, operator:, right:, location:)
       @left = left
+      @operator = operator
       @right = right
       @location = location
       @comments = []
     end
 
     def accept(visitor)
-      visitor.visit_dot2(self)
+      visitor.visit_range_literal(self)
     end
 
     def child_nodes
@@ -3947,59 +3921,20 @@ def child_nodes
     alias deconstruct child_nodes
 
     def deconstruct_keys(_keys)
-      { left: left, right: right, location: location, comments: comments }
+      { left: left, operator: operator, right: right, location: location, comments: comments }
     end
 
     def format(q)
-      DotFormatter.new("..", self).format(q)
-    end
-  end
-
-  # Dot3 represents using the ... operator between two expressions. Usually this
-  # is to create a range object. It's effectively the same event as the Dot2
-  # node but with this operator you're asking Ruby to omit the final value.
-  #
-  #     1...2
-  #
-  # Like Dot2 it can also be used to create a flip-flop.
-  #
-  #     if value == 5 ... value == 10
-  #     end
-  #
-  # One of the sides of the expression may be nil, but not both.
-  class Dot3 < Node
-    # [nil | untyped] the left side of the expression
-    attr_reader :left
-
-    # [nil | untyped] the right side of the expression
-    attr_reader :right
-
-    # [Array[ Comment | EmbDoc ]] the comments attached to this node
-    attr_reader :comments
-
-    def initialize(left:, right:, location:)
-      @left = left
-      @right = right
-      @location = location
-      @comments = []
-    end
-
-    def accept(visitor)
-      visitor.visit_dot3(self)
-    end
-
-    def child_nodes
-      [left, right]
-    end
-
-    alias deconstruct child_nodes
+      q.format(left) if left
 
-    def deconstruct_keys(_keys)
-      { left: left, right: right, location: location, comments: comments }
-    end
+      case q.parent
+      when If, Unless
+        q.text(" #{operator.value} ")
+      else
+        q.text(operator.value)
+      end
 
-    def format(q)
-      DotFormatter.new("...", self).format(q)
+      q.format(right) if right
     end
   end
 
@@ -9771,7 +9706,7 @@ def format(q)
             # last argument to the predicate is and endless range, then you are
             # forced to use the "then" keyword to make it parse properly.
             last = arguments.parts.last
-            if (last.is_a?(Dot2) || last.is_a?(Dot3)) && !last.right
+            if last.is_a?(RangeLiteral) && !last.right
               q.text(" then")
             end
           end

lib/syntax_tree/parser.rb

@@ -1357,30 +1357,32 @@ def on_do_block(block_var, bodystmt)
     end
 
     # :call-seq:
-    #   on_dot2: ((nil | untyped) left, (nil | untyped) right) -> Dot2
+    #   on_dot2: ((nil | untyped) left, (nil | untyped) right) -> RangeLiteral
     def on_dot2(left, right)
       operator = consume_operator(:"..")
 
       beginning = left || operator
       ending = right || operator
 
-      Dot2.new(
+      RangeLiteral.new(
         left: left,
+        operator: operator,
         right: right,
         location: beginning.location.to(ending.location)
       )
     end
 
     # :call-seq:
-    #   on_dot3: ((nil | untyped) left, (nil | untyped) right) -> Dot3
+    #   on_dot3: ((nil | untyped) left, (nil | untyped) right) -> RangeLiteral
     def on_dot3(left, right)
       operator = consume_operator(:"...")
 
       beginning = left || operator
       ending = right || operator
 
-      Dot3.new(
+      RangeLiteral.new(
         left: left,
+        operator: operator,
         right: right,
         location: beginning.location.to(ending.location)
       )

lib/syntax_tree/visitor.rb

@@ -131,12 +131,6 @@ class Visitor < BasicVisitor
     # Visit a DoBlock node.
     alias visit_do_block visit_child_nodes
 
-    # Visit a Dot2 node.
-    alias visit_dot2 visit_child_nodes
-
-    # Visit a Dot3 node.
-    alias visit_dot3 visit_child_nodes
-
     # Visit a DynaSymbol node.
     alias visit_dyna_symbol visit_child_nodes
 
@@ -305,6 +299,9 @@ class Visitor < BasicVisitor
     # Visit a QWordsBeg node.
     alias visit_qwords_beg visit_child_nodes
 
+    # Visit a RangeLiteral node
+    alias visit_range_literal visit_child_nodes
+
     # Visit a RAssign node.
     alias visit_rassign visit_child_nodes
 

lib/syntax_tree/visitor/field_visitor.rb

@@ -362,22 +362,6 @@ def visit_do_block(node)
         end
       end
 
-      def visit_dot2(node)
-        node(node, "dot2") do
-          field("left", node.left) if node.left
-          field("right", node.right) if node.right
-          comments(node)
-        end
-      end
-
-      def visit_dot3(node)
-        node(node, "dot3") do
-          field("left", node.left) if node.left
-          field("right", node.right) if node.right
-          comments(node)
-        end
-      end
-
       def visit_dyna_symbol(node)
         node(node, "dyna_symbol") do
           list("parts", node.parts)
@@ -739,6 +723,15 @@ def visit_qwords_beg(node)
         node(node, "qwords_beg") { field("value", node.value) }
       end
 
+      def visit_range_literal(node)
+        node(node, "range_literal") do
+          field("left", node.left) if node.left
+          field("operator", node.operator)
+          field("right", node.right) if node.right
+          comments(node)
+        end
+      end
+
       def visit_rassign(node)
         node(node, "rassign") do
           field("value", node.value)

test/node_test.rb

@@ -414,11 +414,11 @@ def test_do_block
     end
 
     def test_dot2
-      assert_node(Dot2, "1..3")
+      assert_node(RangeLiteral, "1..3")
     end
 
     def test_dot3
-      assert_node(Dot3, "1...3")
+      assert_node(RangeLiteral, "1...3")
     end
 
     def test_dyna_symbol