Fix function with properties assigned to variable declaration (#1202)

GlassBricks · web-flow · commit 32257709c90a · 2022-01-04T21:26:40.000+01:00
diff --git a/src/transformation/visitors/function.ts b/src/transformation/visitors/function.ts
@@ -277,8 +277,9 @@ export function transformFunctionLikeDeclaration(
 
     const [functionExpression, functionScope] = transformFunctionToExpression(context, node);
 
+    const isNamedFunctionExpression = ts.isFunctionExpression(node) && node.name;
     // Handle named function expressions which reference themselves
-    if (ts.isFunctionExpression(node) && node.name && functionScope.referencedSymbols) {
+    if (isNamedFunctionExpression && functionScope.referencedSymbols) {
         const symbol = context.checker.getSymbolAtLocation(node.name);
         if (symbol) {
             // TODO: Not using symbol ids because of https://github.com/microsoft/TypeScript/issues/37131
@@ -304,7 +305,9 @@ export function transformFunctionLikeDeclaration(
         }
     }
 
-    return functionExpression;
+    return isNamedFunctionExpression && isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node))
+        ? createCallableTable(functionExpression)
+        : functionExpression;
 }
 
 export const transformFunctionDeclaration: FunctionVisitor<ts.FunctionDeclaration> = (node, context) => {
diff --git a/src/transformation/visitors/variable-declaration.ts b/src/transformation/visitors/variable-declaration.ts
@@ -261,20 +261,24 @@ export function transformVariableDeclaration(
 
         // Wrap functions being assigned to a type that contains additional properties in a callable table
         // This catches 'const foo = function() {}; foo.bar = "FOOBAR";'
-        const wrappedValue =
-            value &&
-            // Skip named function expressions because they will have been wrapped already
-            !(statement.initializer && ts.isFunctionExpression(statement.initializer) && statement.initializer.name) &&
-            isFunctionTypeWithProperties(context.checker.getTypeAtLocation(statement.name))
-                ? createCallableTable(value)
-                : value;
+        const wrappedValue = value && shouldWrapInitializerInCallableTable() ? createCallableTable(value) : value;
 
         return createLocalOrExportedOrGlobalDeclaration(context, identifierName, wrappedValue, statement);
     } else if (ts.isArrayBindingPattern(statement.name) || ts.isObjectBindingPattern(statement.name)) {
         return transformBindingVariableDeclaration(context, statement.name, statement.initializer);
     } else {
         return assertNever(statement.name);
     }
+
+    function shouldWrapInitializerInCallableTable() {
+        assert(statement.initializer);
+        const initializer = ts.skipOuterExpressions(statement.initializer);
+        // do not wrap if not a function expression
+        if (!ts.isFunctionExpression(initializer) && !ts.isArrowFunction(initializer)) return false;
+        // Skip named function expressions because they will have been wrapped already
+        if (ts.isFunctionExpression(initializer) && initializer.name) return false;
+        return isFunctionTypeWithProperties(context.checker.getTypeAtLocation(statement.name));
+    }
 }
 
 export function checkVariableDeclarationList(context: TransformationContext, node: ts.VariableDeclarationList): void {
diff --git a/test/unit/functions/functionProperties.spec.ts b/test/unit/functions/functionProperties.spec.ts
@@ -60,6 +60,14 @@ test("void function with property assigned to variable", () => {
     `.expectToMatchJsResult();
 });
 
+test("named function with property assigned to variable", () => {
+    util.testFunction`
+        const foo = function baz(s: string) { return s; }
+        foo.bar = "bar";
+        return foo("foo") + foo.bar;
+    `.expectToMatchJsResult();
+});
+
 test("recursively referenced function with property assigned to variable", () => {
     util.testFunction`
         const foo = function(s: string) { return s + foo.bar; };
@@ -173,3 +181,22 @@ test("call function with property using bind method", () => {
         return foo.bind("foo", "bar")() + foo.baz;
     `.expectToMatchJsResult();
 });
+
+// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1196
+test("Does not wrap simple variable declaration", () => {
+    util.testFunction`
+        function foo(s: string) { return s; }
+        foo.bar = "bar";
+        const foo2 = foo;
+        return foo2("foo") + foo2.bar;
+    `.expectToMatchJsResult();
+});
+
+test("Wraps function in inner expression", () => {
+    util.testFunction`
+        type Foo = { (s: string): string; bar: string; }
+        const foo = (s => s)! as Foo
+        foo.bar = "bar";
+        return foo("foo") + foo.bar;
+    `.expectToMatchJsResult();
+});

Original file line number	Diff line number	Diff line change
`@@ -277,8 +277,9 @@ export function transformFunctionLikeDeclaration(`
`277`	`277`
`278`	`278`	`const [functionExpression, functionScope] = transformFunctionToExpression(context, node);`
`279`	`279`
	`280`	`+ const isNamedFunctionExpression = ts.isFunctionExpression(node) && node.name;`
`280`	`281`	`// Handle named function expressions which reference themselves`
`281`		`- if (ts.isFunctionExpression(node) && node.name && functionScope.referencedSymbols) {`
	`282`	`+ if (isNamedFunctionExpression && functionScope.referencedSymbols) {`
`282`	`283`	`const symbol = context.checker.getSymbolAtLocation(node.name);`
`283`	`284`	`if (symbol) {`
`284`	`285`	`// TODO: Not using symbol ids because of https://github.com/microsoft/TypeScript/issues/37131`
`@@ -304,7 +305,9 @@ export function transformFunctionLikeDeclaration(`
`304`	`305`	`}`
`305`	`306`	`}`
`306`	`307`
`307`		`- return functionExpression;`
	`308`	`+ return isNamedFunctionExpression && isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node))`
	`309`	`+ ? createCallableTable(functionExpression)`
	`310`	`+ : functionExpression;`
`308`	`311`	`}`
`309`	`312`
`310`	`313`	`export const transformFunctionDeclaration: FunctionVisitor<ts.FunctionDeclaration> = (node, context) => {`