1 files changed, 742 insertions, 0 deletions

diff --git a/spec/outputs/test/switch_spec.lua b/spec/outputs/test/switch_spec.lua
new file mode 100644
index 0000000..59ffca5
--- /dev/null
+++ b/spec/outputs/test/switch_spec.lua
@@ -0,0 +1,742 @@
+return describe("switch", function()
+        it("should match single value", function()
+                local value = "cool"
+                local result
+                if "cool" == value then
+                        result = "matched"
+                else
+                        result = "not matched"
+                end
+                return assert.same(result, "matched")
+        end)
+        it("should match multiple values with or", function()
+                local hi = "world"
+                local matched = false
+                if "one" == hi or "two" == hi then
+                        matched = true
+                end
+                assert.is_false(matched)
+                hi = "one"
+                if "one" == hi or "two" == hi then
+                        matched = true
+                end
+                return assert.is_true(matched)
+        end)
+        it("should execute else branch when no match", function()
+                local value = "other"
+                local result
+                if "cool" == value then
+                        result = "matched cool"
+                elseif "yeah" == value then
+                        result = "matched yeah"
+                else
+                        result = "else branch"
+                end
+                return assert.same(result, "else branch")
+        end)
+        it("should destructure table with single key", function()
+                local tb = {
+                        x = 100
+                }
+                local result
+                do
+                        local _type_0 = type(tb)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                local x = tb.x
+                                if x ~= nil then
+                                        _match_0 = true
+                                        result = x
+                                end
+                        end
+                        if not _match_0 then
+                                result = "no match"
+                        end
+                end
+                return assert.same(result, 100)
+        end)
+        it("should destructure table with multiple keys", function()
+                local tb = {
+                        x = 100,
+                        y = 200
+                }
+                local result
+                do
+                        local _type_0 = type(tb)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                local x = tb.x
+                                local y = tb.y
+                                if x ~= nil and y ~= nil then
+                                        _match_0 = true
+                                        result = x + y
+                                end
+                        end
+                        if not _match_0 then
+                                result = "no match"
+                        end
+                end
+                return assert.same(result, 300)
+        end)
+        it("should destructure table with default values", function()
+                local tb = {
+                        a = 1
+                }
+                local _type_0 = type(tb)
+                local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                if _tab_0 then
+                        local a = tb.a
+                        local b = tb.b
+                        if a == nil then
+                                a = 1
+                        end
+                        if b == nil then
+                                b = 2
+                        end
+                        assert.same(a, 1)
+                        return assert.same(b, 2)
+                end
+        end)
+        it("should destructure nested tables", function()
+                local dict = {
+                        { },
+                        {
+                                1,
+                                2,
+                                3
+                        },
+                        a = {
+                                b = {
+                                        c = 1
+                                }
+                        },
+                        x = {
+                                y = {
+                                        z = 1
+                                }
+                        }
+                }
+                local matched = false
+                do
+                        local _type_0 = type(dict)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        if _tab_0 then
+                                local first = dict[1]
+                                local one
+                                do
+                                        local _obj_0 = dict[2]
+                                        local _type_1 = type(_obj_0)
+                                        if "table" == _type_1 or "userdata" == _type_1 then
+                                                one = _obj_0[1]
+                                        end
+                                end
+                                local two
+                                do
+                                        local _obj_0 = dict[2]
+                                        local _type_1 = type(_obj_0)
+                                        if "table" == _type_1 or "userdata" == _type_1 then
+                                                two = _obj_0[2]
+                                        end
+                                end
+                                local three
+                                do
+                                        local _obj_0 = dict[2]
+                                        local _type_1 = type(_obj_0)
+                                        if "table" == _type_1 or "userdata" == _type_1 then
+                                                three = _obj_0[3]
+                                        end
+                                end
+                                local c
+                                do
+                                        local _obj_0 = dict.a
+                                        local _type_1 = type(_obj_0)
+                                        if "table" == _type_1 or "userdata" == _type_1 then
+                                                do
+                                                        local _obj_1 = _obj_0.b
+                                                        local _type_2 = type(_obj_1)
+                                                        if "table" == _type_2 or "userdata" == _type_2 then
+                                                                c = _obj_1.c
+                                                        end
+                                                end
+                                        end
+                                end
+                                local z
+                                do
+                                        local _obj_0 = dict.x
+                                        local _type_1 = type(_obj_0)
+                                        if "table" == _type_1 or "userdata" == _type_1 then
+                                                do
+                                                        local _obj_1 = _obj_0.y
+                                                        local _type_2 = type(_obj_1)
+                                                        if "table" == _type_2 or "userdata" == _type_2 then
+                                                                z = _obj_1.z
+                                                        end
+                                                end
+                                        end
+                                end
+                                if first ~= nil and one ~= nil and two ~= nil and three ~= nil and c ~= nil and z ~= nil then
+                                        matched = type(first) == 'table' and one == 1 and two == 2 and three == 3 and c == 1 and z == 1
+                                end
+                        end
+                end
+                return assert.is_true(matched)
+        end)
+        it("should destructure arrays with exact match", function()
+                local tb = {
+                        1,
+                        2,
+                        3
+                }
+                local result
+                do
+                        local _type_0 = type(tb)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                if 1 == tb[1] and 2 == tb[2] and 3 == tb[3] then
+                                        _match_0 = true
+                                        result = "exact match"
+                                end
+                        end
+                        if not _match_0 then
+                                result = "no match"
+                        end
+                end
+                return assert.same(result, "exact match")
+        end)
+        it("should destructure arrays with variables", function()
+                local tb = {
+                        1,
+                        "b",
+                        3
+                }
+                local result
+                do
+                        local _type_0 = type(tb)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                local b = tb[2]
+                                if 1 == tb[1] and b ~= nil and 3 == tb[3] then
+                                        _match_0 = true
+                                        result = b
+                                end
+                        end
+                        if not _match_0 then
+                                result = "no match"
+                        end
+                end
+                return assert.same(result, "b")
+        end)
+        it("should destructure arrays with defaults", function()
+                local tb = {
+                        1,
+                        2
+                }
+                local result
+                do
+                        local _type_0 = type(tb)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                local b = tb[3]
+                                if b == nil then
+                                        b = 3
+                                end
+                                if 1 == tb[1] and 2 == tb[2] then
+                                        _match_0 = true
+                                        result = b
+                                end
+                        end
+                        if not _match_0 then
+                                result = "no match"
+                        end
+                end
+                return assert.same(result, 3)
+        end)
+        it("should match pattern with __class", function()
+                local ClassA
+                do
+                        local _class_0
+                        local _base_0 = { }
+                        if _base_0.__index == nil then
+                                _base_0.__index = _base_0
+                        end
+                        _class_0 = setmetatable({
+                                __init = function() end,
+                                __base = _base_0,
+                                __name = "ClassA"
+                        }, {
+                                __index = _base_0,
+                                __call = function(cls, ...)
+                                        local _self_0 = setmetatable({ }, _base_0)
+                                        cls.__init(_self_0, ...)
+                                        return _self_0
+                                end
+                        })
+                        _base_0.__class = _class_0
+                        ClassA = _class_0
+                end
+                local ClassB
+                do
+                        local _class_0
+                        local _base_0 = { }
+                        if _base_0.__index == nil then
+                                _base_0.__index = _base_0
+                        end
+                        _class_0 = setmetatable({
+                                __init = function() end,
+                                __base = _base_0,
+                                __name = "ClassB"
+                        }, {
+                                __index = _base_0,
+                                __call = function(cls, ...)
+                                        local _self_0 = setmetatable({ }, _base_0)
+                                        cls.__init(_self_0, ...)
+                                        return _self_0
+                                end
+                        })
+                        _base_0.__class = _class_0
+                        ClassB = _class_0
+                end
+                local item = ClassA()
+                local result
+                do
+                        local _type_0 = type(item)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                ClassA = item.__class
+                                if ClassA ~= nil then
+                                        _match_0 = true
+                                        result = "Object A"
+                                end
+                        end
+                        if not _match_0 then
+                                local _match_1 = false
+                                if _tab_0 then
+                                        ClassB = item.__class
+                                        if ClassB ~= nil then
+                                                _match_1 = true
+                                                result = "Object B"
+                                        end
+                                end
+                                if not _match_1 then
+                                        result = "unknown"
+                                end
+                        end
+                end
+                return assert.same(result, "Object A")
+        end)
+        it("should match pattern with metatable", function()
+                local tb = setmetatable({ }, {
+                        __mode = "v"
+                })
+                local metatable_matched = false
+                do
+                        local _type_0 = type(tb)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        if _tab_0 then
+                                local mt = getmetatable(tb)
+                                if mt ~= nil then
+                                        metatable_matched = mt ~= nil
+                                end
+                        end
+                end
+                return assert.is_true(metatable_matched)
+        end)
+        it("should use switch as expression in assignment", function()
+                local tb = {
+                        x = "abc"
+                }
+                local matched
+                if 1 == tb then
+                        matched = "1"
+                else
+                        do
+                                local _type_0 = type(tb)
+                                local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                                local _match_0 = false
+                                if _tab_0 then
+                                        local x = tb.x
+                                        if x ~= nil then
+                                                _match_0 = true
+                                                matched = x
+                                        end
+                                end
+                                if not _match_0 then
+                                        if false == tb then
+                                                matched = "false"
+                                        else
+                                                matched = nil
+                                        end
+                                end
+                        end
+                end
+                return assert.same(matched, "abc")
+        end)
+        it("should use switch in return statement", function()
+                local fn
+                fn = function(tb)
+                        if nil == tb then
+                                return "invalid"
+                        else
+                                local _type_0 = type(tb)
+                                local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                                local _match_0 = false
+                                if _tab_0 then
+                                        local a = tb.a
+                                        local b = tb.b
+                                        if a ~= nil and b ~= nil then
+                                                _match_0 = true
+                                                return tostring(a + b)
+                                        end
+                                end
+                                if not _match_0 then
+                                        if 1 == tb or 2 == tb or 3 == tb or 4 == tb or 5 == tb then
+                                                return "number 1 - 5"
+                                        else
+                                                return "should not reach here"
+                                        end
+                                end
+                        end
+                end
+                assert.same(fn({
+                        a = 1,
+                        b = 2
+                }), "3")
+                assert.same(fn(3), "number 1 - 5")
+                return assert.same(fn(nil), "invalid")
+        end)
+        it("should support pattern matching assignment with :=", function()
+                local v = "hello"
+                local matched = false
+                do
+                        v = "hello"
+                        if "hello" == v then
+                                matched = true
+                        else
+                                matched = false
+                        end
+                end
+                assert.is_true(matched)
+                return assert.same(v, "hello")
+        end)
+        it("should match with computed expressions", function()
+                local hi = 4
+                local matched = false
+                if (3 + 1) == hi or (function()
+                        return 4
+                end)() == hi or (5 - 1) == hi then
+                        matched = true
+                end
+                return assert.is_true(matched)
+        end)
+        it("should handle nested array destructuring", function()
+                local tb = {
+                        {
+                                a = 1,
+                                b = 2
+                        },
+                        {
+                                a = 3,
+                                b = 4
+                        },
+                        {
+                                a = 5,
+                                b = 6
+                        },
+                        "fourth"
+                }
+                local result
+                do
+                        local _type_0 = type(tb)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                local fourth = tb[4]
+                                local _val_0
+                                do
+                                        local _obj_0 = tb[1]
+                                        if _obj_0 ~= nil then
+                                                _val_0 = _obj_0.a
+                                        end
+                                end
+                                local _val_1
+                                do
+                                        local _obj_0 = tb[1]
+                                        if _obj_0 ~= nil then
+                                                _val_1 = _obj_0.b
+                                        end
+                                end
+                                local _val_2
+                                do
+                                        local _obj_0 = tb[2]
+                                        if _obj_0 ~= nil then
+                                                _val_2 = _obj_0.a
+                                        end
+                                end
+                                local _val_3
+                                do
+                                        local _obj_0 = tb[2]
+                                        if _obj_0 ~= nil then
+                                                _val_3 = _obj_0.b
+                                        end
+                                end
+                                local _val_4
+                                do
+                                        local _obj_0 = tb[3]
+                                        if _obj_0 ~= nil then
+                                                _val_4 = _obj_0.a
+                                        end
+                                end
+                                local _val_5
+                                do
+                                        local _obj_0 = tb[3]
+                                        if _obj_0 ~= nil then
+                                                _val_5 = _obj_0.b
+                                        end
+                                end
+                                if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 and fourth ~= nil then
+                                        _match_0 = true
+                                        result = fourth
+                                end
+                        end
+                        if not _match_0 then
+                                result = "no match"
+                        end
+                end
+                return assert.same(result, "fourth")
+        end)
+        it("should match combined patterns", function()
+                local tb = {
+                        success = true,
+                        result = "data"
+                }
+                local result
+                do
+                        local _type_0 = type(tb)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                result = tb.result
+                                if true == tb.success and result ~= nil then
+                                        _match_0 = true
+                                        result = {
+                                                "success",
+                                                result
+                                        }
+                                end
+                        end
+                        if not _match_0 then
+                                local _match_1 = false
+                                if _tab_0 then
+                                        if false == tb.success then
+                                                _match_1 = true
+                                                result = {
+                                                        "failed",
+                                                        result
+                                                }
+                                        end
+                                end
+                                if not _match_1 then
+                                        result = {
+                                                "invalid"
+                                        }
+                                end
+                        end
+                end
+                return assert.same(result, {
+                        "success",
+                        "data"
+                })
+        end)
+        it("should match type discriminated patterns", function()
+                local tb = {
+                        type = "success",
+                        content = "data"
+                }
+                local result
+                do
+                        local _type_0 = type(tb)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                local content = tb.content
+                                if "success" == tb.type and content ~= nil then
+                                        _match_0 = true
+                                        result = {
+                                                "success",
+                                                content
+                                        }
+                                end
+                        end
+                        if not _match_0 then
+                                local _match_1 = false
+                                if _tab_0 then
+                                        local content = tb.content
+                                        if "error" == tb.type and content ~= nil then
+                                                _match_1 = true
+                                                result = {
+                                                        "error",
+                                                        content
+                                                }
+                                        end
+                                end
+                                if not _match_1 then
+                                        result = {
+                                                "invalid"
+                                        }
+                                end
+                        end
+                end
+                return assert.same(result, {
+                        "success",
+                        "data"
+                })
+        end)
+        it("should match with wildcard array capture", function()
+                local clientData = {
+                        "Meta",
+                        "CUST_1001",
+                        "CHK123"
+                }
+                local metadata = nil
+                local customerId = nil
+                local checksum = nil
+                do
+                        local _type_0 = type(clientData)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        if _tab_0 then
+                                local capturedMetadata
+                                do
+                                        local _accum_0 = { }
+                                        local _len_0 = 1
+                                        local _max_0 = #clientData + -3 + 1
+                                        for _index_0 = 1, _max_0 do
+                                                local _item_0 = clientData[_index_0]
+                                                _accum_0[_len_0] = _item_0
+                                                _len_0 = _len_0 + 1
+                                        end
+                                        capturedMetadata = _accum_0
+                                end
+                                customerId = clientData[#clientData - 1]
+                                checksum = clientData[#clientData]
+                                if customerId ~= nil and checksum ~= nil then
+                                        metadata = capturedMetadata
+                                end
+                        end
+                end
+                assert.same(metadata, {
+                        "Meta"
+                })
+                assert.same(customerId, "CUST_1001")
+                return assert.same(checksum, "CHK123")
+        end)
+        it("should work with complex tuple patterns", function()
+                local handlePath
+                handlePath = function(segments)
+                        local _type_0 = type(segments)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                local resource = segments[#segments - 1]
+                                local action = segments[#segments]
+                                if resource ~= nil and action ~= nil then
+                                        _match_0 = true
+                                        return {
+                                                "Resource: " .. tostring(resource),
+                                                "Action: " .. tostring(action)
+                                        }
+                                end
+                        end
+                        if not _match_0 then
+                                return {
+                                        "no match"
+                                }
+                        end
+                end
+                local result = handlePath({
+                        "admin",
+                        "logs",
+                        "view"
+                })
+                return assert.same(result, {
+                        "Resource: logs",
+                        "Action: view"
+                })
+        end)
+        it("should match boolean false correctly", function()
+                local items = {
+                        {
+                                x = 100,
+                                y = 200
+                        },
+                        {
+                                width = 300,
+                                height = 400
+                        },
+                        false
+                }
+                local results = { }
+                for _index_0 = 1, #items do
+                        local item = items[_index_0]
+                        local _type_0 = type(item)
+                        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                        local _match_0 = false
+                        if _tab_0 then
+                                local x = item.x
+                                local y = item.y
+                                if x ~= nil and y ~= nil then
+                                        _match_0 = true
+                                        table.insert(results, "Vec2")
+                                end
+                        end
+                        if not _match_0 then
+                                local _match_1 = false
+                                if _tab_0 then
+                                        local width = item.width
+                                        local height = item.height
+                                        if width ~= nil and height ~= nil then
+                                                _match_1 = true
+                                                table.insert(results, "Size")
+                                        end
+                                end
+                                if not _match_1 then
+                                        if false == item then
+                                                table.insert(results, "None")
+                                        end
+                                end
+                        end
+                end
+                return assert.same(results, {
+                        "Vec2",
+                        "Size",
+                        "None"
+                })
+        end)
+        it("should handle switch with then syntax", function()
+                local value = "cool"
+                local result
+                if "cool" == value then
+                        result = "matched cool"
+                else
+                        result = "else branch"
+                end
+                return assert.same(result, "matched cool")
+        end)
+        return it("should handle switch in function call", function()
+                local something = 1
+                local getValue
+                getValue = function()
+                        if 1 == something then
+                                return "yes"
+                        else
+                                return "no"
+                        end
+                end
+                return assert.same(getValue(), "yes")
+        end)
+end)