Implement support for void expression (#1148)

Perryvw · web-flow · commit 8f70f506f18c · 2021-10-26T19:41:04.000+02:00
* Implement support for void expression

* PR feedback
diff --git a/src/transformation/utils/diagnostics.ts b/src/transformation/utils/diagnostics.ts
@@ -10,9 +10,9 @@ const createDiagnosticFactory = <TArgs extends any[]>(
     message: MessageProvider<TArgs>
 ) =>
     createSerialDiagnosticFactory((node: ts.Node, ...args: TArgs) => ({
-        file: node.getSourceFile(),
-        start: node.getStart(),
-        length: node.getWidth(),
+        file: ts.getOriginalNode(node).getSourceFile(),
+        start: ts.getOriginalNode(node).getStart(),
+        length: ts.getOriginalNode(node).getWidth(),
         messageText: typeof message === "string" ? message : message(...args),
         category,
     }));
diff --git a/src/transformation/visitors/expression-statement.ts b/src/transformation/visitors/expression-statement.ts
@@ -9,6 +9,7 @@ import {
     transformTableSetExpression,
 } from "./language-extensions/table";
 import { transformUnaryExpressionStatement } from "./unary-expression";
+import { transformVoidExpressionStatement } from "./void";
 
 export const transformExpressionStatement: FunctionVisitor<ts.ExpressionStatement> = (node, context) => {
     const expression = node.expression;
@@ -21,6 +22,10 @@ export const transformExpressionStatement: FunctionVisitor<ts.ExpressionStatemen
         return transformTableSetExpression(context, expression);
     }
 
+    if (ts.isVoidExpression(expression)) {
+        return transformVoidExpressionStatement(expression, context);
+    }
+
     const unaryExpressionResult = transformUnaryExpressionStatement(context, node);
     if (unaryExpressionResult) {
         return unaryExpressionResult;
diff --git a/src/transformation/visitors/index.ts b/src/transformation/visitors/index.ts
@@ -41,6 +41,7 @@ import { typescriptVisitors } from "./typescript";
 import { transformPostfixUnaryExpression, transformPrefixUnaryExpression } from "./unary-expression";
 import { transformVariableStatement } from "./variable-declaration";
 import { transformAwaitExpression } from "./async-await";
+import { transformVoidExpression } from "./void";
 
 const transformEmptyStatement: FunctionVisitor<ts.EmptyStatement> = () => undefined;
 const transformParenthesizedExpression: FunctionVisitor<ts.ParenthesizedExpression> = (node, context) =>
@@ -98,4 +99,5 @@ export const standardVisitors: Visitors = {
     [ts.SyntaxKind.VariableStatement]: transformVariableStatement,
     [ts.SyntaxKind.WhileStatement]: transformWhileStatement,
     [ts.SyntaxKind.YieldExpression]: transformYieldExpression,
+    [ts.SyntaxKind.VoidExpression]: transformVoidExpression,
 };
diff --git a/src/transformation/visitors/void.ts b/src/transformation/visitors/void.ts
@@ -0,0 +1,33 @@
+import * as ts from "typescript";
+import * as lua from "../../LuaAST";
+import { TransformationContext } from "../context";
+import { FunctionVisitor } from "../context/visitors";
+import { createImmediatelyInvokedFunctionExpression } from "../utils/lua-ast";
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void
+export const transformVoidExpression: FunctionVisitor<ts.VoidExpression> = (node, context) => {
+    // If content is a literal it is safe to replace the entire expression with nil
+    if (ts.isLiteralExpression(node.expression)) {
+        return lua.createNilLiteral(node);
+    }
+
+    // (function() local ____ = <expression> end)()
+    return createImmediatelyInvokedFunctionExpression(
+        [
+            lua.createVariableDeclarationStatement(
+                lua.createAnonymousIdentifier(),
+                context.transformExpression(node.expression)
+            ),
+        ],
+        [],
+        node
+    );
+};
+
+export const transformVoidExpressionStatement = (node: ts.VoidExpression, context: TransformationContext) =>
+    // In case of a void expression statement we can omit the IIFE
+    lua.createVariableDeclarationStatement(
+        lua.createAnonymousIdentifier(),
+        context.transformExpression(node.expression),
+        node
+    );
diff --git a/src/transpilation/transformers.ts b/src/transpilation/transformers.ts
@@ -71,6 +71,8 @@ export const stripParenthesisExpressionsTransformer: ts.TransformerFactory<ts.So
                 node.typeArguments,
                 node.arguments
             );
+        } else if (ts.isVoidExpression(node)) {
+            return ts.factory.updateVoidExpression(node, unwrapParentheses(node.expression));
         }
 
         return ts.visitEachChild(node, visit, context);
diff --git a/test/unit/void.spec.ts b/test/unit/void.spec.ts
@@ -0,0 +1,34 @@
+import * as util from "../util";
+
+test.each(["0", "1", '"a"'])("void evaluates to undefined (%p)", value => {
+    util.testExpression`void (${value})`.expectToMatchJsResult();
+});
+
+test("void applies to function declarations", () => {
+    util.testFunction`
+        let result = 0;
+        void function setResult() {
+            result = 1;
+        }();
+        return result;
+    `.expectToMatchJsResult();
+});
+
+test("void used to ignore function return values", () => {
+    util.testFunction`
+        let result = 0;
+        function setResult() {
+            result = 1;
+            return 3
+        };
+
+        void(setResult());
+
+        return result;
+    `.expectToMatchJsResult();
+});
+
+// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1102
+test("void works with lambdas", () => {
+    util.testExpression`void (() => {})()`.expectToMatchJsResult();
+});

Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,8 @@ export const stripParenthesisExpressionsTransformer: ts.TransformerFactory<ts.So`
`71`	`71`	`node.typeArguments,`
`72`	`72`	`node.arguments`
`73`	`73`	`);`
	`74`	`+ } else if (ts.isVoidExpression(node)) {`
	`75`	`+ return ts.factory.updateVoidExpression(node, unwrapParentheses(node.expression));`
`74`	`76`	`}`
`75`	`77`
`76`	`78`	`return ts.visitEachChild(node, visit, context);`