TypeScriptToLua · Perryvw · Jul 7, 2019 · Jun 12, 2019 · Jun 12, 2019 · Jun 13, 2019
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -23,9 +23,9 @@
         "pretest": "npm run lint && ts-node --transpile-only ./build_lualib.ts",
         "test": "jest",
         "lint": "npm run lint:tslint && npm run lint:prettier",
-        "lint:prettier": "prettier --check **/*.{js,ts,yml,json,md} || (echo 'Run `npm run fix:prettier` to fix it.' && exit 1)",
+        "lint:prettier": "prettier --check \"**/*.{js,ts,yml,json,md}\" || (echo 'Run `npm run fix:prettier` to fix it.' && exit 1)",
         "lint:tslint": "tslint -p . && tslint -p test && tslint -p src/lualib",
-        "fix:prettier": "prettier --check --write **/*.{js,ts,yml,json,md}",
+        "fix:prettier": "prettier --check --write \"**/*.{js,ts,yml,json,md}\"",
         "release-major": "npm version major",
         "release-minor": "npm version minor",
         "release-patch": "npm version patch",

diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -4876,14 +4876,6 @@ export class LuaTransformer {
     }
 
     public transformIdentifier(identifier: ts.Identifier): tstl.Identifier {
-        if (identifier.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
-            // TODO this is a hack that allows use to keep Identifier
-            // as return time as changing that would break a lot of stuff.
-            // But this should be changed to return tstl.createNilLiteral()
-            // at some point.
-            return tstl.createIdentifier("nil");
-        }
-
         if (tsHelper.isForRangeType(identifier, this.checker)) {
             const callExpression = tsHelper.findFirstNodeAbove(identifier, ts.isCallExpression);
             if (!callExpression || !callExpression.parent || !ts.isForOfStatement(callExpression.parent)) {
@@ -4910,6 +4902,10 @@ export class LuaTransformer {
             return this.createExportedIdentifier(identifier, exportScope);
         }
 
+        if (expression.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
+            return tstl.createNilLiteral();
+        }
+
         switch (this.getIdentifierText(expression)) {
             case "NaN":
                 return tstl.createParenthesizedExpression(
@@ -4925,6 +4921,9 @@ export class LuaTransformer {
                 const math = tstl.createIdentifier("math");
                 const huge = tstl.createStringLiteral("huge");
                 return tstl.createTableIndexExpression(math, huge, expression);
+
+            case "globalThis":
+                return tstl.createIdentifier("_G", expression, this.getIdentifierSymbolId(expression));
         }
 
         return identifier;
@@ -5432,7 +5431,8 @@ export class LuaTransformer {
     protected hasUnsafeSymbolName(symbol: ts.Symbol, tsOriginal?: ts.Identifier): boolean {
         const isLuaKeyword = luaKeywords.has(symbol.name);
         const isInvalidIdentifier = !tsHelper.isValidLuaIdentifier(symbol.name);
-        const isAmbient = symbol.declarations.some(d => tsHelper.isAmbientNode(d));
+        // TODO rework once microsoft/TypeScript#24706 is fixed and remove check for symbol.declarations
+        const isAmbient = symbol.declarations && symbol.declarations.some(d => tsHelper.isAmbientNode(d));
         if ((isLuaKeyword || isInvalidIdentifier) && isAmbient) {
             // Catch ambient declarations of identifiers with bad names
             throw TSTLErrors.InvalidAmbientIdentifierName(tsOriginal || ts.createIdentifier(symbol.name));

diff --git a/test/unit/identifiers.spec.ts b/test/unit/identifiers.spec.ts
@@ -788,3 +788,66 @@ test("exported variable with lua keyword as name is not renamed", () => {
 
     expect(util.transpileExecuteAndReturnExport(code, "print")).toBe("foobar");
 });
+
+describe("globalThis translation", () => {
+    test("globalThis to _G (expression)", () => {
+        const code = `
+        var foo = "bar";
+        return globalThis.foo;`;
+
+        const lua = util.transpileString(code);
+
+        expect(util.executeLua(lua)).toBe("bar");
+    });
+
+    test("globalThis to _G (assign)", () => {
+        const code = `
+        globalThis.foo = "bar";
+        return globalThis.foo;`;
+
+        expect(util.transpileAndExecute(code)).toBe("bar");
+    });
+
+    test("globalThis to _G (reassign)", () => {
+        const code = `
+        globalThis.foo = "bar";
+        globalThis.foo = "baz";
+        return globalThis.foo;`;
+
+        expect(util.transpileAndExecute(code)).toBe("baz");
+    });
+
+    test("globalThis to _G (function)", () => {
+        const code = `
+        globalThis.foo = () => "bar";
+        return globalThis.foo();`;
+
+        expect(util.transpileAndExecute(code)).toBe("bar");
+    });
+
+    test("globalThis to _G (assign + noImplicitAny)", () => {
+        const code = `
+        (<any>globalThis).foo = "bar";
+        return (<any>globalThis).foo;`;
+
+        expect(util.transpileAndExecute(code)).toBe("bar");
+    });
+
+    test("globalThis to _G (var)", () => {
+        const code = `
+        var globalFoo = "bar";
+        return globalThis.globalFoo;`;
+
+        const lua = util.transpileString(code);
+
+        expect(util.executeLua(lua)).toBe("bar");
+    });
+
+    test("globalThis to _G (let)", () => {
+        const code = `
+        let NotAGlobalFoo = "bar";
+        return (<any>globalThis).NotAGlobalFoo;`;
+
+        expect(util.transpileAndExecute(code)).toBe(undefined);
+    });
+});