typescript-to-lua 1.2.0 → 1.3.3

package/dist/transformation/builtins/index.js

@@ -28,7 +28,7 @@ function transformBuiltinPropertyAccessExpression(context, node) {
     if ((0, typescript_1.isArrayType)(context, ownerType)) {
         return (0, array_1.transformArrayProperty)(context, node);
     }
-    if ((0, typescript_1.isFunctionType)(context, ownerType)) {
+    if ((0, typescript_1.isFunctionType)(ownerType)) {
         return (0, function_1.transformFunctionProperty)(context, node);
     }
     if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
@@ -42,12 +42,18 @@ function transformBuiltinPropertyAccessExpression(context, node) {
 }
 exports.transformBuiltinPropertyAccessExpression = transformBuiltinPropertyAccessExpression;
 function transformBuiltinCallExpression(context, node, isOptionalCall) {
+    const unsupportedOptionalCall = () => {
+        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+        return lua.createNilLiteral();
+    };
     const expressionType = context.checker.getTypeAtLocation(node.expression);
     if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, expressionType, undefined)) {
         // TODO:
         (0, new_1.checkForLuaLibType)(context, expressionType);
         const result = (0, global_1.transformGlobalCall)(context, node);
         if (result) {
+            if (isOptionalCall)
+                return unsupportedOptionalCall();
             return result;
         }
     }
@@ -55,12 +61,8 @@ function transformBuiltinCallExpression(context, node, isOptionalCall) {
     if (!ts.isPropertyAccessExpression(expression)) {
         return;
     }
-    (0, utils_1.assume)(node);
     const isOptionalAccess = expression.questionDotToken;
-    const unsupportedOptionalCall = () => {
-        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-        return lua.createNilLiteral();
-    };
+    (0, utils_1.assume)(node);
     // If the function being called is of type owner.func, get the type of owner
     const ownerType = context.checker.getTypeAtLocation(expression.expression);
     if ((0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
@@ -115,7 +117,7 @@ function transformBuiltinCallExpression(context, node, isOptionalCall) {
             return unsupportedOptionalCall();
         return (0, array_1.transformArrayPrototypeCall)(context, node);
     }
-    if ((0, typescript_1.isFunctionType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+    if ((0, typescript_1.isFunctionType)(ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
         if (isOptionalCall)
             return unsupportedOptionalCall();
         return (0, function_1.transformFunctionPrototypeCall)(context, node);

package/dist/transformation/builtins/math.js

@@ -57,6 +57,10 @@ function transformMathCall(context, node) {
             const add = lua.createBinaryExpression(one, params[0], lua.SyntaxKind.AdditionOperator);
             return lua.createCallExpression(lua.createTableIndexExpression(math, log), [add], node);
         }
+        case "pow": {
+            // Translate to base ^ power
+            return lua.createBinaryExpression(params[0], params[1], lua.SyntaxKind.PowerOperator, node);
+        }
         // math.floor(x + 0.5)
         case "round": {
             const floor = lua.createStringLiteral("floor");
@@ -64,6 +68,9 @@ function transformMathCall(context, node) {
             const add = lua.createBinaryExpression(params[0], half, lua.SyntaxKind.AdditionOperator);
             return lua.createCallExpression(lua.createTableIndexExpression(math, floor), [add], node);
         }
+        case "sign": {
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.MathSign, node, ...params);
+        }
         case "abs":
         case "acos":
         case "asin":
@@ -75,7 +82,6 @@ function transformMathCall(context, node) {
         case "log":
         case "max":
         case "min":
-        case "pow":
         case "random":
         case "sin":
         case "sqrt":

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

@@ -34,6 +34,9 @@ export declare const invalidRangeControlVariable: ((node: ts.Node, ...args: any[
 export declare const invalidMultiIterableWithoutDestructuring: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
+export declare const invalidPairsIterableWithoutDestructuring: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+    code: number;
+};
 export declare const unsupportedAccessorInObjectLiteral: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
@@ -73,12 +76,6 @@ export declare const invalidOperatorMappingUse: ((node: ts.Node, ...args: any[])
 export declare const invalidTableExtensionUse: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
-export declare const invalidTableDeleteExpression: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
-    code: number;
-};
-export declare const invalidTableSetExpression: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
-    code: number;
-};
 export declare const annotationRemoved: ((node: ts.Node, kind: AnnotationKind) => ts.Diagnostic) & {
     code: number;
 };

package/dist/transformation/utils/diagnostics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unsupportedOptionalCompileMembersOnly = exports.unsupportedBuiltinOptionalCall = exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidTableSetExpression = exports.invalidTableDeleteExpression = exports.invalidTableExtensionUse = exports.invalidOperatorMappingUse = exports.invalidMultiReturnAccess = exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = exports.invalidMultiTypeToNonArrayLiteral = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
+exports.unsupportedOptionalCompileMembersOnly = exports.unsupportedBuiltinOptionalCall = exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidTableExtensionUse = exports.invalidOperatorMappingUse = exports.invalidMultiReturnAccess = exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = exports.invalidMultiTypeToNonArrayLiteral = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.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");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const utils_1 = require("../../utils");
@@ -36,6 +36,7 @@ exports.invalidRangeUse = createErrorDiagnosticFactory("$range can only be used
 exports.invalidVarargUse = createErrorDiagnosticFactory("$vararg can only be used in a spread element ('...$vararg') in global scope.");
 exports.invalidRangeControlVariable = createErrorDiagnosticFactory("For loop using $range must declare a single control variable.");
 exports.invalidMultiIterableWithoutDestructuring = createErrorDiagnosticFactory("LuaIterable with a LuaMultiReturn return value type must be destructured.");
+exports.invalidPairsIterableWithoutDestructuring = createErrorDiagnosticFactory("LuaPairsIterable type must be destructured in a for...of statement.");
 exports.unsupportedAccessorInObjectLiteral = createErrorDiagnosticFactory("Accessors in object literal are not supported.");
 exports.unsupportedRightShiftOperator = createErrorDiagnosticFactory("Right shift operator is not supported for target Lua 5.3. Use `>>>` instead.");
 const getLuaTargetName = (version) => (version === CompilerOptions_1.LuaTarget.LuaJIT ? "LuaJIT" : `Lua ${version}`);
@@ -50,8 +51,6 @@ exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = createErrorDiagnosticFact
 exports.invalidMultiReturnAccess = createErrorDiagnosticFactory("The LuaMultiReturn type can only be accessed via an element access expression of a numeric type.");
 exports.invalidOperatorMappingUse = createErrorDiagnosticFactory("This function must always be directly called and cannot be referred to.");
 exports.invalidTableExtensionUse = createErrorDiagnosticFactory("This function must be called directly and cannot be referred to.");
-exports.invalidTableDeleteExpression = createErrorDiagnosticFactory("Table delete extension can only be called as a stand-alone statement. It cannot be used as an expression in another statement.");
-exports.invalidTableSetExpression = createErrorDiagnosticFactory("Table set extension can only be called as a stand-alone statement. It cannot be used as an expression in another statement.");
 exports.annotationRemoved = createErrorDiagnosticFactory((kind) => `'@${kind}' has been removed and will no longer have any effect.` +
     `See https://typescripttolua.github.io/docs/advanced/compiler-annotations#${kind.toLowerCase()} for more information.`);
 exports.annotationDeprecated = createWarningDiagnosticFactory((kind) => `'@${kind}' is deprecated and will be removed in a future update. Please update your code before upgrading to the next release, otherwise your project will no longer compile. ` +

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

@@ -6,6 +6,7 @@ export declare enum ExtensionKind {
     RangeFunction = "RangeFunction",
     VarargConstant = "VarargConstant",
     IterableType = "IterableType",
+    PairsIterableType = "PairsIterableType",
     AdditionOperatorType = "AdditionOperatorType",
     AdditionOperatorMethodType = "AdditionOperatorMethodType",
     SubtractionOperatorType = "SubtractionOperatorType",
@@ -53,4 +54,5 @@ export declare enum ExtensionKind {
     TableSetMethodType = "TableSetMethodType"
 }
 export declare function isExtensionType(type: ts.Type, extensionKind: ExtensionKind): boolean;
+export declare function getExtensionKinds(type: ts.Type): ExtensionKind[];
 export declare function isExtensionValue(context: TransformationContext, symbol: ts.Symbol, extensionKind: ExtensionKind): boolean;

package/dist/transformation/utils/language-extensions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExtensionValue = exports.isExtensionType = exports.ExtensionKind = void 0;
+exports.isExtensionValue = exports.getExtensionKinds = exports.isExtensionType = exports.ExtensionKind = void 0;
 var ExtensionKind;
 (function (ExtensionKind) {
     ExtensionKind["MultiFunction"] = "MultiFunction";
@@ -8,6 +8,7 @@ var ExtensionKind;
     ExtensionKind["RangeFunction"] = "RangeFunction";
     ExtensionKind["VarargConstant"] = "VarargConstant";
     ExtensionKind["IterableType"] = "IterableType";
+    ExtensionKind["PairsIterableType"] = "PairsIterableType";
     ExtensionKind["AdditionOperatorType"] = "AdditionOperatorType";
     ExtensionKind["AdditionOperatorMethodType"] = "AdditionOperatorMethodType";
     ExtensionKind["SubtractionOperatorType"] = "SubtractionOperatorType";
@@ -65,6 +66,7 @@ const extensionKindToTypeBrand = {
     [ExtensionKind.RangeFunction]: "__luaRangeFunctionBrand",
     [ExtensionKind.VarargConstant]: "__luaVarargConstantBrand",
     [ExtensionKind.IterableType]: "__luaIterableBrand",
+    [ExtensionKind.PairsIterableType]: "__luaPairsIterableBrand",
     [ExtensionKind.AdditionOperatorType]: "__luaAdditionBrand",
     [ExtensionKind.AdditionOperatorMethodType]: "__luaAdditionMethodBrand",
     [ExtensionKind.SubtractionOperatorType]: "__luaSubtractionBrand",
@@ -116,6 +118,10 @@ function isExtensionType(type, extensionKind) {
     return typeBrand !== undefined && type.getProperty(typeBrand) !== undefined;
 }
 exports.isExtensionType = isExtensionType;
+function getExtensionKinds(type) {
+    return Object.keys(extensionKindToTypeBrand).filter(e => type.getProperty(extensionKindToTypeBrand[e]) !== undefined);
+}
+exports.getExtensionKinds = getExtensionKinds;
 function isExtensionValue(context, symbol, extensionKind) {
     var _a;
     return (symbol.getName() === extensionKindToValueName[extensionKind] &&

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

@@ -119,7 +119,9 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
         const scope = (0, scope_1.peekScope)(context);
         const isTopLevelVariable = scope.type === scope_1.ScopeType.File;
         if (context.isModule || !isTopLevelVariable) {
-            if (!isFunctionDeclaration && hasMultipleReferences(scope, lhs)) {
+            const isLuaFunctionExpression = rhs && !Array.isArray(rhs) && lua.isFunctionExpression(rhs);
+            const isSafeRecursiveFunctionDeclaration = isFunctionDeclaration && isLuaFunctionExpression;
+            if (!isSafeRecursiveFunctionDeclaration && hasMultipleReferences(scope, lhs)) {
                 // Split declaration and assignment of identifiers that reference themselves in their declaration.
                 // Put declaration above preceding statements in case the identifier is referenced in those.
                 const precedingDeclaration = lua.createVariableDeclarationStatement(lhs, undefined, tsOriginal);
@@ -127,10 +129,8 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
                 if (rhs) {
                     assignment = lua.createAssignmentStatement(lhs, rhs, tsOriginal);
                 }
-                if (!isFunctionDeclaration) {
-                    // Remember local variable declarations for hoisting later
-                    (0, scope_1.addScopeVariableDeclaration)(scope, precedingDeclaration);
-                }
+                // Remember local variable declarations for hoisting later
+                (0, scope_1.addScopeVariableDeclaration)(scope, precedingDeclaration);
             }
             else {
                 declaration = lua.createVariableDeclarationStatement(lhs, rhs, tsOriginal);

package/dist/transformation/utils/safe-names.d.ts

@@ -1,8 +1,10 @@
 import * as ts from "typescript";
+import { CompilerOptions } from "../..";
 import { TransformationContext } from "../context";
-export declare const isValidLuaIdentifier: (name: string) => boolean;
+export declare const shouldAllowUnicode: (options: CompilerOptions) => boolean;
+export declare const isValidLuaIdentifier: (name: string, options: CompilerOptions) => boolean;
 export declare const luaKeywords: ReadonlySet<string>;
-export declare const isUnsafeName: (name: string) => boolean;
+export declare const isUnsafeName: (name: string, options: CompilerOptions) => boolean;
 export declare function hasUnsafeSymbolName(context: TransformationContext, symbol: ts.Symbol, tsOriginal: ts.Identifier): boolean;
 export declare function hasUnsafeIdentifierName(context: TransformationContext, identifier: ts.Identifier, checkSymbol?: boolean): boolean;
 export declare const createSafeName: (name: string) => string;

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

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSafeName = exports.hasUnsafeIdentifierName = exports.hasUnsafeSymbolName = exports.isUnsafeName = exports.luaKeywords = exports.isValidLuaIdentifier = void 0;
+exports.createSafeName = exports.hasUnsafeIdentifierName = exports.hasUnsafeSymbolName = exports.isUnsafeName = exports.luaKeywords = exports.isValidLuaIdentifier = exports.shouldAllowUnicode = void 0;
+const __1 = require("../..");
 const diagnostics_1 = require("./diagnostics");
 const export_1 = require("./export");
 const typescript_1 = require("./typescript");
-const isValidLuaIdentifier = (name) => !exports.luaKeywords.has(name) && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name);
+const shouldAllowUnicode = (options) => options.luaTarget === __1.LuaTarget.LuaJIT;
+exports.shouldAllowUnicode = shouldAllowUnicode;
+const isValidLuaIdentifier = (name, options) => !exports.luaKeywords.has(name) &&
+    ((0, exports.shouldAllowUnicode)(options)
+        ? /^[a-zA-Z_\u007F-\uFFFD][a-zA-Z0-9_\u007F-\uFFFD]*$/
+        : /^[a-zA-Z_][a-zA-Z0-9_]*$/).test(name);
 exports.isValidLuaIdentifier = isValidLuaIdentifier;
 exports.luaKeywords = new Set([
     "and",
@@ -51,10 +57,10 @@ const luaBuiltins = new Set([
     "type",
     "unpack",
 ]);
-const isUnsafeName = (name) => !(0, exports.isValidLuaIdentifier)(name) || luaBuiltins.has(name);
+const isUnsafeName = (name, options) => !(0, exports.isValidLuaIdentifier)(name, options) || luaBuiltins.has(name);
 exports.isUnsafeName = isUnsafeName;
 function checkName(context, name, node) {
-    const isInvalid = !(0, exports.isValidLuaIdentifier)(name);
+    const isInvalid = !(0, exports.isValidLuaIdentifier)(name, context.options);
     if (isInvalid) {
         // Empty identifier is a TypeScript error
         if (name !== "") {
@@ -71,7 +77,7 @@ function hasUnsafeSymbolName(context, symbol, tsOriginal) {
         return true;
     }
     // only unsafe when non-ambient and not exported
-    return (0, exports.isUnsafeName)(symbol.name) && !isAmbient && !(0, export_1.isSymbolExported)(context, symbol);
+    return (0, exports.isUnsafeName)(symbol.name, context.options) && !isAmbient && !(0, export_1.isSymbolExported)(context, symbol);
 }
 exports.hasUnsafeSymbolName = hasUnsafeSymbolName;
 function hasUnsafeIdentifierName(context, identifier, checkSymbol = true) {

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

@@ -9,7 +9,8 @@ export declare enum ScopeType {
     Conditional = 16,
     Block = 32,
     Try = 64,
-    Catch = 128
+    Catch = 128,
+    LoopInitializer = 256
 }
 interface FunctionDefinitionInfo {
     referencedSymbols: Map<lua.SymbolId, ts.Node[]>;

package/dist/transformation/utils/scope.js

@@ -16,6 +16,7 @@ var ScopeType;
     ScopeType[ScopeType["Block"] = 32] = "Block";
     ScopeType[ScopeType["Try"] = 64] = "Try";
     ScopeType[ScopeType["Catch"] = 128] = "Catch";
+    ScopeType[ScopeType["LoopInitializer"] = 256] = "LoopInitializer";
 })(ScopeType = exports.ScopeType || (exports.ScopeType = {}));
 const scopeStacks = new WeakMap();
 function getScopeStack(context) {

package/dist/transformation/utils/typescript/types.d.ts

@@ -10,4 +10,6 @@ export declare function isNumberType(context: TransformationContext, type: ts.Ty
  */
 export declare function forTypeOrAnySupertype(context: TransformationContext, type: ts.Type, predicate: (type: ts.Type) => boolean): boolean;
 export declare function isArrayType(context: TransformationContext, type: ts.Type): boolean;
-export declare function isFunctionType(context: TransformationContext, type: ts.Type): boolean;
+export declare function isFunctionType(type: ts.Type): boolean;
+export declare function canBeFalsy(context: TransformationContext, type: ts.Type): boolean;
+export declare function canBeFalsyWhenNotNull(context: TransformationContext, type: ts.Type): boolean;

package/dist/transformation/utils/typescript/types.js

@@ -1,21 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNumberType = exports.isStringType = exports.typeCanSatisfy = exports.typeAlwaysSatisfies = exports.isTypeWithFlags = void 0;
+exports.canBeFalsyWhenNotNull = exports.canBeFalsy = exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNumberType = exports.isStringType = exports.typeCanSatisfy = exports.typeAlwaysSatisfies = exports.isTypeWithFlags = void 0;
 const ts = require("typescript");
 function isTypeWithFlags(context, type, flags) {
-    const predicate = (type) => {
-        if (type.symbol) {
-            const baseConstraint = context.checker.getBaseConstraintOfType(type);
-            if (baseConstraint && baseConstraint !== type) {
-                return isTypeWithFlags(context, baseConstraint, flags);
-            }
-        }
-        return (type.flags & flags) !== 0;
-    };
+    const predicate = (type) => (type.flags & flags) !== 0;
     return typeAlwaysSatisfies(context, type, predicate);
 }
 exports.isTypeWithFlags = isTypeWithFlags;
 function typeAlwaysSatisfies(context, type, predicate) {
+    const baseConstraint = context.checker.getBaseConstraintOfType(type);
+    if (baseConstraint) {
+        type = baseConstraint;
+    }
     if (predicate(type)) {
         return true;
     }
@@ -29,6 +25,15 @@ function typeAlwaysSatisfies(context, type, predicate) {
 }
 exports.typeAlwaysSatisfies = typeAlwaysSatisfies;
 function typeCanSatisfy(context, type, predicate) {
+    const baseConstraint = context.checker.getBaseConstraintOfType(type);
+    if (!baseConstraint) {
+        // type parameter with no constraint can be anything, assume it might satisfy predicate
+        if (type.isTypeParameter())
+            return true;
+    }
+    else {
+        type = baseConstraint;
+    }
     if (predicate(type)) {
         return true;
     }
@@ -84,9 +89,31 @@ function isArrayType(context, type) {
     return forTypeOrAnySupertype(context, type, t => isExplicitArrayType(context, t));
 }
 exports.isArrayType = isArrayType;
-function isFunctionType(context, type) {
-    const typeNode = context.checker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.InTypeAlias);
-    return typeNode !== undefined && ts.isFunctionTypeNode(typeNode);
+function isFunctionType(type) {
+    return type.getCallSignatures().length > 0;
 }
 exports.isFunctionType = isFunctionType;
+function canBeFalsy(context, type) {
+    const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
+    const falsyFlags = ts.TypeFlags.Boolean |
+        ts.TypeFlags.BooleanLiteral |
+        ts.TypeFlags.Never |
+        ts.TypeFlags.Void |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.Any |
+        ts.TypeFlags.Undefined |
+        ts.TypeFlags.Null;
+    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0 || (!strictNullChecks && !type.isLiteral()));
+}
+exports.canBeFalsy = canBeFalsy;
+function canBeFalsyWhenNotNull(context, type) {
+    const falsyFlags = ts.TypeFlags.Boolean |
+        ts.TypeFlags.BooleanLiteral |
+        ts.TypeFlags.Never |
+        ts.TypeFlags.Void |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.Any;
+    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0);
+}
+exports.canBeFalsyWhenNotNull = canBeFalsyWhenNotNull;
 //# sourceMappingURL=types.js.map

package/dist/transformation/visitors/binary-expression/index.js

@@ -167,9 +167,7 @@ exports.transformBinaryExpressionStatement = transformBinaryExpressionStatement;
 function transformNullishCoalescingOperationNoPrecedingStatements(context, node, transformedLeft, transformedRight) {
     const lhsType = context.checker.getTypeAtLocation(node.left);
     // Check if we can take a shortcut to 'lhs or rhs' if the left-hand side cannot be 'false'.
-    const typeCanBeFalse = (type) => (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Boolean)) !== 0 ||
-        (type.flags & ts.TypeFlags.BooleanLiteral & ts.TypeFlags.PossiblyFalsy) !== 0;
-    if ((0, typescript_1.typeCanSatisfy)(context, lhsType, typeCanBeFalse)) {
+    if ((0, typescript_1.canBeFalsyWhenNotNull)(context, lhsType)) {
         // reuse logic from case with preceding statements
         const [precedingStatements, result] = createShortCircuitBinaryExpressionPrecedingStatements(context, transformedLeft, transformedRight, [], ts.SyntaxKind.QuestionQuestionToken, node);
         context.addPrecedingStatements(precedingStatements);

package/dist/transformation/visitors/call.js

@@ -12,12 +12,11 @@ const safe_names_1 = require("../utils/safe-names");
 const typescript_1 = require("../utils/typescript");
 const access_1 = require("./access");
 const multi_1 = require("./language-extensions/multi");
-const operators_1 = require("./language-extensions/operators");
-const table_1 = require("./language-extensions/table");
 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");
 function validateArguments(context, params, signature) {
     if (!signature || signature.parameters.length < params.length) {
         return;
@@ -86,7 +85,7 @@ function transformContextualCallExpression(context, node, args, signature) {
     let [argPrecedingStatements, transformedArguments] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, args, signature));
     if (ts.isPropertyAccessExpression(left) &&
         ts.isIdentifier(left.name) &&
-        (0, safe_names_1.isValidLuaIdentifier)(left.name.text) &&
+        (0, safe_names_1.isValidLuaIdentifier)(left.name.text, context.options) &&
         argPrecedingStatements.length === 0) {
         // table:name()
         const table = context.transformExpression(left.expression);
@@ -145,6 +144,7 @@ function transformElementCall(context, node) {
     }
 }
 const transformCallExpression = (node, context) => {
+    var _a;
     if (ts.isOptionalChain(node)) {
         return (0, optional_chaining_1.transformOptionalChain)(context, node);
     }
@@ -152,46 +152,13 @@ const transformCallExpression = (node, context) => {
         ? (0, optional_chaining_1.getOptionalContinuationData)(node.expression)
         : undefined;
     const wrapResultInTable = (0, multi_1.isMultiReturnCall)(context, node) && (0, multi_1.shouldMultiReturnCallBeWrapped)(context, node);
-    const builtinResult = (0, builtins_1.transformBuiltinCallExpression)(context, node, optionalContinuation !== undefined);
-    if (builtinResult) {
-        if (optionalContinuation) {
-            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-        }
-        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinResult) : builtinResult;
-    }
     if ((0, annotations_1.isTupleReturnCall)(context, node)) {
         context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
     }
-    if ((0, operators_1.isOperatorMapping)(context, node)) {
-        if (optionalContinuation) {
-            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-            return lua.createNilLiteral();
-        }
-        return (0, operators_1.transformOperatorMappingExpression)(context, node);
-    }
-    if ((0, table_1.isTableDeleteCall)(context, node)) {
-        context.diagnostics.push((0, diagnostics_1.invalidTableDeleteExpression)(node));
-        context.addPrecedingStatements((0, table_1.transformTableDeleteExpression)(context, node));
-        return lua.createNilLiteral();
-    }
-    if ((0, table_1.isTableGetCall)(context, node)) {
-        if (optionalContinuation) {
-            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-            return lua.createNilLiteral();
-        }
-        return (0, table_1.transformTableGetExpression)(context, node);
-    }
-    if ((0, table_1.isTableHasCall)(context, node)) {
-        if (optionalContinuation) {
-            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-            return lua.createNilLiteral();
-        }
-        return (0, table_1.transformTableHasExpression)(context, node);
-    }
-    if ((0, table_1.isTableSetCall)(context, node)) {
-        context.diagnostics.push((0, diagnostics_1.invalidTableSetExpression)(node));
-        context.addPrecedingStatements((0, table_1.transformTableSetExpression)(context, node));
-        return lua.createNilLiteral();
+    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);
+    if (builtinOrExtensionResult) {
+        // unsupportedOptionalCall diagnostic already present
+        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinOrExtensionResult) : builtinOrExtensionResult;
     }
     if (ts.isPropertyAccessExpression(node.expression)) {
         const ownerType = context.checker.getTypeAtLocation(node.expression.expression);

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

@@ -70,7 +70,7 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
     const instanceFields = properties.filter(prop => !(0, utils_2.isStaticNode)(prop));
     const result = [];
     let localClassName;
-    if ((0, safe_names_1.isUnsafeName)(className.text)) {
+    if ((0, safe_names_1.isUnsafeName)(className.text, context.options)) {
         localClassName = lua.createIdentifier((0, safe_names_1.createSafeName)(className.text), undefined, className.symbolId, className.text);
         lua.setNodePosition(localClassName, className);
     }

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformStaticPropertyDeclaration = exports.transformClassInstanceFields = exports.createPropertyDecoratingExpression = void 0;
 const lua = require("../../../../LuaAST");
 const lua_ast_1 = require("../../../utils/lua-ast");
+const preceding_statements_1 = require("../../../utils/preceding-statements");
 const literal_1 = require("../../literal");
 const decorators_1 = require("../decorators");
 const method_1 = require("./method");
@@ -17,14 +18,17 @@ exports.createPropertyDecoratingExpression = createPropertyDecoratingExpression;
 function transformClassInstanceFields(context, instanceFields) {
     const statements = [];
     for (const f of instanceFields) {
-        // Get identifier
-        const fieldName = (0, literal_1.transformPropertyName)(context, f.name);
-        const value = f.initializer ? context.transformExpression(f.initializer) : undefined;
-        // self[fieldName]
-        const selfIndex = lua.createTableIndexExpression((0, lua_ast_1.createSelfIdentifier)(), fieldName);
-        // self[fieldName] = value
-        const assignClassField = lua.createAssignmentStatement(selfIndex, value, f);
-        statements.push(assignClassField);
+        const [precedingStatements, statement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+            // Get identifier
+            const fieldName = (0, literal_1.transformPropertyName)(context, f.name);
+            const value = f.initializer ? context.transformExpression(f.initializer) : undefined;
+            // self[fieldName]
+            const selfIndex = lua.createTableIndexExpression((0, lua_ast_1.createSelfIdentifier)(), fieldName);
+            // self[fieldName] = value
+            const assignClassField = lua.createAssignmentStatement(selfIndex, value, f);
+            return assignClassField;
+        });
+        statements.push(...precedingStatements, statement);
     }
     return statements;
 }

package/dist/transformation/visitors/conditional.js

@@ -6,28 +6,7 @@ const lua = require("../../LuaAST");
 const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
 const block_1 = require("./block");
-function canBeFalsy(context, type) {
-    const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
-    const falsyFlags = ts.TypeFlags.Boolean |
-        ts.TypeFlags.BooleanLiteral |
-        ts.TypeFlags.Undefined |
-        ts.TypeFlags.Null |
-        ts.TypeFlags.Never |
-        ts.TypeFlags.Void |
-        ts.TypeFlags.Any;
-    if (type.flags & falsyFlags) {
-        return true;
-    }
-    else if (!strictNullChecks && !type.isLiteral()) {
-        return true;
-    }
-    else if (type.isUnion()) {
-        return type.types.some(subType => canBeFalsy(context, subType));
-    }
-    else {
-        return false;
-    }
-}
+const typescript_1 = require("../utils/typescript");
 function transformProtectedConditionalExpression(context, expression) {
     const tempVar = context.createTempNameForNode(expression.condition);
     const condition = context.transformExpression(expression.condition);
@@ -42,7 +21,7 @@ function transformProtectedConditionalExpression(context, expression) {
     return lua.cloneIdentifier(tempVar);
 }
 const transformConditionalExpression = (expression, context) => {
-    if (canBeFalsy(context, context.checker.getTypeAtLocation(expression.whenTrue))) {
+    if ((0, typescript_1.canBeFalsy)(context, context.checker.getTypeAtLocation(expression.whenTrue))) {
         return transformProtectedConditionalExpression(context, expression);
     }
     const condition = context.transformExpression(expression.condition);

package/dist/transformation/visitors/errors.js

@@ -12,6 +12,7 @@ const identifier_1 = require("./identifier");
 const multi_1 = require("./language-extensions/multi");
 const return_1 = require("./return");
 const transformTryStatement = (statement, context) => {
+    var _a;
     const [tryBlock, tryScope] = (0, block_1.transformScopeBlock)(context, statement.tryBlock, scope_1.ScopeType.Try);
     if (context.options.luaTarget === __1.LuaTarget.Lua51 && (0, typescript_1.isInAsyncFunction)(statement)) {
         context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(statement, "try/catch inside async functions", __1.LuaTarget.Lua51));
@@ -34,24 +35,25 @@ const transformTryStatement = (statement, context) => {
         const catchParameter = statement.catchClause.variableDeclaration
             ? (0, identifier_1.transformIdentifier)(context, statement.catchClause.variableDeclaration.name)
             : undefined;
-        const catchParameters = () => (catchParameter ? [lua.cloneIdentifier(catchParameter)] : []);
+        const catchFunction = lua.createFunctionExpression(catchBlock, catchParameter ? [lua.cloneIdentifier(catchParameter)] : []);
         const catchIdentifier = lua.createIdentifier("____catch");
-        const catchFunction = lua.createFunctionExpression(catchBlock, catchParameters());
         result.push(lua.createVariableDeclarationStatement(catchIdentifier, catchFunction));
+        const hasReturn = (_a = tryScope.functionReturned) !== null && _a !== void 0 ? _a : catchScope.functionReturned;
         const tryReturnIdentifiers = [tryResultIdentifier]; // ____try
-        if (returnedIdentifier) {
-            tryReturnIdentifiers.push(returnedIdentifier); // ____returned or catch variable
-            if (tryScope.functionReturned || catchScope.functionReturned) {
+        if (hasReturn || statement.catchClause.variableDeclaration) {
+            tryReturnIdentifiers.push(returnedIdentifier); // ____returned
+            if (hasReturn) {
                 tryReturnIdentifiers.push(returnValueIdentifier); // ____returnValue
                 returnCondition = lua.cloneIdentifier(returnedIdentifier);
             }
         }
         result.push(lua.createVariableDeclarationStatement(tryReturnIdentifiers, tryCall));
-        // Wrap catch in function if try or catch has return
-        const catchCall = lua.createCallExpression(catchIdentifier, [lua.cloneIdentifier(returnedIdentifier)]);
-        const catchAssign = lua.createAssignmentStatement([lua.cloneIdentifier(returnedIdentifier), lua.cloneIdentifier(returnValueIdentifier)], catchCall);
+        const catchCall = lua.createCallExpression(catchIdentifier, statement.catchClause.variableDeclaration ? [lua.cloneIdentifier(returnedIdentifier)] : []);
+        const catchCallStatement = hasReturn
+            ? lua.createAssignmentStatement([lua.cloneIdentifier(returnedIdentifier), lua.cloneIdentifier(returnValueIdentifier)], catchCall)
+            : lua.createExpressionStatement(catchCall);
         const notTryCondition = lua.createUnaryExpression(tryResultIdentifier, lua.SyntaxKind.NotOperator);
-        result.push(lua.createIfStatement(notTryCondition, lua.createBlock([catchAssign])));
+        result.push(lua.createIfStatement(notTryCondition, lua.createBlock([catchCallStatement])));
     }
     else if (tryScope.functionReturned) {
         // try with return, but no catch

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

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