@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/TSTransformer/nodes/class/transformClassLikeDeclaration.js

@@ -0,0 +1,262 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformClassLikeDeclaration = transformClassLikeDeclaration;
+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 transformClassConstructor_1 = require("./transformClassConstructor");
+const transformDecorators_1 = require("./transformDecorators");
+const transformPropertyDeclaration_1 = require("./transformPropertyDeclaration");
+const transformExpression_1 = require("../expressions/transformExpression");
+const transformIdentifier_1 = require("../expressions/transformIdentifier");
+const transformBlock_1 = require("../statements/transformBlock");
+const transformMethodDeclaration_1 = require("../transformMethodDeclaration");
+const findConstructor_1 = require("../../util/findConstructor");
+const getExtendsNode_1 = require("../../util/getExtendsNode");
+const getKindName_1 = require("../../util/getKindName");
+const validateIdentifier_1 = require("../../util/validateIdentifier");
+const validateMethodAssignment_1 = require("../../util/validateMethodAssignment");
+const typescript_1 = __importDefault(require("typescript"));
+const MAGIC_TO_STRING_METHOD = "toString";
+function createNameFunction(name) {
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.FunctionExpression, {
+        statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+            expression: luau_ast_1.default.string(name),
+        })),
+        parameters: luau_ast_1.default.list.make(),
+        hasDotDotDot: false,
+    });
+}
+function createBoilerplate(state, node, className, isClassExpression) {
+    const isAbstract = typescript_1.default.hasAbstractModifier(node);
+    const statements = luau_ast_1.default.list.make();
+    const extendsNode = (0, getExtendsNode_1.getExtendsNode)(node);
+    if (isAbstract && !extendsNode) {
+        luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+            left: className,
+            operator: "=",
+            right: luau_ast_1.default.map(),
+        }));
+    }
+    else {
+        const metatableFields = luau_ast_1.default.list.make();
+        luau_ast_1.default.list.push(metatableFields, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MapField, {
+            index: luau_ast_1.default.strings.__tostring,
+            value: createNameFunction(luau_ast_1.default.isTemporaryIdentifier(className) ? "Anonymous" : className.name),
+        }));
+        if (extendsNode) {
+            const [extendsExp, extendsExpPrereqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, extendsNode.expression));
+            const superId = luau_ast_1.default.id("super");
+            luau_ast_1.default.list.pushList(statements, extendsExpPrereqs);
+            luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+                left: superId,
+                right: extendsExp,
+            }));
+            luau_ast_1.default.list.push(metatableFields, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MapField, {
+                index: luau_ast_1.default.strings.__index,
+                value: superId,
+            }));
+        }
+        const metatable = luau_ast_1.default.call(luau_ast_1.default.globals.setmetatable, [
+            luau_ast_1.default.map(),
+            luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Map, { fields: metatableFields }),
+        ]);
+        if (isClassExpression && node.name) {
+            luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+                left: (0, transformIdentifier_1.transformIdentifierDefined)(state, node.name),
+                right: metatable,
+            }));
+        }
+        else {
+            luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: className,
+                operator: "=",
+                right: metatable,
+            }));
+        }
+        luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+            left: luau_ast_1.default.property(className, "__index"),
+            operator: "=",
+            right: className,
+        }));
+    }
+    if (!isAbstract) {
+        const statementsInner = luau_ast_1.default.list.make();
+        luau_ast_1.default.list.push(statementsInner, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: luau_ast_1.default.globals.self,
+            right: luau_ast_1.default.call(luau_ast_1.default.globals.setmetatable, [luau_ast_1.default.map(), className]),
+        }));
+        luau_ast_1.default.list.push(statementsInner, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+            expression: luau_ast_1.default.binary(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MethodCallExpression, {
+                expression: luau_ast_1.default.globals.self,
+                name: "constructor",
+                args: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VarArgsLiteral, {})),
+            }), "or", luau_ast_1.default.globals.self),
+        }));
+        luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.FunctionDeclaration, {
+            name: luau_ast_1.default.property(className, "new"),
+            parameters: luau_ast_1.default.list.make(),
+            hasDotDotDot: true,
+            statements: statementsInner,
+            localize: false,
+        }));
+    }
+    return statements;
+}
+function isClassHoisted(state, node) {
+    if (node.name) {
+        const symbol = state.typeChecker.getSymbolAtLocation(node.name);
+        (0, assert_1.assert)(symbol);
+        return state.isHoisted.get(symbol) === true;
+    }
+    return false;
+}
+function transformClassLikeDeclaration(state, node) {
+    const isClassExpression = typescript_1.default.isClassExpression(node);
+    const statements = luau_ast_1.default.list.make();
+    const isExportDefault = typescript_1.default.hasSyntacticModifier(node, typescript_1.default.ModifierFlags.ExportDefault);
+    if (node.name) {
+        (0, validateIdentifier_1.validateIdentifier)(state, node.name);
+    }
+    const shouldUseInternalName = isClassExpression && node.name !== undefined;
+    let returnVar;
+    if (shouldUseInternalName) {
+        returnVar = luau_ast_1.default.tempId("class");
+    }
+    else if (node.name) {
+        returnVar = (0, transformIdentifier_1.transformIdentifierDefined)(state, node.name);
+    }
+    else if (isExportDefault) {
+        returnVar = luau_ast_1.default.id("default");
+    }
+    else {
+        returnVar = luau_ast_1.default.tempId("class");
+    }
+    let internalName;
+    if (shouldUseInternalName) {
+        internalName = (0, transformIdentifier_1.transformIdentifierDefined)(state, node.name);
+    }
+    else {
+        internalName = returnVar;
+    }
+    state.classIdentifierMap.set(node, internalName);
+    if (!isClassHoisted(state, node)) {
+        luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: returnVar,
+            right: undefined,
+        }));
+    }
+    const statementsInner = luau_ast_1.default.list.make();
+    luau_ast_1.default.list.pushList(statementsInner, createBoilerplate(state, node, internalName, isClassExpression));
+    const constructor = (0, findConstructor_1.findConstructor)(node);
+    if (constructor) {
+        luau_ast_1.default.list.pushList(statementsInner, (0, transformClassConstructor_1.transformClassConstructor)(state, constructor, internalName));
+    }
+    else {
+        luau_ast_1.default.list.pushList(statementsInner, (0, transformClassConstructor_1.transformImplicitClassConstructor)(state, node, internalName));
+    }
+    for (const member of node.members) {
+        if ((typescript_1.default.isPropertyDeclaration(member) || typescript_1.default.isMethodDeclaration(member)) &&
+            (typescript_1.default.isIdentifier(member.name) || typescript_1.default.isStringLiteral(member.name)) &&
+            luau_ast_1.default.isReservedClassField(member.name.text)) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noReservedClassFields(member.name));
+        }
+        if (typescript_1.default.isAutoAccessorPropertyDeclaration(member)) {
+            const keyword = typescript_1.default.getModifiers(member).find(m => m.kind === typescript_1.default.SyntaxKind.AccessorKeyword);
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noAutoAccessorModifiers(keyword));
+        }
+    }
+    const methods = new Array();
+    const staticDeclarations = new Array();
+    for (const member of node.members) {
+        (0, validateMethodAssignment_1.validateMethodAssignment)(state, member);
+        if (typescript_1.default.isConstructorDeclaration(member) ||
+            typescript_1.default.isIndexSignatureDeclaration(member) ||
+            typescript_1.default.isSemicolonClassElement(member)) {
+            continue;
+        }
+        else if (typescript_1.default.isMethodDeclaration(member)) {
+            methods.push(member);
+        }
+        else if (typescript_1.default.isPropertyDeclaration(member)) {
+            if (!typescript_1.default.hasStaticModifier(member)) {
+                continue;
+            }
+            staticDeclarations.push(member);
+        }
+        else if (typescript_1.default.isAccessor(member)) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noGetterSetter(member));
+        }
+        else if (typescript_1.default.isClassStaticBlockDeclaration(member)) {
+            staticDeclarations.push(member);
+        }
+        else {
+            (0, assert_1.assert)(false, `ClassMember kind not implemented: ${(0, getKindName_1.getKindName)(member.kind)}`);
+        }
+    }
+    const classType = state.typeChecker.getTypeOfSymbolAtLocation(node.symbol, node);
+    const instanceType = state.typeChecker.getDeclaredTypeOfSymbol(node.symbol);
+    for (const method of methods) {
+        if (typescript_1.default.isIdentifier(method.name) || typescript_1.default.isStringLiteral(method.name)) {
+            if (luau_ast_1.default.isMetamethod(method.name.text)) {
+                DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noClassMetamethods(method.name));
+            }
+            if (typescript_1.default.hasStaticModifier(method)) {
+                if (instanceType.getProperty(method.name.text) !== undefined) {
+                    DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noInstanceMethodCollisions(method));
+                }
+            }
+            else {
+                if (classType.getProperty(method.name.text) !== undefined) {
+                    DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noStaticMethodCollisions(method));
+                }
+            }
+        }
+        const [statements, prereqs] = state.capture(() => (0, transformMethodDeclaration_1.transformMethodDeclaration)(state, method, { name: "name", value: internalName }));
+        luau_ast_1.default.list.pushList(statementsInner, prereqs);
+        luau_ast_1.default.list.pushList(statementsInner, statements);
+    }
+    const toStringProperty = instanceType.getProperty(MAGIC_TO_STRING_METHOD);
+    if (toStringProperty && !!(toStringProperty.flags & typescript_1.default.SymbolFlags.Method)) {
+        luau_ast_1.default.list.push(statementsInner, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MethodDeclaration, {
+            expression: internalName,
+            name: "__tostring",
+            hasDotDotDot: false,
+            parameters: luau_ast_1.default.list.make(),
+            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+                expression: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MethodCallExpression, {
+                    expression: luau_ast_1.default.globals.self,
+                    name: MAGIC_TO_STRING_METHOD,
+                    args: luau_ast_1.default.list.make(),
+                }),
+            })),
+        }));
+    }
+    for (const declaration of staticDeclarations) {
+        if (typescript_1.default.isClassStaticBlockDeclaration(declaration)) {
+            luau_ast_1.default.list.pushList(statementsInner, (0, transformBlock_1.transformBlock)(state, declaration.body));
+        }
+        else {
+            const [statements, prereqs] = state.capture(() => (0, transformPropertyDeclaration_1.transformPropertyDeclaration)(state, declaration, internalName));
+            luau_ast_1.default.list.pushList(statementsInner, prereqs);
+            luau_ast_1.default.list.pushList(statementsInner, statements);
+        }
+    }
+    if (shouldUseInternalName) {
+        luau_ast_1.default.list.push(statementsInner, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+            left: returnVar,
+            operator: "=",
+            right: internalName,
+        }));
+    }
+    luau_ast_1.default.list.pushList(statementsInner, (0, transformDecorators_1.transformDecorators)(state, node, returnVar));
+    luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.DoStatement, {
+        statements: statementsInner,
+    }));
+    return { statements, name: returnVar };
+}
+//# sourceMappingURL=transformClassLikeDeclaration.js.map

