typescript-to-lua 0.41.2 → 1.1.0

package/dist/transformation/builtins/string.js

@@ -13,35 +13,37 @@ function createStringCall(methodName, tsOriginal, ...params) {
 function transformStringPrototypeCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = call_1.transformArguments(context, node.arguments, signature);
+    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
     const caller = context.transformExpression(expression.expression);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "replace":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringReplace, node, caller, ...params);
+            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 lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringConcat, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringConcat, node, caller, ...params);
         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
-                    lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("math"), lua.createStringLiteral("max")), [lua_ast_1.addToNumericExpression(params[1], 1), lua.createNumericLiteral(1)])
+                    lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("math"), lua.createStringLiteral("max")), [(0, lua_ast_1.addToNumericExpression)(params[1], 1), lua.createNumericLiteral(1)])
                 : lua.createNilLiteral(), lua.createBooleanLiteral(true));
             return lua.createBinaryExpression(lua.createBinaryExpression(stringExpression, lua.createNumericLiteral(0), lua.SyntaxKind.OrOperator), lua.createNumericLiteral(1), lua.SyntaxKind.SubtractionOperator, node);
         }
         case "substr":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSubstr, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSubstr, node, caller, ...params);
         case "substring":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSubstring, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSubstring, node, caller, ...params);
         case "slice": {
-            const literalArg1 = lua_ast_1.getNumberLiteralValue(params[0]);
+            const literalArg1 = (0, lua_ast_1.getNumberLiteralValue)(params[0]);
             if (params[0] && literalArg1 !== undefined) {
                 let stringSubArgs = [
-                    lua_ast_1.addToNumericExpression(params[0], literalArg1 < 0 ? 0 : 1),
+                    (0, lua_ast_1.addToNumericExpression)(params[0], literalArg1 < 0 ? 0 : 1),
                 ];
                 if (params[1]) {
-                    const literalArg2 = lua_ast_1.getNumberLiteralValue(params[1]);
+                    const literalArg2 = (0, lua_ast_1.getNumberLiteralValue)(params[1]);
                     if (literalArg2 !== undefined) {
-                        stringSubArgs.push(lua_ast_1.addToNumericExpression(params[1], literalArg2 < 0 ? -1 : 0));
+                        stringSubArgs.push((0, lua_ast_1.addToNumericExpression)(params[1], literalArg2 < 0 ? -1 : 0));
                     }
                     else {
                         stringSubArgs = undefined;
@@ -52,69 +54,69 @@ function transformStringPrototypeCall(context, node) {
                     return createStringCall("sub", node, caller, ...stringSubArgs);
                 }
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSlice, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSlice, node, caller, ...params);
         }
         case "toLowerCase":
             return createStringCall("lower", node, caller);
         case "toUpperCase":
             return createStringCall("upper", node, caller);
         case "trim":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringTrim, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringTrim, node, caller);
         case "trimEnd":
         case "trimRight":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringTrimEnd, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringTrimEnd, node, caller);
         case "trimStart":
         case "trimLeft":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringTrimStart, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringTrimStart, node, caller);
         case "split":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSplit, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSplit, node, caller, ...params);
         case "charAt": {
-            const literalValue = lua_ast_1.getNumberLiteralValue(params[0]);
+            const literalValue = (0, lua_ast_1.getNumberLiteralValue)(params[0]);
             // Inline string.sub call if we know that parameter is pure and isn't negative
             if (literalValue !== undefined && literalValue >= 0) {
-                const firstParamPlusOne = lua_ast_1.addToNumericExpression(params[0], 1);
+                const firstParamPlusOne = (0, lua_ast_1.addToNumericExpression)(params[0], 1);
                 return createStringCall("sub", node, caller, firstParamPlusOne, firstParamPlusOne);
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringCharAt, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringCharAt, node, caller, ...params);
         }
         case "charCodeAt": {
-            const literalValue = lua_ast_1.getNumberLiteralValue(params[0]);
+            const literalValue = (0, lua_ast_1.getNumberLiteralValue)(params[0]);
             // Inline string.sub call if we know that parameter is pure and isn't negative
             if (literalValue !== undefined && literalValue >= 0) {
-                return lua.createBinaryExpression(createStringCall("byte", node, caller, lua_ast_1.addToNumericExpression(params[0], 1)), lua_ast_1.createNaN(), lua.SyntaxKind.OrOperator);
+                return lua.createBinaryExpression(createStringCall("byte", node, caller, (0, lua_ast_1.addToNumericExpression)(params[0], 1)), (0, lua_ast_1.createNaN)(), lua.SyntaxKind.OrOperator);
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringCharCodeAt, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringCharCodeAt, node, caller, ...params);
         }
         case "startsWith":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringStartsWith, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringStartsWith, node, caller, ...params);
         case "endsWith":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringEndsWith, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringEndsWith, node, caller, ...params);
         case "includes":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringIncludes, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringIncludes, node, caller, ...params);
         case "repeat":
             const math = lua.createIdentifier("math");
             const floor = lua.createStringLiteral("floor");
             const parameter = lua.createCallExpression(lua.createTableIndexExpression(math, floor), [params[0]]);
             return createStringCall("rep", node, caller, parameter);
         case "padStart":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringPadStart, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringPadStart, node, caller, ...params);
         case "padEnd":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringPadEnd, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringPadEnd, node, caller, ...params);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "string", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "string", expressionName));
     }
 }
 exports.transformStringPrototypeCall = transformStringPrototypeCall;
 function transformStringConstructorCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = call_1.transformArguments(context, node.arguments, signature);
