typescript-to-lua 1.6.3 → 1.7.0

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

@@ -1,127 +1,120 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformOperatorMappingExpression = exports.isOperatorMapping = void 0;
+exports.operatorExtensionTransformers = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
-const extensions = require("../../utils/language-extensions");
 const utils_1 = require("../../../utils");
-const typescript_1 = require("../../utils/typescript");
 const CompilerOptions_1 = require("../../../CompilerOptions");
 const diagnostics_1 = require("../../utils/diagnostics");
+const language_extensions_1 = require("../../utils/language-extensions");
 const binaryOperatorMappings = new Map([
-    [extensions.ExtensionKind.AdditionOperatorType, lua.SyntaxKind.AdditionOperator],
-    [extensions.ExtensionKind.AdditionOperatorMethodType, lua.SyntaxKind.AdditionOperator],
-    [extensions.ExtensionKind.SubtractionOperatorType, lua.SyntaxKind.SubtractionOperator],
-    [extensions.ExtensionKind.SubtractionOperatorMethodType, lua.SyntaxKind.SubtractionOperator],
-    [extensions.ExtensionKind.MultiplicationOperatorType, lua.SyntaxKind.MultiplicationOperator],
-    [extensions.ExtensionKind.MultiplicationOperatorMethodType, lua.SyntaxKind.MultiplicationOperator],
-    [extensions.ExtensionKind.DivisionOperatorType, lua.SyntaxKind.DivisionOperator],
-    [extensions.ExtensionKind.DivisionOperatorMethodType, lua.SyntaxKind.DivisionOperator],
-    [extensions.ExtensionKind.ModuloOperatorType, lua.SyntaxKind.ModuloOperator],
-    [extensions.ExtensionKind.ModuloOperatorMethodType, lua.SyntaxKind.ModuloOperator],
-    [extensions.ExtensionKind.PowerOperatorType, lua.SyntaxKind.PowerOperator],
-    [extensions.ExtensionKind.PowerOperatorMethodType, lua.SyntaxKind.PowerOperator],
-    [extensions.ExtensionKind.FloorDivisionOperatorType, lua.SyntaxKind.FloorDivisionOperator],
-    [extensions.ExtensionKind.FloorDivisionOperatorMethodType, lua.SyntaxKind.FloorDivisionOperator],
-    [extensions.ExtensionKind.BitwiseAndOperatorType, lua.SyntaxKind.BitwiseAndOperator],
-    [extensions.ExtensionKind.BitwiseAndOperatorMethodType, lua.SyntaxKind.BitwiseAndOperator],
-    [extensions.ExtensionKind.BitwiseOrOperatorType, lua.SyntaxKind.BitwiseOrOperator],
-    [extensions.ExtensionKind.BitwiseOrOperatorMethodType, lua.SyntaxKind.BitwiseOrOperator],
-    [extensions.ExtensionKind.BitwiseExclusiveOrOperatorType, lua.SyntaxKind.BitwiseExclusiveOrOperator],
-    [extensions.ExtensionKind.BitwiseExclusiveOrOperatorMethodType, lua.SyntaxKind.BitwiseExclusiveOrOperator],
-    [extensions.ExtensionKind.BitwiseLeftShiftOperatorType, lua.SyntaxKind.BitwiseLeftShiftOperator],
-    [extensions.ExtensionKind.BitwiseLeftShiftOperatorMethodType, lua.SyntaxKind.BitwiseLeftShiftOperator],
-    [extensions.ExtensionKind.BitwiseRightShiftOperatorType, lua.SyntaxKind.BitwiseRightShiftOperator],
-    [extensions.ExtensionKind.BitwiseRightShiftOperatorMethodType, lua.SyntaxKind.BitwiseRightShiftOperator],
-    [extensions.ExtensionKind.ConcatOperatorType, lua.SyntaxKind.ConcatOperator],
-    [extensions.ExtensionKind.ConcatOperatorMethodType, lua.SyntaxKind.ConcatOperator],
-    [extensions.ExtensionKind.LessThanOperatorType, lua.SyntaxKind.LessThanOperator],
-    [extensions.ExtensionKind.LessThanOperatorMethodType, lua.SyntaxKind.LessThanOperator],
-    [extensions.ExtensionKind.GreaterThanOperatorType, lua.SyntaxKind.GreaterThanOperator],
-    [extensions.ExtensionKind.GreaterThanOperatorMethodType, lua.SyntaxKind.GreaterThanOperator],
+    [language_extensions_1.ExtensionKind.AdditionOperatorType, lua.SyntaxKind.AdditionOperator],
+    [language_extensions_1.ExtensionKind.AdditionOperatorMethodType, lua.SyntaxKind.AdditionOperator],
+    [language_extensions_1.ExtensionKind.SubtractionOperatorType, lua.SyntaxKind.SubtractionOperator],
+    [language_extensions_1.ExtensionKind.SubtractionOperatorMethodType, lua.SyntaxKind.SubtractionOperator],
+    [language_extensions_1.ExtensionKind.MultiplicationOperatorType, lua.SyntaxKind.MultiplicationOperator],
+    [language_extensions_1.ExtensionKind.MultiplicationOperatorMethodType, lua.SyntaxKind.MultiplicationOperator],
+    [language_extensions_1.ExtensionKind.DivisionOperatorType, lua.SyntaxKind.DivisionOperator],
+    [language_extensions_1.ExtensionKind.DivisionOperatorMethodType, lua.SyntaxKind.DivisionOperator],
+    [language_extensions_1.ExtensionKind.ModuloOperatorType, lua.SyntaxKind.ModuloOperator],
+    [language_extensions_1.ExtensionKind.ModuloOperatorMethodType, lua.SyntaxKind.ModuloOperator],
+    [language_extensions_1.ExtensionKind.PowerOperatorType, lua.SyntaxKind.PowerOperator],
+    [language_extensions_1.ExtensionKind.PowerOperatorMethodType, lua.SyntaxKind.PowerOperator],
+    [language_extensions_1.ExtensionKind.FloorDivisionOperatorType, lua.SyntaxKind.FloorDivisionOperator],
+    [language_extensions_1.ExtensionKind.FloorDivisionOperatorMethodType, lua.SyntaxKind.FloorDivisionOperator],
+    [language_extensions_1.ExtensionKind.BitwiseAndOperatorType, lua.SyntaxKind.BitwiseAndOperator],
+    [language_extensions_1.ExtensionKind.BitwiseAndOperatorMethodType, lua.SyntaxKind.BitwiseAndOperator],
+    [language_extensions_1.ExtensionKind.BitwiseOrOperatorType, lua.SyntaxKind.BitwiseOrOperator],
+    [language_extensions_1.ExtensionKind.BitwiseOrOperatorMethodType, lua.SyntaxKind.BitwiseOrOperator],
+    [language_extensions_1.ExtensionKind.BitwiseExclusiveOrOperatorType, lua.SyntaxKind.BitwiseExclusiveOrOperator],
+    [language_extensions_1.ExtensionKind.BitwiseExclusiveOrOperatorMethodType, lua.SyntaxKind.BitwiseExclusiveOrOperator],
+    [language_extensions_1.ExtensionKind.BitwiseLeftShiftOperatorType, lua.SyntaxKind.BitwiseLeftShiftOperator],
+    [language_extensions_1.ExtensionKind.BitwiseLeftShiftOperatorMethodType, lua.SyntaxKind.BitwiseLeftShiftOperator],
+    [language_extensions_1.ExtensionKind.BitwiseRightShiftOperatorType, lua.SyntaxKind.BitwiseRightShiftOperator],
+    [language_extensions_1.ExtensionKind.BitwiseRightShiftOperatorMethodType, lua.SyntaxKind.BitwiseRightShiftOperator],
+    [language_extensions_1.ExtensionKind.ConcatOperatorType, lua.SyntaxKind.ConcatOperator],
+    [language_extensions_1.ExtensionKind.ConcatOperatorMethodType, lua.SyntaxKind.ConcatOperator],
+    [language_extensions_1.ExtensionKind.LessThanOperatorType, lua.SyntaxKind.LessThanOperator],
+    [language_extensions_1.ExtensionKind.LessThanOperatorMethodType, lua.SyntaxKind.LessThanOperator],
+    [language_extensions_1.ExtensionKind.GreaterThanOperatorType, lua.SyntaxKind.GreaterThanOperator],
+    [language_extensions_1.ExtensionKind.GreaterThanOperatorMethodType, lua.SyntaxKind.GreaterThanOperator],
 ]);
 const unaryOperatorMappings = new Map([
-    [extensions.ExtensionKind.NegationOperatorType, lua.SyntaxKind.NegationOperator],
-    [extensions.ExtensionKind.NegationOperatorMethodType, lua.SyntaxKind.NegationOperator],
-    [extensions.ExtensionKind.BitwiseNotOperatorType, lua.SyntaxKind.BitwiseNotOperator],
-    [extensions.ExtensionKind.BitwiseNotOperatorMethodType, lua.SyntaxKind.BitwiseNotOperator],
-    [extensions.ExtensionKind.LengthOperatorType, lua.SyntaxKind.LengthOperator],
-    [extensions.ExtensionKind.LengthOperatorMethodType, lua.SyntaxKind.LengthOperator],
+    [language_extensions_1.ExtensionKind.NegationOperatorType, lua.SyntaxKind.NegationOperator],
+    [language_extensions_1.ExtensionKind.NegationOperatorMethodType, lua.SyntaxKind.NegationOperator],
+    [language_extensions_1.ExtensionKind.BitwiseNotOperatorType, lua.SyntaxKind.BitwiseNotOperator],
+    [language_extensions_1.ExtensionKind.BitwiseNotOperatorMethodType, lua.SyntaxKind.BitwiseNotOperator],
+    [language_extensions_1.ExtensionKind.LengthOperatorType, lua.SyntaxKind.LengthOperator],
+    [language_extensions_1.ExtensionKind.LengthOperatorMethodType, lua.SyntaxKind.LengthOperator],
 ]);
