@jackctaylor/roblox-ts 3.0.0-projectrefs.0

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

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformExpression = transformExpression;
+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 transformArrayLiteralExpression_1 = require("./transformArrayLiteralExpression");
+const transformAwaitExpression_1 = require("./transformAwaitExpression");
+const transformBinaryExpression_1 = require("./transformBinaryExpression");
+const transformBooleanLiteral_1 = require("./transformBooleanLiteral");
+const transformCallExpression_1 = require("./transformCallExpression");
+const transformClassExpression_1 = require("./transformClassExpression");
+const transformConditionalExpression_1 = require("./transformConditionalExpression");
+const transformDeleteExpression_1 = require("./transformDeleteExpression");
+const transformElementAccessExpression_1 = require("./transformElementAccessExpression");
+const transformFunctionExpression_1 = require("./transformFunctionExpression");
+const transformIdentifier_1 = require("./transformIdentifier");
+const transformJsxElement_1 = require("./transformJsxElement");
+const transformJsxExpression_1 = require("./transformJsxExpression");
+const transformJsxFragment_1 = require("./transformJsxFragment");
+const transformJsxSelfClosingElement_1 = require("./transformJsxSelfClosingElement");
+const transformNewExpression_1 = require("./transformNewExpression");
+const transformNoSubstitutionTemplateLiteral_1 = require("./transformNoSubstitutionTemplateLiteral");
+const transformNumericLiteral_1 = require("./transformNumericLiteral");
+const transformObjectLiteralExpression_1 = require("./transformObjectLiteralExpression");
+const transformOmittedExpression_1 = require("./transformOmittedExpression");
+const transformParenthesizedExpression_1 = require("./transformParenthesizedExpression");
+const transformPropertyAccessExpression_1 = require("./transformPropertyAccessExpression");
+const transformSpreadElement_1 = require("./transformSpreadElement");
+const transformStringLiteral_1 = require("./transformStringLiteral");
+const transformSuperKeyword_1 = require("./transformSuperKeyword");
+const transformTaggedTemplateExpression_1 = require("./transformTaggedTemplateExpression");
+const transformTemplateExpression_1 = require("./transformTemplateExpression");
+const transformThisExpression_1 = require("./transformThisExpression");
+const transformTypeExpression_1 = require("./transformTypeExpression");
+const transformUnaryExpression_1 = require("./transformUnaryExpression");
+const transformVoidExpression_1 = require("./transformVoidExpression");
+const transformYieldExpression_1 = require("./transformYieldExpression");
+const getKindName_1 = require("../../util/getKindName");
+const typescript_1 = __importDefault(require("typescript"));
+const NO_EMIT = () => luau_ast_1.default.none();
+const DIAGNOSTIC = (factory) => (state, node) => {
+    DiagnosticService_1.DiagnosticService.addDiagnostic(factory(node));
+    return NO_EMIT();
+};
+function createTransformerMap(values) {
+    return new Map(values);
+}
+const TRANSFORMER_BY_KIND = createTransformerMap([
+    [typescript_1.default.SyntaxKind.BigIntLiteral, DIAGNOSTIC(diagnostics_1.errors.noBigInt)],
+    [typescript_1.default.SyntaxKind.NullKeyword, DIAGNOSTIC(diagnostics_1.errors.noNullLiteral)],
+    [typescript_1.default.SyntaxKind.PrivateIdentifier, DIAGNOSTIC(diagnostics_1.errors.noPrivateIdentifier)],
+    [typescript_1.default.SyntaxKind.RegularExpressionLiteral, DIAGNOSTIC(diagnostics_1.errors.noRegex)],
+    [typescript_1.default.SyntaxKind.TypeOfExpression, DIAGNOSTIC(diagnostics_1.errors.noTypeOfExpression)],
+    [typescript_1.default.SyntaxKind.ImportKeyword, NO_EMIT],
+    [typescript_1.default.SyntaxKind.ArrayLiteralExpression, transformArrayLiteralExpression_1.transformArrayLiteralExpression],
+    [typescript_1.default.SyntaxKind.ArrowFunction, transformFunctionExpression_1.transformFunctionExpression],
+    [typescript_1.default.SyntaxKind.AsExpression, transformTypeExpression_1.transformTypeExpression],
+    [typescript_1.default.SyntaxKind.AwaitExpression, transformAwaitExpression_1.transformAwaitExpression],
+    [typescript_1.default.SyntaxKind.BinaryExpression, transformBinaryExpression_1.transformBinaryExpression],
+    [typescript_1.default.SyntaxKind.CallExpression, transformCallExpression_1.transformCallExpression],
+    [typescript_1.default.SyntaxKind.ClassExpression, transformClassExpression_1.transformClassExpression],
+    [typescript_1.default.SyntaxKind.ConditionalExpression, transformConditionalExpression_1.transformConditionalExpression],
+    [typescript_1.default.SyntaxKind.DeleteExpression, transformDeleteExpression_1.transformDeleteExpression],
+    [typescript_1.default.SyntaxKind.ElementAccessExpression, transformElementAccessExpression_1.transformElementAccessExpression],
+    [typescript_1.default.SyntaxKind.ExpressionWithTypeArguments, transformTypeExpression_1.transformTypeExpression],
+    [typescript_1.default.SyntaxKind.FalseKeyword, transformBooleanLiteral_1.transformFalseKeyword],
+    [typescript_1.default.SyntaxKind.FunctionExpression, transformFunctionExpression_1.transformFunctionExpression],
+    [typescript_1.default.SyntaxKind.Identifier, transformIdentifier_1.transformIdentifier],
+    [typescript_1.default.SyntaxKind.JsxElement, transformJsxElement_1.transformJsxElement],
+    [typescript_1.default.SyntaxKind.JsxExpression, transformJsxExpression_1.transformJsxExpression],
+    [typescript_1.default.SyntaxKind.JsxFragment, transformJsxFragment_1.transformJsxFragment],
+    [typescript_1.default.SyntaxKind.JsxSelfClosingElement, transformJsxSelfClosingElement_1.transformJsxSelfClosingElement],
+    [typescript_1.default.SyntaxKind.NewExpression, transformNewExpression_1.transformNewExpression],
+    [typescript_1.default.SyntaxKind.NonNullExpression, transformTypeExpression_1.transformTypeExpression],
+    [typescript_1.default.SyntaxKind.NoSubstitutionTemplateLiteral, transformNoSubstitutionTemplateLiteral_1.transformNoSubstitutionTemplateLiteral],
+    [typescript_1.default.SyntaxKind.NumericLiteral, transformNumericLiteral_1.transformNumericLiteral],
+    [typescript_1.default.SyntaxKind.ObjectLiteralExpression, transformObjectLiteralExpression_1.transformObjectLiteralExpression],
+    [typescript_1.default.SyntaxKind.OmittedExpression, transformOmittedExpression_1.transformOmittedExpression],
+    [typescript_1.default.SyntaxKind.ParenthesizedExpression, transformParenthesizedExpression_1.transformParenthesizedExpression],
+    [typescript_1.default.SyntaxKind.PostfixUnaryExpression, transformUnaryExpression_1.transformPostfixUnaryExpression],
+    [typescript_1.default.SyntaxKind.PrefixUnaryExpression, transformUnaryExpression_1.transformPrefixUnaryExpression],
+    [typescript_1.default.SyntaxKind.PropertyAccessExpression, transformPropertyAccessExpression_1.transformPropertyAccessExpression],
+    [typescript_1.default.SyntaxKind.SatisfiesExpression, transformTypeExpression_1.transformTypeExpression],
+    [typescript_1.default.SyntaxKind.SpreadElement, transformSpreadElement_1.transformSpreadElement],
+    [typescript_1.default.SyntaxKind.StringLiteral, transformStringLiteral_1.transformStringLiteral],
+    [typescript_1.default.SyntaxKind.SuperKeyword, transformSuperKeyword_1.transformSuperKeyword],
+    [typescript_1.default.SyntaxKind.TaggedTemplateExpression, transformTaggedTemplateExpression_1.transformTaggedTemplateExpression],
+    [typescript_1.default.SyntaxKind.TemplateExpression, transformTemplateExpression_1.transformTemplateExpression],
+    [typescript_1.default.SyntaxKind.ThisKeyword, transformThisExpression_1.transformThisExpression],
+    [typescript_1.default.SyntaxKind.TrueKeyword, transformBooleanLiteral_1.transformTrueKeyword],
+    [typescript_1.default.SyntaxKind.TypeAssertionExpression, transformTypeExpression_1.transformTypeExpression],
+    [typescript_1.default.SyntaxKind.VoidExpression, transformVoidExpression_1.transformVoidExpression],
+    [typescript_1.default.SyntaxKind.YieldExpression, transformYieldExpression_1.transformYieldExpression],
+]);
+function transformExpression(state, node) {
+    const transformer = TRANSFORMER_BY_KIND.get(node.kind);
+    if (transformer) {
+        return transformer(state, node);
+    }
+    (0, assert_1.assert)(false, `Unknown expression: ${(0, getKindName_1.getKindName)(node.kind)}`);
+}
+//# sourceMappingURL=transformExpression.js.map

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

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

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

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFunctionExpression = transformFunctionExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformReturnStatement_1 = require("../statements/transformReturnStatement");
+const transformParameters_1 = require("../transformParameters");
+const transformStatementList_1 = require("../transformStatementList");
+const wrapStatementsAsGenerator_1 = require("../../util/wrapStatementsAsGenerator");
+const typescript_1 = __importDefault(require("typescript"));
+function transformFunctionExpression(state, node) {
+    if (node.name) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noFunctionExpressionName(node.name));
+    }
+    let { statements, parameters, hasDotDotDot } = (0, transformParameters_1.transformParameters)(state, node);
+    const body = node.body;
+    if (typescript_1.default.isFunctionBody(body)) {
+        luau_ast_1.default.list.pushList(statements, (0, transformStatementList_1.transformStatementList)(state, body, body.statements));
+    }
+    else {
+        const [returnStatements, prereqs] = state.capture(() => (0, transformReturnStatement_1.transformReturnStatementInner)(state, body));
+        luau_ast_1.default.list.pushList(statements, prereqs);
+        luau_ast_1.default.list.pushList(statements, returnStatements);
+    }
+    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);
+    }
+    let expression = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.FunctionExpression, {
+        hasDotDotDot,
+        parameters,
+        statements,
+    });
+    if (isAsync) {
+        expression = luau_ast_1.default.call(state.TS(node, "async"), [expression]);
+    }
+    return expression;
+}
+//# sourceMappingURL=transformFunctionExpression.js.map

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

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformIdentifierDefined(state: TransformState, node: ts.Identifier): luau.Identifier | luau.TemporaryIdentifier;
+export declare function transformIdentifier(state: TransformState, node: ts.Identifier): luau.Expression<luau.SyntaxKind>;

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

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformIdentifierDefined = transformIdentifierDefined;
+exports.transformIdentifier = transformIdentifier;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const assert_1 = require("../../../Shared/util/assert");
+const getOrSetDefault_1 = require("../../../Shared/util/getOrSetDefault");
+const TSTransformer_1 = require("../..");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const typeGuards_1 = require("../../typeGuards");
+const getExtendsNode_1 = require("../../util/getExtendsNode");
+const isSymbolMutable_1 = require("../../util/isSymbolMutable");
+const traversal_1 = require("../../util/traversal");
+const types_1 = require("../../util/types");
+const typescript_1 = __importDefault(require("typescript"));
+function transformIdentifierDefined(state, node) {
+    const symbol = typescript_1.default.isShorthandPropertyAssignment(node.parent)
+        ? state.typeChecker.getShorthandAssignmentValueSymbol(node.parent)
+        : state.typeChecker.getSymbolAtLocation(node);
+    (0, assert_1.assert)(symbol);
+    const replacementId = state.symbolToIdMap.get(symbol);
+    if (replacementId) {
+        return replacementId;
+    }
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Identifier, {
+        name: node.text,
+    });
+}
+function getAncestorWhichIsChildOf(parent, node) {
+    while (node.parent && node.parent !== parent) {
+        node = node.parent;
+    }
+    return node.parent ? node : undefined;
+}
+function getDeclarationFromImport(symbol) {
+    var _a;
+    for (const declaration of (_a = symbol.declarations) !== null && _a !== void 0 ? _a : []) {
+        const importDec = (0, traversal_1.getAncestor)(declaration, typescript_1.default.isAnyImportSyntax);
+        if (importDec) {
+            return declaration;
+        }
+    }
+}
+function checkIdentifierHoist(state, node, symbol) {
+    var _a;
+    if (state.isHoisted.get(symbol) !== undefined) {
+        return;
+    }
+    const declaration = (_a = symbol.valueDeclaration) !== null && _a !== void 0 ? _a : getDeclarationFromImport(symbol);
+    if (!declaration || (0, traversal_1.getAncestor)(declaration, typescript_1.default.isParameter) || typescript_1.default.isShorthandPropertyAssignment(declaration)) {
+        return;
+    }
+    if (typescript_1.default.isClassLike(declaration) && (0, traversal_1.isAncestorOf)(declaration, node)) {
+        return;
+    }
+    const declarationStatement = (0, traversal_1.getAncestor)(declaration, typescript_1.default.isStatement);
+    if (!declarationStatement ||
+        typescript_1.default.isForStatement(declarationStatement) ||
+        typescript_1.default.isForOfStatement(declarationStatement) ||
+        typescript_1.default.isTryStatement(declarationStatement)) {
+        return;
+    }
+    const parent = declarationStatement.parent;
+    if (!parent || !(0, typeGuards_1.isBlockLike)(parent)) {
+        return;
+    }
+    const sibling = getAncestorWhichIsChildOf(parent, node);
+    if (!sibling || !typescript_1.default.isStatement(sibling)) {
+        return;
+    }
+    const declarationIdx = parent.statements.indexOf(declarationStatement);
+    const siblingIdx = parent.statements.indexOf(sibling);
+    if (siblingIdx > declarationIdx) {
+        return;
+    }
+    if (siblingIdx === declarationIdx) {
+        if ((typescript_1.default.isFunctionDeclaration(declarationStatement) &&
+            !typescript_1.default.hasSyntacticModifier(declarationStatement, typescript_1.default.ModifierFlags.Async)) ||
+            typescript_1.default.isClassDeclaration(declarationStatement) ||
+            (typescript_1.default.isVariableStatement(declarationStatement) &&
+                (0, traversal_1.getAncestor)(node, node => typescript_1.default.isStatement(node) || typescript_1.default.isFunctionLikeDeclaration(node)) ===
+                    declarationStatement)) {
+            return;
+        }
+    }
+    (0, getOrSetDefault_1.getOrSetDefault)(state.hoistsByStatement, sibling, () => new Array()).push(node);
+    state.isHoisted.set(symbol, true);
+    return;
+}
+function transformIdentifier(state, node) {
+    var _a;
+    if (!node.parent || typescript_1.default.positionIsSynthesized(node.pos)) {
+        return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Identifier, { name: node.text });
+    }
+    const symbol = typescript_1.default.isShorthandPropertyAssignment(node.parent)
+        ? state.typeChecker.getShorthandAssignmentValueSymbol(node.parent)
+        : state.typeChecker.getSymbolAtLocation(node);
+    (0, assert_1.assert)(symbol);
+    if (state.typeChecker.isUndefinedSymbol(symbol)) {
+        return luau_ast_1.default.nil();
+    }
+    else if (state.typeChecker.isArgumentsSymbol(symbol)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noArguments(node));
+    }
+    else if (symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.globalThis)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noGlobalThis(node));
+    }
+    const macro = state.services.macroManager.getIdentifierMacro(symbol);
+    if (macro) {
+        return macro(state, node);
+    }
+    const constructSymbol = (0, types_1.getFirstConstructSymbol)(state, node);
+    if (constructSymbol) {
+        const constructorMacro = state.services.macroManager.getConstructorMacro(constructSymbol);
+        if (constructorMacro) {
+            const isClassExtendsNode = typescript_1.default.isClassLike(node.parent.parent.parent) &&
+                ((_a = (0, getExtendsNode_1.getExtendsNode)(node.parent.parent.parent)) === null || _a === void 0 ? void 0 : _a.expression) === node;
+            if (isClassExtendsNode) {
+                DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noMacroExtends(node));
+            }
+            else {
+                DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noConstructorMacroWithoutNew(node));
+            }
+        }
+    }
+    const parent = (0, traversal_1.skipUpwards)(node).parent;
+    if ((!typescript_1.default.isCallExpression(parent) || (0, traversal_1.skipDownwards)(parent.expression) != node) &&
+        state.services.macroManager.getCallMacro(symbol)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noIndexWithoutCall(node));
+        return luau_ast_1.default.none();
+    }
+    if (symbol.valueDeclaration &&
+        symbol.valueDeclaration.getSourceFile() === node.getSourceFile() &&
+        (0, traversal_1.getAncestor)(symbol.valueDeclaration, node => typescript_1.default.isModuleDeclaration(node) && !(0, typeGuards_1.isNamespace)(node)) === undefined) {
+        const exportAccess = state.getModuleIdPropertyAccess(symbol);
+        if (exportAccess && (0, isSymbolMutable_1.isSymbolMutable)(state, symbol)) {
+            return exportAccess;
+        }
+    }
+    checkIdentifierHoist(state, node, symbol);
+    return transformIdentifierDefined(state, node);
+}
+//# sourceMappingURL=transformIdentifier.js.map