package/out/TSTransformer/nodes/class/transformDecorators.d.ts

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

package/out/TSTransformer/nodes/class/transformDecorators.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformDecorators = transformDecorators;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const assert_1 = require("../../../Shared/util/assert");
+const transformExpression_1 = require("../expressions/transformExpression");
+const transformPropertyName_1 = require("../transformPropertyName");
+const convertToIndexableExpression_1 = require("../../util/convertToIndexableExpression");
+const expressionMightMutate_1 = require("../../util/expressionMightMutate");
+const findConstructor_1 = require("../../util/findConstructor");
+const typescript_1 = __importDefault(require("typescript"));
+function countDecorators(node) {
+    var _a, _b;
+    return (_b = (_a = typescript_1.default.getDecorators(node)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+}
+function shouldInline(state, isLastDecorator, decorator, expression) {
+    if (!(0, expressionMightMutate_1.expressionMightMutate)(state, expression, decorator.expression))
+        return true;
+    if (!isLastDecorator)
+        return false;
+    const node = decorator.parent;
+    if (typescript_1.default.isMethodDeclaration(node) && node.parameters.some(parameter => countDecorators(parameter) > 0))
+        return false;
+    if (typescript_1.default.isClassLike(node)) {
+        const constructor = (0, findConstructor_1.findConstructor)(node);
+        if (constructor && constructor.parameters.some(parameter => countDecorators(parameter) > 0))
+            return false;
+    }
+    if (typescript_1.default.isParameter(node)) {
+        const parameters = node.parent.parameters;
+        const paramIdx = parameters.findIndex(param => param === node);
+        for (let i = paramIdx + 1; i < parameters.length; i++) {
+            if (countDecorators(parameters[i]) > 0) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function transformMemberDecorators(state, node, callback) {
+    var _a;
+    const initializers = luau_ast_1.default.list.make();
+    const finalizers = luau_ast_1.default.list.make();
+    const decorators = (_a = typescript_1.default.getDecorators(node)) !== null && _a !== void 0 ? _a : [];
+    for (let i = 0; i < decorators.length; i++) {
+        const decorator = decorators[i];
+        let [expression, prereqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, decorator.expression));
+        luau_ast_1.default.list.pushList(initializers, prereqs);
+        const isLastDecorator = i === decorators.length - 1;
+        if (!shouldInline(state, isLastDecorator, decorator, expression)) {
+            const tempId = luau_ast_1.default.tempId("decorator");
+            luau_ast_1.default.list.push(initializers, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+                left: tempId,
+                right: expression,
+            }));
+            expression = tempId;
+        }
+        luau_ast_1.default.list.unshiftList(finalizers, callback((0, convertToIndexableExpression_1.convertToIndexableExpression)(expression)));
+    }
+    return [initializers, finalizers];
+}
+function transformMethodDecorators(state, member, classId) {
+    const [initializers, finalizers] = transformMemberDecorators(state, member, expression => {
+        const result = luau_ast_1.default.list.make();
+        const descriptorId = luau_ast_1.default.tempId("descriptor");
+        const key = state.getClassElementObjectKey(member);
+        (0, assert_1.assert)(key, "Did not find method key for method decorator");
+        luau_ast_1.default.list.push(result, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: descriptorId,
+            right: luau_ast_1.default.call(expression, [
+                classId,
+                key,
+                luau_ast_1.default.map([
+                    [
+                        luau_ast_1.default.string("value"),
+                        luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                            expression: classId,
+                            index: key,
+                        }),
+                    ],
+                ]),
+            ]),
+        }));
+        luau_ast_1.default.list.push(result, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+            condition: descriptorId,
+            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                    expression: classId,
+                    index: key,
+                }),
+                operator: "=",
+                right: luau_ast_1.default.property(descriptorId, "value"),
+            })),
+            elseBody: luau_ast_1.default.list.make(),
+        }));
+        return result;
+    });
+    const result = luau_ast_1.default.list.make();
+    luau_ast_1.default.list.pushList(result, initializers);
+    luau_ast_1.default.list.pushList(result, transformParameterDecorators(state, member, classId));
+    luau_ast_1.default.list.pushList(result, finalizers);
+    return result;
+}
+function transformPropertyDecorators(state, member, classId) {
+    const [initializers, finalizers] = transformMemberDecorators(state, member, expression => {
+        const key = state.noPrereqs(() => (0, transformPropertyName_1.transformPropertyName)(state, member.name));
+        return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+            expression: luau_ast_1.default.call(expression, [classId, key]),
+        }));
+    });
+    const result = luau_ast_1.default.list.make();
+    luau_ast_1.default.list.pushList(result, initializers);
+    luau_ast_1.default.list.pushList(result, finalizers);
+    return result;
+}
+function transformParameterDecorators(state, member, classId) {
+    const initializers = luau_ast_1.default.list.make();
+    const finalizers = luau_ast_1.default.list.make();
+    for (let i = 0; i < member.parameters.length; i++) {
+        const parameter = member.parameters[i];
+        const [paramInitializers, paramFinalizers] = transformMemberDecorators(state, parameter, expression => {
+            const key = member.name ? state.getClassElementObjectKey(member) : luau_ast_1.default.nil();
+            (0, assert_1.assert)(key, "Did not find method key for parameter decorator");
+            return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+                expression: luau_ast_1.default.call(expression, [classId, key, luau_ast_1.default.number(i)]),
+            }));
+        });
+        luau_ast_1.default.list.pushList(initializers, paramInitializers);
+        luau_ast_1.default.list.unshiftList(finalizers, paramFinalizers);
+    }
+    const result = luau_ast_1.default.list.make();
+    luau_ast_1.default.list.pushList(result, initializers);
+    luau_ast_1.default.list.pushList(result, finalizers);
+    return result;
+}
+function transformClassDecorators(state, node, classId) {
+    const [initializers, finalizers] = transformMemberDecorators(state, node, expression => luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: classId,
+        operator: "=",
+        right: luau_ast_1.default.binary(luau_ast_1.default.call(expression, [classId]), "or", classId),
+    })));
+    const result = luau_ast_1.default.list.make();
+    luau_ast_1.default.list.pushList(result, initializers);
+    const constructor = (0, findConstructor_1.findConstructor)(node);
+    if (constructor) {
+        luau_ast_1.default.list.pushList(result, transformParameterDecorators(state, constructor, classId));
+    }
+    luau_ast_1.default.list.pushList(result, finalizers);
+    return result;
+}
+function transformDecorators(state, node, classId) {
+    const result = luau_ast_1.default.list.make();
+    for (const member of node.members) {
+        if (!typescript_1.default.hasStaticModifier(member)) {
+            if (typescript_1.default.isMethodDeclaration(member) && member.body) {
+                luau_ast_1.default.list.pushList(result, transformMethodDecorators(state, member, classId));
+            }
+            else if (typescript_1.default.isPropertyDeclaration(member)) {
+                luau_ast_1.default.list.pushList(result, transformPropertyDecorators(state, member, classId));
+            }
+        }
+    }
+    for (const member of node.members) {
+        if (typescript_1.default.hasStaticModifier(member)) {
+            if (typescript_1.default.isMethodDeclaration(member) && member.body) {
+                luau_ast_1.default.list.pushList(result, transformMethodDecorators(state, member, classId));
+            }
+            else if (typescript_1.default.isPropertyDeclaration(member)) {
+                luau_ast_1.default.list.pushList(result, transformPropertyDecorators(state, member, classId));
+            }
+        }
+    }
+    luau_ast_1.default.list.pushList(result, transformClassDecorators(state, node, classId));
+    return result;
+}
+//# sourceMappingURL=transformDecorators.js.map

