typescript-to-lua 1.6.1 → 1.7.0

package/dist/transformation/visitors/access.js

@@ -76,10 +76,6 @@ function transformPropertyAccessExpressionWithCapture(context, node, thisValueCa
     const property = node.name.text;
     const type = context.checker.getTypeAtLocation(node.expression);
     const isOptionalLeft = (0, optional_chaining_1.isOptionalContinuation)(node.expression);
-    const annotations = (0, annotations_1.getTypeAnnotations)(type);
-    if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
-    }
     const constEnumValue = (0, enum_1.tryGetConstEnumValue)(context, node);
     if (constEnumValue) {
         return { expression: constEnumValue };
@@ -91,6 +87,7 @@ function transformPropertyAccessExpressionWithCapture(context, node, thisValueCa
         return (0, optional_chaining_1.transformOptionalChainWithCapture)(context, node, thisValueCapture);
     }
     // Do not output path for member only enums
+    const annotations = (0, annotations_1.getTypeAnnotations)(type);
     if (annotations.has(annotations_1.AnnotationKind.CompileMembersOnly)) {
         if (isOptionalLeft) {
             context.diagnostics.push((0, diagnostics_1.unsupportedOptionalCompileMembersOnly)(node));

package/dist/transformation/visitors/block.js

@@ -9,16 +9,16 @@ function transformBlockOrStatement(context, statement) {
 }
 exports.transformBlockOrStatement = transformBlockOrStatement;
 function transformScopeBlock(context, node, scopeType) {
-    (0, scope_1.pushScope)(context, scopeType);
+    context.pushScope(scopeType);
     const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
-    const scope = (0, scope_1.popScope)(context);
+    const scope = context.popScope();
     return [lua.createBlock(statements, node), scope];
 }
 exports.transformScopeBlock = transformScopeBlock;
 const transformBlock = (node, context) => {
-    (0, scope_1.pushScope)(context, scope_1.ScopeType.Block);
+    context.pushScope(scope_1.ScopeType.Block);
     const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
-    (0, scope_1.popScope)(context);
+    context.popScope();
     return lua.createDoStatement(statements, node);
 };
 exports.transformBlock = transformBlock;

package/dist/transformation/visitors/call.js

@@ -4,7 +4,6 @@ exports.getCalledExpression = exports.transformCallExpression = exports.transfor
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
-const annotations_1 = require("../utils/annotations");
 const assignment_validation_1 = require("../utils/assignment-validation");
 const function_context_1 = require("../utils/function-context");
 const lua_ast_1 = require("../utils/lua-ast");
@@ -16,17 +15,17 @@ const diagnostics_1 = require("../utils/diagnostics");
 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");
+const call_extension_1 = require("./language-extensions/call-extension");
 function validateArguments(context, params, signature) {
     if (!signature || signature.parameters.length < params.length) {
         return;
     }
     for (const [index, param] of params.entries()) {
         const signatureParameter = signature.parameters[index];
-        const paramType = context.checker.getTypeAtLocation(param);
         if (signatureParameter.valueDeclaration !== undefined) {
             const signatureType = context.checker.getTypeAtLocation(signatureParameter.valueDeclaration);
+            const paramType = context.checker.getTypeAtLocation(param);
             (0, assignment_validation_1.validateAssignment)(context, param, paramType, signatureType, signatureParameter.name);
         }
     }
@@ -157,20 +156,14 @@ const transformCallExpression = (node, context) => {
         ? (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)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
-    }
-    const builtinOrExtensionResult = (_a = (0, builtins_1.transformBuiltinCallExpression)(context, node, optionalContinuation !== undefined)) !== null && _a !== void 0 ? _a : (0, language_extensions_1.transformLanguageExtensionCallExpression)(context, node, optionalContinuation !== undefined);
+    const builtinOrExtensionResult = (_a = (0, builtins_1.transformBuiltinCallExpression)(context, node)) !== null && _a !== void 0 ? _a : (0, call_extension_1.transformLanguageExtensionCallExpression)(context, node);
     if (builtinOrExtensionResult) {
-        // unsupportedOptionalCall diagnostic already present
+        if (optionalContinuation !== undefined) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+        }
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinOrExtensionResult) : builtinOrExtensionResult;
     }
     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, calledExpression);
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(result) : result;
     }
