@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/TSTransformer/nodes/statements/transformVariableStatement.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformVariable = transformVariable;
+exports.transformVariableDeclaration = transformVariableDeclaration;
+exports.isVarDeclaration = isVarDeclaration;
+exports.transformVariableDeclarationList = transformVariableDeclarationList;
+exports.transformVariableStatement = transformVariableStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const assert_1 = require("../../../Shared/util/assert");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformArrayBindingPattern_1 = require("../binding/transformArrayBindingPattern");
+const transformObjectBindingPattern_1 = require("../binding/transformObjectBindingPattern");
+const transformExpression_1 = require("../expressions/transformExpression");
+const transformIdentifier_1 = require("../expressions/transformIdentifier");
+const transformInitializer_1 = require("../transformInitializer");
+const arrayBindingPatternContainsHoists_1 = require("../../util/arrayBindingPatternContainsHoists");
+const arrayLikeExpressionContainsSpread_1 = require("../../util/arrayLikeExpressionContainsSpread");
+const getTargetIdForBindingPattern_1 = require("../../util/binding/getTargetIdForBindingPattern");
+const checkVariableHoist_1 = require("../../util/checkVariableHoist");
+const isSymbolMutable_1 = require("../../util/isSymbolMutable");
+const types_1 = require("../../util/types");
+const validateIdentifier_1 = require("../../util/validateIdentifier");
+const wrapExpressionStatement_1 = require("../../util/wrapExpressionStatement");
+const typescript_1 = __importDefault(require("typescript"));
+function transformVariable(state, identifier, right) {
+    (0, validateIdentifier_1.validateIdentifier)(state, identifier);
+    const symbol = state.typeChecker.getSymbolAtLocation(identifier);
+    (0, assert_1.assert)(symbol);
+    if ((0, isSymbolMutable_1.isSymbolMutable)(state, symbol)) {
+        const exportAccess = state.getModuleIdPropertyAccess(symbol);
+        if (exportAccess) {
+            if (right) {
+                state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                    left: exportAccess,
+                    operator: "=",
+                    right,
+                }));
+            }
+            return exportAccess;
+        }
+    }
+    const left = (0, transformIdentifier_1.transformIdentifierDefined)(state, identifier);
+    (0, checkVariableHoist_1.checkVariableHoist)(state, identifier, symbol);
+    if (state.isHoisted.get(symbol) === true) {
+        if (right) {
+            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, { left, operator: "=", right }));
+        }
+    }
+    else {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, { left, right }));
+    }
+    return left;
+}
+function transformOptimizedArrayBindingPattern(state, bindingPattern, rhs) {
+    return state.capturePrereqs(() => {
+        const ids = luau_ast_1.default.list.make();
+        const statements = state.capturePrereqs(() => {
+            for (const element of bindingPattern.elements) {
+                if (typescript_1.default.isOmittedExpression(element)) {
+                    luau_ast_1.default.list.push(ids, luau_ast_1.default.tempId());
+                }
+                else {
+                    if (typescript_1.default.isIdentifier(element.name)) {
+                        (0, validateIdentifier_1.validateIdentifier)(state, element.name);
+                        const id = (0, transformIdentifier_1.transformIdentifierDefined)(state, element.name);
+                        luau_ast_1.default.list.push(ids, id);
+                        if (element.initializer) {
+                            state.prereq((0, transformInitializer_1.transformInitializer)(state, id, element.initializer));
+                        }
+                    }
+                    else {
+                        const id = luau_ast_1.default.tempId("binding");
+                        luau_ast_1.default.list.push(ids, id);
+                        if (element.initializer) {
+                            state.prereq((0, transformInitializer_1.transformInitializer)(state, id, element.initializer));
+                        }
+                        if (typescript_1.default.isArrayBindingPattern(element.name)) {
+                            (0, transformArrayBindingPattern_1.transformArrayBindingPattern)(state, element.name, id);
+                        }
+                        else {
+                            (0, transformObjectBindingPattern_1.transformObjectBindingPattern)(state, element.name, id);
+                        }
+                    }
+                }
+            }
+        });
+        (0, assert_1.assert)(!luau_ast_1.default.list.isEmpty(ids));
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, { left: ids, right: rhs }));
+        state.prereqList(statements);
+    });
+}
+function transformVariableDeclaration(state, node) {
+    const statements = luau_ast_1.default.list.make();
+    let value;
+    if (node.initializer) {
+        luau_ast_1.default.list.pushList(statements, state.capturePrereqs(() => (value = (0, transformExpression_1.transformExpression)(state, node.initializer))));
+    }
+    const name = node.name;
+    if (typescript_1.default.isIdentifier(name)) {
+        luau_ast_1.default.list.pushList(statements, state.capturePrereqs(() => transformVariable(state, name, value)));
+    }
+    else {
+        (0, assert_1.assert)(node.initializer && value);
+        if (name.elements.length === 0) {
+            if (!luau_ast_1.default.isArray(value) || !luau_ast_1.default.list.isEmpty(value.members)) {
+                luau_ast_1.default.list.pushList(statements, (0, wrapExpressionStatement_1.wrapExpressionStatement)(value));
+            }
+            return statements;
+        }
+        if (typescript_1.default.isArrayBindingPattern(name)) {
+            if (luau_ast_1.default.isCall(value) &&
+                (0, types_1.isLuaTupleType)(state)(state.getType(node.initializer)) &&
+                !(0, arrayBindingPatternContainsHoists_1.arrayBindingPatternContainsHoists)(state, name) &&
+                !(0, arrayLikeExpressionContainsSpread_1.arrayLikeExpressionContainsSpread)(name)) {
+                luau_ast_1.default.list.pushList(statements, transformOptimizedArrayBindingPattern(state, name, value));
+            }
+            else if (luau_ast_1.default.isArray(value) &&
+                !luau_ast_1.default.list.isEmpty(value.members) &&
+                !(0, arrayBindingPatternContainsHoists_1.arrayBindingPatternContainsHoists)(state, name) &&
+                !(0, arrayLikeExpressionContainsSpread_1.arrayLikeExpressionContainsSpread)(name)) {
+                luau_ast_1.default.list.pushList(statements, transformOptimizedArrayBindingPattern(state, name, value.members));
+            }
+            else {
+                luau_ast_1.default.list.pushList(statements, state.capturePrereqs(() => (0, transformArrayBindingPattern_1.transformArrayBindingPattern)(state, name, (0, getTargetIdForBindingPattern_1.getTargetIdForBindingPattern)(state, name, value))));
+            }
+        }
+        else {
+            luau_ast_1.default.list.pushList(statements, state.capturePrereqs(() => (0, transformObjectBindingPattern_1.transformObjectBindingPattern)(state, name, (0, getTargetIdForBindingPattern_1.getTargetIdForBindingPattern)(state, name, value))));
+        }
+    }
+    return statements;
+}
+function isVarDeclaration(node) {
+    return !(node.flags & typescript_1.default.NodeFlags.Const) && !(node.flags & typescript_1.default.NodeFlags.Let);
+}
+function transformVariableDeclarationList(state, node) {
+    if (isVarDeclaration(node)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noVar(node));
+    }
+    const statements = luau_ast_1.default.list.make();
+    for (const declaration of node.declarations) {
+        const [variableStatements, prereqs] = state.capture(() => transformVariableDeclaration(state, declaration));
+        luau_ast_1.default.list.pushList(statements, prereqs);
+        luau_ast_1.default.list.pushList(statements, variableStatements);
+    }
+    return statements;
+}
+function transformVariableStatement(state, node) {
+    return transformVariableDeclarationList(state, node.declarationList);
+}
+//# sourceMappingURL=transformVariableStatement.js.map

