typescript-to-lua 1.4.2 → 1.5.0

package/dist/transformation/builtins/promise.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformPromiseConstructorCall = exports.createPromiseIdentifier = exports.isPromiseClass = void 0;
+exports.createStaticPromiseFunctionAccessor = exports.transformPromiseConstructorCall = exports.createPromiseIdentifier = exports.isPromiseClass = void 0;
 const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const lualib_1 = require("../utils/lualib");
@@ -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,16 +30,17 @@ 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;
 function createStaticPromiseFunctionAccessor(functionName, node) {
     return lua.createTableIndexExpression(lua.createIdentifier("__TS__Promise"), lua.createStringLiteral(functionName), node);
 }
+exports.createStaticPromiseFunctionAccessor = createStaticPromiseFunctionAccessor;
 //# sourceMappingURL=promise.js.map

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,18 +10,17 @@ 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);
         case "replaceAll":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringReplaceAll, node, caller, ...params);
         case "concat":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringConcat, node, caller, ...params);
+            return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("table"), lua.createStringLiteral("concat")), [(0, lua_ast_1.wrapInTable)(caller, ...params)], node);
         case "indexOf": {
             const stringExpression = createStringCall("find", node, caller, params[0], params[1]
                 ? // string.find handles negative indexes by making it relative to string end, but for indexOf it's the same as 0
@@ -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/utils/diagnostics.d.ts

@@ -1,5 +1,5 @@
 import * as ts from "typescript";
-import { LuaTarget } from "../../CompilerOptions";
+import { LuaTarget, TypeScriptToLuaOptions } from "../../CompilerOptions";
 import { AnnotationKind } from "./annotations";
 export declare const unsupportedNodeKind: ((node: ts.Node, kind: ts.SyntaxKind) => ts.Diagnostic) & {
     code: number;
@@ -43,7 +43,11 @@ export declare const unsupportedAccessorInObjectLiteral: ((node: ts.Node, ...arg
 export declare const unsupportedRightShiftOperator: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
-export declare const unsupportedForTarget: ((node: ts.Node, functionality: string, version: LuaTarget.Lua51 | LuaTarget.Lua52 | LuaTarget.Lua53 | LuaTarget.Lua54 | LuaTarget.LuaJIT) => ts.Diagnostic) & {
+declare type NonUniversalTarget = Exclude<LuaTarget, LuaTarget.Universal>;
+export declare const unsupportedForTarget: ((node: ts.Node, functionality: string, version: NonUniversalTarget) => ts.Diagnostic) & {
+    code: number;
+};
+export declare const unsupportedForTargetButOverrideAvailable: ((node: ts.Node, functionality: string, version: NonUniversalTarget, optionName: keyof TypeScriptToLuaOptions) => ts.Diagnostic) & {
     code: number;
 };
 export declare const unsupportedProperty: ((node: ts.Node, parentName: string, property: string) => ts.Diagnostic) & {
@@ -97,3 +101,4 @@ export declare const unsupportedOptionalCompileMembersOnly: ((node: ts.Node, ...
 export declare const undefinedInArrayLiteral: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
+export {};

package/dist/transformation/utils/diagnostics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.undefinedInArrayLiteral = exports.unsupportedOptionalCompileMembersOnly = exports.unsupportedBuiltinOptionalCall = exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidTableExtensionUse = exports.invalidOperatorMappingUse = exports.invalidMultiReturnAccess = exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = exports.invalidMultiTypeToNonArrayLiteral = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.invalidPairsIterableWithoutDestructuring = exports.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
+exports.undefinedInArrayLiteral = exports.unsupportedOptionalCompileMembersOnly = exports.unsupportedBuiltinOptionalCall = exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidTableExtensionUse = exports.invalidOperatorMappingUse = exports.invalidMultiReturnAccess = exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = exports.invalidMultiTypeToNonArrayLiteral = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTargetButOverrideAvailable = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.invalidPairsIterableWithoutDestructuring = exports.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const utils_1 = require("../../utils");
@@ -41,6 +41,9 @@ exports.unsupportedAccessorInObjectLiteral = createErrorDiagnosticFactory("Acces
 exports.unsupportedRightShiftOperator = createErrorDiagnosticFactory("Right shift operator is not supported for target Lua 5.3. Use `>>>` instead.");
 const getLuaTargetName = (version) => (version === CompilerOptions_1.LuaTarget.LuaJIT ? "LuaJIT" : `Lua ${version}`);
 exports.unsupportedForTarget = createErrorDiagnosticFactory((functionality, version) => `${functionality} is/are not supported for target ${getLuaTargetName(version)}.`);
+exports.unsupportedForTargetButOverrideAvailable = createErrorDiagnosticFactory((functionality, version, optionName) => `As a precaution, ${functionality} is/are not supported for target ${getLuaTargetName(version)} due to language features/limitations. ` +
+    `However "--${optionName}" can be used to bypass this precaution. ` +
+    "See https://typescripttolua.github.io/docs/configuration for more information.");
 exports.unsupportedProperty = createErrorDiagnosticFactory((parentName, property) => `${parentName}.${property} is unsupported.`);
 exports.invalidAmbientIdentifierName = createErrorDiagnosticFactory((text) => `Invalid ambient identifier name '${text}'. Ambient identifiers must be valid lua identifiers.`);
 exports.unsupportedVarDeclaration = createErrorDiagnosticFactory("`var` declarations are not supported. Use `let` or `const` instead.");

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

@@ -8,6 +8,7 @@ export declare function createExportsIdentifier(): lua.Identifier;
 export declare function addToNumericExpression(expression: lua.Expression, change: number): lua.Expression;
 export declare function getNumberLiteralValue(expression?: lua.Expression): number | undefined;
 export declare function createUnpackCall(context: TransformationContext, expression: lua.Expression, tsOriginal?: ts.Node): lua.Expression;
+export declare function isUnpackCall(node: lua.Node): boolean;
 export declare function wrapInTable(...expressions: lua.Expression[]): lua.TableExpression;
 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;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNaN = exports.createLocalOrExportedOrGlobalDeclaration = exports.createHoistableVariableDeclarationStatement = exports.wrapInToStringForConcat = exports.wrapInTable = exports.createUnpackCall = exports.getNumberLiteralValue = exports.addToNumericExpression = exports.createExportsIdentifier = exports.createSelfIdentifier = exports.unwrapVisitorResult = void 0;
+exports.createNaN = exports.createLocalOrExportedOrGlobalDeclaration = exports.createHoistableVariableDeclarationStatement = exports.wrapInToStringForConcat = exports.wrapInTable = exports.isUnpackCall = exports.createUnpackCall = exports.getNumberLiteralValue = exports.addToNumericExpression = exports.createExportsIdentifier = exports.createSelfIdentifier = exports.unwrapVisitorResult = void 0;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const lua = require("../../LuaAST");
@@ -62,9 +62,13 @@ function createUnpackCall(context, expression, tsOriginal) {
     const unpack = context.luaTarget === CompilerOptions_1.LuaTarget.Lua51 || context.luaTarget === CompilerOptions_1.LuaTarget.LuaJIT
         ? lua.createIdentifier("unpack")
         : lua.createTableIndexExpression(lua.createIdentifier("table"), lua.createStringLiteral("unpack"));
-    return lua.createCallExpression(unpack, [expression], tsOriginal);
+    return lua.setNodeFlags(lua.createCallExpression(unpack, [expression], tsOriginal), lua.NodeFlags.TableUnpackCall);
 }
 exports.createUnpackCall = createUnpackCall;
+function isUnpackCall(node) {
+    return lua.isCallExpression(node) && (node.flags & lua.NodeFlags.TableUnpackCall) !== 0;
+}
+exports.isUnpackCall = isUnpackCall;
 function wrapInTable(...expressions) {
     const fields = expressions.map(e => lua.createTableFieldExpression(e));
     return lua.createTableExpression(fields);
@@ -100,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) {
@@ -118,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)) {
@@ -159,6 +164,7 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
             }
         }
     }
+    setJSDocComments(context, tsOriginal, declaration, assignment);
     if (declaration && assignment) {
         return [declaration, assignment];
     }
@@ -173,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/utils/typescript/index.d.ts

@@ -7,6 +7,7 @@ export declare function hasExportEquals(sourceFile: ts.SourceFile): boolean;
  * Search up until finding a node satisfying the callback
  */
 export declare function findFirstNodeAbove<T extends ts.Node>(node: ts.Node, callback: (n: ts.Node) => n is T): T | undefined;
+export declare function findFirstNonOuterParent(node: ts.Node): ts.Node;
 export declare function getFirstDeclarationInFile(symbol: ts.Symbol, sourceFile: ts.SourceFile): ts.Declaration | undefined;
 export declare function isStandardLibraryType(context: TransformationContext, type: ts.Type, name: string | undefined): boolean;
 export declare function hasStandardLibrarySignature(context: TransformationContext, callExpression: ts.CallExpression): boolean;

package/dist/transformation/utils/typescript/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.getFirstDeclarationInFile = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
+exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.getFirstDeclarationInFile = exports.findFirstNonOuterParent = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
 const ts = require("typescript");
 __exportStar(require("./nodes"), exports);
 __exportStar(require("./types"), exports);
@@ -38,6 +38,14 @@ function findFirstNodeAbove(node, callback) {
     }
 }
 exports.findFirstNodeAbove = findFirstNodeAbove;
+function findFirstNonOuterParent(node) {
+    let current = ts.getOriginalNode(node).parent;
+    while (ts.isOuterExpression(current)) {
+        current = ts.getOriginalNode(current).parent;
+    }
+    return current;
+}
+exports.findFirstNonOuterParent = findFirstNonOuterParent;
 function getFirstDeclarationInFile(symbol, sourceFile) {
     var _a, _b;
     const originalSourceFile = (_a = ts.getParseTreeNode(sourceFile)) !== null && _a !== void 0 ? _a : sourceFile;

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/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;

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");
@@ -17,6 +17,7 @@ const expression_list_1 = require("./expression-list");
 const preceding_statements_1 = require("../utils/preceding-statements");
 const optional_chaining_1 = require("./optional-chaining");
 const language_extensions_1 = require("./language-extensions");
+const import_1 = require("./modules/import");
 function validateArguments(context, params, signature) {
     if (!signature || signature.parameters.length < params.length) {
         return;
@@ -81,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) &&
@@ -112,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);
@@ -145,11 +146,15 @@ function transformElementCall(context, node) {
 }
 const transformCallExpression = (node, context) => {
     var _a;
+    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)) {
@@ -160,22 +165,22 @@ 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);
     }
@@ -184,13 +189,13 @@ const transformCallExpression = (node, context) => {
     let parameters;
     const isContextualCall = !signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void;
     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) {
@@ -199,4 +204,12 @@ const transformCallExpression = (node, context) => {
     return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(callExpression) : callExpression;
 };
 exports.transformCallExpression = transformCallExpression;
+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/class/index.js

@@ -96,7 +96,7 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
         const constructorBody = (0, fields_1.transformClassInstanceFields)(context, instanceFields);
         const superCall = lua.createExpressionStatement(lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), [(0, lua_ast_1.createSelfIdentifier)(), lua.createDotsLiteral()]));
         constructorBody.unshift(superCall);
-        const constructorFunction = lua.createFunctionExpression(lua.createBlock(constructorBody), [(0, lua_ast_1.createSelfIdentifier)()], lua.createDotsLiteral(), lua.FunctionExpressionFlags.Declaration);
+        const constructorFunction = lua.createFunctionExpression(lua.createBlock(constructorBody), [(0, lua_ast_1.createSelfIdentifier)()], lua.createDotsLiteral(), lua.NodeFlags.Declaration);
         result.push(lua.createAssignmentStatement((0, constructor_1.createConstructorName)(localClassName), constructorFunction, classDeclaration));
     }
     // Transform accessors

package/dist/transformation/visitors/class/members/accessors.js

@@ -11,7 +11,7 @@ const constructor_1 = require("./constructor");
 function transformAccessor(context, node) {
     const [params, dot, restParam] = (0, function_1.transformParameters)(context, node.parameters, (0, lua_ast_1.createSelfIdentifier)());
     const body = node.body ? (0, function_1.transformFunctionBody)(context, node.parameters, node.body, restParam)[0] : [];
-    return lua.createFunctionExpression(lua.createBlock(body), params, dot, lua.FunctionExpressionFlags.Declaration);
+    return lua.createFunctionExpression(lua.createBlock(body), params, dot, lua.NodeFlags.Declaration);
 }
 function transformAccessorDeclarations(context, { firstAccessor, getAccessor, setAccessor }, className) {
     const propertyName = (0, literal_1.transformPropertyName)(context, firstAccessor.name);

package/dist/transformation/visitors/class/members/constructor.js

@@ -59,7 +59,7 @@ function transformConstructorDeclaration(context, statement, className, instance
     const block = lua.createBlock(bodyWithFieldInitializers);
     const constructorWasGenerated = statement.pos === -1;
     (0, scope_1.popScope)(context);
-    return lua.createAssignmentStatement(createConstructorName(className), lua.createFunctionExpression(block, params, dotsLiteral, lua.FunctionExpressionFlags.Declaration), constructorWasGenerated ? classDeclaration : statement);
+    return lua.createAssignmentStatement(createConstructorName(className), lua.createFunctionExpression(block, params, dotsLiteral, lua.NodeFlags.Declaration), constructorWasGenerated ? classDeclaration : statement);
 }
 exports.transformConstructorDeclaration = transformConstructorDeclaration;
 //# sourceMappingURL=constructor.js.map