typescript-to-lua 1.28.1 → 1.29.0

package/dist/CompilerOptions.d.ts

@@ -49,7 +49,8 @@ export declare enum LuaTarget {
     Lua52 = "5.2",
     Lua53 = "5.3",
     Lua54 = "5.4",
-    LuaJIT = "JIT"
+    LuaJIT = "JIT",
+    Luau = "Luau"
 }
 export declare enum BuildMode {
     Default = "default",

package/dist/CompilerOptions.js

@@ -20,6 +20,7 @@ var LuaTarget;
     LuaTarget["Lua53"] = "5.3";
     LuaTarget["Lua54"] = "5.4";
     LuaTarget["LuaJIT"] = "JIT";
+    LuaTarget["Luau"] = "Luau";
 })(LuaTarget || (exports.LuaTarget = LuaTarget = {}));
 var BuildMode;
 (function (BuildMode) {

package/dist/LuaAST.d.ts

@@ -15,49 +15,51 @@ export declare enum SyntaxKind {
     LabelStatement = 11,
     ReturnStatement = 12,
     BreakStatement = 13,
-    ExpressionStatement = 14,
-    StringLiteral = 15,
-    NumericLiteral = 16,
-    NilKeyword = 17,
-    DotsKeyword = 18,
-    ArgKeyword = 19,
-    TrueKeyword = 20,
-    FalseKeyword = 21,
-    FunctionExpression = 22,
-    TableFieldExpression = 23,
-    TableExpression = 24,
-    UnaryExpression = 25,
-    BinaryExpression = 26,
-    CallExpression = 27,
-    MethodCallExpression = 28,
-    Identifier = 29,
-    TableIndexExpression = 30,
-    ParenthesizedExpression = 31,
-    AdditionOperator = 32,// Maybe use abbreviations for those add, sub, mul ...
-    SubtractionOperator = 33,
-    MultiplicationOperator = 34,
-    DivisionOperator = 35,
-    FloorDivisionOperator = 36,
-    ModuloOperator = 37,
-    PowerOperator = 38,
-    NegationOperator = 39,// Unary minus
-    ConcatOperator = 40,
-    LengthOperator = 41,// Unary
-    EqualityOperator = 42,
-    InequalityOperator = 43,
-    LessThanOperator = 44,
-    LessEqualOperator = 45,
-    GreaterThanOperator = 46,
-    GreaterEqualOperator = 47,// Syntax Sugar `x >= y` <=> `not (y < x)`
-    AndOperator = 48,
-    OrOperator = 49,
-    NotOperator = 50,// Unary
-    BitwiseAndOperator = 51,
-    BitwiseOrOperator = 52,
-    BitwiseExclusiveOrOperator = 53,
-    BitwiseRightShiftOperator = 54,
-    BitwiseLeftShiftOperator = 55,
-    BitwiseNotOperator = 56
+    ContinueStatement = 14,// Luau only.
+    ExpressionStatement = 15,
+    StringLiteral = 16,
+    NumericLiteral = 17,
+    NilKeyword = 18,
+    DotsKeyword = 19,
+    ArgKeyword = 20,
+    TrueKeyword = 21,
+    FalseKeyword = 22,
+    FunctionExpression = 23,
+    TableFieldExpression = 24,
+    TableExpression = 25,
+    UnaryExpression = 26,
+    BinaryExpression = 27,
+    CallExpression = 28,
+    MethodCallExpression = 29,
+    Identifier = 30,
+    TableIndexExpression = 31,
+    ParenthesizedExpression = 32,
+    ConditionalExpression = 33,// Luau only
+    AdditionOperator = 34,// Maybe use abbreviations for those add, sub, mul ...
+    SubtractionOperator = 35,
+    MultiplicationOperator = 36,
+    DivisionOperator = 37,
+    FloorDivisionOperator = 38,
+    ModuloOperator = 39,
+    PowerOperator = 40,
+    NegationOperator = 41,// Unary minus
+    ConcatOperator = 42,
+    LengthOperator = 43,// Unary
+    EqualityOperator = 44,
+    InequalityOperator = 45,
+    LessThanOperator = 46,
+    LessEqualOperator = 47,
+    GreaterThanOperator = 48,
+    GreaterEqualOperator = 49,// Syntax Sugar `x >= y` <=> `not (y < x)`
+    AndOperator = 50,
+    OrOperator = 51,
+    NotOperator = 52,// Unary
+    BitwiseAndOperator = 53,
+    BitwiseOrOperator = 54,
+    BitwiseExclusiveOrOperator = 55,
+    BitwiseRightShiftOperator = 56,
+    BitwiseLeftShiftOperator = 57,
+    BitwiseNotOperator = 58
 }
 export type UnaryBitwiseOperator = SyntaxKind.BitwiseNotOperator;
 export type UnaryOperator = SyntaxKind.NegationOperator | SyntaxKind.LengthOperator | SyntaxKind.NotOperator | UnaryBitwiseOperator;
@@ -190,6 +192,11 @@ export interface BreakStatement extends Statement {
 }
 export declare function isBreakStatement(node: Node): node is BreakStatement;
 export declare function createBreakStatement(tsOriginal?: ts.Node): BreakStatement;
+export interface ContinueStatement extends Statement {
+    kind: SyntaxKind.ContinueStatement;
+}
+export declare function isContinueStatement(node: Node): node is ContinueStatement;
+export declare function createContinueStatement(tsOriginal?: ts.Node): ContinueStatement;
 export interface ExpressionStatement extends Statement {
     kind: SyntaxKind.ExpressionStatement;
     expression: Expression;
@@ -320,3 +327,10 @@ export type ParenthesizedExpression = Expression & {
 };
 export declare function isParenthesizedExpression(node: Node): node is ParenthesizedExpression;
 export declare function createParenthesizedExpression(expression: Expression, tsOriginal?: ts.Node): ParenthesizedExpression;
+export type ConditionalExpression = Expression & {
+    condition: Expression;
+    whenTrue: Expression;
+    whenFalse: Expression;
+};
+export declare function isConditionalExpression(node: Node): node is ConditionalExpression;
+export declare function createConditionalExpression(condition: Expression, whenTrue: Expression, whenFalse: Expression, tsOriginal?: ts.Node): ConditionalExpression;

package/dist/LuaAST.js

@@ -38,6 +38,8 @@ exports.isReturnStatement = isReturnStatement;
 exports.createReturnStatement = createReturnStatement;
 exports.isBreakStatement = isBreakStatement;
 exports.createBreakStatement = createBreakStatement;
+exports.isContinueStatement = isContinueStatement;
+exports.createContinueStatement = createContinueStatement;
 exports.isExpressionStatement = isExpressionStatement;
 exports.createExpressionStatement = createExpressionStatement;
 exports.isNilLiteral = isNilLiteral;
@@ -78,6 +80,8 @@ exports.isFunctionDefinition = isFunctionDefinition;
 exports.isInlineFunctionExpression = isInlineFunctionExpression;
 exports.isParenthesizedExpression = isParenthesizedExpression;
 exports.createParenthesizedExpression = createParenthesizedExpression;
+exports.isConditionalExpression = isConditionalExpression;
+exports.createConditionalExpression = createConditionalExpression;
 // We can elide a lot of nodes especially tokens and keywords
 // because we don't create the AST from text
 const ts = require("typescript");
@@ -99,59 +103,61 @@ var SyntaxKind;
     SyntaxKind[SyntaxKind["LabelStatement"] = 11] = "LabelStatement";
     SyntaxKind[SyntaxKind["ReturnStatement"] = 12] = "ReturnStatement";
     SyntaxKind[SyntaxKind["BreakStatement"] = 13] = "BreakStatement";
-    SyntaxKind[SyntaxKind["ExpressionStatement"] = 14] = "ExpressionStatement";
+    SyntaxKind[SyntaxKind["ContinueStatement"] = 14] = "ContinueStatement";
+    SyntaxKind[SyntaxKind["ExpressionStatement"] = 15] = "ExpressionStatement";
     // Expression
-    SyntaxKind[SyntaxKind["StringLiteral"] = 15] = "StringLiteral";
-    SyntaxKind[SyntaxKind["NumericLiteral"] = 16] = "NumericLiteral";
-    SyntaxKind[SyntaxKind["NilKeyword"] = 17] = "NilKeyword";
-    SyntaxKind[SyntaxKind["DotsKeyword"] = 18] = "DotsKeyword";
-    SyntaxKind[SyntaxKind["ArgKeyword"] = 19] = "ArgKeyword";
-    SyntaxKind[SyntaxKind["TrueKeyword"] = 20] = "TrueKeyword";
-    SyntaxKind[SyntaxKind["FalseKeyword"] = 21] = "FalseKeyword";
-    SyntaxKind[SyntaxKind["FunctionExpression"] = 22] = "FunctionExpression";
-    SyntaxKind[SyntaxKind["TableFieldExpression"] = 23] = "TableFieldExpression";
-    SyntaxKind[SyntaxKind["TableExpression"] = 24] = "TableExpression";
-    SyntaxKind[SyntaxKind["UnaryExpression"] = 25] = "UnaryExpression";
-    SyntaxKind[SyntaxKind["BinaryExpression"] = 26] = "BinaryExpression";
-    SyntaxKind[SyntaxKind["CallExpression"] = 27] = "CallExpression";
-    SyntaxKind[SyntaxKind["MethodCallExpression"] = 28] = "MethodCallExpression";
-    SyntaxKind[SyntaxKind["Identifier"] = 29] = "Identifier";
-    SyntaxKind[SyntaxKind["TableIndexExpression"] = 30] = "TableIndexExpression";
-    SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 31] = "ParenthesizedExpression";
+    SyntaxKind[SyntaxKind["StringLiteral"] = 16] = "StringLiteral";
+    SyntaxKind[SyntaxKind["NumericLiteral"] = 17] = "NumericLiteral";
+    SyntaxKind[SyntaxKind["NilKeyword"] = 18] = "NilKeyword";
+    SyntaxKind[SyntaxKind["DotsKeyword"] = 19] = "DotsKeyword";
+    SyntaxKind[SyntaxKind["ArgKeyword"] = 20] = "ArgKeyword";
+    SyntaxKind[SyntaxKind["TrueKeyword"] = 21] = "TrueKeyword";
+    SyntaxKind[SyntaxKind["FalseKeyword"] = 22] = "FalseKeyword";
+    SyntaxKind[SyntaxKind["FunctionExpression"] = 23] = "FunctionExpression";
+    SyntaxKind[SyntaxKind["TableFieldExpression"] = 24] = "TableFieldExpression";
+    SyntaxKind[SyntaxKind["TableExpression"] = 25] = "TableExpression";
+    SyntaxKind[SyntaxKind["UnaryExpression"] = 26] = "UnaryExpression";
+    SyntaxKind[SyntaxKind["BinaryExpression"] = 27] = "BinaryExpression";
+    SyntaxKind[SyntaxKind["CallExpression"] = 28] = "CallExpression";
+    SyntaxKind[SyntaxKind["MethodCallExpression"] = 29] = "MethodCallExpression";
+    SyntaxKind[SyntaxKind["Identifier"] = 30] = "Identifier";
+    SyntaxKind[SyntaxKind["TableIndexExpression"] = 31] = "TableIndexExpression";
+    SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 32] = "ParenthesizedExpression";
+    SyntaxKind[SyntaxKind["ConditionalExpression"] = 33] = "ConditionalExpression";
     // Operators
     // Arithmetic
-    SyntaxKind[SyntaxKind["AdditionOperator"] = 32] = "AdditionOperator";
-    SyntaxKind[SyntaxKind["SubtractionOperator"] = 33] = "SubtractionOperator";
-    SyntaxKind[SyntaxKind["MultiplicationOperator"] = 34] = "MultiplicationOperator";
-    SyntaxKind[SyntaxKind["DivisionOperator"] = 35] = "DivisionOperator";
-    SyntaxKind[SyntaxKind["FloorDivisionOperator"] = 36] = "FloorDivisionOperator";
-    SyntaxKind[SyntaxKind["ModuloOperator"] = 37] = "ModuloOperator";
-    SyntaxKind[SyntaxKind["PowerOperator"] = 38] = "PowerOperator";
-    SyntaxKind[SyntaxKind["NegationOperator"] = 39] = "NegationOperator";
+    SyntaxKind[SyntaxKind["AdditionOperator"] = 34] = "AdditionOperator";
+    SyntaxKind[SyntaxKind["SubtractionOperator"] = 35] = "SubtractionOperator";
+    SyntaxKind[SyntaxKind["MultiplicationOperator"] = 36] = "MultiplicationOperator";
+    SyntaxKind[SyntaxKind["DivisionOperator"] = 37] = "DivisionOperator";
+    SyntaxKind[SyntaxKind["FloorDivisionOperator"] = 38] = "FloorDivisionOperator";
+    SyntaxKind[SyntaxKind["ModuloOperator"] = 39] = "ModuloOperator";
+    SyntaxKind[SyntaxKind["PowerOperator"] = 40] = "PowerOperator";
+    SyntaxKind[SyntaxKind["NegationOperator"] = 41] = "NegationOperator";
     // Concat
-    SyntaxKind[SyntaxKind["ConcatOperator"] = 40] = "ConcatOperator";
+    SyntaxKind[SyntaxKind["ConcatOperator"] = 42] = "ConcatOperator";
     // Length
-    SyntaxKind[SyntaxKind["LengthOperator"] = 41] = "LengthOperator";
+    SyntaxKind[SyntaxKind["LengthOperator"] = 43] = "LengthOperator";
     // Relational Ops
-    SyntaxKind[SyntaxKind["EqualityOperator"] = 42] = "EqualityOperator";
-    SyntaxKind[SyntaxKind["InequalityOperator"] = 43] = "InequalityOperator";
-    SyntaxKind[SyntaxKind["LessThanOperator"] = 44] = "LessThanOperator";
-    SyntaxKind[SyntaxKind["LessEqualOperator"] = 45] = "LessEqualOperator";
+    SyntaxKind[SyntaxKind["EqualityOperator"] = 44] = "EqualityOperator";
+    SyntaxKind[SyntaxKind["InequalityOperator"] = 45] = "InequalityOperator";
+    SyntaxKind[SyntaxKind["LessThanOperator"] = 46] = "LessThanOperator";
+    SyntaxKind[SyntaxKind["LessEqualOperator"] = 47] = "LessEqualOperator";
     // Syntax Sugar `x > y` <=> `not (y <= x)`
     // but we should probably use them to make the output code more readable
-    SyntaxKind[SyntaxKind["GreaterThanOperator"] = 46] = "GreaterThanOperator";
-    SyntaxKind[SyntaxKind["GreaterEqualOperator"] = 47] = "GreaterEqualOperator";
+    SyntaxKind[SyntaxKind["GreaterThanOperator"] = 48] = "GreaterThanOperator";
+    SyntaxKind[SyntaxKind["GreaterEqualOperator"] = 49] = "GreaterEqualOperator";
     // Logical
-    SyntaxKind[SyntaxKind["AndOperator"] = 48] = "AndOperator";
-    SyntaxKind[SyntaxKind["OrOperator"] = 49] = "OrOperator";
-    SyntaxKind[SyntaxKind["NotOperator"] = 50] = "NotOperator";
+    SyntaxKind[SyntaxKind["AndOperator"] = 50] = "AndOperator";
+    SyntaxKind[SyntaxKind["OrOperator"] = 51] = "OrOperator";
+    SyntaxKind[SyntaxKind["NotOperator"] = 52] = "NotOperator";
     // Bitwise
-    SyntaxKind[SyntaxKind["BitwiseAndOperator"] = 51] = "BitwiseAndOperator";
-    SyntaxKind[SyntaxKind["BitwiseOrOperator"] = 52] = "BitwiseOrOperator";
-    SyntaxKind[SyntaxKind["BitwiseExclusiveOrOperator"] = 53] = "BitwiseExclusiveOrOperator";
-    SyntaxKind[SyntaxKind["BitwiseRightShiftOperator"] = 54] = "BitwiseRightShiftOperator";
-    SyntaxKind[SyntaxKind["BitwiseLeftShiftOperator"] = 55] = "BitwiseLeftShiftOperator";
-    SyntaxKind[SyntaxKind["BitwiseNotOperator"] = 56] = "BitwiseNotOperator";
+    SyntaxKind[SyntaxKind["BitwiseAndOperator"] = 53] = "BitwiseAndOperator";
+    SyntaxKind[SyntaxKind["BitwiseOrOperator"] = 54] = "BitwiseOrOperator";
+    SyntaxKind[SyntaxKind["BitwiseExclusiveOrOperator"] = 55] = "BitwiseExclusiveOrOperator";
+    SyntaxKind[SyntaxKind["BitwiseRightShiftOperator"] = 56] = "BitwiseRightShiftOperator";
+    SyntaxKind[SyntaxKind["BitwiseLeftShiftOperator"] = 57] = "BitwiseLeftShiftOperator";
+    SyntaxKind[SyntaxKind["BitwiseNotOperator"] = 58] = "BitwiseNotOperator";
 })(SyntaxKind || (exports.SyntaxKind = SyntaxKind = {}));
 var NodeFlags;
 (function (NodeFlags) {
@@ -337,6 +343,12 @@ function isBreakStatement(node) {
 function createBreakStatement(tsOriginal) {
     return createNode(SyntaxKind.BreakStatement, tsOriginal);
 }
+function isContinueStatement(node) {
+    return node.kind === SyntaxKind.ContinueStatement;
+}
+function createContinueStatement(tsOriginal) {
+    return createNode(SyntaxKind.ContinueStatement, tsOriginal);
+}
 function isExpressionStatement(node) {
     return node.kind === SyntaxKind.ExpressionStatement;
 }
@@ -510,4 +522,14 @@ function createParenthesizedExpression(expression, tsOriginal) {
     parenthesizedExpression.expression = expression;
     return parenthesizedExpression;
 }
+function isConditionalExpression(node) {
+    return node.kind === SyntaxKind.ConditionalExpression;
+}
+function createConditionalExpression(condition, whenTrue, whenFalse, tsOriginal) {
+    const conditionalExpression = createNode(SyntaxKind.ConditionalExpression, tsOriginal);
+    conditionalExpression.condition = condition;
+    conditionalExpression.whenTrue = whenTrue;
+    conditionalExpression.whenFalse = whenFalse;
+    return conditionalExpression;
+}
 //# sourceMappingURL=LuaAST.js.map

package/dist/LuaPrinter.d.ts

@@ -54,6 +54,7 @@ export declare class LuaPrinter {
     printLabelStatement(statement: lua.LabelStatement): SourceNode;
     printReturnStatement(statement: lua.ReturnStatement): SourceNode;
     printBreakStatement(statement: lua.BreakStatement): SourceNode;
+    printContinueStatement(statement: lua.ContinueStatement): SourceNode;
     printExpressionStatement(statement: lua.ExpressionStatement): SourceNode;
     printExpression(expression: lua.Expression): SourceNode;
     printStringLiteral(expression: lua.StringLiteral): SourceNode;
@@ -76,6 +77,7 @@ export declare class LuaPrinter {
     printIdentifier(expression: lua.Identifier): SourceNode;
     printTableIndexExpression(expression: lua.TableIndexExpression): SourceNode;
     printParenthesizedExpression(expression: lua.ParenthesizedExpression): SourceNode;
+    printConditionalExpression(expression: lua.ConditionalExpression): SourceNode;
     printOperator(kind: lua.Operator): SourceNode;
     protected joinChunksWithComma(chunks: SourceChunk[]): SourceChunk[];
     /**

package/dist/LuaPrinter.js

@@ -260,6 +260,8 @@ class LuaPrinter {
                 return this.printReturnStatement(statement);
             case lua.SyntaxKind.BreakStatement:
                 return this.printBreakStatement(statement);
+            case lua.SyntaxKind.ContinueStatement:
+                return this.printContinueStatement(statement);
             case lua.SyntaxKind.ExpressionStatement:
                 return this.printExpressionStatement(statement);
             default:
@@ -393,6 +395,9 @@ class LuaPrinter {
     printBreakStatement(statement) {
         return this.createSourceNode(statement, this.indent("break"));
     }
+    printContinueStatement(statement) {
+        return this.createSourceNode(statement, this.indent("continue"));
+    }
     printExpressionStatement(statement) {
         return this.createSourceNode(statement, [this.indent(), this.printExpression(statement.expression)]);
     }
@@ -432,6 +437,8 @@ class LuaPrinter {
                 return this.printTableIndexExpression(expression);
             case lua.SyntaxKind.ParenthesizedExpression:
                 return this.printParenthesizedExpression(expression);
+            case lua.SyntaxKind.ConditionalExpression:
+                return this.printConditionalExpression(expression);
             default:
                 throw new Error(`Tried to print unknown statement kind: ${lua.SyntaxKind[expression.kind]}`);
         }
@@ -587,6 +594,16 @@ class LuaPrinter {
     printParenthesizedExpression(expression) {
         return this.createSourceNode(expression, ["(", this.printExpression(expression.expression), ")"]);
     }
+    printConditionalExpression(expression) {
+        return this.createSourceNode(expression, [
+            "if ",
+            this.printExpression(expression.condition),
+            " then ",
+            this.printExpression(expression.whenTrue),
+            " else ",
+            this.printExpression(expression.whenFalse),
+        ]);
+    }
     printOperator(kind) {
         return new source_map_1.SourceNode(null, null, this.relativeSourcePath, LuaPrinter.operatorMap[kind]);
     }

package/dist/transformation/builtins/index.d.ts

@@ -5,3 +5,4 @@ export declare function transformBuiltinPropertyAccessExpression(context: Transf
 export declare function transformBuiltinCallExpression(context: TransformationContext, node: ts.CallExpression): lua.Expression | undefined;
 export declare function transformBuiltinIdentifierExpression(context: TransformationContext, node: ts.Identifier, symbol: ts.Symbol | undefined): lua.Expression | undefined;
 export declare function checkForLuaLibType(context: TransformationContext, type: ts.Type): void;
+export declare function tryGetStandardLibrarySymbolOfType(context: TransformationContext, type: ts.Type): ts.Symbol | undefined;

package/dist/transformation/builtins/index.js

@@ -4,6 +4,7 @@ exports.transformBuiltinPropertyAccessExpression = transformBuiltinPropertyAcces
 exports.transformBuiltinCallExpression = transformBuiltinCallExpression;
 exports.transformBuiltinIdentifierExpression = transformBuiltinIdentifierExpression;
 exports.checkForLuaLibType = checkForLuaLibType;
+exports.tryGetStandardLibrarySymbolOfType = tryGetStandardLibrarySymbolOfType;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const lua_ast_1 = require("../utils/lua-ast");

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

@@ -104,3 +104,6 @@ export declare const cannotAssignToNodeOfKind: ((node: ts.Node, kind: lua.Syntax
 export declare const incompleteFieldDecoratorWarning: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
+export declare const unsupportedArrayWithLengthConstructor: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+    code: number;
+};

package/dist/transformation/utils/diagnostics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.incompleteFieldDecoratorWarning = exports.cannotAssignToNodeOfKind = 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;
+exports.unsupportedArrayWithLengthConstructor = exports.incompleteFieldDecoratorWarning = exports.cannotAssignToNodeOfKind = 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");
 const lua = require("../../LuaAST");
 const CompilerOptions_1 = require("../../CompilerOptions");
@@ -64,4 +64,5 @@ exports.invalidMethodCallExtensionUse = createErrorDiagnosticFactory("This langu
 exports.invalidSpreadInCallExtension = createErrorDiagnosticFactory("Spread elements are not supported in call extensions.");
 exports.cannotAssignToNodeOfKind = createErrorDiagnosticFactory((kind) => `Cannot create assignment assigning to a node of type ${lua.SyntaxKind[kind]}.`);
 exports.incompleteFieldDecoratorWarning = createWarningDiagnosticFactory("You are using a class field decorator, note that tstl ignores returned value initializers!");
+exports.unsupportedArrayWithLengthConstructor = createErrorDiagnosticFactory(`Constructing new Array with length is not supported.`);
 //# sourceMappingURL=diagnostics.js.map

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

@@ -18,7 +18,8 @@ interface FunctionDefinitionInfo {
 }
 export declare enum LoopContinued {
     WithGoto = 0,
-    WithRepeatBreak = 1
+    WithRepeatBreak = 1,
+    WithContinue = 2
 }
 export interface Scope {
     type: ScopeType;

package/dist/transformation/utils/scope.js

@@ -32,6 +32,7 @@ var LoopContinued;
 (function (LoopContinued) {
     LoopContinued[LoopContinued["WithGoto"] = 0] = "WithGoto";
     LoopContinued[LoopContinued["WithRepeatBreak"] = 1] = "WithRepeatBreak";
+    LoopContinued[LoopContinued["WithContinue"] = 2] = "WithContinue";
 })(LoopContinued || (exports.LoopContinued = LoopContinued = {}));
 function* walkScopesUp(context) {
     const scopeStack = context.scopeStack;

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

@@ -57,15 +57,23 @@ function isNumberType(context, type) {
 function isExplicitArrayType(context, type) {
     if (context.checker.isArrayType(type) || context.checker.isTupleType(type))
         return true;
+    if (type.isUnionOrIntersection()) {
+        if (type.types.some(t => isExplicitArrayType(context, t))) {
+            return true;
+        }
+    }
+    const baseTypes = type.getBaseTypes();
+    if (baseTypes) {
+        if (baseTypes.some(t => isExplicitArrayType(context, t))) {
+            return true;
+        }
+    }
     if (type.symbol) {
         const baseConstraint = context.checker.getBaseConstraintOfType(type);
         if (baseConstraint && baseConstraint !== type) {
             return isExplicitArrayType(context, baseConstraint);
         }
     }
-    if (type.isUnionOrIntersection()) {
-        return type.types.some(t => isExplicitArrayType(context, t));
-    }
     return false;
 }
 function isAlwaysExplicitArrayType(context, type) {

package/dist/transformation/visitors/break-continue.js

@@ -12,11 +12,16 @@ exports.transformBreakStatement = transformBreakStatement;
 const transformContinueStatement = (statement, context) => {
     var _a;
     const scope = (0, scope_1.findScope)(context, scope_1.ScopeType.Loop);
-    const continuedWith = context.luaTarget === CompilerOptions_1.LuaTarget.Universal ||
-        context.luaTarget === CompilerOptions_1.LuaTarget.Lua50 ||
-        context.luaTarget === CompilerOptions_1.LuaTarget.Lua51
-        ? scope_1.LoopContinued.WithRepeatBreak
-        : scope_1.LoopContinued.WithGoto;
+    const continuedWith = {
+        [CompilerOptions_1.LuaTarget.Universal]: scope_1.LoopContinued.WithRepeatBreak,
+        [CompilerOptions_1.LuaTarget.Lua50]: scope_1.LoopContinued.WithRepeatBreak,
+        [CompilerOptions_1.LuaTarget.Lua51]: scope_1.LoopContinued.WithRepeatBreak,
+        [CompilerOptions_1.LuaTarget.Lua52]: scope_1.LoopContinued.WithGoto,
+        [CompilerOptions_1.LuaTarget.Lua53]: scope_1.LoopContinued.WithGoto,
+        [CompilerOptions_1.LuaTarget.Lua54]: scope_1.LoopContinued.WithGoto,
+        [CompilerOptions_1.LuaTarget.LuaJIT]: scope_1.LoopContinued.WithGoto,
+        [CompilerOptions_1.LuaTarget.Luau]: scope_1.LoopContinued.WithContinue,
+    }[context.luaTarget];
     if (scope) {
         scope.loopContinued = continuedWith;
     }
@@ -24,6 +29,8 @@ const transformContinueStatement = (statement, context) => {
     switch (continuedWith) {
         case scope_1.LoopContinued.WithGoto:
             return lua.createGotoStatement(label, statement);
+        case scope_1.LoopContinued.WithContinue:
+            return lua.createContinueStatement(statement);
         case scope_1.LoopContinued.WithRepeatBreak:
             return [
                 lua.createAssignmentStatement(lua.createIdentifier(label), lua.createBooleanLiteral(true), statement),

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

@@ -7,19 +7,41 @@ const diagnostics_1 = require("../../utils/diagnostics");
 const lualib_1 = require("../../utils/lualib");
 const call_1 = require("../call");
 const table_1 = require("../language-extensions/table");
+const builtins_1 = require("../../builtins");
 const transformNewExpression = (node, context) => {
-    var _a, _b;
+    var _a, _b, _c;
     if ((0, table_1.isTableNewCall)(context, node)) {
         return lua.createTableExpression(undefined, node);
     }
+    const constructorType = context.checker.getTypeAtLocation(node.expression);
+    if (((_a = (0, builtins_1.tryGetStandardLibrarySymbolOfType)(context, constructorType)) === null || _a === void 0 ? void 0 : _a.name) === "ArrayConstructor") {
+        if (node.arguments === undefined || node.arguments.length === 0) {
+            // turn new Array<>() into a simple {}
+            return lua.createTableExpression([], node);
+        }
+        else {
+            // More than one argument, check if items constructor
+            const signature = context.checker.getResolvedSignature(node);
+            const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
+            if ((signatureDeclaration === null || signatureDeclaration === void 0 ? void 0 : signatureDeclaration.parameters.length) === 1 &&
+                signatureDeclaration.parameters[0].dotDotDotToken === undefined) {
+                context.diagnostics.push((0, diagnostics_1.unsupportedArrayWithLengthConstructor)(node));
+                return lua.createTableExpression([], node);
+            }
+            else {
+                const callArguments = (0, call_1.transformArguments)(context, node.arguments, signature);
+                return lua.createTableExpression(callArguments.map(e => lua.createTableFieldExpression(e)), node);
+            }
+        }
+    }
     const signature = context.checker.getResolvedSignature(node);
-    const [name, params] = (0, call_1.transformCallAndArguments)(context, node.expression, (_a = node.arguments) !== null && _a !== void 0 ? _a : [], signature);
+    const [name, params] = (0, call_1.transformCallAndArguments)(context, node.expression, (_b = node.arguments) !== null && _b !== void 0 ? _b : [], signature);
     const type = context.checker.getTypeAtLocation(node);
     const annotations = (0, annotations_1.getTypeAnnotations)(type);
     const customConstructorAnnotation = annotations.get(annotations_1.AnnotationKind.CustomConstructor);
     if (customConstructorAnnotation) {
         if (customConstructorAnnotation.args.length === 1) {
-            return lua.createCallExpression(lua.createIdentifier(customConstructorAnnotation.args[0]), (0, call_1.transformArguments)(context, (_b = node.arguments) !== null && _b !== void 0 ? _b : []), node);
+            return lua.createCallExpression(lua.createIdentifier(customConstructorAnnotation.args[0]), (0, call_1.transformArguments)(context, (_c = node.arguments) !== null && _c !== void 0 ? _c : []), node);
         }
         else {
             context.diagnostics.push((0, diagnostics_1.annotationInvalidArgumentCount)(node, annotations_1.AnnotationKind.CustomConstructor, customConstructorAnnotation.args.length, 1));

package/dist/transformation/visitors/conditional.js

@@ -10,6 +10,7 @@ const scope_1 = require("../utils/scope");
 const block_1 = require("./block");
 const typescript_1 = require("../utils/typescript");
 const diagnostics_1 = require("../utils/diagnostics");
+const CompilerOptions_1 = require("../../CompilerOptions");
 function transformProtectedConditionalExpression(context, expression, condition, whenTrue, whenFalse) {
     const tempVar = context.createTempNameForNode(expression.condition);
     const trueStatements = whenTrue.precedingStatements.concat(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), whenTrue.result, expression.whenTrue));
@@ -22,6 +23,10 @@ function transformProtectedConditionalExpression(context, expression, condition,
     return lua.cloneIdentifier(tempVar);
 }
 const transformConditionalExpression = (expression, context) => {
+    if (context.luaTarget === CompilerOptions_1.LuaTarget.Luau) {
+        // Luau's ternary operator doesn't have these issues
+        return lua.createConditionalExpression(context.transformExpression(expression.condition), context.transformExpression(expression.whenTrue), context.transformExpression(expression.whenFalse), expression);
+    }
     // Check if we need to add diagnostic about Lua truthiness
     checkOnlyTruthyCondition(expression.condition, context);
     const condition = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.condition));

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

@@ -21,6 +21,7 @@ function transformLoopBody(context, loop) {
     const scopeId = scope.id;
     switch (scope.loopContinued) {
         case undefined:
+        case scope_1.LoopContinued.WithContinue:
             return body;
         case scope_1.LoopContinued.WithGoto:
             return [lua.createDoStatement(body), lua.createLabelStatement(`__continue${scopeId}`)];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.28.1",
+    "version": "1.29.0",
     "description": "A generic TypeScript to Lua transpiler. Write your code in TypeScript and publish Lua!",
     "repository": "https://github.com/TypeScriptToLua/TypeScriptToLua",
     "homepage": "https://typescripttolua.github.io/",