typescript-to-lua - npm Package Compare versions

Comparing version 1.12.0 to 1.12.1

dist/CompilerOptions.d.ts

@@ -42,3 +42,4 @@ import * as ts from "typescript";
     Inline = "inline",
-    Require = "require"
+    Require = "require",
+    RequireMinimal = "require-minimal"
 }
@@ -45,0 +46,0 @@ export declare enum LuaTarget {

dist/CompilerOptions.js

@@ -11,2 +11,3 @@ "use strict";
     LuaLibImportKind["Require"] = "require";
+    LuaLibImportKind["RequireMinimal"] = "require-minimal";
 })(LuaLibImportKind = exports.LuaLibImportKind || (exports.LuaLibImportKind = {}));
@@ -13,0 +14,0 @@ var LuaTarget;

dist/lualib-build/plugin.js

@@ -52,3 +52,3 @@ "use strict";
         const exports = allFeatures.flatMap(feature => luaLibModuleInfo[feature].exports);
-        lualibBundle += `\nreturn {\n${exports.map(exportName => `  ${exportName} = ${exportName}`).join(",\n")}\n}\n`;
+        lualibBundle += (0, LuaLib_1.getLualibBundleReturn)(exports);
         result.push({ fileName: "lualib_bundle.lua", code: lualibBundle });
@@ -55,0 +55,0 @@ return diagnostics;

dist/LuaLib.d.ts

@@ -113,2 +113,3 @@ import { EmitHost } from "./transpilation";
 export declare function getLuaLibModulesInfo(luaTarget: LuaTarget, emitHost: EmitHost): LuaLibModulesInfo;
+export declare function getLuaLibExportToFeatureMap(luaTarget: LuaTarget, emitHost: EmitHost): ReadonlyMap<string, LuaLibFeature>;
 export declare function readLuaLibFeature(feature: LuaLibFeature, luaTarget: LuaTarget, emitHost: EmitHost): string;
@@ -119,1 +120,4 @@ export declare function resolveRecursiveLualibFeatures(features: Iterable<LuaLibFeature>, luaTarget: LuaTarget, emitHost: EmitHost, luaLibModulesInfo?: LuaLibModulesInfo): LuaLibFeature[];
 export declare function getLuaLibBundle(luaTarget: LuaTarget, emitHost: EmitHost): string;
+export declare function getLualibBundleReturn(exportedValues: string[]): string;
+export declare function buildMinimalLualibBundle(features: Iterable<LuaLibFeature>, luaTarget: LuaTarget, emitHost: EmitHost): string;
+export declare function findUsedLualibFeatures(luaTarget: LuaTarget, emitHost: EmitHost, luaContents: string[]): Set<LuaLibFeature>;

dist/LuaLib.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLuaLibBundle = exports.loadImportedLualibFeatures = exports.loadInlineLualibFeatures = exports.resolveRecursiveLualibFeatures = exports.readLuaLibFeature = exports.getLuaLibModulesInfo = exports.luaLibModulesInfoFileName = exports.resolveLuaLibDir = exports.LuaLibFeature = void 0;
+exports.findUsedLualibFeatures = exports.buildMinimalLualibBundle = exports.getLualibBundleReturn = exports.getLuaLibBundle = exports.loadImportedLualibFeatures = exports.loadInlineLualibFeatures = exports.resolveRecursiveLualibFeatures = exports.readLuaLibFeature = exports.getLuaLibExportToFeatureMap = exports.getLuaLibModulesInfo = exports.luaLibModulesInfoFileName = exports.resolveLuaLibDir = exports.LuaLibFeature = void 0;
 const path = require("path");
 const lua = require("./LuaAST");
 const CompilerOptions_1 = require("./CompilerOptions");
+const utils_1 = require("./utils");
 var LuaLibFeature;
