Array union fix (#243)

tomblind · Perryvw · commit d75cdabc270b · 2018-10-15T17:37:12.000+02:00
* Updated check for array types to include unions and intersections that include an array type.

* fix for detecting arrays/tuples in aliases

* added tests
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -66,9 +66,16 @@ export class TSHelper {
             || (type.flags & ts.TypeFlags.StringLiteral) !== 0;
     }
 
+    public static isArrayTypeNode(typeNode: ts.TypeNode): boolean {
+        return typeNode.kind === ts.SyntaxKind.ArrayType
+            || typeNode.kind === ts.SyntaxKind.TupleType
+            || ((typeNode.kind === ts.SyntaxKind.UnionType || typeNode.kind === ts.SyntaxKind.IntersectionType)
+                && (typeNode as ts.UnionOrIntersectionTypeNode).types.some(this.isArrayTypeNode));
+    }
+
     public static isArrayType(type: ts.Type, checker: ts.TypeChecker): boolean {
-        const typeNode = checker.typeToTypeNode(type);
-        return typeNode && (typeNode.kind === ts.SyntaxKind.ArrayType || typeNode.kind === ts.SyntaxKind.TupleType);
+        const typeNode = checker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.InTypeAlias);
+        return typeNode && this.isArrayTypeNode(typeNode);
     }
 
     public static isTupleReturnCall(node: ts.Node, checker: ts.TypeChecker): boolean {
diff --git a/test/unit/array.spec.ts b/test/unit/array.spec.ts
@@ -0,0 +1,41 @@
+import { Expect, Test, TestCase } from "alsatian";
+import * as util from "../src/util";
+
+export class ArrayTests {
+    @Test("Array access")
+    public arrayAccess(): void {
+        const lua = util.transpileString(
+            `const arr: number[] = [3,5,1];
+            return arr[1];`
+        );
+        const result = util.executeLua(lua);
+        Expect(result).toBe(5);
+    }
+
+    @Test("Array union access")
+    public arrayUnionAccess(): void {
+        const lua = util.transpileString(
+            `function makeArray(): number[] | string[] { return [3,5,1]; }
+            const arr = makeArray();
+            return arr[1];`
+        );
+        const result = util.executeLua(lua);
+        Expect(result).toBe(5);
+    }
+
+    @Test("Array intersection access")
+    public arrayIntersectionAccess(): void {
+        const lua = util.transpileString(
+            `type I = number[] & {foo: string};
+            function makeArray(): I {
+                let t = [3,5,1];
+                (t as I).foo = "bar";
+                return (t as I);
+            }
+            const arr = makeArray();
+            return arr[1];`
+        );
+        const result = util.executeLua(lua);
+        Expect(result).toBe(5);
+    }
+}
diff --git a/test/unit/tuples.spec.ts b/test/unit/tuples.spec.ts
@@ -51,6 +51,33 @@ export class TupleTests {
         Expect(result).toBe(5);
     }
 
+    @Test("Tuple union access")
+    public tupleUnionAccess(): void {
+        const lua = util.transpileString(
+            `function makeTuple(): [number, number, number] | [string, string, string] { return [3,5,1]; }
+            const tuple = makeTuple();
+            return tuple[1];`
+        );
+        const result = util.executeLua(lua);
+        Expect(result).toBe(5);
+    }
+
+    @Test("Tuple intersection access")
+    public tupleIntersectionAccess(): void {
+        const lua = util.transpileString(
+            `type I = [number, number, number] & {foo: string};
+            function makeTuple(): I {
+                let t = [3,5,1];
+                (t as I).foo = "bar";
+                return (t as I);
+            }
+            const tuple = makeTuple();
+            return tuple[1];`
+        );
+        const result = util.executeLua(lua);
+        Expect(result).toBe(5);
+    }
+
     @Test("Tuple Destruct")
     public tupleDestruct(): void {
         // Transpile