+    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "fromCharCode":
             return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("string"), lua.createStringLiteral("char")), params, node);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "String", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "String", expressionName));
     }
 }
 exports.transformStringConstructorCall = transformStringConstructorCall;
@@ -124,7 +126,7 @@ function transformStringProperty(context, node) {
             const expression = context.transformExpression(node.expression);
             return lua.createUnaryExpression(expression, lua.SyntaxKind.LengthOperator, node);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(node.name, "string", node.name.text));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(node.name, "string", node.name.text));
     }
 }
 exports.transformStringProperty = transformStringProperty;

package/dist/transformation/builtins/symbol.js

@@ -8,17 +8,17 @@ const call_1 = require("../visitors/call");
 function transformSymbolConstructorCall(context, expression) {
     const method = expression.expression;
     const signature = context.checker.getResolvedSignature(expression);
-    const parameters = call_1.transformArguments(context, expression.arguments, signature);
+    const parameters = (0, call_1.transformArguments)(context, expression.arguments, signature);
     const methodName = method.name.text;
     switch (methodName) {
         case "for":
         case "keyFor":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.SymbolRegistry);
+            (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);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(method.name, "Symbol", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "Symbol", methodName));
     }
 }
 exports.transformSymbolConstructorCall = transformSymbolConstructorCall;

package/dist/transformation/context/context.js

@@ -35,13 +35,13 @@ class TransformationContext {
         }
         const nodeVisitors = this.visitorMap.get(node.kind);
         if (!nodeVisitors || nodeVisitors.length === 0) {
-            this.diagnostics.push(diagnostics_1.unsupportedNodeKind(node, node.kind));
+            this.diagnostics.push((0, diagnostics_1.unsupportedNodeKind)(node, node.kind));
             return isExpression ? [lua.createNilLiteral()] : [];
         }
         const previousNodeVisitors = this.currentNodeVisitors;
         this.currentNodeVisitors = [...nodeVisitors];
         const visitor = this.currentNodeVisitors.pop();
-        const result = lua_ast_1.unwrapVisitorResult(visitor.transform(node, this));
+        const result = (0, lua_ast_1.unwrapVisitorResult)(visitor.transform(node, this));
         this.currentNodeVisitors = previousNodeVisitors;
         return result;
     }
@@ -50,7 +50,7 @@ class TransformationContext {
             throw new Error(`There is no super transform for ${ts.SyntaxKind[node.kind]} visitor`);
         }
         const visitor = this.currentNodeVisitors.pop();
