Merge Words into ArrayLilteral

Signed-off-by: Alexandre Terrasa <[email protected]>

Author: Morriar

lib/syntax_tree/dsl.rb

@@ -952,15 +952,6 @@ def Word(parts)
       Word.new(parts: parts, location: Location.default)
     end
 
-    # Create a new Words node.
-    def Words(beginning, elements)
-      Words.new(
-        beginning: beginning,
-        elements: elements,
-        location: Location.default
-      )
-    end
-
     # Create a new WordsBeg node.
     def WordsBeg(value)
       WordsBeg.new(value: value, location: Location.default)

lib/syntax_tree/field_visitor.rb

@@ -959,13 +959,6 @@ def visit_word(node)
         end
       end
 
-      def visit_words(node)
-        node(node, "words") do
-          list("elements", node.elements)
-          comments(node)
-        end
-      end
-
       def visit_words_beg(node)
         node(node, "words_beg") { field("value", node.value) }
       end

lib/syntax_tree/mutation_visitor.rb

@@ -863,14 +863,6 @@ def visit_word(node)
         node.copy(parts: visit_all(node.parts))
       end
 
-      # Visit a Words node.
-      def visit_words(node)
-        node.copy(
-          beginning: visit(node.beginning),
-          elements: visit_all(node.elements)
-        )
-      end
-
       # Visit a WordsBeg node.
       def visit_words_beg(node)
         node.copy

lib/syntax_tree/node.rb

@@ -1214,7 +1214,7 @@ def format(q)
 
       q.group do
         case lbracket
-        when QSymbolsBeg, QWordsBeg
+        when QSymbolsBeg, QWordsBeg, WordsBeg
           q.text(lbracket.value)
         else
           q.format(lbracket)
@@ -1228,6 +1228,10 @@ def format(q)
               q.seplist(contents.parts, BREAKABLE_SPACE_SEPARATOR) do |part|
                 q.text(part.value)
               end
+            when WordsBeg
+              q.seplist(contents.parts, BREAKABLE_SPACE_SEPARATOR) do |part|
+                q.format(part)
+              end
             else
               q.format(contents)
               q.if_break { q.text(",") } if q.trailing_comma?
@@ -1238,7 +1242,7 @@ def format(q)
         q.breakable_empty
 
         case lbracket
-        when QSymbolsBeg, QWordsBeg
+        when QSymbolsBeg, QWordsBeg, WordsBeg
           q.text(lbracket.value[-1] == "{" ? "}" : "]")
         else
           q.text("]")
@@ -1416,7 +1420,7 @@ def ===(other)
   module AssignFormatting
     def self.skip_indent?(value)
       case value
-      when ArrayLiteral, HashLiteral, Heredoc, Lambda, Symbols, Words
+      when ArrayLiteral, HashLiteral, Heredoc, Lambda, Symbols
         true
       when CallNode
         skip_indent?(value.receiver)
@@ -11825,7 +11829,8 @@ def modifier?
   #
   #     %W[a#{b}c xyz]
   #
-  # In the example above, there would be two Word nodes within a parent Words
+  # In the example above, there would be two Word nodes within a parent
+  # ArrayLiteral
   # node.
   class Word < Node
     # [Array[ StringEmbExpr | StringDVar | TStringContent ]] the parts of the
@@ -11879,82 +11884,6 @@ def ===(other)
     end
   end
 
-  # Words represents a string literal array with interpolation.
-  #
-  #     %W[one two three]
-  #
-  class Words < Node
-    # [WordsBeg] the token that opens this array literal
-    attr_reader :beginning
-
-    # [Array[ Word ]] the elements of this array
-    attr_reader :elements
-
-    # [Array[ Comment | EmbDoc ]] the comments attached to this node
-    attr_reader :comments
-
-    def initialize(beginning:, elements:, location:)
-      @beginning = beginning
-      @elements = elements
-      @location = location
-      @comments = []
-    end
-
-    def accept(visitor)
-      visitor.visit_words(self)
-    end
-
-    def child_nodes
-      []
-    end
-
-    def copy(beginning: nil, elements: nil, location: nil)
-      Words.new(
-        beginning: beginning || self.beginning,
-        elements: elements || self.elements,
-        location: location || self.location
-      )
-    end
-
-    alias deconstruct child_nodes
-
-    def deconstruct_keys(_keys)
-      {
-        beginning: beginning,
-        elements: elements,
-        location: location,
-        comments: comments
-      }
-    end
-
-    def format(q)
-      opening, closing = "%W[", "]"
-
-      if elements.any? { |element| element.match?(/[\[\]]/) }
-        opening = beginning.value
-        closing = Quotes.matching(opening[2])
-      end
-
-      q.text(opening)
-      q.group do
-        q.indent do
-          q.breakable_empty
-          q.seplist(
-            elements,
-            ArrayLiteral::BREAKABLE_SPACE_SEPARATOR
-          ) { |element| q.format(element) }
-        end
-        q.breakable_empty
-      end
-      q.text(closing)
-    end
-
-    def ===(other)
-      other.is_a?(Words) && beginning === other.beginning &&
-        ArrayMatch.call(elements, other.elements)
-    end
-  end
-
   # WordsBeg represents the beginning of a string literal array with
   # interpolation.
   #