@@ -211,11 +204,7 @@ function isContextualCallExpression(context, signature) {
     return (0, function_context_1.getDeclarationContextType)(context, declaration) !== function_context_1.ContextType.Void;
 }
 function getCalledExpression(node) {
-    function unwrapExpression(expression) {
-        expression = ts.skipOuterExpressions(expression);
-        return ts.isNonNullExpression(expression) ? unwrapExpression(expression.expression) : expression;
-    }
-    return unwrapExpression(node.expression);
+    return ts.skipOuterExpressions(node.expression);
 }
 exports.getCalledExpression = getCalledExpression;
 //# sourceMappingURL=call.js.map

package/dist/transformation/visitors/class/index.js

@@ -3,9 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformSuperExpression = exports.transformClassAsExpression = exports.transformThisExpression = exports.transformClassDeclaration = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
-const utils_1 = require("../../../utils");
-const annotations_1 = require("../../utils/annotations");
-const diagnostics_1 = require("../../utils/diagnostics");
 const export_1 = require("../../utils/export");
 const lua_ast_1 = require("../../utils/lua-ast");
 const safe_names_1 = require("../../utils/safe-names");
@@ -15,7 +12,7 @@ const accessors_1 = require("./members/accessors");
 const constructor_1 = require("./members/constructor");
 const fields_1 = require("./members/fields");
 const method_1 = require("./members/method");
