Fix constructor scope breaking vararg spread optimization (#1675)

Perryvw · web-flow · commit a6230a75ed30 · 2025-12-27T11:47:12.000+01:00
* Fix constructor scope breaking vararg spread optimization

* remove test debug

* fix typo in test name
diff --git a/package-lock.json b/package-lock.json
diff --git a/src/transformation/context/context.ts b/src/transformation/context/context.ts
@@ -247,8 +247,8 @@ export class TransformationContext {
     public readonly scopeStack: Scope[] = [];
     private lastScopeId = 0;
 
-    public pushScope(type: ScopeType): Scope {
-        const scope = { type, id: ++this.lastScopeId };
+    public pushScope(type: ScopeType, node: ts.Node): Scope {
+        const scope: Scope = { type, id: ++this.lastScopeId, node };
         this.scopeStack.push(scope);
         return scope;
     }
diff --git a/src/transformation/utils/scope.ts b/src/transformation/utils/scope.ts
@@ -31,7 +31,7 @@ export enum LoopContinued {
 export interface Scope {
     type: ScopeType;
     id: number;
-    node?: ts.Node;
+    node: ts.Node;
     referencedSymbols?: Map<lua.SymbolId, ts.Node[]>;
     variableDeclarations?: lua.VariableDeclarationStatement[];
     functionDefinitions?: Map<lua.SymbolId, FunctionDefinitionInfo>;
@@ -99,7 +99,7 @@ function isHoistableFunctionDeclaredInScope(symbol: ts.Symbol, scopeNode: ts.Nod
 // Checks for references to local functions which haven't been defined yet,
 // and thus will be hoisted above the current position.
 export function hasReferencedUndefinedLocalFunction(context: TransformationContext, scope: Scope) {
-    if (!scope.referencedSymbols || !scope.node) {
+    if (!scope.referencedSymbols) {
         return false;
     }
     for (const [symbolId, nodes] of scope.referencedSymbols) {
@@ -127,10 +127,6 @@ export function hasReferencedSymbol(context: TransformationContext, scope: Scope
     return false;
 }
 
-export function isFunctionScopeWithDefinition(scope: Scope): scope is Scope & { node: ts.SignatureDeclaration } {
-    return scope.node !== undefined && ts.isFunctionLike(scope.node);
-}
-
 export function separateHoistedStatements(context: TransformationContext, statements: lua.Statement[]): HoistingResult {
     const scope = peekScope(context);
     const allHoistedStatments: lua.Statement[] = [];
diff --git a/src/transformation/visitors/block.ts b/src/transformation/visitors/block.ts
@@ -12,14 +12,14 @@ export function transformScopeBlock(
     node: ts.Block,
     scopeType: ScopeType
 ): [lua.Block, Scope] {
-    context.pushScope(scopeType);
+    context.pushScope(scopeType, node);
     const statements = performHoisting(context, context.transformStatements(node.statements));
     const scope = context.popScope();
     return [lua.createBlock(statements, node), scope];
 }
 
 export const transformBlock: FunctionVisitor<ts.Block> = (node, context) => {
-    context.pushScope(ScopeType.Block);
+    context.pushScope(ScopeType.Block, node);
     const statements = performHoisting(context, context.transformStatements(node.statements));
     context.popScope();
     return lua.createDoStatement(statements, node);
diff --git a/src/transformation/visitors/class/members/accessors.ts b/src/transformation/visitors/class/members/accessors.ts
@@ -15,7 +15,7 @@ function transformAccessor(
     className: lua.Identifier
 ): lua.Expression {
     const [params, dot, restParam] = transformParameters(context, node.parameters, createSelfIdentifier());
-    const body = node.body ? transformFunctionBody(context, node.parameters, node.body, restParam)[0] : [];
+    const body = node.body ? transformFunctionBody(context, node.parameters, node.body, node, restParam)[0] : [];
     const accessorFunction = lua.createFunctionExpression(
         lua.createBlock(body),
         params,
diff --git a/src/transformation/visitors/class/members/constructor.ts b/src/transformation/visitors/class/members/constructor.ts
@@ -28,7 +28,7 @@ export function transformConstructorDeclaration(
     }
 
     // Transform body
-    const scope = context.pushScope(ScopeType.Function);
+    const scope = context.pushScope(ScopeType.Function, statement);
     const body = transformFunctionBodyContent(context, statement.body);
 
     const [params, dotsLiteral, restParamName] = transformParameters(
diff --git a/src/transformation/visitors/conditional.ts b/src/transformation/visitors/conditional.ts
@@ -76,7 +76,7 @@ export const transformConditionalExpression: FunctionVisitor<ts.ConditionalExpre
 };
 
 export function transformIfStatement(statement: ts.IfStatement, context: TransformationContext): lua.IfStatement {
-    context.pushScope(ScopeType.Conditional);
+    context.pushScope(ScopeType.Conditional, statement);
 
     // Check if we need to add diagnostic about Lua truthiness
     checkOnlyTruthyCondition(statement.expression, context);
@@ -107,7 +107,7 @@ export function transformIfStatement(statement: ts.IfStatement, context: Transfo
                 return lua.createIfStatement(condition, ifBlock, elseStatement);
             }
         } else {
-            context.pushScope(ScopeType.Conditional);
+            context.pushScope(ScopeType.Conditional, statement);
             const elseStatements = performHoisting(
                 context,
                 transformBlockOrStatement(context, statement.elseStatement)
diff --git a/src/transformation/visitors/function.ts b/src/transformation/visitors/function.ts
@@ -164,11 +164,10 @@ export function transformFunctionBody(
     context: TransformationContext,
     parameters: ts.NodeArray<ts.ParameterDeclaration>,
     body: ts.ConciseBody,
-    spreadIdentifier?: lua.Identifier,
-    node?: ts.FunctionLikeDeclaration
+    node: ts.FunctionLikeDeclaration,
+    spreadIdentifier?: lua.Identifier
 ): [lua.Statement[], Scope] {
-    const scope = context.pushScope(ScopeType.Function);
-    scope.node = node;
+    const scope = context.pushScope(ScopeType.Function, node);
     let bodyStatements = transformFunctionBodyContent(context, body);
     if (node && isAsyncFunction(node)) {
         bodyStatements = [lua.createReturnStatement([wrapInAsyncAwaiter(context, bodyStatements)])];
@@ -258,8 +257,8 @@ export function transformFunctionToExpression(
         context,
         node.parameters,
         node.body,
-        spreadIdentifier,
-        node
+        node,
+        spreadIdentifier
     );
 
     const functionExpression = lua.createFunctionExpression(
diff --git a/src/transformation/visitors/loops/for.ts b/src/transformation/visitors/loops/for.ts
@@ -9,7 +9,7 @@ import { ScopeType } from "../../utils/scope";
 export const transformForStatement: FunctionVisitor<ts.ForStatement> = (statement, context) => {
     const result: lua.Statement[] = [];
 
-    context.pushScope(ScopeType.Loop);
+    context.pushScope(ScopeType.Loop, statement);
 
     if (statement.initializer) {
         if (ts.isVariableDeclarationList(statement.initializer)) {
diff --git a/src/transformation/visitors/loops/utils.ts b/src/transformation/visitors/loops/utils.ts
@@ -14,7 +14,7 @@ export function transformLoopBody(
     context: TransformationContext,
     loop: ts.WhileStatement | ts.DoStatement | ts.ForStatement | ts.ForOfStatement | ts.ForInOrOfStatement
 ): lua.Statement[] {
-    context.pushScope(ScopeType.Loop);
+    context.pushScope(ScopeType.Loop, loop);
     const body = performHoisting(context, transformBlockOrStatement(context, loop.statement));
     const scope = context.popScope();
     const scopeId = scope.id;
@@ -79,7 +79,7 @@ export function transformForInitializer(
 ): lua.Identifier {
     const valueVariable = lua.createIdentifier("____value");
 
-    context.pushScope(ScopeType.LoopInitializer);
+    context.pushScope(ScopeType.LoopInitializer, initializer);
 
     if (ts.isVariableDeclarationList(initializer)) {
         // Declaration of new variable
diff --git a/src/transformation/visitors/namespace.ts b/src/transformation/visitors/namespace.ts
@@ -118,7 +118,7 @@ export const transformModuleDeclaration: FunctionVisitor<ts.ModuleDeclaration> =
 
     // Transform moduleblock to block and visit it
     if (moduleHasEmittedBody(node)) {
-        context.pushScope(ScopeType.Block);
+        context.pushScope(ScopeType.Block, node);
         const statements = performHoisting(
             context,
             context.transformStatements(ts.isModuleBlock(node.body) ? node.body.statements : node.body)
diff --git a/src/transformation/visitors/sourceFile.ts b/src/transformation/visitors/sourceFile.ts
@@ -26,7 +26,7 @@ export const transformSourceFileNode: FunctionVisitor<ts.SourceFile> = (node, co
             statements.push(lua.createExpressionStatement(errorCall));
         }
     } else {
-        context.pushScope(ScopeType.File);
+        context.pushScope(ScopeType.File, node);
 
         statements = performHoisting(context, context.transformStatements(node.statements));
         context.popScope();
diff --git a/src/transformation/visitors/spread.ts b/src/transformation/visitors/spread.ts
@@ -6,13 +6,7 @@ import { FunctionVisitor, TransformationContext } from "../context";
 import { getIterableExtensionKindForNode, IterableExtensionKind } from "../utils/language-extensions";
 import { createUnpackCall } from "../utils/lua-ast";
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
-import {
-    findScope,
-    hasReferencedSymbol,
-    hasReferencedUndefinedLocalFunction,
-    isFunctionScopeWithDefinition,
-    ScopeType,
-} from "../utils/scope";
+import { findScope, hasReferencedSymbol, hasReferencedUndefinedLocalFunction, ScopeType } from "../utils/scope";
 import { findFirstNonOuterParent, isAlwaysArrayType } from "../utils/typescript";
 import { isMultiReturnCall } from "./language-extensions/multi";
 import { isGlobalVarargConstant } from "./language-extensions/vararg";
@@ -34,7 +28,7 @@ export function isOptimizedVarArgSpread(context: TransformationContext, symbol:
     }
 
     // Scope must be a function scope associated with a real ts function
-    if (!isFunctionScopeWithDefinition(scope)) {
+    if (!ts.isFunctionLike(scope.node)) {
         return false;
     }
 
diff --git a/src/transformation/visitors/switch.ts b/src/transformation/visitors/switch.ts
@@ -73,7 +73,7 @@ const coalesceCondition = (
 };
 
 export const transformSwitchStatement: FunctionVisitor<ts.SwitchStatement> = (statement, context) => {
-    const scope = context.pushScope(ScopeType.Switch);
+    const scope = context.pushScope(ScopeType.Switch, statement);
 
     // Give the switch and condition accumulator a unique name to prevent nested switches from acting up.
     const switchName = `____switch${scope.id}`;
diff --git a/test/unit/classes/classes.spec.ts b/test/unit/classes/classes.spec.ts
@@ -909,3 +909,15 @@ test("get inherted __index member from super (DotA 2 inheritance) (#1537)", () =
         )
         .expectToEqual("foo");
 });
+
+// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1673
+test("vararg spread optimization in class constructor (#1673)", () => {
+    const lua = util.testModule`
+        class C {
+            constructor(...args: any[]) {
+                console.log(...args);
+            }
+        }`.getMainLuaCodeChunk();
+
+    expect(lua).not.toContain("table.unpack");
+});

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ export function transformConstructorDeclaration(`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`// Transform body`
`31`		`- const scope = context.pushScope(ScopeType.Function);`
	`31`	`+ const scope = context.pushScope(ScopeType.Function, statement);`
`32`	`32`	`const body = transformFunctionBodyContent(context, statement.body);`
`33`	`33`
`34`	`34`	`const [params, dotsLiteral, restParamName] = transformParameters(`