package/out/TSTransformer/nodes/statements/transformWhileStatement.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformWhileStatement(state: TransformState, node: ts.WhileStatement): luau.List<luau.WhileStatement>;

package/out/TSTransformer/nodes/statements/transformWhileStatement.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformWhileStatement = transformWhileStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("../expressions/transformExpression");
+const transformStatementList_1 = require("../transformStatementList");
+const createTruthinessChecks_1 = require("../../util/createTruthinessChecks");
+const getStatements_1 = require("../../util/getStatements");
+function transformWhileStatement(state, node) {
+    const whileStatements = luau_ast_1.default.list.make();
+    let [conditionExp, conditionPrereqs] = state.capture(() => (0, createTruthinessChecks_1.createTruthinessChecks)(state, (0, transformExpression_1.transformExpression)(state, node.expression), node.expression));
+    if (!luau_ast_1.default.list.isEmpty(conditionPrereqs)) {
+        luau_ast_1.default.list.pushList(whileStatements, conditionPrereqs);
+        luau_ast_1.default.list.push(whileStatements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+            condition: luau_ast_1.default.unary("not", conditionExp),
+            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BreakStatement, {})),
+            elseBody: luau_ast_1.default.list.make(),
+        }));
+        conditionExp = luau_ast_1.default.bool(true);
+    }
+    luau_ast_1.default.list.pushList(whileStatements, (0, transformStatementList_1.transformStatementList)(state, node.statement, (0, getStatements_1.getStatements)(node.statement)));
+    return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.WhileStatement, {
+        condition: conditionExp,
+        statements: whileStatements,
+    }));
+}
+//# sourceMappingURL=transformWhileStatement.js.map