-const operatorMapExtensions = [...binaryOperatorMappings.keys(), ...unaryOperatorMappings.keys()];
 const bitwiseOperatorMapExtensions = new Set([
-    extensions.ExtensionKind.BitwiseAndOperatorType,
-    extensions.ExtensionKind.BitwiseAndOperatorMethodType,
-    extensions.ExtensionKind.BitwiseOrOperatorType,
-    extensions.ExtensionKind.BitwiseOrOperatorMethodType,
-    extensions.ExtensionKind.BitwiseExclusiveOrOperatorType,
-    extensions.ExtensionKind.BitwiseExclusiveOrOperatorMethodType,
-    extensions.ExtensionKind.BitwiseLeftShiftOperatorType,
-    extensions.ExtensionKind.BitwiseLeftShiftOperatorMethodType,
-    extensions.ExtensionKind.BitwiseRightShiftOperatorType,
-    extensions.ExtensionKind.BitwiseRightShiftOperatorMethodType,
-    extensions.ExtensionKind.BitwiseNotOperatorType,
-    extensions.ExtensionKind.BitwiseNotOperatorMethodType,
+    language_extensions_1.ExtensionKind.BitwiseAndOperatorType,
+    language_extensions_1.ExtensionKind.BitwiseAndOperatorMethodType,
+    language_extensions_1.ExtensionKind.BitwiseOrOperatorType,
+    language_extensions_1.ExtensionKind.BitwiseOrOperatorMethodType,
+    language_extensions_1.ExtensionKind.BitwiseExclusiveOrOperatorType,
+    language_extensions_1.ExtensionKind.BitwiseExclusiveOrOperatorMethodType,
+    language_extensions_1.ExtensionKind.BitwiseLeftShiftOperatorType,
+    language_extensions_1.ExtensionKind.BitwiseLeftShiftOperatorMethodType,
+    language_extensions_1.ExtensionKind.BitwiseRightShiftOperatorType,
+    language_extensions_1.ExtensionKind.BitwiseRightShiftOperatorMethodType,
+    language_extensions_1.ExtensionKind.BitwiseNotOperatorType,
+    language_extensions_1.ExtensionKind.BitwiseNotOperatorMethodType,
 ]);