@@ -117,7 +118,7 @@ (function (LuaLibFeature) {
 function getLuaLibModulesInfo(luaTarget, emitHost) {
-    const lualibPath = path.join(resolveLuaLibDir(luaTarget), exports.luaLibModulesInfoFileName);
-    if (!luaLibModulesInfo.has(lualibPath)) {
+    if (!luaLibModulesInfo.has(luaTarget)) {
+        const lualibPath = path.join(resolveLuaLibDir(luaTarget), exports.luaLibModulesInfoFileName);
         const result = emitHost.readFile(lualibPath);
         if (result !== undefined) {
-            luaLibModulesInfo.set(lualibPath, JSON.parse(result));
+            luaLibModulesInfo.set(luaTarget, JSON.parse(result));
         }
@@ -128,12 +129,33 @@ else {
     }
-    return luaLibModulesInfo.get(lualibPath);
+    return luaLibModulesInfo.get(luaTarget);
 }
 exports.getLuaLibModulesInfo = getLuaLibModulesInfo;
+// This caches the names of lualib exports to their LuaLibFeature, avoiding a linear search for every lookup
+const lualibExportToFeature = new Map();
+function getLuaLibExportToFeatureMap(luaTarget, emitHost) {
+    if (!lualibExportToFeature.has(luaTarget)) {
+        const luaLibModulesInfo = getLuaLibModulesInfo(luaTarget, emitHost);
+        const map = new Map();
+        for (const [feature, info] of Object.entries(luaLibModulesInfo)) {
+            for (const exportName of info.exports) {
+                map.set(exportName, feature);
+            }
+        }
+        lualibExportToFeature.set(luaTarget, map);
+    }
+    return lualibExportToFeature.get(luaTarget);
+}
+exports.getLuaLibExportToFeatureMap = getLuaLibExportToFeatureMap;
+const lualibFeatureCache = new Map();
 function readLuaLibFeature(feature, luaTarget, emitHost) {
-    const featurePath = path.join(resolveLuaLibDir(luaTarget), `${feature}.lua`);
-    const luaLibFeature = emitHost.readFile(featurePath);
-    if (luaLibFeature === undefined) {
-        throw new Error(`Could not load lualib feature from '${featurePath}'`);
+    const featureMap = (0, utils_1.getOrUpdate)(lualibFeatureCache, luaTarget, () => new Map());
+    if (!featureMap.has(feature)) {
+        const featurePath = path.join(resolveLuaLibDir(luaTarget), `${feature}.lua`);
+        const luaLibFeature = emitHost.readFile(featurePath);
+        if (luaLibFeature === undefined) {
+            throw new Error(`Could not load lualib feature from '${featurePath}'`);
+        }
+        featureMap.set(feature, luaLibFeature);
     }
-    return luaLibFeature;
+    return featureMap.get(feature);
 }
@@ -162,8 +184,5 @@ exports.readLuaLibFeature = readLuaLibFeature;
 function loadInlineLualibFeatures(features, luaTarget, emitHost) {
-    let result = "";
-    for (const feature of resolveRecursiveLualibFeatures(features, luaTarget, emitHost)) {
-        const luaLibFeature = readLuaLibFeature(feature, luaTarget, emitHost);
-        result += luaLibFeature + "\n";
-    }
-    return result;
+    return resolveRecursiveLualibFeatures(features, luaTarget, emitHost)
+        .map(feature => readLuaLibFeature(feature, luaTarget, emitHost))
+        .join("\n");
 }
@@ -174,8 +193,8 @@ exports.loadInlineLualibFeatures = loadInlineLualibFeatures;
     const imports = Array.from(features).flatMap(feature => luaLibModuleInfo[feature].exports);
+    if (imports.length === 0) {
+        return [];
+    }
     const requireCall = lua.createCallExpression(lua.createIdentifier("require"), [
         lua.createStringLiteral("lualib_bundle"),
     ]);
-    if (imports.length === 0) {
-        return [];
-    }
     const luaLibId = lua.createIdentifier("____lualib");
@@ -206,2 +225,33 @@ const importStatement = lua.createVariableDeclarationStatement(luaLibId, requireCall);
 exports.getLuaLibBundle = getLuaLibBundle;
+function getLualibBundleReturn(exportedValues) {
+    return `\nreturn {\n${exportedValues.map(exportName => `  ${exportName} = ${exportName}`).join(",\n")}\n}\n`;
+}
+exports.getLualibBundleReturn = getLualibBundleReturn;
+function buildMinimalLualibBundle(features, luaTarget, emitHost) {
+    const code = loadInlineLualibFeatures(features, luaTarget, emitHost);
+    const moduleInfo = getLuaLibModulesInfo(luaTarget, emitHost);
+    const exports = Array.from(features).flatMap(feature => moduleInfo[feature].exports);
+    return code + getLualibBundleReturn(exports);
+}
+exports.buildMinimalLualibBundle = buildMinimalLualibBundle;
+function findUsedLualibFeatures(luaTarget, emitHost, luaContents) {
+    const features = new Set();
+    const exportToFeatureMap = getLuaLibExportToFeatureMap(luaTarget, emitHost);
+    for (const lua of luaContents) {
+        const regex = /^local (\w+) = ____lualib\.(\w+)$/gm;
+        while (true) {
+            const match = regex.exec(lua);
+            if (!match)
+                break;
+            const [, localName, exportName] = match;
+            if (localName !== exportName)
+                continue;
+            const feature = exportToFeatureMap.get(exportName);
+            if (feature)
+                features.add(feature);
+        }
+    }
+    return features;
+}
+exports.findUsedLualibFeatures = findUsedLualibFeatures;
 //# sourceMappingURL=LuaLib.js.map

dist/LuaPrinter.js

@@ -138,3 +138,4 @@ "use strict";
         const luaLibImport = (_b = this.options.luaLibImport) !== null && _b !== void 0 ? _b : CompilerOptions_1.LuaLibImportKind.Require;
-        if (luaLibImport === CompilerOptions_1.LuaLibImportKind.Require && file.luaLibFeatures.size > 0) {
+        if ((luaLibImport === CompilerOptions_1.LuaLibImportKind.Require || luaLibImport === CompilerOptions_1.LuaLibImportKind.RequireMinimal) &&
+            file.luaLibFeatures.size > 0) {
             // Import lualib features
@@ -141,0 +142,0 @@ sourceChunks = this.printStatementArray((0, LuaLib_1.loadImportedLualibFeatures)(file.luaLibFeatures, luaTarget, this.emitHost));

dist/transformation/builtins/array.js

@@ -45,6 +45,6 @@ "use strict";
 function transformSingleElementArrayPush(context, node, caller, param) {
-    const expressionIsUsed = !ts.isExpressionStatement((0, typescript_1.findFirstNonOuterParent)(node));
     const arrayIdentifier = lua.isIdentifier(caller) ? caller : (0, expression_list_1.moveToPrecedingTemp)(context, caller);
     // #array + 1
     let lengthExpression = lua.createBinaryExpression(createTableLengthExpression(context, arrayIdentifier), lua.createNumericLiteral(1), lua.SyntaxKind.AdditionOperator);
+    const expressionIsUsed = (0, typescript_1.expressionResultIsUsed)(node);
     if (expressionIsUsed) {
@@ -51,0 +51,0 @@ // store length in a temp

dist/transformation/utils/diagnostics.d.ts

@@ -94,1 +94,7 @@ import * as ts from "typescript";
 };
+export declare const invalidMethodCallExtensionUse: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+    code: number;
+};
+export declare const invalidSpreadInCallExtension: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+    code: number;
+};

dist/transformation/utils/diagnostics.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.undefinedInArrayLiteral = exports.unsupportedOptionalCompileMembersOnly = exports.unsupportedBuiltinOptionalCall = exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.truthyOnlyConditionalValue = exports.annotationDeprecated = exports.invalidCallExtensionUse = exports.invalidMultiReturnAccess = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTargetButOverrideAvailable = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.invalidPairsIterableWithoutDestructuring = exports.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
+exports.invalidSpreadInCallExtension = exports.invalidMethodCallExtensionUse = exports.undefinedInArrayLiteral = exports.unsupportedOptionalCompileMembersOnly = exports.unsupportedBuiltinOptionalCall = exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.truthyOnlyConditionalValue = exports.annotationDeprecated = exports.invalidCallExtensionUse = exports.invalidMultiReturnAccess = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTargetButOverrideAvailable = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.invalidPairsIterableWithoutDestructuring = exports.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
 const ts = require("typescript");
@@ -62,2 +62,4 @@ const CompilerOptions_1 = require("../../CompilerOptions");
 exports.undefinedInArrayLiteral = createErrorDiagnosticFactory("Array literals may not contain undefined or null.");
+exports.invalidMethodCallExtensionUse = createErrorDiagnosticFactory("This language extension must be called as a method.");
+exports.invalidSpreadInCallExtension = createErrorDiagnosticFactory("Spread elements are not supported in call extensions.");
 //# sourceMappingURL=diagnostics.js.map

dist/transformation/utils/language-extensions.d.ts

@@ -66,1 +66,5 @@ import * as ts from "typescript";
 export declare function getIterableExtensionKindForNode(context: TransformationContext, node: ts.Node): IterableExtensionKind | undefined;
+export declare const methodExtensionKinds: ReadonlySet<ExtensionKind>;
+export declare function getNaryCallExtensionArgs(context: TransformationContext, node: ts.CallExpression, kind: ExtensionKind, numArgs: number): readonly ts.Expression[] | undefined;
+export declare function getUnaryCallExtensionArg(context: TransformationContext, node: ts.CallExpression, kind: ExtensionKind): ts.Expression | undefined;
+export declare function getBinaryCallExtensionArgs(context: TransformationContext, node: ts.CallExpression, kind: ExtensionKind): readonly [ts.Expression, ts.Expression] | undefined;

dist/transformation/utils/language-extensions.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIterableExtensionKindForNode = exports.getIterableExtensionTypeForType = exports.isLuaIterable = exports.IterableExtensionKind = exports.getExtensionKindForSymbol = exports.getExtensionKindForNode = exports.getExtensionKindForType = exports.ExtensionKind = void 0;
+exports.getBinaryCallExtensionArgs = exports.getUnaryCallExtensionArg = exports.getNaryCallExtensionArgs = exports.methodExtensionKinds = exports.getIterableExtensionKindForNode = exports.getIterableExtensionTypeForType = exports.isLuaIterable = exports.IterableExtensionKind = exports.getExtensionKindForSymbol = exports.getExtensionKindForNode = exports.getExtensionKindForType = exports.ExtensionKind = void 0;
 const ts = require("typescript");
+const diagnostics_1 = require("./diagnostics");
 var ExtensionKind;
@@ -115,2 +116,66 @@ (function (ExtensionKind) {
 exports.getIterableExtensionKindForNode = getIterableExtensionKindForNode;
+exports.methodExtensionKinds = new Set([
+    ExtensionKind.AdditionOperatorMethodType,
+    ExtensionKind.SubtractionOperatorMethodType,
+    ExtensionKind.MultiplicationOperatorMethodType,
+    ExtensionKind.DivisionOperatorMethodType,
+    ExtensionKind.ModuloOperatorMethodType,
+    ExtensionKind.PowerOperatorMethodType,
+    ExtensionKind.FloorDivisionOperatorMethodType,
+    ExtensionKind.BitwiseAndOperatorMethodType,
+    ExtensionKind.BitwiseOrOperatorMethodType,
+    ExtensionKind.BitwiseExclusiveOrOperatorMethodType,
+    ExtensionKind.BitwiseLeftShiftOperatorMethodType,
+    ExtensionKind.BitwiseRightShiftOperatorMethodType,
+    ExtensionKind.ConcatOperatorMethodType,
+    ExtensionKind.LessThanOperatorMethodType,
+    ExtensionKind.GreaterThanOperatorMethodType,
+    ExtensionKind.NegationOperatorMethodType,
+    ExtensionKind.BitwiseNotOperatorMethodType,
+    ExtensionKind.LengthOperatorMethodType,
+    ExtensionKind.TableDeleteMethodType,
+    ExtensionKind.TableGetMethodType,
+    ExtensionKind.TableHasMethodType,
+    ExtensionKind.TableSetMethodType,
+    ExtensionKind.TableAddKeyMethodType,
+]);
+function getNaryCallExtensionArgs(context, node, kind, numArgs) {
+    let expressions;
+    if (node.arguments.some(ts.isSpreadElement)) {
+        context.diagnostics.push((0, diagnostics_1.invalidSpreadInCallExtension)(node));
+        return undefined;
+    }
+    if (exports.methodExtensionKinds.has(kind)) {
+        if (!(ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
+            context.diagnostics.push((0, diagnostics_1.invalidMethodCallExtensionUse)(node));
+            return undefined;
+        }
+        if (node.arguments.length < numArgs - 1) {
+            // assumed to be TS error
+            return undefined;
+        }
+        expressions = [node.expression.expression, ...node.arguments];
+    }
+    else {
+        if (node.arguments.length < numArgs) {
+            // assumed to be TS error
+            return undefined;
+        }
+        expressions = node.arguments;
+    }
+    return expressions;
+}
+exports.getNaryCallExtensionArgs = getNaryCallExtensionArgs;
+function getUnaryCallExtensionArg(context, node, kind) {
+    var _a;
+    return (_a = getNaryCallExtensionArgs(context, node, kind, 1)) === null || _a === void 0 ? void 0 : _a[0];
+}
+exports.getUnaryCallExtensionArg = getUnaryCallExtensionArg;
+function getBinaryCallExtensionArgs(context, node, kind) {
+    const expressions = getNaryCallExtensionArgs(context, node, kind, 2);
+    if (expressions === undefined)
+        return undefined;
+    return [expressions[0], expressions[1]];
+}
+exports.getBinaryCallExtensionArgs = getBinaryCallExtensionArgs;
 //# sourceMappingURL=language-extensions.js.map

dist/transformation/utils/typescript/index.d.ts

@@ -11,2 +11,3 @@ import * as ts from "typescript";
 export declare function findFirstNonOuterParent(node: ts.Node): ts.Node;
+export declare function expressionResultIsUsed(node: ts.Expression): boolean;
 export declare function getFirstDeclarationInFile(symbol: ts.Symbol, sourceFile: ts.SourceFile): ts.Declaration | undefined;
@@ -13,0 +14,0 @@ export declare function isStandardLibraryDeclaration(context: TransformationContext, declaration: ts.Declaration): boolean;

dist/transformation/utils/typescript/index.js

@@ -17,3 +17,3 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.isStandardLibraryDeclaration = exports.getFirstDeclarationInFile = exports.findFirstNonOuterParent = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
+exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.isStandardLibraryDeclaration = exports.getFirstDeclarationInFile = exports.expressionResultIsUsed = exports.findFirstNonOuterParent = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
 const ts = require("typescript");
@@ -50,2 +50,6 @@ __exportStar(require("./nodes"), exports);
 exports.findFirstNonOuterParent = findFirstNonOuterParent;
+function expressionResultIsUsed(node) {
+    return !ts.isExpressionStatement(findFirstNonOuterParent(node));
+}
+exports.expressionResultIsUsed = expressionResultIsUsed;
 function getFirstDeclarationInFile(symbol, sourceFile) {
@@ -52,0 +56,0 @@ var _a, _b;

dist/transformation/utils/typescript/types.js

@@ -106,5 +106,2 @@ "use strict";
 function canBeFalsyWhenNotNull(context, type) {
-    const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
-    if (!strictNullChecks && !type.isLiteral())
-        return true;
     const falsyFlags = ts.TypeFlags.Boolean |
@@ -111,0 +108,0 @@ ts.TypeFlags.BooleanLiteral |

dist/transformation/visitors/expression-statement.d.ts

 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
-import { FunctionVisitor, TransformationContext } from "../context";
+import { FunctionVisitor } from "../context";
 export declare const transformExpressionStatement: FunctionVisitor<ts.ExpressionStatement>;
-export declare function transformExpressionToStatement(context: TransformationContext, expression: ts.Expression): lua.Statement | undefined;
+export declare function wrapInStatement(result: lua.Expression): lua.Statement | undefined;

dist/transformation/visitors/expression-statement.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformExpressionToStatement = exports.transformExpressionStatement = void 0;
+exports.wrapInStatement = exports.transformExpressionStatement = void 0;
 const lua = require("../../LuaAST");
@@ -17,7 +17,6 @@ const context_1 = require("../context");
     }
-    return transformExpressionToStatement(context, node.expression);
+    return wrapInStatement(context.transformExpression(node.expression));
 };
 exports.transformExpressionStatement = transformExpressionStatement;
-function transformExpressionToStatement(context, expression) {
-    const result = context.transformExpression(expression);
+function wrapInStatement(result) {
     const isTempVariable = lua.isIdentifier(result) && result.symbolId === context_1.tempSymbolId;
@@ -38,3 +37,3 @@ if (isTempVariable) {
 }
-exports.transformExpressionToStatement = transformExpressionToStatement;
+exports.wrapInStatement = wrapInStatement;
 //# sourceMappingURL=expression-statement.js.map

dist/transformation/visitors/identifier.js

@@ -24,3 +24,5 @@ "use strict";
     if ((0, optional_chaining_1.isOptionalContinuation)(identifier)) {
-        return lua.createIdentifier(identifier.text, undefined, context_1.tempSymbolId);
+        const result = lua.createIdentifier(identifier.text, undefined, context_1.tempSymbolId);
+        (0, optional_chaining_1.getOptionalContinuationData)(identifier).usedIdentifiers.push(result);
+        return result;
     }
@@ -27,0 +29,0 @@ const extensionKind = symbol

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

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.operatorExtensionTransformers = void 0;
-const ts = require("typescript");
 const lua = require("../../../LuaAST");
@@ -10,2 +9,3 @@ const utils_1 = require("../../../utils");
 const language_extensions_1 = require("../../utils/language-extensions");
+const expression_list_1 = require("../expression-list");
 const binaryOperatorMappings = new Map([
@@ -80,10 +80,9 @@ [language_extensions_1.ExtensionKind.AdditionOperatorType, lua.SyntaxKind.AdditionOperator],
         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 args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, kind);
+    if (!args)
+        return lua.createNilLiteral();
+    const [left, right] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     const luaOperator = binaryOperatorMappings.get(kind);
     (0, utils_1.assert)(luaOperator);
-    return lua.createBinaryExpression(context.transformExpression(args[0]), context.transformExpression(args[1]), luaOperator);
+    return lua.createBinaryExpression(left, right, luaOperator);
 }
@@ -93,10 +92,5 @@ function transformUnaryOperator(context, node, 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 {
-        arg = node.arguments[0];
-    }
+    const arg = (0, language_extensions_1.getUnaryCallExtensionArg)(context, node, kind);
+    if (!arg)
+        return lua.createNilLiteral();
     const luaOperator = unaryOperatorMappings.get(kind);
@@ -103,0 +97,0 @@ (0, utils_1.assert)(luaOperator);

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

 import * as ts from "typescript";
 import { TransformationContext } from "../../context";
 import { ExtensionKind } from "../../utils/language-extensions";
-import { LanguageExtensionCallTransformer } from "./call-extension";
+import { LanguageExtensionCallTransformerMap } from "./call-extension";
 export declare function isTableNewCall(context: TransformationContext, node: ts.NewExpression): boolean;
 export declare const tableNewExtensions: ExtensionKind[];
-export declare const tableExtensionTransformers: {
-    [P in ExtensionKind]?: LanguageExtensionCallTransformer;
-};
+export declare const tableExtensionTransformers: LanguageExtensionCallTransformerMap;

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

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tableExtensionTransformers = exports.tableNewExtensions = exports.isTableNewCall = void 0;
-const ts = require("typescript");
 const lua = require("../../../LuaAST");
@@ -22,39 +21,32 @@ const language_extensions_1 = require("../../utils/language-extensions");
     [language_extensions_1.ExtensionKind.TableSetMethodType]: transformTableSetExpression,
-    [language_extensions_1.ExtensionKind.TableAddKeyType]: transformTableAddExpression,
-    [language_extensions_1.ExtensionKind.TableAddKeyMethodType]: transformTableAddExpression,
+    [language_extensions_1.ExtensionKind.TableAddKeyType]: transformTableAddKeyExpression,
+    [language_extensions_1.ExtensionKind.TableAddKeyMethodType]: transformTableAddKeyExpression,
 };
 function transformTableDeleteExpression(context, node, extensionKind) {
-    const args = node.arguments.slice();
-    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);
+    const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, extensionKind);
+    if (!args) {
+        return lua.createNilLiteral();
     }
-    const [table, accessExpression] = (0, expression_list_1.transformExpressionList)(context, args);
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1] = nil
-    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, accessExpression), lua.createNilLiteral(), node));
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, key), lua.createNilLiteral(), node));
     return lua.createBooleanLiteral(true);
 }
-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]);
+function transformTableGetExpression(context, node, extensionKind) {
+    const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, extensionKind);
+    if (!args) {
+        return lua.createNilLiteral();
     }