package/out/TSTransformer/nodes/transformEntityName.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../classes/TransformState";
+import ts from "typescript";
+export declare function transformEntityName(state: TransformState, node: ts.EntityName): luau.Expression<luau.SyntaxKind>;

package/out/TSTransformer/nodes/transformEntityName.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformEntityName = transformEntityName;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformIdentifier_1 = require("./expressions/transformIdentifier");
+const convertToIndexableExpression_1 = require("../util/convertToIndexableExpression");
+const validateIdentifier_1 = require("../util/validateIdentifier");
+const typescript_1 = __importDefault(require("typescript"));
+function transformEntityName(state, node) {
+    if (typescript_1.default.isIdentifier(node)) {
+        (0, validateIdentifier_1.validateIdentifier)(state, node);
+        return (0, transformIdentifier_1.transformIdentifier)(state, node);
+    }
+    else {
+        return transformQualifiedName(state, node);
+    }
+}
+function transformQualifiedName(state, node) {
+    return luau_ast_1.default.property((0, convertToIndexableExpression_1.convertToIndexableExpression)(transformEntityName(state, node.left)), node.right.text);
+}
+//# sourceMappingURL=transformEntityName.js.map

package/out/TSTransformer/nodes/transformInitializer.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function transformInitializer(state: TransformState, id: luau.WritableExpression, initializer: ts.Expression): luau.IfStatement;

package/out/TSTransformer/nodes/transformInitializer.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformInitializer = transformInitializer;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./expressions/transformExpression");
+function transformInitializer(state, id, initializer) {
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+        condition: luau_ast_1.default.binary(id, "==", luau_ast_1.default.nil()),
+        elseBody: luau_ast_1.default.list.make(),
+        statements: state.capturePrereqs(() => {
+            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: id,
+                operator: "=",
+                right: (0, transformExpression_1.transformExpression)(state, initializer),
+            }));
+        }),
+    });
+}
+//# sourceMappingURL=transformInitializer.js.map

package/out/TSTransformer/nodes/transformInterpolatedStringPart.d.ts

@@ -0,0 +1,3 @@
+import luau from "@roblox-ts/luau-ast";
+import ts from "typescript";
+export declare function transformInterpolatedStringPart(node: ts.TemplateLiteralToken | ts.StringLiteral): luau.InterpolatedStringPart;