-const utils_2 = require("./utils");
+const utils_1 = require("./utils");
 const setup_1 = require("./setup");
 const transformClassDeclaration = (declaration, context) => {
     // If declaration is a default export, transform to export variable assignment instead
@@ -36,7 +33,6 @@ function transformClassAsExpression(expression, context) {
     return name;
 }
 exports.transformClassAsExpression = transformClassAsExpression;
-const classSuperInfos = new WeakMap();
 function transformClassLikeDeclaration(classDeclaration, context, nameOverride) {
     let className;
     if (nameOverride !== undefined) {
@@ -48,22 +44,14 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
     else {
         className = lua.createIdentifier(context.createTempName("class"), classDeclaration);
     }
-    const annotations = (0, annotations_1.getTypeAnnotations)(context.checker.getTypeAtLocation(classDeclaration));
-    if (annotations.has(annotations_1.AnnotationKind.Extension)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(classDeclaration, annotations_1.AnnotationKind.Extension));
-    }
-    if (annotations.has(annotations_1.AnnotationKind.MetaExtension)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(classDeclaration, annotations_1.AnnotationKind.MetaExtension));
-    }
     // Get type that is extended
-    const extendedTypeNode = (0, utils_2.getExtendedNode)(context, classDeclaration);
-    const extendedType = (0, utils_2.getExtendedType)(context, classDeclaration);
-    const superInfo = (0, utils_1.getOrUpdate)(classSuperInfos, context, () => []);
-    superInfo.push({ className, extendedTypeNode });
+    const extendedTypeNode = (0, utils_1.getExtendedNode)(classDeclaration);
+    const extendedType = (0, utils_1.getExtendedType)(context, classDeclaration);
+    context.classSuperInfos.push({ className, extendedTypeNode });
     // Get all properties with value
     const properties = classDeclaration.members.filter(ts.isPropertyDeclaration).filter(member => member.initializer);
     // Divide properties into static and non-static
-    const instanceFields = properties.filter(prop => !(0, utils_2.isStaticNode)(prop));
+    const instanceFields = properties.filter(prop => !(0, utils_1.isStaticNode)(prop));
     const result = [];
     let localClassName;
     if ((0, safe_names_1.isUnsafeName)(className.text, context.options)) {
@@ -129,7 +117,7 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
             }
         }
         else if (ts.isPropertyDeclaration(member)) {
-            if ((0, utils_2.isStaticNode)(member)) {
+            if ((0, utils_1.isStaticNode)(member)) {
                 const statement = (0, fields_1.transformStaticPropertyDeclaration)(context, member, localClassName);
                 if (statement)
                     decorationStatements.push(statement);
@@ -153,11 +141,11 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
             result.push(classAssignment);
         }
     }
-    superInfo.pop();
+    context.classSuperInfos.pop();
     return { statements: result, name: className };
 }
 const transformSuperExpression = (expression, context) => {
-    const superInfos = (0, utils_1.getOrUpdate)(classSuperInfos, context, () => []);
+    const superInfos = context.classSuperInfos;
     const superInfo = superInfos[superInfos.length - 1];
     if (!superInfo)
         return lua.createAnonymousIdentifier(expression);

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

@@ -22,7 +22,7 @@ function transformConstructorDeclaration(context, statement, className, instance
         return undefined;
     }
     // Transform body
-    const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
+    const scope = context.pushScope(scope_1.ScopeType.Function);
     const body = (0, function_1.transformFunctionBodyContent)(context, statement.body);
     const [params, dotsLiteral, restParamName] = (0, function_1.transformParameters)(context, statement.parameters, (0, lua_ast_1.createSelfIdentifier)());
     // Make sure default parameters are assigned before fields are initialized
@@ -58,7 +58,7 @@ function transformConstructorDeclaration(context, statement, className, instance
     bodyWithFieldInitializers.push(...body);
     const block = lua.createBlock(bodyWithFieldInitializers);
     const constructorWasGenerated = statement.pos === -1;
-    (0, scope_1.popScope)(context);
+    context.popScope();
     return lua.createAssignmentStatement(createConstructorName(className), lua.createFunctionExpression(block, params, dotsLiteral, lua.NodeFlags.Declaration), constructorWasGenerated ? classDeclaration : statement);
 }
 exports.transformConstructorDeclaration = transformConstructorDeclaration;

package/dist/transformation/visitors/class/new.js

@@ -10,16 +10,13 @@ const call_1 = require("../call");
 const table_1 = require("../language-extensions/table");
 const transformNewExpression = (node, context) => {
     var _a, _b;
-    const type = context.checker.getTypeAtLocation(node);
-    const annotations = (0, annotations_1.getTypeAnnotations)(type);
-    if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
-    }
     if ((0, table_1.isTableNewCall)(context, node)) {
         return lua.createTableExpression(undefined, node);
     }
     const signature = context.checker.getResolvedSignature(node);
     const [name, params] = (0, call_1.transformCallAndArguments)(context, node.expression, (_a = node.arguments) !== null && _a !== void 0 ? _a : [ts.factory.createTrue()], signature);
+    const type = context.checker.getTypeAtLocation(node);
+    const annotations = (0, annotations_1.getTypeAnnotations)(type);
     const customConstructorAnnotation = annotations.get(annotations_1.AnnotationKind.CustomConstructor);
     if (customConstructorAnnotation) {
         if (customConstructorAnnotation.args.length === 1) {

package/dist/transformation/visitors/class/setup.d.ts

@@ -2,4 +2,4 @@ import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { TransformationContext } from "../../context";
 export declare function createClassSetup(context: TransformationContext, statement: ts.ClassLikeDeclarationBase, className: lua.Identifier, localClassName: lua.Identifier, extendsType?: ts.Type): lua.Statement[];
-export declare function getReflectionClassName(context: TransformationContext, declaration: ts.ClassLikeDeclarationBase, className: lua.Identifier): lua.Expression;
+export declare function getReflectionClassName(declaration: ts.ClassLikeDeclarationBase, className: lua.Identifier): lua.Expression;

package/dist/transformation/visitors/class/setup.js

@@ -34,16 +34,16 @@ function createClassSetup(context, statement, className, localClassName, extends
         }
     }
     // localClassName.name = className
-    result.push(lua.createAssignmentStatement(lua.createTableIndexExpression(lua.cloneIdentifier(localClassName), lua.createStringLiteral("name")), getReflectionClassName(context, statement, className), statement));
+    result.push(lua.createAssignmentStatement(lua.createTableIndexExpression(lua.cloneIdentifier(localClassName), lua.createStringLiteral("name")), getReflectionClassName(statement, className), statement));
     if (extendsType) {
-        const extendedNode = (0, utils_2.getExtendedNode)(context, statement);
+        const extendedNode = (0, utils_2.getExtendedNode)(statement);
         (0, utils_1.assert)(extendedNode);
         result.push(lua.createExpressionStatement((0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ClassExtends, (0, utils_2.getExtendsClause)(statement), lua.cloneIdentifier(localClassName), context.transformExpression(extendedNode.expression))));
     }
     return result;
 }
 exports.createClassSetup = createClassSetup;
-function getReflectionClassName(context, declaration, className) {
+function getReflectionClassName(declaration, className) {
     if (declaration.name) {
         return lua.createStringLiteral(declaration.name.text);
     }
@@ -53,7 +53,7 @@ function getReflectionClassName(context, declaration, className) {
     else if ((0, export_1.hasDefaultExportModifier)(declaration)) {
         return lua.createStringLiteral("default");
     }
-    if ((0, utils_2.getExtendedNode)(context, declaration)) {
+    if ((0, utils_2.getExtendedNode)(declaration)) {
         return lua.createTableIndexExpression(className, lua.createStringLiteral("name"));
     }
     return lua.createStringLiteral("");

package/dist/transformation/visitors/class/utils.d.ts

@@ -2,5 +2,5 @@ import * as ts from "typescript";
 import { TransformationContext } from "../../context";
 export declare function isStaticNode(node: ts.Node): boolean;
 export declare function getExtendsClause(node: ts.ClassLikeDeclarationBase): ts.HeritageClause | undefined;
-export declare function getExtendedNode(context: TransformationContext, node: ts.ClassLikeDeclarationBase): ts.ExpressionWithTypeArguments | undefined;
+export declare function getExtendedNode(node: ts.ClassLikeDeclarationBase): ts.ExpressionWithTypeArguments | undefined;
 export declare function getExtendedType(context: TransformationContext, node: ts.ClassLikeDeclarationBase): ts.Type | undefined;

package/dist/transformation/visitors/class/utils.js

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExtendedType = exports.getExtendedNode = exports.getExtendsClause = exports.isStaticNode = void 0;
 const ts = require("typescript");
-const annotations_1 = require("../../utils/annotations");
-const diagnostics_1 = require("../../utils/diagnostics");
 function isStaticNode(node) {
     var _a;
     return ((_a = node.modifiers) !== null && _a !== void 0 ? _a : []).some(m => m.kind === ts.SyntaxKind.StaticKeyword);
@@ -14,20 +12,15 @@ function getExtendsClause(node) {
     return ((_a = node.heritageClauses) !== null && _a !== void 0 ? _a : []).find(clause => clause.token === ts.SyntaxKind.ExtendsKeyword);
 }
 exports.getExtendsClause = getExtendsClause;
-function getExtendedNode(context, node) {
+function getExtendedNode(node) {
     const extendsClause = getExtendsClause(node);
     if (!extendsClause)
         return;
-    const superType = context.checker.getTypeAtLocation(extendsClause.types[0]);
-    const annotations = (0, annotations_1.getTypeAnnotations)(superType);
-    if (annotations.has(annotations_1.AnnotationKind.PureAbstract)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(extendsClause, annotations_1.AnnotationKind.PureAbstract));
-    }
     return extendsClause.types[0];
 }
 exports.getExtendedNode = getExtendedNode;
 function getExtendedType(context, node) {
-    const extendedNode = getExtendedNode(context, node);
+    const extendedNode = getExtendedNode(node);
     return extendedNode && context.checker.getTypeAtLocation(extendedNode);
 }
 exports.getExtendedType = getExtendedType;

package/dist/transformation/visitors/conditional.js

@@ -34,10 +34,10 @@ const transformConditionalExpression = (expression, context) => {
 };
 exports.transformConditionalExpression = transformConditionalExpression;
 function transformIfStatement(statement, context) {
-    (0, scope_1.pushScope)(context, scope_1.ScopeType.Conditional);
+    context.pushScope(scope_1.ScopeType.Conditional);
     const condition = context.transformExpression(statement.expression);
     const statements = (0, scope_1.performHoisting)(context, (0, block_1.transformBlockOrStatement)(context, statement.thenStatement));
-    (0, scope_1.popScope)(context);
+    context.popScope();
     const ifBlock = lua.createBlock(statements);
     if (statement.elseStatement) {
         if (ts.isIfStatement(statement.elseStatement)) {
@@ -60,9 +60,9 @@ function transformIfStatement(statement, context) {
             }
         }
         else {
-            (0, scope_1.pushScope)(context, scope_1.ScopeType.Conditional);
+            context.pushScope(scope_1.ScopeType.Conditional);
             const elseStatements = (0, scope_1.performHoisting)(context, (0, block_1.transformBlockOrStatement)(context, statement.elseStatement));
-            (0, scope_1.popScope)(context);
+            context.popScope();
             const elseBlock = lua.createBlock(elseStatements);
             return lua.createIfStatement(condition, ifBlock, elseBlock);
         }

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

@@ -3,7 +3,7 @@ import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
 import { Scope } from "../utils/scope";
 export declare function createCallableTable(functionExpression: lua.Expression): lua.Expression;
-export declare function isFunctionTypeWithProperties(functionType: ts.Type): boolean;
+export declare function isFunctionTypeWithProperties(context: TransformationContext, functionType: ts.Type): boolean;
 export declare function transformFunctionBodyContent(context: TransformationContext, body: ts.ConciseBody): lua.Statement[];
 export declare function transformFunctionBodyHeader(context: TransformationContext, bodyScope: Scope, parameters: ts.NodeArray<ts.ParameterDeclaration>, spreadIdentifier?: lua.Identifier): lua.Statement[];
 export declare function transformFunctionBody(context: TransformationContext, parameters: ts.NodeArray<ts.ParameterDeclaration>, body: ts.ConciseBody, spreadIdentifier?: lua.Identifier, node?: ts.FunctionLikeDeclaration): [lua.Statement[], Scope];

package/dist/transformation/visitors/function.js

@@ -4,8 +4,6 @@ exports.transformYieldExpression = exports.transformFunctionDeclaration = export
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
-const annotations_1 = require("../utils/annotations");
-const diagnostics_1 = require("../utils/diagnostics");
 const export_1 = require("../utils/export");
 const function_context_1 = require("../utils/function-context");
 const language_extensions_1 = require("../utils/language-extensions");
@@ -56,14 +54,14 @@ function createCallableTable(functionExpression) {
     ]);
 }
 exports.createCallableTable = createCallableTable;
-function isFunctionTypeWithProperties(functionType) {
+function isFunctionTypeWithProperties(context, functionType) {
     if (functionType.isUnion()) {
-        return functionType.types.some(isFunctionTypeWithProperties);
+        return functionType.types.some(t => isFunctionTypeWithProperties(context, t));
     }
     else {
         return ((0, typescript_1.isFunctionType)(functionType) &&
             functionType.getProperties().length > 0 &&
-            (0, language_extensions_1.getExtensionKinds)(functionType).length === 0 // ignore TSTL extension functions like $range
+            (0, language_extensions_1.getExtensionKindForType)(context, functionType) === undefined // ignore TSTL extension functions like $range
         );
     }
 }
@@ -110,14 +108,14 @@ function transformFunctionBodyHeader(context, bodyScope, parameters, spreadIdent
 }
 exports.transformFunctionBodyHeader = transformFunctionBodyHeader;
 function transformFunctionBody(context, parameters, body, spreadIdentifier, node) {
-    const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
+    const scope = context.pushScope(scope_1.ScopeType.Function);
     scope.node = node;
     let bodyStatements = transformFunctionBodyContent(context, body);
     if (node && (0, async_await_1.isAsyncFunction)(node)) {
         bodyStatements = [lua.createReturnStatement([(0, async_await_1.wrapInAsyncAwaiter)(context, bodyStatements)])];
     }
     const headerStatements = transformFunctionBodyHeader(context, scope, parameters, spreadIdentifier);
-    (0, scope_1.popScope)(context);
+    context.popScope();
     return [[...headerStatements, ...bodyStatements], scope];
 }
 exports.transformFunctionBody = transformFunctionBody;
@@ -191,9 +189,6 @@ function transformFunctionLikeDeclaration(node, context) {
         // This code can be reached only from object methods, which is TypeScript error
         return lua.createNilLiteral();
     }
-    if ((0, annotations_1.getNodeAnnotations)(node).has(annotations_1.AnnotationKind.TupleReturn)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
-    }
     const [functionExpression, functionScope] = transformFunctionToExpression(context, node);
     const isNamedFunctionExpression = ts.isFunctionExpression(node) && node.name;
     // Handle named function expressions which reference themselves
@@ -205,7 +200,7 @@ function transformFunctionLikeDeclaration(node, context) {
             // Only handle if the name is actually referenced inside the function
             if (isReferenced) {
                 const nameIdentifier = (0, identifier_1.transformIdentifier)(context, node.name);
-                if (isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node))) {
+                if (isFunctionTypeWithProperties(context, context.checker.getTypeAtLocation(node))) {
                     context.addPrecedingStatements([
                         lua.createVariableDeclarationStatement(nameIdentifier),
                         lua.createAssignmentStatement(nameIdentifier, createCallableTable(functionExpression)),
@@ -218,16 +213,13 @@ function transformFunctionLikeDeclaration(node, context) {
             }
         }
     }
-    return isNamedFunctionExpression && isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node))
+    return isNamedFunctionExpression && isFunctionTypeWithProperties(context, context.checker.getTypeAtLocation(node))
         ? createCallableTable(functionExpression)
         : functionExpression;
 }
 exports.transformFunctionLikeDeclaration = transformFunctionLikeDeclaration;
 const transformFunctionDeclaration = (node, context) => {
     var _a;
-    if ((0, annotations_1.getNodeAnnotations)(node).has(annotations_1.AnnotationKind.TupleReturn)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
-    }
     // Don't transform functions without body (overload declarations)
     if (node.body === undefined) {
         return undefined;
@@ -248,7 +240,7 @@ const transformFunctionDeclaration = (node, context) => {
         scope.functionDefinitions.set(name.symbolId, functionInfo);
     }
     // Wrap functions with properties into a callable table
-    const wrappedFunction = node.name && isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node.name))
+    const wrappedFunction = node.name && isFunctionTypeWithProperties(context, context.checker.getTypeAtLocation(node.name))
         ? createCallableTable(functionExpression)
         : functionExpression;
     return (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, name, wrappedFunction, node);

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

@@ -2,4 +2,5 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
 export declare function transformIdentifier(context: TransformationContext, identifier: ts.Identifier): lua.Identifier;
+export declare function transformIdentifierWithSymbol(context: TransformationContext, node: ts.Identifier, symbol: ts.Symbol | undefined): lua.Expression;
 export declare const transformIdentifierExpression: FunctionVisitor<ts.Identifier>;

package/dist/transformation/visitors/identifier.js

@@ -1,82 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformIdentifierExpression = exports.transformIdentifier = void 0;
+exports.transformIdentifierExpression = exports.transformIdentifierWithSymbol = exports.transformIdentifier = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
 const promise_1 = require("../builtins/promise");
 const context_1 = require("../context");
-const annotations_1 = require("../utils/annotations");
 const diagnostics_1 = require("../utils/diagnostics");
 const export_1 = require("../utils/export");
-const lualib_1 = require("../utils/lualib");
 const safe_names_1 = require("../utils/safe-names");
 const symbols_1 = require("../utils/symbols");
-const multi_1 = require("./language-extensions/multi");
-const operators_1 = require("./language-extensions/operators");
-const range_1 = require("./language-extensions/range");
-const table_1 = require("./language-extensions/table");
-const vararg_1 = require("./language-extensions/vararg");
 const optional_chaining_1 = require("./optional-chaining");
 const typescript_1 = require("../utils/typescript");
+const language_extensions_1 = require("../utils/language-extensions");
+const call_extension_1 = require("./language-extensions/call-extension");
+const identifier_1 = require("./language-extensions/identifier");
 function transformIdentifier(context, identifier) {
+    return transformNonValueIdentifier(context, identifier, context.checker.getSymbolAtLocation(identifier));
+}
+exports.transformIdentifier = transformIdentifier;
+function transformNonValueIdentifier(context, identifier, symbol) {
     if ((0, optional_chaining_1.isOptionalContinuation)(identifier)) {
         return lua.createIdentifier(identifier.text, undefined, context_1.tempSymbolId);
     }
-    if ((0, multi_1.isMultiFunctionNode)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionUse)(identifier));
-        return lua.createAnonymousIdentifier(identifier);
-    }
-    if ((0, operators_1.isOperatorMapping)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.invalidOperatorMappingUse)(identifier));
-    }
-    if ((0, table_1.isTableExtensionIdentifier)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.invalidTableExtensionUse)(identifier));
-    }
-    if ((0, range_1.isRangeFunctionNode)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.invalidRangeUse)(identifier));
-        return lua.createAnonymousIdentifier(identifier);
-    }
-    if ((0, vararg_1.isVarargConstantNode)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.invalidVarargUse)(identifier));
-        return lua.createAnonymousIdentifier(identifier);
-    }
-    if ((0, annotations_1.isForRangeType)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(identifier, annotations_1.AnnotationKind.ForRange));
-    }
-    if ((0, promise_1.isPromiseClass)(context, identifier)) {
-        (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
-        return (0, promise_1.createPromiseIdentifier)(identifier);
+    const extensionKind = symbol
+        ? (0, language_extensions_1.getExtensionKindForSymbol)(context, symbol)
+        : (0, language_extensions_1.getExtensionKindForNode)(context, identifier);
+    if (extensionKind) {
+        if (call_extension_1.callExtensions.has(extensionKind)) {
+            context.diagnostics.push((0, diagnostics_1.invalidCallExtensionUse)(identifier));
+            // fall through
+        }
+        else if ((0, identifier_1.isIdentifierExtensionValue)(symbol, extensionKind)) {
+            (0, identifier_1.reportInvalidExtensionValue)(context, identifier, extensionKind);
+            return lua.createAnonymousIdentifier(identifier);
+        }
     }
     const type = context.checker.getTypeAtLocation(identifier);
     if ((0, typescript_1.isStandardLibraryType)(context, type, undefined)) {
         (0, builtins_1.checkForLuaLibType)(context, type);
+        if ((0, promise_1.isPromiseClass)(context, identifier)) {
+            return (0, promise_1.createPromiseIdentifier)(identifier);
+        }
     }
-    const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, identifier) ? (0, safe_names_1.createSafeName)(identifier.text) : identifier.text;
-    const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, identifier);
+    const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, identifier, symbol)
+        ? (0, safe_names_1.createSafeName)(identifier.text)
+        : identifier.text;
+    const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, identifier, symbol);
     return lua.createIdentifier(text, identifier, symbolId, identifier.text);
 }