package/out/TSTransformer/nodes/class/transformPropertyDeclaration.d.ts

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

package/out/TSTransformer/nodes/class/transformPropertyDeclaration.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformPropertyDeclaration = transformPropertyDeclaration;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformExpression_1 = require("../expressions/transformExpression");
+const transformPropertyName_1 = require("../transformPropertyName");
+const typescript_1 = __importDefault(require("typescript"));
+function transformPropertyDeclaration(state, node, name) {
+    if (!typescript_1.default.hasStaticModifier(node)) {
+        return luau_ast_1.default.list.make();
+    }
+    if (typescript_1.default.isPrivateIdentifier(node.name)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noPrivateIdentifier(node));
+        return luau_ast_1.default.list.make();
+    }
+    if (!node.initializer) {
+        return luau_ast_1.default.list.make();
+    }
+    return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+            expression: name,
+            index: (0, transformPropertyName_1.transformPropertyName)(state, node.name),
+        }),
+        operator: "=",
+        right: (0, transformExpression_1.transformExpression)(state, node.initializer),
+    }));
+}
+//# sourceMappingURL=transformPropertyDeclaration.js.map

package/out/TSTransformer/nodes/expressions/transformArrayLiteralExpression.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformArrayLiteralExpression(state: TransformState, node: ts.ArrayLiteralExpression): luau.TemporaryIdentifier | luau.Array;

