Merge pull request #653 from igrvlhlb/typealias-type

Add the `types.T.Alias` type

Author: igrvlhlb

spec/typechecker_spec.lua

@@ -92,27 +92,27 @@ describe("Module", function()
         assert_error([[
             function m.f() end
             function m.f() end
-        ]], "multiple definitions for module field 'f'")
+        ]], "the module field 'f' is being shadowed")
     end)
 
     it("forbids repeated exported names (function / variable)", function()
         assert_error([[
             function m.f() end
             m.f = 1
-        ]], "multiple definitions for module field 'f'")
+        ]], "the module field 'f' is being shadowed")
     end)
 
     it("forbids repeated exported names (variable / variable)", function()
         assert_error([[
             m.x = 10
             m.x = 20
-        ]], "multiple definitions for module field 'x'")
+        ]], "the module field 'x' is being shadowed")
     end)
 
     it("forbids repeated exported names (in multiple assignment)", function()
         assert_error([[
             m.x, m.x = 10, 20
-        ]], "multiple definitions for module field 'x'")
+        ]], "the module field 'x' is being shadowed")
     end)
 
     it("ensures that exported variables are not in scope in their initializers", function()
@@ -142,6 +142,37 @@ describe("Typealias", function()
         ]], "'t' is not a type")
     end)
 
+    it("must not be shadowed by other typealias names", function()
+        assert_error([[
+            typealias point = {x: integer, y: integer}
+            typealias point = {x: float, y: float}
+        ]], "the type 'point' is being shadowed")
+    end)
+
+    it("must not be shadowed by record names", function()
+        assert_error([[
+            typealias point = {x: float, y: float}
+            record point
+                x: integer
+                y: integer
+            end
+        ]], "the type 'point' is being shadowed")
+    end)
+
+    it("must not be shadowed by module field names", function()
+        assert_error([[
+            typealias x = integer
+            m.x = 10
+        ]], "the type 'x' is being shadowed")
+    end)
+
+    it("must not be shadowed by function names", function()
+        assert_error([[
+            typealias f = integer
+            function m.f() end
+        ]], "the type 'f' is being shadowed")
+    end)
+
 end)
 
 describe("Record declaration", function()
@@ -155,6 +186,49 @@ describe("Record declaration", function()
         ]], "duplicate field name 'x' in record type")
     end)
 
+    it("must not be shadowed by other record names", function()
+        assert_error([[
+            record Point
+                x: integer
+                y: integer
+            end
+            record Point
+                x: float
+                y: float
+            end
+        ]], "the type 'Point' is being shadowed")
+    end)
+
+    it("must not be shadowed by typealias names", function()
+        assert_error([[
+            record Point
+                x: integer
+                y: integer
+            end
+            typealias Point = {x: float, y: float}
+        ]], "the type 'Point' is being shadowed")
+    end)
+
+    it("must not be shadowed by module field names", function()
+        assert_error([[
+            record P
+                x: integer
+                y: integer
+            end
+            m.P = 10
+        ]], "the type 'P' is being shadowed")
+    end)
+
+    it("must not be shadowed by function names", function()
+        assert_error([[
+            record P
+                x: integer
+                y: integer
+            end
+            function m.P() end
+        ]], "the type 'P' is being shadowed")
+    end)
+
 end)
 
 describe("Function declaration", function()
@@ -195,6 +269,71 @@ describe("Function declaration", function()
         ]], "function 'f' was not forward declared")
     end)
 
