Merge branch 'master' into ts-to-lua-ast

Perryvw · Perryvw · commit b75720533b9f · 2019-01-21T21:38:29.000+01:00
# Conflicts:
#	src/Transpiler.ts
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -384,7 +384,8 @@ export class LuaTransformer {
 
         // Write class declaration
         if (extendsType) {
-            const baseName = tstl.createIdentifier(extendsType.symbol.escapedName as string);
+            const extendedTypeNode = tsHelper.getExtendedTypeNode(statement, this.checker);
+            const baseName = this.transformExpression(extendedTypeNode.expression);
 
             // baseName.new
             const newIndex = tstl.createTableIndexExpression(baseName, tstl.createStringLiteral("new"));
@@ -428,7 +429,9 @@ export class LuaTransformer {
         result.push(assignClassIndex);
 
         if (extendsType) {
-            const baseName = tstl.createIdentifier(extendsType.symbol.escapedName as string);
+            const extendedTypeNode = tsHelper.getExtendedTypeNode(statement, this.checker);
+            const baseName = this.transformExpression(extendedTypeNode.expression);
+
             // className.__base = baseName
             const classBase = tstl.createTableIndexExpression(className, tstl.createStringLiteral("__base"));
 
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -56,21 +56,27 @@ export class TSHelper {
         return result;
     }
 
-    public static getExtendedType(node: ts.ClassLikeDeclarationBase, checker: ts.TypeChecker): ts.Type | undefined {
+    public static getExtendedTypeNode(node: ts.ClassLikeDeclarationBase, checker: ts.TypeChecker):
+    ts.ExpressionWithTypeArguments | undefined {
         if (node && node.heritageClauses) {
             for (const clause of node.heritageClauses) {
                 if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
                     const superType = checker.getTypeAtLocation(clause.types[0]);
                     const decorators = this.getCustomDecorators(superType, checker);
                     if (!decorators.has(DecoratorKind.PureAbstract)) {
-                        return superType;
+                        return clause.types[0];
                     }
                 }
             }
         }
         return undefined;
     }
 
+    public static getExtendedType(node: ts.ClassLikeDeclarationBase, checker: ts.TypeChecker): ts.Type | undefined {
+        const extendedTypeNode = this.getExtendedTypeNode(node, checker);
+        return extendedTypeNode && checker.getTypeAtLocation(extendedTypeNode);
+    }
+
     public static isFileModule(sourceFile: ts.SourceFile): boolean {
         if (sourceFile) {
             // Vanilla ts flags files as external module if they have an import or
diff --git a/test/unit/class.spec.ts b/test/unit/class.spec.ts
@@ -277,6 +277,30 @@ export class ClassTests {
         Expect(result).toBe(10);
     }
 
+    @Test("renamedClassExtends")
+    public renamedClassExtends(): void
+    {
+        const result = util.transpileAndExecute(
+            `const b = new B();
+            return b.value;`,
+            undefined, undefined,
+            `namespace Classes {
+                export class Base {
+                    public value: number;
+                    constructor(){ this.value = 3; }
+                }
+            }
+
+            const A = Classes.Base;
+            class B extends A {
+                constructor(){ super(); }
+            };`
+        );
+
+        // Assert
+        Expect(result).toBe(3);
+    }
+
     @Test("ClassMethodCall")
     public classMethodCall(): void {
         const result = util.transpileAndExecute(

Original file line number	Diff line number	Diff line change
`@@ -56,21 +56,27 @@ export class TSHelper {`
`56`	`56`	`return result;`
`57`	`57`	`}`
`58`	`58`
`59`		`- public static getExtendedType(node: ts.ClassLikeDeclarationBase, checker: ts.TypeChecker): ts.Type \| undefined {`
	`59`	`+ public static getExtendedTypeNode(node: ts.ClassLikeDeclarationBase, checker: ts.TypeChecker):`
	`60`	`+ ts.ExpressionWithTypeArguments \| undefined {`
`60`	`61`	`if (node && node.heritageClauses) {`
`61`	`62`	`for (const clause of node.heritageClauses) {`
`62`	`63`	`if (clause.token === ts.SyntaxKind.ExtendsKeyword) {`
`63`	`64`	`const superType = checker.getTypeAtLocation(clause.types[0]);`
`64`	`65`	`const decorators = this.getCustomDecorators(superType, checker);`
`65`	`66`	`if (!decorators.has(DecoratorKind.PureAbstract)) {`
`66`		`- return superType;`
	`67`	`+ return clause.types[0];`
`67`	`68`	`}`
`68`	`69`	`}`
`69`	`70`	`}`
`70`	`71`	`}`
`71`	`72`	`return undefined;`
`72`	`73`	`}`
`73`	`74`
	`75`	`+ public static getExtendedType(node: ts.ClassLikeDeclarationBase, checker: ts.TypeChecker): ts.Type \| undefined {`
	`76`	`+ const extendedTypeNode = this.getExtendedTypeNode(node, checker);`
	`77`	`+ return extendedTypeNode && checker.getTypeAtLocation(extendedTypeNode);`
	`78`	`+ }`
	`79`	`+`
`74`	`80`	`public static isFileModule(sourceFile: ts.SourceFile): boolean {`
`75`	`81`	`if (sourceFile) {`
`76`	`82`	`// Vanilla ts flags files as external module if they have an import or`