Fixed bug with array and tuple types

Perryvw · Perryvw · commit 3100b923c4e0 · 2018-04-02T13:02:24.000+02:00
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -58,15 +58,14 @@ export class TSHelper {
             || (type.flags & ts.TypeFlags.StringLiteral) !== 0;
     }
 
-    public static isArrayType(type: ts.Type): boolean {
-        return (type.flags & ts.TypeFlags.Object) !== 0
-            && (type as ts.ObjectType).symbol
-            && (type as ts.ObjectType).symbol.escapedName === "Array";
+    public static isArrayType(type: ts.Type, checker: ts.TypeChecker): boolean {
+        const typeNode = checker.typeToTypeNode(type);
+        return typeNode && typeNode.kind === ts.SyntaxKind.ArrayType;
     }
 
-    public static isTupleType(type: ts.Type): boolean {
-        return (type.flags & ts.TypeFlags.Object) !== 0
-            && (type as ts.TypeReference).typeArguments !== undefined;
+    public static isTupleType(type: ts.Type, checker: ts.TypeChecker): boolean {
+        const typeNode = checker.typeToTypeNode(type);
+        return typeNode && typeNode.kind === ts.SyntaxKind.TupleType;
     }
 
     public static isCompileMembersOnlyEnum(type: ts.Type, checker: ts.TypeChecker): boolean {
diff --git a/src/Transpiler.ts b/src/Transpiler.ts
@@ -388,7 +388,7 @@ export class LuaTranspiler {
         const expression = this.transpileExpression(node.expression);
 
         // Use ipairs for array types, pairs otherwise
-        const isArray = tsEx.isArrayType(this.checker.getTypeAtLocation(node.expression));
+        const isArray = tsEx.isArrayType(this.checker.getTypeAtLocation(node.expression), this.checker);
         const pairs = isArray ? "ipairs" : "pairs";
 
         // Make header
@@ -410,7 +410,7 @@ export class LuaTranspiler {
         // Transpile expression
         const expression = this.transpileExpression(node.expression);
 
-        if (tsEx.isArrayType(this.checker.getTypeAtLocation(node.expression))) {
+        if (tsEx.isArrayType(this.checker.getTypeAtLocation(node.expression), this.checker)) {
             throw new TranspileError("Iterating over arrays with 'for in' is not allowed.", node);
         }
 
@@ -861,7 +861,7 @@ export class LuaTranspiler {
                     return this.transpileStringCallExpression(node);
 
             }
-            if (tsEx.isArrayType(expType)) {
+            if (tsEx.isArrayType(expType, this.checker)) {
                 return this.transpileArrayCallExpression(node);
             }
 
@@ -1007,7 +1007,7 @@ export class LuaTranspiler {
             case ts.TypeFlags.StringLiteral:
                 return this.transpileStringProperty(node);
             case ts.TypeFlags.Object:
-                if (tsEx.isArrayType(type)) {
+                if (tsEx.isArrayType(type, this.checker)) {
                     return this.transpileArrayProperty(node);
                 }
         }
@@ -1083,7 +1083,7 @@ export class LuaTranspiler {
         const index = this.transpileExpression(node.argumentExpression);
 
         const type = this.checker.getTypeAtLocation(node.expression);
-        if (tsEx.isArrayType(type) || tsEx.isTupleType(type)) {
+        if (tsEx.isArrayType(type, this.checker) || tsEx.isTupleType(type, this.checker)) {
             return `${element}[${index}+1]`;
         } else if (tsEx.isStringType(type)) {
             return `string.sub(${element},${index}+1,${index}+1)`;
@@ -1130,9 +1130,9 @@ export class LuaTranspiler {
             if (ts.isCallExpression(node.initializer)
                 && tsEx.isTupleReturnFunction(this.checker.getTypeAtLocation(node.initializer.expression), this.checker)
                ) {
-                return `local ${vars}=${value}`;
+                return `local ${vars}=${value}\n`;
             } else {
-                return `local ${vars}=unpack(${value})`;
+                return `local ${vars}=unpack(${value})\n`;
             }
         } else {
             throw new TranspileError(
diff --git a/test/translation/lua/interfaceIndex.lua b/test/translation/lua/interfaceIndex.lua
@@ -0,0 +1,3 @@
+local a = {}
+
+a["abc"]="def"
diff --git a/test/translation/ts/interfaceIndex.ts b/test/translation/ts/interfaceIndex.ts
@@ -0,0 +1,6 @@
+declare interface Dictionary<T> {
+    [index: number]: T;
+}
+
+let a: Dictionary<string> = {};
+a["abc"] = "def";

Original file line number	Diff line number	Diff line change
`@@ -58,15 +58,14 @@ export class TSHelper {`
`58`	`58`	`\|\| (type.flags & ts.TypeFlags.StringLiteral) !== 0;`
`59`	`59`	`}`
`60`	`60`
`61`		`- public static isArrayType(type: ts.Type): boolean {`
`62`		`- return (type.flags & ts.TypeFlags.Object) !== 0`
`63`		`- && (type as ts.ObjectType).symbol`
`64`		`- && (type as ts.ObjectType).symbol.escapedName === "Array";`
	`61`	`+ public static isArrayType(type: ts.Type, checker: ts.TypeChecker): boolean {`
	`62`	`+ const typeNode = checker.typeToTypeNode(type);`
	`63`	`+ return typeNode && typeNode.kind === ts.SyntaxKind.ArrayType;`
`65`	`64`	`}`
`66`	`65`
`67`		`- public static isTupleType(type: ts.Type): boolean {`
`68`		`- return (type.flags & ts.TypeFlags.Object) !== 0`
`69`		`- && (type as ts.TypeReference).typeArguments !== undefined;`
	`66`	`+ public static isTupleType(type: ts.Type, checker: ts.TypeChecker): boolean {`
	`67`	`+ const typeNode = checker.typeToTypeNode(type);`
	`68`	`+ return typeNode && typeNode.kind === ts.SyntaxKind.TupleType;`
`70`	`69`	`}`
`71`	`70`
`72`	`71`	`public static isCompileMembersOnlyEnum(type: ts.Type, checker: ts.TypeChecker): boolean {`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+local a = {}`
	`2`	`+`
	`3`	`+a["abc"]="def"`