@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/TSTransformer/util/spreadDestructuring/spreadDestructureMap.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spreadDestructureMap = spreadDestructureMap;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function spreadDestructureMap(state, parentId, index, idStack) {
+    const extracted = state.pushToVar(luau_ast_1.default.set(idStack), "extracted");
+    const rest = state.pushToVar(luau_ast_1.default.array(), "rest");
+    const keyId = luau_ast_1.default.tempId("k");
+    const valueId = luau_ast_1.default.tempId("v");
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
+        ids: luau_ast_1.default.list.make(keyId, valueId),
+        expression: parentId,
+        statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+            condition: luau_ast_1.default.unary("not", luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                expression: extracted,
+                index: keyId,
+            })),
+            elseBody: luau_ast_1.default.list.make(),
+            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+                expression: luau_ast_1.default.call(luau_ast_1.default.globals.table.insert, [
+                    rest,
+                    luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Array, {
+                        members: luau_ast_1.default.list.make(keyId, valueId),
+                    }),
+                ]),
+            })),
+        })),
+    }));
+    return rest;
+}
+//# sourceMappingURL=spreadDestructureMap.js.map

package/out/TSTransformer/util/spreadDestructuring/spreadDestructureObject.d.ts

@@ -0,0 +1,3 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../../classes/TransformState";
+export declare function spreadDestructureObject(state: TransformState, parentId: luau.AnyIdentifier, preSpreadNames: Array<luau.Expression>): luau.TemporaryIdentifier;

package/out/TSTransformer/util/spreadDestructuring/spreadDestructureObject.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spreadDestructureObject = spreadDestructureObject;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const assert_1 = require("../../../Shared/util/assert");
+function spreadDestructureObject(state, parentId, preSpreadNames) {
+    const extracted = state.pushToVar(luau_ast_1.default.set(preSpreadNames.map(expression => {
+        if (luau_ast_1.default.isPropertyAccessExpression(expression))
+            return luau_ast_1.default.string(expression.name);
+        if (luau_ast_1.default.isComputedIndexExpression(expression))
+            return expression.index;
+        (0, assert_1.assert)(false, "Unknown expression type");
+    })), "extracted");
+    const rest = state.pushToVar(luau_ast_1.default.map(), "rest");
+    const keyId = luau_ast_1.default.tempId("k");
+    const valueId = luau_ast_1.default.tempId("v");
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
+        ids: luau_ast_1.default.list.make(keyId, valueId),
+        expression: parentId,
+        statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+            condition: luau_ast_1.default.unary("not", luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                expression: extracted,
+                index: keyId,
+            })),
+            elseBody: luau_ast_1.default.list.make(),
+            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: rest,
+                    index: keyId,
+                }),
+                operator: "=",
+                right: valueId,
+            })),
+        })),
+    }));
+    return rest;
+}
+//# sourceMappingURL=spreadDestructureObject.js.map

package/out/TSTransformer/util/spreadDestructuring/spreadDestructureSet.d.ts

@@ -0,0 +1,3 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../../classes/TransformState";
+export declare function spreadDestructureSet(state: TransformState, parentId: luau.AnyIdentifier, index: number, idStack: Array<luau.AnyIdentifier>): luau.TemporaryIdentifier;

package/out/TSTransformer/util/spreadDestructuring/spreadDestructureSet.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.spreadDestructureSet = spreadDestructureSet;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function spreadDestructureSet(state, parentId, index, idStack) {
+    const extracted = state.pushToVar(luau_ast_1.default.set(idStack), "extracted");
+    const rest = state.pushToVar(luau_ast_1.default.array(), "rest");
+    const keyId = luau_ast_1.default.tempId("k");
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
+        ids: luau_ast_1.default.list.make(keyId),
+        expression: parentId,
+        statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+            condition: luau_ast_1.default.unary("not", luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                expression: extracted,
+                index: keyId,
+            })),
+            elseBody: luau_ast_1.default.list.make(),
+            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+                expression: luau_ast_1.default.call(luau_ast_1.default.globals.table.insert, [rest, keyId]),
+            })),
+        })),
+    }));
+    return rest;
+}
+//# sourceMappingURL=spreadDestructureSet.js.map

package/out/TSTransformer/util/traversal.d.ts

