fixed transforming undefined as a property name (#474)

tomblind · web-flow · commit d870f00098cd · 2019-03-10T13:18:48.000-06:00
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -3978,29 +3978,34 @@ export class LuaTransformer {
             const value = Number(propertyName.text);
             return tstl.createNumericLiteral(value, propertyName);
         } else {
-            return tstl.createStringLiteral(this.transformIdentifier(propertyName).text);
+            return tstl.createStringLiteral(this.getIdentifierText(propertyName));
         }
     }
 
-    public transformIdentifier(expression: ts.Identifier): tstl.Identifier {
-        if (expression.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
-            return tstl.createIdentifier("nil");  // 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 retun tstl.createNilLiteral()
-                                                  // at some point.
-        }
-
-        let escapedText = expression.escapedText as string;
+    public getIdentifierText(identifier: ts.Identifier): string {
+        let escapedText = identifier.escapedText as string;
         const underScoreCharCode = "_".charCodeAt(0);
         if (escapedText.length >= 3 && escapedText.charCodeAt(0) === underScoreCharCode &&
             escapedText.charCodeAt(1) === underScoreCharCode && escapedText.charCodeAt(2) === underScoreCharCode) {
             escapedText = escapedText.substr(1);
         }
 
         if (this.luaKeywords.has(escapedText)) {
-            throw TSTLErrors.KeywordIdentifier(expression);
+            throw TSTLErrors.KeywordIdentifier(identifier);
+        }
+
+        return escapedText;
+    }
+
+    public transformIdentifier(expression: ts.Identifier): tstl.Identifier {
+        if (expression.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
+            return tstl.createIdentifier("nil");  // 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 retun tstl.createNilLiteral()
+                                                  // at some point.
         }
 
+        const escapedText = this.getIdentifierText(expression);
         const symbolId = this.getIdentifierSymbolId(expression);
         return tstl.createIdentifier(escapedText, expression, symbolId);
     }
diff --git a/test/unit/objectLiteral.spec.ts b/test/unit/objectLiteral.spec.ts
@@ -23,4 +23,12 @@ export class ObjectLiteralTests {
         const result = util.transpileAndExecute(`const x = ${input}; const o = {x}; return o.x;`);
         Expect(result).toBe(expected);
     }
+
+    @Test("undefined as object key")
+    public undefinedAsObjectKey(): void {
+        const code =
+            `const foo = {undefined: "foo"};
+            return foo.undefined;`;
+        Expect(util.transpileAndExecute(code)).toBe("foo");
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -23,4 +23,12 @@ export class ObjectLiteralTests {`
`23`	`23`	const result = util.transpileAndExecute(`const x = ${input}; const o = {x}; return o.x;`);
`24`	`24`	`Expect(result).toBe(expected);`
`25`	`25`	`}`
	`26`	`+`
	`27`	`+ @Test("undefined as object key")`
	`28`	`+ public undefinedAsObjectKey(): void {`
	`29`	`+ const code =`
	`30`	+ `const foo = {undefined: "foo"};
	`31`	+ return foo.undefined;`;
	`32`	`+ Expect(util.transpileAndExecute(code)).toBe("foo");`
	`33`	`+ }`
`26`	`34`	`}`