-    // 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;
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1]
-    return lua.createTableIndexExpression(table, accessExpression, node);
+    return lua.createTableIndexExpression(table, key, node);
 }
 function transformTableHasExpression(context, node, extensionKind) {
-    const args = extensionKind === language_extensions_1.ExtensionKind.TableHasMethodType
-        ? transformWithTableArgument(context, node)
-        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
-    const [table, accessExpression] = args;
+    const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, extensionKind);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1]
-    const tableIndexExpression = lua.createTableIndexExpression(table, accessExpression);
+    const tableIndexExpression = lua.createTableIndexExpression(table, key);
     // arg0[arg1] ~= nil
@@ -64,19 +56,21 @@ return lua.createBinaryExpression(tableIndexExpression, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator, node);
 function transformTableSetExpression(context, node, extensionKind) {
-    const args = extensionKind === language_extensions_1.ExtensionKind.TableSetMethodType
-        ? transformWithTableArgument(context, node)
-        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
-    const [table, accessExpression, value] = args;
+    const args = (0, language_extensions_1.getNaryCallExtensionArgs)(context, node, extensionKind, 3);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const [table, key, value] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1] = arg2
-    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, accessExpression), value, node));
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, key), 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;
+function transformTableAddKeyExpression(context, node, extensionKind) {
+    const args = (0, language_extensions_1.getNaryCallExtensionArgs)(context, node, extensionKind, 2);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1] = true
-    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, value), lua.createBooleanLiteral(true), node));
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, key), lua.createBooleanLiteral(true), node));
     return lua.createNilLiteral();
 }
 //# sourceMappingURL=table.js.map