-function getOperatorMapExtensionKindForCall(context, node) {
-    const type = (0, typescript_1.getFunctionTypeForCall)(context, node);
-    return type && operatorMapExtensions.find(extensionKind => extensions.isExtensionType(type, extensionKind));
+const requiresLua53 = new Set([
+    ...bitwiseOperatorMapExtensions,
+    language_extensions_1.ExtensionKind.FloorDivisionOperatorType,
+    language_extensions_1.ExtensionKind.FloorDivisionOperatorMethodType,
+]);
+exports.operatorExtensionTransformers = {};
+for (const kind of binaryOperatorMappings.keys()) {
+    exports.operatorExtensionTransformers[kind] = transformBinaryOperator;
+}
+for (const kind of unaryOperatorMappings.keys()) {
+    exports.operatorExtensionTransformers[kind] = transformUnaryOperator;
+}
+function transformBinaryOperator(context, node, kind) {
+    if (requiresLua53.has(kind))
+        checkHasLua53(context, node, kind);
+    let args = node.arguments;
+    if (args.length === 1 &&
+        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
+        args = [node.expression.expression, ...args];
+    }
+    const luaOperator = binaryOperatorMappings.get(kind);
+    (0, utils_1.assert)(luaOperator);
+    return lua.createBinaryExpression(context.transformExpression(args[0]), context.transformExpression(args[1]), luaOperator);
 }
-function isOperatorMapping(context, node) {
-    if (ts.isCallExpression(node)) {
-        return getOperatorMapExtensionKindForCall(context, node) !== undefined;
+function transformUnaryOperator(context, node, kind) {
+    if (requiresLua53.has(kind))
+        checkHasLua53(context, node, kind);
+    let arg;
+    if (node.arguments.length === 0 &&
+        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
+        arg = node.expression.expression;
     }
     else {
-        const type = context.checker.getTypeAtLocation(node);
-        return operatorMapExtensions.some(extensionKind => extensions.isExtensionType(type, extensionKind));
+        arg = node.arguments[0];
     }
+    const luaOperator = unaryOperatorMappings.get(kind);
+    (0, utils_1.assert)(luaOperator);
+    return lua.createUnaryExpression(context.transformExpression(arg), luaOperator);
 }
-exports.isOperatorMapping = isOperatorMapping;
-function transformOperatorMappingExpression(context, node, isOptionalCall) {
-    const extensionKind = getOperatorMapExtensionKindForCall(context, node);
-    if (!extensionKind)
-        return undefined;
-    if (isOptionalCall) {
-        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-        return lua.createNilLiteral();
-    }
+function checkHasLua53(context, node, kind) {
     const isBefore53 = context.luaTarget === CompilerOptions_1.LuaTarget.Lua51 ||
         context.luaTarget === CompilerOptions_1.LuaTarget.Lua52 ||
         context.luaTarget === CompilerOptions_1.LuaTarget.LuaJIT ||
         context.luaTarget === CompilerOptions_1.LuaTarget.Universal;
     if (isBefore53) {
         const luaTarget = context.luaTarget === CompilerOptions_1.LuaTarget.Universal ? CompilerOptions_1.LuaTarget.Lua51 : context.luaTarget;
-        if (bitwiseOperatorMapExtensions.has(extensionKind)) {
-            context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "Native bitwise operations", luaTarget));
-        }
-        else if (extensionKind === extensions.ExtensionKind.FloorDivisionOperatorType ||
-            extensionKind === extensions.ExtensionKind.FloorDivisionOperatorMethodType) {
+        if (kind === language_extensions_1.ExtensionKind.FloorDivisionOperatorType ||
+            kind === language_extensions_1.ExtensionKind.FloorDivisionOperatorMethodType) {
             context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "Floor division operator", luaTarget));
         }
-    }
-    const args = node.arguments.slice();
-    if (binaryOperatorMappings.has(extensionKind)) {
-        if (args.length === 1 &&
-            (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
-            args.unshift(node.expression.expression);
-        }
-        const luaOperator = binaryOperatorMappings.get(extensionKind);
-        (0, utils_1.assert)(luaOperator);
-        return lua.createBinaryExpression(context.transformExpression(args[0]), context.transformExpression(args[1]), luaOperator);
-    }
-    else {
-        let arg;
-        if (args.length === 0 &&
-            (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
-            arg = node.expression.expression;
-        }
         else {
-            arg = args[0];
+            // is bitwise operator
+            context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "Native bitwise operations", luaTarget));
         }
-        const luaOperator = unaryOperatorMappings.get(extensionKind);
-        (0, utils_1.assert)(luaOperator);
-        return lua.createUnaryExpression(context.transformExpression(arg), luaOperator);
     }
 }
-exports.transformOperatorMappingExpression = transformOperatorMappingExpression;
 //# sourceMappingURL=operators.js.map

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

@@ -9,13 +9,15 @@ const identifier_1 = require("../identifier");
 const call_1 = require("../call");
 const utils_2 = require("../../../utils");
 const diagnostics_1 = require("../../utils/diagnostics");
+const language_extensions_1 = require("../../utils/language-extensions");
 function isRangeFunction(context, expression) {
     return isRangeFunctionNode(context, expression.expression);
 }
 exports.isRangeFunction = isRangeFunction;
 function isRangeFunctionNode(context, node) {
-    const symbol = context.checker.getSymbolAtLocation(node);
-    return symbol ? extensions.isExtensionValue(context, symbol, extensions.ExtensionKind.RangeFunction) : false;
+    return (ts.isIdentifier(node) &&
+        node.text === "$range" &&
+        (0, language_extensions_1.getExtensionKindForNode)(context, node) === extensions.ExtensionKind.RangeFunction);
 }
 exports.isRangeFunctionNode = isRangeFunctionNode;
 function getControlVariable(context, statement) {

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

@@ -1,6 +1,9 @@
 import * as ts from "typescript";
-import * as lua from "../../../LuaAST";
 import { TransformationContext } from "../../context";
-export declare function isTableExtensionIdentifier(context: TransformationContext, node: ts.Identifier): boolean;
+import { ExtensionKind } from "../../utils/language-extensions";
+import { LanguageExtensionCallTransformer } from "./call-extension";
 export declare function isTableNewCall(context: TransformationContext, node: ts.NewExpression): boolean;
-export declare function transformTableExtensionCall(context: TransformationContext, node: ts.CallExpression, isOptionalCall: boolean): lua.Expression | undefined;
+export declare const tableNewExtensions: ExtensionKind[];
+export declare const tableExtensionTransformers: {
+    [P in ExtensionKind]?: LanguageExtensionCallTransformer;
+};

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

@@ -1,109 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformTableExtensionCall = exports.isTableNewCall = exports.isTableExtensionIdentifier = void 0;
+exports.tableExtensionTransformers = exports.tableNewExtensions = exports.isTableNewCall = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
-const extensions = require("../../utils/language-extensions");
-const typescript_1 = require("../../utils/typescript");
+const language_extensions_1 = require("../../utils/language-extensions");
 const expression_list_1 = require("../expression-list");
-const diagnostics_1 = require("../../utils/diagnostics");
-const tableCallExtensions = [
-    extensions.ExtensionKind.TableDeleteType,
-    extensions.ExtensionKind.TableDeleteMethodType,
-    extensions.ExtensionKind.TableGetType,
-    extensions.ExtensionKind.TableGetMethodType,
-    extensions.ExtensionKind.TableHasType,
-    extensions.ExtensionKind.TableHasMethodType,
-    extensions.ExtensionKind.TableSetType,
-    extensions.ExtensionKind.TableSetMethodType,
-];
-const tableExtensions = [extensions.ExtensionKind.TableNewType, ...tableCallExtensions];
-function getTableExtensionKindForCall(context, node, validExtensions) {
-    const type = (0, typescript_1.getFunctionTypeForCall)(context, node);
-    return type && validExtensions.find(extensionKind => extensions.isExtensionType(type, extensionKind));
-}
-function isTableExtensionIdentifier(context, node) {
-    const type = context.checker.getTypeAtLocation(node);
-    return tableExtensions.some(extensionKind => extensions.isExtensionType(type, extensionKind));
-}
-exports.isTableExtensionIdentifier = isTableExtensionIdentifier;
 function isTableNewCall(context, node) {
-    const type = context.checker.getTypeAtLocation(node.expression);
-    return extensions.isExtensionType(type, extensions.ExtensionKind.TableNewType);
+    return (0, language_extensions_1.getExtensionKindForNode)(context, node.expression) === language_extensions_1.ExtensionKind.TableNewType;
 }
 exports.isTableNewCall = isTableNewCall;
-function transformTableExtensionCall(context, node, isOptionalCall) {
-    const extensionType = getTableExtensionKindForCall(context, node, tableCallExtensions);
-    if (!extensionType)
-        return;
-    if (isOptionalCall) {
-        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-        return lua.createNilLiteral();
-    }
-    if (extensionType === extensions.ExtensionKind.TableDeleteType ||
-        extensionType === extensions.ExtensionKind.TableDeleteMethodType) {
-        return transformTableDeleteExpression(context, node, extensionType);
-    }
-    if (extensionType === extensions.ExtensionKind.TableGetType ||
-        extensionType === extensions.ExtensionKind.TableGetMethodType) {
-        return transformTableGetExpression(context, node, extensionType);
-    }
-    if (extensionType === extensions.ExtensionKind.TableHasType ||
-        extensionType === extensions.ExtensionKind.TableHasMethodType) {
-        return transformTableHasExpression(context, node, extensionType);
-    }
-    if (extensionType === extensions.ExtensionKind.TableSetType ||
-        extensionType === extensions.ExtensionKind.TableSetMethodType) {
-        return transformTableSetExpression(context, node, extensionType);
-    }
-}
-exports.transformTableExtensionCall = transformTableExtensionCall;
+exports.tableNewExtensions = [language_extensions_1.ExtensionKind.TableNewType];
+exports.tableExtensionTransformers = {
+    [language_extensions_1.ExtensionKind.TableDeleteType]: transformTableDeleteExpression,
+    [language_extensions_1.ExtensionKind.TableDeleteMethodType]: transformTableDeleteExpression,
+    [language_extensions_1.ExtensionKind.TableGetType]: transformTableGetExpression,
+    [language_extensions_1.ExtensionKind.TableGetMethodType]: transformTableGetExpression,
+    [language_extensions_1.ExtensionKind.TableHasType]: transformTableHasExpression,
+    [language_extensions_1.ExtensionKind.TableHasMethodType]: transformTableHasExpression,
+    [language_extensions_1.ExtensionKind.TableSetType]: transformTableSetExpression,
+    [language_extensions_1.ExtensionKind.TableSetMethodType]: transformTableSetExpression,
+    [language_extensions_1.ExtensionKind.TableAddKeyType]: transformTableAddExpression,
+    [language_extensions_1.ExtensionKind.TableAddKeyMethodType]: transformTableAddExpression,
+};
 function transformTableDeleteExpression(context, node, extensionKind) {
     const args = node.arguments.slice();
-    if (extensionKind === extensions.ExtensionKind.TableDeleteMethodType &&
+    if (extensionKind === language_extensions_1.ExtensionKind.TableDeleteMethodType &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
         // In case of method (no table argument), push method owner to front of args list
         args.unshift(node.expression.expression);
     }
-    // arg0[arg1] = nil
     const [table, accessExpression] = (0, expression_list_1.transformExpressionList)(context, args);
+    // arg0[arg1] = nil
     context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, accessExpression), lua.createNilLiteral(), node));
     return lua.createBooleanLiteral(true);
 }