package/out/TSTransformer/nodes/expressions/transformImportExpression.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 transformImportExpression(state: TransformState, node: ts.CallExpression): luau.CallExpression | luau.None;

package/out/TSTransformer/nodes/expressions/transformImportExpression.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.transformImportExpression = transformImportExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const createImportExpression_1 = require("../../util/createImportExpression");
+const typescript_1 = __importDefault(require("typescript"));
+function transformImportExpression(state, node) {
+    const moduleSpecifier = node.arguments[0];
+    if (!moduleSpecifier || !typescript_1.default.isStringLiteral(moduleSpecifier)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noNonStringModuleSpecifier(node));
+        return luau_ast_1.default.none();
+    }
+    const importExpression = (0, createImportExpression_1.createImportExpression)(state, node.getSourceFile(), moduleSpecifier);
+    const resolveId = luau_ast_1.default.id("resolve");
+    return luau_ast_1.default.call(luau_ast_1.default.property(state.TS(node, "Promise"), "new"), [
+        luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.FunctionExpression, {
+            hasDotDotDot: false,
+            parameters: luau_ast_1.default.list.make(resolveId),
+            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+                expression: luau_ast_1.default.call(resolveId, [importExpression]),
+            })),
+        }),
+    ]);
+}
+//# sourceMappingURL=transformImportExpression.js.map

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