dist/transformation/visitors/optional-chaining.d.ts

@@ -11,2 +11,3 @@ import * as ts from "typescript";
     contextualCall?: lua.CallExpression;
+    usedIdentifiers: lua.Identifier[];
 }
@@ -16,3 +17,3 @@ export declare function isOptionalContinuation(node: ts.Node): boolean;
 export declare function transformOptionalChain(context: TransformationContext, node: ts.OptionalChain): lua.Expression;
-export declare function transformOptionalChainWithCapture(context: TransformationContext, node: ts.OptionalChain, thisValueCapture: lua.Identifier | undefined, isDelete?: ts.DeleteExpression): ExpressionWithThisValue;
+export declare function transformOptionalChainWithCapture(context: TransformationContext, tsNode: ts.OptionalChain, thisValueCapture: lua.Identifier | undefined, isDelete?: ts.DeleteExpression): ExpressionWithThisValue;
 export declare function transformOptionalDeleteExpression(context: TransformationContext, node: ts.DeleteExpression, innerExpression: ts.OptionalChain): lua.BooleanLiteral;

dist/transformation/visitors/optional-chaining.js

@@ -11,2 +11,4 @@ "use strict";
 const expression_list_1 = require("./expression-list");
+const typescript_1 = require("../utils/typescript");
+const expression_statement_1 = require("./expression-statement");
 function skipNonNullChains(chain) {
@@ -43,3 +45,3 @@ while (ts.isNonNullChain(chain)) {
 function captureThisValue(context, expression, thisValueCapture, tsOriginal) {
-    if (!(0, expression_list_1.shouldMoveToTemp)(context, expression, tsOriginal) && !isOptionalContinuation(tsOriginal)) {
+    if (!(0, expression_list_1.shouldMoveToTemp)(context, expression, tsOriginal)) {
         return expression;
@@ -57,3 +59,5 @@ }
     ts.setOriginalNode(identifier, tsOriginal);
-    optionalContinuations.set(identifier, {});
+    optionalContinuations.set(identifier, {
+        usedIdentifiers: [],
+    });
     return identifier;
@@ -73,8 +77,7 @@ }
 exports.transformOptionalChain = transformOptionalChain;
-function transformOptionalChainWithCapture(context, node, thisValueCapture, isDelete) {
-    var _a;
-    const luaTemp = context.createTempNameForNode(node);
-    const { expression: tsLeftExpression, chain } = flattenChain(node);
+function transformOptionalChainWithCapture(context, tsNode, thisValueCapture, isDelete) {
+    const luaTempName = context.createTempName("opt");
+    const { expression: tsLeftExpression, chain } = flattenChain(tsNode);
     // build temp.b.c.d
-    const tsTemp = createOptionalContinuationIdentifier(luaTemp.text, tsLeftExpression);
+    const tsTemp = createOptionalContinuationIdentifier(luaTempName, tsLeftExpression);
     let tsRightExpression = tsTemp;
@@ -103,11 +106,9 @@ for (const link of chain) {
     let returnThisValue;
-    const [rightPrecedingStatements, rightAssignment] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
-        let result;
-        if (thisValueCapture) {
-            ({ expression: result, thisValue: returnThisValue } = transformExpressionWithThisValueCapture(context, tsRightExpression, thisValueCapture));
+    const [rightPrecedingStatements, rightExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        if (!thisValueCapture) {
+            return context.transformExpression(tsRightExpression);
         }
-        else {
-            result = context.transformExpression(tsRightExpression);
-        }
-        return lua.createAssignmentStatement(luaTemp, result);
+        const { expression: result, thisValue } = transformExpressionWithThisValueCapture(context, tsRightExpression, thisValueCapture);
+        returnThisValue = thisValue;
+        return result;
     });
@@ -118,3 +119,4 @@ // transform left expression, handle thisValue if needed by rightExpression
     let capturedThisValue;
-    const rightContextualCall = (_a = getOptionalContinuationData(tsTemp)) === null || _a === void 0 ? void 0 : _a.contextualCall;
+    const optionalContinuationData = getOptionalContinuationData(tsTemp);
+    const rightContextualCall = optionalContinuationData === null || optionalContinuationData === void 0 ? void 0 : optionalContinuationData.contextualCall;
     const [leftPrecedingStatements, leftExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
@@ -155,18 +157,62 @@ let result;
     }
-    // <left preceding statements>
-    // local temp = <left>
-    // if temp ~= nil then
-    //   <right preceding statements>
-    //   temp = temp.b.c.d
-    // end
-    // return temp
-    context.addPrecedingStatements([
-        ...leftPrecedingStatements,
-        lua.createVariableDeclarationStatement(luaTemp, leftExpression),
-        lua.createIfStatement(lua.createBinaryExpression(luaTemp, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock([...rightPrecedingStatements, rightAssignment])),
-    ]);
-    return {
-        expression: luaTemp,
-        thisValue: returnThisValue,
-    };
+    // evaluate optional chain
+    context.addPrecedingStatements(leftPrecedingStatements);
+    // try use existing variable instead of creating new one, if possible
+    let leftIdentifier;
+    const usedLuaIdentifiers = optionalContinuationData === null || optionalContinuationData === void 0 ? void 0 : optionalContinuationData.usedIdentifiers;
+    const reuseLeftIdentifier = usedLuaIdentifiers &&
+        usedLuaIdentifiers.length > 0 &&
+        lua.isIdentifier(leftExpression) &&
+        (rightPrecedingStatements.length === 0 || !(0, expression_list_1.shouldMoveToTemp)(context, leftExpression, tsLeftExpression));
+    if (reuseLeftIdentifier) {
+        leftIdentifier = leftExpression;
+        for (const usedIdentifier of usedLuaIdentifiers) {
+            usedIdentifier.text = leftIdentifier.text;
+        }
+    }
+    else {
+        leftIdentifier = lua.createIdentifier(luaTempName, undefined, context_1.tempSymbolId);
+        context.addPrecedingStatements(lua.createVariableDeclarationStatement(leftIdentifier, leftExpression));
+    }
+    if (!(0, typescript_1.expressionResultIsUsed)(tsNode) || isDelete) {
+        // if left ~= nil then
+        //   <right preceding statements>
+        //   <right expression>
+        // end
+        const innerExpression = (0, expression_statement_1.wrapInStatement)(rightExpression);
+        const innerStatements = rightPrecedingStatements;
+        if (innerExpression)
+            innerStatements.push(innerExpression);
+        context.addPrecedingStatements(lua.createIfStatement(lua.createBinaryExpression(leftIdentifier, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock(innerStatements)));
+        return { expression: lua.createNilLiteral(), thisValue: returnThisValue };
+    }
+    else if (rightPrecedingStatements.length === 0 &&
+        !(0, typescript_1.canBeFalsyWhenNotNull)(context, context.checker.getTypeAtLocation(tsLeftExpression))) {
+        // return a && a.b
+        return {
+            expression: lua.createBinaryExpression(leftIdentifier, rightExpression, lua.SyntaxKind.AndOperator, tsNode),
+            thisValue: returnThisValue,
+        };
+    }
+    else {
+        let resultIdentifier;
+        if (!reuseLeftIdentifier) {
+            // reuse temp variable for output
+            resultIdentifier = leftIdentifier;
+        }
+        else {
+            resultIdentifier = lua.createIdentifier(context.createTempName("opt_result"), undefined, context_1.tempSymbolId);
+            context.addPrecedingStatements(lua.createVariableDeclarationStatement(resultIdentifier));
+        }
+        // if left ~= nil then
+        //   <right preceding statements>
+        //   result = <right expression>
+        // end
+        // return result
+        context.addPrecedingStatements(lua.createIfStatement(lua.createBinaryExpression(leftIdentifier, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock([
+            ...rightPrecedingStatements,
+            lua.createAssignmentStatement(resultIdentifier, rightExpression),
+        ])));
+        return { expression: resultIdentifier, thisValue: returnThisValue };
+    }
 }
@@ -173,0 +219,0 @@ exports.transformOptionalChainWithCapture = transformOptionalChainWithCapture;

dist/transformation/visitors/void.js

@@ -11,3 +11,3 @@ "use strict";
     if (!ts.isLiteralExpression(node.expression)) {
-        const statements = (0, expression_statement_1.transformExpressionToStatement)(context, node.expression);
+        const statements = (0, expression_statement_1.wrapInStatement)(context.transformExpression(node.expression));
         if (statements)
@@ -14,0 +14,0 @@ context.addPrecedingStatements(statements);

dist/transpilation/diagnostics.js

@@ -20,5 +20,5 @@ "use strict";
 }));
-exports.cannotBundleLibrary = createDiagnosticFactory(() => 'Cannot bundle probjects with"buildmode": "library". Projects including the library can still bundle (which will include external library files).');
+exports.cannotBundleLibrary = createDiagnosticFactory(() => 'Cannot bundle projects with "buildmode": "library". Projects including the library can still bundle (which will include external library files).');
 exports.unsupportedJsxEmit = createDiagnosticFactory(() => 'JSX is only supported with "react" jsx option.');
 exports.pathsWithoutBaseUrl = createDiagnosticFactory(() => "When configuring 'paths' in tsconfig.json, the option 'baseUrl' must also be provided.");
 //# sourceMappingURL=diagnostics.js.map

dist/transpilation/transpiler.d.ts

@@ -22,2 +22,3 @@ import * as ts from "typescript";
     };
+    private getLuaLibBundleContent;
 }
@@ -24,0 +25,0 @@ export declare function getEmitPath(file: string, program: ts.Program): string;

dist/transpilation/transpiler.js

@@ -64,3 +64,2 @@ "use strict";
     getEmitPlan(program, diagnostics, files) {
-        var _a;
         performance.startSection("getEmitPlan");
@@ -83,4 +82,4 @@ const options = program.getCompilerOptions();
             const fileName = (0, utils_1.normalizeSlashes)(path.resolve(getSourceDir(program), "lualib_bundle.lua"));
-            const luaTarget = (_a = options.luaTarget) !== null && _a !== void 0 ? _a : CompilerOptions_1.LuaTarget.Universal;
-            resolutionResult.resolvedFiles.unshift({ fileName, code: (0, LuaLib_1.getLuaLibBundle)(luaTarget, this.emitHost) });
+            const code = this.getLuaLibBundleContent(options, resolutionResult.resolvedFiles);
+            resolutionResult.resolvedFiles.unshift({ fileName, code });
         }
@@ -102,2 +101,13 @@ let emitPlan;
     }
+    getLuaLibBundleContent(options, resolvedFiles) {
+        var _a;
+        const luaTarget = (_a = options.luaTarget) !== null && _a !== void 0 ? _a : CompilerOptions_1.LuaTarget.Universal;
+        if (options.luaLibImport === CompilerOptions_1.LuaLibImportKind.RequireMinimal) {
+            const usedFeatures = (0, LuaLib_1.findUsedLualibFeatures)(luaTarget, this.emitHost, resolvedFiles.map(f => f.code));
+            return (0, LuaLib_1.buildMinimalLualibBundle)(usedFeatures, luaTarget, this.emitHost);
+        }
+        else {
+            return (0, LuaLib_1.getLuaLibBundle)(luaTarget, this.emitHost);
+        }
+    }
 }
@@ -104,0 +114,0 @@ exports.Transpiler = Transpiler;

package.json

 {
     "name": "typescript-to-lua",
-    "version": "1.12.0",
+    "version": "1.12.1",
     "description": "A generic TypeScript to Lua transpiler. Write your code in TypeScript and publish Lua!",
@@ -5,0 +5,0 @@ "repository": "https://github.com/TypeScriptToLua/TypeScriptToLua",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1034244

increased by0.68%

Lines of code

14739

increased by1.24%

No dependency changes