-function transformTableGetExpression(context, node, extensionKind) {
-    const args = node.arguments.slice();
-    if (extensionKind === extensions.ExtensionKind.TableGetMethodType &&
-        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
-        // In case of method (no table argument), push method owner to front of args list
-        args.unshift(node.expression.expression);
+function transformWithTableArgument(context, node) {
+    if (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression)) {
+        return (0, expression_list_1.transformExpressionList)(context, [node.expression.expression, ...node.arguments]);
     }
-    const [table, accessExpression] = (0, expression_list_1.transformExpressionList)(context, args);
+    // todo: report diagnostic?
+    return [lua.createNilLiteral(), ...(0, expression_list_1.transformExpressionList)(context, node.arguments)];
+}
+function transformTableGetExpression(context, node, extensionKind) {
+    const args = extensionKind === language_extensions_1.ExtensionKind.TableGetMethodType
+        ? transformWithTableArgument(context, node)
+        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
+    const [table, accessExpression] = args;
     // arg0[arg1]
     return lua.createTableIndexExpression(table, accessExpression, node);
 }
 function transformTableHasExpression(context, node, extensionKind) {
-    const args = node.arguments.slice();
-    if (extensionKind === extensions.ExtensionKind.TableHasMethodType &&
-        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
-        // In case of method (no table argument), push method owner to front of args list
-        args.unshift(node.expression.expression);
-    }
+    const args = extensionKind === language_extensions_1.ExtensionKind.TableHasMethodType
+        ? transformWithTableArgument(context, node)
+        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
+    const [table, accessExpression] = args;
     // arg0[arg1]
-    const [table, accessExpression] = (0, expression_list_1.transformExpressionList)(context, args);
     const tableIndexExpression = lua.createTableIndexExpression(table, accessExpression);
     // arg0[arg1] ~= nil
     return lua.createBinaryExpression(tableIndexExpression, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator, node);
 }
 function transformTableSetExpression(context, node, extensionKind) {
-    const args = node.arguments.slice();
-    if (extensionKind === extensions.ExtensionKind.TableSetMethodType &&
-        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
-        // In case of method (no table argument), push method owner to front of args list
-        args.unshift(node.expression.expression);
-    }
+    const args = extensionKind === language_extensions_1.ExtensionKind.TableSetMethodType
+        ? transformWithTableArgument(context, node)
+        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
+    const [table, accessExpression, value] = args;
     // arg0[arg1] = arg2
-    const [table, accessExpression, value] = (0, expression_list_1.transformExpressionList)(context, args);
     context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, accessExpression), value, node));
     return lua.createNilLiteral();
 }
