Update to ruby/spec@f8a2d54

1 files changed, 966 insertions, 0 deletions

diff --git a/spec/ruby/language/pattern_matching_spec.rb b/spec/ruby/language/pattern_matching_spec.rb
new file mode 100644
index 0000000000..6a6de506ff
--- /dev/null
+++ b/spec/ruby/language/pattern_matching_spec.rb
@@ -0,0 +1,966 @@
+require_relative '../spec_helper'
+
+ruby_version_is "2.7" do
+  describe "Pattern matching" do
+    # TODO: Remove excessive eval calls when support of previous version
+    #       Ruby 2.6 will be dropped
+
+    before do
+      ScratchPad.record []
+    end
+
+    it "can be standalone in operator that deconstructs value" do
+      eval(<<-RUBY).should == [0, 1]
+        [0, 1] in [a, b]
+        [a, b]
+      RUBY
+    end
+
+    it "extends case expression with case/in construction" do
+      eval(<<~RUBY).should == :bar
+        case [0, 1]
+          in [0]
+            :foo
+          in [0, 1]
+            :bar
+        end
+      RUBY
+    end
+
+    it "allows using then operator" do
+      eval(<<~RUBY).should == :bar
+        case [0, 1]
+          in [0]    then :foo
+          in [0, 1] then :bar
+        end
+      RUBY
+    end
+
+    it "warns about pattern matching is experimental feature" do
+      -> {
+        eval <<~RUBY
+          case 0
+            in 0
+          end
+        RUBY
+      }.should complain(/warning: Pattern matching is experimental, and the behavior may change in future versions of Ruby!/)
+    end
+
+    it "binds variables" do
+      eval(<<~RUBY).should == 1
+        case [0, 1]
+          in [0, a]
+            a
+        end
+      RUBY
+    end
+
+    it "cannot mix in and when operators" do
+      -> {
+        eval <<~RUBY
+          case []
+            when 1 == 1
+            in []
+          end
+        RUBY
+      }.should raise_error(SyntaxError, /syntax error, unexpected `in'/)
+
+      -> {
+        eval <<~RUBY
+          case []
+            in []
+            when 1 == 1
+          end
+        RUBY
+      }.should raise_error(SyntaxError, /syntax error, unexpected `when'/)
+    end
+
+    it "checks patterns until the first matching" do
+      eval(<<~RUBY).should == :bar
+        case [0, 1]
+          in [0]
+            :foo
+          in [0, 1]
+            :bar
+          in [0, 1]
+            :baz
+        end
+      RUBY
+    end
+
+    it "executes else clause if no pattern matches" do
+      eval(<<~RUBY).should == false
+        case [0, 1]
+          in [0]
+            true
+          else
+            false
+        end
+      RUBY
+    end
+
+    it "raises NoMatchingPatternError if no pattern matches and no else clause" do
+      -> {
+        eval <<~RUBY
+          case [0, 1]
+            in [0]
+          end
+        RUBY
+      }.should raise_error(NoMatchingPatternError, /\[0, 1\]/)
+    end
+
+    it "does not allow calculation or method calls in a pattern" do
+      -> {
+        eval <<~RUBY
+          case 0
+            in 1 + 1
+              true
+          end
+        RUBY
+      }.should raise_error(SyntaxError, /unexpected/)
+    end
+
+    describe "guards" do
+      it "supports if guard" do
+        eval(<<~RUBY).should == false
+          case 0
+            in 0 if false
+              true
+          else
+            false
+          end
+        RUBY
+
+        eval(<<~RUBY).should == true
+          case 0
+            in 0 if true
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "supports unless guard" do
+        eval(<<~RUBY).should == false
+          case 0
+            in 0 unless true
+              true
+          else
+            false
+          end
+        RUBY
+
+        eval(<<~RUBY).should == true
+          case 0
+            in 0 unless false
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "makes bound variables visible in guard" do
+        eval(<<~RUBY).should == true
+          case [0, 1]
+            in [a, 1] if a >= 0
+              true
+          end
+        RUBY
+      end
+
+      it "does not evaluate guard if pattern does not match" do
+        eval <<~RUBY
+          case 0
+            in 1 if (ScratchPad << :foo) || true
+          else
+          end
+        RUBY
+
+        ScratchPad.recorded.should == []
+      end
+
+      it "takes guards into account when there are several matching patterns" do
+        eval(<<~RUBY).should == :bar
+          case 0
+            in 0 if false
+              :foo
+            in 0 if true
+              :bar
+          end
+        RUBY
+      end
+
+      it "executes else clause if no guarded pattern matches" do
+        eval(<<~RUBY).should == false
+          case 0
+            in 0 if false
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "raises NoMatchingPatternError if no guarded pattern matches and no else clause" do
+        -> {
+          eval <<~RUBY
+            case [0, 1]
+              in [0, 1] if false
+            end
+          RUBY
+        }.should raise_error(NoMatchingPatternError, /\[0, 1\]/)
+      end
+    end
+
+    describe "value pattern" do
+      it "matches an object such that pattern === object" do
+        eval(<<~RUBY).should == true
+          case 0
+            in 0
+              true
+          end
+        RUBY
+
+        eval(<<~RUBY).should == true
+          case 0
+            in (-1..1)
+              true
+          end
+        RUBY
+
+        eval(<<~RUBY).should == true
+          case 0
+            in Integer
+              true
+          end
+        RUBY
+
+        eval(<<~RUBY).should == true
+          case "0"
+            in /0/
+              true
+          end
+        RUBY
+
+        eval(<<~RUBY).should == true
+          case "0"
+            in ->(s) { s == "0" }
+              true
+          end
+        RUBY
+      end
+
+      it "allows string literal with interpolation" do
+        x = "x"
+
+        eval(<<~RUBY).should == true
+          case "x"
+            in "#{x + ""}"
+              true
+          end
+        RUBY
+      end
+    end
+
+    describe "variable pattern" do
+      it "matches a value and binds variable name to this value" do
+        eval(<<~RUBY).should == 0
+          case 0
+            in a
+              a
+          end
+        RUBY
+      end
+
+      it "makes bounded variable visible outside a case statement scope" do
+        eval(<<~RUBY).should == 0
+          case 0
+            in a
+          end
+
+          a
+        RUBY
+      end
+
+      it "create local variables even if a pattern doesn't match" do
+        eval(<<~RUBY).should == [0, nil, nil]
+          case 0
+            in a
+            in b
+            in c
+          end
+
+          [a, b, c]
+        RUBY
+      end
+
+      it "allow using _ name to drop values" do
+        eval(<<~RUBY).should == 0
+          case [0, 1]
+            in [a, _]
+              a
+          end
+        RUBY
+      end
+
+      it "supports using _ in a pattern several times" do
+        eval(<<~RUBY).should == 2
+          case [0, 1, 2]
+            in [0, _, _]
+              _
+          end
+        RUBY
+      end
+
+      it "supports using any name with _ at the beginning in a pattern several times" do
+        eval(<<~RUBY).should == 2
+          case [0, 1, 2]
+            in [0, _x, _x]
+              _x
+          end
+        RUBY
+
+        eval(<<~RUBY).should == 2
+          case {a: 0, b: 1, c: 2}
+            in {a: 0, b: _x, c: _x}
+              _x
+          end
+        RUBY
+      end
+
+      it "does not support using variable name (except _) several times" do
+        -> {
+          eval <<~RUBY
+            case [0]
+              in [a, a]
+            end
+          RUBY
+        }.should raise_error(SyntaxError, /duplicated variable name/)
+      end
+
+      it "supports existing variables in a pattern specified with ^ operator" do
+        a = 0
+
+        eval(<<~RUBY).should == true
+          case 0
+            in ^a
+              true
+          end
+        RUBY
+      end
+
+      it "allows applying ^ operator to bound variables" do
+        eval(<<~RUBY).should == 1
+          case [1, 1]
+            in [n, ^n]
+              n
+          end
+        RUBY
+
+        eval(<<~RUBY).should == false
+          case [1, 2]
+            in [n, ^n]
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "requires bound variable to be specified in a pattern before ^ operator when it relies on a bound variable" do
+        -> {
+          eval <<~RUBY
+            case [1, 2]
+              in [^n, n]
+                true
+            else
+              false
+            end
+          RUBY
+        }.should raise_error(SyntaxError, /n: no such local variable/)
+      end
+    end
+
+    describe "alternative pattern" do
+      it "matches if any of patterns matches" do
+        eval(<<~RUBY).should == true
+          case 0
+            in 0 | 1 | 2
+              true
+          end
+        RUBY
+      end
+
+      it "does not support variable binding" do
+        -> {
+          eval <<~RUBY
+            case [0, 1]
+              in [0, 0] | [0, a]
+            end
+          RUBY
+        }.should raise_error(SyntaxError, /illegal variable in alternative pattern/)
+      end
+    end
+
+    describe "AS pattern" do
+      it "binds a variable to a value if pattern matches" do
+        eval(<<~RUBY).should == 0
+          case 0
+            in Integer => n
+              n
+          end
+        RUBY
+      end
+
+      it "can be used as a nested pattern" do
+        eval(<<~RUBY).should == [2, 3]
+          case [1, [2, 3]]
+            in [1, Array => ary]
+              ary
+          end
+        RUBY
+      end
+    end
+
+    describe "Array pattern" do
+      it "supports form Constant(pat, pat, ...)" do
+        eval(<<~RUBY).should == true
+          case [0, 1, 2]
+            in Array(0, 1, 2)
+              true
+          end
+        RUBY
+      end
+
+      it "supports form Constant[pat, pat, ...]" do
+        eval(<<~RUBY).should == true
+          case [0, 1, 2]
+            in Array[0, 1, 2]
+              true
+          end
+        RUBY
+      end
+
+      it "supports form [pat, pat, ...]" do
+        eval(<<~RUBY).should == true
+          case [0, 1, 2]
+            in [0, 1, 2]
+              true
+          end
+        RUBY
+      end
+
+      it "supports form pat, pat, ..." do
+        eval(<<~RUBY).should == true
+          case [0, 1, 2]
+            in 0, 1, 2
+              true
+          end
+        RUBY
+
+        eval(<<~RUBY).should == 1
+          case [0, 1, 2]
+            in 0, a, 2
+              a
+          end
+        RUBY
+
+        eval(<<~RUBY).should == [1, 2]
+          case [0, 1, 2]
+            in 0, *rest
+              rest
+          end
+        RUBY
+      end
+
+      it "matches an object with #deconstruct method which returns an array and each element in array matches element in pattern" do
+        obj = Object.new
+        def obj.deconstruct; [0, 1] end
+
+        eval(<<~RUBY).should == true
+          case obj
+            in [Integer, Integer]
+              true
+          end
+        RUBY
+      end
+
+      it "does not match object if Constant === object returns false" do
+        eval(<<~RUBY).should == false
+          case [0, 1, 2]
+            in String[0, 1, 2]
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "does not match object without #deconstruct method" do
+        obj = Object.new
+
+        eval(<<~RUBY).should == false
+          case obj
+            in Object[]
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "raises TypeError if #deconstruct method does not return array" do
+        obj = Object.new
+        def obj.deconstruct; "" end
+
+        -> {
+          eval <<~RUBY
+            case obj
+              in Object[]
+            else
+            end
+          RUBY
+        }.should raise_error(TypeError, /deconstruct must return Array/)
+      end
+
+      it "does not match object if elements of array returned by #deconstruct method does not match elements in pattern" do
+        obj = Object.new
+        def obj.deconstruct; [1] end
+
+        eval(<<~RUBY).should == false
+          case obj
+            in Object[0]
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "binds variables" do
+        eval(<<~RUBY).should == [0, 1, 2]
+          case [0, 1, 2]
+            in [a, b, c]
+              [a, b, c]
+          end
+        RUBY
+      end
+
+      it "binds variable even if patter matches only partially" do
+        a = nil
+
+        eval(<<~RUBY).should == 0
+          case [0, 1, 2]
+            in [a, 1, 3]
+          else
+          end
+
+          a
+        RUBY
+      end
+
+      it "supports splat operator *rest" do
+        eval(<<~RUBY).should == [1, 2]
+          case [0, 1, 2]
+            in [0, *rest]
+              rest
+          end
+        RUBY
+      end
+
+      it "does not match partially by default" do
+        eval(<<~RUBY).should == false
+          case [0, 1, 2, 3]
+            in [1, 2]
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "does match partially from the array beginning if list + , syntax used" do
+        eval(<<~RUBY).should == true
+          case [0, 1, 2, 3]
+            in [0, 1,]
+              true
+          end
+        RUBY
+
+        eval(<<~RUBY).should == true
+          case [0, 1, 2, 3]
+            in 0, 1,;
+              true
+          end
+        RUBY
+      end
+
+      it "matches [] with []" do
+        eval(<<~RUBY).should == true
+          case []
+            in []
+              true
+          end
+        RUBY
+      end
+
+      it "matches anything with *" do
+        eval(<<~RUBY).should == true
+          case [0, 1]
+            in *;
+              true
+          end
+        RUBY
+      end
+    end
+
+    describe "Hash pattern" do
+      it "supports form Constant(id: pat, id: pat, ...)" do
+        eval(<<~RUBY).should == true
+          case {a: 0, b: 1}
+            in Hash(a: 0, b: 1)
+              true
+          end
+        RUBY
+      end
+
+      it "supports form Constant[id: pat, id: pat, ...]" do
+        eval(<<~RUBY).should == true
+          case {a: 0, b: 1}
+            in Hash[a: 0, b: 1]
+              true
+          end
+        RUBY
+      end
+
+      it "supports form {id: pat, id: pat, ...}" do
+        eval(<<~RUBY).should == true
+          case {a: 0, b: 1}
+            in {a: 0, b: 1}
+              true
+          end
+        RUBY
+      end
+
+      it "supports form id: pat, id: pat, ..." do
+        eval(<<~RUBY).should == true
+          case {a: 0, b: 1}
+            in a: 0, b: 1
+              true
+          end
+        RUBY
+
+        eval(<<~RUBY).should == [0, 1]
+          case {a: 0, b: 1}
+            in a: a, b: b
+              [a, b]
+          end
+        RUBY
+
+        eval(<<~RUBY).should == { b: 1, c: 2 }
+          case {a: 0, b: 1, c: 2}
+            in a: 0, **rest
+              rest
+          end
+        RUBY
+      end
+
+      it "supports a: which means a: a" do
+        eval(<<~RUBY).should == [0, 1]
+          case {a: 0, b: 1}
+            in Hash(a:, b:)
+              [a, b]
+          end
+        RUBY
+
+        a = b = nil
+        eval(<<~RUBY).should == [0, 1]
+          case {a: 0, b: 1}
+            in Hash[a:, b:]
+              [a, b]
+          end
+        RUBY
+
+        a = b = nil
+        eval(<<~RUBY).should == [0, 1]
+          case {a: 0, b: 1}
+            in {a:, b:}
+              [a, b]
+          end
+        RUBY
+
+        a = nil
+        eval(<<~RUBY).should == [0, {b: 1, c: 2}]
+          case {a: 0, b: 1, c: 2}
+            in {a:, **rest}
+              [a, rest]
+          end
+        RUBY
+
+        a = b = nil
+        eval(<<~RUBY).should == [0, 1]
+          case {a: 0, b: 1}
+            in a:, b:
+              [a, b]
+          end
+        RUBY
+      end
+
+      it "can mix key (a:) and key-value (a: b) declarations" do
+        eval(<<~RUBY).should == [0, 1]
+          case {a: 0, b: 1}
+            in Hash(a:, b: x)
+              [a, x]
+          end
+        RUBY
+      end
+
+      it "supports 'string': key literal" do
+        eval(<<~RUBY).should == true
+          case {a: 0}
+            in {"a": 0}
+              true
+          end
+        RUBY
+      end
+
+      it "does not support non-symbol keys" do
+        -> {
+          eval <<~RUBY
+            case {a: 1}
+              in {"a" => 1}
+            end
+          RUBY
+        }.should raise_error(SyntaxError, /unexpected/)
+      end
+
+      it "does not support string interpolation in keys" do
+        x = "a"
+
+        -> {
+          eval <<~'RUBY'
+            case {a: 1}
+              in {"#{x}": 1}
+            end
+          RUBY
+        }.should raise_error(SyntaxError, /symbol literal with interpolation is not allowed/)
+      end
+
+      it "raise SyntaxError when keys duplicate in pattern" do
+        -> {
+          eval <<~RUBY
+            case {a: 1}
+              in {a: 1, b: 2, a: 3}
+            end
+          RUBY
+        }.should raise_error(SyntaxError, /duplicated key name/)
+      end
+
+      it "matches an object with #deconstruct_keys method which returns a Hash with equal keys and each value in Hash matches value in pattern" do
+        obj = Object.new
+        def obj.deconstruct_keys(*); {a: 1} end
+
+        eval(<<~RUBY).should == true
+          case obj
+            in {a: 1}
+              true
+          end
+        RUBY
+      end
+
+      it "does not match object if Constant === object returns false" do
+        eval(<<~RUBY).should == false
+          case {a: 1}
+            in String[a: 1]
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "does not match object without #deconstruct_keys method" do
+        obj = Object.new
+
+        eval(<<~RUBY).should == false
+          case obj
+            in Object[a: 1]
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "does not match object if #deconstruct_keys method does not return Hash" do
+        obj = Object.new
+        def obj.deconstruct_keys(*); "" end
+
+        -> {
+          eval <<~RUBY
+            case obj
+              in Object[a: 1]
+            end
+          RUBY
+        }.should raise_error(TypeError, /deconstruct_keys must return Hash/)
+      end
+
+      it "does not match object if #deconstruct_keys method returns Hash with non-symbol keys" do
+        obj = Object.new
+        def obj.deconstruct_keys(*); {"a" => 1} end
+
+        eval(<<~RUBY).should == false
+          case obj
+            in Object[a: 1]
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "does not match object if elements of Hash returned by #deconstruct_keys method does not match values in pattern" do
+        obj = Object.new
+        def obj.deconstruct_keys(*); {a: 1} end
+
+        eval(<<~RUBY).should == false
+          case obj
+            in Object[a: 2]
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "passes keys specified in pattern as arguments to #deconstruct_keys method" do
+        obj = Object.new
+
+        def obj.deconstruct_keys(*args)
+          ScratchPad << args
+          {a: 1, b: 2, c: 3}
+        end
+
+        eval <<~RUBY
+          case obj
+            in Object[a: 1, b: 2, c: 3]
+          end
+        RUBY
+
+        ScratchPad.recorded.should == [[[:a, :b, :c]]]
+      end
+
+      it "passes keys specified in pattern to #deconstruct_keys method if pattern contains double splat operator **" do
+        obj = Object.new
+
+        def obj.deconstruct_keys(*args)
+          ScratchPad << args
+          {a: 1, b: 2, c: 3}
+        end
+
+        eval <<~RUBY
+          case obj
+            in Object[a: 1, b: 2, **]
+          end
+        RUBY
+
+        ScratchPad.recorded.should == [[[:a, :b]]]
+      end
+
+      it "passes nil to #deconstruct_keys method if pattern contains double splat operator **rest" do
+        obj = Object.new
+
+        def obj.deconstruct_keys(*args)
+          ScratchPad << args
+          {a: 1, b: 2}
+        end
+
+        eval <<~RUBY
+          case obj
+            in Object[a: 1, **rest]
+          end
+        RUBY
+
+        ScratchPad.recorded.should == [[nil]]
+      end
+
+      it "binds variables" do
+        eval(<<~RUBY).should == [0, 1, 2]
+          case {a: 0, b: 1, c: 2}
+            in {a: x, b: y, c: z}
+              [x, y, z]
+          end
+        RUBY
+      end
+
+      it "binds variable even if pattern matches only partially" do
+        x = nil
+
+        eval(<<~RUBY).should == 0
+          case {a: 0, b: 1}
+            in {a: x, b: 2}
+          else
+          end
+
+          x
+        RUBY
+      end
+
+      it "supports double splat operator **rest" do
+        eval(<<~RUBY).should == {b: 1, c: 2}
+          case {a: 0, b: 1, c: 2}
+            in {a: 0, **rest}
+              rest
+          end
+        RUBY
+      end
+
+      it "treats **nil like there should not be any other keys in a matched Hash" do
+        eval(<<~RUBY).should == true
+          case {a: 1, b: 2}
+            in {a: 1, b: 2, **nil}
+              true
+          end
+        RUBY
+
+        eval(<<~RUBY).should == false
+          case {a: 1, b: 2}
+            in {a: 1, **nil}
+              true
+          else
+            false
+          end
+        RUBY
+      end
+
+      it "can match partially" do
+        eval(<<~RUBY).should == true
+          case {a: 1, b: 2}
+            in {a: 1}
+              true
+          end
+        RUBY
+      end
+
+      it "matches {} with {}" do
+        eval(<<~RUBY).should == true
+          case {}
+            in {}
+              true
+          end
+        RUBY
+      end
+
+      it "matches anything with **" do
+        eval(<<~RUBY).should == true
+          case {a: 1}
+            in **;
+              true
+          end
+        RUBY
+      end
+    end
+  end
+end