cluaupp 0.2.3 → 1.0.0

package/generated/clpp/runner.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasClpp = hasClpp;
+exports.resolveClppBinary = resolveClppBinary;
+exports.compileViaClpp = compileViaClpp;
+exports.clppManifest = clppManifest;
+exports.clppVersion = clppVersion;
+const node_child_process_1 = require("node:child_process");
+const contract_js_1 = require("./contract.js");
+const MISSING_CLPP = `cluaupp: clpp not found. ${contract_js_1.CLPP_INSTALL_HINT}`;
+function whichClpp() {
+    if (process.env.CLPP_PATH) {
+        return process.env.CLPP_PATH;
+    }
+    const finder = process.platform === "win32" ? "where" : "which";
+    const found = (0, node_child_process_1.spawnSync)(finder, ["clpp"], { encoding: "utf8", windowsHide: true });
+    if (found.status !== 0) {
+        return null;
+    }
+    const line = String(found.stdout || "")
+        .split(/\r?\n/)
+        .map((item) => item.trim())
+        .find((item) => item.length > 0);
+    return line || "clpp";
+}
+function hasClpp() {
+    return Boolean(whichClpp());
+}
+function resolveClppBinary() {
+    const bin = whichClpp();
+    if (!bin) {
+        throw new Error(MISSING_CLPP);
+    }
+    return bin;
+}
+function parseArtifact(stdout, fileName, fallbackError) {
+    const text = String(stdout || "").trim();
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return {
+        ok: false,
+        luau: "",
+        fileName,
+        outputHint: "",
+        scriptKind: null,
+        isScript: false,
+        isHeader: false,
+        rojoClass: "ModuleScript",
+        libraries: [],
+        error: fallbackError || "clpp returned invalid JSON",
+    };
+}
+function compileViaClpp(request) {
+    const bin = resolveClppBinary();
+    const payload = JSON.stringify({
+        source: request.source,
+        fileName: request.fileName,
+        strict: request.strict,
+    });
+    const result = (0, node_child_process_1.spawnSync)(bin, ["api", "compile"], {
+        input: payload,
+        encoding: "utf8",
+        cwd: request.cwd,
+        maxBuffer: 16 * 1024 * 1024,
+        windowsHide: true,
+    });
+    const stderr = String(result.stderr || "").trim();
+    const artifact = parseArtifact(result.stdout, request.fileName, stderr || result.error?.message || "clpp api compile failed");
+    if (!artifact.ok) {
+        throw new Error(artifact.error || stderr || `clpp failed (${result.status})`);
+    }
+    return artifact;
+}
+function clppManifest() {
+    const bin = resolveClppBinary();
+    const result = (0, node_child_process_1.spawnSync)(bin, ["api", "manifest"], {
+        encoding: "utf8",
+        windowsHide: true,
+    });
+    if (result.status !== 0) {
+        throw new Error(String(result.stderr || result.error?.message || "clpp api manifest failed"));
+    }
+    return JSON.parse(result.stdout);
+}
+function clppVersion() {
+    const bin = whichClpp();
+    if (!bin) {
+        return null;
+    }
+    const result = (0, node_child_process_1.spawnSync)(bin, ["--version"], { encoding: "utf8", windowsHide: true });
+    if (result.status !== 0) {
+        return null;
+    }
+    return String(result.stdout || "").trim() || null;
+}

package/generated/compile.js

@@ -5,149 +5,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileSource = compileSource;
 exports.compileService = compileService;
