typescript-to-lua 1.4.4 → 1.6.1

package/dist/transformation/visitors/call.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCallExpression = exports.transformContextualCallExpression = exports.transformCallAndArguments = exports.transformArguments = exports.validateArguments = void 0;
+exports.getCalledExpression = exports.transformCallExpression = exports.transformContextualCallExpression = exports.transformCallAndArguments = exports.transformArguments = exports.validateArguments = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
@@ -82,7 +82,7 @@ function transformContextualCallExpression(context, node, args, signature) {
     if (ts.isOptionalChain(node)) {
         return (0, optional_chaining_1.transformOptionalChain)(context, node);
     }
-    const left = ts.isCallExpression(node) ? node.expression : node.tag;
+    const left = ts.isCallExpression(node) ? getCalledExpression(node) : node.tag;
     let [argPrecedingStatements, transformedArguments] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, args, signature));
     if (ts.isPropertyAccessExpression(left) &&
         ts.isIdentifier(left.name) &&
@@ -113,9 +113,9 @@ function transformContextualCallExpression(context, node, args, signature) {
     }
 }
 exports.transformContextualCallExpression = transformContextualCallExpression;
-function transformPropertyCall(context, node) {
+function transformPropertyCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
-    if (node.expression.expression.kind === ts.SyntaxKind.SuperKeyword) {
+    if (calledMethod.expression.kind === ts.SyntaxKind.SuperKeyword) {
         // Super calls take the format of super.call(self,...)
         const parameters = transformArguments(context, node.arguments, signature, ts.factory.createThis());
         return lua.createCallExpression(context.transformExpression(node.expression), parameters);
@@ -146,14 +146,15 @@ function transformElementCall(context, node) {
 }
 const transformCallExpression = (node, context) => {
     var _a;
-    if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+    const calledExpression = getCalledExpression(node);
+    if (calledExpression.kind === ts.SyntaxKind.ImportKeyword) {
         return (0, import_1.transformImportExpression)(node, context);
     }
     if (ts.isOptionalChain(node)) {
         return (0, optional_chaining_1.transformOptionalChain)(context, node);
     }
-    const optionalContinuation = ts.isIdentifier(node.expression)
-        ? (0, optional_chaining_1.getOptionalContinuationData)(node.expression)
+    const optionalContinuation = ts.isIdentifier(calledExpression)
+        ? (0, optional_chaining_1.getOptionalContinuationData)(calledExpression)
         : undefined;
     const wrapResultInTable = (0, multi_1.isMultiReturnCall)(context, node) && (0, multi_1.shouldMultiReturnCallBeWrapped)(context, node);
     if ((0, annotations_1.isTupleReturnCall)(context, node)) {
@@ -164,37 +165,36 @@ const transformCallExpression = (node, context) => {
         // unsupportedOptionalCall diagnostic already present
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinOrExtensionResult) : builtinOrExtensionResult;
     }
-    if (ts.isPropertyAccessExpression(node.expression)) {
-        const ownerType = context.checker.getTypeAtLocation(node.expression.expression);
+    if (ts.isPropertyAccessExpression(calledExpression)) {
+        const ownerType = context.checker.getTypeAtLocation(calledExpression.expression);
         const annotations = (0, annotations_1.getTypeAnnotations)(ownerType);
         if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
             context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
         }
-        const result = transformPropertyCall(context, node);
+        const result = transformPropertyCall(context, node, calledExpression);
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(result) : result;
     }
-    if (ts.isElementAccessExpression(node.expression)) {
+    if (ts.isElementAccessExpression(calledExpression)) {
         const result = transformElementCall(context, node);
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(result) : result;
     }
     const signature = context.checker.getResolvedSignature(node);
     // Handle super calls properly
-    if (node.expression.kind === ts.SyntaxKind.SuperKeyword) {
+    if (calledExpression.kind === ts.SyntaxKind.SuperKeyword) {
         const parameters = transformArguments(context, node.arguments, signature, ts.factory.createThis());
         return lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), parameters);
     }
-    const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
     let callPath;
     let parameters;
-    const isContextualCall = !signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void;
+    const isContextualCall = isContextualCallExpression(context, signature);
     if (!isContextualCall) {
-        [callPath, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature);
+        [callPath, parameters] = transformCallAndArguments(context, calledExpression, node.arguments, signature);
     }
     else {
         // if is optionalContinuation, context will be handled by transformOptionalChain.
         const useGlobalContext = !context.isStrict && optionalContinuation === undefined;
         const callContext = useGlobalContext ? ts.factory.createIdentifier("_G") : ts.factory.createNull();
-        [callPath, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature, callContext);
+        [callPath, parameters] = transformCallAndArguments(context, calledExpression, node.arguments, signature, callContext);
     }
     const callExpression = lua.createCallExpression(callPath, parameters, node);
     if (optionalContinuation && isContextualCall) {
@@ -203,4 +203,19 @@ const transformCallExpression = (node, context) => {
     return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(callExpression) : callExpression;
 };
 exports.transformCallExpression = transformCallExpression;
+function isContextualCallExpression(context, signature) {
+    const declaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
+    if (!declaration) {
+        return !context.options.noImplicitSelf;
+    }
+    return (0, function_context_1.getDeclarationContextType)(context, declaration) !== function_context_1.ContextType.Void;
+}
+function getCalledExpression(node) {
+    function unwrapExpression(expression) {
+        expression = ts.skipOuterExpressions(expression);
+        return ts.isNonNullExpression(expression) ? unwrapExpression(expression.expression) : expression;
+    }
+    return unwrapExpression(node.expression);
+}
+exports.getCalledExpression = getCalledExpression;
 //# sourceMappingURL=call.js.map

package/dist/transformation/visitors/errors.js

@@ -5,21 +5,58 @@ const __1 = require("../..");
 const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const lua_ast_1 = require("../utils/lua-ast");
+const lualib_1 = require("../utils/lualib");
 const scope_1 = require("../utils/scope");
 const typescript_1 = require("../utils/typescript");
+const async_await_1 = require("./async-await");
 const block_1 = require("./block");
 const identifier_1 = require("./identifier");
 const multi_1 = require("./language-extensions/multi");
 const return_1 = require("./return");
-const transformTryStatement = (statement, context) => {
-    var _a;
-    const [tryBlock, tryScope] = (0, block_1.transformScopeBlock)(context, statement.tryBlock, scope_1.ScopeType.Try);
-    if (context.options.luaTarget === __1.LuaTarget.Lua51 &&
-        (0, typescript_1.isInAsyncFunction)(statement) &&
-        !context.options.lua51AllowTryCatchInAsyncAwait) {
+const transformAsyncTry = (statement, context) => {
+    const [tryBlock] = (0, block_1.transformScopeBlock)(context, statement.tryBlock, scope_1.ScopeType.Try);
+    if (context.options.luaTarget === __1.LuaTarget.Lua51 && !context.options.lua51AllowTryCatchInAsyncAwait) {
         context.diagnostics.push((0, diagnostics_1.unsupportedForTargetButOverrideAvailable)(statement, "try/catch inside async functions", __1.LuaTarget.Lua51, "lua51AllowTryCatchInAsyncAwait"));
         return tryBlock.statements;
     }
+    // __TS__AsyncAwaiter(<catch block>)
+    const awaiter = (0, async_await_1.wrapInAsyncAwaiter)(context, tryBlock.statements, false);
+    const awaiterIdentifier = lua.createIdentifier("____try");
+    const awaiterDefinition = lua.createVariableDeclarationStatement(awaiterIdentifier, awaiter);
+    // local ____try = __TS__AsyncAwaiter(<catch block>)
+    const result = [awaiterDefinition];
+    if (statement.finallyBlock) {
+        const awaiterFinally = lua.createTableIndexExpression(awaiterIdentifier, lua.createStringLiteral("finally"));
+        const finallyFunction = lua.createFunctionExpression(lua.createBlock(context.transformStatements(statement.finallyBlock.statements)));
+        const finallyCall = lua.createCallExpression(awaiterFinally, [awaiterIdentifier, finallyFunction], statement.finallyBlock);
+        // ____try.finally(<finally function>)
+        result.push(lua.createExpressionStatement(finallyCall));
+    }
+    if (statement.catchClause) {
+        // ____try.catch(<catch function>)
+        const [catchFunction] = transformCatchClause(context, statement.catchClause);
+        if (catchFunction.params) {
+            catchFunction.params.unshift(lua.createAnonymousIdentifier());
+        }
+        const awaiterCatch = lua.createTableIndexExpression(awaiterIdentifier, lua.createStringLiteral("catch"));
+        const catchCall = lua.createCallExpression(awaiterCatch, [awaiterIdentifier, catchFunction]);
+        // await ____try.catch(<catch function>)
+        const promiseAwait = (0, lualib_1.transformLuaLibFunction)(context, __1.LuaLibFeature.Await, statement, catchCall);
+        result.push(lua.createExpressionStatement(promiseAwait, statement));
+    }
+    else {
+        // await ____try
+        const promiseAwait = (0, lualib_1.transformLuaLibFunction)(context, __1.LuaLibFeature.Await, statement, awaiterIdentifier);
+        result.push(lua.createExpressionStatement(promiseAwait, statement));
+    }
+    return result;
+};
+const transformTryStatement = (statement, context) => {
+    var _a;
+    if ((0, typescript_1.isInAsyncFunction)(statement)) {
+        return transformAsyncTry(statement, context);
+    }
+    const [tryBlock, tryScope] = (0, block_1.transformScopeBlock)(context, statement.tryBlock, scope_1.ScopeType.Try);
     if (context.options.luaTarget === __1.LuaTarget.Lua51 && (0, typescript_1.isInGeneratorFunction)(statement)) {
         context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(statement, "try/catch inside generator functions", __1.LuaTarget.Lua51));
         return tryBlock.statements;
@@ -33,11 +70,7 @@ const transformTryStatement = (statement, context) => {
     const tryCall = lua.createCallExpression(pCall, [lua.createFunctionExpression(tryBlock)]);
     if (statement.catchClause && statement.catchClause.block.statements.length > 0) {
         // try with catch
-        const [catchBlock, catchScope] = (0, block_1.transformScopeBlock)(context, statement.catchClause.block, scope_1.ScopeType.Catch);
-        const catchParameter = statement.catchClause.variableDeclaration
-            ? (0, identifier_1.transformIdentifier)(context, statement.catchClause.variableDeclaration.name)
-            : undefined;
-        const catchFunction = lua.createFunctionExpression(catchBlock, catchParameter ? [lua.cloneIdentifier(catchParameter)] : []);
+        const [catchFunction, catchScope] = transformCatchClause(context, statement.catchClause);
         const catchIdentifier = lua.createIdentifier("____catch");
         result.push(lua.createVariableDeclarationStatement(catchIdentifier, catchFunction));
         const hasReturn = (_a = tryScope.functionReturned) !== null && _a !== void 0 ? _a : catchScope.functionReturned;
@@ -96,4 +129,12 @@ const transformThrowStatement = (statement, context) => {
     return lua.createExpressionStatement(lua.createCallExpression(lua.createIdentifier("error"), parameters), statement);
 };
 exports.transformThrowStatement = transformThrowStatement;
+function transformCatchClause(context, catchClause) {
+    const [catchBlock, catchScope] = (0, block_1.transformScopeBlock)(context, catchClause.block, scope_1.ScopeType.Catch);
+    const catchParameter = catchClause.variableDeclaration
+        ? (0, identifier_1.transformIdentifier)(context, catchClause.variableDeclaration.name)
+        : undefined;
+    const catchFunction = lua.createFunctionExpression(catchBlock, catchParameter ? [lua.cloneIdentifier(catchParameter)] : []);
+    return [catchFunction, catchScope];
+}
 //# sourceMappingURL=errors.js.map

package/dist/transformation/visitors/expression-list.js

@@ -12,7 +12,10 @@ const optional_chaining_1 = require("./optional-chaining");
 function shouldMoveToTemp(context, expression, tsOriginal) {
     return (!lua.isLiteral(expression) &&
         !(lua.isIdentifier(expression) && expression.symbolId === context_1.tempSymbolId) && // Treat generated temps as consts
-        !(tsOriginal && ((0, typescript_1.isConstIdentifier)(context, tsOriginal) || (0, optional_chaining_1.isOptionalContinuation)(tsOriginal))));
+        !(tsOriginal &&
+            ((0, typescript_1.isConstIdentifier)(context, tsOriginal) ||
+                (0, optional_chaining_1.isOptionalContinuation)(tsOriginal) ||
+                tsOriginal.kind === ts.SyntaxKind.ThisKeyword)));
 }
 exports.shouldMoveToTemp = shouldMoveToTemp;
 // Cache an expression in a preceding statement and return the temp identifier

package/dist/transformation/visitors/function.js

@@ -114,7 +114,7 @@ function transformFunctionBody(context, parameters, body, spreadIdentifier, node
     scope.node = node;
     let bodyStatements = transformFunctionBodyContent(context, body);
     if (node && (0, async_await_1.isAsyncFunction)(node)) {
-        bodyStatements = (0, async_await_1.wrapInAsyncAwaiter)(context, bodyStatements);
+        bodyStatements = [lua.createReturnStatement([(0, async_await_1.wrapInAsyncAwaiter)(context, bodyStatements)])];
     }
     const headerStatements = transformFunctionBodyHeader(context, scope, parameters, spreadIdentifier);
     (0, scope_1.popScope)(context);

package/dist/transformation/visitors/return.js

@@ -61,14 +61,15 @@ const transformReturnStatement = (statement, context) => {
 exports.transformReturnStatement = transformReturnStatement;
 function createReturnStatement(context, values, node) {
     const results = [...values];
+    if ((0, typescript_1.isInAsyncFunction)(node)) {
+        return lua.createReturnStatement([
+            lua.createCallExpression(lua.createIdentifier("____awaiter_resolve"), [lua.createNilLiteral(), ...values]),
+        ]);
+    }
     if (isInTryCatch(context)) {
         // Bubble up explicit return flag and check if we're inside a try/catch block
         results.unshift(lua.createBooleanLiteral(true));
     }
-    else if ((0, typescript_1.isInAsyncFunction)(node)) {
-        // Add nil error handler in async function and not in try
-        results.unshift(lua.createNilLiteral());
-    }
     return lua.createReturnStatement(results, node);
 }
 exports.createReturnStatement = createReturnStatement;

package/dist/transformation/visitors/variable-declaration.d.ts

@@ -2,7 +2,7 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
 export declare function transformArrayBindingElement(context: TransformationContext, name: ts.ArrayBindingElement): lua.Identifier;
-export declare function transformBindingPattern(context: TransformationContext, pattern: ts.BindingPattern, table: lua.Identifier, propertyAccessStack?: ts.PropertyName[]): lua.Statement[];
+export declare function transformBindingPattern(context: TransformationContext, pattern: ts.BindingPattern, table: lua.Expression, propertyAccessStack?: ts.PropertyName[]): lua.Statement[];
 export declare function transformBindingVariableDeclaration(context: TransformationContext, bindingPattern: ts.BindingPattern, initializer?: ts.Expression): lua.Statement[];
 export declare function transformVariableDeclaration(context: TransformationContext, statement: ts.VariableDeclaration): lua.Statement[];
 export declare function checkVariableDeclarationList(context: TransformationContext, node: ts.VariableDeclarationList): void;

package/dist/transformation/visitors/variable-declaration.js

@@ -14,6 +14,7 @@ const function_1 = require("./function");
 const identifier_1 = require("./identifier");
 const multi_1 = require("./language-extensions/multi");
 const literal_1 = require("./literal");
+const expression_list_1 = require("./expression-list");
 function transformArrayBindingElement(context, name) {
     if (ts.isOmittedExpression(name)) {
         return lua.createAnonymousIdentifier(name);
@@ -117,22 +118,18 @@ function transformBindingVariableDeclaration(context, bindingPattern, initialize
     const isComplexBindingElement = (e) => ts.isBindingElement(e) && (!ts.isIdentifier(e.name) || e.dotDotDotToken);
     if (ts.isObjectBindingPattern(bindingPattern) || bindingPattern.elements.some(isComplexBindingElement)) {
         let table;
-        if (initializer !== undefined && ts.isIdentifier(initializer)) {
-            table = (0, identifier_1.transformIdentifier)(context, initializer);
-        }
-        else {
+        if (initializer) {
             // Contain the expression in a temporary variable
-            if (initializer) {
-                table = context.createTempNameForNode(initializer);
-                let expression = context.transformExpression(initializer);
-                if ((0, multi_1.isMultiReturnCall)(context, initializer)) {
-                    expression = (0, lua_ast_1.wrapInTable)(expression);
-                }
-                statements.push(lua.createVariableDeclarationStatement(table, expression));
-            }
-            else {
-                table = lua.createAnonymousIdentifier();
+            let expression = context.transformExpression(initializer);
+            if ((0, multi_1.isMultiReturnCall)(context, initializer)) {
+                expression = (0, lua_ast_1.wrapInTable)(expression);
             }
+            const [moveStatements, movedExpr] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, expression_list_1.moveToPrecedingTemp)(context, expression, initializer));
+            statements.push(...moveStatements);
+            table = movedExpr;
+        }
+        else {
+            table = lua.createAnonymousIdentifier();
         }
         statements.push(...transformBindingPattern(context, bindingPattern, table));
         return statements;

package/dist/transpilation/index.js

@@ -19,6 +19,7 @@ const fs = require("fs");
 const path = require("path");
 const ts = require("typescript");
 const tsconfig_1 = require("../cli/tsconfig");
+const utils_1 = require("../utils");
 const output_collector_1 = require("./output-collector");
 const transpiler_1 = require("./transpiler");
 __exportStar(require("./transpile"), exports);
@@ -44,8 +45,12 @@ exports.transpileProject = transpileProject;
 const libCache = {};
 /** @internal */
 function createVirtualProgram(input, options = {}) {
+    const normalizedFiles = {};
+    for (const [path, file] of Object.entries(input)) {
+        normalizedFiles[(0, utils_1.normalizeSlashes)(path)] = file;
+    }
     const compilerHost = {
-        fileExists: fileName => fileName in input || ts.sys.fileExists(fileName),
+        fileExists: fileName => fileName in normalizedFiles || ts.sys.fileExists(fileName),
         getCanonicalFileName: fileName => fileName,
         getCurrentDirectory: () => "",
         getDefaultLibFileName: ts.getDefaultLibFileName,
@@ -54,8 +59,8 @@ function createVirtualProgram(input, options = {}) {
         useCaseSensitiveFileNames: () => false,
         writeFile() { },
         getSourceFile(fileName) {
-            if (fileName in input) {
-                return ts.createSourceFile(fileName, input[fileName], ts.ScriptTarget.Latest, false);
+            if (fileName in normalizedFiles) {
+                return ts.createSourceFile(fileName, normalizedFiles[fileName], ts.ScriptTarget.Latest, false);
             }
             let filePath;
             if (fileName.startsWith("lib.")) {
@@ -75,7 +80,7 @@ function createVirtualProgram(input, options = {}) {
             }
         },
     };
-    return ts.createProgram(Object.keys(input), options, compilerHost);
+    return ts.createProgram(Object.keys(normalizedFiles), options, compilerHost);
 }
 exports.createVirtualProgram = createVirtualProgram;
 function transpileVirtualProject(files, options = {}) {

package/dist/transpilation/resolve.js

@@ -115,7 +115,7 @@ function resolveFileDependencies(file, context) {
     const dependencies = [];
     const diagnostics = [];
     for (const required of findRequiredPaths(file.code)) {
-        // Do no resolve lualib
+        // Do no resolve lualib - always use the lualib of the application entry point, not the lualib from external packages
         if (required === "lualib_bundle") {
             dependencies.push({ fileName: "lualib_bundle", code: "" });
             continue;

package/dist/transpilation/transpiler.js

@@ -16,9 +16,10 @@ class Transpiler {
     }
     emit(emitOptions) {
         var _a, _b;
-        const { program, writeFile = this.emitHost.writeFile } = emitOptions;
+        const { program, writeFile = this.emitHost.writeFile, plugins: optionsPlugins = [] } = emitOptions;
         const options = program.getCompilerOptions();
-        const { diagnostics: getPluginsDiagnostics, plugins } = (0, plugins_1.getPlugins)(program);
+        const { diagnostics: getPluginsDiagnostics, plugins: configPlugins } = (0, plugins_1.getPlugins)(program);
+        const plugins = [...optionsPlugins, ...configPlugins];
         const { diagnostics, transpiledFiles: freshFiles } = (0, transpile_1.getProgramTranspileResult)(this.emitHost, writeFile, {
             ...emitOptions,
             plugins,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.4.4",
+    "version": "1.6.1",
     "description": "A generic TypeScript to Lua transpiler. Write your code in TypeScript and publish Lua!",
     "repository": "https://github.com/TypeScriptToLua/TypeScriptToLua",
     "homepage": "https://typescripttolua.github.io/",
@@ -43,7 +43,7 @@
         "node": ">=12.13.0"
     },
     "peerDependencies": {
-        "typescript": "~4.6.2"
+        "typescript": "~4.7.3"
     },
     "dependencies": {
         "enhanced-resolve": "^5.8.2",
@@ -53,14 +53,14 @@
     "devDependencies": {
         "@types/fs-extra": "^8.1.0",
         "@types/glob": "^7.1.1",
-        "@types/jest": "^27.4.1",
+        "@types/jest": "^27.5.2",
         "@types/node": "^13.7.7",
         "@types/resolve": "1.14.0",
-        "@typescript-eslint/eslint-plugin": "^5.13.0",
-        "@typescript-eslint/parser": "^5.13.0",
-        "eslint": "^8.10.0",
-        "eslint-plugin-import": "^2.25.4",
-        "eslint-plugin-jest": "^26.1.1",
+        "@typescript-eslint/eslint-plugin": "^5.27.0",
+        "@typescript-eslint/parser": "^5.27.0",
+        "eslint": "^8.17.0",
+        "eslint-plugin-import": "^2.26.0",
+        "eslint-plugin-jest": "^26.4.6",
         "fs-extra": "^8.1.0",
         "javascript-stringify": "^2.0.1",
         "jest": "^27.3.0",
@@ -70,6 +70,6 @@
         "prettier": "^2.3.2",
         "ts-jest": "^27.1.3",
         "ts-node": "^10.3.0",
-        "typescript": "~4.6.2"
+        "typescript": "~4.7.3"
     }
 }