package/out/TSTransformer/nodes/expressions/transformArrayLiteralExpression.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArrayLiteralExpression = transformArrayLiteralExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const assert_1 = require("../../../Shared/util/assert");
+const transformExpression_1 = require("./transformExpression");
+const ensureTransformOrder_1 = require("../../util/ensureTransformOrder");
+const getAddIterableToArrayBuilder_1 = require("../../util/getAddIterableToArrayBuilder");
+const pointer_1 = require("../../util/pointer");
+const typescript_1 = __importDefault(require("typescript"));
+function transformArrayLiteralExpression(state, node) {
+    if (!node.elements.find(element => typescript_1.default.isSpreadElement(element))) {
+        return luau_ast_1.default.array((0, ensureTransformOrder_1.ensureTransformOrder)(state, node.elements));
+    }
+    const ptr = (0, pointer_1.createArrayPointer)("array");
+    const lengthId = luau_ast_1.default.tempId("length");
+    let lengthInitialized = false;
+    let amtElementsSinceUpdate = 0;
+    function updateLengthId() {
+        const right = luau_ast_1.default.unary("#", ptr.value);
+        if (lengthInitialized) {
+            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: lengthId,
+                operator: "=",
+                right,
+            }));
+        }
+        else {
+            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+                left: lengthId,
+                right,
+            }));
+            lengthInitialized = true;
+        }
+        amtElementsSinceUpdate = 0;
+    }
+    for (let i = 0; i < node.elements.length; i++) {
+        const element = node.elements[i];
+        if (typescript_1.default.isSpreadElement(element)) {
+            if (luau_ast_1.default.isArray(ptr.value)) {
+                (0, pointer_1.disableArrayInline)(state, ptr);
+                updateLengthId();
+            }
+            (0, assert_1.assert)(luau_ast_1.default.isAnyIdentifier(ptr.value));
+            const type = state.getType(element.expression);
+            const addIterableToArrayBuilder = (0, getAddIterableToArrayBuilder_1.getAddIterableToArrayBuilder)(state, element.expression, type);
+            const spreadExp = (0, transformExpression_1.transformExpression)(state, element.expression);
+            const shouldUpdateLengthId = i < node.elements.length - 1;
+            state.prereqList(addIterableToArrayBuilder(state, spreadExp, ptr.value, lengthId, amtElementsSinceUpdate, shouldUpdateLengthId));
+        }
+        else {
+            const [expression, prereqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, element));
+            if (luau_ast_1.default.isArray(ptr.value) && !luau_ast_1.default.list.isEmpty(prereqs)) {
+                (0, pointer_1.disableArrayInline)(state, ptr);
+                updateLengthId();
+            }
+            if (luau_ast_1.default.isArray(ptr.value)) {
+                luau_ast_1.default.list.push(ptr.value.members, expression);
+            }
+            else {
+                state.prereqList(prereqs);
+                state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                    left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                        expression: ptr.value,
+                        index: luau_ast_1.default.binary(lengthId, "+", luau_ast_1.default.number(amtElementsSinceUpdate + 1)),
+                    }),
+                    operator: "=",
+                    right: expression,
+                }));
+            }
+            amtElementsSinceUpdate++;
+        }
+    }
+    return ptr.value;
+}
+//# sourceMappingURL=transformArrayLiteralExpression.js.map