+    it("must not be shadowed by typealias names", function()
+        assert_error([[
+            function m.f() end
+            typealias f = integer
+        ]], "the module field 'f' is being shadowed")
+    end)
+
+    it("must not be shadowed by record names", function()
+        assert_error([[
+            function m.f() end
+            record f
+                x: integer
+                y: integer
+            end
+        ]], "the module field 'f' is being shadowed")
+    end)
+
+    it("must not be shadowed by module field names", function()
+        assert_error([[
+            function m.f() end
+            m.f = 10
+        ]], "the module field 'f' is being shadowed")
+    end)
+
+    it("must not be shadowed by function names", function()
+        assert_error([[
+            function m.f() end
+            function m.f() end
+        ]], "the module field 'f' is being shadowed")
+    end)
+
+end)
+
+describe("Module fields", function()
+
+    it("must not be shadowed by typealias names", function()
+        assert_error([[
+            m.x = 10
+            typealias x = integer
+        ]], "the module field 'x' is being shadowed")
+    end)
+
+    it("must not be shadowed by record names", function()
+        assert_error([[
+            m.x = 10
+            record x
+                y: integer
+            end
+        ]], "the module field 'x' is being shadowed")
+    end)
+
+    it("must not be shadowed by function names", function()
+        assert_error([[
+            m.f = 10
+            function m.f() end
+        ]], "the module field 'f' is being shadowed")
+    end)
+
+    it("must not be shadowed by module field names", function()
+        assert_error([[
+            m.x = 10
+            m.x = 20
+        ]], "the module field 'x' is being shadowed")
+    end)
+
 end)
 
 --

spec/types_spec.lua

@@ -119,6 +119,21 @@ describe("Pallene types", function()
             local t2 = types.T.Record("P", {}, {}, false)
             assert.falsy(types.equals(t1, t2))
         end)
+
+        it("is true for similar type aliases", function()
+            local ta1 = types.T.Alias("A", types.T.Integer)
+            local ta2 = types.T.Alias("B", types.T.Integer)
+            assert.truthy(types.equals(ta1, ta2))
+        end)
+
+        it("should expand type aliases", function()
+            local ta = types.T.Alias("A", types.T.Integer)
+
+            assert.truthy(types.equals(
+                ta,
+                types.T.Integer
+            ))
+        end)
     end)
 
     describe("consistency", function()
@@ -161,5 +176,50 @@ describe("Pallene types", function()
                 types.T.Function({types.T.Integer},{types.T.Integer})
             ))
         end)
+
+        it("should be true for type aliases whose types are consistent", function()
+            local ta1 = types.T.Alias("A", types.T.Any)
+            local ta2 = types.T.Alias("B", types.T.Integer)
+            local ta3 = types.T.Alias("C", types.T.String)
+
+            assert.truthy(types.consistent(ta1, ta2))
+            assert.truthy(types.consistent(ta1, ta3))
+            assert.falsy(types.consistent(ta2, ta3))
+        end)
+
+        it("should expand type aliases", function()
+            local ta = types.T.Alias("A", types.T.Integer)
+
+            assert.truthy(types.consistent(
+                ta,
+                types.T.Integer
+            ))
+
+            assert.falsy(types.consistent(
+                ta,
+                types.T.String
+            ))
+        end)
     end)
+
+    describe("type aliases", function()
+
+        it("should recursively expand type aliases", function()
+            local ta1 = types.T.Alias("A", types.T.Integer)
+            local ta2 = types.T.Alias("B", ta1)
+            local ta3 = types.T.Alias("C", ta2)
+
+            assert.truthy(types.expand_typealias(ta3) == types.T.Integer)
+        end)
+
+        it("should be considered equal to the expanded type", function()
+            local ta1 = types.T.Alias("A", types.T.Integer)
+
+            assert.truthy(types.equals(
+                ta1,
+                types.T.Integer
+            ))
+        end)
+    end)
+
 end)

src/pallene/to_ir.lua

@@ -47,8 +47,9 @@ end
 
 function to_ir.convert(prog_ast)
     assert(prog_ast._tag == "ast.Program.Program")
+    local alias_free_prog_ast = util.expand_type_aliases(prog_ast)
     local ok, ret = trycatch.pcall(function()
-        return ToIR.new():convert_toplevel(prog_ast.tls)
+        return ToIR.new():convert_toplevel(alias_free_prog_ast.tls)
     end)
 
     if not ok then