typescript-to-lua 1.4.4 → 1.6.1

package/dist/transformation/builtins/object.js

@@ -5,41 +5,40 @@ const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const lualib_1 = require("../utils/lualib");
 const call_1 = require("../visitors/call");
-function transformObjectConstructorCall(context, expression) {
-    const method = expression.expression;
-    const args = (0, call_1.transformArguments)(context, expression.arguments);
-    const methodName = method.name.text;
+function transformObjectConstructorCall(context, node, calledMethod) {
+    const args = (0, call_1.transformArguments)(context, node.arguments);
+    const methodName = calledMethod.name.text;
     switch (methodName) {
         case "assign":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectAssign, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectAssign, node, ...args);
         case "defineProperty":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectDefineProperty, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectDefineProperty, node, ...args);
         case "entries":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectEntries, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectEntries, node, ...args);
         case "fromEntries":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectFromEntries, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectFromEntries, node, ...args);
         case "getOwnPropertyDescriptor":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptor, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptor, node, ...args);
         case "getOwnPropertyDescriptors":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptors, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptors, node, ...args);
         case "keys":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectKeys, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectKeys, node, ...args);
         case "values":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectValues, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectValues, node, ...args);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "Object", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "Object", methodName));
     }
 }
 exports.transformObjectConstructorCall = transformObjectConstructorCall;
-function transformObjectPrototypeCall(context, node, expression) {
+function transformObjectPrototypeCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
-    const name = expression.name.text;
+    const name = calledMethod.name.text;
     switch (name) {
         case "toString":
             const toStringIdentifier = lua.createIdentifier("tostring");
-            return lua.createCallExpression(toStringIdentifier, [context.transformExpression(expression.expression)], node);
+            return lua.createCallExpression(toStringIdentifier, [context.transformExpression(calledMethod.expression)], node);
         case "hasOwnProperty":
-            const expr = context.transformExpression(expression.expression);
+            const expr = context.transformExpression(calledMethod.expression);
             const parameters = (0, call_1.transformArguments)(context, node.arguments, signature);
             const rawGetIdentifier = lua.createIdentifier("rawget");
             const rawGetCall = lua.createCallExpression(rawGetIdentifier, [expr, ...parameters]);

package/dist/transformation/builtins/promise.d.ts

@@ -1,8 +1,7 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
 export declare function isPromiseClass(context: TransformationContext, node: ts.Identifier): boolean;
 export declare function createPromiseIdentifier(original: ts.Node): lua.Identifier;
-export declare function transformPromiseConstructorCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
+export declare function transformPromiseConstructorCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
 export declare function createStaticPromiseFunctionAccessor(functionName: string, node: ts.Node): lua.TableIndexExpression;

package/dist/transformation/builtins/promise.js

@@ -15,11 +15,10 @@ function createPromiseIdentifier(original) {
     return lua.createIdentifier("__TS__Promise", original);
 }
 exports.createPromiseIdentifier = createPromiseIdentifier;
-function transformPromiseConstructorCall(context, node) {
-    const expression = node.expression;
+function transformPromiseConstructorCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
     const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const expressionName = expression.name.text;
+    const expressionName = calledMethod.name.text;
     switch (expressionName) {
         case "all":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseAll, node, ...params);
@@ -31,12 +30,12 @@ function transformPromiseConstructorCall(context, node) {
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseRace, node, ...params);
         case "resolve":
             (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
-            return lua.createCallExpression(createStaticPromiseFunctionAccessor("resolve", expression), params, node);
+            return lua.createCallExpression(createStaticPromiseFunctionAccessor("resolve", calledMethod), params, node);
         case "reject":
             (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
-            return lua.createCallExpression(createStaticPromiseFunctionAccessor("reject", expression), params, node);
+            return lua.createCallExpression(createStaticPromiseFunctionAccessor("reject", calledMethod), params, node);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "Promise", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "Promise", expressionName));
     }
 }
 exports.transformPromiseConstructorCall = transformPromiseConstructorCall;

package/dist/transformation/builtins/string.d.ts

@@ -1,7 +1,6 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
-export declare function transformStringPrototypeCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
-export declare function transformStringConstructorCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
+export declare function transformStringPrototypeCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
+export declare function transformStringConstructorCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
 export declare function transformStringProperty(context: TransformationContext, node: ts.PropertyAccessExpression): lua.UnaryExpression | undefined;

package/dist/transformation/builtins/string.js

@@ -10,11 +10,10 @@ function createStringCall(methodName, tsOriginal, ...params) {
     const stringIdentifier = lua.createIdentifier("string");
     return lua.createCallExpression(lua.createTableIndexExpression(stringIdentifier, lua.createStringLiteral(methodName)), params, tsOriginal);
 }
-function transformStringPrototypeCall(context, node) {
-    const expression = node.expression;
+function transformStringPrototypeCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
-    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
-    const expressionName = expression.name.text;
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, calledMethod.expression, node.arguments, signature);
+    const expressionName = calledMethod.name.text;
     switch (expressionName) {
         case "replace":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringReplace, node, caller, ...params);
@@ -102,20 +101,19 @@ function transformStringPrototypeCall(context, node) {
         case "padEnd":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringPadEnd, node, caller, ...params);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "string", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "string", expressionName));
     }
 }
 exports.transformStringPrototypeCall = transformStringPrototypeCall;