package/out/TSTransformer/nodes/transformInterpolatedStringPart.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformInterpolatedStringPart = transformInterpolatedStringPart;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const createStringFromLiteral_1 = require("../util/createStringFromLiteral");
+function transformInterpolatedStringPart(node) {
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.InterpolatedStringPart, { text: (0, createStringFromLiteral_1.createStringFromLiteral)(node) });
+}
+//# sourceMappingURL=transformInterpolatedStringPart.js.map

package/out/TSTransformer/nodes/transformLogical.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function transformLogical(state: TransformState, node: ts.BinaryExpression): luau.Expression;

package/out/TSTransformer/nodes/transformLogical.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformLogical = transformLogical;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const assert_1 = require("../../Shared/util/assert");
+const transformExpression_1 = require("./expressions/transformExpression");
+const createTruthinessChecks_1 = require("../util/createTruthinessChecks");
+const expressionChain_1 = require("../util/expressionChain");
+const getKindName_1 = require("../util/getKindName");
+const types_1 = require("../util/types");
+const typescript_1 = __importDefault(require("typescript"));
+function flattenByOperator(node, operatorKind) {
+    const result = new Array();
+    while (typescript_1.default.isBinaryExpression(node) && node.operatorToken.kind === operatorKind) {
+        result.unshift(node.right);
+        node = node.left;
+    }
+    result.unshift(node);
+    return result;
+}
+function getLogicalChain(state, binaryExp, binaryOperatorKind, enableInlining) {
+    return flattenByOperator(binaryExp, binaryOperatorKind).map((node, index, array) => {
+        const type = state.getType(node);
+        const [expression, statements] = state.capture(() => (0, transformExpression_1.transformExpression)(state, node));
+        let inline = false;
+        if (enableInlining) {
+            const willWrap = index < array.length - 1 && (0, createTruthinessChecks_1.willCreateTruthinessChecks)(type);
+            inline = luau_ast_1.default.list.isEmpty(statements) && !willWrap;
+        }
+        return { node, type, expression, statements, inline };
+    });
+}
+function buildLogicalChainPrereqs(state, chain, conditionId, buildCondition, index = 0) {
+    const expInfo = chain[index];
+    state.prereqList(expInfo.statements);
+    if (index === 0) {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: conditionId,
+            right: expInfo.expression,
+        }));
+    }
+    else {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+            left: conditionId,
+            operator: "=",
+            right: expInfo.expression,
+        }));
+    }
+    if (index + 1 < chain.length) {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+            condition: buildCondition(conditionId, expInfo.node),
+            statements: state.capturePrereqs(() => buildLogicalChainPrereqs(state, chain, conditionId, buildCondition, index + 1)),
+            elseBody: luau_ast_1.default.list.make(),
+        }));
+    }
+}
+function mergeInlineExpressions(chain, binaryOperator) {
+    for (let i = 0; i < chain.length; i++) {
+        const info = chain[i];
+        if (info.inline) {
+            const exps = [info.expression];
+            const j = i + 1;
+            while (j < chain.length && chain[j].inline) {
+                exps.push(chain[j].expression);
+                chain.splice(j, 1);
+            }
+            info.expression = (0, expressionChain_1.binaryExpressionChain)(exps, binaryOperator);
+        }
+    }
+}
+function buildInlineConditionExpression(state, node, tsBinaryOperator, luaBinaryOperator, buildCondition) {
+    const chain = getLogicalChain(state, node, tsBinaryOperator, true);
+    mergeInlineExpressions(chain, luaBinaryOperator);
+    if (chain.length === 1 && chain[0].inline) {
+        return chain[0].expression;
+    }
+    const conditionId = luau_ast_1.default.tempId("condition");
+    buildLogicalChainPrereqs(state, chain, conditionId, buildCondition);
+    return conditionId;
+}
+function transformLogical(state, node) {
+    if (node.operatorToken.kind === typescript_1.default.SyntaxKind.AmpersandAmpersandToken) {
+        return buildInlineConditionExpression(state, node, node.operatorToken.kind, "and", (conditionId, node) => (0, createTruthinessChecks_1.createTruthinessChecks)(state, conditionId, node));
+    }
+    else if (node.operatorToken.kind === typescript_1.default.SyntaxKind.BarBarToken) {
+        return buildInlineConditionExpression(state, node, node.operatorToken.kind, "or", (conditionId, node) => luau_ast_1.default.unary("not", (0, createTruthinessChecks_1.createTruthinessChecks)(state, conditionId, node)));
+    }
+    else if (node.operatorToken.kind === typescript_1.default.SyntaxKind.QuestionQuestionToken) {
+        const conditionBuilder = (conditionId) => luau_ast_1.default.binary(conditionId, "==", luau_ast_1.default.nil());
+        if (!(0, types_1.isPossiblyType)(state.getType(node), (0, types_1.isBooleanLiteralType)(state, false))) {
+            return buildInlineConditionExpression(state, node, node.operatorToken.kind, "or", conditionBuilder);
+        }
+        const chain = getLogicalChain(state, node, typescript_1.default.SyntaxKind.QuestionQuestionToken, false);
+        const conditionId = luau_ast_1.default.tempId("condition");
+        buildLogicalChainPrereqs(state, chain, conditionId, conditionBuilder);
+        return conditionId;
+    }
+    (0, assert_1.assert)(false, `Operator not implemented: ${(0, getKindName_1.getKindName)(node.operatorToken.kind)}`);
+}
+//# sourceMappingURL=transformLogical.js.map