-const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const parse_js_1 = require("./parse.js");
-const emit_js_1 = require("./emit.js");
-const preprocess_js_1 = require("./preprocess.js");
-const libs_js_1 = require("./libs.js");
-const architecture_js_1 = require("./architecture.js");
-const headers_js_1 = require("./headers.js");
-function shouldAttachRequires(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();
-    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-        return false;
-    }
-    return true;
-}
-function attachRequires(contents, source, ast, options, outName) {
-    if (!shouldAttachRequires(outName, contents)) {
-        return contents;
-    }
-    const libraries = String(contents).includes("CluauppLibs") ? [] : (0, libs_js_1.collectLibraries)(source, ast);
-    return (0, libs_js_1.insertPreamble)(contents, options.moduleIncludes || [], libraries, outName);
-}
-function posixRel(from, file) {
-    return node_path_1.default.relative(from, file).replace(/\\/g, "/");
-}
-function declKey(decl) {
-    return `${decl.owner || ""}::${decl.name}`;
-}
-function mergeSiblingImpl(ast, implPath, options) {
-    const implOptions = {
-        ...options,
-        moduleIncludes: [],
-        seen: new Set(),
-        pragmaResolved: false,
-    };
-    const prepared = (0, preprocess_js_1.preprocess)(node_fs_1.default.readFileSync(implPath, "utf8"), implPath, implOptions);
-    const implAst = (0, parse_js_1.parse)(prepared, node_path_1.default.basename(implPath));
-    if (!Array.isArray(ast.body)) {
-        ast.body = [];
-    }
-    const existing = new Set((ast.body || [])
-        .filter((decl) => decl && (decl.type === "function" || decl.type === "proto") && decl.name)
-        .map(declKey));
-    for (const decl of implAst.body || []) {
-        if ((decl.type !== "function" && decl.type !== "proto") || !decl.name) {
-            continue;
-        }
-        const key = declKey(decl);
-        if (existing.has(key)) {
-            continue;
-        }
-        existing.add(key);
-        ast.body.push({
-            type: "proto",
-            name: decl.name,
-            owner: decl.owner,
-            returnType: decl.returnType,
-            params: decl.params,
-        });
-    }
-}
-function wireHeaderImpl(ast, fileName, options) {
-    const headerPath = options.filePath || null;
-    const impl = headerPath ? (0, preprocess_js_1.siblingImplementation)(headerPath) : null;
-    if (!impl) {
-        return;
-    }
-    mergeSiblingImpl(ast, impl, options);
-    const typeName = (0, headers_js_1.primaryHeaderName)(ast, options.relativeName || fileName);
-    const implRel = options.srcDir ? posixRel(options.srcDir, impl) : node_path_1.default.basename(impl).replace(/\\/g, "/");
-    const implOut = (0, preprocess_js_1.implOutName)(implRel);
-    options.headerImplName = `${typeName}Module`;
-    options.moduleIncludes = options.moduleIncludes || [];
-    if (!options.moduleIncludes.some((spec) => spec.name === options.headerImplName)) {
-        options.moduleIncludes.push({
-            name: options.headerImplName,
-            outRel: implOut,
-            exports: { consts: [], structs: [] },
-        });
-    }
-}
-function compileHeader(source, fileName, options, ast) {
-    wireHeaderImpl(ast, fileName, options);
-    const rel = (options.relativeName || fileName || "header.h").replace(/\\/g, "/");
-    const outName = (0, preprocess_js_1.toLuauPath)(rel);
-    const luau = attachRequires((0, headers_js_1.emitHeaderModule)(ast, options), source, ast, options, outName);
-    return {
-        kind: "module",
-        plan: { kind: "module", strict: options.strict === true },
-        files: [{ name: outName, contents: luau }],
-        stale: [],
-    };
-}
+const runner_js_1 = require("./clpp/runner.js");
+const postprocess_js_1 = require("./clpp/postprocess.js");
+const paths_js_1 = require("./clpp/paths.js");
 function compileSource(source, fileName, options = {}) {
-    const opts = options;
-    opts.moduleIncludes = opts.moduleIncludes || [];
-    const prepared = (0, preprocess_js_1.preprocess)(source, opts.filePath || null, opts);
-    const ast = (0, parse_js_1.parse)(prepared, fileName || "input.cpp");
-    if ((0, preprocess_js_1.isHeaderFile)(fileName || "") || (0, preprocess_js_1.isHeaderFile)(opts.filePath || "")) {
-        return compileHeader(source, fileName || "header.h", opts, ast).files[0].contents;
-    }
-    const luau = (0, emit_js_1.emit)(ast, opts);
-    return attachRequires(luau, source, ast, opts, opts.outName || fileName || "input.cpp");
+    return compileService(source, fileName, options).files[0]?.contents ?? "";
 }
 function compileService(source, fileName, options = {}) {
-    const opts = options;
-    opts.moduleIncludes = opts.moduleIncludes || [];
-    const prepared = (0, preprocess_js_1.preprocess)(source, opts.filePath || null, opts);
-    const ast = (0, parse_js_1.parse)(prepared, fileName || "input.cpp");
-    if ((0, preprocess_js_1.isHeaderFile)(fileName || "") || (0, preprocess_js_1.isHeaderFile)(opts.filePath || "") || (0, preprocess_js_1.isHeaderFile)(opts.relativeName || "")) {
-        return compileHeader(source, fileName || "header.h", opts, ast);
-    }
-    const implHeader = opts.filePath ? (0, preprocess_js_1.siblingHeader)(opts.filePath) : null;
-    if (implHeader) {
-        opts.skipInit = true;
-    }
-    const planned = (0, architecture_js_1.planOutput)(ast, fileName || "input.cpp", {
-        ...opts,
-        relativeName: opts.relativeName || fileName,
-        source: prepared,
-        siblingHeader: implHeader,
+    const relative = (options.relativeName || fileName || "input.clpp").replace(/\\/g, "/");
+    const outName = options.outName || (0, paths_js_1.toLuauPath)(relative);
+    const header = options.filePath ? (0, paths_js_1.siblingHeader)(options.filePath) : null;
+    const skipInit = options.skipInit === true || (0, postprocess_js_1.shouldSkipInit)(relative, Boolean(header));
+    const diskPath = options.filePath ? node_path_1.default.resolve(options.filePath) : null;
+    const artifact = (0, runner_js_1.compileViaClpp)({
+        source,
+        fileName: diskPath ? diskPath.replace(/\\/g, "/") : relative,
+        strict: options.strict,
+        cwd: diskPath ? node_path_1.default.dirname(diskPath) : options.srcDir,
+    });
+    const luau = (0, postprocess_js_1.clppLuauToGame)(artifact, {
+        relativeName: relative,
+        outName,
+        srcDir: options.srcDir,
+        rootDir: options.rootDir,
+        strict: options.strict,
+        skipInit,
     });
-    if (planned.files) {
-        return {
-            ...planned,
-            files: planned.files.map((file) => ({
-                ...file,
-                contents: attachRequires(file.contents, source, ast, opts, file.name),
-            })),
-        };
-    }
-    const luau = attachRequires((0, emit_js_1.emit)(ast, opts), source, ast, opts, planned.outName || opts.outName || fileName || "input.cpp");
-    const name = planned.outName ||
-        opts.outName ||
-        String(fileName || "input.cpp").replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
     return {
-        kind: planned.kind || "flat",
-        plan: planned.plan,
-        files: [{ name, contents: luau }],
-        stale: planned.stale || [],
+        kind: (0, paths_js_1.emitKind)(relative),
+        plan: { kind: (0, paths_js_1.emitKind)(relative), strict: options.strict === true },
+        files: [{ name: outName, contents: luau }],
+        stale: [],
     };
 }

package/generated/intellisense.js

@@ -3,9 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clangPath = clangPath;
-exports.writeCompileCommands = writeCompileCommands;
-exports.writeClangd = writeClangd;
+exports.isClppSource = void 0;
 exports.diagnosticsFor = diagnosticsFor;
 exports.syncEditorSupport = syncEditorSupport;
 exports.installEditorExtension = installEditorExtension;
@@ -13,57 +11,11 @@ exports.installEditorSupport = installEditorSupport;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
-const parse_js_1 = require("./parse.js");
-const preprocess_js_1 = require("./preprocess.js");
-const editor_install_js_1 = require("./editor-install.js");
+const node_child_process_1 = require("node:child_process");
 const package_info_js_1 = require("./package-info.js");
-function posix(file) {
-    return String(file).replace(/\\/g, "/");
-}
-function collectFiles(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()) {
-            collectFiles(full, files);
-        }
-        else {
-            files.push(full);
-        }
-    }
-    return files;
-}
-function isCppFile(file) {
-    return /\.(cpp|cc|cxx|c|h|hpp|hh)$/i.test(file);
-}
-function clangCompileArgs(root) {
-    const absRoot = posix(node_path_1.default.resolve(root));
-    const absInclude = posix(node_path_1.default.join(absRoot, "include"));
-    const absSrc = posix(node_path_1.default.join(absRoot, "src"));
-    const roblox = posix(node_path_1.default.join(absInclude, "cluaupp", "roblox.hpp"));
-    return [
-        "-xc++",
-        "-std=c++20",
-        "-ferror-limit=0",
-        "-I" + absInclude,
-        "-I" + absSrc,
-        "-Iinclude",
-        "-Isrc",
-        "-include",
-        roblox,
-    ];
-}
-function compileCommandEntry(root, file) {
-    const absRoot = posix(node_path_1.default.resolve(root));
-    const absFile = posix(node_path_1.default.resolve(file));
-    return {
-        directory: absRoot,
-        file: absFile,
-        arguments: [clangPath(), ...clangCompileArgs(root), "-c", absFile],
-    };
-}
+const contract_js_1 = require("./clpp/contract.js");
+const runner_js_1 = require("./clpp/runner.js");
+const paths_js_1 = require("./clpp/paths.js");
 function copyDir(from, to) {
     node_fs_1.default.mkdirSync(to, { recursive: true });
     for (const entry of node_fs_1.default.readdirSync(from, { withFileTypes: true })) {
@@ -93,16 +45,6 @@ function uniqueStrings(...lists) {
     }
     return out;
 }
-function stripCppToolsSettings(current) {
-    const next = {};
-    for (const [key, value] of Object.entries(current)) {
-        if (key === "C_Cpp" || key.startsWith("C_Cpp.")) {
-            continue;
-        }
-        next[key] = value;
-    }
-    return next;
-}
 function readJsonObject(file) {
     if (!node_fs_1.default.existsSync(file)) {
         return {};
@@ -114,7 +56,7 @@ function readJsonObject(file) {
         }
     }
     catch {
-        // ignore corrupt editor json
+        // ignore
     }
     return {};
 }
@@ -126,58 +68,6 @@ function writeJson(file, value) {
     }
     node_fs_1.default.writeFileSync(file, json, "utf8");
 }