-exports.transformIdentifier = transformIdentifier;
-const transformIdentifierExpression = (node, context) => {
-    const symbol = context.checker.getSymbolAtLocation(node);
+function transformIdentifierWithSymbol(context, node, symbol) {
     if (symbol) {
         const exportScope = (0, export_1.getSymbolExportScope)(context, symbol);
         if (exportScope) {
             const name = symbol.name;
-            const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, node) ? (0, safe_names_1.createSafeName)(name) : name;
-            const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, node);
+            const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, node, symbol) ? (0, safe_names_1.createSafeName)(name) : name;
+            const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, node, symbol);
             const identifier = lua.createIdentifier(text, node, symbolId, name);
             return (0, export_1.createExportedIdentifier)(context, identifier, exportScope);
         }
     }
-    if (node.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
-        return lua.createNilLiteral();
-    }
-    const builtinResult = (0, builtins_1.transformBuiltinIdentifierExpression)(context, node);
+    const builtinResult = (0, builtins_1.transformBuiltinIdentifierExpression)(context, node, symbol);
     if (builtinResult) {
         return builtinResult;
     }
-    return transformIdentifier(context, node);
+    return transformNonValueIdentifier(context, node, symbol);
+}
+exports.transformIdentifierWithSymbol = transformIdentifierWithSymbol;
+const transformIdentifierExpression = (node, context) => {
+    if (node.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
+        return lua.createNilLiteral(node);
+    }
+    const symbol = context.checker.getSymbolAtLocation(node);
+    return transformIdentifierWithSymbol(context, node, symbol);
 };
 exports.transformIdentifierExpression = transformIdentifierExpression;
 //# sourceMappingURL=identifier.js.map

