Fix optimized vararg spread with casts (#1193)

GlassBricks · web-flow · commit c8d8c73d1376 · 2021-12-21T22:19:26.000+01:00
Also fixes for other outer expressions.
diff --git a/src/transformation/visitors/spread.ts b/src/transformation/visitors/spread.ts
@@ -16,8 +16,15 @@ import { isMultiReturnCall } from "./language-extensions/multi";
 import { annotationRemoved } from "../utils/diagnostics";
 import { isGlobalVarargConstant } from "./language-extensions/vararg";
 
+function skipOuterExpressionParents(node: ts.Node) {
+    while (ts.isOuterExpression(node)) {
+        node = node.parent;
+    }
+    return node;
+}
+
 export function isOptimizedVarArgSpread(context: TransformationContext, symbol: ts.Symbol, identifier: ts.Identifier) {
-    if (!ts.isSpreadElement(identifier.parent)) {
+    if (!ts.isSpreadElement(skipOuterExpressionParents(identifier.parent))) {
         return false;
     }
 
@@ -63,20 +70,21 @@ export function isOptimizedVarArgSpread(context: TransformationContext, symbol:
 
 // TODO: Currently it's also used as an array member
 export const transformSpreadElement: FunctionVisitor<ts.SpreadElement> = (node, context) => {
-    if (ts.isIdentifier(node.expression)) {
-        if (isVarargType(context, node.expression)) {
+    const tsInnerExpression = ts.skipOuterExpressions(node.expression);
+    if (ts.isIdentifier(tsInnerExpression)) {
+        if (isVarargType(context, tsInnerExpression)) {
             context.diagnostics.push(annotationRemoved(node, AnnotationKind.Vararg));
         }
-        const symbol = context.checker.getSymbolAtLocation(node.expression);
-        if (symbol && isOptimizedVarArgSpread(context, symbol, node.expression)) {
+        const symbol = context.checker.getSymbolAtLocation(tsInnerExpression);
+        if (symbol && isOptimizedVarArgSpread(context, symbol, tsInnerExpression)) {
             return lua.createDotsLiteral(node);
         }
     }
 
     const innerExpression = context.transformExpression(node.expression);
-    if (isMultiReturnCall(context, node.expression)) return innerExpression;
+    if (isMultiReturnCall(context, tsInnerExpression)) return innerExpression;
 
-    const type = context.checker.getTypeAtLocation(node.expression);
+    const type = context.checker.getTypeAtLocation(node.expression); // not ts-inner expression, in case of casts
     if (isArrayType(context, type)) {
         return createUnpackCall(context, innerExpression, node);
     }
diff --git a/src/typescript-internal.d.ts b/src/typescript-internal.d.ts
@@ -1,5 +1,4 @@
 import { DiagnosticsProducingTypeChecker } from "./transformation/context";
-
 export {};
 
 declare module "typescript" {
@@ -31,6 +30,13 @@ declare module "typescript" {
 
     function transformJsx(context: TransformationContext): (x: SourceFile) => SourceFile;
 
-    function skipParentheses(node: Expression): Expression;
-    function skipParentheses(node: Node): Node;
+    export type OuterExpression =
+        | ParenthesizedExpression
+        | TypeAssertion
+        | AsExpression
+        | NonNullExpression
+        | PartiallyEmittedExpression;
+
+    function skipOuterExpressions(node: Expression, kinds?: OuterExpressionKinds): Expression;
+    export function isOuterExpression(node: Node, kinds?: OuterExpressionKinds): node is OuterExpression;
 }
diff --git a/test/unit/__snapshots__/spread.spec.ts.snap b/test/unit/__snapshots__/spread.spec.ts.snap
@@ -17,6 +17,21 @@ end
 return ____exports"
 `;
 
+exports[`vararg spread optimization With cast 1`] = `
+"local ____exports = {}
+function ____exports.__main(self)
+    local function pick(self, ...)
+        local args = {...}
+        return args[2]
+    end
+    local function test(self, ...)
+        return pick(nil, ...)
+    end
+    return test(nil, \\"a\\", \\"b\\", \\"c\\")
+end
+return ____exports"
+`;
+
 exports[`vararg spread optimization basic use 1`] = `
 "local ____exports = {}
 function ____exports.__main(self)
diff --git a/test/unit/spread.spec.ts b/test/unit/spread.spec.ts
@@ -265,6 +265,18 @@ describe("vararg spread optimization", () => {
             .expectLuaToMatchSnapshot()
             .expectToMatchJsResult();
     });
+
+    test("With cast", () => {
+        util.testFunction`
+            function pick(...args: any[]) { return args[1]; }
+            function test<F extends (...args: any)=>any>(...args: Parameters<F>) {
+                return pick(...(args as any[]));
+            }
+            return test<(...args: string[])=>void>("a", "b", "c");
+        `
+            .expectLuaToMatchSnapshot()
+            .expectToMatchJsResult();
+    });
 });
 
 describe("vararg spread de-optimization", () => {