@@ -0,0 +1,7 @@
+import ts from "typescript";
+export declare function isAncestorOf(ancestor: ts.Node, node: ts.Node): boolean;
+export declare function skipDownwards(node: ts.Expression): ts.Expression;
+export declare function skipUpwards(node: ts.Node): ts.Node;
+export declare function getAncestor<T extends ts.Node>(node: ts.Node, check: (value: ts.Node) => value is T): T | undefined;
+export declare function getAncestor(node: ts.Node, check: (value: ts.Node) => boolean): ts.Node | undefined;
+export declare function getModuleAncestor(node: ts.Node): ts.SourceFile | ts.ModuleDeclaration;

package/out/TSTransformer/util/traversal.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAncestorOf = isAncestorOf;
+exports.skipDownwards = skipDownwards;
+exports.skipUpwards = skipUpwards;
+exports.getAncestor = getAncestor;
+exports.getModuleAncestor = getModuleAncestor;
+const typescript_1 = __importDefault(require("typescript"));
+function isAncestorOf(ancestor, node) {
+    do {
+        if (ancestor === node) {
+            return true;
+        }
+        node = node.parent;
+    } while (node);
+    return false;
+}
+function skipDownwards(node) {
+    while (typescript_1.default.isNonNullExpression(node) ||
+        typescript_1.default.isParenthesizedExpression(node) ||
+        typescript_1.default.isAsExpression(node) ||
+        typescript_1.default.isTypeAssertionExpression(node) ||
+        typescript_1.default.isSatisfiesExpression(node)) {
+        node = node.expression;
+    }
+    return node;
+}
+function skipUpwards(node) {
+    let parent = node.parent;
+    while (parent &&
+        (typescript_1.default.isNonNullExpression(parent) ||
+            typescript_1.default.isParenthesizedExpression(parent) ||
+            typescript_1.default.isAsExpression(parent) ||
+            typescript_1.default.isTypeAssertionExpression(parent) ||
+            typescript_1.default.isSatisfiesExpression(parent))) {
+        node = parent;
+        parent = node.parent;
+    }
+    return node;
+}
+function getAncestor(node, check) {
+    let current = node;
+    while (current && !check(current)) {
+        current = current.parent;
+    }
+    return current;
+}
+function isSourceFileOrModuleDeclaration(node) {
+    return typescript_1.default.isSourceFile(node) || typescript_1.default.isModuleDeclaration(node);
+}
+function getModuleAncestor(node) {
+    return getAncestor(node, isSourceFileOrModuleDeclaration);
+}
+//# sourceMappingURL=traversal.js.map

package/out/TSTransformer/util/types.d.ts

@@ -0,0 +1,31 @@
+import { TransformState } from "..";
+import ts from "typescript";
+type TypeCheck = (type: ts.Type) => boolean;
+export declare function isDefinitelyType(type: ts.Type, ...callbacks: Array<TypeCheck>): boolean;
+export declare function isPossiblyType(type: ts.Type, ...callbacks: Array<TypeCheck>): boolean;
+export declare function isDefinedType(type: ts.Type): boolean;
+export declare function isAnyType(state: TransformState): TypeCheck;
+export declare function isBooleanType(type: ts.Type): boolean;
+export declare function isBooleanLiteralType(state: TransformState, value: boolean): TypeCheck;
+export declare function isNumberType(type: ts.Type): boolean;
+export declare function isNumberLiteralType(value: number): TypeCheck;
+export declare function isNaNType(type: ts.Type): boolean;
+export declare function isStringType(type: ts.Type): boolean;
+export declare function isArrayType(state: TransformState): TypeCheck;
+export declare function isSetType(state: TransformState): TypeCheck;
+export declare function isMapType(state: TransformState): TypeCheck;
+export declare function isSharedTableType(state: TransformState): TypeCheck;
+export declare function isGeneratorType(state: TransformState): TypeCheck;
+export declare function isIterableFunctionType(state: TransformState): TypeCheck;
+export declare function isLuaTupleType(state: TransformState): TypeCheck;
+export declare function isIterableFunctionLuaTupleType(state: TransformState): TypeCheck;
+export declare function isIterableType(state: TransformState): TypeCheck;
+export declare function isObjectType(type: ts.Type): boolean;
+export declare function isUndefinedType(type: ts.Type): boolean;
+export declare function isEmptyStringType(type: ts.Type): boolean;
+export declare function isRobloxType(state: TransformState): TypeCheck;
+export declare function walkTypes(type: ts.Type, callback: (type: ts.Type) => void): void;
+export declare function getFirstConstructSymbol(state: TransformState, expression: ts.Expression): ts.Symbol | undefined;
+export declare function getFirstDefinedSymbol(state: TransformState, type: ts.Type): ts.Symbol | undefined;
+export declare function getTypeArguments(state: TransformState, type: ts.Type): readonly ts.Type[];
+export {};