-function transformStringConstructorCall(context, node) {
-    const expression = node.expression;
+function transformStringConstructorCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
     const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const expressionName = expression.name.text;
+    const expressionName = calledMethod.name.text;
     switch (expressionName) {
         case "fromCharCode":
             return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("string"), lua.createStringLiteral("char")), params, node);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "String", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "String", expressionName));
     }
 }
 exports.transformStringConstructorCall = transformStringConstructorCall;

package/dist/transformation/builtins/symbol.d.ts

@@ -1,4 +1,4 @@
+import ts = require("typescript");
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
-export declare function transformSymbolConstructorCall(context: TransformationContext, expression: PropertyCallExpression): lua.CallExpression | undefined;
+export declare function transformSymbolConstructorCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.CallExpression | undefined;

package/dist/transformation/builtins/symbol.js

@@ -5,20 +5,19 @@ const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const lualib_1 = require("../utils/lualib");
 const call_1 = require("../visitors/call");
-function transformSymbolConstructorCall(context, expression) {
-    const method = expression.expression;
-    const signature = context.checker.getResolvedSignature(expression);
-    const parameters = (0, call_1.transformArguments)(context, expression.arguments, signature);
-    const methodName = method.name.text;
+function transformSymbolConstructorCall(context, node, calledMethod) {
+    const signature = context.checker.getResolvedSignature(node);
+    const parameters = (0, call_1.transformArguments)(context, node.arguments, signature);
+    const methodName = calledMethod.name.text;
     switch (methodName) {
         case "for":
         case "keyFor":
             (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.SymbolRegistry);
             const upperMethodName = methodName[0].toUpperCase() + methodName.slice(1);
             const functionIdentifier = lua.createIdentifier(`__TS__SymbolRegistry${upperMethodName}`);
-            return lua.createCallExpression(functionIdentifier, parameters, expression);
+            return lua.createCallExpression(functionIdentifier, parameters, node);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "Symbol", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "Symbol", methodName));
     }
 }
 exports.transformSymbolConstructorCall = transformSymbolConstructorCall;

package/dist/transformation/context/context.d.ts

@@ -16,7 +16,7 @@ export interface EmitResolver {
     moduleExportsSomeValue(moduleReferenceExpression: ts.Expression): boolean;
     getAllAccessorDeclarations(declaration: ts.AccessorDeclaration): AllAccessorDeclarations;
 }
