TypeScriptToLua · Perryvw · Dec 23, 2020 · Jan 4, 2020 · Jan 9, 2020 · Jan 9, 2020
diff --git a/language-extensions/index.d.ts b/language-extensions/index.d.ts
@@ -0,0 +1,2 @@
+declare function $multi<T extends any[]>(...values: T): MultiReturn<T>;
+declare type MultiReturn<T extends any[]> = T & { readonly " __multiBrand": unique symbol };
diff --git a/package.json b/package.json
@@ -13,7 +13,8 @@
     "files": [
         "dist/**/*.js",
         "dist/**/*.lua",
-        "dist/**/*.ts"
+        "dist/**/*.ts",
+        "language-extensions/**/*.ts"
     ],
     "main": "dist/index.js",
     "types": "dist/index.d.ts",

diff --git a/src/lualib/tsconfig.json b/src/lualib/tsconfig.json
@@ -3,7 +3,7 @@
         "outDir": "../../dist/lualib",
         "target": "esnext",
         "lib": ["esnext"],
-        "types": [],
+        "types": ["../../language-extensions"],
         "skipLibCheck": true,
 
         "noUnusedLocals": true,

diff --git a/src/transformation/utils/diagnostics.ts b/src/transformation/utils/diagnostics.ts
@@ -142,6 +142,32 @@ export const unsupportedVarDeclaration = createErrorDiagnosticFactory(
     "`var` declarations are not supported. Use `let` or `const` instead."
 );
 