+function transformTableAddExpression(context, node, extensionKind) {
+    const args = extensionKind === language_extensions_1.ExtensionKind.TableAddKeyMethodType
+        ? transformWithTableArgument(context, node)
+        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
+    const [table, value] = args;
+    // arg0[arg1] = true
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, value), lua.createBooleanLiteral(true), node));
+    return lua.createNilLiteral();
+}
 //# sourceMappingURL=table.js.map

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

@@ -2,15 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isVarargConstantNode = exports.isGlobalVarargConstant = void 0;
 const extensions = require("../../utils/language-extensions");
+const language_extensions_1 = require("../../utils/language-extensions");
 const scope_1 = require("../../utils/scope");
 function isGlobalVarargConstant(context, symbol, scope) {
-    return (scope.type === scope_1.ScopeType.File &&
-        extensions.isExtensionValue(context, symbol, extensions.ExtensionKind.VarargConstant));
+    return scope.type === scope_1.ScopeType.File && isVarargConstantSymbol(context, symbol);
 }
 exports.isGlobalVarargConstant = isGlobalVarargConstant;
+function isVarargConstantSymbol(context, symbol) {
+    return (symbol.getName() === "$vararg" &&
+        (0, language_extensions_1.getExtensionKindForSymbol)(context, symbol) === extensions.ExtensionKind.VarargConstant);
+}
 function isVarargConstantNode(context, node) {
     const symbol = context.checker.getSymbolAtLocation(node);
-    return symbol ? extensions.isExtensionValue(context, symbol, extensions.ExtensionKind.VarargConstant) : false;
+    return symbol !== undefined && isVarargConstantSymbol(context, symbol);
 }
 exports.isVarargConstantNode = isVarargConstantNode;
 //# sourceMappingURL=vararg.js.map

