fixed declarations that reference their own identifiers (#910)

tomblind · ark120202 · web-flow · commit 8dd12a93778f · 2020-08-01T07:20:39.000-06:00
* fixed variable declarations that reference their own identifiers in the initializer

* Update src/transformation/utils/lua-ast.ts

Co-authored-by: ark120202 &lt;ark120202@gmail.com&gt;

* compiler error fix

* moved tests to assignments

Co-authored-by: Tom &lt;tomblind@users.noreply.github.com&gt;
Co-authored-by: ark120202 &lt;ark120202@gmail.com&gt;
diff --git a/src/transformation/utils/lua-ast.ts b/src/transformation/utils/lua-ast.ts
@@ -4,8 +4,7 @@ import * as lua from "../../LuaAST";
 import { assert, castArray } from "../../utils";
 import { TransformationContext } from "../context";
 import { createExportedIdentifier, getIdentifierExportScope } from "./export";
-import { peekScope, ScopeType } from "./scope";
-import { isFunctionType } from "./typescript";
+import { peekScope, ScopeType, Scope } from "./scope";
 import { transformLuaLibFunction } from "./lualib";
 import { LuaLibFeature } from "../../LuaLib";
 
@@ -129,6 +128,17 @@ export function createHoistableVariableDeclarationStatement(
     return declaration;
 }
 
+function hasMultipleReferences(scope: Scope, identifiers: lua.Identifier | lua.Identifier[]) {
+    const scopeSymbols = scope.referencedSymbols;
+    if (!scopeSymbols) {
+        return false;
+    }
+
+    const referenceLists = castArray(identifiers).map(i => i.symbolId && scopeSymbols.get(i.symbolId));
+
+    return referenceLists.some(symbolRefs => symbolRefs && symbolRefs.length > 1);
+}
+
 export function createLocalOrExportedOrGlobalDeclaration(
     context: TransformationContext,
     lhs: lua.Identifier | lua.Identifier[],
@@ -163,15 +173,8 @@ export function createLocalOrExportedOrGlobalDeclaration(
         const isTopLevelVariable = scope.type === ScopeType.File;
 
         if (context.isModule || !isTopLevelVariable) {
-            const isPossibleWrappedFunction =
-                !isFunctionDeclaration &&
-                tsOriginal &&
-                ts.isVariableDeclaration(tsOriginal) &&
-                tsOriginal.initializer &&
-                isFunctionType(context, context.checker.getTypeAtLocation(tsOriginal.initializer));
-
-            if (isPossibleWrappedFunction || scope.type === ScopeType.Switch) {
-                // Split declaration and assignment for wrapped function types to allow recursion
+            if (scope.type === ScopeType.Switch || (!isFunctionDeclaration && hasMultipleReferences(scope, lhs))) {
+                // Split declaration and assignment of identifiers that reference themselves in their declaration
                 declaration = lua.createVariableDeclarationStatement(lhs, undefined, tsOriginal);
                 assignment = lua.createAssignmentStatement(lhs, rhs, tsOriginal);
             } else {
diff --git a/test/unit/assignments.spec.ts b/test/unit/assignments.spec.ts
@@ -323,3 +323,39 @@ test.each([
         return { r, o, a };
     `.expectToMatchJsResult();
 });
+
+test("local variable declaration referencing self indirectly", () => {
+    util.testFunction`
+        let cb: () => void;
+
+        function foo(newCb: () => void) {
+            cb = newCb;
+            return "foo";
+        }
+
+        let bar = foo(() => {
+            bar = "bar";
+        });
+
+        cb();
+        return bar;
+    `.expectToMatchJsResult();
+});
+
+test("local multiple variable declaration referencing self indirectly", () => {
+    util.testFunction`
+        let cb: () => void;
+
+        function foo(newCb: () => void) {
+            cb = newCb;
+            return ["a", "foo", "c"];
+        }
+
+        let [a, bar, c] = foo(() => {
+            bar = "bar";
+        });
+
+        cb();
+        return bar;
+    `.expectToMatchJsResult();
+});
