TypeScriptToLua · Perryvw · Feb 2, 2019 · Feb 1, 2019 · Feb 1, 2019 · Feb 1, 2019
diff --git a/src/LuaLib.ts b/src/LuaLib.ts
@@ -25,6 +25,7 @@ export enum LuaLibFeature {
     Set = "Set",
     StringReplace = "StringReplace",
     StringSplit = "StringSplit",
+    StringConcat = "StringConcat",
     Symbol = "Symbol",
 }
 

diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -2708,6 +2708,8 @@ export class LuaTransformer {
         switch (expressionName) {
             case "replace":
                 return this.transformLuaLibFunction(LuaLibFeature.StringReplace, caller, ...params);
+            case "concat":
+                return this.transformLuaLibFunction(LuaLibFeature.StringConcat, caller, ...params);
             case "indexOf":
                 const stringExpression =
                     node.arguments.length === 1
@@ -2747,6 +2749,18 @@ export class LuaTransformer {
                     const arg2 = params[1];
                     return this.createStringCall("sub", node, caller, arg1, arg2);
                 }
+            case "slice":
+                if (node.arguments.length === 0) {
+                    return caller;
+                }
+                else if (node.arguments.length === 1) {
+                    const arg1 = this.expressionPlusOne(params[0]);
+                    return this.createStringCall("sub", node, caller, arg1);
+                } else {
+                    const arg1 = this.expressionPlusOne(params[0]);
+                    const arg2 = params[1];
+                    return this.createStringCall("sub", node, caller, arg1, arg2);
+                }
             case "toLowerCase":
                 return this.createStringCall("lower", node, caller);
             case "toUpperCase":
@@ -2756,6 +2770,11 @@ export class LuaTransformer {
             case "charAt":
                 const firstParamPlusOne = this.expressionPlusOne(params[0]);
                 return this.createStringCall("sub", node, caller, firstParamPlusOne, firstParamPlusOne);
+            case "charCodeAt":
+            {
+                const firstParamPlusOne = this.expressionPlusOne(params[0]);
+                return this.createStringCall("byte", node, caller, firstParamPlusOne);
+            }
             default:
                 throw TSTLErrors.UnsupportedProperty("string", expressionName, node);
         }

diff --git a/src/lualib/StringConcat.ts b/src/lualib/StringConcat.ts
@@ -0,0 +1,7 @@
+function __TS__StringConcat(str1: string, ...args: string[]): string {
+  let out = str1;
+  for (const arg of args) {
+    out = out + arg;
+  }
+  return out;
+}
diff --git a/test/unit/string.spec.ts b/test/unit/string.spec.ts
@@ -81,7 +81,20 @@ export class StringTests
         // Assert
         Expect(result).toBe(expected);
     }
-
+    @TestCase("", ["", ""])
+    @TestCase("hello", ["test"])
+    @TestCase("hello", [])
+    @TestCase("hello", ["test", "bye"])
+    @Test("string.concatFct")
+    public concatFct(str: string, param: string[]): void {
+        const paramStr = param.map(elem => `"${elem}"`).join(", ");
+        console.log(`return "${str}".concat(${paramStr})`);
+         const result = util.transpileAndExecute(
+             `return "${str}".concat(${paramStr})`
+         );
+         // Assert
+         Expect(result).toBe(str.concat(...param));
+    }
     @TestCase("hello test", "")
     @TestCase("hello test", "t")
     @TestCase("hello test", "h")
@@ -122,7 +135,23 @@ export class StringTests
         // Assert
         Expect(result).toBe(inp.indexOf(searchValue, x));
     }
+    @TestCase("hello test")
+    @TestCase("hello test", 0)
+    @TestCase("hello test", 1)
+    @TestCase("hello test", 1, 2)
+    @TestCase("hello test", 1, 5)
+    @Test("string.slice")
+    public slice(inp: string, start?: number, end?: number): void
+    {
+        // Transpile/Execute
+        const paramStr = start? (end ? `${start}, ${end}` : `${start}`):'';
+        const result = util.transpileAndExecute(
+            `return "${inp}".slice(${paramStr})`
+        );
 
+        // Assert
+        Expect(result).toBe(inp.slice(start, end));
+    }
     @TestCase("hello test", 0)
     @TestCase("hello test", 1)
     @TestCase("hello test", 1, 2)
@@ -258,6 +287,20 @@ export class StringTests
         Expect(result).toBe(inp.charAt(index));
     }
 
+    @TestCase("hello test", 1)
+    @TestCase("hello test", 2)
+    @TestCase("hello test", 3)
+    @Test("string.charCodeAt")
+    public charCodeAt(inp: string, index: number): void
+    {
+        const result = util.transpileAndExecute(
+            `return "${inp}".charCodeAt(${index})`
+        );
+
+        // Assert
+        Expect(result).toBe(inp.charCodeAt(index));
+    }
+
     @TestCase("hello test", 1, 0)
     @TestCase("hello test", 1, 2)
     @TestCase("hello test", 3, 2)