Classes update (#383)

tomblind · web-flow · commit 03beabbe8ad5 · 2019-02-11T05:25:21.000-07:00
* update to class transpilation
- classes separated into static and instance tables
- fixed issues with super calls
- renamed new and constructor to avoid name collisions
- added errors for extensions being used in inappropriate ways

* added cloneIdentifier
...and using it to prevent the same nodes being referenced from different places in the lua ast

* reverted ____new back to new and added new and self to banned identifier list

* spacing sanity

* fixed bug introduced in merge
diff --git a/src/LuaAST.ts b/src/LuaAST.ts
@@ -813,6 +813,10 @@ export function createIdentifier(
     return expression;
 }
 
+export function cloneIdentifier(identifier: Identifier): Identifier {
+    return createIdentifier(identifier.text, undefined, identifier.symbolId);
+}
+
 export function createAnnonymousIdentifier(tsOriginal?: ts.Node, parent?: Node): Identifier {
     const expression = createNode(SyntaxKind.Identifier, tsOriginal, parent) as Identifier;
     expression.text = "____";
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
diff --git a/src/TSTLErrors.ts b/src/TSTLErrors.ts
@@ -25,10 +25,19 @@ export class TSTLErrors {
         new TranspileError(`${name} expects ${expected} argument(s) but got ${got}.`, node);
 
     public static InvalidExtensionMetaExtension = (node: ts.Node) =>
-        new TranspileError(`Cannot use both '!Extension' and '!MetaExtension' decorators on the same class.`, node);
+        new TranspileError(`Cannot use both '@extension' and '@metaExtension' decorators on the same class.`, node);
 
     public static InvalidNewExpressionOnExtension = (node: ts.Node) =>
-        new TranspileError(`Cannot construct classes with decorator '!Extension' or '!MetaExtension'.`, node);
+        new TranspileError(`Cannot construct classes with decorator '@extension' or '@metaExtension'.`, node);
+
+    public static InvalidExtendsExtension = (node: ts.Node) =>
+        new TranspileError(`Cannot extend classes with decorator '@extension' or '@metaExtension'.`, node);
+
+    public static InvalidExportsExtension = (node: ts.Node) =>
+        new TranspileError(`Cannot export classes with decorator '@extension' or '@metaExtension'.`, node);
+
+    public static InvalidInstanceOfExtension = (node: ts.Node) =>
+        new TranspileError(`Cannot use instanceof on classes with decorator '@extension' or '@metaExtension'.`, node);
 
     public static InvalidPropertyCall = (node: ts.Node) =>
         new TranspileError(`Tried to transpile a non-property call as property call.`, node);
diff --git a/src/lualib/InstanceOf.ts b/src/lualib/InstanceOf.ts
@@ -1,14 +1,20 @@
 interface LuaClass {
-    __index: LuaClass;
-    __base: LuaClass;
+    ____super?: LuaClass;
 }
 
-function __TS__InstanceOf(obj: LuaClass, classTbl: LuaClass): boolean {
-    while (obj !== undefined) {
-        if (obj.__index === classTbl) {
-            return true;
+interface LuaObject {
+    constructor: LuaClass;
+}
+
+function __TS__InstanceOf(obj: LuaObject, classTbl: LuaClass): boolean {
+    if (obj !== undefined) {
+        let luaClass = obj.constructor;
+        while (luaClass !== undefined) {
+            if (luaClass === classTbl) {
+                return true;
+            }
+            luaClass = luaClass.____super;
         }
-        obj = obj.__base;
     }
     return false;
 }
diff --git a/test/translation/lua/classExtension1.lua b/test/translation/lua/classExtension1.lua
@@ -1,2 +1,2 @@
-MyClass.myFunction = function(self)
+MyClass.prototype.myFunction = function(self)
 end;
diff --git a/test/translation/lua/classExtension2.lua b/test/translation/lua/classExtension2.lua
@@ -1,2 +1,2 @@
-TestClass.myFunction = function(self)
+TestClass.prototype.myFunction = function(self)
 end;
diff --git a/test/translation/lua/classExtension3.lua b/test/translation/lua/classExtension3.lua
@@ -1,4 +1,4 @@
-RenamedTestClass.myFunction = function(self)
+RenamedTestClass.prototype.myFunction = function(self)
 end;
-RenamedMyClass.myFunction = function(self)
+RenamedMyClass.prototype.myFunction = function(self)
 end;
diff --git a/test/translation/lua/classExtension4.lua b/test/translation/lua/classExtension4.lua
@@ -1,4 +1,4 @@
 MyClass.test = "test";
 MyClass.testP = "testP";
-MyClass.myFunction = function(self)
+MyClass.prototype.myFunction = function(self)
 end;
diff --git a/test/translation/lua/classPureAbstract.lua b/test/translation/lua/classPureAbstract.lua
@@ -1,11 +1,12 @@
 ClassB = ClassB or {};
 ClassB.__index = ClassB;
-ClassB.new = function(construct, ...)
-    local self = setmetatable({}, ClassB);
-    if construct and ClassB.constructor then
-        ClassB.constructor(self, ...);
-    end
+ClassB.prototype = ClassB.prototype or {};
+ClassB.prototype.__index = ClassB.prototype;
+ClassB.prototype.constructor = ClassB;
+ClassB.new = function(...)
+    local self = setmetatable({}, ClassB.prototype);
+    self:____constructor(...);
     return self;
 end;
-ClassB.constructor = function(self)
+ClassB.prototype.____constructor = function(self)
 end;
diff --git a/test/translation/lua/getSetAccessors.lua b/test/translation/lua/getSetAccessors.lua
@@ -1,21 +1,22 @@
 MyClass = MyClass or {};
 MyClass.__index = MyClass;
-MyClass.new = function(construct, ...)
-    local self = setmetatable({}, MyClass);
-    if construct and MyClass.constructor then
-        MyClass.constructor(self, ...);
-    end
+MyClass.prototype = MyClass.prototype or {};
+MyClass.prototype.__index = MyClass.prototype;
+MyClass.prototype.constructor = MyClass;
+MyClass.new = function(...)
+    local self = setmetatable({}, MyClass.prototype);
+    self:____constructor(...);
     return self;
 end;
-MyClass.constructor = function(self)
+MyClass.prototype.____constructor = function(self)
 end;
-MyClass.get__field = function(self)
+MyClass.prototype.get__field = function(self)
     return self._field + 4;
 end;
-MyClass.set__field = function(self, v)
+MyClass.prototype.set__field = function(self, v)
     self._field = v * 2;
 end;
-local instance = MyClass.new(true);
+local instance = MyClass.new();
 instance:set__field(4);
 local b = instance:get__field();
 local c = (4 + instance:get__field()) * 3;
diff --git a/test/translation/lua/methodRestArguments.lua b/test/translation/lua/methodRestArguments.lua
@@ -1,14 +1,15 @@
 MyClass = MyClass or {};
 MyClass.__index = MyClass;
-MyClass.new = function(construct, ...)
-    local self = setmetatable({}, MyClass);
-    if construct and MyClass.constructor then
-        MyClass.constructor(self, ...);
-    end
+MyClass.prototype = MyClass.prototype or {};
+MyClass.prototype.__index = MyClass.prototype;
+MyClass.prototype.constructor = MyClass;
+MyClass.new = function(...)
+    local self = setmetatable({}, MyClass.prototype);
+    self:____constructor(...);
     return self;
 end;
-MyClass.constructor = function(self)
+MyClass.prototype.____constructor = function(self)
 end;
-MyClass.varargsFunction = function(self, a, ...)
+MyClass.prototype.varargsFunction = function(self, a, ...)
     local b = ({...});
 end;
diff --git a/test/translation/lua/modulesClassExport.lua b/test/translation/lua/modulesClassExport.lua
@@ -1,13 +1,14 @@
 local exports = exports or {};
 exports.TestClass = exports.TestClass or {};
 exports.TestClass.__index = exports.TestClass;
-exports.TestClass.new = function(construct, ...)
-    local self = setmetatable({}, exports.TestClass);
-    if construct and exports.TestClass.constructor then
-        exports.TestClass.constructor(self, ...);
-    end
+exports.TestClass.prototype = exports.TestClass.prototype or {};
+exports.TestClass.prototype.__index = exports.TestClass.prototype;
+exports.TestClass.prototype.constructor = TestClass;
+exports.TestClass.new = function(...)
+    local self = setmetatable({}, exports.TestClass.prototype);
+    self:____constructor(...);
     return self;
 end;
-exports.TestClass.constructor = function(self)
+exports.TestClass.prototype.____constructor = function(self)
 end;
 return exports;
diff --git a/test/translation/lua/modulesClassWithMemberExport.lua b/test/translation/lua/modulesClassWithMemberExport.lua
@@ -1,15 +1,16 @@
 local exports = exports or {};
 exports.TestClass = exports.TestClass or {};
 exports.TestClass.__index = exports.TestClass;
-exports.TestClass.new = function(construct, ...)
-    local self = setmetatable({}, exports.TestClass);
-    if construct and exports.TestClass.constructor then
-        exports.TestClass.constructor(self, ...);
-    end
+exports.TestClass.prototype = exports.TestClass.prototype or {};
+exports.TestClass.prototype.__index = exports.TestClass.prototype;
+exports.TestClass.prototype.constructor = TestClass;
+exports.TestClass.new = function(...)
+    local self = setmetatable({}, exports.TestClass.prototype);
+    self:____constructor(...);
     return self;
 end;
-exports.TestClass.constructor = function(self)
+exports.TestClass.prototype.____constructor = function(self)
 end;
-exports.TestClass.memberFunc = function(self)
+exports.TestClass.prototype.memberFunc = function(self)
 end;
 return exports;
diff --git a/test/translation/lua/namespaceMerge.lua b/test/translation/lua/namespaceMerge.lua
@@ -1,24 +1,25 @@
 MergedClass = MergedClass or {};
 MergedClass.__index = MergedClass;
-MergedClass.new = function(construct, ...)
-    local self = setmetatable({}, MergedClass);
-    self.propertyFunc = function(____)
-    end;
-    if construct and MergedClass.constructor then
-        MergedClass.constructor(self, ...);
-    end
+MergedClass.prototype = MergedClass.prototype or {};
+MergedClass.prototype.__index = MergedClass.prototype;
+MergedClass.prototype.constructor = MergedClass;
+MergedClass.new = function(...)
+    local self = setmetatable({}, MergedClass.prototype);
+    self:____constructor(...);
     return self;
 end;
-MergedClass.constructor = function(self)
+MergedClass.prototype.____constructor = function(self)
+    self.propertyFunc = function(____)
+    end;
 end;
 MergedClass.staticMethodA = function(self)
 end;
 MergedClass.staticMethodB = function(self)
     self:staticMethodA();
 end;
-MergedClass.methodA = function(self)
+MergedClass.prototype.methodA = function(self)
 end;
-MergedClass.methodB = function(self)
+MergedClass.prototype.methodB = function(self)
     self:methodA();
     self:propertyFunc();
 end;
@@ -27,7 +28,7 @@ do
     MergedClass.namespaceFunc = function()
     end;
 end
-local mergedClass = MergedClass.new(true);
+local mergedClass = MergedClass.new();
 mergedClass:methodB();
 mergedClass:propertyFunc();
 MergedClass:staticMethodB();
diff --git a/test/unit/assignments.spec.ts b/test/unit/assignments.spec.ts
@@ -152,7 +152,7 @@ export class AssignmentTests {
                    + `let [a,b] = jkl.abc();`;
 
         const lua = util.transpileString(code);
-        Expect(lua).toBe("local jkl = def.new(true);\nlocal a, b = jkl:abc();");
+        Expect(lua).toBe("local jkl = def.new();\nlocal a, b = jkl:abc();");
     }
 
     @Test("TupleReturn functional")
diff --git a/test/unit/class.spec.ts b/test/unit/class.spec.ts
diff --git a/test/unit/compiler/configuration/options.spec.ts b/test/unit/compiler/configuration/options.spec.ts
diff --git a/test/unit/decoratorMetaExtension.spec.ts b/test/unit/decoratorMetaExtension.spec.ts
diff --git a/test/unit/typechecking.spec.ts b/test/unit/typechecking.spec.ts

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`		`-MyClass.myFunction = function(self)`
	`1`	`+MyClass.prototype.myFunction = function(self)`
`2`	`2`	`end;`
Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`		`-TestClass.myFunction = function(self)`
	`1`	`+TestClass.prototype.myFunction = function(self)`
`2`	`2`	`end;`