Fix array pattern unparsing

Parser represents %-encoded array patterns with the `ArrayNode`,
not `ArrayPatternNode`. We can infer required %-notation variant
given array's children elements.

```bash
$ bundle exec bin/unparser -e 'a => %i[a b]'
(string)
Original-Source:
a => %i[a b]
Generated-Source:
a => [:a, :b]
Original-Node:
(match-pattern
  (send nil :a)
  (array
    (sym :a)
    (sym :b)))
Generated-Node:
(match-pattern
  (send nil :a)
  (array-pattern
    (sym :a)
    (sym :b)))
Node-Diff:
@@ -1,5 +1,5 @@
 (match-pattern
   (send nil :a)
-  (array
+  (array-pattern
     (sym :a)
     (sym :b)))
Error: (string)
```

Author: viralpraxis

lib/unparser.rb

@@ -295,6 +295,7 @@ def self.buffer(source, identification = '(string)')
 require 'unparser/emitter/match_pattern'
 require 'unparser/emitter/match_pattern_p'
 require 'unparser/writer'
+require 'unparser/writer/array'
 require 'unparser/writer/binary'
 require 'unparser/writer/dynamic_string'
 require 'unparser/writer/regexp'

lib/unparser/emitter/in_pattern.rb

@@ -16,7 +16,7 @@ def dispatch
 
         ws
 
-        visit(target)
+        dispatch_target(target)
 
         if unless_guard
           ws
@@ -31,6 +31,14 @@ def dispatch
           nl
         end
       end
+
+      def dispatch_target(target)
+        if n_array?(target)
+          writer_with(Writer::Array, node: target).emit_compact
+        else
+          visit(target)
+        end
+      end
     end # InPattern
   end # Emitter
 end # Unparser

lib/unparser/emitter/match_pattern.rb

@@ -14,7 +14,12 @@ class MatchPattern < self
       def dispatch
         visit(target)
         write(' => ')
-        visit(pattern)
+
+        if n_array?(pattern)
+          writer_with(Writer::Array, node: pattern).emit_compact
+        else
+          visit(pattern)
+        end
       end
     end # MatchPattern
   end # Emitter

lib/unparser/emitter/match_pattern_p.rb

@@ -13,7 +13,12 @@ class MatchPatternP < self
       def dispatch
         visit(target)
         write(' in ')
-        visit(pattern)
+
+        if n_array?(pattern)
+          writer_with(Writer::Array, node: pattern).emit_compact
+        else
+          visit(pattern)
+        end
       end
     end # MatchPatternP
   end # Emitter

lib/unparser/writer/array.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    class Array
+      include Writer, Adamantium
+
+      MAP = {
+        dsym: '%I',
+        sym:  '%i',
+        dstr: '%W',
+        str:  '%w'
+      }.freeze
+      private_constant(*constants(false))
+
+      def emit_compact # rubocop:disable Metrics/AbcSize
+        children_generic_type = array_elements_generic_type || :sym
+
+        write(MAP.fetch(children_generic_type))
+
+        # NOTE: I'd like to use stricter `children.fetch(0)` here instead of `children.first`,
+        # but mutant tries to inject `fetch(-1)` and complains that tests pass.
+        # fetch(0) and fetch(-1) are equivalent for singleton arrays and there's not `sole` in the stdlb.
+        parentheses('[', ']') do
+          delimited(children, ' ') do |child|
+            if n_sym?(child) || n_str?(child)
+              write(child.children.first.to_s)
+            else
+              write('#{')
+              emitter(unwrap_single_begin(child.children.first)).write_to_buffer
+              write('}')
+            end
+          end
+        end
+      end
+
+      private
+
+      def array_elements_generic_type
+        children_types = children.to_set(&:type)
+
+        if children_types == Set[:sym, :dsym]
+          :dsym
+        elsif children_types == Set[:str, :dstr]
+          :dstr
+        else
+          children_types.first
+        end
+      end
+    end # Array
+  end # Writer
+end # Unparser

test/corpus/literal/pattern.rb

@@ -43,3 +43,40 @@
 1 => [*]
 1 in [*, 42, *]
 1 in [*, a, *foo]
+a => %i[a b]
+a => %w[a b]
+a => ["a", "b"]
+a => [:a, :b]
+a => [:a, "b"]
+a => [true, false, nil]
+a => {a: 1, b: 2}
+a in %i[a b]
+a in %w[a b]
+a in ["a", "b"]
+a in [:a, :b]
+a in [:a, "b"]
+a in [true, false, nil]
+a in {a: 1, b: 2}
+case foo
+in %i[a b]
+end
+case foo
+in %w[a b]
+end
+case foo
+in [:a, "b"]
+end
+case foo
+in [1, 2]
+end
+case foo
+in [true, false, nil]
+end
+a => %I[a b #{foo(1)}]
+a => %W[a b #{foo(1)}]
+case a
+in %I[#{1 + 1}]
+end
+case foo
+in %i[a b c $FILE]
+end

test/corpus/semantic/pattern.rb

@@ -0,0 +1,28 @@
+case foo
+in %s[a b]
+end
+case foo
+in %r[foo]
+end
+case foo
+in %r[/foo.+bar/]
+end
+case foo
+in %r:/foo.+bar/:
+end
+case foo
+in %x(rm -rf /)
+end
+case foo
+in %i[]
+end
+case foo
+in %w[]
+end
+case foo
+in %q[a b c #{foo}]
+end
+case foo
+in %q[a b c $FILE]
+end
+