@@ -0,0 +1,3 @@
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformJsxElement(state: TransformState, node: ts.JsxElement): import("@roblox-ts/luau-ast/out/LuauAST/bundle").CallExpression;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformJsxElement = transformJsxElement;
+const transformJsx_1 = require("../jsx/transformJsx");
+function transformJsxElement(state, node) {
+    return (0, transformJsx_1.transformJsx)(state, node, node.openingElement.tagName, node.openingElement.attributes, node.children);
+}
+//# sourceMappingURL=transformJsxElement.js.map

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformJsxExpression = transformJsxExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./transformExpression");
+function transformJsxExpression(state, node) {
+    if (node.expression) {
+        const expression = (0, transformExpression_1.transformExpression)(state, node.expression);
+        if (node.dotDotDotToken) {
+            return luau_ast_1.default.call(luau_ast_1.default.globals.unpack, [expression]);
+        }
+        return expression;
+    }
+    return luau_ast_1.default.none();
+}
+//# sourceMappingURL=transformJsxExpression.js.map

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

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

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformJsxFragment = transformJsxFragment;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const assert_1 = require("../../../Shared/util/assert");
+const transformJsxChildren_1 = require("../jsx/transformJsxChildren");
+const transformEntityName_1 = require("../transformEntityName");
+const convertToIndexableExpression_1 = require("../../util/convertToIndexableExpression");
+const typescript_1 = __importDefault(require("typescript"));
+function transformJsxFragment(state, node) {
+    var _a;
+    const jsxFactoryEntity = state.resolver.getJsxFactoryEntity(node);
+    (0, assert_1.assert)(jsxFactoryEntity, "Expected jsxFactoryEntity to be defined");
+    const createElementExpression = (0, convertToIndexableExpression_1.convertToIndexableExpression)((0, transformEntityName_1.transformEntityName)(state, jsxFactoryEntity));
+    const jsxFragmentFactoryEntity = (_a = state.resolver.getJsxFragmentFactoryEntity(node)) !== null && _a !== void 0 ? _a : typescript_1.default.parseIsolatedEntityName("Fragment", typescript_1.default.ScriptTarget.ESNext);
+    (0, assert_1.assert)(jsxFragmentFactoryEntity, "Unable to find valid jsxFragmentFactoryEntity");
+    const args = [(0, transformEntityName_1.transformEntityName)(state, jsxFragmentFactoryEntity)];
+    const transformedChildren = (0, transformJsxChildren_1.transformJsxChildren)(state, node.children);
+    if (transformedChildren.length > 0) {
+        args.push(luau_ast_1.default.nil());
+    }
+    args.push(...transformedChildren);
+    return luau_ast_1.default.call(createElementExpression, args);
+}
+//# sourceMappingURL=transformJsxFragment.js.map

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

