cluaupp 1.5.2 → 2.0.0-beta.2

package/generated/compiler/project.js

@@ -0,0 +1,332 @@
+"use strict";
+/**
+ * Project compilation: maps `Src/` onto the Roblox DataModel, builds the typed `@game` tree,
+ * resolves `link`s into a module graph (each module checked once, cycles reported) and emits Luau.
+ *
+ * Layout — folders named like a service map onto that service:
+ *   Src/ServerScriptService/…            → game.ServerScriptService
+ *   Src/ReplicatedStorage/Shared/…       → game.ReplicatedStorage.Shared
+ *   Src/StarterPlayer/StarterPlayerScripts → game.StarterPlayer.StarterPlayerScripts
+ * Legacy domain folders still work: Server → ServerScriptService, Client → StarterPlayerScripts,
+ * anything else → ReplicatedStorage/<folder>.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIdentifier = exports.ProjectCompiler = exports.LIBS_FOLDER = exports.SOURCE_EXT = void 0;
+exports.scriptStem = scriptStem;
+exports.outputName = outputName;
+exports.dataModelPath = dataModelPath;
+exports.classForFile = classForFile;
+exports.collectClp = collectClp;
+exports.buildDataModel = buildDataModel;
+exports.instancePath = instancePath;
+exports.compileSource = compileSource;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const checker_js_1 = require("./checker/checker.js");
+const diagnostics_js_1 = require("./diagnostics.js");
+const emitter_js_1 = require("./emit/emitter.js");
+const names_js_1 = require("./emit/names.js");
+Object.defineProperty(exports, "isIdentifier", { enumerable: true, get: function () { return names_js_1.isIdentifier; } });
+const parser_js_1 = require("./parser.js");
+const api_js_1 = require("./roblox/api.js");
+const context_js_1 = require("./roblox/context.js");
+const source_js_1 = require("./source.js");
+const stdlib_js_1 = require("./stdlib.js");
+exports.SOURCE_EXT = ".clp";
+exports.LIBS_FOLDER = ["ReplicatedStorage", "CluauppLibs"];
+const LEGACY_FOLDERS = {
+    Server: ["ServerScriptService"],
+    Client: ["StarterPlayer", "StarterPlayerScripts"],
+    Character: ["StarterPlayer", "StarterCharacterScripts"],
+    Gui: ["StarterGui"],
+};
+const NESTED_SERVICES = {
+    StarterPlayerScripts: ["StarterPlayer", "StarterPlayerScripts"],
+    StarterCharacterScripts: ["StarterPlayer", "StarterCharacterScripts"],
+};
+function scriptStem(fileName) {
+    return node_path_1.default.basename(fileName).replace(/\.(server|client|plugin)?\.?clp$/i, "").replace(/\.clp$/i, "");
+}
+function outputName(rel) {
+    return rel.replace(/\.clp$/i, ".luau");
+}
+/** DataModel path of a source file, e.g. `ReplicatedStorage/Shared/Combat.clp` → ["ReplicatedStorage", "Shared", "Combat"]. */
+function dataModelPath(api, rel) {
+    const parts = rel.replace(/\\/g, "/").split("/");
+    const file = parts.pop();
+    const stem = scriptStem(file);
+    const first = parts[0];
+    let base;
+    let rest;
+    if (!first) {
+        base = ["ReplicatedStorage"];
+        rest = [];
+    }
+    else if (NESTED_SERVICES[first]) {
+        base = NESTED_SERVICES[first];
+        rest = parts.slice(1);
+    }
+    else if (first === "StarterPlayer" && NESTED_SERVICES[parts[1]]) {
+        base = NESTED_SERVICES[parts[1]];
+        rest = parts.slice(2);
+    }
+    else if (api.isService(first)) {
+        base = [first];
+        rest = parts.slice(1);
+    }
+    else if (LEGACY_FOLDERS[first]) {
+        base = LEGACY_FOLDERS[first];
+        rest = parts.slice(1);
+    }
+    else {
+        base = ["ReplicatedStorage"];
+        rest = parts;
+    }
+    return [...base, ...rest, stem];
+}
+function classForFile(fileName) {
+    const ctx = (0, context_js_1.runContextOf)(fileName);
+    return ctx === "server" ? "Script" : ctx === "client" ? "LocalScript" : ctx === "plugin" ? "Script" : "ModuleScript";
+}
+function collectClp(dir, out = []) {
+    if (!node_fs_1.default.existsSync(dir)) {
+        return out;
+    }
+    for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+        const full = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectClp(full, out);
+        }
+        else if (entry.name.toLowerCase().endsWith(exports.SOURCE_EXT)) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+/** Typed `game` tree: services → folders → scripts compiled from Src, plus CluauppLibs. */
+function buildDataModel(api, srcDir, files, libs = []) {
+    const root = { name: "game", className: "DataModel", path: [], children: new Map() };
+    const ensure = (segments, leafClass, sourceFile) => {
+        let node = root;
+        segments.forEach((seg, i) => {
+            let child = node.children.get(seg);
+            const isLeaf = i === segments.length - 1;
+            if (!child) {
+                const cls = i === 0 && api.isService(seg) ? seg : isLeaf ? leafClass : i === 1 && segments[0] === "StarterPlayer" ? seg : "Folder";
+                child = { name: seg, className: cls, path: segments.slice(0, i + 1), children: new Map() };
+                node.children.set(seg, child);
+            }
+            if (isLeaf && sourceFile) {
+                child.className = leafClass;
+                child.sourceFile = sourceFile;
+            }
+            node = child;
+        });
+    };
+    for (const svc of ["Workspace", "Players", "ReplicatedStorage", "ReplicatedFirst", "ServerScriptService", "ServerStorage", "StarterGui", "StarterPack", "StarterPlayer", "Lighting", "SoundService", "Teams"]) {
+        ensure([svc], svc);
+    }
+    ensure(["StarterPlayer", "StarterPlayerScripts"], "StarterPlayerScripts");
+    ensure(["StarterPlayer", "StarterCharacterScripts"], "StarterCharacterScripts");
+    for (const file of files) {
+        const rel = node_path_1.default.relative(srcDir, file).replace(/\\/g, "/");
+        ensure(dataModelPath(api, rel), classForFile(file), node_path_1.default.resolve(file));
+    }
+    if (libs.length) {
+        ensure(exports.LIBS_FOLDER, "Folder");
+        for (const lib of libs) {
+            ensure([...exports.LIBS_FOLDER, lib], "ModuleScript");
+        }
+    }
+    return root;
+}
+/** Luau expression that reaches an Instance by its DataModel path, robust to replication order. */
+function instancePath(dm, service, fromDm) {
+    if (fromDm && fromDm.length > 1 && dm.length > 1) {
+        const fromParent = fromDm.slice(0, -1);
+        const targetParent = dm.slice(0, -1);
+        if (fromParent.join("/") === targetParent.join("/")) {
+            return `script.Parent${childAccess(dm[dm.length - 1])}`;
+        }
+    }
+    const [first, ...rest] = dm;
+    let expr = first === "Workspace" ? "workspace" : service(first);
+    for (const seg of rest) {
+        expr += childAccess(seg);
+    }
+    return expr;
+}
+function childAccess(name) {
+    return `:WaitForChild(${(0, names_js_1.luauString)(name)})`;
+}
+class ProjectCompiler {
+    options;
+    api;
+    files;
+    dataModel;
+    results = new Map();
+    inProgress = [];
+    byDmPath = new Map();
+    libs;
+    constructor(options, libs = []) {
+        this.options = options;
+        this.api = options.api ?? (0, api_js_1.robloxApi)();
+        this.files = collectClp(options.srcDir).map((f) => node_path_1.default.resolve(f));
+        this.libs = libs;
+        this.dataModel = buildDataModel(this.api, options.srcDir, this.files, libs);
+        for (const f of this.files) {
+            this.byDmPath.set(this.dmOf(f).join("/"), f);
+        }
+    }
+    rel(file) {
+        return node_path_1.default.relative(this.options.srcDir, file).replace(/\\/g, "/");
+    }
+    dmOf(file) {
+        return dataModelPath(this.api, this.rel(file));
+    }
+    compileAll() {
+        return this.files.map((f) => this.compile(f));
+    }
+    compile(file, text) {
+        const key = node_path_1.default.resolve(file);
+        const cached = this.results.get(key);
+        if (cached && text === undefined) {
+            return cached;
+        }
+        const source = new source_js_1.SourceFile(this.rel(key), text ?? node_fs_1.default.readFileSync(key, "utf8"));
+        const diags = new diagnostics_js_1.DiagnosticBag(source);
+        const rel = this.rel(key);
+        const context = (0, context_js_1.runContextOf)(key);
+        const kind = context === "shared" ? "module" : "script";
+        this.inProgress.push(key);
+        const program = (0, parser_js_1.parse)(source, diags);
+        const dmPath = this.dmOf(key);
+        let info = null;
+        try {
+            info = new checker_js_1.Checker({
+                program,
+                source,
+                diags,
+                api: this.api,
+                moduleId: key,
+                kind,
+                context,
+                strict: this.options.strict,
+                resolveLink: (link) => this.resolveLink(link, key, diags),
+                dataModel: this.dataModel,
+                dmPath,
+            }).run();
+        }
+        finally {
+            this.inProgress.pop();
+        }
+        let luau = null;
+        let sourceMap = [];
+        if (diags.errorCount === 0) {
+            luau = (0, emitter_js_1.emitLuau)(program, info, this.api, {
+                sourceLabel: rel,
+                sourcePosition: offset => source.position(offset),
+                onSourceMap: lines => { sourceMap = lines; },
+                version: this.options.version,
+                requireTarget: (l, service) => this.requireTarget(l, dmPath, service),
+                libsRoot: (service) => instancePath(exports.LIBS_FOLDER, service, null),
+            });
+        }
+        const result = { file: key, rel, outRel: outputName(rel), luau, sourceMap, diagnostics: diags.items, source, info };
+        this.results.set(key, result);
+        return result;
+    }
+    resolveLink(link, fromFile, diags) {
+        const p = link.path;
+        if (link.isPackage) {
+            if (p === "@clpp.roblox" || p === "@roblox") {
+                return { kind: "roblox" };
+            }
+            const std = stdlib_js_1.STD_PATHS[p];
+            if (std && std !== "unsupported") {
+                return { kind: "std", module: std };
+            }
+            if (stdlib_js_1.DESKTOP_ONLY[p]) {
+                return { kind: "error", message: `${p} is a desktop module of the clpp VM and does not exist on Roblox`, notes: [stdlib_js_1.DESKTOP_ONLY[p]] };
+            }
+            const lib = /^@(?:clpp\.libs|cluaupp)\.([A-Za-z0-9_]+)$/.exec(p);
+            if (lib) {
+                const name = this.libs.find((l) => l.toLowerCase() === lib[1].toLowerCase());
+                if (!name && this.libs.length) {
+                    return { kind: "error", message: `CluauppLibs has no library '${lib[1]}'`, notes: [`available: ${this.libs.join(", ")}`] };
+                }
+                const libName = name ?? lib[1][0].toUpperCase() + lib[1].slice(1);
+                return { kind: "luau", dmPath: [...exports.LIBS_FOLDER, libName], label: libName };
+            }
+            if (p.startsWith("@game.") || /^@[A-Z]/.test(p)) {
+                const shorthand = !p.startsWith("@game.");
+                const segments = p.slice(shorthand ? 1 : "@game.".length).split(".");
+                if (!this.api.isService(segments[0])) {
+                    return { kind: "error", message: `'${segments[0]}' is not a Roblox service`, notes: ["link @ReplicatedStorage.Shared.Module as Module;"] };
+                }
+                const fileHit = this.byDmPath.get(segments.join("/"));
+                if (fileHit) {
+                    return this.linkFile(fileHit, fromFile);
+                }
+                if (shorthand) {
+                    return { kind: "error", message: `no .clp module at ${p}`, notes: [`create src/${segments.join("/")}.clp or use a relative link to the file`] };
+                }
+                return { kind: "luau", dmPath: segments, label: segments.join(".") };
+            }
+            return { kind: "error", message: `unknown module ${p}`, notes: ["@clpp.roblox, @clpp.axiom, @clpp.libs.<Lib>, @ReplicatedStorage.Shared.<Module>, @game.<Service>.<…>"] };
+        }
+        let target = node_path_1.default.resolve(node_path_1.default.dirname(fromFile), p);
+        if (!node_fs_1.default.existsSync(target) && node_fs_1.default.existsSync(`${target}.clp`)) {
+            target = `${target}.clp`;
+        }
+        if (!target.toLowerCase().endsWith(exports.SOURCE_EXT)) {
+            return { kind: "error", message: `cannot link '${p}': CL++ modules are .clp files`, notes: [/\.(clh|clpp)$/i.test(p) ? "Legacy .clh/.clpp files use a different syntax: migrate the declarations and imports to .clp; changing the extension alone is insufficient" : "link \"./file.clp\" as Name;"] };
+        }
+        if (!node_fs_1.default.existsSync(target)) {
+            return { kind: "error", message: `cannot open module '${p}'` };
+        }
+        void diags;
+        return this.linkFile(target, fromFile);
+    }
+    linkFile(target, fromFile) {
+        const key = node_path_1.default.resolve(target);
+        if (this.inProgress.includes(key)) {
+            const cycle = [...this.inProgress.slice(this.inProgress.indexOf(key)), key].map((f) => this.rel(f));
+            return { kind: "error", message: "circular link", notes: [cycle.join(" → ")] };
+        }
+        if (key === node_path_1.default.resolve(fromFile)) {
+            return { kind: "error", message: "a module cannot link itself" };
+        }
+        const compiled = this.compile(key);
+        if (!compiled.info) {
+            return { kind: "error", message: `module ${this.rel(key)} failed to compile` };
+        }
+        if (compiled.diagnostics.some((d) => d.severity === "error")) {
+            const first = compiled.diagnostics.find((d) => d.severity === "error");
+            return { kind: "error", message: `module ${this.rel(key)} has errors`, notes: [`${first.file}:${first.line}:${first.column}: ${first.message}`] };
+        }
+        const exports = compiled.info.exports;
+        return { kind: "clp", exports, dmPath: this.dmOf(key), file: key };
+    }
+    requireTarget(link, fromDm, service) {
+        const t = link.target;
+        if (t.kind === "clp" && t.dmPath) {
+            return instancePath(t.dmPath, service, fromDm);
+        }
+        if (t.kind === "luau") {
+            return instancePath(t.dmPath, service, fromDm);
+        }
+        return null;
+    }
+}
+exports.ProjectCompiler = ProjectCompiler;
+/** Compile one file with no project around it (tests, playground, `cluaupp check <file>`). */
+function compileSource(text, fileName = "Main.server.clp", options = {}) {
+    const root = options.root ?? process.cwd();
+    const srcDir = options.srcDir ?? root;
+    const compiler = new ProjectCompiler({ root, srcDir, strict: options.strict ?? false, version: options.version ?? "dev", api: options.api });
+    return compiler.compile(node_path_1.default.resolve(srcDir, fileName), text);
+}