cluaupp 0.1.4 → 0.2.0

package/generated/intellisense.js

@@ -0,0 +1,277 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intelliSenseMode = intelliSenseMode;
+exports.clangPath = clangPath;
+exports.writeCompileCommands = writeCompileCommands;
+exports.writeClangd = writeClangd;
+exports.diagnosticsFor = diagnosticsFor;
+exports.syncEditorSupport = syncEditorSupport;
+exports.installEditorExtension = installEditorExtension;
+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 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],
+    };
+}
+function mergeJson(file, patch) {
+    let current = {};
+    if (node_fs_1.default.existsSync(file)) {
+        try {
+            current = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+        }
+        catch {
+            current = {};
+        }
+    }
+    const next = { ...current, ...patch };
+    for (const key of Object.keys(patch)) {
+        const value = patch[key];
+        const existing = current[key];
+        if (value && typeof value === "object" && !Array.isArray(value) && existing && typeof existing === "object" && !Array.isArray(existing)) {
+            next[key] = { ...existing, ...value };
+        }
+    }
+    const json = `${JSON.stringify(next, null, "\t")}\n`;
+    if (node_fs_1.default.existsSync(file) && node_fs_1.default.readFileSync(file, "utf8") === json) {
+        return false;
+    }
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
+    node_fs_1.default.writeFileSync(file, json, "utf8");
+    return true;
+}
+function copyDir(from, to) {
+    node_fs_1.default.mkdirSync(to, { recursive: true });
+    for (const entry of node_fs_1.default.readdirSync(from, { withFileTypes: true })) {
+        const src = node_path_1.default.join(from, entry.name);
+        const dest = node_path_1.default.join(to, entry.name);
+        if (entry.isDirectory()) {
+            copyDir(src, dest);
+        }
+        else {
+            node_fs_1.default.copyFileSync(src, dest);
+        }
+    }
+}
+function clangdEditorArgs() {
+    return [
+        "--compile-commands-dir=${workspaceFolder}",
+        "--header-insertion=never",
+        "--query-driver=**/clang++*,**/clang++.exe,**/g++*,**/g++.exe",
+    ];
+}
+function intelliSenseMode() {
+    const arch = process.arch === "arm64" ? "arm64" : "x64";
+    if (process.platform === "win32") {
+        return `windows-clang-${arch}`;
+    }
+    if (process.platform === "darwin") {
+        return `macos-clang-${arch}`;
+    }
+    return `linux-clang-${arch}`;
+}
+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 settings = node_path_1.default.join(root, ".vscode", "settings.json");
+    mergeJson(settings, {
+        "C_Cpp.intelliSenseEngine": "Disabled",
+        "C_Cpp.default.cppStandard": "c++20",
+        "C_Cpp.default.cStandard": "c17",
+        "C_Cpp.default.compilerPath": clangPath(),
+        "C_Cpp.default.intelliSenseMode": intelliSenseMode(),
+        "C_Cpp.default.includePath": ["${workspaceFolder}/include", "${workspaceFolder}/src"],
+        "clangd.enable": true,
+        "clangd.arguments": clangdEditorArgs(),
+        "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",
+        },
+    });
+    mergeJson(node_path_1.default.join(root, ".vscode", "extensions.json"), {
+        recommendations: ["llvm-vs-code-extensions.vscode-clangd"],
+    });
+    const props = node_path_1.default.join(root, ".vscode", "c_cpp_properties.json");
+    const nextProps = {
+        configurations: [
+            {
+                name: "Cluaupp",
+                compilerPath: clangPath(),
+                cStandard: "c17",
+                cppStandard: "c++20",
+                intelliSenseMode: intelliSenseMode(),
+                includePath: ["${workspaceFolder}/include", "${workspaceFolder}/src"],
+                forcedInclude: ["${workspaceFolder}/include/cluaupp/roblox.hpp"],
+                compileCommands: "${workspaceFolder}/compile_commands.json",
+                browse: {
+                    path: ["${workspaceFolder}/include", "${workspaceFolder}/src"],
+                    limitSymbolsToIncludedHeaders: true,
+                },
+            },
+        ],
+        version: 4,
+    };
+    const json = `${JSON.stringify(nextProps, null, "\t")}\n`;
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(props), { recursive: true });
+    if (!node_fs_1.default.existsSync(props) || node_fs_1.default.readFileSync(props, "utf8") !== json) {
+        node_fs_1.default.writeFileSync(props, json, "utf8");
+    }
+}
+function diagnosticsFor(source, fileName, options = {}) {
+    try {
+        const prepared = options.filePath ? (0, preprocess_js_1.preprocess)(source, options.filePath, options) : source;
+        (0, parse_js_1.parse)(prepared, fileName || "input.cpp");
+        return [];
+    }
+    catch (err) {
+        const error = err;
+        const message = error.message ? String(error.message) : "parse error";
+        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" }];
+    }
+}
+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);
+    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");
+    if (!node_fs_1.default.existsSync(from)) {
+        return [];
+    }
+    const id = `kartzdev.cluaupp-diagnostics-${package_info_js_1.pkg.version}`;
+    const homes = [node_path_1.default.join(node_os_1.default.homedir(), ".cursor", "extensions"), node_path_1.default.join(node_os_1.default.homedir(), ".vscode", "extensions")];
+    const installed = [];
+    for (const home of homes) {
+        if (!node_fs_1.default.existsSync(node_path_1.default.dirname(home))) {
+            continue;
+        }
+        node_fs_1.default.mkdirSync(home, { recursive: true });
+        const dest = node_path_1.default.join(home, id);
+        copyDir(from, dest);
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dest, "cluaupp.root"), node_path_1.default.resolve(cluauppRoot), "utf8");
+        installed.push(dest);
+    }
+    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 };
+}