-function clangdEditorArgs() {
-    return [
-        "--compile-commands-dir=${workspaceFolder}",
-        "--header-insertion=never",
-        "--query-driver=**/clang++*,**/clang++.exe,**/g++*,**/g++.exe",
-    ];
-}
-function clangPath() {
-    return (0, editor_install_js_1.findClangPlusPlus)() || "clang++";
-}
-function writeCompileCommands(root, srcDir) {
-    const files = collectFiles(srcDir).filter((file) => isCppFile(file)).sort();
-    const json = `${JSON.stringify(files.map((file) => compileCommandEntry(root, file)), null, "\t")}\n`;
-    const dest = node_path_1.default.join(root, "compile_commands.json");
-    if (node_fs_1.default.existsSync(dest) && node_fs_1.default.readFileSync(dest, "utf8") === json) {
-        return false;
-    }
-    node_fs_1.default.writeFileSync(dest, json, "utf8");
-    return true;
-}
-function writeClangd(root) {
-    const flags = clangCompileArgs(root)
-        .map((flag) => `    - ${flag}`)
-        .join("\n");
-    const contents = `CompileFlags:
-  CompilationDatabase: .
-  Add:
-${flags}
-
-Diagnostics:
-  Suppress: '*'
-
----
-If:
-  PathMatch: .*\\.(cpp|cc|cxx|c|h|hpp|hh)$
-CompileFlags:
-  Add:
-    - -xc++
-
----
-If:
-  PathMatch: (out|libs)/.*
-Index:
-  Background: Skip
-`;
-    const dest = node_path_1.default.join(root, ".clangd");
-    if (node_fs_1.default.existsSync(dest) && node_fs_1.default.readFileSync(dest, "utf8") === contents) {
-        return false;
-    }
-    node_fs_1.default.writeFileSync(dest, contents, "utf8");
-    return true;
-}
 function writeVscode(root) {
     const settingsPath = node_path_1.default.join(root, ".vscode", "settings.json");
     const current = readJsonObject(settingsPath);
@@ -185,61 +75,44 @@ function writeVscode(root) {
         ...((current["files.associations"] && typeof current["files.associations"] === "object" && !Array.isArray(current["files.associations"]))
             ? current["files.associations"]
             : {}),
-        "*.hpp": "cpp",
-        "*.h": "cpp",
-        "*.server.cpp": "cpp",
-        "*.client.cpp": "cpp",
-        "*.plugin.cpp": "cpp",
-        "*.legacy.cpp": "cpp",
-        "*.legacy.server.cpp": "cpp",
-        "*.legacy.client.cpp": "cpp",
+        "*.clpp": "clpp",
+        "*.clp": "clpp",
+        "*.clh": "clpp",
+        "*.server.clpp": "clpp",
+        "*.client.clpp": "clpp",
+        "*.plugin.clpp": "clpp",
     };
     writeJson(settingsPath, {
-        ...stripCppToolsSettings(current),
-        "clangd.enable": true,
-        "clangd.arguments": clangdEditorArgs(),
+        ...current,
         "files.associations": associations,
     });
     const extensionsPath = node_path_1.default.join(root, ".vscode", "extensions.json");
     const extensions = readJsonObject(extensionsPath);
     writeJson(extensionsPath, {
         ...extensions,
-        recommendations: uniqueStrings(extensions.recommendations, ["llvm-vs-code-extensions.vscode-clangd"]),
+        recommendations: uniqueStrings(extensions.recommendations),
         unwantedRecommendations: uniqueStrings(extensions.unwantedRecommendations, ["ms-vscode.cpptools"]),
     });
-    const props = node_path_1.default.join(root, ".vscode", "c_cpp_properties.json");
-    if (node_fs_1.default.existsSync(props)) {
-        node_fs_1.default.unlinkSync(props);
-    }
 }
