test: add test cases for empty table pattern matchingfeature/ast-node-end-position

- Test [] pattern matches tables with #x == 0
- Test {} pattern matches tables with next(x) == nil
- Test distinguishing between [] and {} patterns
- Test empty patterns with then syntax
- Test empty patterns with multiple when branches

Related to #249

2 files changed, 327 insertions, 1 deletions

diff --git a/spec/inputs/test/switch_spec.yue b/spec/inputs/test/switch_spec.yue
index 0865e5a..b7aca5b 100644
--- a/spec/inputs/test/switch_spec.yue
+++ b/spec/inputs/test/switch_spec.yue
@@ -265,3 +265,86 @@ describe "switch", ->
                                 when 1 then "yes"
                                 else "no"
                 assert.same getValue!, "yes"
+
+        it "should match empty list pattern with []", ->
+                -- [] uses #x == 0 check, matches tables with no array elements
+                emptyArray = {}
+                hashTable = {a: 1, b: 2}
+                arrayWithElements = {1, 2, 3}
+
+                result1 = switch emptyArray
+                        when [] then "empty list"
+                        else "not empty list"
+                assert.same result1, "empty list"
+
+                result2 = switch hashTable
+                        when [] then "empty list"
+                        else "not empty list"
+                assert.same result2, "empty list"
+
+                result3 = switch arrayWithElements
+                        when [] then "empty list"
+                        else "not empty list"
+                assert.same result3, "not empty list"
+
+        it "should match empty table pattern with {}", ->
+                -- {} uses next(x) == nil check, matches only truly empty tables
+                emptyTable = {}
+                hashTable = {a: 1}
+                arrayTable = {1}
+
+                result1 = switch emptyTable
+                        when {} then "empty table"
+                        else "not empty table"
+                assert.same result1, "empty table"
+
+                result2 = switch hashTable
+                        when {} then "empty table"
+                        else "not empty table"
+                assert.same result2, "not empty table"
+
+                result3 = switch arrayTable
+                        when {} then "empty table"
+                        else "not empty table"
+                assert.same result3, "not empty table"
+
+        it "should distinguish between [] and {} patterns", ->
+                -- [] matches tables with #x == 0 (no array part)
+                -- {} matches tables with next(x) == nil (completely empty)
+                classify = (x) ->
+                        switch x
+                                when {} then "truly empty"
+                                when [] then "no array elements"
+                                else "has elements"
+
+                assert.same classify({}), "truly empty"
+                assert.same classify({a: 1}), "no array elements"
+                assert.same classify({1, 2}), "has elements"
+
+        it "should handle empty list pattern with then syntax", ->
+                result = switch {}
+                        when [] then "matched"
+                        else "not matched"
+                assert.same result, "matched"
+
+        it "should handle empty table pattern with then syntax", ->
+                result = switch {}
+                        when {} then "matched"
+                        else "not matched"
+                assert.same result, "matched"
+
+        it "should match empty patterns with multiple when branches", ->
+                emptyArray = {}
+                emptyHash = {}
+
+                result1 = switch emptyArray
+                        when {1} then "has 1"
+                        when [] then "empty list"
+                        else "other"
+                assert.same result1, "empty list"
+
+                result2 = switch emptyHash
+                        when {a: 1} then "has a"
+                        when {} then "empty table"
+                        else "other"
+                assert.same result2, "empty table"
diff --git a/spec/outputs/test/switch_spec.lua b/spec/outputs/test/switch_spec.lua
index 59ffca5..1f436b8 100644
--- a/spec/outputs/test/switch_spec.lua
+++ b/spec/outputs/test/switch_spec.lua
@@ -727,7 +727,7 @@ return describe("switch", function()
                 end
                 return assert.same(result, "matched cool")
         end)