package/generated/layout.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTRY_FN = exports.PRINCIPAL_FN = exports.CLEANUP_FN = exports.SECTION = void 0;
+exports.isJanitorDecl = isJanitorDecl;
+exports.isApiDecl = isApiDecl;
+exports.classifyDecl = classifyDecl;
+exports.organizeDecls = organizeDecls;
+exports.janitorNames = janitorNames;
+exports.emitSection = emitSection;
+exports.joinBlocks = joinBlocks;
+exports.commentLine = commentLine;
+exports.SECTION = {
+    api: "API",
+    constants: "CONSTANTS",
+    variables: "VARIABLES",
+    types: "TYPES",
+    support: "HELPERS FUNCTIONS",
+    principal: "MAIN FUNCTIONS",
+    cleanup: "JANITOR",
+    returns: "RETURN",
+};
+exports.CLEANUP_FN = /^(OnClose|OnPlayerRemoving|Cleanup|Shutdown|OnDestroy)$/i;
+exports.PRINCIPAL_FN = /^(init|start|main|setup)/i;
+exports.ENTRY_FN = /^(init|main)$/i;
+function isGetService(node) {
+    return Boolean(node && node.type === "getService");
+}
+function isDataServiceAlias(node) {
+    let current = node || undefined;
+    while (current && current.type === "member") {
+        if (current.object && current.object.type === "ident" && current.object.name === "DataService") {
+            return true;
+        }
+        current = current.object;
+    }
+    return false;
+}
+function isJanitorDecl(decl) {
+    if (!decl || decl.type !== "decl") {
+        return false;
+    }
+    const name = String(decl.name || "").toLowerCase();
+    const typeName = String(decl.valueType || "").toLowerCase();
+    const created = decl.value && decl.value.type === "new" && decl.value.className === "Janitor";
+    return name.includes("janitor") || typeName.includes("janitor") || created;
+}
+function isApiDecl(decl) {
+    if (!decl || decl.type !== "decl") {
+        return false;
+    }
+    return isGetService(decl.value) || isDataServiceAlias(decl.value);
+}
+function classifyDecl(decl) {
+    if (!decl || decl.type === "proto") {
+        return null;
+    }
+    if (decl.type === "decl") {
+        if (isApiDecl(decl)) {
+            return "api";
+        }
+        if (isJanitorDecl(decl)) {
+            return "variables";
+        }
+        if (decl.isConst) {
+            return "constants";
+        }
+        return "variables";
+    }
+    if (decl.type === "function") {
+        if (exports.CLEANUP_FN.test(decl.name || "")) {
+            return "cleanup";
+        }
+        if (exports.PRINCIPAL_FN.test(decl.name || "")) {
+            return "principal";
+        }
+        return "support";
+    }
+    return null;
+}
+function organizeDecls(keep) {
+    const groups = {
+        api: [],
+        constants: [],
+        variables: [],
+        support: [],
+        principal: [],
+        cleanup: [],
+    };
+    for (const decl of keep) {
+        const bucket = classifyDecl(decl);
+        if (bucket && groups[bucket]) {
+            groups[bucket].push(decl);
+        }
+    }
+    return groups;
+}
+function janitorNames(keep) {
+    return (keep || []).filter(isJanitorDecl).map((decl) => decl.name);
+}
+function emitSection(_title, body) {
+    const text = String(body || "").trimEnd();
+    if (!text) {
+        return "";
+    }
+    return `${text}\n\n`;
+}
+function joinBlocks(parts) {
+    return parts.filter((part) => Boolean(part && String(part).trim())).join("\n\n");
+}
+function commentLine(title) {
+    return `-- ${title}`;
+}