package/out/TSTransformer/nodes/transformLogicalOrCoalescingAssignmentExpression.d.ts

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../classes/TransformState";
+import ts from "typescript";
+export declare function transformLogicalOrCoalescingAssignmentExpression(state: TransformState, node: ts.AssignmentExpression<ts.Token<ts.LogicalOrCoalescingAssignmentOperator>>): luau.WritableExpression;
+export declare function transformLogicalOrCoalescingAssignmentExpressionStatement(state: TransformState, node: ts.AssignmentExpression<ts.Token<ts.LogicalOrCoalescingAssignmentOperator>>): luau.List<luau.Statement>;

package/out/TSTransformer/nodes/transformLogicalOrCoalescingAssignmentExpression.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformLogicalOrCoalescingAssignmentExpression = transformLogicalOrCoalescingAssignmentExpression;
+exports.transformLogicalOrCoalescingAssignmentExpressionStatement = transformLogicalOrCoalescingAssignmentExpressionStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./expressions/transformExpression");
+const transformWritable_1 = require("./transformWritable");
+const createTruthinessChecks_1 = require("../util/createTruthinessChecks");
+const typescript_1 = __importDefault(require("typescript"));
+function transformCoalescingAssignmentExpression(state, left, right) {
+    const writable = (0, transformWritable_1.transformWritableExpression)(state, left, true);
+    const [value, valuePreqreqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, right));
+    const ifStatements = luau_ast_1.default.list.make();
+    luau_ast_1.default.list.pushList(ifStatements, valuePreqreqs);
+    luau_ast_1.default.list.push(ifStatements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: writable,
+        operator: "=",
+        right: value,
+    }));
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+        condition: luau_ast_1.default.binary(writable, "==", luau_ast_1.default.nil()),
+        statements: ifStatements,
+        elseBody: luau_ast_1.default.list.make(),
+    }));
+    return writable;
+}
+function transformLogicalAndAssignmentExpression(state, left, right) {
+    const writable = (0, transformWritable_1.transformWritableExpression)(state, left, true);
+    const [value, valuePreqreqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, right));
+    const conditionId = state.pushToVar(writable, "condition");
+    const ifStatements = luau_ast_1.default.list.make();
+    luau_ast_1.default.list.pushList(ifStatements, valuePreqreqs);
+    luau_ast_1.default.list.push(ifStatements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: conditionId,
+        operator: "=",
+        right: value,
+    }));
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+        condition: (0, createTruthinessChecks_1.createTruthinessChecks)(state, writable, left),
+        statements: ifStatements,
+        elseBody: luau_ast_1.default.list.make(),
+    }));
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: writable,
+        operator: "=",
+        right: conditionId,
+    }));
+    return writable;
+}
+function transformLogicalOrAssignmentExpression(state, left, right) {
+    const writable = (0, transformWritable_1.transformWritableExpression)(state, left, true);
+    const [value, valuePreqreqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, right));
+    const conditionId = state.pushToVar(writable, "condition");
+    const ifStatements = luau_ast_1.default.list.make();
+    luau_ast_1.default.list.pushList(ifStatements, valuePreqreqs);
+    luau_ast_1.default.list.push(ifStatements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: conditionId,
+        operator: "=",
+        right: value,
+    }));
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+        condition: luau_ast_1.default.unary("not", (0, createTruthinessChecks_1.createTruthinessChecks)(state, writable, left)),
+        statements: ifStatements,
+        elseBody: luau_ast_1.default.list.make(),
+    }));
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: writable,
+        operator: "=",
+        right: conditionId,
+    }));
+    return writable;
+}
+function transformLogicalOrCoalescingAssignmentExpression(state, node) {
+    const operator = node.operatorToken.kind;
+    if (operator === typescript_1.default.SyntaxKind.QuestionQuestionEqualsToken) {
+        return transformCoalescingAssignmentExpression(state, node.left, node.right);
+    }
+    else if (operator === typescript_1.default.SyntaxKind.AmpersandAmpersandEqualsToken) {
+        return transformLogicalAndAssignmentExpression(state, node.left, node.right);
+    }
+    else {
+        return transformLogicalOrAssignmentExpression(state, node.left, node.right);
+    }
+}
+function transformLogicalOrCoalescingAssignmentExpressionStatement(state, node) {
+    return state.capturePrereqs(() => transformLogicalOrCoalescingAssignmentExpression(state, node));
+}
+//# sourceMappingURL=transformLogicalOrCoalescingAssignmentExpression.js.map

