Fixed inconsistent scoping of top-level variable declarations

Perryvw · Perryvw · commit 0724d18933d2 · 2020-01-09T22:13:23.000+01:00
diff --git a/src/transformation/utils/lua-ast.ts b/src/transformation/utils/lua-ast.ts
@@ -122,7 +122,6 @@ export function createLocalOrExportedOrGlobalDeclaration(
     let declaration: lua.VariableDeclarationStatement | undefined;
     let assignment: lua.AssignmentStatement | undefined;
 
-    const isVariableDeclaration = tsOriginal !== undefined && ts.isVariableDeclaration(tsOriginal);
     const isFunctionDeclaration = tsOriginal !== undefined && ts.isFunctionDeclaration(tsOriginal);
 
     const identifiers = Array.isArray(lhs) ? lhs : [lhs];
@@ -145,7 +144,7 @@ export function createLocalOrExportedOrGlobalDeclaration(
     } else {
         const insideFunction = findScope(context, ScopeType.Function) !== undefined;
 
-        if (context.isModule || getCurrentNamespace(context) || insideFunction || isVariableDeclaration) {
+        if (context.isModule || getCurrentNamespace(context) || insideFunction) {
             const scope = peekScope(context);
 
             const isPossibleWrappedFunction =
diff --git a/test/translation/__snapshots__/transformation.spec.ts.snap b/test/translation/__snapshots__/transformation.spec.ts.snap
@@ -1,18 +1,18 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`Transformation (characterEscapeSequence) 1`] = `
-"local quoteInDoubleQuotes = \\"' ' '\\"
-local quoteInTemplateString = \\"' ' '\\"
-local doubleQuoteInQuotes = \\"\\\\\\" \\\\\\" \\\\\\"\\"
-local doubleQuoteInDoubleQuotes = \\"\\\\\\" \\\\\\" \\\\\\"\\"
-local doubleQuoteInTemplateString = \\"\\\\\\" \\\\\\" \\\\\\"\\"
-local backQuoteInQuotes = \\"\` \` \`\\"
-local backQuoteInDoubleQuotes = \\"\` \` \`\\"
-local backQuoteInTemplateString = \\"\` \` \`\\"
-local escapedCharsInQuotes = \\"\\\\\\\\ \\\\0 \\\\b \\\\t \\\\n \\\\v \\\\f \\\\\\" ' \`\\"
-local escapedCharsInDoubleQuotes = \\"\\\\\\\\ \\\\0 \\\\b \\\\t \\\\n \\\\v \\\\f \\\\\\" ' \`\\"
-local escapedCharsInTemplateString = \\"\\\\\\\\ \\\\0 \\\\b \\\\t \\\\n \\\\v \\\\f \\\\\\" ' \`\\"
-local nonEmptyTemplateString = \\"Level 0: \\\\n\\\\t \\" .. \\"Level 1: \\\\n\\\\t\\\\t \\" .. \\"Level 3: \\\\n\\\\t\\\\t\\\\t \\" .. \\"Last level \\\\n --\\" .. \\" \\\\n --\\" .. \\" \\\\n --\\" .. \\" \\\\n --\\""
+"quoteInDoubleQuotes = \\"' ' '\\"
+quoteInTemplateString = \\"' ' '\\"
+doubleQuoteInQuotes = \\"\\\\\\" \\\\\\" \\\\\\"\\"
+doubleQuoteInDoubleQuotes = \\"\\\\\\" \\\\\\" \\\\\\"\\"
+doubleQuoteInTemplateString = \\"\\\\\\" \\\\\\" \\\\\\"\\"
+backQuoteInQuotes = \\"\` \` \`\\"
+backQuoteInDoubleQuotes = \\"\` \` \`\\"
+backQuoteInTemplateString = \\"\` \` \`\\"
+escapedCharsInQuotes = \\"\\\\\\\\ \\\\0 \\\\b \\\\t \\\\n \\\\v \\\\f \\\\\\" ' \`\\"
+escapedCharsInDoubleQuotes = \\"\\\\\\\\ \\\\0 \\\\b \\\\t \\\\n \\\\v \\\\f \\\\\\" ' \`\\"
+escapedCharsInTemplateString = \\"\\\\\\\\ \\\\0 \\\\b \\\\t \\\\n \\\\v \\\\f \\\\\\" ' \`\\"
+nonEmptyTemplateString = \\"Level 0: \\\\n\\\\t \\" .. \\"Level 1: \\\\n\\\\t\\\\t \\" .. \\"Level 3: \\\\n\\\\t\\\\t\\\\t \\" .. \\"Last level \\\\n --\\" .. \\" \\\\n --\\" .. \\" \\\\n --\\" .. \\" \\\\n --\\""
 `;
 
 exports[`Transformation (classExtension1) 1`] = `
@@ -244,7 +244,7 @@ ____exports.foo = \\"bar\\"
 return ____exports"
 `;
 
-exports[`Transformation (modulesVariableNoExport) 1`] = `"local foo = \\"bar\\""`;
+exports[`Transformation (modulesVariableNoExport) 1`] = `"foo = \\"bar\\""`;
 
 exports[`Transformation (namespacePhantom) 1`] = `
 "function nsMember(self)
@@ -257,6 +257,16 @@ exports[`Transformation (returnDefault) 1`] = `
 end"
 `;
 
+exports[`Transformation (topLevelVariables) 1`] = `
+"obj = {value1 = 1, value2 = 2}
+value1 = obj.value1
+value2 = obj.value2
+function fun1(self)
+end
+fun2 = function()
+end"
+`;
+
 exports[`Transformation (unusedDefaultWithNamespaceImport) 1`] = `
 "local ____exports = {}
 local x = require(\\"module\\")
diff --git a/test/translation/transformation/topLevelVariables.ts b/test/translation/transformation/topLevelVariables.ts
@@ -0,0 +1,6 @@
+const obj = { value1: 1, value2: 2 };
+const value1 = obj.value1;
+const { value2 } = obj;
+
+function fun1(): void {}
+const fun2 = () => {};
diff --git a/test/unit/assignments.spec.ts b/test/unit/assignments.spec.ts
@@ -1,13 +1,23 @@
 import * as util from "../util";
 
 test("const declaration", () => {
-    const lua = util.transpileString(`const foo = true;`);
-    expect(lua).toBe(`local foo = true`);
+    const lua = util.testFunction`const foo = true;`.getMainLuaCodeChunk();
+    expect(lua).toContain(`local foo = true`);
 });
 
 test("let declaration", () => {
-    const lua = util.transpileString(`let foo = true;`);
-    expect(lua).toBe(`local foo = true`);
+    const lua = util.testFunction`let foo = true;`.getMainLuaCodeChunk();
+    expect(lua).toContain(`local foo = true`);
+});
+
+test("const declaration top-level is global", () => {
+    const lua = util.testModule`const foo = true;`.getMainLuaCodeChunk();
+    expect(lua).toBe(`foo = true`);
+});
+
+test("let declaration top-level is global", () => {
+    const lua = util.testModule`let foo = true;`.getMainLuaCodeChunk();
+    expect(lua).toBe(`foo = true`);
 });
 
 test("var declaration is disallowed", () => {
diff --git a/test/unit/objectLiteral.spec.ts b/test/unit/objectLiteral.spec.ts
@@ -8,59 +8,53 @@ test.each([
     { inp: `{[myFunc()]:3,b:"4"}`, out: '{\n    [myFunc(_G)] = 3,\n    b = "4"\n}' },
     { inp: `{x}`, out: `{x = x}` },
 ])("Object Literal (%p)", ({ inp, out }) => {
-    const lua = util.transpileString(`const myvar = ${inp};`);
-    expect(lua).toBe(`local myvar = ${out}`);
+    const lua = util.testModule`const myvar = ${inp};`.getMainLuaCodeChunk();
+    expect(lua).toBe(`myvar = ${out}`);
 });
 
 describe("property shorthand", () => {
     test("should support property shorthand", () => {
-        const result = util.transpileAndExecute(`
+        util.testFunction`
             const x = 1;
             const o = { x };
             return o.x;
-        `);
-
-        expect(result).toBe(1);
+        `.expectToMatchJsResult();
     });
 
     test.each([NaN, Infinity])("should support %p shorthand", identifier => {
-        const result = util.transpileAndExecute(`return ({ ${identifier} }).${identifier}`);
-
-        expect(result).toBe(identifier);
+        util.testFunction`return ({ ${identifier} }).${identifier}`.expectToMatchJsResult();
     });
 
     test("should support _G shorthand", () => {
-        const result = util.transpileAndExecute(
-            `return ({ _G })._G.foobar;`,
-            undefined,
-            `foobar = "foobar"`,
-            "declare const _G: any;"
-        );
-
-        expect(result).toBe("foobar");
+        const luaResult = util.testFunction`
+            return ({ _G })._G.foobar;
+        `
+            .setTsHeader(`declare const _G: any;`)
+            .setLuaHeader(`foobar = "foobar"`)
+            .getLuaExecutionResult();
+
+        expect(luaResult).toEqual("foobar");
     });
 
     test("should support export property shorthand", () => {
-        const code = `
+        util.testModule`
             export const x = 1;
             const o = { x };
             export const y = o.x;
-        `;
-        expect(util.transpileExecuteAndReturnExport(code, "y")).toBe(1);
+        `.expectToMatchJsResult();
     });
 });
 
 test("undefined as object key", () => {
-    const code = `const foo = {undefined: "foo"};
-        return foo.undefined;`;
-    expect(util.transpileAndExecute(code)).toBe("foo");
+    util.testFunction`
+        const foo = {undefined: "foo"};
+        return foo.undefined;
+    `.expectToMatchJsResult();
 });
 
 test.each([`({x: "foobar"}.x)`, `({x: "foobar"}["x"])`, `({x: () => "foobar"}.x())`, `({x: () => "foobar"}["x"]())`])(
     "object literal property access (%p)",
     expression => {
-        const code = `return ${expression}`;
-        const expectResult = eval(expression);
-        expect(util.transpileAndExecute(code)).toBe(expectResult);
+        util.testFunction`return ${expression}`.expectToMatchJsResult();
     }
 );