package/generated/lex.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = tokenize;
+const KEYWORDS = new Set([
+    "if",
+    "else",
+    "for",
+    "while",
+    "return",
+    "new",
+    "auto",
+    "const",
+    "void",
+    "int",
+    "bool",
+    "float",
+    "double",
+    "true",
+    "false",
+    "nullptr",
+    "class",
+    "struct",
+    "public",
+    "private",
+    "protected",
+    "namespace",
+    "using",
+    "template",
+    "typedef",
+    "extern",
+    "enum",
+    "switch",
+    "case",
+    "default",
+    "break",
+]);
+function tokenize(source) {
+    const tokens = [];
+    let i = 0;
+    let line = 1;
+    let col = 1;
+    const push = (type, value, startLine, startCol, start, end) => {
+        tokens.push({ type, value, line: startLine, col: startCol, start, end });
+    };
+    while (i < source.length) {
+        const c = source[i];
+        if (c === "\n") {
+            i += 1;
+            line += 1;
+            col = 1;
+            continue;
+        }
+        if (c === " " || c === "\t" || c === "\r") {
+            i += 1;
+            col += 1;
+            continue;
+        }
+        if (c === "#") {
+            while (i < source.length && source[i] !== "\n") {
+                i += 1;
+            }
+            continue;
+        }
+        if (c === "/" && source[i + 1] === "/") {
+            while (i < source.length && source[i] !== "\n") {
+                i += 1;
+            }
+            continue;
+        }
+        if (c === "/" && source[i + 1] === "*") {
+            i += 2;
+            col += 2;
+            while (i < source.length && !(source[i] === "*" && source[i + 1] === "/")) {
+                if (source[i] === "\n") {
+                    line += 1;
+                    col = 1;
+                }
+                else {
+                    col += 1;
+                }
+                i += 1;
+            }
+            i += 2;
+            col += 2;
+            continue;
+        }
+        const startLine = line;
+        const startCol = col;
+        if (c === '"') {
+            const start = i;
+            i += 1;
+            col += 1;
+            let value = "";
+            while (i < source.length && source[i] !== '"') {
+                if (source[i] === "\\" && i + 1 < source.length) {
+                    value += source[i] + source[i + 1];
+                    i += 2;
+                    col += 2;
+                    continue;
+                }
+                value += source[i];
+                i += 1;
+                col += 1;
+            }
+            i += 1;
+            col += 1;
+            push("string", value, startLine, startCol, start, i);
+            continue;
+        }
+        if (/[0-9]/.test(c)) {
+            const start = i;
+            let value = "";
+            while (i < source.length && /[0-9.]/.test(source[i])) {
+                value += source[i];
+                i += 1;
+                col += 1;
+            }
+            push("number", value, startLine, startCol, start, i);
+            continue;
+        }
+        if (/[A-Za-z_]/.test(c)) {
+            const start = i;
+            let value = "";
+            while (i < source.length && /[A-Za-z0-9_]/.test(source[i])) {
+                value += source[i];
+                i += 1;
+                col += 1;
+            }
+            push(KEYWORDS.has(value) ? "kw" : "ident", value, startLine, startCol, start, i);
+            continue;
+        }
+        const two = source.slice(i, i + 2);
+        const start = i;
+        if (["->", "==", "!=", "<=", ">=", "&&", "||", "::", "<<", ">>"].includes(two)) {
+            push("op", two, startLine, startCol, start, i + 2);
+            i += 2;
+            col += 2;
+            continue;
+        }
+        push("op", c, startLine, startCol, start, i + 1);
+        i += 1;
+        col += 1;
+    }
+    push("eof", "", line, col, source.length, source.length);
+    return tokens;
+}