lib/syntax_tree/parser.rb

@@ -618,7 +618,7 @@ def on_args_new
 
     # :call-seq:
     #   on_array: ((nil | Args | Array [ TStringContent ]) contents) ->
-    #     ArrayLiteral | Symbols | Words
+    #     ArrayLiteral | Symbols
     def on_array(contents)
       if !contents || contents.is_a?(Args)
         lbracket = consume_token(LBracket)
@@ -4077,11 +4077,13 @@ def on_word_new
     end
 
     # :call-seq:
-    #   on_words_add: (Words words, Word word) -> Words
+    #   on_words_add: (ArrayLiteral words, Word word) -> ArrayLiteral
     def on_words_add(words, word)
-      Words.new(
-        beginning: words.beginning,
-        elements: words.elements << word,
+      words.contents.parts << word
+
+      ArrayLiteral.new(
+        lbracket: words.lbracket,
+        contents: words.contents,
         location: words.location.to(word.location)
       )
     end
@@ -4106,13 +4108,16 @@ def on_words_beg(value)
     end
 
     # :call-seq:
-    #   on_words_new: () -> Words
+    #   on_words_new: () -> ArrayLiteral
     def on_words_new
       beginning = consume_token(WordsBeg)
 
-      Words.new(
-        beginning: beginning,
-        elements: [],
+      ArrayLiteral.new(
+        lbracket: beginning,
+        contents: Args.new(
+          parts: [],
+          location: beginning.location
+        ),
         location: beginning.location
       )
     end

lib/syntax_tree/translation/parser.rb

@@ -2598,17 +2598,6 @@ def visit_word(node)
           )
         end
 
-        # Visit a Words node.
-        def visit_words(node)
-          visit_array(
-            ArrayLiteral.new(
-              lbracket: node.beginning,
-              contents: Args.new(parts: node.elements, location: node.location),
-              location: node.location
-            )
-          )
-        end
-
         # Visit an XStringLiteral node.
         def visit_xstring_literal(node)
           s(

lib/syntax_tree/visitor.rb

@@ -425,9 +425,6 @@ class Visitor < BasicVisitor
     # Visit a Word node.
     alias visit_word visit_child_nodes
 
-    # Visit a Words node.
-    alias visit_words visit_child_nodes
-
     # Visit a WordsBeg node.
     alias visit_words_beg visit_child_nodes
 

lib/syntax_tree/yarv/compiler.rb

@@ -236,10 +236,6 @@ def visit_word(node)
               raise CompilationError
             end
           end
-
-          def visit_words(node)
-            visit_all(node.elements)
-          end
         end
 
         # This isn't actually a visit method, though maybe it should be. It is
@@ -383,14 +379,24 @@ def visit_args(node)
       end
 
       def visit_array(node)
-        if node.lbracket.is_a?(QWordsBeg)
+        case node.lbracket
+        when QWordsBeg
           if options.frozen_string_literal?
             iseq.duparray(node.accept(RubyVisitor.new))
           else
             visit(node.contents)
             iseq.newarray(node.contents.parts.length)
           end
           return
+        when WordsBeg
+          if options.frozen_string_literal? &&
+               (compiled = RubyVisitor.compile(node))
+            iseq.duparray(compiled)
+          else
+            visit_all(node.contents.parts)
+            iseq.newarray(node.contents.parts.length)
+          end
+          return
         end
 
         if (compiled = RubyVisitor.compile(node))
@@ -1824,16 +1830,6 @@ def visit_word(node)
         end
       end
 
-      def visit_words(node)
-        if options.frozen_string_literal? &&
-             (compiled = RubyVisitor.compile(node))
-          iseq.duparray(compiled)
-        else
-          visit_all(node.elements)
-          iseq.newarray(node.elements.length)
-        end
-      end
-
       def visit_xstring_literal(node)
         iseq.putself
         length = visit_string_parts(node)

test/node_test.rb

@@ -990,11 +990,11 @@ def test_while_mod
 
     def test_word
       at = location(chars: 3..7)
-      assert_node(Word, "%W[word]", at: at) { |node| node.elements.first }
+      assert_node(Word, "%W[word]", at: at) { |node| node.contents.parts.first }
     end
 
     def test_words
-      assert_node(Words, "%W[one two three]")
+      assert_node(ArrayLiteral, "%W[one two three]")
     end
 
     def test_xstring_literal