-function diagnosticsFor(source, fileName, options = {}) {
+function diagnosticsFor(source, fileName) {
+    if (!(0, runner_js_1.hasClpp)()) {
+        return [];
+    }
     try {
-        const prepared = options.filePath ? (0, preprocess_js_1.preprocess)(source, options.filePath, options) : source;
-        (0, parse_js_1.parse)(prepared, fileName || "input.cpp");
+        (0, runner_js_1.compileViaClpp)({ source, fileName: fileName || "input.clpp" });
         return [];
     }
     catch (err) {
-        const error = err;
-        const message = error.message ? String(error.message) : "parse error";
+        const message = err instanceof Error ? err.message : String(err);
         const match = message.match(/:(\d+):(\d+):\s*(.*)$/);
         if (match) {
             return [{ line: Number(match[1]), col: Number(match[2]), message: match[3], severity: "error" }];
         }
-        return [{ line: error.line || 1, col: error.col || 1, message, severity: "error" }];
+        return [{ line: 1, col: 1, message, severity: "error" }];
     }
 }
-function syncEditorSupport(root, config = {}) {
-    const srcDir = node_path_1.default.join(root, config.rootDir || "src");
-    if (node_fs_1.default.existsSync(srcDir)) {
-        writeCompileCommands(root, srcDir);
-    }
-    writeClangd(root);
+function syncEditorSupport(root, _config = {}) {
     writeVscode(root);
-    const flags = ["-xc++", "-std=c++20", "-ferror-limit=0", "-Iinclude", "-Isrc", "-include", "include/cluaupp/roblox.hpp"].join("\n") + "\n";
-    const flagsFile = node_path_1.default.join(root, "compile_flags.txt");
-    if (!node_fs_1.default.existsSync(flagsFile) || node_fs_1.default.readFileSync(flagsFile, "utf8") !== flags) {
-        node_fs_1.default.writeFileSync(flagsFile, flags, "utf8");
-    }
 }
 function installEditorExtension(cluauppRoot = package_info_js_1.projectRoot) {
     const from = node_path_1.default.join(cluauppRoot, "editors", "vscode");
@@ -261,12 +134,20 @@ function installEditorExtension(cluauppRoot = package_info_js_1.projectRoot) {
     }
     return installed;
 }
-async function installEditorSupport(cluauppRoot = package_info_js_1.projectRoot) {
-    const local = installEditorExtension(cluauppRoot);
-    const llvm = (0, editor_install_js_1.ensureLlvm)();
-    (0, editor_install_js_1.reportInstall)(llvm, "LLVM clang++");
-    const clangd = await (0, editor_install_js_1.installMarketplaceExtension)(editor_install_js_1.CLANGD_ID, "clangd (LLVM)");
-    (0, editor_install_js_1.reportInstall)(clangd, "clangd");
-    console.log("cluaupp: C++ completion is clangd — reload the editor (Ctrl+Shift+P → Developer: Reload Window)");
-    return { local, llvm, clangd };
+async function installEditorSupport() {
+    const local = installEditorExtension();
+    if ((0, runner_js_1.hasClpp)()) {
+        const result = (0, node_child_process_1.spawnSync)("clpp", ["install"], { encoding: "utf8", windowsHide: true });
+        if (result.status === 0) {
+            console.log(String(result.stderr || result.stdout || "clpp install ok").trim());
+        }
+        else {
+            console.log("cluaupp:", contract_js_1.CLPP_INSTALL_HINT);
+        }
+    }
+    else {
+        console.log("cluaupp:", contract_js_1.CLPP_INSTALL_HINT);
+    }
+    return { local };
 }
+exports.isClppSource = paths_js_1.isSourceFile;

package/generated/libs.js

@@ -259,7 +259,7 @@ function walk(node, visit) {
 function modulesFromIncludes(source) {
     const found = new Set();
     for (const line of String(source).split(/\r?\n/)) {
-        const match = line.match(/^\s*#\s*include\s+<cluaupp\/(?:libs\/)?([A-Za-z0-9]+)\.hpp>/);
+        const match = line.match(/^\s*#\s*include\s+<(?:clpp|cluaupp)\/(?:libs\/)?([A-Za-z0-9]+)\.(?:clh|hpp)>/);
         if (!match) {
             continue;
         }

package/generated/lsp.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.start = start;
-const node_path_1 = __importDefault(require("node:path"));
 const node_1 = require("vscode-languageserver/node");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
 const intellisense_js_1 = require("./intellisense.js");
@@ -28,10 +24,7 @@ function start(options = {}) {
     }));
     const publish = (document) => {
         const file = uriPath(document.uri);
-        const items = (0, intellisense_js_1.diagnosticsFor)(document.getText(), file, {
-            filePath: file,
-            includeDirs: [node_path_1.default.dirname(file), node_path_1.default.join(projectRoot, "src"), node_path_1.default.join(projectRoot, "include")],
-        });
+        const items = (0, intellisense_js_1.diagnosticsFor)(document.getText(), file);
         connection.sendDiagnostics({
             uri: document.uri,
             diagnostics: items.map((item) => ({