typescript-to-lua 0.42.0 → 1.1.1

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,9 +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 diagnostics_1 = require("./diagnostics");
-const typescript_1 = require("./typescript");
 var AnnotationKind;
 (function (AnnotationKind) {
     AnnotationKind["Extension"] = "extension";
@@ -20,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());
@@ -104,7 +100,6 @@ function isTupleReturnCall(context, node) {
     const signature = context.checker.getResolvedSignature(node);
     if (signature) {
         if (getSignatureAnnotations(context, signature).has(AnnotationKind.TupleReturn)) {
-            context.diagnostics.push(diagnostics_1.annotationDeprecated(node, AnnotationKind.TupleReturn));
             return true;
         }
         // Only check function type for directive if it is declared as an interface or type alias
@@ -117,41 +112,9 @@ function isTupleReturnCall(context, node) {
         }
     }
     const type = context.checker.getTypeAtLocation(node.expression);
-    const result = getTypeAnnotations(type).has(AnnotationKind.TupleReturn);
-    if (result) {
-        context.diagnostics.push(diagnostics_1.annotationDeprecated(node, AnnotationKind.TupleReturn));
-    }
-    return result;
+    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.d.ts

@@ -2,8 +2,8 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
 export declare function hasDefaultExportModifier(node: ts.Node): boolean;
-export declare const createDefaultExportIdentifier: (original: ts.Node) => lua.Identifier;
-export declare const createDefaultExportStringLiteral: (original: ts.Node) => lua.StringLiteral;
+export declare function hasExportModifier(node: ts.Node): boolean;
+export declare const createDefaultExportStringLiteral: (original?: ts.Node | undefined) => 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;
@@ -14,3 +14,4 @@ export declare function isSymbolExported(context: TransformationContext, symbol:
 export declare function isSymbolExportedFromScope(context: TransformationContext, symbol: ts.Symbol, scope: ts.SourceFile | ts.ModuleDeclaration): boolean;
 export declare function addExportToIdentifier(context: TransformationContext, identifier: lua.Identifier): lua.AssignmentLeftHandSideExpression;
 export declare function createExportedIdentifier(context: TransformationContext, identifier: lua.Identifier, exportScope?: ts.SourceFile | ts.ModuleDeclaration): lua.AssignmentLeftHandSideExpression;
+export declare function createDefaultExportExpression(node: ts.Node): lua.AssignmentLeftHandSideExpression;

package/dist/transformation/utils/export.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExportedIdentifier = exports.addExportToIdentifier = exports.isSymbolExportedFromScope = exports.isSymbolExported = exports.getDependenciesOfSymbol = exports.getExportedSymbolsFromScope = exports.getSymbolExportScope = exports.getIdentifierExportScope = exports.getSymbolFromIdentifier = exports.getExportedSymbolDeclaration = exports.createDefaultExportStringLiteral = exports.createDefaultExportIdentifier = exports.hasDefaultExportModifier = void 0;
+exports.createDefaultExportExpression = exports.createExportedIdentifier = exports.addExportToIdentifier = exports.isSymbolExportedFromScope = exports.isSymbolExported = exports.getDependenciesOfSymbol = exports.getExportedSymbolsFromScope = exports.getSymbolExportScope = exports.getIdentifierExportScope = exports.getSymbolFromIdentifier = exports.getExportedSymbolDeclaration = exports.createDefaultExportStringLiteral = exports.hasExportModifier = exports.hasDefaultExportModifier = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const namespace_1 = require("../visitors/namespace");
@@ -12,8 +12,11 @@ function hasDefaultExportModifier(node) {
     return ((_a = node.modifiers) !== null && _a !== void 0 ? _a : []).some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword);
 }
 exports.hasDefaultExportModifier = hasDefaultExportModifier;
-const createDefaultExportIdentifier = (original) => lua.createIdentifier("default", original);
-exports.createDefaultExportIdentifier = createDefaultExportIdentifier;
+function hasExportModifier(node) {
+    var _a;
+    return ((_a = node.modifiers) !== null && _a !== void 0 ? _a : []).some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword);
+}
+exports.hasExportModifier = hasExportModifier;
 const createDefaultExportStringLiteral = (original) => lua.createStringLiteral("default", original);
 exports.createDefaultExportStringLiteral = createDefaultExportStringLiteral;
 function getExportedSymbolDeclaration(symbol) {
@@ -25,7 +28,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 +51,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,9 +101,13 @@ 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;
+function createDefaultExportExpression(node) {
+    return lua.createTableIndexExpression((0, lua_ast_1.createExportsIdentifier)(), (0, exports.createDefaultExportStringLiteral)(node), node);
+}
+exports.createDefaultExportExpression = createDefaultExportExpression;
 //# sourceMappingURL=export.js.map

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;