-        return lua_ast_1.unwrapVisitorResult(visitor.transform(node, this));
+        return (0, lua_ast_1.unwrapVisitorResult)(visitor.transform(node, this));
     }
     transformExpression(node) {
         const [result] = this.transformNode(node, true);
@@ -67,10 +67,10 @@ class TransformationContext {
         return result;
     }
     transformStatements(node) {
-        return utils_1.castArray(node).flatMap(n => this.transformNode(n));
+        return (0, utils_1.castArray)(node).flatMap(n => this.transformNode(n));
     }
     superTransformStatements(node) {
-        return utils_1.castArray(node).flatMap(n => this.superTransformNode(n));
+        return (0, utils_1.castArray)(node).flatMap(n => this.superTransformNode(n));
     }
 }
 exports.TransformationContext = TransformationContext;

package/dist/transformation/index.js

@@ -12,7 +12,7 @@ function createVisitorMap(customVisitors) {
             if (!visitor)
                 continue;
             const syntaxKind = Number(syntaxKindKey);
-            const nodeVisitors = utils_1.getOrUpdate(visitorMap, syntaxKind, () => []);
+            const nodeVisitors = (0, utils_1.getOrUpdate)(visitorMap, syntaxKind, () => []);
             const objectVisitor = typeof visitor === "function" ? { transform: visitor, priority } : visitor;
             nodeVisitors.push(objectVisitor);
         }

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