-        return it("should handle switch in function call", function()
+        it("should handle switch in function call", function()
                 local something = 1
                 local getValue
                 getValue = function()
@@ -739,4 +739,247 @@ return describe("switch", function()
                 end
                 return assert.same(getValue(), "yes")
         end)
+        it("should match empty list pattern with []", function()
+                local emptyArray = { }
+                local hashTable = {
+                        a = 1,
+                        b = 2
+                }
+                local arrayWithElements = {
+                        1,
+                        2,
+                        3
+                }
+                local result1
+                do
+                        local _type_0 = type(emptyArray)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if #emptyArray == 0 then
+                                        _match_0 = true
+                                        result1 = "empty list"
+                                end
+                        end
+                        if not _match_0 then
+                                result1 = "not empty list"
+                        end
+                end
+                assert.same(result1, "empty list")
+                local result2
+                do
+                        local _type_0 = type(hashTable)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if #hashTable == 0 then
+                                        _match_0 = true
+                                        result2 = "empty list"
+                                end
+                        end
+                        if not _match_0 then
+                                result2 = "not empty list"
+                        end
+                end
+                assert.same(result2, "empty list")
+                local result3
+                do
+                        local _type_0 = type(arrayWithElements)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if #arrayWithElements == 0 then
+                                        _match_0 = true
+                                        result3 = "empty list"
+                                end
+                        end
+                        if not _match_0 then
+                                result3 = "not empty list"
+                        end
+                end
+                return assert.same(result3, "not empty list")
+        end)
+        it("should match empty table pattern with {}", function()
+                local emptyTable = { }
+                local hashTable = {
+                        a = 1
+                }
+                local arrayTable = {
+                        1
+                }
+                local result1
+                do
+                        local _type_0 = type(emptyTable)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if next(emptyTable) == nil then
+                                        _match_0 = true
+                                        result1 = "empty table"
+                                end
+                        end
+                        if not _match_0 then
+                                result1 = "not empty table"
+                        end
+                end
+                assert.same(result1, "empty table")
+                local result2
+                do
+                        local _type_0 = type(hashTable)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if next(hashTable) == nil then
+                                        _match_0 = true
+                                        result2 = "empty table"
+                                end
+                        end
+                        if not _match_0 then
+                                result2 = "not empty table"
+                        end
+                end
+                assert.same(result2, "not empty table")
+                local result3
+                do
+                        local _type_0 = type(arrayTable)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if next(arrayTable) == nil then
+                                        _match_0 = true
+                                        result3 = "empty table"
+                                end
+                        end
+                        if not _match_0 then
+                                result3 = "not empty table"
+                        end
+                end
+                return assert.same(result3, "not empty table")
+        end)
+        it("should distinguish between [] and {} patterns", function()
+                local classify
+                classify = function(x)
+                        local _type_0 = type(x)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if next(x) == nil then
+                                        _match_0 = true
+                                        return "truly empty"
+                                end
+                        end
+                        if not _match_0 then
+                                local _match_1 = false
+                                if _tab_0 then
+                                        if #x == 0 then
+                                                _match_1 = true
+                                                return "no array elements"
+                                        end
+                                end
+                                if not _match_1 then
+                                        return "has elements"
+                                end
+                        end
+                end
+                assert.same(classify({ }), "truly empty")
+                assert.same(classify({
+                        a = 1
+                }), "no array elements")
+                return assert.same(classify({
+                        1,
+                        2
+                }), "has elements")
+        end)
+        it("should handle empty list pattern with then syntax", function()
+                local result
+                do
+                        local _exp_0 = { }
+                        local _type_0 = type(_exp_0)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if #_exp_0 == 0 then
+                                        _match_0 = true
+                                        result = "matched"
+                                end
+                        end
+                        if not _match_0 then
+                                result = "not matched"
+                        end
+                end
+                return assert.same(result, "matched")
+        end)
+        it("should handle empty table pattern with then syntax", function()
+                local result
+                do
+                        local _exp_0 = { }
+                        local _type_0 = type(_exp_0)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if next(_exp_0) == nil then
+                                        _match_0 = true
+                                        result = "matched"
+                                end
+                        end
+                        if not _match_0 then
+                                result = "not matched"
+                        end
+                end
+                return assert.same(result, "matched")
+        end)
+        return it("should match empty patterns with multiple when branches", function()
+                local emptyArray = { }
+                local emptyHash = { }
+                local result1
+                do
+                        local _type_0 = type(emptyArray)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if 1 == emptyArray[1] then
+                                        _match_0 = true
+                                        result1 = "has 1"
+                                end
+                        end
+                        if not _match_0 then
+                                local _match_1 = false
+                                if _tab_0 then
+                                        if #emptyArray == 0 then
+                                                _match_1 = true
+                                                result1 = "empty list"
+                                        end
+                                end
+                                if not _match_1 then
+                                        result1 = "other"
+                                end
+                        end
+                end
+                assert.same(result1, "empty list")
+                local result2
+                do
+                        local _type_0 = type(emptyHash)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if 1 == emptyHash.a then
+                                        _match_0 = true
+                                        result2 = "has a"
+                                end
+                        end
+                        if not _match_0 then
+                                local _match_1 = false
+                                if _tab_0 then
+                                        if next(emptyHash) == nil then
+                                                _match_1 = true
+                                                result2 = "empty table"
+                                        end
+                                end
+                                if not _match_1 then
+                                        result2 = "other"
+                                end
+                        end
+                end
+                return assert.same(result2, "empty table")
+        end)
 end)