package/out/TSTransformer/util/types.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefinitelyType = isDefinitelyType;
+exports.isPossiblyType = isPossiblyType;
+exports.isDefinedType = isDefinedType;
+exports.isAnyType = isAnyType;
+exports.isBooleanType = isBooleanType;
+exports.isBooleanLiteralType = isBooleanLiteralType;
+exports.isNumberType = isNumberType;
+exports.isNumberLiteralType = isNumberLiteralType;
+exports.isNaNType = isNaNType;
+exports.isStringType = isStringType;
+exports.isArrayType = isArrayType;
+exports.isSetType = isSetType;
+exports.isMapType = isMapType;
+exports.isSharedTableType = isSharedTableType;
+exports.isGeneratorType = isGeneratorType;
+exports.isIterableFunctionType = isIterableFunctionType;
+exports.isLuaTupleType = isLuaTupleType;
+exports.isIterableFunctionLuaTupleType = isIterableFunctionLuaTupleType;
+exports.isIterableType = isIterableType;
+exports.isObjectType = isObjectType;
+exports.isUndefinedType = isUndefinedType;
+exports.isEmptyStringType = isEmptyStringType;
+exports.isRobloxType = isRobloxType;
+exports.walkTypes = walkTypes;
+exports.getFirstConstructSymbol = getFirstConstructSymbol;
+exports.getFirstDefinedSymbol = getFirstDefinedSymbol;
+exports.getTypeArguments = getTypeArguments;
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../../Shared/constants");
+const isPathDescendantOf_1 = require("../../Shared/util/isPathDescendantOf");
+const TSTransformer_1 = require("..");
+const MacroManager_1 = require("../classes/MacroManager");
+const typeGuards_1 = require("../typeGuards");
+const typescript_1 = __importDefault(require("typescript"));
+function getRecursiveBaseTypesInner(result, type) {
+    var _a;
+    for (const baseType of (_a = type.getBaseTypes()) !== null && _a !== void 0 ? _a : []) {
+        result.push(baseType);
+        if (baseType.isClassOrInterface()) {
+            getRecursiveBaseTypesInner(result, baseType);
+        }
+    }
+}
+function getRecursiveBaseTypes(type) {
+    const result = new Array();
+    getRecursiveBaseTypesInner(result, type);
+    return result;
+}
+function isDefinitelyTypeInner(type, callbacks) {
+    if (type.isUnion()) {
+        return type.types.every(t => isDefinitelyTypeInner(t, callbacks));
+    }
+    else if (type.isIntersection()) {
+        return type.types.some(t => isDefinitelyTypeInner(t, callbacks));
+    }
+    else {
+        if (type.isClassOrInterface() && getRecursiveBaseTypes(type).some(t => isDefinitelyTypeInner(t, callbacks))) {
+            return true;
+        }
+        return callbacks.some(cb => cb(type));
+    }
+}
+function isDefinitelyType(type, ...callbacks) {
+    var _a;
+    return isDefinitelyTypeInner((_a = type.getConstraint()) !== null && _a !== void 0 ? _a : type, callbacks);
+}
+function isPossiblyTypeInner(type, callbacks) {
+    if (type.isUnionOrIntersection()) {
+        return type.types.some(t => isPossiblyTypeInner(t, callbacks));
+    }
+    else {
+        if (type.isClassOrInterface() && getRecursiveBaseTypes(type).some(t => isPossiblyTypeInner(t, callbacks))) {
+            return true;
+        }
+        if (!!(type.flags & (typescript_1.default.TypeFlags.TypeVariable | typescript_1.default.TypeFlags.AnyOrUnknown))) {
+            return true;
+        }
+        if (isDefinedType(type)) {
+            if (callbacks.length === 1 && callbacks[0] === isUndefinedType) {
+                return false;
+            }
+            return true;
+        }
+        return callbacks.some(cb => cb(type));
+    }
+}
+function isPossiblyType(type, ...callbacks) {
+    var _a;
+    return isPossiblyTypeInner((_a = type.getConstraint()) !== null && _a !== void 0 ? _a : type, callbacks);
+}
+function isDefinedType(type) {
+    return (type.flags === typescript_1.default.TypeFlags.Object &&
+        type.getProperties().length === 0 &&
+        type.getCallSignatures().length === 0 &&
+        type.getConstructSignatures().length === 0 &&
+        type.getNumberIndexType() === undefined &&
+        type.getStringIndexType() === undefined);
+}
+function isAnyType(state) {
+    return type => type === state.typeChecker.getAnyType();
+}
+function isBooleanType(type) {
+    return !!(type.flags & (typescript_1.default.TypeFlags.Boolean | typescript_1.default.TypeFlags.BooleanLiteral));
+}
+function isBooleanLiteralType(state, value) {
+    return type => {
+        if (!!(type.flags & typescript_1.default.TypeFlags.BooleanLiteral)) {
+            const valueType = value ? state.typeChecker.getTrueType() : state.typeChecker.getFalseType();
+            return type === valueType;
+        }
+        return isBooleanType(type);
+    };
+}
+function isNumberType(type) {
+    return !!(type.flags & (typescript_1.default.TypeFlags.Number | typescript_1.default.TypeFlags.NumberLike | typescript_1.default.TypeFlags.NumberLiteral));
+}
+function isNumberLiteralType(value) {
+    return type => {
+        if (type.isNumberLiteral()) {
+            return type.value === value;
+        }
+        return isNumberType(type);
+    };
+}
+function isNaNType(type) {
+    return isNumberType(type) && !type.isNumberLiteral();
+}
+function isStringType(type) {
+    return !!(type.flags & (typescript_1.default.TypeFlags.String | typescript_1.default.TypeFlags.StringLike | typescript_1.default.TypeFlags.StringLiteral));
+}
+function isArrayType(state) {
+    return type => {
+        if (!!(type.flags & typescript_1.default.TypeFlags.Any)) {
+            return false;
+        }
+        return (state.typeChecker.isTupleType(type) ||
+            state.typeChecker.isArrayLikeType(type) ||
+            type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.ReadonlyArray) ||
+            type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.Array) ||
+            type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.ReadVoxelsArray) ||
+            type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.TemplateStringsArray));
+    };
+}
+function isSetType(state) {
+    return type => type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.Set) ||
+        type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.ReadonlySet) ||
+        type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.WeakSet);
+}
+function isMapType(state) {
+    return type => type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.Map) ||
+        type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.ReadonlyMap) ||
+        type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.WeakMap);
+}
+function isSharedTableType(state) {
+    return type => type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.SharedTable);
+}
+function isGeneratorType(state) {
+    return type => type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.Generator);
+}
+function isIterableFunctionType(state) {
+    return type => type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.IterableFunction);
+}
+function isLuaTupleType(state) {
+    return type => type.getProperty(MacroManager_1.NOMINAL_LUA_TUPLE_NAME) ===
+        state.services.macroManager.getSymbolOrThrow(MacroManager_1.NOMINAL_LUA_TUPLE_NAME);
+}
+function isIterableFunctionLuaTupleType(state) {
+    return type => {
+        if (isIterableFunctionType(state)(type)) {
+            const firstTypeArg = getTypeArguments(state, type)[0];
+            return firstTypeArg !== undefined && isLuaTupleType(state)(firstTypeArg);
+        }
+        return false;
+    };
+}
+function isIterableType(state) {
+    return type => type.symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.Iterable);
+}
+function isObjectType(type) {
+    return !!(type.flags & typescript_1.default.TypeFlags.Object);
+}
+function isUndefinedType(type) {
+    return !!(type.flags & (typescript_1.default.TypeFlags.Undefined | typescript_1.default.TypeFlags.Void));
+}
+function isEmptyStringType(type) {
+    if (type.isStringLiteral()) {
+        return type.value === "";
+    }
+    if ((0, typeGuards_1.isTemplateLiteralType)(type)) {
+        return type.texts.length === 0 || type.texts.every(v => v.length === 0);
+    }
+    return isStringType(type);
+}
+function isRobloxType(state) {
+    const typesPath = path_1.default.join(state.data.nodeModulesPath, constants_1.RBXTS_SCOPE, "types");
+    return type => {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = type.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b.some(d => {
+            var _a;
+            const filePath = (_a = d.getSourceFile()) === null || _a === void 0 ? void 0 : _a.fileName;
+            return filePath !== undefined && (0, isPathDescendantOf_1.isPathDescendantOf)(filePath, typesPath);
+        })) !== null && _c !== void 0 ? _c : false;
+    };
+}
+function walkTypes(type, callback) {
+    if (type.isUnionOrIntersection()) {
+        for (const t of type.types) {
+            walkTypes(t, callback);
+        }
+    }
+    else {
+        const constraint = type.getConstraint();
+        if (constraint && constraint !== type) {
+            walkTypes(constraint, callback);
+        }
+        else {
+            callback(type);
+        }
+    }
+}
+function getFirstConstructSymbol(state, expression) {
+    const type = state.getType(expression);
+    if (type.symbol) {
+        const declarations = type.symbol.getDeclarations();
+        if (declarations) {
+            for (const declaration of declarations) {
+                if (typescript_1.default.isInterfaceDeclaration(declaration)) {
+                    for (const member of declaration.members) {
+                        if (typescript_1.default.isConstructSignatureDeclaration(member)) {
+                            return member.symbol;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+function getFirstDefinedSymbol(state, type) {
+    if (type.isUnionOrIntersection()) {
+        for (const t of type.types) {
+            if (t.symbol && !state.typeChecker.isUndefinedSymbol(t.symbol)) {
+                return t.symbol;
+            }
+        }
+    }
+    else {
+        return type.symbol;
+    }
+}
+function getTypeArguments(state, type) {
+    var _a;
+    return (_a = state.typeChecker.getTypeArguments(type)) !== null && _a !== void 0 ? _a : [];
+}
+//# sourceMappingURL=types.js.map

package/out/TSTransformer/util/validateIdentifier.d.ts

@@ -0,0 +1,3 @@
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function validateIdentifier(state: TransformState, node: ts.Identifier): void;

package/out/TSTransformer/util/validateIdentifier.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateIdentifier = validateIdentifier;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../Shared/diagnostics");
+const DiagnosticService_1 = require("../classes/DiagnosticService");
+function validateIdentifier(state, node) {
+    if (!luau_ast_1.default.isValidIdentifier(node.text)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noInvalidIdentifier(node));
+    }
+    else if (luau_ast_1.default.isReservedIdentifier(node.text)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noReservedIdentifier(node));
+    }
+}
+//# sourceMappingURL=validateIdentifier.js.map

package/out/TSTransformer/util/validateMethodAssignment.d.ts

@@ -0,0 +1,3 @@
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function validateMethodAssignment(state: TransformState, node: ts.ObjectLiteralElementLike | ts.ClassElement): void;

package/out/TSTransformer/util/validateMethodAssignment.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMethodAssignment = validateMethodAssignment;
+const diagnostics_1 = require("../../Shared/diagnostics");
+const DiagnosticService_1 = require("../classes/DiagnosticService");
+const isMethod_1 = require("./isMethod");
+const types_1 = require("./types");
+const typescript_1 = __importDefault(require("typescript"));
+function hasCallSignatures(type) {
+    let hasCallSignatures = false;
+    (0, types_1.walkTypes)(type, t => {
+        hasCallSignatures || (hasCallSignatures = t.getCallSignatures().length > 0);
+    });
+    return hasCallSignatures;
+}
+function validateTypes(state, node, baseType, assignmentType) {
+    if (hasCallSignatures(baseType) && hasCallSignatures(assignmentType)) {
+        const assignmentIsMethod = (0, isMethod_1.isMethodFromType)(state, node, assignmentType);
+        if ((0, isMethod_1.isMethodFromType)(state, node, baseType) !== assignmentIsMethod) {
+            if (assignmentIsMethod) {
+                DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.expectedMethodGotFunction(node));
+            }
+            else {
+                DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.expectedFunctionGotMethod(node));
+            }
+        }
+    }
+}
+function validateObjectLiteralElement(state, node) {
+    const type = state.getType(node);
+    const contextualType = state.typeChecker.getContextualTypeForObjectLiteralElement(node);
+    if (contextualType && contextualType !== type) {
+        validateTypes(state, node, type, contextualType);
+    }
+}
+function validateHeritageClause(state, node, typeNode) {
+    const name = typescript_1.default.getPropertyNameForPropertyNameNode(node.name);
+    if (!name)
+        return;
+    const type = state.getType(node);
+    const propertyType = state.typeChecker.getTypeOfPropertyOfType(state.getType(typeNode), name);
+    if (!propertyType)
+        return;
+    validateTypes(state, node, type, propertyType);
+}
+function validateSpread(state, node) {
+    const type = state.getType(node.expression);
+    const contextualType = state.typeChecker.getContextualType(node.expression);
+    if (!contextualType)
+        return;
+    for (const property of type.getProperties()) {
+        const basePropertyType = state.typeChecker.getTypeOfPropertyOfType(type, property.name);
+        const assignmentPropertyType = state.typeChecker.getTypeOfPropertyOfType(contextualType, property.name);
+        if (!basePropertyType)
+            continue;
+        if (!assignmentPropertyType)
+            continue;
+        validateTypes(state, node, basePropertyType, assignmentPropertyType);
+    }
+}
+function validateMethodAssignment(state, node) {
+    if (typescript_1.default.isClassElement(node) && typescript_1.default.isClassLike(node.parent) && node.name) {
+        for (const typeNode of typescript_1.default.getAllSuperTypeNodes(node.parent)) {
+            validateHeritageClause(state, node, typeNode);
+        }
+    }
+    else if (typescript_1.default.isObjectLiteralElementLike(node)) {
+        if (typescript_1.default.isSpreadAssignment(node)) {
+            if (!typescript_1.default.isObjectLiteralExpression(node.expression)) {
+                validateSpread(state, node);
+            }
+        }
+        else {
+            validateObjectLiteralElement(state, node);
+        }
+    }
+}
+//# sourceMappingURL=validateMethodAssignment.js.map

package/out/TSTransformer/util/validateNotAny.d.ts

@@ -0,0 +1,3 @@
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function validateNotAnyType(state: TransformState, node: ts.Node): void;

package/out/TSTransformer/util/validateNotAny.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNotAnyType = validateNotAnyType;
+const diagnostics_1 = require("../../Shared/diagnostics");
+const DiagnosticService_1 = require("../classes/DiagnosticService");
+const getOriginalSymbolOfNode_1 = require("./getOriginalSymbolOfNode");
+const traversal_1 = require("./traversal");
+const types_1 = require("./types");
+const typescript_1 = __importDefault(require("typescript"));
+function validateNotAnyType(state, node) {
+    if (typescript_1.default.isSpreadElement(node)) {
+        node = (0, traversal_1.skipDownwards)(node.expression);
+    }
+    let type = state.getType(node);
+    if ((0, types_1.isDefinitelyType)(type, (0, types_1.isArrayType)(state))) {
+        const indexType = state.typeChecker.getIndexTypeOfType(type, typescript_1.default.IndexKind.Number);
+        if (indexType) {
+            type = indexType;
+        }
+    }
+    if ((0, types_1.isDefinitelyType)(type, (0, types_1.isAnyType)(state))) {
+        const symbol = (0, getOriginalSymbolOfNode_1.getOriginalSymbolOfNode)(state.typeChecker, node);
+        if (symbol) {
+            if (!state.multiTransformState.isReportedByNoAnyCache.has(symbol)) {
+                state.multiTransformState.isReportedByNoAnyCache.add(symbol);
+                DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noAny(node));
+            }
+        }
+        else {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noAny(node));
+        }
+    }
+}
+//# sourceMappingURL=validateNotAny.js.map

package/out/TSTransformer/util/valueToIdStr.d.ts

@@ -0,0 +1,2 @@
+import luau from "@roblox-ts/luau-ast";
+export declare function valueToIdStr(value: luau.Expression): string;

package/out/TSTransformer/util/valueToIdStr.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valueToIdStr = valueToIdStr;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function expressionToStr(expression) {
+    if (luau_ast_1.default.isIdentifier(expression) ||
+        luau_ast_1.default.isPropertyAccessExpression(expression)) {
+        return expression.name;
+    }
+    if (luau_ast_1.default.isCallExpression(expression)) {
+        if (luau_ast_1.default.isPropertyAccessExpression(expression.expression) && expression.expression.name === "new") {
+            return expressionToStr(expression.expression.expression);
+        }
+    }
+}
+function uncapitalizeFirstLetter(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function valueToIdStr(value) {
+    const valueStr = expressionToStr(value);
+    if (valueStr !== undefined && luau_ast_1.default.isValidIdentifier(valueStr)) {
+        return uncapitalizeFirstLetter(valueStr);
+    }
+    return "";
+}
+//# sourceMappingURL=valueToIdStr.js.map

package/out/TSTransformer/util/wrapExpressionStatement.d.ts

@@ -0,0 +1,2 @@
+import luau from "@roblox-ts/luau-ast";
+export declare function wrapExpressionStatement(node: luau.Expression): luau.List<luau.Statement>;