cluaupp 0.2.3 → 1.3.0

package/generated/preprocess.js

@@ -1,181 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SOURCE_EXTS = void 0;
-exports.isSourceFile = isSourceFile;
-exports.isHeaderFile = isHeaderFile;
-exports.toLuauPath = toLuauPath;
-exports.isEngineStub = isEngineStub;
-exports.siblingImplementation = siblingImplementation;
-exports.siblingHeader = siblingHeader;
-exports.implOutName = implOutName;
-exports.resolveInclude = resolveInclude;
-exports.scanHeaderExports = scanHeaderExports;
-exports.applyPragmas = applyPragmas;
-exports.preprocess = preprocess;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-exports.SOURCE_EXTS = [".cpp", ".cc", ".cxx", ".c", ".h", ".hpp", ".hh"];
-function isSourceFile(fileName) {
-    return exports.SOURCE_EXTS.includes(node_path_1.default.extname(fileName).toLowerCase());
-}
-function isHeaderFile(fileName) {
-    return [".h", ".hpp", ".hh"].includes(node_path_1.default.extname(fileName).toLowerCase());
-}
-function toLuauPath(filePath) {
-    return filePath.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
-}
-function isEngineStub(filePath) {
-    const normalized = filePath.replace(/\\/g, "/").toLowerCase();
-    return (normalized.includes("/include/cluaupp/") ||
-        normalized.includes("/include/cluau/") ||
-        normalized.endsWith("/roblox.hpp") ||
-        normalized.endsWith("/roblox.h"));
-}
-function includeVariants(name) {
-    const variants = [name];
-    if (/\.h$/i.test(name)) {
-        variants.push(name.replace(/\.h$/i, ".hpp"), name.replace(/\.h$/i, ".hh"));
-    }
-    else if (/\.hpp$/i.test(name)) {
-        variants.push(name.replace(/\.hpp$/i, ".h"), name.replace(/\.hpp$/i, ".hh"));
-    }
-    else if (/\.hh$/i.test(name)) {
-        variants.push(name.replace(/\.hh$/i, ".h"), name.replace(/\.hh$/i, ".hpp"));
-    }
-    return [...new Set(variants)];
-}
-function siblingImplementation(headerPath) {
-    if (!headerPath || !isHeaderFile(headerPath)) {
-        return null;
-    }
-    const base = headerPath.replace(/\.(h|hpp|hh)$/i, "");
-    for (const ext of [".cpp", ".cc", ".cxx", ".c"]) {
-        if (node_fs_1.default.existsSync(base + ext)) {
-            return base + ext;
-        }
-    }
-    return null;
-}
-function siblingHeader(implPath) {
-    if (!implPath || isHeaderFile(implPath)) {
-        return null;
-    }
-    const base = String(implPath).replace(/\.(cpp|cc|cxx|c)$/i, "");
-    if (base === String(implPath)) {
-        return null;
-    }
-    for (const ext of [".h", ".hpp", ".hh"]) {
-        if (node_fs_1.default.existsSync(base + ext)) {
-            return base + ext;
-        }
-    }
-    return null;
-}
-function implOutName(rel) {
-    return String(rel)
-        .replace(/\\/g, "/")
-        .replace(/\.(cpp|cc|cxx|c)$/i, "Impl.luau");
-}
-function resolveInclude(name, fromFile, includeDirs) {
-    const bases = [node_path_1.default.dirname(fromFile), ...(includeDirs || [])];
-    for (const base of bases) {
-        for (const variant of includeVariants(name)) {
-            const candidate = node_path_1.default.resolve(base, variant);
-            if (node_fs_1.default.existsSync(candidate) && node_fs_1.default.statSync(candidate).isFile()) {
-                return candidate;
-            }
-        }
-    }
-    return null;
-}
-function scanHeaderExports(source) {
-    const consts = [];
-    const structs = [];
-    for (const match of String(source).matchAll(/\bconst\s+(?:int|bool|float|double|auto|string)\s+(\w+)/g)) {
-        if (!consts.includes(match[1])) {
-            consts.push(match[1]);
-        }
-    }
-    for (const match of String(source).matchAll(/\bstruct\s+(\w+)/g)) {
-        if (!structs.includes(match[1])) {
-            structs.push(match[1]);
-        }
-    }
-    const hasProtos = /\b(?:void|int|bool|float|double|auto|string|[\w:]+)\s+\w+\s*\([^;]*\)\s*;/.test(String(source));
-    return { consts, structs, hasProtos };
-}
-function pushModuleInclude(options, resolved, impl) {
-    options.moduleIncludes = options.moduleIncludes || [];
-    const srcDir = options.srcDir || null;
-    const moduleFile = impl || resolved;
-    const rel = srcDir ? node_path_1.default.relative(srcDir, moduleFile).replace(/\\/g, "/") : node_path_1.default.basename(moduleFile);
-    const headerText = node_fs_1.default.readFileSync(resolved, "utf8");
-    options.moduleIncludes.push({
-        name: node_path_1.default.basename(resolved).replace(/\.(h|hpp|hh)$/i, ""),
-        outRel: rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau"),
-        header: resolved,
-        impl: impl || null,
-        exports: scanHeaderExports(headerText),
-    });
-}
-function applyPragmas(source, options) {
-    let nstrict = false;
-    let strict = false;
-    for (const line of String(source).split(/\r?\n/)) {
-        if (/^\s*#\s*pragma\s+nstrict\b/i.test(line)) {
-            nstrict = true;
-        }
-        else if (/^\s*#\s*pragma\s+strict\b/i.test(line)) {
-            strict = true;
-        }
-    }
-    if (nstrict) {
-        options.strict = false;
-    }
-    else if (strict) {
-        options.strict = true;
-    }
-}
-function preprocess(source, filePath, options = {}) {
-    if (!options.pragmaResolved) {
-        options.pragmaResolved = true;
-        applyPragmas(source, options);
-    }
-    const seen = options.seen || new Set();
-    options.seen = seen;
-    const includeDirs = options.includeDirs || [];
-    const resolvedSelf = filePath ? node_path_1.default.resolve(filePath) : null;
-    if (resolvedSelf) {
-        seen.add(resolvedSelf);
-    }
-    const lines = String(source).split(/\r?\n/);
-    const out = [];
-    for (const line of lines) {
-        const quoted = line.match(/^\s*#\s*include\s+"([^"]+)"/);
-        if (quoted) {
-            const resolved = resolveInclude(quoted[1], filePath || process.cwd(), includeDirs);
-            if (!resolved || isEngineStub(resolved) || seen.has(resolved)) {
-                continue;
-            }
-            const impl = siblingImplementation(resolved);
-            const including = filePath ? node_path_1.default.resolve(filePath) : null;
-            const ownHeader = Boolean(impl && including && node_path_1.default.resolve(impl) === including);
-            if (!ownHeader) {
-                pushModuleInclude(options, resolved, impl);
-                continue;
-            }
-            seen.add(resolved);
-            const inner = node_fs_1.default.readFileSync(resolved, "utf8");
-            out.push(preprocess(inner, resolved, { ...options, seen }));
-            continue;
-        }
-        if (/^\s*#\s*include\s+</.test(line)) {
-            continue;
-        }
-        out.push(line);
-    }
-    return out.join("\n");
-}
+exports.siblingHeader = exports.toLuauPath = exports.isEngineStub = exports.isHeaderFile = exports.isSourceFile = exports.SOURCE_EXTS = void 0;
+var paths_js_1 = require("./clpp/paths.js");
+Object.defineProperty(exports, "SOURCE_EXTS", { enumerable: true, get: function () { return paths_js_1.SOURCE_EXTS; } });
+Object.defineProperty(exports, "isSourceFile", { enumerable: true, get: function () { return paths_js_1.isSourceFile; } });
+Object.defineProperty(exports, "isHeaderFile", { enumerable: true, get: function () { return paths_js_1.isHeaderFile; } });
+Object.defineProperty(exports, "isEngineStub", { enumerable: true, get: function () { return paths_js_1.isEngineStub; } });
+Object.defineProperty(exports, "toLuauPath", { enumerable: true, get: function () { return paths_js_1.toLuauPath; } });
+Object.defineProperty(exports, "siblingHeader", { enumerable: true, get: function () { return paths_js_1.siblingHeader; } });

package/generated/system-understander.js

@@ -11,7 +11,7 @@ exports.scoreIntents = scoreIntents;
 exports.determineArchitecture = determineArchitecture;
 exports.understandSystem = understandSystem;
 const node_path_1 = __importDefault(require("node:path"));
-const EXT = "(cpp|cc|cxx|c|h|hpp|hh)";
+const EXT = "(clpp|clp|clh)";
 const EXT_REGEX = new RegExp(`\\.${EXT}$`, "i");
 const SCORE_THRESHOLD = 2;
 const TREE_NAME_TYPES = new Set([

package/generated/transpile.js

@@ -3,64 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectState = collectState;
 exports.transpileSource = transpileSource;
+exports.transpileSourceAsync = transpileSourceAsync;
 exports.outputNameFor = outputNameFor;
 const node_path_1 = __importDefault(require("node:path"));
-const collector_js_1 = require("./parser/collector.js");
-const index_js_1 = require("./parser/index.js");
-const luau_codegen_js_1 = require("./emitter/luau-codegen.js");
 const compile_js_1 = require("./compile.js");
-const system_understander_js_1 = require("./system-understander.js");
-function shouldMerge(name, contents) {
-    const file = String(name || "").replace(/\\/g, "/");
-    if (/\.json$/i.test(file) || /\.meta\.json$/i.test(file)) {
-        return false;
-    }
-    const trimmed = String(contents || "").trim();
-    return !(trimmed.startsWith("{") || trimmed.startsWith("["));
-}
-function collectState(source, mapper, options) {
-    const tree = (0, index_js_1.parseCpp)(source);
-    if (!tree) {
-        const state = luau_codegen_js_1.LuauCodeEmitter.emptyState(options.strict === true);
-        return state;
-    }
-    const collector = new collector_js_1.ASTCollector(mapper, {
-        fileName: options.relativeName || options.filePath || "input.cpp",
-        sourcePath: options.filePath,
-        srcDir: options.srcDir,
-        outDir: options.outDir,
-        strict: options.strict,
-    });
-    const state = collector.collect(tree.rootNode);
-    const report = (0, system_understander_js_1.determineArchitecture)(options.relativeName || options.filePath || "input.cpp", null, tree.rootNode);
-    for (const service of report.injectedServices) {
-        state.robloxServices.add(service);
-    }
-    for (const line of report.reasoning) {
-        state.headerLines.push(`-- ${line}`);
-    }
-    return state;
+function transpileSource(source, fileName, options, _mapper) {
+    return (0, compile_js_1.compileService)(source, fileName, options);
 }
-function transpileSource(source, fileName, options, mapper) {
-    const state = collectState(source, mapper, options);
-    if (state.strict) {
-        options.strict = true;
-    }
-    const compiled = (0, compile_js_1.compileService)(source, fileName, options);
-    return {
-        ...compiled,
-        files: compiled.files.map((file) => ({
-            ...file,
-            contents: shouldMerge(file.name, file.contents) ? luau_codegen_js_1.LuauCodeEmitter.merge(state, file.contents) : file.contents,
-        })),
-    };
+function transpileSourceAsync(source, fileName, options, _mapper) {
+    return (0, compile_js_1.compileServiceAsync)(source, fileName, options);
 }
 function outputNameFor(inputFile, outputPath) {
     if (/\.luau$/i.test(outputPath)) {
         return outputPath;
     }
-    const base = node_path_1.default.basename(inputFile).replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+    const base = node_path_1.default.basename(inputFile).replace(/\.(clpp|clp|clh)$/i, ".luau");
     return node_path_1.default.join(outputPath, base);
 }

package/generated/utils/project.js

@@ -3,15 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSourcesFiles = void 0;
 exports.loadConfig = loadConfig;
 exports.collectCpp = collectCpp;
 exports.build = build;
+exports.buildAsync = buildAsync;
 exports.init = init;
 exports.watch = watch;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const package_info_js_1 = require("../package-info.js");
-const preprocess_js_1 = require("../preprocess.js");
+const paths_js_1 = require("../clpp/paths.js");
 const intellisense_js_1 = require("../intellisense.js");
 const process_orchestrator_js_1 = require("./process-orchestrator.js");
 const rojo_mapper_js_1 = require("./rojo-mapper.js");
@@ -142,27 +144,16 @@ function copyRuntime(dest) {
     syncDir(runtime, node_path_1.default.join(dest, "libs"));
 }
 function copyHeaders(dest) {
-    const from = node_path_1.default.join(__dirname, "..", "..", "include", "cluaupp");
+    const from = node_path_1.default.join(__dirname, "..", "..", "include", "clpp");
     if (!node_fs_1.default.existsSync(from)) {
         return;
     }
-    syncDir(from, node_path_1.default.join(dest, "include", "cluaupp"));
+    syncDir(from, node_path_1.default.join(dest, "include", "clpp"));
 }
 function collectCpp(dir, files = []) {
-    if (!node_fs_1.default.existsSync(dir)) {
-        return files;
-    }
-    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()) {
-            collectCpp(full, files);
-        }
-        else if ((0, preprocess_js_1.isSourceFile)(entry.name)) {
-            files.push(full);
-        }
-    }
-    return files;
+    return (0, paths_js_1.collectSources)(dir, files);
 }
+exports.collectSourcesFiles = paths_js_1.collectSources;
 function collectFiles(dir, files = []) {
     if (!node_fs_1.default.existsSync(dir)) {
         return files;
@@ -186,9 +177,9 @@ function posixRel(from, file) {
     return node_path_1.default.relative(from, file).replace(/\\/g, "/");
 }
 function sourcePrefixes(rel) {
-    const noExt = rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, "");
+    const noExt = rel.replace(/\.(clpp|clp|clh)$/i, "");
     const noTag = noExt.replace(/\.(server|client)$/i, "");
-    return [...new Set([noExt, noTag, (0, preprocess_js_1.toLuauPath)(rel).replace(/\\/g, "/")])];
+    return [...new Set([noExt, noTag, (0, paths_js_1.toLuauPath)(rel).replace(/\\/g, "/")])];
 }
 function matchesPrefix(relOut, prefixes) {
     const n = relOut.replace(/\\/g, "/").toLowerCase();
@@ -251,25 +242,47 @@ function createMapper(root, config, rojoPath) {
     mapper.loadSync();
     return mapper;
 }
+function compileOptions(root, config, file, rel) {
+    const srcDir = node_path_1.default.join(root, config.rootDir);
+    return {
+        ...config,
+        filePath: file,
+        relativeName: rel,
+        outName: (0, paths_js_1.toLuauPath)(rel),
+        architecture: config.architecture === true,
+        includeDirs: [node_path_1.default.dirname(file), srcDir, node_path_1.default.join(root, "include")],
+        srcDir,
+        outDir: config.outDir,
+    };
+}
 function compileProject(root, config, mapper) {
     const srcDir = node_path_1.default.join(root, config.rootDir);
-    const files = collectCpp(srcDir);
+    const files = (0, paths_js_1.collectSources)(srcDir);
     const jobs = [];
     const errors = [];
     for (const file of files) {
         const source = node_fs_1.default.readFileSync(file, "utf8");
         const rel = posixRel(srcDir, file);
         try {
-            const result = (0, transpile_js_1.transpileSource)(source, rel, {
-                ...config,
-                filePath: file,
-                relativeName: rel,
-                outName: (0, preprocess_js_1.toLuauPath)(rel),
-                architecture: config.architecture === true,
-                includeDirs: [node_path_1.default.dirname(file), srcDir, node_path_1.default.join(root, "include")],
-                srcDir,
-                outDir: config.outDir,
-            }, mapper);
+            const result = (0, transpile_js_1.transpileSource)(source, rel, compileOptions(root, config, file, rel), mapper);
+            jobs.push({ rel, files: result.files, stale: result.stale || [] });
+        }
+        catch (err) {
+            errors.push({ rel, prefixes: sourcePrefixes(rel), message: err.message });
+        }
+    }
+    return { files, jobs, errors };
+}
+async function compileProjectAsync(root, config, mapper) {
+    const srcDir = node_path_1.default.join(root, config.rootDir);
+    const files = (0, paths_js_1.collectSources)(srcDir);
+    const jobs = [];
+    const errors = [];
+    for (const file of files) {
+        const source = node_fs_1.default.readFileSync(file, "utf8");
+        const rel = posixRel(srcDir, file);
+        try {
+            const result = await (0, transpile_js_1.transpileSourceAsync)(source, rel, compileOptions(root, config, file, rel), mapper);
             jobs.push({ rel, files: result.files, stale: result.stale || [] });
         }
         catch (err) {
@@ -332,27 +345,10 @@ function ensureVendor(root) {
     copyRuntime(root);
     copyHeaders(root);
 }
-function build(root, options = {}) {
+function finishBuild(root, config, compiled, options) {
     const exitOnError = options.exitOnError !== false;
     const holdOnError = options.holdOnError === true;
     const format = options.format === true;
-    const config = loadConfig(root);
-    if (options.syncVendor !== false) {
-        ensureVendor(root);
-    }
-    const srcDir = node_path_1.default.join(root, config.rootDir);
-    if (!node_fs_1.default.existsSync(srcDir) || collectCpp(srcDir).length === 0) {
-        console.error("no .cpp/.h/.hpp files in", config.rootDir);
-        if (!holdOnError) {
-            pruneOut(root, config, new Set(), []);
-        }
-        if (exitOnError) {
-            process.exit(1);
-        }
-        return { failed: 0, written: new Set() };
-    }
-    const mapper = createMapper(root, config, options.rojo);
-    const compiled = compileProject(root, config, mapper);
     if (compiled.errors.length > 0) {
         for (const err of compiled.errors) {
             console.error(err.message);
@@ -392,6 +388,45 @@ function build(root, options = {}) {
     }
     return { failed: compiled.errors.length, written };
 }
+function prepareBuild(root, options) {
+    const exitOnError = options.exitOnError !== false;
+    const holdOnError = options.holdOnError === true;
+    const config = loadConfig(root);
+    if (options.strict === true) {
+        config.strict = true;
+    }
+    if (options.syncVendor !== false) {
+        ensureVendor(root);
+    }
+    const srcDir = node_path_1.default.join(root, config.rootDir);
+    if (!node_fs_1.default.existsSync(srcDir) || (0, paths_js_1.collectSources)(srcDir).length === 0) {
+        console.error("no .clpp/.clp/.clh files in", config.rootDir);
+        if (!holdOnError) {
+            pruneOut(root, config, new Set(), []);
+        }
+        if (exitOnError) {
+            process.exit(1);
+        }
+        return null;
+    }
+    return { config, mapper: createMapper(root, config, options.rojo) };
+}
+function build(root, options = {}) {
+    const prepared = prepareBuild(root, options);
+    if (!prepared) {
+        return { failed: 0, written: new Set() };
+    }
+    const compiled = compileProject(root, prepared.config, prepared.mapper);
+    return finishBuild(root, prepared.config, compiled, options);
+}
+async function buildAsync(root, options = {}) {
+    const prepared = prepareBuild(root, options);
+    if (!prepared) {
+        return { failed: 0, written: new Set() };
+    }
+    const compiled = await compileProjectAsync(root, prepared.config, prepared.mapper);
+    return finishBuild(root, prepared.config, compiled, options);
+}
 async function init(dest) {
     const target = (0, safe_paths_js_1.assertInitDest)(dest);
     const template = node_path_1.default.join(__dirname, "..", "..", "templates", "game");
@@ -400,16 +435,11 @@ async function init(dest) {
     copyDir(include, node_path_1.default.join(target, "include"));
     copyRuntime(target);
     (0, intellisense_js_1.syncEditorSupport)(target);
-    const installed = await (0, intellisense_js_1.installEditorSupport)();
     console.log("Cluaupp ready in", target);
+    console.log("  clpp install          (CL++ highlighting + IntelliSense)");
     console.log("  rokit install");
     console.log("  cluaupp build");
     console.log("  rojo serve");
-    if (installed.local.length ||
-        (installed.clangd && (installed.clangd.status === "installed" || installed.clangd.status === "already")) ||
-        (installed.llvm && (installed.llvm.status === "installed" || installed.llvm.status === "already"))) {
-        console.log("  reload Cursor (Ctrl+Shift+P → Developer: Reload Window)");
-    }
 }
 function pidAlive(pid) {
     try {
@@ -452,7 +482,6 @@ function acquireWatchLock(root) {
 }
 function watch(root, options = {}) {
     acquireWatchLock(root);
-    build(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo });
     const config = loadConfig(root);
     const dir = node_path_1.default.join(root, config.rootDir);
     let timer = null;
@@ -464,24 +493,23 @@ function watch(root, options = {}) {
             return;
         }
         running = true;
-        try {
-            build(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo });
-        }
-        catch (err) {
+        void buildAsync(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo })
+            .catch((err) => {
             console.error(err.message);
-        }
-        finally {
+        })
+            .finally(() => {
             running = false;
             if (queued) {
                 queued = false;
                 run();
             }
-        }
+        });
     };
     console.log("cluaupp", package_info_js_1.pkg.version, "watching", dir, "(libs untouched)");
     if (!node_fs_1.default.existsSync(dir)) {
         node_fs_1.default.mkdirSync(dir, { recursive: true });
     }
+    run();
     node_fs_1.default.watch(dir, { recursive: true }, () => {
         if (timer) {
             clearTimeout(timer);