@@ -0,0 +1,3 @@
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformJsxSelfClosingElement(state: TransformState, node: ts.JsxSelfClosingElement): import("@roblox-ts/luau-ast/out/LuauAST/bundle").CallExpression;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformJsxSelfClosingElement = transformJsxSelfClosingElement;
+const transformJsx_1 = require("../jsx/transformJsx");
+function transformJsxSelfClosingElement(state, node) {
+    return (0, transformJsx_1.transformJsx)(state, node, node.tagName, node.attributes, []);
+}
+//# sourceMappingURL=transformJsxSelfClosingElement.js.map

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformNewExpression = transformNewExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./transformExpression");
+const convertToIndexableExpression_1 = require("../../util/convertToIndexableExpression");
+const ensureTransformOrder_1 = require("../../util/ensureTransformOrder");
+const types_1 = require("../../util/types");
+const validateNotAny_1 = require("../../util/validateNotAny");
+function transformNewExpression(state, node) {
+    (0, validateNotAny_1.validateNotAnyType)(state, node.expression);
+    const symbol = (0, types_1.getFirstConstructSymbol)(state, node.expression);
+    if (symbol) {
+        const macro = state.services.macroManager.getConstructorMacro(symbol);
+        if (macro) {
+            return macro(state, node);
+        }
+    }
+    const expression = (0, convertToIndexableExpression_1.convertToIndexableExpression)((0, transformExpression_1.transformExpression)(state, node.expression));
+    const args = node.arguments ? (0, ensureTransformOrder_1.ensureTransformOrder)(state, node.arguments) : [];
+    return luau_ast_1.default.call(luau_ast_1.default.property(expression, "new"), args);
+}
+//# sourceMappingURL=transformNewExpression.js.map