@@ -14,9 +14,7 @@ export declare enum AnnotationKind {
     NoSelf = "noSelf",
     NoSelfInFile = "noSelfInFile",
     Vararg = "vararg",
-    ForRange = "forRange",
-    Jsx = "jsx",
-    JsxFrag = "jsxFrag"
+    ForRange = "forRange"
 }
 export interface Annotation {
     kind: AnnotationKind;
@@ -29,7 +27,6 @@ export declare function getNodeAnnotations(node: ts.Node): AnnotationsMap;
 export declare function getFileAnnotations(sourceFile: ts.SourceFile): AnnotationsMap;
 export declare function getSignatureAnnotations(context: TransformationContext, signature: ts.Signature): AnnotationsMap;
 export declare function isTupleReturnCall(context: TransformationContext, node: ts.Node): boolean;
-export declare function isInTupleReturnFunction(context: TransformationContext, node: ts.Node): boolean;
 export declare function isLuaIteratorType(context: TransformationContext, node: ts.Node): boolean;
 export declare function isVarargType(context: TransformationContext, node: ts.Node): boolean;
 export declare function isForRangeType(context: TransformationContext, node: ts.Node): boolean;

package/dist/transformation/utils/annotations.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTagArgsFromComment = exports.isForRangeType = exports.isVarargType = exports.isLuaIteratorType = exports.isInTupleReturnFunction = exports.isTupleReturnCall = exports.getSignatureAnnotations = exports.getFileAnnotations = exports.getNodeAnnotations = exports.getTypeAnnotations = exports.getSymbolAnnotations = exports.AnnotationKind = void 0;
+exports.getTagArgsFromComment = exports.isForRangeType = exports.isVarargType = exports.isLuaIteratorType = exports.isTupleReturnCall = exports.getSignatureAnnotations = exports.getFileAnnotations = exports.getNodeAnnotations = exports.getTypeAnnotations = exports.getSymbolAnnotations = exports.AnnotationKind = void 0;
 const ts = require("typescript");
-const typescript_1 = require("./typescript");
 var AnnotationKind;
 (function (AnnotationKind) {
     AnnotationKind["Extension"] = "extension";
@@ -19,8 +18,6 @@ var AnnotationKind;
     AnnotationKind["NoSelfInFile"] = "noSelfInFile";
     AnnotationKind["Vararg"] = "vararg";
     AnnotationKind["ForRange"] = "forRange";
-    AnnotationKind["Jsx"] = "jsx";
-    AnnotationKind["JsxFrag"] = "jsxFrag";
 })(AnnotationKind = exports.AnnotationKind || (exports.AnnotationKind = {}));
 function createAnnotation(name, args) {
     const kind = Object.values(AnnotationKind).find(k => k.toLowerCase() === name.toLowerCase());
@@ -118,34 +115,6 @@ function isTupleReturnCall(context, node) {
     return getTypeAnnotations(type).has(AnnotationKind.TupleReturn);
 }
 exports.isTupleReturnCall = isTupleReturnCall;
-function isInTupleReturnFunction(context, node) {
-    const declaration = typescript_1.findFirstNodeAbove(node, ts.isFunctionLike);
-    if (!declaration) {
-        return false;
-    }
-    let functionType;
-    if (ts.isFunctionExpression(declaration) || ts.isArrowFunction(declaration)) {
-        functionType = typescript_1.inferAssignedType(context, declaration);
-    }
-    else if (ts.isMethodDeclaration(declaration) && ts.isObjectLiteralExpression(declaration.parent)) {
-        // Manually lookup type for object literal properties declared with method syntax
-        const interfaceType = typescript_1.inferAssignedType(context, declaration.parent);
-        const propertySymbol = interfaceType.getProperty(declaration.name.getText());
-        if (propertySymbol) {
-            functionType = context.checker.getTypeOfSymbolAtLocation(propertySymbol, declaration);
-        }
-    }
-    if (functionType === undefined) {
-        functionType = context.checker.getTypeAtLocation(declaration);
-    }
-    // Check all overloads for directive
-    const signatures = functionType.getCallSignatures();
-    if (signatures === null || signatures === void 0 ? void 0 : signatures.some(s => getSignatureAnnotations(context, s).has(AnnotationKind.TupleReturn))) {
-        return true;
-    }
-    return getTypeAnnotations(functionType).has(AnnotationKind.TupleReturn);
-}
-exports.isInTupleReturnFunction = isInTupleReturnFunction;
 function isLuaIteratorType(context, node) {
     const type = context.checker.getTypeAtLocation(node);
     return getTypeAnnotations(type).has(AnnotationKind.LuaIterator);

package/dist/transformation/utils/assignment-validation.js

@@ -16,7 +16,7 @@ function validateAssignment(context, node, fromType, toType, toName) {
         return;
     }
     // Use cache to avoid repeating check for same types (protects against infinite loop in recursive types)
-    const fromTypeCache = utils_1.getOrUpdate(typeValidationCache, fromType, () => new Set());
+    const fromTypeCache = (0, utils_1.getOrUpdate)(typeValidationCache, fromType, () => new Set());
     if (fromTypeCache.has(toType))
         return;
     fromTypeCache.add(toType);
@@ -40,7 +40,8 @@ function validateAssignment(context, node, fromType, toType, toName) {
         }
     }
     if ((toType.flags & ts.TypeFlags.Object) !== 0 &&
-        (toType.objectFlags & ts.ObjectFlags.ClassOrInterface) !== 0 &&
+        (ts.isTypeLiteralNode(toTypeNode) ||
+            (toType.objectFlags & ts.ObjectFlags.ClassOrInterface) !== 0) &&
         toType.symbol &&
         toType.symbol.members &&
         fromType.symbol &&
@@ -61,15 +62,15 @@ function validateAssignment(context, node, fromType, toType, toName) {
 }
 exports.validateAssignment = validateAssignment;
 function validateFunctionAssignment(context, node, fromType, toType, toName) {
-    const fromContext = function_context_1.getFunctionContextType(context, fromType);
-    const toContext = function_context_1.getFunctionContextType(context, toType);
+    const fromContext = (0, function_context_1.getFunctionContextType)(context, fromType);
+    const toContext = (0, function_context_1.getFunctionContextType)(context, toType);
     if (fromContext === function_context_1.ContextType.Mixed || toContext === function_context_1.ContextType.Mixed) {
-        context.diagnostics.push(diagnostics_1.unsupportedOverloadAssignment(node, toName));
+        context.diagnostics.push((0, diagnostics_1.unsupportedOverloadAssignment)(node, toName));
     }
     else if (fromContext !== toContext && fromContext !== function_context_1.ContextType.None && toContext !== function_context_1.ContextType.None) {
         context.diagnostics.push(toContext === function_context_1.ContextType.Void
-            ? diagnostics_1.unsupportedNoSelfFunctionConversion(node, toName)
-            : diagnostics_1.unsupportedSelfFunctionConversion(node, toName));
+            ? (0, diagnostics_1.unsupportedNoSelfFunctionConversion)(node, toName)
+            : (0, diagnostics_1.unsupportedSelfFunctionConversion)(node, toName));
     }
 }
 //# sourceMappingURL=assignment-validation.js.map

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

@@ -88,3 +88,6 @@ export declare const annotationDeprecated: ((node: ts.Node, kind: AnnotationKind
 export declare const notAllowedOptionalAssignment: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
+export declare const awaitMustBeInAsyncFunction: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+    code: number;
+};

package/dist/transformation/utils/diagnostics.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidTableSetExpression = exports.invalidTableDeleteExpression = 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.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
+exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidTableSetExpression = exports.invalidTableDeleteExpression = 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.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");
-const createDiagnosticFactory = (category, message) => utils_1.createSerialDiagnosticFactory((node, ...args) => ({
-    file: node.getSourceFile(),
-    start: node.getStart(),
-    length: node.getWidth(),
+const createDiagnosticFactory = (category, message) => (0, utils_1.createSerialDiagnosticFactory)((node, ...args) => ({
+    file: ts.getOriginalNode(node).getSourceFile(),
+    start: ts.getOriginalNode(node).getStart(),
+    length: ts.getOriginalNode(node).getWidth(),
     messageText: typeof message === "string" ? message : message(...args),
     category,
 }));
@@ -57,4 +57,5 @@ exports.annotationRemoved = createErrorDiagnosticFactory((kind) => `'@${kind}' h
 exports.annotationDeprecated = createWarningDiagnosticFactory((kind) => `'@${kind}' is deprecated and will be removed in a future update. Please update your code before upgrading to the next release, otherwise your project will no longer compile. ` +
     `See https://typescripttolua.github.io/docs/advanced/compiler-annotations#${kind.toLowerCase()} for more information.`);
 exports.notAllowedOptionalAssignment = createErrorDiagnosticFactory("The left-hand side of an assignment expression may not be an optional property access.");
+exports.awaitMustBeInAsyncFunction = createErrorDiagnosticFactory("Await can only be used inside async functions.");
 //# sourceMappingURL=diagnostics.js.map

package/dist/transformation/utils/export.js

@@ -25,7 +25,7 @@ function getExportedSymbolDeclaration(symbol) {
 exports.getExportedSymbolDeclaration = getExportedSymbolDeclaration;
 function getSymbolFromIdentifier(context, identifier) {
     if (identifier.symbolId !== undefined) {
-        const symbolInfo = symbols_1.getSymbolInfo(context, identifier.symbolId);
+        const symbolInfo = (0, symbols_1.getSymbolInfo)(context, identifier.symbolId);
         if (symbolInfo !== undefined) {
             return symbolInfo.symbol;
         }
@@ -48,7 +48,7 @@ function getSymbolExportScope(context, symbol) {
     if (!exportedDeclaration) {
         return undefined;
     }
-    const scope = typescript_1.findFirstNodeAbove(exportedDeclaration, (n) => ts.isSourceFile(n) || ts.isModuleDeclaration(n));
+    const scope = (0, typescript_1.findFirstNodeAbove)(exportedDeclaration, (n) => ts.isSourceFile(n) || ts.isModuleDeclaration(n));
     if (!scope) {
         return undefined;
     }
@@ -98,8 +98,8 @@ function createExportedIdentifier(context, identifier, exportScope) {
         return identifier;
     }
     const exportTable = exportScope && ts.isModuleDeclaration(exportScope)
-        ? namespace_1.createModuleLocalNameIdentifier(context, exportScope)
-        : lua_ast_1.createExportsIdentifier();
+        ? (0, namespace_1.createModuleLocalNameIdentifier)(context, exportScope)
+        : (0, lua_ast_1.createExportsIdentifier)();
     return lua.createTableIndexExpression(exportTable, lua.createStringLiteral(identifier.text));
 }
 exports.createExportedIdentifier = createExportedIdentifier;

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

@@ -12,14 +12,14 @@ var ContextType;
     ContextType[ContextType["Mixed"] = 3] = "Mixed";
 })(ContextType = exports.ContextType || (exports.ContextType = {}));
 function hasNoSelfAncestor(declaration) {
-    const scopeDeclaration = typescript_1.findFirstNodeAbove(declaration, (node) => ts.isSourceFile(node) || ts.isModuleDeclaration(node));
+    const scopeDeclaration = (0, typescript_1.findFirstNodeAbove)(declaration, (node) => ts.isSourceFile(node) || ts.isModuleDeclaration(node));
     if (!scopeDeclaration) {
         return false;
     }
     else if (ts.isSourceFile(scopeDeclaration)) {
-        return annotations_1.getFileAnnotations(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelfInFile);
+        return (0, annotations_1.getFileAnnotations)(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelfInFile);
     }
-    else if (annotations_1.getNodeAnnotations(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
+    else if ((0, annotations_1.getNodeAnnotations)(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
         return true;
     }
     else {
@@ -38,7 +38,7 @@ function getDeclarationContextType({ program }, signatureDeclaration) {
             : ContextType.NonVoid;
     }
     // noSelf declaration on function signature
-    if (annotations_1.getNodeAnnotations(signatureDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
+    if ((0, annotations_1.getNodeAnnotations)(signatureDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
         return ContextType.Void;
     }
     if (ts.isMethodSignature(signatureDeclaration) ||
@@ -48,11 +48,11 @@ function getDeclarationContextType({ program }, signatureDeclaration) {
         (signatureDeclaration.parent && ts.isPropertyDeclaration(signatureDeclaration.parent)) ||
         (signatureDeclaration.parent && ts.isPropertySignature(signatureDeclaration.parent))) {
         // Class/interface methods only respect @noSelf on their parent
-        const scopeDeclaration = typescript_1.findFirstNodeAbove(signatureDeclaration, (n) => ts.isClassDeclaration(n) || ts.isClassExpression(n) || ts.isInterfaceDeclaration(n));
+        const scopeDeclaration = (0, typescript_1.findFirstNodeAbove)(signatureDeclaration, (n) => ts.isClassDeclaration(n) || ts.isClassExpression(n) || ts.isInterfaceDeclaration(n));
         if (scopeDeclaration === undefined) {
             return ContextType.NonVoid;
         }
-        if (annotations_1.getNodeAnnotations(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
+        if ((0, annotations_1.getNodeAnnotations)(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
             return ContextType.Void;
         }
         return ContextType.NonVoid;
@@ -89,15 +89,21 @@ function reduceContextTypes(contexts) {
 function getSignatureDeclarations(context, signatures) {
     return signatures.flatMap(signature => {
         const signatureDeclaration = signature.getDeclaration();
-        if ((ts.isFunctionExpression(signatureDeclaration) || ts.isArrowFunction(signatureDeclaration)) &&
+        let inferredType;
+        if (ts.isMethodDeclaration(signatureDeclaration) &&
+            ts.isObjectLiteralExpression(signatureDeclaration.parent) &&
+            !getExplicitThisParameter(signatureDeclaration)) {
+            inferredType = context.checker.getContextualTypeForObjectLiteralElement(signatureDeclaration);
+        }
+        else if ((ts.isFunctionExpression(signatureDeclaration) || ts.isArrowFunction(signatureDeclaration)) &&
             !getExplicitThisParameter(signatureDeclaration)) {
             // Infer type of function expressions/arrow functions
-            const inferredType = typescript_1.inferAssignedType(context, signatureDeclaration);
-            if (inferredType) {
-                const inferredSignatures = typescript_1.getAllCallSignatures(inferredType);
-                if (inferredSignatures.length > 0) {
-                    return inferredSignatures.map(s => s.getDeclaration());
-                }
+            inferredType = (0, typescript_1.inferAssignedType)(context, signatureDeclaration);
+        }
+        if (inferredType) {
+            const inferredSignatures = (0, typescript_1.getAllCallSignatures)(inferredType);
+            if (inferredSignatures.length > 0) {
+                return inferredSignatures.map(s => s.getDeclaration());
             }
         }
         return signatureDeclaration;

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

@@ -10,7 +10,7 @@ const scope_1 = require("./scope");
 const lualib_1 = require("./lualib");
 const LuaLib_1 = require("../../LuaLib");
 function unwrapVisitorResult(result) {
-    return result === undefined ? [] : utils_1.castArray(result);
+    return result === undefined ? [] : (0, utils_1.castArray)(result);
 }
 exports.unwrapVisitorResult = unwrapVisitorResult;
 function createSelfIdentifier(tsOriginal) {
@@ -58,7 +58,7 @@ exports.getNumberLiteralValue = getNumberLiteralValue;
 // Prefer use of transformToImmediatelyInvokedFunctionExpression to maintain correct scope. If you use this directly,
 // ensure you push/pop a function scope appropriately to avoid incorrect vararg optimization.
 function createImmediatelyInvokedFunctionExpression(statements, result, tsOriginal) {
-    const body = [...statements, lua.createReturnStatement(utils_1.castArray(result))];
+    const body = [...statements, lua.createReturnStatement((0, utils_1.castArray)(result))];
     const flags = statements.length === 0 ? lua.FunctionExpressionFlags.Inline : lua.FunctionExpressionFlags.None;
     const iife = lua.createFunctionExpression(lua.createBlock(body), undefined, undefined, flags);
     return lua.createCallExpression(iife, [], tsOriginal);
@@ -66,7 +66,7 @@ function createImmediatelyInvokedFunctionExpression(statements, result, tsOrigin
 exports.createImmediatelyInvokedFunctionExpression = createImmediatelyInvokedFunctionExpression;
 function createUnpackCall(context, expression, tsOriginal) {
     if (context.luaTarget === CompilerOptions_1.LuaTarget.Universal) {
-        return lualib_1.transformLuaLibFunction(context, LuaLib_1.LuaLibFeature.Unpack, tsOriginal, expression);
+        return (0, lualib_1.transformLuaLibFunction)(context, LuaLib_1.LuaLibFeature.Unpack, tsOriginal, expression);
     }
     const unpack = context.luaTarget === CompilerOptions_1.LuaTarget.Lua51 || context.luaTarget === CompilerOptions_1.LuaTarget.LuaJIT
         ? lua.createIdentifier("unpack")
@@ -91,8 +91,8 @@ exports.wrapInToStringForConcat = wrapInToStringForConcat;
 function createHoistableVariableDeclarationStatement(context, identifier, initializer, tsOriginal) {
     const declaration = lua.createVariableDeclarationStatement(identifier, initializer, tsOriginal);
     if (identifier.symbolId !== undefined) {
-        const scope = scope_1.peekScope(context);
-        utils_1.assert(scope.type !== scope_1.ScopeType.Switch);
+        const scope = (0, scope_1.peekScope)(context);
+        (0, utils_1.assert)(scope.type !== scope_1.ScopeType.Switch);
         if (!scope.variableDeclarations) {
             scope.variableDeclarations = [];
         }
@@ -106,32 +106,32 @@ function hasMultipleReferences(scope, identifiers) {
     if (!scopeSymbols) {
         return false;
     }
-    const referenceLists = utils_1.castArray(identifiers).map(i => i.symbolId && scopeSymbols.get(i.symbolId));
+    const referenceLists = (0, utils_1.castArray)(identifiers).map(i => i.symbolId && scopeSymbols.get(i.symbolId));
     return referenceLists.some(symbolRefs => symbolRefs && symbolRefs.length > 1);
 }
 function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal, overrideExportScope) {
     let declaration;
     let assignment;
     const isFunctionDeclaration = tsOriginal !== undefined && ts.isFunctionDeclaration(tsOriginal);
-    const identifiers = utils_1.castArray(lhs);
+    const identifiers = (0, utils_1.castArray)(lhs);
     if (identifiers.length === 0) {
         return [];
     }
-    const exportScope = overrideExportScope !== null && overrideExportScope !== void 0 ? overrideExportScope : export_1.getIdentifierExportScope(context, identifiers[0]);
+    const exportScope = overrideExportScope !== null && overrideExportScope !== void 0 ? overrideExportScope : (0, export_1.getIdentifierExportScope)(context, identifiers[0]);
     if (exportScope) {
         // exported
         if (!rhs) {
             return [];
         }
         else {
-            assignment = lua.createAssignmentStatement(identifiers.map(identifier => export_1.createExportedIdentifier(context, identifier, exportScope)), rhs, tsOriginal);
+            assignment = lua.createAssignmentStatement(identifiers.map(identifier => (0, export_1.createExportedIdentifier)(context, identifier, exportScope)), rhs, tsOriginal);
         }
     }
     else {
-        const scope = scope_1.peekScope(context);
+        const scope = (0, scope_1.peekScope)(context);
         const isTopLevelVariable = scope.type === scope_1.ScopeType.File;
         if (context.isModule || !isTopLevelVariable) {
-            if (scope.type === scope_1.ScopeType.Switch || (!isFunctionDeclaration && hasMultipleReferences(scope, lhs))) {
+            if (!isFunctionDeclaration && hasMultipleReferences(scope, lhs)) {
                 // Split declaration and assignment of identifiers that reference themselves in their declaration
                 declaration = lua.createVariableDeclarationStatement(lhs, undefined, tsOriginal);
                 if (rhs) {
@@ -141,13 +141,12 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
             else {
                 declaration = lua.createVariableDeclarationStatement(lhs, rhs, tsOriginal);
             }
-            // Remember local variable declarations for hoisting later
-            if (!scope.variableDeclarations) {
-                scope.variableDeclarations = [];
-            }
-            scope.variableDeclarations.push(declaration);
-            if (scope.type === scope_1.ScopeType.Switch) {
-                declaration = undefined;
+            if (!isFunctionDeclaration) {
+                // Remember local variable declarations for hoisting later
+                if (!scope.variableDeclarations) {
+                    scope.variableDeclarations = [];
+                }
+                scope.variableDeclarations.push(declaration);
             }
         }
         else if (rhs) {
@@ -161,7 +160,7 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
     if (isFunctionDeclaration) {
         // Remember function definitions for hoisting later
         const functionSymbolId = lhs.symbolId;
-        const scope = scope_1.peekScope(context);
+        const scope = (0, scope_1.peekScope)(context);
         if (functionSymbolId && scope.functionDefinitions) {
             const definitions = scope.functionDefinitions.get(functionSymbolId);
             if (definitions) {

package/dist/transformation/utils/lualib.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "LuaLibFeature", { enumerable: true, get: functio
 const utils_1 = require("../../utils");
 const luaLibFeatures = new WeakMap();
 function getUsedLuaLibFeatures(context) {
-    return utils_1.getOrUpdate(luaLibFeatures, context, () => new Set());
+    return (0, utils_1.getOrUpdate)(luaLibFeatures, context, () => new Set());
 }
 exports.getUsedLuaLibFeatures = getUsedLuaLibFeatures;
 function importLuaLibFeature(context, feature) {

package/dist/transformation/utils/safe-names.js

@@ -51,27 +51,27 @@ const luaBuiltins = new Set([
     "type",
     "unpack",
 ]);
-const isUnsafeName = (name) => !exports.isValidLuaIdentifier(name) || luaBuiltins.has(name);
+const isUnsafeName = (name) => !(0, exports.isValidLuaIdentifier)(name) || luaBuiltins.has(name);
 exports.isUnsafeName = isUnsafeName;
 function checkName(context, name, node) {
-    const isInvalid = !exports.isValidLuaIdentifier(name);
+    const isInvalid = !(0, exports.isValidLuaIdentifier)(name);
     if (isInvalid) {
         // Empty identifier is a TypeScript error
         if (name !== "") {
-            context.diagnostics.push(diagnostics_1.invalidAmbientIdentifierName(node, name));
+            context.diagnostics.push((0, diagnostics_1.invalidAmbientIdentifierName)(node, name));
         }
     }
     return isInvalid;
 }
 function hasUnsafeSymbolName(context, symbol, tsOriginal) {
     var _a, _b;
-    const isAmbient = (_b = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(d => typescript_1.isAmbientNode(d))) !== null && _b !== void 0 ? _b : false;
+    const isAmbient = (_b = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(d => (0, typescript_1.isAmbientNode)(d))) !== null && _b !== void 0 ? _b : false;
     // Catch ambient declarations of identifiers with bad names
     if (isAmbient && checkName(context, symbol.name, tsOriginal)) {
         return true;
     }
     // only unsafe when non-ambient and not exported
-    return exports.isUnsafeName(symbol.name) && !isAmbient && !export_1.isSymbolExported(context, symbol);
+    return (0, exports.isUnsafeName)(symbol.name) && !isAmbient && !(0, export_1.isSymbolExported)(context, symbol);
 }
 exports.hasUnsafeSymbolName = hasUnsafeSymbolName;
 function hasUnsafeIdentifierName(context, identifier, checkSymbol = true) {