package/out/TSTransformer/nodes/transformMethodDeclaration.d.ts

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import { Pointer } from "../util/pointer";
+import ts from "typescript";
+export declare function transformMethodDeclaration(state: TransformState, node: ts.MethodDeclaration, ptr: Pointer<luau.Map | luau.AnyIdentifier>): luau.List<luau.Statement<luau.SyntaxKind>>;

package/out/TSTransformer/nodes/transformMethodDeclaration.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformMethodDeclaration = transformMethodDeclaration;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../Shared/diagnostics");
+const assert_1 = require("../../Shared/util/assert");
+const DiagnosticService_1 = require("../classes/DiagnosticService");
+const transformParameters_1 = require("./transformParameters");
+const transformPropertyName_1 = require("./transformPropertyName");
+const transformStatementList_1 = require("./transformStatementList");
+const isMethod_1 = require("../util/isMethod");
+const pointer_1 = require("../util/pointer");
+const wrapStatementsAsGenerator_1 = require("../util/wrapStatementsAsGenerator");
+const typescript_1 = __importDefault(require("typescript"));
+function transformMethodDeclaration(state, node, ptr) {
+    const result = luau_ast_1.default.list.make();
+    if (!node.body) {
+        return luau_ast_1.default.list.make();
+    }
+    (0, assert_1.assert)(node.name);
+    if (typescript_1.default.isPrivateIdentifier(node.name)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noPrivateIdentifier(node.name));
+        return luau_ast_1.default.list.make();
+    }
+    let { statements, parameters, hasDotDotDot } = (0, transformParameters_1.transformParameters)(state, node);
+    luau_ast_1.default.list.pushList(statements, (0, transformStatementList_1.transformStatementList)(state, node.body, node.body.statements));
+    let name = (0, transformPropertyName_1.transformPropertyName)(state, node.name);
+    if (typescript_1.default.hasDecorators(node) || node.parameters.some(parameter => typescript_1.default.hasDecorators(parameter))) {
+        if (!luau_ast_1.default.isSimplePrimitive(name)) {
+            const tempId = luau_ast_1.default.tempId("key");
+            luau_ast_1.default.list.push(result, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+                left: tempId,
+                right: name,
+            }));
+            name = tempId;
+        }
+        state.setClassElementObjectKey(node, name);
+    }
+    const isAsync = typescript_1.default.hasSyntacticModifier(node, typescript_1.default.ModifierFlags.Async);
+    if (node.asteriskToken) {
+        if (isAsync) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noAsyncGeneratorFunctions(node));
+        }
+        statements = (0, wrapStatementsAsGenerator_1.wrapStatementsAsGenerator)(state, node, statements);
+    }
+    if (!isAsync && luau_ast_1.default.isStringLiteral(name) && !luau_ast_1.default.isMap(ptr.value) && luau_ast_1.default.isValidIdentifier(name.value)) {
+        if ((0, isMethod_1.isMethod)(state, node)) {
+            luau_ast_1.default.list.shift(parameters);
+            luau_ast_1.default.list.push(result, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MethodDeclaration, {
+                expression: ptr.value,
+                name: name.value,
+                statements,
+                parameters,
+                hasDotDotDot,
+            }));
+        }
+        else {
+            luau_ast_1.default.list.push(result, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.FunctionDeclaration, {
+                name: luau_ast_1.default.property(ptr.value, name.value),
+                localize: false,
+                statements,
+                parameters,
+                hasDotDotDot,
+            }));
+        }
+        return result;
+    }
+    let expression = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.FunctionExpression, {
+        statements,
+        parameters,
+        hasDotDotDot,
+    });
+    if (isAsync) {
+        expression = luau_ast_1.default.call(state.TS(node, "async"), [expression]);
+    }
+    luau_ast_1.default.list.pushList(result, state.capturePrereqs(() => (0, pointer_1.assignToMapPointer)(state, ptr, name, expression)));
+    return result;
+}
+//# sourceMappingURL=transformMethodDeclaration.js.map