package/dist/transformation/visitors/language-extensions/call-extension.d.ts

@@ -0,0 +1,10 @@
+import { TransformationContext } from "../../context";
+import * as ts from "typescript";
+import { ExtensionKind } from "../../utils/language-extensions";
+import * as lua from "../../../LuaAST";
+export declare const callExtensions: Set<ExtensionKind>;
+export declare type LanguageExtensionCallTransformer = (context: TransformationContext, node: ts.CallExpression, extensionKind: ExtensionKind) => lua.Expression;
+export declare type LanguageExtensionCallTransformerMap = {
+    [P in ExtensionKind]?: LanguageExtensionCallTransformer;
+};
+export declare function transformLanguageExtensionCallExpression(context: TransformationContext, node: ts.CallExpression): lua.Expression | undefined;

package/dist/transformation/visitors/language-extensions/call-extension.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformLanguageExtensionCallExpression = exports.callExtensions = void 0;
+const language_extensions_1 = require("../../utils/language-extensions");
+const operators_1 = require("./operators");
+const table_1 = require("./table");
+const allCallExtensionHandlers = {
+    ...operators_1.operatorExtensionTransformers,
+    ...table_1.tableExtensionTransformers,
+};
+exports.callExtensions = new Set(Object.keys(allCallExtensionHandlers));
+table_1.tableNewExtensions.forEach(kind => exports.callExtensions.add(kind));
+function transformLanguageExtensionCallExpression(context, node) {
+    const extensionKind = (0, language_extensions_1.getExtensionKindForNode)(context, node.expression);
+    if (!extensionKind)
+        return;
+    const transformer = allCallExtensionHandlers[extensionKind];
+    if (transformer) {
+        return transformer(context, node, extensionKind);
+    }
+}
+exports.transformLanguageExtensionCallExpression = transformLanguageExtensionCallExpression;
+//# sourceMappingURL=call-extension.js.map