package/out/TSTransformer/nodes/expressions/transformAwaitExpression.d.ts

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

package/out/TSTransformer/nodes/expressions/transformAwaitExpression.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformAwaitExpression = transformAwaitExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./transformExpression");
+const traversal_1 = require("../../util/traversal");
+function transformAwaitExpression(state, node) {
+    return luau_ast_1.default.call(state.TS(node, "await"), [(0, transformExpression_1.transformExpression)(state, (0, traversal_1.skipDownwards)(node.expression))]);
+}
+//# sourceMappingURL=transformAwaitExpression.js.map

package/out/TSTransformer/nodes/expressions/transformBinaryExpression.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformBinaryExpression(state: TransformState, node: ts.BinaryExpression): luau.Identifier | luau.TemporaryIdentifier | luau.ComputedIndexExpression | luau.PropertyAccessExpression | luau.CallExpression | luau.MethodCallExpression | luau.ParenthesizedExpression | luau.None | luau.NilLiteral | luau.FalseLiteral | luau.TrueLiteral | luau.NumberLiteral | luau.StringLiteral | luau.VarArgsLiteral | luau.FunctionExpression | luau.BinaryExpression | luau.UnaryExpression | luau.IfExpression | luau.InterpolatedString | luau.Array | luau.Map | luau.Set | luau.MixedTable;