package/out/TSTransformer/nodes/expressions/transformNoSubstitutionTemplateLiteral.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 transformNoSubstitutionTemplateLiteral(state: TransformState, node: ts.NoSubstitutionTemplateLiteral): luau.InterpolatedString;

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

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformNoSubstitutionTemplateLiteral = transformNoSubstitutionTemplateLiteral;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformInterpolatedStringPart_1 = require("../transformInterpolatedStringPart");
+function transformNoSubstitutionTemplateLiteral(state, node) {
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.InterpolatedString, {
+        parts: luau_ast_1.default.list.make((0, transformInterpolatedStringPart_1.transformInterpolatedStringPart)(node)),
+    });
+}
+//# sourceMappingURL=transformNoSubstitutionTemplateLiteral.js.map

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

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

package/out/TSTransformer/nodes/expressions/transformNumericLiteral.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.transformNumericLiteral = transformNumericLiteral;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function transformNumericLiteral(state, node) {
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.NumberLiteral, {
+        value: node.getText(),
+    });
+}
+//# sourceMappingURL=transformNumericLiteral.js.map

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

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

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

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformObjectLiteralExpression = transformObjectLiteralExpression;
+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("./transformExpression");
+const transformMethodDeclaration_1 = require("../transformMethodDeclaration");
+const transformPropertyName_1 = require("../transformPropertyName");
+const createTruthinessChecks_1 = require("../../util/createTruthinessChecks");
+const pointer_1 = require("../../util/pointer");
+const types_1 = require("../../util/types");
+const validateMethodAssignment_1 = require("../../util/validateMethodAssignment");
+const typescript_1 = __importDefault(require("typescript"));
+function transformPropertyAssignment(state, ptr, name, initializer) {
+    let [left, leftPrereqs] = state.capture(() => (0, transformPropertyName_1.transformPropertyName)(state, name));
+    const [right, rightPrereqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, initializer));
+    if (!luau_ast_1.default.list.isEmpty(leftPrereqs) || !luau_ast_1.default.list.isEmpty(rightPrereqs)) {
+        (0, pointer_1.disableMapInline)(state, ptr);
+        state.prereqList(leftPrereqs);
+        left = state.pushToVar(left, "left");
+    }
+    state.prereqList(rightPrereqs);
+    (0, pointer_1.assignToMapPointer)(state, ptr, left, right);
+}
+function transformSpreadAssignment(state, ptr, property) {
+    const expType = state.typeChecker.getNonOptionalType(state.getType(property.expression));
+    const symbol = (0, types_1.getFirstDefinedSymbol)(state, expType);
+    if (symbol && state.services.macroManager.isMacroOnlyClass(symbol)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noMacroObjectSpread(property));
+    }
+    const type = state.getType(property.expression);
+    const definitelyObject = (0, types_1.isDefinitelyType)(type, types_1.isObjectType);
+    if (definitelyObject && luau_ast_1.default.isMap(ptr.value) && luau_ast_1.default.list.isEmpty(ptr.value.fields)) {
+        ptr.value = state.pushToVar(luau_ast_1.default.call(luau_ast_1.default.globals.table.clone, [(0, transformExpression_1.transformExpression)(state, property.expression)]), ptr.name);
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+            expression: luau_ast_1.default.call(luau_ast_1.default.globals.setmetatable, [ptr.value, luau_ast_1.default.nil()]),
+        }));
+        return;
+    }
+    (0, pointer_1.disableMapInline)(state, ptr);
+    let spreadExp = (0, transformExpression_1.transformExpression)(state, property.expression);
+    if (!definitelyObject) {
+        spreadExp = state.pushToVarIfComplex(spreadExp, "spread");
+    }
+    const keyId = luau_ast_1.default.tempId("k");
+    const valueId = luau_ast_1.default.tempId("v");
+    let statement = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
+        ids: luau_ast_1.default.list.make(keyId, valueId),
+        expression: spreadExp,
+        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: ptr.value,
+                index: keyId,
+            }),
+            operator: "=",
+            right: valueId,
+        })),
+    });
+    if (!definitelyObject) {
+        statement = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+            condition: (0, createTruthinessChecks_1.createTruthinessChecks)(state, spreadExp, property.expression),
+            statements: luau_ast_1.default.list.make(statement),
+            elseBody: luau_ast_1.default.list.make(),
+        });
+    }
+    state.prereq(statement);
+}
+function transformObjectLiteralExpression(state, node) {
+    const ptr = (0, pointer_1.createMapPointer)("object");
+    for (const property of node.properties) {
+        (0, validateMethodAssignment_1.validateMethodAssignment)(state, property);
+        if (typescript_1.default.isPropertyAssignment(property)) {
+            if (typescript_1.default.isPrivateIdentifier(property.name)) {
+                DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noPrivateIdentifier(property.name));
+                continue;
+            }
+            transformPropertyAssignment(state, ptr, property.name, property.initializer);
+        }
+        else if (typescript_1.default.isShorthandPropertyAssignment(property)) {
+            transformPropertyAssignment(state, ptr, property.name, property.name);
+        }
+        else if (typescript_1.default.isSpreadAssignment(property)) {
+            transformSpreadAssignment(state, ptr, property);
+        }
+        else if (typescript_1.default.isMethodDeclaration(property)) {
+            state.prereqList((0, transformMethodDeclaration_1.transformMethodDeclaration)(state, property, ptr));
+        }
+        else {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noGetterSetter(property));
+        }
+    }
+    return ptr.value;
+}
+//# sourceMappingURL=transformObjectLiteralExpression.js.map

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

@@ -0,0 +1,2 @@
+import luau from "@roblox-ts/luau-ast";
+export declare function transformOmittedExpression(): luau.NilLiteral;