cluaupp 0.2.1 → 0.2.3

package/generated/intellisense.js

@@ -3,7 +3,6 @@ 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;
@@ -65,32 +64,6 @@ function compileCommandEntry(root, file) {
         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 })) {
@@ -104,6 +77,55 @@ function copyDir(from, to) {
         }
     }
 }
+function uniqueStrings(...lists) {
+    const seen = new Set();
+    const out = [];
+    for (const list of lists) {
+        if (!Array.isArray(list)) {
+            continue;
+        }
+        for (const item of list) {
+            if (typeof item === "string" && item && !seen.has(item)) {
+                seen.add(item);
+                out.push(item);
+            }
+        }
+    }
+    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 {};
+    }
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore corrupt editor json
+    }
+    return {};
+}
+function writeJson(file, value) {
+    const json = `${JSON.stringify(value, null, "\t")}\n`;
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
+    if (node_fs_1.default.existsSync(file) && node_fs_1.default.readFileSync(file, "utf8") === json) {
+        return;
+    }
+    node_fs_1.default.writeFileSync(file, json, "utf8");
+}
 function clangdEditorArgs() {
     return [
         "--compile-commands-dir=${workspaceFolder}",
@@ -111,16 +133,6 @@ function clangdEditorArgs() {
         "--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++";
 }
@@ -167,54 +179,37 @@ Index:
     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"],
+    const settingsPath = node_path_1.default.join(root, ".vscode", "settings.json");
+    const current = readJsonObject(settingsPath);
+    const associations = {
+        ...((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",
+    };
+    writeJson(settingsPath, {
+        ...stripCppToolsSettings(current),
         "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",
-        },
+        "files.associations": associations,
     });
-    mergeJson(node_path_1.default.join(root, ".vscode", "extensions.json"), {
-        recommendations: ["llvm-vs-code-extensions.vscode-clangd"],
+    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"]),
+        unwantedRecommendations: uniqueStrings(extensions.unwantedRecommendations, ["ms-vscode.cpptools"]),
     });
     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");
+    if (node_fs_1.default.existsSync(props)) {
+        node_fs_1.default.unlinkSync(props);
     }
 }
 function diagnosticsFor(source, fileName, options = {}) {

package/generated/lex.js

@@ -33,6 +33,9 @@ const KEYWORDS = new Set([
     "case",
     "default",
     "break",
+    "static",
+    "constexpr",
+    "inline",
 ]);
 function tokenize(source) {
     const tokens = [];

package/generated/parse.js

@@ -46,21 +46,124 @@ function parse(source, fileName) {
         eat("op", ">");
         return name;
     };
+    const CAST_NAMES = new Set(["static_cast", "const_cast", "reinterpret_cast", "dynamic_cast"]);
+    function skipSpecifiers() {
+        let isConst = false;
+        while (at("kw", "static") || at("kw", "inline") || at("kw", "constexpr") || at("kw", "const")) {
+            if (at("kw", "constexpr") || at("kw", "const")) {
+                isConst = true;
+            }
+            i += 1;
+        }
+        return isConst;
+    }
+    function looksLikePrimaryStart() {
+        if (at("ident") || at("number") || at("string")) {
+            return true;
+        }
+        if (at("kw", "true") || at("kw", "false") || at("kw", "nullptr") || at("kw", "new")) {
+            return true;
+        }
+        return at("op", "(") || at("op", "{") || at("op", "[") || at("op", "-") || at("op", "!");
+    }
+    function parseLambda() {
+        eat("op", "[");
+        while (!at("eof") && !at("op", "]")) {
+            i += 1;
+        }
+        eat("op", "]");
+        const params = [];
+        if (at("op", "(")) {
+            i += 1;
+            if (!at("op", ")")) {
+                params.push(parseParam());
+                while (at("op", ",")) {
+                    i += 1;
+                    params.push(parseParam());
+                }
+            }
+            eat("op", ")");
+        }
+        const body = parseBlock();
+        return { type: "lambda", params, body };
+    }
+    function parseNamedCast() {
+        i += 1;
+        eat("op", "<");
+        const valueType = parseType() || "any";
+        eat("op", ">");
+        const args = parseArgs();
+        return { type: "cast", valueType, argument: args[0] || { type: "null" } };
+    }
+    function parseParenPrimary() {
+        eat("op", "(");
+        const saved = i;
+        skipSpecifiers();
+        const valueType = parseType();
+        if (valueType && at("op", ")")) {
+            i += 1;
+            if (looksLikePrimaryStart()) {
+                return { type: "cast", valueType, argument: parseUnary() };
+            }
+        }
+        i = saved;
+        const expr = parseExpr();
+        eat("op", ")");
+        return expr;
+    }
+    function eatGeneric() {
+        let text = "";
+        let depth = 0;
+        while (!at("eof")) {
+            const token = peek();
+            if (at("op", "<")) {
+                depth += 1;
+                text += "<";
+                i += 1;
+                continue;
+            }
+            if (at("op", ">")) {
+                depth -= 1;
+                text += ">";
+                i += 1;
+                if (depth === 0) {
+                    return text;
+                }
+                continue;
+            }
+            if (token.type === "string") {
+                text += `"${token.value}"`;
+            }
+            else {
+                text += token.value;
+            }
+            i += 1;
+        }
+        return text;
+    }
     function parseType() {
         if (at("kw", "const")) {
             i += 1;
         }
+        let name = null;
         if (at("kw", "auto") || at("kw", "void") || at("kw", "int") || at("kw", "bool") || at("kw", "float") || at("kw", "double")) {
-            const name = eat("kw").value;
-            while (at("op", "*")) {
+            name = eat("kw").value;
+        }
+        else if (at("ident")) {
+            name = eat("ident").value;
+            while (at("op", "::")) {
                 i += 1;
+                if (at("ident")) {
+                    name += `::${eat("ident").value}`;
+                }
             }
-            return name;
         }
-        if (!at("ident")) {
+        else {
             return null;
         }
-        const name = eat("ident").value;
+        if (at("op", "<")) {
+            name += eatGeneric();
+        }
         while (at("op", "*")) {
             i += 1;
         }
@@ -129,14 +232,17 @@ function parse(source, fileName) {
             eat("op", ")");
             return { type: "getService", service };
         }
+        if (at("ident") && CAST_NAMES.has(peek().value) && peek(1).value === "<") {
+            return parseNamedCast();
+        }
         if (at("ident")) {
             return { type: "ident", name: eat("ident").value };
         }
+        if (at("op", "[")) {
+            return parseLambda();
+        }
         if (at("op", "(")) {
-            i += 1;
-            const expr = parseExpr();
-            eat("op", ")");
-            return expr;
+            return parseParenPrimary();
         }
         if (at("op", "{")) {
             return parseInitList();
@@ -309,11 +415,8 @@ function parse(source, fileName) {
         throw error("only range-for is supported: for (auto* x : list)");
     }
     function parseDeclOrExpr() {
-        const isConst = at("kw", "const");
-        if (isConst) {
-            i += 1;
-        }
         const saved = i;
+        const isConst = skipSpecifiers();
         const maybeType = parseType();
         if (maybeType && at("ident") && (peek(1).value === "=" || peek(1).value === ";")) {
             const name = eat("ident").value;
@@ -325,9 +428,6 @@ function parse(source, fileName) {
             return { type: "decl", name, valueType: maybeType, value, isConst: isConst || maybeType === "const" };
         }
         i = saved;
-        if (isConst) {
-            i = saved - 1;
-        }
         return { type: "expr", expr: parseExpr() };
     }
     function parseStmt() {
@@ -380,6 +480,7 @@ function parse(source, fileName) {
         };
     }
     function parseFunction() {
+        skipSpecifiers();
         const returnType = parseType();
         if (!returnType || !at("ident")) {
             throw error("invalid function declaration");
@@ -449,10 +550,7 @@ function parse(source, fileName) {
                 continue;
             }
             const saved = i;
-            const isConst = at("kw", "const");
-            if (isConst) {
-                i += 1;
-            }
+            const isConst = skipSpecifiers();
             const valueType = parseType();
             if (valueType && at("ident")) {
                 if (peek(1).value === "(") {
@@ -573,10 +671,7 @@ function parse(source, fileName) {
                 continue;
             }
             const saved = i;
-            const isConst = at("kw", "const");
-            if (isConst) {
-                i += 1;
-            }
+            const isConst = skipSpecifiers();
             const maybeType = parseType();
             if (maybeType && at("ident")) {
                 const next = peek(1);

package/generated/parser/collector.js

@@ -1,7 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ASTCollector = void 0;
 exports.emptyState = emptyState;
+const node_path_1 = __importDefault(require("node:path"));
+const preprocess_js_1 = require("../preprocess.js");
 const translators_js_1 = require("../emitter/translators.js");
 function emptyState(strict = false) {
     return {
@@ -16,9 +21,11 @@ function emptyState(strict = false) {
 }
 class ASTCollector {
     mapper;
+    context;
     state;
     constructor(mapper, context = { fileName: "input.cpp" }) {
         this.mapper = mapper;
+        this.context = context;
         this.state = emptyState(context.strict === true);
     }
     collect(rootNode) {
@@ -58,12 +65,41 @@ class ASTCollector {
             }
         }
     }
+    includeTarget(raw) {
+        const from = this.context.sourcePath;
+        if (!from) {
+            return null;
+        }
+        const cleaned = raw.replace(/[<>'"]/g, "").trim();
+        if (!cleaned || raw.includes("<")) {
+            return null;
+        }
+        return node_path_1.default.resolve(node_path_1.default.dirname(from), cleaned);
+    }
+    isOwnHeader(raw) {
+        const from = this.context.sourcePath;
+        if (!from) {
+            return false;
+        }
+        const target = this.includeTarget(raw);
+        if (!target) {
+            return false;
+        }
+        if (node_path_1.default.resolve(from) === target) {
+            return true;
+        }
+        const header = (0, preprocess_js_1.siblingHeader)(from);
+        return Boolean(header && node_path_1.default.resolve(header) === target);
+    }
     collectInclude(node) {
         const pathNode = node.childForFieldName("path") || node.namedChildren[0] || node.child(1);
         if (!pathNode) {
             return;
         }
-        const resolved = this.mapper.resolveIncludeToRequire(pathNode.text);
+        if (this.isOwnHeader(pathNode.text)) {
+            return;
+        }
+        const resolved = this.mapper.resolveIncludeToRequire(pathNode.text, this.context.sourcePath);
         if (resolved) {
             this.state.moduleRequires.set(resolved.alias, resolved.path);
         }

package/generated/utils/rojo-mapper.js

@@ -64,7 +64,23 @@ class RojoMapper {
         this.config = (0, comment_json_1.parse)(content);
         this.bindings = this.walkTree(this.config.tree, []);
     }
-    resolveIncludeToRequire(includePath) {
+    resolveQuotedFile(raw, fromFile) {
+        const bases = [];
+        if (fromFile) {
+            bases.push(node_path_1.default.dirname(fromFile));
+        }
+        if (this.srcDir) {
+            bases.push(this.srcDir);
+        }
+        for (const base of bases) {
+            const candidate = node_path_1.default.resolve(base, raw);
+            if (node_fs_1.default.existsSync(candidate) && node_fs_1.default.statSync(candidate).isFile()) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+    resolveIncludeToRequire(includePath, fromFile) {
         const raw = includePath.replace(/[<>'"]/g, "").trim();
         if (!raw) {
             return null;
@@ -79,11 +95,15 @@ class RojoMapper {
         if (library) {
             return library;
         }
-        const fromTree = this.resolveFromRojoTree(cleanPath, baseName);
+        const resolvedFile = this.resolveQuotedFile(raw, fromFile);
+        const lookupPath = resolvedFile && this.srcDir
+            ? posix(node_path_1.default.relative(this.srcDir, resolvedFile)).replace(/\.h(pp|h)?$/i, "")
+            : cleanPath;
+        const fromTree = this.resolveFromRojoTree(lookupPath, baseName);
         if (fromTree) {
             return fromTree;
         }
-        const segments = cleanPath.split("/").filter(Boolean);
+        const segments = lookupPath.split("/").filter(Boolean);
         if (segments[0] === "src") {
             segments.shift();
         }

package/include/cluaupp/datatypes.hpp

@@ -17,6 +17,10 @@ using Enum::Axis;
 
 using string = const char*;
 
+// Variadic join. Cluaupp emits Luau a .. b .. c.
+template <typename... Args>
+string string_concat(Args... args);
+
 struct Instance;
 struct Player;