TypeScriptToLua · Perryvw · Jul 16, 2019 · Jul 15, 2019 · Jul 15, 2019 · Jul 15, 2019
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -2757,7 +2757,7 @@ export class LuaTransformer {
         }
 
         const type = this.checker.getTypeAtLocation(statement.expression);
-        if (tsHelper.isStringType(type)) {
+        if (tsHelper.isStringType(type, this.checker, this.program)) {
             const error = tstl.createIdentifier("error");
             return tstl.createExpressionStatement(
                 tstl.createCallExpression(error, [this.transformExpression(statement.expression)]),
@@ -3289,7 +3289,10 @@ export class LuaTransformer {
                     // Check is we need to use string concat operator
                     const typeLeft = this.checker.getTypeAtLocation(node.left);
                     const typeRight = this.checker.getTypeAtLocation(node.right);
-                    if (tsHelper.isStringType(typeLeft) || tsHelper.isStringType(typeRight)) {
+                    if (
+                        tsHelper.isStringType(typeLeft, this.checker, this.program) ||
+                        tsHelper.isStringType(typeRight, this.checker, this.program)
+                    ) {
                         return tstl.SyntaxKind.ConcatOperator;
                     }
                 }
@@ -4084,7 +4087,7 @@ export class LuaTransformer {
 
         // Check for primitive types to override
         const type = this.checker.getTypeAtLocation(expression.expression);
-        if (tsHelper.isStringType(type)) {
+        if (tsHelper.isStringType(type, this.checker, this.program)) {
             return this.transformStringProperty(expression);
         } else if (tsHelper.isArrayType(type, this.checker, this.program)) {
             const arrayPropertyAccess = this.transformArrayProperty(expression);
@@ -4291,7 +4294,7 @@ export class LuaTransformer {
 
         const argumentType = this.checker.getTypeAtLocation(expression.argumentExpression);
         const type = this.checker.getTypeAtLocation(expression.expression);
-        if (tsHelper.isNumberType(argumentType) && tsHelper.isStringType(type)) {
+        if (tsHelper.isNumberType(argumentType) && tsHelper.isStringType(type, this.checker, this.program)) {
             const index = this.transformExpression(expression.argumentExpression);
             return tstl.createCallExpression(
                 tstl.createTableIndexExpression(tstl.createIdentifier("string"), tstl.createStringLiteral("sub")),

diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -132,7 +132,14 @@ export function isStaticNode(node: ts.Node): boolean {
     return node.modifiers !== undefined && node.modifiers.some(m => m.kind === ts.SyntaxKind.StaticKeyword);
 }
 
-export function isStringType(type: ts.Type): boolean {
+export function isStringType(type: ts.Type, checker: ts.TypeChecker, program: ts.Program): boolean {
+    if (type.symbol) {
+        const baseConstraint = checker.getBaseConstraintOfType(type);
+        if (baseConstraint) {
+            return isStringType(baseConstraint, checker, program);
+        }
+    }
+
     return (
         (type.flags & ts.TypeFlags.String) !== 0 ||
         (type.flags & ts.TypeFlags.StringLike) !== 0 ||
@@ -149,6 +156,13 @@ export function isNumberType(type: ts.Type): boolean {
 }
 
 export function isExplicitArrayType(type: ts.Type, checker: ts.TypeChecker, program: ts.Program): boolean {
+    if (type.symbol) {
+        const baseConstraint = checker.getBaseConstraintOfType(type);
+        if (baseConstraint) {
+            return isExplicitArrayType(baseConstraint, checker, program);
+        }
+    }
+
     if (type.isUnionOrIntersection()) {
         return type.types.some(t => isExplicitArrayType(t, checker, program));
     }

diff --git a/test/unit/array.spec.ts b/test/unit/array.spec.ts
@@ -226,3 +226,38 @@ test.each([`["foo", "bar"].length`, `["foo", "bar"][0]`, `[() => "foo", () => "b
         expect(util.transpileAndExecute(code)).toBe(expectResult);
     }
 );
+
+const genericChecks = [
+    "function generic<T extends number[]>(array: T)",
+    "function generic<T extends [...number[]]>(array: T)",
+    "function generic<T extends any>(array: T[])",
+    "type ArrayType = number[]; function generic<T extends ArrayType>(array: T)",
+    "function generic<T extends number[]>(array: T & {})",
+    "function generic<T extends number[] & {}>(array: T)",
+];
+
+test.each(genericChecks)("array constrained generic foreach (%p)", signature => {
+    const code = `
+            ${signature}: number {
+                let sum = 0;
+                array.forEach(item => {
+                    if (typeof item === "number") {
+                        sum += item;
+                    }
+                });
+                return sum;
+            }
+            return generic([1, 2, 3]);
+        `;
+    expect(util.transpileAndExecute(code)).toBe(6);
+});
+
+test.each(genericChecks)("array constrained generic length (%p)", signature => {
+    const code = `
+            ${signature}: number {
+                return array.length;
+            }
+            return generic([1, 2, 3]);
+        `;
+    expect(util.transpileAndExecute(code)).toBe(3);
+});
diff --git a/test/unit/string.spec.ts b/test/unit/string.spec.ts
@@ -348,3 +348,16 @@ test.each([`"foobar".length`, `"foobar".repeat(2)`, "`foo${'bar'}`.length", "`fo
         expect(util.transpileAndExecute(code)).toBe(expectResult);
     }
 );
+
+test.each([
+    "function generic<T extends string>(string: T)",
+    "type StringType = string; function generic<T extends StringType>(string: T)",
+])("string constrained generic foreach (%p)", signature => {
+    const code = `
+            ${signature}: number {
+                return string.length;
+            }
+            return generic("string");
+        `;
+    expect(util.transpileAndExecute(code)).toBe(6);
+});