package/out/TSTransformer/nodes/transformOptionalChain.d.ts

@@ -0,0 +1,46 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+declare enum OptionalChainItemKind {
+    PropertyAccess = 0,
+    ElementAccess = 1,
+    Call = 2,
+    PropertyCall = 3,
+    ElementCall = 4
+}
+interface OptionalChainItem<T extends OptionalChainItemKind, U extends ts.Expression> {
+    kind: T;
+    node: U;
+    optional: boolean;
+    type: ts.Type;
+}
+interface PropertyAccessItem extends OptionalChainItem<OptionalChainItemKind.PropertyAccess, ts.PropertyAccessExpression> {
+    name: string;
+}
+interface ElementAccessItem extends OptionalChainItem<OptionalChainItemKind.ElementAccess, ts.ElementAccessExpression> {
+    expression: ts.Expression;
+}
+interface CallItem extends OptionalChainItem<OptionalChainItemKind.Call, ts.CallExpression> {
+    args: ReadonlyArray<ts.Expression>;
+}
+interface PropertyCallItem extends OptionalChainItem<OptionalChainItemKind.PropertyCall, ts.CallExpression> {
+    expression: ts.PropertyAccessExpression;
+    name: string;
+    callOptional: boolean;
+    callType: ts.Type;
+    args: ReadonlyArray<ts.Expression>;
+}
+interface ElementCallItem extends OptionalChainItem<OptionalChainItemKind.ElementCall, ts.CallExpression> {
+    expression: ts.ElementAccessExpression;
+    argumentExpression: ts.Expression;
+    callOptional: boolean;
+    callType: ts.Type;
+    args: ReadonlyArray<ts.Expression>;
+}
+type ChainItem = PropertyAccessItem | ElementAccessItem | CallItem | PropertyCallItem | ElementCallItem;
+export declare function flattenOptionalChain(state: TransformState, expression: ts.Expression): {
+    chain: ChainItem[];
+    expression: ts.Expression;
+};
+export declare function transformOptionalChain(state: TransformState, node: ts.PropertyAccessExpression | ts.ElementAccessExpression | ts.CallExpression): luau.Expression;
+export {};