cluaupp 0.2.2 → 1.0.0

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/emit.js

@@ -31,6 +31,7 @@ function emit(ast, options = {}) {
         }
     }
     const ownedFns = (ast.body || []).filter((decl) => decl.type === "function");
+    const hasOwnedMethods = ownedFns.some((decl) => Boolean(decl.owner));
     const classModule = ownedFns.length > 0 && ownedFns.every((decl) => Boolean(decl.owner));
     const nestedTypes = new Set();
     for (const decl of ast.body || []) {
@@ -131,6 +132,35 @@ function emit(ast, options = {}) {
         }
         return linesOut;
     };
+    const isStringConcatCall = (node) => node && node.type === "call" && !node.object && node.name === "string_concat";
+    const emitStringConcat = (args) => {
+        const parts = (args || []).map(emitExpr);
+        if (parts.length === 0) {
+            return `""`;
+        }
+        if (parts.length === 1) {
+            return parts[0];
+        }
+        return `(${parts.join(" .. ")})`;
+    };
+    const isStringExpr = (node) => {
+        if (!node) {
+            return false;
+        }
+        if (node.type === "string") {
+            return true;
+        }
+        if (isStringConcatCall(node)) {
+            return true;
+        }
+        if (node.type === "binary" && node.op === "+" && (isStringExpr(node.left) || isStringExpr(node.right))) {
+            return true;
+        }
+        if (node.type === "member" && (node.name === "Name" || node.name === "Text" || node.name === "DisplayName")) {
+            return true;
+        }
+        return false;
+    };
     const emitExpr = (node) => {
         if (!node) {
             return "nil";
@@ -153,6 +183,28 @@ function emit(ast, options = {}) {
                 }
                 return `{ ${entries.join(", ")} }`;
             }
+            case "cast":
+                if (node.valueType === "void") {
+                    return emitExpr(node.argument);
+                }
+                return emitExpr(node.argument);
+            case "lambda": {
+                const params = (node.params || [])
+                    .map((param) => {
+                    if (typeof param === "string") {
+                        return param;
+                    }
+                    const typeAnn = (0, api_js_1.luauType)(param.valueType);
+                    return typeAnn ? `${param.name}: ${typeAnn}` : param.name;
+                })
+                    .join(", ");
+                const inner = [];
+                for (const stmt of node.body || []) {
+                    inner.push(...emitStmt(stmt, 1));
+                }
+                const body = inner.length > 0 ? `\n${inner.join("\n")}\n` : "\n";
+                return `function(${params})${body}end`;
+            }
             case "unary": {
                 const inner = emitExpr(node.argument);
                 if (node.op === "!") {
@@ -172,6 +224,9 @@ function emit(ast, options = {}) {
             case "member":
                 return `${emitExpr(node.object)}.${node.name}`;
             case "call": {
+                if (isStringConcatCall(node)) {
+                    return emitStringConcat(node.args);
+                }
                 const args = node.args.map(emitMethodArg).join(", ");
                 if (!node.object) {
                     if ((0, api_js_1.isDatatype)(node.name)) {
@@ -183,6 +238,9 @@ function emit(ast, options = {}) {
                     return `${node.name}(${args})`;
                 }
                 const obj = emitExpr(node.object);
+                if (classMethods.has(node.name) && !localNames.has(node.name)) {
+                    return `${obj}:${node.name}(${args})`;
+                }
                 if (node.access === "::" && node.object.type === "ident" && node.object.name === "cout") {
                     if (node.name === "endl") {
                         return "print()";
@@ -220,6 +278,9 @@ function emit(ast, options = {}) {
                         return printed.join("; ");
                     }
                 }
+                if (node.op === "+" && (isStringExpr(node.left) || isStringExpr(node.right))) {
+                    return `${emitExpr(node.left)} .. ${emitExpr(node.right)}`;
+                }
                 const ops = { "!=": "~=", "&&": "and", "||": "or" };
                 const op = ops[node.op] || node.op;
                 return `${emitExpr(node.left)} ${op} ${emitExpr(node.right)}`;
@@ -278,6 +339,9 @@ function emit(ast, options = {}) {
             return [`${prefix}${kind} ${node.name}${typed} = ${created.className}.new(${args})`];
         }
         const value = node.value ? emitExpr(node.value) : "nil";
+        if (!node.value && node.valueType && classOwners.has(node.valueType)) {
+            return [`${prefix}${kind} ${node.name}${typed} = ${node.valueType}`];
+        }
         return [`${prefix}${kind} ${node.name}${typed} = ${value}`];
     };
     const emitStmt = (node, indent) => {
@@ -290,6 +354,9 @@ function emit(ast, options = {}) {
                 return emitNewDecl(node, indent);
             case "expr": {
                 const expr = node.expr;
+                if (expr && expr.type === "cast" && expr.valueType === "void") {
+                    return [];
+                }
                 if (expr && expr.type === "binary" && expr.op === "<<") {
                     const printed = emitCout(expr);
                     if (printed) {
@@ -433,10 +500,8 @@ function emit(ast, options = {}) {
         lines.push("	}");
         lines.push("end");
         lines.push("");
-        lines.push(`return ${root}`);
-        lines.push("");
     };
-    if (classModule) {
+    if (hasOwnedMethods) {
         for (const owner of classOwners) {
             lines.push(`local ${owner} = {}`);
             lines.push("");
@@ -446,6 +511,17 @@ function emit(ast, options = {}) {
         for (const root of structRoots) {
             emitStructConstructor(root);
         }
+        if (structRoots.length === 1) {
+            lines.push(`return ${structRoots[0]}`);
+        }
+        else {
+            lines.push("return {");
+            for (const root of structRoots) {
+                lines.push(`	${root} = ${root},`);
+            }
+            lines.push("}");
+        }
+        lines.push("");
         return lines.join("\n");
     }
     for (const decl of ast.body) {

package/generated/intellisense.js

@@ -3,10 +3,7 @@ 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.isClppSource = void 0;
 exports.diagnosticsFor = diagnosticsFor;
 exports.syncEditorSupport = syncEditorSupport;
 exports.installEditorExtension = installEditorExtension;
@@ -14,83 +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],
-    };
-}
-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;
-}
+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 })) {
@@ -104,147 +29,90 @@ function copyDir(from, to) {
         }
     }
 }
-function clangdEditorArgs() {
-    return [
-        "--compile-commands-dir=${workspaceFolder}",
-        "--header-insertion=never",
-        "--query-driver=**/clang++*,**/clang++.exe,**/g++*,**/g++.exe",
-    ];
+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 intelliSenseMode() {
-    const arch = process.arch === "arm64" ? "arm64" : "x64";
-    if (process.platform === "win32") {
-        return `windows-clang-${arch}`;
+function readJsonObject(file) {
+    if (!node_fs_1.default.existsSync(file)) {
+        return {};
     }
-    if (process.platform === "darwin") {
-        return `macos-clang-${arch}`;
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
     }
-    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;
+    catch {
+        // ignore
     }
-    node_fs_1.default.writeFileSync(dest, json, "utf8");
-    return true;
+    return {};
 }
-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;
+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(dest, contents, "utf8");
-    return true;
+    node_fs_1.default.writeFileSync(file, json, "utf8");
 }
 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",
-        },
+    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"]
+            : {}),
+        "*.clpp": "clpp",
+        "*.clp": "clpp",
+        "*.clh": "clpp",
+        "*.server.clpp": "clpp",
+        "*.client.clpp": "clpp",
+        "*.plugin.clpp": "clpp",
+    };
+    writeJson(settingsPath, {
+        ...current,
+        "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),
+        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");
-    }
 }
-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");
@@ -266,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;