+export const invalidMultiFunctionUse = createErrorDiagnosticFactory(
+    "The $multi function must be called in an expression that is returned."
+);
+
+export const invalidMultiTypeToNonArrayBindingPattern = createErrorDiagnosticFactory(
+    "Expected an array destructuring pattern."
+);
+
+export const invalidMultiTypeToNonArrayLiteral = createErrorDiagnosticFactory("Expected an array literal.");
+
+export const invalidMultiTypeToEmptyPatternOrArrayLiteral = createErrorDiagnosticFactory(
+    "There must be one or more elements specified here."
+);
+
+export const invalidMultiTypeArrayBindingPatternElementInitializer = createErrorDiagnosticFactory(
+    "This array binding pattern cannot have initializers."
+);
+
+export const invalidMultiTypeArrayLiteralElementInitializer = createErrorDiagnosticFactory(
+    "This array literal pattern cannot have initializers."
+);
+
+export const unsupportedMultiFunctionAssignment = createErrorDiagnosticFactory(
+    "Omitted expressions and BindingElements are expected here."
+);
+
 export const annotationDeprecated = createWarningDiagnosticFactory(
     (kind: AnnotationKind) =>
         `'@${kind}' is deprecated and will be removed in a future update. Please update your code before upgrading to the next release, otherwise your project will no longer compile. ` +

diff --git a/src/transformation/utils/language-extensions.ts b/src/transformation/utils/language-extensions.ts
@@ -0,0 +1,28 @@
+import * as ts from "typescript";
+import * as path from "path";
+
+export enum ExtensionKind {
+    MultiFunction = "MultiFunction",
+    MultiType = "MultiType",
+}
+
+function isSourceFileFromLanguageExtensions(sourceFile: ts.SourceFile): boolean {
+    const extensionDirectory = path.resolve(__dirname, "../../../language-extensions");
+    const sourceFileDirectory = path.dirname(path.normalize(sourceFile.fileName));
+    return extensionDirectory === sourceFileDirectory;
+}
+
+export function getExtensionKind(declaration: ts.Declaration): ExtensionKind | undefined {
+    const sourceFile = declaration.getSourceFile();
+    if (isSourceFileFromLanguageExtensions(sourceFile)) {
+        if (ts.isFunctionDeclaration(declaration) && declaration?.name?.text === "$multi") {
+            return ExtensionKind.MultiFunction;
+        }
+
+        if (ts.isTypeAliasDeclaration(declaration) && declaration.name.text === "MultiReturn") {
+            return ExtensionKind.MultiType;
+        }
+
+        throw new Error("Unknown extension kind");
+    }
+}
diff --git a/src/transformation/visitors/call.ts b/src/transformation/visitors/call.ts
@@ -11,6 +11,7 @@ import { isValidLuaIdentifier } from "../utils/safe-names";
 import { isArrayType, isExpressionWithEvaluationEffect, isInDestructingAssignment } from "../utils/typescript";
 import { transformElementAccessArgument } from "./access";
 import { transformLuaTableCallExpression } from "./lua-table";
+import { returnsMultiType } from "./language-extensions/multi";
 
 export type PropertyCallExpression = ts.CallExpression & { expression: ts.PropertyAccessExpression };
 
@@ -250,9 +251,8 @@ export const transformCallExpression: FunctionVisitor<ts.CallExpression> = (node
 // TODO: Currently it's also used as an array member
 export const transformSpreadElement: FunctionVisitor<ts.SpreadElement> = (node, context) => {
     const innerExpression = context.transformExpression(node.expression);
-    if (isTupleReturnCall(context, node.expression)) {
-        return innerExpression;
-    }
+    if (isTupleReturnCall(context, node.expression)) return innerExpression;
+    if (ts.isCallExpression(node.expression) && returnsMultiType(context, node.expression)) return innerExpression;
 
     if (ts.isIdentifier(node.expression) && isVarargType(context, node.expression)) {
         return lua.createDotsLiteral(node);

diff --git a/src/transformation/visitors/expression-statement.ts b/src/transformation/visitors/expression-statement.ts
@@ -4,8 +4,18 @@ import { FunctionVisitor } from "../context";
 import { transformBinaryExpressionStatement } from "./binary-expression";
 import { transformLuaTableExpressionStatement } from "./lua-table";
 import { transformUnaryExpressionStatement } from "./unary-expression";
+import { returnsMultiType, transformMultiDestructuringAssignmentStatement } from "./language-extensions/multi";
 
 export const transformExpressionStatement: FunctionVisitor<ts.ExpressionStatement> = (node, context) => {
+    if (
+        ts.isBinaryExpression(node.expression) &&
+        node.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        ts.isCallExpression(node.expression.right) &&
+        returnsMultiType(context, node.expression.right)
+    ) {
+        return transformMultiDestructuringAssignmentStatement(context, node);
+    }
+
     const luaTableResult = transformLuaTableExpressionStatement(context, node);
     if (luaTableResult) {
         return luaTableResult;

diff --git a/src/transformation/visitors/function.ts b/src/transformation/visitors/function.ts
@@ -15,6 +15,7 @@ import {
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
 import { peekScope, performHoisting, popScope, pushScope, Scope, ScopeType } from "../utils/scope";
 import { transformIdentifier } from "./identifier";
+import { isMultiFunction, transformMultiCallExpressionToReturnStatement } from "./language-extensions/multi";
 import { transformExpressionBodyToReturnStatement } from "./return";
 import { transformBindingPattern } from "./variable-declaration";
 
@@ -55,6 +56,10 @@ function isRestParameterReferenced(context: TransformationContext, identifier: l
 
 export function transformFunctionBodyContent(context: TransformationContext, body: ts.ConciseBody): lua.Statement[] {
     if (!ts.isBlock(body)) {
+        if (ts.isCallExpression(body) && isMultiFunction(context, body)) {
+            return [transformMultiCallExpressionToReturnStatement(context, body)];
+        }
+
         const returnStatement = transformExpressionBodyToReturnStatement(context, body);
         return [returnStatement];
     }

diff --git a/src/transformation/visitors/identifier.ts b/src/transformation/visitors/identifier.ts
@@ -3,13 +3,19 @@ import * as lua from "../../LuaAST";
 import { transformBuiltinIdentifierExpression } from "../builtins";
 import { FunctionVisitor, TransformationContext } from "../context";
 import { isForRangeType } from "../utils/annotations";
-import { invalidForRangeCall } from "../utils/diagnostics";
+import { invalidForRangeCall, invalidMultiFunctionUse } from "../utils/diagnostics";
 import { createExportedIdentifier, getSymbolExportScope } from "../utils/export";
 import { createSafeName, hasUnsafeIdentifierName } from "../utils/safe-names";
 import { getIdentifierSymbolId } from "../utils/symbols";
 import { findFirstNodeAbove } from "../utils/typescript";
+import { isMultiFunctionNode } from "./language-extensions/multi";
 
 export function transformIdentifier(context: TransformationContext, identifier: ts.Identifier): lua.Identifier {
+    if (isMultiFunctionNode(context, identifier)) {
+        context.diagnostics.push(invalidMultiFunctionUse(identifier));
+        return lua.createAnonymousIdentifier(identifier);
+    }
+
     if (isForRangeType(context, identifier)) {
         const callExpression = findFirstNodeAbove(identifier, ts.isCallExpression);
         if (!callExpression || !callExpression.parent || !ts.isForOfStatement(callExpression.parent)) {

diff --git a/src/transformation/visitors/language-extensions/multi.ts b/src/transformation/visitors/language-extensions/multi.ts
@@ -0,0 +1,188 @@
+import * as ts from "typescript";
+import * as lua from "../../../LuaAST";
+import * as extensions from "../../utils/language-extensions";
+import { TransformationContext } from "../../context";
+import { transformAssignmentLeftHandSideExpression } from "../binary-expression/assignments";
+import { transformIdentifier } from "../identifier";
+import { transformArguments } from "../call";
+import { getDependenciesOfSymbol, createExportedIdentifier } from "../../utils/export";
+import { createLocalOrExportedOrGlobalDeclaration } from "../../utils/lua-ast";
+import {
+    invalidMultiTypeArrayBindingPatternElementInitializer,
+    invalidMultiTypeArrayLiteralElementInitializer,
+    invalidMultiTypeToEmptyPatternOrArrayLiteral,
+    invalidMultiTypeToNonArrayBindingPattern,
+    invalidMultiTypeToNonArrayLiteral,
+    unsupportedMultiFunctionAssignment,
+    invalidMultiFunctionUse,
+} from "../../utils/diagnostics";
+import { assert } from "../../../utils";
+
+const isMultiFunctionDeclaration = (declaration: ts.Declaration): boolean =>
+    extensions.getExtensionKind(declaration) === extensions.ExtensionKind.MultiFunction;
+
+const isMultiTypeDeclaration = (declaration: ts.Declaration): boolean =>
+    extensions.getExtensionKind(declaration) === extensions.ExtensionKind.MultiType;
+
+export function isMultiFunction(context: TransformationContext, expression: ts.CallExpression): boolean {
+    const type = context.checker.getTypeAtLocation(expression.expression);
+    return type.symbol?.declarations?.some(isMultiFunctionDeclaration) ?? false;
+}
+
+export function returnsMultiType(context: TransformationContext, node: ts.CallExpression): boolean {
+    const signature = context.checker.getResolvedSignature(node);
+    return signature?.getReturnType().aliasSymbol?.declarations?.some(isMultiTypeDeclaration) ?? false;
+}
+
+export function isMultiFunctionNode(context: TransformationContext, node: ts.Node): boolean {
+    const type = context.checker.getTypeAtLocation(node);
+    return type.symbol?.declarations?.some(isMultiFunctionDeclaration) ?? false;
+}
+
+export function transformMultiCallExpressionToReturnStatement(
+    context: TransformationContext,
+    expression: ts.Expression
+): lua.Statement {
+    assert(ts.isCallExpression(expression));
+
+    const expressions = transformArguments(context, expression.arguments);
+    return lua.createReturnStatement(expressions, expression);
+}
+
+export function transformMultiReturnStatement(
+    context: TransformationContext,
+    statement: ts.ReturnStatement
+): lua.Statement {
+    assert(statement.expression);
+
+    return transformMultiCallExpressionToReturnStatement(context, statement.expression);
+}
+
+function transformMultiFunctionArguments(
+    context: TransformationContext,
+    expression: ts.CallExpression
+): lua.Expression[] | lua.Expression {
+    if (!isMultiFunction(context, expression)) {
+        return context.transformExpression(expression);
+    }
+
+    if (expression.arguments.length === 0) {
+        return lua.createNilLiteral(expression);
+    }
+
+    return expression.arguments.map(e => context.transformExpression(e));
+}
+
+export function transformMultiVariableDeclaration(
+    context: TransformationContext,
+    declaration: ts.VariableDeclaration
+): lua.Statement[] {
+    assert(declaration.initializer);
+    assert(ts.isCallExpression(declaration.initializer));
+
+    if (!ts.isArrayBindingPattern(declaration.name)) {
+        context.diagnostics.push(invalidMultiTypeToNonArrayBindingPattern(declaration.name));
+        return [];
+    }
+
+    if (declaration.name.elements.length < 1) {
+        context.diagnostics.push(invalidMultiTypeToEmptyPatternOrArrayLiteral(declaration.name));
+        return [];
+    }
+
+    if (declaration.name.elements.some(e => ts.isBindingElement(e) && e.initializer)) {
+        context.diagnostics.push(invalidMultiTypeArrayBindingPatternElementInitializer(declaration.name));
+        return [];
+    }
+
+    if (isMultiFunction(context, declaration.initializer)) {
+        context.diagnostics.push(invalidMultiFunctionUse(declaration.initializer));
+        return [];
+    }
+
+    const leftIdentifiers: lua.Identifier[] = [];
+
+    for (const element of declaration.name.elements) {
+        if (ts.isBindingElement(element)) {
+            if (ts.isIdentifier(element.name)) {
+                leftIdentifiers.push(transformIdentifier(context, element.name));
+            } else {
+                context.diagnostics.push(unsupportedMultiFunctionAssignment(element));
+            }
+        } else if (ts.isOmittedExpression(element)) {
+            leftIdentifiers.push(lua.createAnonymousIdentifier(element));
+        }
+    }
+
+    const rightExpressions = transformMultiFunctionArguments(context, declaration.initializer);
+    return createLocalOrExportedOrGlobalDeclaration(context, leftIdentifiers, rightExpressions, declaration);
+}
+
+export function transformMultiDestructuringAssignmentStatement(
+    context: TransformationContext,
+    statement: ts.ExpressionStatement
+): lua.Statement[] | undefined {
+    assert(ts.isBinaryExpression(statement.expression));
+    assert(ts.isCallExpression(statement.expression.right));
+
+    if (!ts.isArrayLiteralExpression(statement.expression.left)) {
+        context.diagnostics.push(invalidMultiTypeToNonArrayLiteral(statement.expression.left));
+        return [];
+    }
+
+    if (statement.expression.left.elements.some(ts.isBinaryExpression)) {
+        context.diagnostics.push(invalidMultiTypeArrayLiteralElementInitializer(statement.expression.left));
+        return [];
+    }
+
+    if (statement.expression.left.elements.length < 1) {
+        context.diagnostics.push(invalidMultiTypeToEmptyPatternOrArrayLiteral(statement.expression.left));
+        return [];
+    }
+
+    if (isMultiFunction(context, statement.expression.right)) {
+        context.diagnostics.push(invalidMultiFunctionUse(statement.expression.right));
+        return [];
+    }
+
+    const transformLeft = (expression: ts.Expression): lua.AssignmentLeftHandSideExpression =>
+        ts.isOmittedExpression(expression)
+            ? lua.createAnonymousIdentifier(expression)
+            : transformAssignmentLeftHandSideExpression(context, expression);
+
+    const leftIdentifiers = statement.expression.left.elements.map(transformLeft);
+
+    const rightExpressions = transformMultiFunctionArguments(context, statement.expression.right);
+
+    const trailingStatements = statement.expression.left.elements.flatMap(expression => {
+        const symbol = context.checker.getSymbolAtLocation(expression);
+        const dependentSymbols = symbol ? getDependenciesOfSymbol(context, symbol) : [];
+        return dependentSymbols.map(symbol => {
+            const identifierToAssign = createExportedIdentifier(context, lua.createIdentifier(symbol.name));
+            return lua.createAssignmentStatement(identifierToAssign, transformLeft(expression));
+        });
+    });
+
+    return [lua.createAssignmentStatement(leftIdentifiers, rightExpressions, statement), ...trailingStatements];
+}
+
+export function findMultiAssignmentViolations(
+    context: TransformationContext,
+    node: ts.ObjectLiteralExpression
+): ts.Node[] {
+    const result: ts.Node[] = [];
+
+    for (const element of node.properties) {
+        if (!ts.isShorthandPropertyAssignment(element)) continue;
+        const valueSymbol = context.checker.getShorthandAssignmentValueSymbol(element);
+        if (valueSymbol) {
+            const declaration = valueSymbol.valueDeclaration;
+            if (declaration && isMultiFunctionDeclaration(declaration)) {
+                context.diagnostics.push(invalidMultiFunctionUse(element));
+                result.push(element);
+            }
+        }
+    }
+
+    return result;
+}
diff --git a/src/transformation/visitors/literal.ts b/src/transformation/visitors/literal.ts
@@ -2,14 +2,15 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { assertNever } from "../../utils";
 import { FunctionVisitor, TransformationContext, Visitors } from "../context";
-import { unsupportedAccessorInObjectLiteral } from "../utils/diagnostics";
+import { unsupportedAccessorInObjectLiteral, invalidMultiFunctionUse } from "../utils/diagnostics";
 import { createExportedIdentifier, getSymbolExportScope } from "../utils/export";
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
 import { createSafeName, hasUnsafeIdentifierName, hasUnsafeSymbolName } from "../utils/safe-names";
 import { getSymbolIdOfSymbol, trackSymbolReference } from "../utils/symbols";
 import { isArrayType } from "../utils/typescript";
 import { transformFunctionLikeDeclaration } from "./function";
 import { flattenSpreadExpressions } from "./call";
+import { findMultiAssignmentViolations } from "./language-extensions/multi";
 
 // TODO: Move to object-literal.ts?
 export function transformPropertyName(context: TransformationContext, node: ts.PropertyName): lua.Expression {
@@ -62,6 +63,12 @@ const transformNumericLiteralExpression: FunctionVisitor<ts.NumericLiteral> = ex
 };
 
 const transformObjectLiteralExpression: FunctionVisitor<ts.ObjectLiteralExpression> = (expression, context) => {
+    const violations = findMultiAssignmentViolations(context, expression);
+    if (violations.length > 0) {
+        context.diagnostics.push(...violations.map(e => invalidMultiFunctionUse(e)));
+        return lua.createNilLiteral(expression);
+    }
+
     let properties: lua.TableFieldExpression[] = [];
     const tableExpressions: lua.Expression[] = [];
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		declare function $multi<T extends any[]>(...values: T): MultiReturn<T>;
		declare type MultiReturn<T extends any[]> = T & { readonly " __multiBrand": unique symbol };