-export interface DiagnosticsProducingTypeChecker extends ts.TypeChecker {
+export interface TypeCheckerWithEmitResolver extends ts.TypeChecker {
     getEmitResolver(sourceFile?: ts.SourceFile, cancellationToken?: ts.CancellationToken): EmitResolver;
 }
 export declare class TransformationContext {
@@ -24,7 +24,7 @@ export declare class TransformationContext {
     sourceFile: ts.SourceFile;
     private visitorMap;
     readonly diagnostics: ts.Diagnostic[];
-    readonly checker: DiagnosticsProducingTypeChecker;
+    readonly checker: TypeCheckerWithEmitResolver;
     readonly resolver: EmitResolver;
     readonly precedingStatementsStack: lua.Statement[][];
     readonly options: CompilerOptions;

package/dist/transformation/context/context.js

@@ -16,7 +16,7 @@ class TransformationContext {
         this.sourceFile = sourceFile;
         this.visitorMap = visitorMap;
         this.diagnostics = [];
-        this.checker = this.program.getDiagnosticsProducingTypeChecker();
+        this.checker = this.program.getTypeChecker();
         this.precedingStatementsStack = [];
         this.options = this.program.getCompilerOptions();
         this.luaTarget = (_a = this.options.luaTarget) !== null && _a !== void 0 ? _a : CompilerOptions_1.LuaTarget.Universal;

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

@@ -3,7 +3,7 @@ import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
 export declare function hasDefaultExportModifier(node: ts.Node): boolean;
 export declare function hasExportModifier(node: ts.Node): boolean;
-export declare const createDefaultExportStringLiteral: (original?: ts.Node | undefined) => lua.StringLiteral;
+export declare const createDefaultExportStringLiteral: (original?: ts.Node) => lua.StringLiteral;
 export declare function getExportedSymbolDeclaration(symbol: ts.Symbol): ts.Declaration | undefined;
 export declare function getSymbolFromIdentifier(context: TransformationContext, identifier: lua.Identifier): ts.Symbol | undefined;
 export declare function getIdentifierExportScope(context: TransformationContext, identifier: lua.Identifier): ts.SourceFile | ts.ModuleDeclaration | undefined;

package/dist/transformation/utils/function-context.js

@@ -59,8 +59,13 @@ function getDeclarationContextType({ program }, signatureDeclaration) {
     }
     // When using --noImplicitSelf and the signature is defined in a file targeted by the program apply the @noSelf rule.
     const options = program.getCompilerOptions();
-    if (options.noImplicitSelf && program.getRootFileNames().includes(signatureDeclaration.getSourceFile().fileName)) {
-        return ContextType.Void;
+    if (options.noImplicitSelf) {
+        const sourceFile = program.getSourceFile(signatureDeclaration.getSourceFile().fileName);
+        if (sourceFile !== undefined &&
+            !program.isSourceFileDefaultLibrary(sourceFile) &&
+            !program.isSourceFileFromExternalLibrary(sourceFile)) {
+            return ContextType.Void;
+        }
     }
     // Walk up to find @noSelf or @noSelfInFile
     if (hasNoSelfAncestor(signatureDeclaration)) {

package/dist/transformation/utils/lua-ast.d.ts

@@ -13,4 +13,4 @@ export declare function wrapInTable(...expressions: lua.Expression[]): lua.Table
 export declare function wrapInToStringForConcat(expression: lua.Expression): lua.Expression;
 export declare function createHoistableVariableDeclarationStatement(context: TransformationContext, identifier: lua.Identifier, initializer?: lua.Expression, tsOriginal?: ts.Node): lua.AssignmentStatement | lua.VariableDeclarationStatement;
 export declare function createLocalOrExportedOrGlobalDeclaration(context: TransformationContext, lhs: lua.Identifier | lua.Identifier[], rhs?: lua.Expression | lua.Expression[], tsOriginal?: ts.Node, overrideExportScope?: ts.SourceFile | ts.ModuleDeclaration): lua.Statement[];
-export declare const createNaN: (tsOriginal?: ts.Node | undefined) => lua.BinaryExpression;
+export declare const createNaN: (tsOriginal?: ts.Node) => lua.BinaryExpression;

package/dist/transformation/utils/lua-ast.js

@@ -104,6 +104,7 @@ function hasMultipleReferences(scope, identifiers) {
 function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal, overrideExportScope) {
     let declaration;
     let assignment;
+    const noImplicitGlobalVariables = context.options.noImplicitGlobalVariables === true;
     const isFunctionDeclaration = tsOriginal !== undefined && ts.isFunctionDeclaration(tsOriginal);
     const identifiers = (0, utils_1.castArray)(lhs);
     if (identifiers.length === 0) {
@@ -122,7 +123,7 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
     else {
         const scope = (0, scope_1.peekScope)(context);
         const isTopLevelVariable = scope.type === scope_1.ScopeType.File;
-        if (context.isModule || !isTopLevelVariable) {
+        if (context.isModule || !isTopLevelVariable || noImplicitGlobalVariables) {
             const isLuaFunctionExpression = rhs && !Array.isArray(rhs) && lua.isFunctionExpression(rhs);
             const isSafeRecursiveFunctionDeclaration = isFunctionDeclaration && isLuaFunctionExpression;
             if (!isSafeRecursiveFunctionDeclaration && hasMultipleReferences(scope, lhs)) {
@@ -163,6 +164,7 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
             }
         }
     }
+    setJSDocComments(context, tsOriginal, declaration, assignment);
     if (declaration && assignment) {
         return [declaration, assignment];
     }
@@ -177,6 +179,86 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
     }
 }
 exports.createLocalOrExportedOrGlobalDeclaration = createLocalOrExportedOrGlobalDeclaration;
+/**
+ * Apply JSDoc comments to the newly-created Lua statement, if present.
+ * https://stackoverflow.com/questions/47429792/is-it-possible-to-get-comments-as-nodes-in-the-ast-using-the-typescript-compiler
+ */
+function setJSDocComments(context, tsOriginal, declaration, assignment) {
+    // Respect the vanilla TypeScript option of "removeComments":
+    // https://www.typescriptlang.org/tsconfig#removeComments
+    if (context.options.removeComments) {
+        return;
+    }
+    const docCommentArray = getJSDocCommentFromTSNode(context, tsOriginal);
+    if (docCommentArray === undefined) {
+        return;
+    }
+    if (declaration && assignment) {
+        declaration.leadingComments = docCommentArray;
+    }
+    else if (declaration) {
+        declaration.leadingComments = docCommentArray;
+    }
+    else if (assignment) {
+        assignment.leadingComments = docCommentArray;
+    }
+}
+function getJSDocCommentFromTSNode(context, tsOriginal) {
+    if (tsOriginal === undefined) {
+        return undefined;
+    }
+    // The "name" property is only on a subset of node types; we want to be permissive and get the
+    // comments from as many nodes as possible.
+    const node = tsOriginal;
+    if (node.name === undefined) {
+        return undefined;
+    }
+    const symbol = context.checker.getSymbolAtLocation(node.name);
+    if (symbol === undefined) {
+        return undefined;
+    }
+    // The TypeScript compiler separates JSDoc comments into the "documentation comment" and the
+    // "tags". The former is conventionally at the top of the comment, and the bottom is
+    // conventionally at the bottom. We need to get both from the TypeScript API and then combine
+    // them into one block of text.
+    const docCommentArray = symbol.getDocumentationComment(context.checker);
+    const docCommentText = ts.displayPartsToString(docCommentArray).trim();
+    const jsDocTagInfoArray = symbol.getJsDocTags(context.checker);
+    const jsDocTagsTextLines = jsDocTagInfoArray.map(jsDocTagInfo => {
+        let text = "@" + jsDocTagInfo.name;
+        if (jsDocTagInfo.text !== undefined) {
+            const tagDescriptionTextArray = jsDocTagInfo.text
+                .filter(symbolDisplayPart => symbolDisplayPart.text.trim() !== "")
+                .map(symbolDisplayPart => symbolDisplayPart.text.trim());
+            const tagDescriptionText = tagDescriptionTextArray.join(" ");
+            text += " " + tagDescriptionText;
+        }
+        return text;
+    });
+    const jsDocTagsText = jsDocTagsTextLines.join("\n");
+    const combined = (docCommentText + "\n\n" + jsDocTagsText).trim();
+    if (combined === "") {
+        return undefined;
+    }
+    // By default, TSTL will display comments immediately next to the "--" characters. We can make
+    // the comments look better if we separate them by a space (similar to what Prettier does in
+    // JavaScript/TypeScript).
+    const linesWithoutSpace = combined.split("\n");
+    const lines = linesWithoutSpace.map(line => ` ${line}`);
+    // We want to JSDoc comments to map on to LDoc comments:
+    // https://stevedonovan.github.io/ldoc/manual/doc.md.html
+    // LDoc comments require that the first line starts with three hyphens.
+    // Thus, need to add a hyphen to the first line.
+    const firstLine = lines[0];
+    if (firstLine.startsWith(" @")) {
+        lines.unshift("-");
+    }
+    else {
+        lines.shift();
+        lines.unshift("-" + firstLine);
+    }
+    return lines;
+}
 const createNaN = (tsOriginal) => lua.createBinaryExpression(lua.createNumericLiteral(0), lua.createNumericLiteral(0), lua.SyntaxKind.DivisionOperator, tsOriginal);
 exports.createNaN = createNaN;
 //# sourceMappingURL=lua-ast.js.map

package/dist/transformation/visitors/async-await.d.ts

@@ -3,4 +3,4 @@ import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
 export declare const transformAwaitExpression: FunctionVisitor<ts.AwaitExpression>;
 export declare function isAsyncFunction(declaration: ts.FunctionLikeDeclaration): boolean;
-export declare function wrapInAsyncAwaiter(context: TransformationContext, statements: lua.Statement[]): lua.Statement[];
+export declare function wrapInAsyncAwaiter(context: TransformationContext, statements: lua.Statement[], includeResolveParameter?: boolean): lua.CallExpression;

package/dist/transformation/visitors/async-await.js

@@ -7,16 +7,12 @@ const diagnostics_1 = require("../utils/diagnostics");
 const lualib_1 = require("../utils/lualib");
 const typescript_1 = require("../utils/typescript");
 const transformAwaitExpression = (node, context) => {
-    var _a;
     // Check if await is inside an async function, it is not allowed at top level or in non-async functions
-    const containingFunction = (0, typescript_1.findFirstNodeAbove)(node, ts.isFunctionLike);
-    if (containingFunction === undefined ||
-        !((_a = containingFunction.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword))) {
+    if (!(0, typescript_1.isInAsyncFunction)(node)) {
         context.diagnostics.push((0, diagnostics_1.awaitMustBeInAsyncFunction)(node));
     }
     const expression = context.transformExpression(node.expression);
-    const catchIdentifier = lua.createIdentifier("____catch");
-    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Await, node, catchIdentifier, expression);
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Await, node, expression);
 };
 exports.transformAwaitExpression = transformAwaitExpression;
 function isAsyncFunction(declaration) {
@@ -24,15 +20,12 @@ function isAsyncFunction(declaration) {
     return (_b = (_a = declaration.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)) !== null && _b !== void 0 ? _b : false;
 }
 exports.isAsyncFunction = isAsyncFunction;
-function wrapInAsyncAwaiter(context, statements) {
+function wrapInAsyncAwaiter(context, statements, includeResolveParameter = true) {
     (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Await);
-    return [
-        lua.createReturnStatement([
-            lua.createCallExpression(lua.createIdentifier("__TS__AsyncAwaiter"), [
-                lua.createFunctionExpression(lua.createBlock(statements)),
-            ]),
-        ]),
-    ];
+    const parameters = includeResolveParameter ? [lua.createIdentifier("____awaiter_resolve")] : [];
+    return lua.createCallExpression(lua.createIdentifier("__TS__AsyncAwaiter"), [
+        lua.createFunctionExpression(lua.createBlock(statements), parameters),
+    ]);
 }
 exports.wrapInAsyncAwaiter = wrapInAsyncAwaiter;
 //# sourceMappingURL=async-await.js.map

package/dist/transformation/visitors/binary-expression/assignments.js

@@ -72,17 +72,14 @@ function transformAssignmentWithRightPrecedingStatements(context, lhs, right, ri
 }
 exports.transformAssignmentWithRightPrecedingStatements = transformAssignmentWithRightPrecedingStatements;
 function transformDestructuredAssignmentExpression(context, expression) {
-    const rootIdentifier = context.createTempNameForNode(expression.right);
     let [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
     context.addPrecedingStatements(rightPrecedingStatements);
     if ((0, multi_1.isMultiReturnCall)(context, expression.right)) {
         right = (0, lua_ast_1.wrapInTable)(right);
     }
-    const statements = [
-        lua.createVariableDeclarationStatement(rootIdentifier, right),
-        ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier, rightPrecedingStatements.length > 0),
-    ];
-    return { statements, result: rootIdentifier };
+    const rightExpr = (0, expression_list_1.moveToPrecedingTemp)(context, right, expression.right);
+    const statements = (0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rightExpr, rightPrecedingStatements.length > 0);
+    return { statements, result: rightExpr };
 }
 function transformAssignmentExpression(context, expression) {
     // Validate assignment
@@ -99,15 +96,12 @@ function transformAssignmentExpression(context, expression) {
         return result;
     }
     if (ts.isPropertyAccessExpression(expression.left) || ts.isElementAccessExpression(expression.left)) {
-        const tempVar = context.createTempNameForNode(expression.right);
         const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
         const left = transformAssignmentLeftHandSideExpression(context, expression.left, precedingStatements.length > 0);
-        context.addPrecedingStatements([
-            ...precedingStatements,
-            lua.createVariableDeclarationStatement(tempVar, right, expression.right),
-            lua.createAssignmentStatement(left, lua.cloneIdentifier(tempVar), expression.left),
-        ]);
-        return lua.cloneIdentifier(tempVar);
+        context.addPrecedingStatements(precedingStatements);
+        const rightExpr = (0, expression_list_1.moveToPrecedingTemp)(context, right, expression.right);
+        context.addPrecedingStatements(lua.createAssignmentStatement(left, rightExpr, expression.left));
+        return rightExpr;
     }
     else {
         // Simple assignment
@@ -158,16 +152,8 @@ function transformAssignmentStatement(context, expression) {
             const left = expression.left.elements.map(e => transformAssignmentLeftHandSideExpression(context, e));
             return [lua.createAssignmentStatement(left, right, expression)];
         }
-        let [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
-        context.addPrecedingStatements(rightPrecedingStatements);
-        if ((0, multi_1.isMultiReturnCall)(context, expression.right)) {
-            right = (0, lua_ast_1.wrapInTable)(right);
-        }
-        const rootIdentifier = context.createTempNameForNode(expression.left);
-        return [
-            lua.createVariableDeclarationStatement(rootIdentifier, right),
-            ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier, rightPrecedingStatements.length > 0),
-        ];
+        const { statements } = transformDestructuredAssignmentExpression(context, expression);
+        return statements;
     }
     else {
         const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));

package/dist/transformation/visitors/binary-expression/compound.d.ts

@@ -6,7 +6,10 @@ export declare const isCompoundAssignmentToken: (token: ts.BinaryOperator) => to
 export declare const unwrapCompoundAssignmentToken: (token: ts.CompoundAssignmentOperator) => CompoundAssignmentToken;
 export declare function transformCompoundAssignment(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): {
     statements: lua.Statement[];
-    result: lua.AssignmentLeftHandSideExpression;
+    result: lua.Identifier;
+} | {
+    statements: lua.Statement[];
+    result: lua.TableIndexExpression;
 };
 export declare function transformCompoundAssignmentExpression(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): lua.Expression;
 export declare function transformCompoundAssignmentStatement(context: TransformationContext, node: ts.Node, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken): lua.Statement[];

package/dist/transformation/visitors/binary-expression/compound.js

@@ -39,7 +39,7 @@ exports.unwrapCompoundAssignmentToken = unwrapCompoundAssignmentToken;
 function transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix) {
     const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
     const [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
-    if (lua.isTableIndexExpression(left) && shouldCacheTableIndexExpressions(left, rightPrecedingStatements)) {
+    if (lua.isTableIndexExpression(left)) {
         // Complex property/element accesses need to cache object/index expressions to avoid repeating side-effects
         // local __obj, __index = ${objExpression}, ${indexExpression};
         const obj = context.createTempNameForLuaExpression(left.table);
@@ -60,6 +60,15 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
             };
         }
         else {
+            if (isSetterSkippingCompoundAssignmentOperator(operator)) {
+                return {
+                    statements: [
+                        objAndIndexDeclaration,
+                        ...transformSetterSkippingCompoundAssignment(accessExpression, operator, right, rightPrecedingStatements),
+                    ],
+                    result: left,
+                };
+            }
             // local ____tmp = ____obj[____index] ${replacementOperator} ${right};
             // ____obj[____index] = ____tmp;
             // return ____tmp
@@ -83,24 +92,6 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
         const assignStatements = (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, rightPrecedingStatements);
         return { statements: [tmpDeclaration, ...precedingStatements, ...assignStatements], result: tmpIdentifier };
     }
-    else if (ts.isPropertyAccessExpression(lhs) || ts.isElementAccessExpression(lhs)) {
-        // Simple property/element access expressions need to cache in temp to avoid double-evaluation
-        // local ____tmp = ${left} ${replacementOperator} ${right};
-        // ${left} = ____tmp;
-        // return ____tmp
-        const tmpIdentifier = context.createTempNameForLuaExpression(left);
-        const [precedingStatements, operatorExpression] = (0, binary_expression_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, expression);
-        const tmpDeclaration = lua.createVariableDeclarationStatement(tmpIdentifier, operatorExpression);
-        if (isSetterSkippingCompoundAssignmentOperator(operator)) {
-            const statements = [
-                tmpDeclaration,
-                ...transformSetterSkippingCompoundAssignment(tmpIdentifier, operator, right, precedingStatements),
-            ];
-            return { statements, result: tmpIdentifier };
-        }
-        const assignStatements = (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, tmpIdentifier, precedingStatements);
-        return { statements: [tmpDeclaration, ...assignStatements], result: tmpIdentifier };
-    }
     else {
         if (rightPrecedingStatements.length > 0 && isSetterSkippingCompoundAssignmentOperator(operator)) {
             return {

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

@@ -1,11 +1,9 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
-export declare type PropertyCallExpression = ts.CallExpression & {
-    expression: ts.PropertyAccessExpression;
-};
 export declare function validateArguments(context: TransformationContext, params: readonly ts.Expression[], signature?: ts.Signature): void;
 export declare function transformArguments(context: TransformationContext, params: readonly ts.Expression[], signature?: ts.Signature, callContext?: ts.Expression): lua.Expression[];
 export declare function transformCallAndArguments(context: TransformationContext, callExpression: ts.Expression, params: readonly ts.Expression[], signature?: ts.Signature, callContext?: ts.Expression): [lua.Expression, lua.Expression[]];
 export declare function transformContextualCallExpression(context: TransformationContext, node: ts.CallExpression | ts.TaggedTemplateExpression, args: ts.Expression[] | ts.NodeArray<ts.Expression>, signature?: ts.Signature): lua.Expression;
 export declare const transformCallExpression: FunctionVisitor<ts.CallExpression>;
+export declare function getCalledExpression(node: ts.CallExpression): ts.Expression;