typescript-to-lua 1.1.0 → 1.3.1

package/dist/transformation/visitors/switch.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformSwitchStatement = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
+const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
+const binary_expression_1 = require("./binary-expression");
 const containsBreakOrReturn = (nodes) => {
     for (const s of nodes) {
         if (ts.isBreakStatement(s) || ts.isReturnStatement(s)) {
@@ -18,13 +20,23 @@ const containsBreakOrReturn = (nodes) => {
     }
     return false;
 };
-const coalesceCondition = (condition, switchVariable, expression, context) => {
+const createOrExpression = (context, left, right, rightPrecedingStatements) => {
+    if (rightPrecedingStatements.length > 0) {
+        return (0, binary_expression_1.createShortCircuitBinaryExpressionPrecedingStatements)(context, left, right, rightPrecedingStatements, ts.SyntaxKind.BarBarToken);
+    }
+    else {
+        return [rightPrecedingStatements, lua.createBinaryExpression(left, right, lua.SyntaxKind.OrOperator)];
+    }
+};
+const coalesceCondition = (condition, conditionPrecedingStatements, switchVariable, expression, context) => {
+    const [precedingStatements, transformedExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression));
     // Coalesce skipped statements
+    const comparison = lua.createBinaryExpression(switchVariable, transformedExpression, lua.SyntaxKind.EqualityOperator);
     if (condition) {
-        return lua.createBinaryExpression(condition, lua.createBinaryExpression(switchVariable, context.transformExpression(expression), lua.SyntaxKind.EqualityOperator), lua.SyntaxKind.OrOperator);
+        return createOrExpression(context, condition, comparison, precedingStatements);
     }
     // Next condition
-    return lua.createBinaryExpression(switchVariable, context.transformExpression(expression), lua.SyntaxKind.EqualityOperator);
+    return [[...conditionPrecedingStatements, ...precedingStatements], comparison];
 };
 const transformSwitchStatement = (statement, context) => {
     const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Switch);
@@ -53,6 +65,7 @@ const transformSwitchStatement = (statement, context) => {
         let defaultTransformed = false;
         let isInitialCondition = true;
         let condition = undefined;
+        let conditionPrecedingStatements = [];
         for (let i = 0; i < clauses.length; i++) {
             const clause = clauses[i];
             const previousClause = clauses[i - 1];
@@ -64,29 +77,35 @@ const transformSwitchStatement = (statement, context) => {
             }
             // Compute the condition for the if statement
             if (!ts.isDefaultClause(clause)) {
-                condition = coalesceCondition(condition, switchVariable, clause.expression, context);
+                [conditionPrecedingStatements, condition] = coalesceCondition(condition, conditionPrecedingStatements, switchVariable, clause.expression, context);
                 // Skip empty clauses unless final clause (i.e side-effects)
                 if (i !== clauses.length - 1 && clause.statements.length === 0)
                     continue;
                 // Declare or assign condition variable
-                statements.push(isInitialCondition
-                    ? lua.createVariableDeclarationStatement(conditionVariable, condition)
-                    : lua.createAssignmentStatement(conditionVariable, lua.createBinaryExpression(conditionVariable, condition, lua.SyntaxKind.OrOperator)));
+                if (isInitialCondition) {
+                    statements.push(...conditionPrecedingStatements, lua.createVariableDeclarationStatement(conditionVariable, condition));
+                }
+                else {
+                    [conditionPrecedingStatements, condition] = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                    statements.push(...conditionPrecedingStatements, lua.createAssignmentStatement(conditionVariable, condition));
+                }
                 isInitialCondition = false;
             }
             else {
                 // If the default is proceeded by empty clauses and will be emitted we may need to initialize the condition
                 if (isInitialCondition) {
-                    statements.push(lua.createVariableDeclarationStatement(conditionVariable, condition !== null && condition !== void 0 ? condition : lua.createBooleanLiteral(false)));
+                    statements.push(...conditionPrecedingStatements, lua.createVariableDeclarationStatement(conditionVariable, condition !== null && condition !== void 0 ? condition : lua.createBooleanLiteral(false)));
                     // Clear condition ot ensure it is not evaluated twice
                     condition = undefined;
+                    conditionPrecedingStatements = [];
                     isInitialCondition = false;
                 }
                 // Allow default to fallthrough to final default clause
                 if (i === clauses.length - 1) {
                     // Evaluate the final condition that we may be skipping
                     if (condition) {
-                        statements.push(lua.createAssignmentStatement(conditionVariable, lua.createBinaryExpression(conditionVariable, condition, lua.SyntaxKind.OrOperator)));
+                        [conditionPrecedingStatements, condition] = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                        statements.push(...conditionPrecedingStatements, lua.createAssignmentStatement(conditionVariable, condition));
                     }
                     continue;
                 }
@@ -106,6 +125,7 @@ const transformSwitchStatement = (statement, context) => {
             statements.push(lua.createIfStatement(conditionVariable, lua.createBlock(clauseStatements)));
             // Clear condition for next clause
             condition = undefined;
+            conditionPrecedingStatements = [];
         }
         // If no conditions above match, we need to create the final default case code-path,
         // as we only handle fallthrough into defaults in the previous if statement chain

package/dist/transformation/visitors/template.js

@@ -7,6 +7,7 @@ const function_context_1 = require("../utils/function-context");
 const lua_ast_1 = require("../utils/lua-ast");
 const types_1 = require("../utils/typescript/types");
 const call_1 = require("./call");
+const expression_list_1 = require("./expression-list");
 // TODO: Source positions
 function getRawLiteral(node) {
     let text = node.getText();
@@ -21,8 +22,10 @@ const transformTemplateExpression = (node, context) => {
     if (head.length > 0) {
         parts.push(lua.createStringLiteral(head, node.head));
     }
-    for (const span of node.templateSpans) {
-        const expression = context.transformExpression(span.expression);
+    const transformedExpressions = (0, expression_list_1.transformOrderedExpressions)(context, node.templateSpans.map(s => s.expression));
+    for (let i = 0; i < node.templateSpans.length; ++i) {
+        const span = node.templateSpans[i];
+        const expression = transformedExpressions[i];
         const spanType = context.checker.getTypeAtLocation(span.expression);
         if ((0, types_1.isStringType)(context, spanType)) {
             parts.push(expression);

package/dist/transformation/visitors/typeof.js

@@ -43,7 +43,9 @@ function transformTypeOfBinaryExpression(context, node) {
     }
     const innerExpression = context.transformExpression(typeOfExpression.expression);
     const typeCall = lua.createCallExpression(lua.createIdentifier("type"), [innerExpression], typeOfExpression);
-    return (0, binary_expression_1.transformBinaryOperation)(context, typeCall, comparedExpression, operator, node);
+    const [precedingStatements, result] = (0, binary_expression_1.transformBinaryOperation)(context, typeCall, comparedExpression, [], operator, node);
+    context.addPrecedingStatements(precedingStatements);
+    return result;
 }
 exports.transformTypeOfBinaryExpression = transformTypeOfBinaryExpression;
 //# sourceMappingURL=typeof.js.map

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

@@ -9,6 +9,8 @@ const diagnostics_1 = require("../utils/diagnostics");
 const export_1 = require("../utils/export");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
+const function_1 = require("./function");
 const identifier_1 = require("./identifier");
 const multi_1 = require("./language-extensions/multi");
 const literal_1 = require("./literal");
@@ -20,10 +22,15 @@ function transformArrayBindingElement(context, name) {
         return (0, identifier_1.transformIdentifier)(context, name);
     }
     else if (ts.isBindingElement(name)) {
-        // TODO: It should always be true when called from `transformVariableDeclaration`,
-        // but could be false from `transformForOfLuaIteratorStatement`.
-        (0, utils_1.assert)(ts.isIdentifier(name.name));
-        return (0, identifier_1.transformIdentifier)(context, name.name);
+        if (ts.isIdentifier(name.name)) {
+            return (0, identifier_1.transformIdentifier)(context, name.name);
+        }
+        else {
+            // ts.isBindingPattern(name.name)
+            const tempName = context.createTempNameForNode(name.name);
+            context.addPrecedingStatements(transformBindingPattern(context, name.name, tempName));
+            return tempName;
+        }
     }
     else {
         (0, utils_1.assertNever)(name);
@@ -52,7 +59,9 @@ function transformBindingPattern(context, pattern, table, propertyAccessStack =
         // The identifier of the new variable
         const variableName = (0, identifier_1.transformIdentifier)(context, element.name);
         // The field to extract
-        const propertyName = (0, literal_1.transformPropertyName)(context, (_a = element.propertyName) !== null && _a !== void 0 ? _a : element.name);
+        const elementName = (_a = element.propertyName) !== null && _a !== void 0 ? _a : element.name;
+        const [precedingStatements, propertyName] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, literal_1.transformPropertyName)(context, elementName));
+        result.push(...precedingStatements); // Keep property's preceding statements in order
         let expression;
         if (element.dotDotDotToken) {
             if (index !== pattern.elements.length - 1) {
@@ -90,8 +99,11 @@ function transformBindingPattern(context, pattern, table, propertyAccessStack =
         result.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, variableName, expression));
         if (element.initializer) {
             const identifier = (0, export_1.addExportToIdentifier)(context, variableName);
+            const tsInitializer = element.initializer;
+            const [initializerPrecedingStatements, initializer] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsInitializer));
             result.push(lua.createIfStatement(lua.createBinaryExpression(identifier, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator), lua.createBlock([
-                lua.createAssignmentStatement(identifier, context.transformExpression(element.initializer)),
+                ...initializerPrecedingStatements,
+                lua.createAssignmentStatement(identifier, initializer),
             ])));
         }
     }
@@ -110,14 +122,17 @@ function transformBindingVariableDeclaration(context, bindingPattern, initialize
         }
         else {
             // Contain the expression in a temporary variable
-            table = lua.createAnonymousIdentifier();
             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();
+            }
         }
         statements.push(...transformBindingPattern(context, bindingPattern, table));
         return statements;
@@ -169,7 +184,10 @@ function transformVariableDeclaration(context, statement) {
         // Find variable identifier
         const identifierName = (0, identifier_1.transformIdentifier)(context, statement.name);
         const value = statement.initializer && context.transformExpression(statement.initializer);
-        return (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, identifierName, value, statement);
+        // Wrap functions being assigned to a type that contains additional properties in a callable table
+        // This catches 'const foo = function() {}; foo.bar = "FOOBAR";'
+        const wrappedValue = value && shouldWrapInitializerInCallableTable() ? (0, function_1.createCallableTable)(value) : value;
+        return (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, identifierName, wrappedValue, statement);
     }
     else if (ts.isArrayBindingPattern(statement.name) || ts.isObjectBindingPattern(statement.name)) {
         return transformBindingVariableDeclaration(context, statement.name, statement.initializer);
@@ -177,6 +195,17 @@ function transformVariableDeclaration(context, statement) {
     else {
         return (0, utils_1.assertNever)(statement.name);
     }
+    function shouldWrapInitializerInCallableTable() {
+        (0, utils_1.assert)(statement.initializer);
+        const initializer = ts.skipOuterExpressions(statement.initializer);
+        // do not wrap if not a function expression
+        if (!ts.isFunctionExpression(initializer) && !ts.isArrowFunction(initializer))
+            return false;
+        // Skip named function expressions because they will have been wrapped already
+        if (ts.isFunctionExpression(initializer) && initializer.name)
+            return false;
+        return (0, function_1.isFunctionTypeWithProperties)(context.checker.getTypeAtLocation(statement.name));
+    }
 }
 exports.transformVariableDeclaration = transformVariableDeclaration;
 function checkVariableDeclarationList(context, node) {

package/dist/transformation/visitors/void.d.ts

@@ -1,6 +1,3 @@
 import * as ts from "typescript";
-import * as lua from "../../LuaAST";
-import { TransformationContext } from "../context";
-import { FunctionVisitor } from "../context/visitors";
+import { FunctionVisitor } from "../context";
 export declare const transformVoidExpression: FunctionVisitor<ts.VoidExpression>;
-export declare const transformVoidExpressionStatement: (node: ts.VoidExpression, context: TransformationContext) => lua.VariableDeclarationStatement;

package/dist/transformation/visitors/void.js

@@ -1,23 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformVoidExpressionStatement = exports.transformVoidExpression = void 0;
+exports.transformVoidExpression = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
-const lua_ast_1 = require("../utils/lua-ast");
+const expression_statement_1 = require("./expression-statement");
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void
 const transformVoidExpression = (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);
+    if (!ts.isLiteralExpression(node.expression)) {
+        const statements = (0, expression_statement_1.transformExpressionToStatement)(context, node.expression);
+        if (statements)
+            context.addPrecedingStatements(statements);
     }
-    // (function() local ____ = <expression> end)()
-    return (0, lua_ast_1.createImmediatelyInvokedFunctionExpression)([
-        lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), context.transformExpression(node.expression)),
-    ], [], node);
+    return lua.createNilLiteral();
 };
 exports.transformVoidExpression = transformVoidExpression;
-const transformVoidExpressionStatement = (node, context) => 
-// In case of a void expression statement we can omit the IIFE
-lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), context.transformExpression(node.expression), node);
-exports.transformVoidExpressionStatement = transformVoidExpressionStatement;
 //# sourceMappingURL=void.js.map

package/dist/transpilation/resolve.js

@@ -244,7 +244,7 @@ function isBuildModeLibrary(program) {
 function findRequiredPaths(code) {
     // Find all require("<path>") paths in a lua code string
     const paths = [];
-    const pattern = /(^|\s|;|=)require\("(.+)"\)/g;
+    const pattern = /(^|\s|;|=)require\("(.+?)"\)/g;
     // eslint-disable-next-line @typescript-eslint/ban-types
     let match;
     while ((match = pattern.exec(code))) {

package/dist/transpilation/transformers.js

@@ -48,7 +48,7 @@ exports.noImplicitSelfTransformer = noImplicitSelfTransformer;
 const stripParenthesisExpressionsTransformer = context => sourceFile => {
     // Remove parenthesis expressions before transforming to Lua, so transpiler is not hindered by extra ParenthesizedExpression nodes
     function unwrapParentheses(node) {
-        while (ts.isParenthesizedExpression(node)) {
+        while (ts.isParenthesizedExpression(node) && !ts.isOptionalChain(node.expression)) {
             node = node.expression;
         }
         return node;
@@ -61,6 +61,9 @@ const stripParenthesisExpressionsTransformer = context => sourceFile => {
         else if (ts.isVoidExpression(node)) {
             return ts.factory.updateVoidExpression(node, unwrapParentheses(node.expression));
         }
+        else if (ts.isDeleteExpression(node)) {
+            return ts.factory.updateDeleteExpression(node, unwrapParentheses(node.expression));
+        }
         return ts.visitEachChild(node, visit, context);
     }
     return ts.visitNode(sourceFile, visit);

package/dist/transpilation/utils.js

@@ -8,6 +8,7 @@ const cliDiagnostics = require("../cli/diagnostics");
 const diagnosticFactories = require("./diagnostics");
 const getConfigDirectory = (options) => options.configFilePath ? path.dirname(options.configFilePath) : process.cwd();
 exports.getConfigDirectory = getConfigDirectory;
+const getTstlDirectory = () => path.dirname(__dirname);
 function resolvePlugin(kind, optionName, basedir, query, importName = "default") {
     if (typeof query !== "string") {
         return { error: cliDiagnostics.compilerOptionRequiresAValueOfType(optionName, "string") };
@@ -25,7 +26,7 @@ function resolvePlugin(kind, optionName, basedir, query, importName = "default")
     const hasNoRequireHook = require.extensions[".ts"] === undefined;
     if (hasNoRequireHook && (resolved.endsWith(".ts") || resolved.endsWith(".tsx"))) {
         try {
-            const tsNodePath = resolve.sync("ts-node", { basedir });
+            const tsNodePath = resolve.sync("ts-node", { basedir: getTstlDirectory() });
             const tsNode = require(tsNodePath);
             tsNode.register({ transpileOnly: true });
         }

package/language-extensions/index.d.ts

@@ -78,6 +78,16 @@ declare type LuaIterable<TValue, TState = undefined> = Iterable<TValue> &
     LuaIterator<TValue, TState> &
     LuaExtension<"__luaIterableBrand">;
 
+/**
+ * Represents an object that can be iterated with pairs()
+ * For more information see: https://typescripttolua.github.io/docs/advanced/language-extensions
+ *
+ * @param TKey The type of the key returned each iteration.
+ * @param TValue The type of the value returned each iteration.
+ */
+declare type LuaPairsIterable<TKey extends AnyNotNil, TValue> = Iterable<[TKey, TValue]> &
+    LuaExtension<"__luaPairsIterableBrand">;
+
 /**
  * Calls to functions with this type are translated to `left + right`.
  * For more information see: https://typescripttolua.github.io/docs/advanced/language-extensions
@@ -535,7 +545,7 @@ declare type LuaTableDeleteMethod<TKey extends AnyNotNil> = ((key: TKey) => bool
  * @param TKey The type of the keys used to access the table.
  * @param TValue The type of the values stored in the table.
  */
-declare interface LuaTable<TKey extends AnyNotNil = AnyNotNil, TValue = any> {
+declare interface LuaTable<TKey extends AnyNotNil = AnyNotNil, TValue = any> extends LuaPairsIterable<TKey, TValue> {
     length: LuaLengthMethod<number>;
     get: LuaTableGetMethod<TKey, TValue>;
     set: LuaTableSetMethod<TKey, TValue>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.1.0",
+    "version": "1.3.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/",
@@ -42,7 +42,7 @@
         "node": ">=12.13.0"
     },
     "peerDependencies": {
-        "typescript": "~4.4.4"
+        "typescript": "~4.5.2"
     },
     "dependencies": {
         "enhanced-resolve": "^5.8.2",
@@ -55,8 +55,8 @@
         "@types/jest": "^25.1.3",
         "@types/node": "^13.7.7",
         "@types/resolve": "1.14.0",
-        "@typescript-eslint/eslint-plugin": "^4.31.0",
-        "@typescript-eslint/parser": "^4.31.0",
+        "@typescript-eslint/eslint-plugin": "^5.4.0",
+        "@typescript-eslint/parser": "^5.4.0",
         "eslint": "^7.32.0",
         "eslint-plugin-import": "^2.24.2",
         "eslint-plugin-jest": "^24.4.0",
@@ -69,6 +69,6 @@
         "prettier": "^2.3.2",
         "ts-jest": "^27.0.7",
         "ts-node": "^10.3.0",
-        "typescript": "~4.4.4"
+        "typescript": "~4.5.2"
     }
 }

package/dist/lualib/OptionalChainAccess.lua

@@ -1,6 +0,0 @@
-function __TS__OptionalChainAccess(____table, key)
-    if ____table then
-        return ____table[key]
-    end
-    return nil
-end

package/dist/lualib/OptionalFunctionCall.lua

@@ -1,6 +0,0 @@
-function __TS__OptionalFunctionCall(f, ...)
-    if f then
-        return f(...)
-    end
-    return nil
-end

package/dist/lualib/OptionalMethodCall.lua

@@ -1,11 +0,0 @@
-function __TS__OptionalMethodCall(____table, methodName, isMethodOptional, ...)
-    if ____table then
-        local method = ____table[methodName]
-        if method then
-            return method(____table, ...)
-        elseif not isMethodOptional then
-            error(methodName .. " is not a function", 0)
-        end
-    end
-    return nil
-end

package/dist/transformation/utils/transform.d.ts

@@ -1,8 +0,0 @@
-import * as ts from "typescript";
-import * as lua from "../../LuaAST";
-import { TransformationContext } from "../context";
-export interface ImmediatelyInvokedFunctionParameters {
-    statements: lua.Statement | lua.Statement[];
-    result: lua.Expression | lua.Expression[];
-}
-export declare function transformToImmediatelyInvokedFunctionExpression(context: TransformationContext, transformFunction: () => ImmediatelyInvokedFunctionParameters, tsOriginal?: ts.Node): lua.CallExpression;

package/dist/transformation/utils/transform.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformToImmediatelyInvokedFunctionExpression = void 0;
-const utils_1 = require("../../utils");
-const lua_ast_1 = require("./lua-ast");
-const scope_1 = require("./scope");
-function transformToImmediatelyInvokedFunctionExpression(context, transformFunction, tsOriginal) {
-    (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
-    const { statements, result } = transformFunction();
-    (0, scope_1.popScope)(context);
-    return (0, lua_ast_1.createImmediatelyInvokedFunctionExpression)((0, utils_1.castArray)(statements), result, tsOriginal);
-}
-exports.transformToImmediatelyInvokedFunctionExpression = transformToImmediatelyInvokedFunctionExpression;
-//# sourceMappingURL=transform.js.map