package/dist/transformation/visitors/language-extensions/identifier.d.ts

@@ -0,0 +1,5 @@
+import * as ts from "typescript";
+import { ExtensionKind } from "../../utils/language-extensions";
+import { TransformationContext } from "../../context";
+export declare function isIdentifierExtensionValue(symbol: ts.Symbol | undefined, extensionKind: ExtensionKind): boolean;
+export declare function reportInvalidExtensionValue(context: TransformationContext, identifier: ts.Identifier, extensionKind: ExtensionKind): void;

package/dist/transformation/visitors/language-extensions/identifier.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportInvalidExtensionValue = exports.isIdentifierExtensionValue = void 0;
+const language_extensions_1 = require("../../utils/language-extensions");
+const diagnostics_1 = require("../../utils/diagnostics");
+const extensionKindToValueName = {
+    [language_extensions_1.ExtensionKind.MultiFunction]: "$multi",
+    [language_extensions_1.ExtensionKind.RangeFunction]: "$range",
+    [language_extensions_1.ExtensionKind.VarargConstant]: "$vararg",
+};
+function isIdentifierExtensionValue(symbol, extensionKind) {
+    return symbol !== undefined && extensionKindToValueName[extensionKind] === symbol.name;
+}
+exports.isIdentifierExtensionValue = isIdentifierExtensionValue;
+function reportInvalidExtensionValue(context, identifier, extensionKind) {
+    if (extensionKind === language_extensions_1.ExtensionKind.MultiFunction) {
+        context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionUse)(identifier));
+    }
+    else if (extensionKind === language_extensions_1.ExtensionKind.RangeFunction) {
+        context.diagnostics.push((0, diagnostics_1.invalidRangeUse)(identifier));
+    }
+    else if (extensionKind === language_extensions_1.ExtensionKind.VarargConstant) {
+        context.diagnostics.push((0, diagnostics_1.invalidVarargUse)(identifier));
+    }
+}
+exports.reportInvalidExtensionValue = reportInvalidExtensionValue;
+//# sourceMappingURL=identifier.js.map