package/dist/transformation/visitors/literal.js

@@ -5,14 +5,12 @@ const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
 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 typescript_1 = require("../utils/typescript");
 const function_1 = require("./function");
 const expression_list_1 = require("./expression-list");
-const multi_1 = require("./language-extensions/multi");
+const identifier_1 = require("./identifier");
 // TODO: Move to object-literal.ts?
 function transformPropertyName(context, node) {
     if (ts.isComputedPropertyName(node)) {
@@ -30,21 +28,7 @@ function transformPropertyName(context, node) {
 }
 exports.transformPropertyName = transformPropertyName;
 function createShorthandIdentifier(context, valueSymbol, propertyIdentifier) {
-    const propertyName = propertyIdentifier.text;
-    const isUnsafeName = valueSymbol
-        ? (0, safe_names_1.hasUnsafeSymbolName)(context, valueSymbol, propertyIdentifier)
-        : (0, safe_names_1.hasUnsafeIdentifierName)(context, propertyIdentifier, false);
-    const name = isUnsafeName ? (0, safe_names_1.createSafeName)(propertyName) : propertyName;
-    let identifier = context.transformExpression(ts.factory.createIdentifier(name));
-    lua.setNodeOriginal(identifier, propertyIdentifier);
-    if (valueSymbol !== undefined && lua.isIdentifier(identifier)) {
-        identifier.symbolId = (0, symbols_1.getSymbolIdOfSymbol)(context, valueSymbol);
-        const exportScope = (0, export_1.getSymbolExportScope)(context, valueSymbol);
-        if (exportScope) {
-            identifier = (0, export_1.createExportedIdentifier)(context, identifier, exportScope);
-        }
-    }
-    return identifier;
+    return (0, identifier_1.transformIdentifierWithSymbol)(context, propertyIdentifier, valueSymbol);
 }
 exports.createShorthandIdentifier = createShorthandIdentifier;
 const transformNumericLiteralExpression = expression => {
@@ -56,11 +40,6 @@ const transformNumericLiteralExpression = expression => {
     return lua.createNumericLiteral(Number(expression.text), expression);
 };
 const transformObjectLiteralExpression = (expression, context) => {
-    const violations = (0, multi_1.findMultiAssignmentViolations)(context, expression);
-    if (violations.length > 0) {
-        context.diagnostics.push(...violations.map(e => (0, diagnostics_1.invalidMultiFunctionUse)(e)));
-        return lua.createNilLiteral(expression);
-    }
     const properties = [];
     const initializers = [];
     const keyPrecedingStatements = [];

package/dist/transformation/visitors/loops/for-of.js

@@ -3,14 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformForOfStatement = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
-const annotations_1 = require("../../utils/annotations");
-const diagnostics_1 = require("../../utils/diagnostics");
 const lualib_1 = require("../../utils/lualib");
 const typescript_1 = require("../../utils/typescript");
 const iterable_1 = require("../language-extensions/iterable");
-const pairsIterable_1 = require("../language-extensions/pairsIterable");
 const range_1 = require("../language-extensions/range");
 const utils_1 = require("./utils");
+const language_extensions_1 = require("../../utils/language-extensions");
+const utils_2 = require("../../../utils");
 function transformForOfArrayStatement(context, statement, block) {
     const valueVariable = (0, utils_1.transformForInitializer)(context, statement.initializer, block);
     const ipairsCall = lua.createCallExpression(lua.createIdentifier("ipairs"), [
@@ -28,24 +27,25 @@ const transformForOfStatement = (node, context) => {
     if (ts.isCallExpression(node.expression) && (0, range_1.isRangeFunction)(context, node.expression)) {
         return (0, range_1.transformRangeStatement)(context, node, body);
     }
-    else if (ts.isCallExpression(node.expression) && (0, annotations_1.isForRangeType)(context, node.expression.expression)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node.expression, annotations_1.AnnotationKind.ForRange));
+    const iterableExtensionType = (0, language_extensions_1.getIterableExtensionKindForNode)(context, node.expression);
+    if (iterableExtensionType) {
+        if (iterableExtensionType === language_extensions_1.IterableExtensionKind.Iterable) {
+            return (0, iterable_1.transformForOfIterableStatement)(context, node, body);
+        }
+        else if (iterableExtensionType === language_extensions_1.IterableExtensionKind.Pairs) {
+            return (0, iterable_1.transformForOfPairsIterableStatement)(context, node, body);
+        }
+        else if (iterableExtensionType === language_extensions_1.IterableExtensionKind.PairsKey) {
+            return (0, iterable_1.transformForOfPairsKeyIterableStatement)(context, node, body);
+        }
+        else {
+            (0, utils_2.assertNever)(iterableExtensionType);
+        }
     }
-    else if ((0, iterable_1.isIterableExpression)(context, node.expression)) {
-        return (0, iterable_1.transformForOfIterableStatement)(context, node, body);
-    }
-    else if ((0, pairsIterable_1.isPairsIterableExpression)(context, node.expression)) {
-        return (0, pairsIterable_1.transformForOfPairsIterableStatement)(context, node, body);
-    }
-    else if ((0, annotations_1.isLuaIteratorType)(context, node.expression)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node.expression, annotations_1.AnnotationKind.LuaIterator));
-    }
-    else if ((0, typescript_1.isArrayType)(context, context.checker.getTypeAtLocation(node.expression))) {
+    if ((0, typescript_1.isArrayType)(context, context.checker.getTypeAtLocation(node.expression))) {
         return transformForOfArrayStatement(context, node, body);
     }
-    else {
-        return transformForOfIteratorStatement(context, node, body);
-    }
+    return transformForOfIteratorStatement(context, node, body);
 };
 exports.transformForOfStatement = transformForOfStatement;
 //# sourceMappingURL=for-of.js.map

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

@@ -12,9 +12,9 @@ const block_1 = require("../block");
 const identifier_1 = require("../identifier");
 const variable_declaration_1 = require("../variable-declaration");
 function transformLoopBody(context, loop) {
-    (0, scope_1.pushScope)(context, scope_1.ScopeType.Loop);
+    context.pushScope(scope_1.ScopeType.Loop);
     const body = (0, scope_1.performHoisting)(context, (0, block_1.transformBlockOrStatement)(context, loop.statement));
-    const scope = (0, scope_1.popScope)(context);
+    const scope = context.popScope();
     const scopeId = scope.id;
     if (!scope.loopContinued) {
         return body;
@@ -35,7 +35,7 @@ function getVariableDeclarationBinding(context, node) {
 exports.getVariableDeclarationBinding = getVariableDeclarationBinding;
 function transformForInitializer(context, initializer, block) {
     const valueVariable = lua.createIdentifier("____value");
-    (0, scope_1.pushScope)(context, scope_1.ScopeType.LoopInitializer);
+    context.pushScope(scope_1.ScopeType.LoopInitializer);
     if (ts.isVariableDeclarationList(initializer)) {
         // Declaration of new variable
         const binding = getVariableDeclarationBinding(context, initializer);
@@ -45,7 +45,7 @@ function transformForInitializer(context, initializer, block) {
         }
         else {
             // Single variable declared in for loop
-            (0, scope_1.popScope)(context);
+            context.popScope();
             return (0, identifier_1.transformIdentifier)(context, binding);
         }
     }
@@ -55,7 +55,7 @@ function transformForInitializer(context, initializer, block) {
             ? (0, destructuring_assignments_1.transformAssignmentPattern)(context, initializer, valueVariable, false)
             : (0, assignments_1.transformAssignment)(context, initializer, valueVariable)));
     }
-    (0, scope_1.popScope)(context);
+    context.popScope();
     return valueVariable;
 }
 exports.transformForInitializer = transformForInitializer;

package/dist/transformation/visitors/namespace.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformModuleDeclaration = exports.createModuleLocalNameIdentifier = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
-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");
@@ -33,16 +31,9 @@ function moduleHasEmittedBody(node) {
     }
     return false;
 }
-// Static context -> namespace dictionary keeping the current namespace for each transformation context
-const currentNamespaces = new WeakMap();
 const transformModuleDeclaration = (node, context) => {
     var _a, _b;
-    const annotations = (0, annotations_1.getTypeAnnotations)(context.checker.getTypeAtLocation(node));
-    // If phantom namespace elide the declaration and return the body
-    if (annotations.has(annotations_1.AnnotationKind.Phantom)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.Phantom));
-    }
-    const currentNamespace = currentNamespaces.get(context);
+    const currentNamespace = context.currentNamespaces;
     const result = [];
     const symbol = context.checker.getSymbolAtLocation(node.name);
     const hasExports = symbol !== undefined && context.checker.getExportsOfModule(symbol).length > 0;
@@ -75,15 +66,15 @@ const transformModuleDeclaration = (node, context) => {
     }
     // Set current namespace for nested NS
     // Keep previous namespace to reset after block transpilation
-    currentNamespaces.set(context, node);
+    context.currentNamespaces = node;
     // Transform moduleblock to block and visit it
     if (moduleHasEmittedBody(node)) {
-        (0, scope_1.pushScope)(context, scope_1.ScopeType.Block);
+        context.pushScope(scope_1.ScopeType.Block);
         const statements = (0, scope_1.performHoisting)(context, context.transformStatements(ts.isModuleBlock(node.body) ? node.body.statements : node.body));
-        (0, scope_1.popScope)(context);
+        context.popScope();
         result.push(lua.createDoStatement(statements));
     }
-    currentNamespaces.set(context, currentNamespace);
+    context.currentNamespaces = currentNamespace;
     return result;
 };
 exports.transformModuleDeclaration = transformModuleDeclaration;