cluaupp 0.1.4 → 0.2.0

package/src/headers.ts

@@ -0,0 +1,233 @@
+// @ts-nocheck
+import path from "node:path";
+import { luauType } from "./api.js";
+
+function fileStem(fileName) {
+	return path.basename(String(fileName || "module")).replace(/\.(h|hpp|hh|cpp|cc|cxx|c)$/i, "");
+}
+
+function emitValue(node) {
+	if (!node) {
+		return "nil";
+	}
+	if (node.type === "number") {
+		return node.value;
+	}
+	if (node.type === "string") {
+		return `"${node.value}"`;
+	}
+	if (node.type === "bool") {
+		return node.value ? "true" : "false";
+	}
+	if (node.type === "null") {
+		return "nil";
+	}
+	if (node.type === "initlist") {
+		const inner = (node.fields || []).map((field) => `${field.name} = ${emitValue(field.value)}`).join(", ");
+		return `{ ${inner} }`;
+	}
+	return "nil";
+}
+
+function collectHeaderShape(ast, fileName) {
+	const owners = new Map();
+	const ensure = (name) => {
+		if (!owners.has(name)) {
+			owners.set(name, { fields: [], methods: [] });
+		}
+		return owners.get(name);
+	};
+	const freeProtos = [];
+	const consts = [];
+	for (const decl of ast.body || []) {
+		if (decl.type === "decl" && decl.owner) {
+			ensure(decl.owner).fields.push(decl);
+			continue;
+		}
+		if (decl.type === "decl") {
+			consts.push(decl);
+			continue;
+		}
+		if ((decl.type === "proto" || decl.type === "function") && decl.owner) {
+			ensure(decl.owner).methods.push(decl);
+			continue;
+		}
+		if (decl.type === "proto") {
+			freeProtos.push(decl);
+		}
+	}
+	const nested = new Set();
+	for (const [ownerName, spec] of owners) {
+		for (const field of spec.fields) {
+			if (field.valueType && owners.has(field.valueType) && field.valueType !== ownerName) {
+				nested.add(field.valueType);
+			}
+		}
+	}
+	const roots = [...owners.keys()].filter((name) => !nested.has(name));
+	const withMethods = roots.filter((name) => ensure(name).methods.length > 0);
+	const stem = fileStem(fileName);
+	let primary = withMethods[0] || (freeProtos.length ? stem : roots[0] || stem);
+	return { owners, nested, roots, freeProtos, consts, primary, stem };
+}
+
+function primaryHeaderName(ast, fileName) {
+	return collectHeaderShape(ast, fileName).primary;
+}
+
+function methodType(fn, owner) {
+	const params = [];
+	if (owner) {
+		params.push(`self: ${owner}`);
+	}
+	for (const param of fn.params || []) {
+		if (typeof param === "string") {
+			params.push(param);
+			continue;
+		}
+		const typeAnn = luauType(param.valueType);
+		params.push(typeAnn ? `${param.name}: ${typeAnn}` : param.name);
+	}
+	const ret = luauType(fn.returnType);
+	const retAnn = !ret || ret === "()" ? "()" : ret;
+	return `(${params.join(", ")}) -> ${retAnn}`;
+}
+
+function fieldType(field, owners) {
+	if (field.valueType && owners.has(field.valueType)) {
+		return field.valueType;
+	}
+	return luauType(field.valueType) || "any";
+}
+
+function emitExportType(lines, name, spec, owners, extraMethods, extraFields) {
+	lines.push(`export type ${name} = {`);
+	const seen = new Set();
+	for (const field of [...((spec && spec.fields) || []), ...(extraFields || [])]) {
+		if (!field.name || seen.has(field.name)) {
+			continue;
+		}
+		seen.add(field.name);
+		lines.push(`	${field.name}: ${fieldType(field, owners)},`);
+	}
+	for (const method of (spec && spec.methods) || []) {
+		if (!method.name || seen.has(method.name)) {
+			continue;
+		}
+		seen.add(method.name);
+		lines.push(`	${method.name}: ${methodType(method, name)},`);
+	}
+	for (const method of extraMethods || []) {
+		if (!method.name || seen.has(method.name)) {
+			continue;
+		}
+		seen.add(method.name);
+		lines.push(`	${method.name}: ${methodType(method, null)},`);
+	}
+	lines.push("}");
+	lines.push("");
+}
+
+function emitDataConstructor(lines, name, spec, owners) {
+	const emitField = (field) => {
+		if (field.valueType && owners.has(field.valueType)) {
+			const nested = owners.get(field.valueType);
+			const inner = nested.fields.map((item) => `${item.name} = ${emitValue(item.value)}`).join(", ");
+			return `{ ${inner} }`;
+		}
+		if (field.value && field.value.type === "initlist") {
+			return emitValue(field.value);
+		}
+		return emitValue(field.value);
+	};
+	lines.push(`const function ${name}(): ${name}`);
+	lines.push("	return {");
+	for (const field of spec.fields) {
+		lines.push(`		${field.name} = ${emitField(field)},`);
+	}
+	lines.push("	}");
+	lines.push("end");
+	lines.push("");
+}
+
+function emitHeaderModule(ast, options = {}) {
+	const strict = options.strict === true;
+	const fileName = options.relativeName || options.filePath || "header.h";
+	const shape = collectHeaderShape(ast, fileName);
+	const lines = [];
+	if (strict) {
+		lines.push("--!strict");
+	}
+	lines.push("-- Compiled by Cluaupp — C++ × Luau");
+	lines.push("");
+
+	const typeOrder = [...shape.nested, ...shape.roots];
+	for (const name of typeOrder) {
+		const extra = name === shape.primary ? shape.freeProtos : [];
+		emitExportType(lines, name, shape.owners.get(name), shape.owners, extra);
+	}
+	if (shape.freeProtos.length && !shape.owners.has(shape.primary)) {
+		emitExportType(lines, shape.primary, { fields: [], methods: [] }, shape.owners, shape.freeProtos, shape.consts);
+	}
+
+	for (const decl of shape.consts) {
+		const typeAnn = luauType(decl.valueType);
+		const typed = typeAnn ? `: ${typeAnn}` : "";
+		lines.push(`const ${decl.name}${typed} = ${emitValue(decl.value)}`);
+	}
+	if (shape.consts.length) {
+		lines.push("");
+	}
+
+	const hasMethods = shape.roots.some((name) => shape.owners.get(name).methods.length > 0) || shape.freeProtos.length > 0;
+	const implName = hasMethods ? options.headerImplName : null;
+
+	if (!hasMethods && shape.roots.length > 0) {
+		for (const name of shape.roots) {
+			emitDataConstructor(lines, name, shape.owners.get(name), shape.owners);
+		}
+		lines.push(`return ${shape.primary}`);
+		lines.push("");
+		return lines.join("\n");
+	}
+
+	if (!hasMethods && shape.consts.length > 0) {
+		lines.push("return {");
+		for (const decl of shape.consts) {
+			lines.push(`	${decl.name} = ${decl.name},`);
+		}
+		lines.push("}");
+		lines.push("");
+		return lines.join("\n");
+	}
+
+	const tableName = shape.primary;
+	const spec = shape.owners.get(tableName) || { fields: [], methods: [] };
+	const methods = [...spec.methods, ...shape.freeProtos];
+	lines.push(`const ${tableName}: ${tableName} = {`);
+	if (implName) {
+		for (const field of spec.fields) {
+			if (field.valueType && shape.owners.has(field.valueType) && field.valueType !== tableName) {
+				continue;
+			}
+			lines.push(`	${field.name} = ${implName}.${field.name},`);
+		}
+		for (const method of methods) {
+			lines.push(`	${method.name} = ${implName}.${method.name},`);
+		}
+	}
+	for (const decl of shape.consts) {
+		lines.push(`	${decl.name} = ${decl.name},`);
+	}
+	lines.push("}");
+	lines.push("");
+	lines.push(`return ${tableName}`);
+	lines.push("");
+	return lines.join("\n");
+}
+
+export {
+	emitHeaderModule,
+	primaryHeaderName,
+	collectHeaderShape,
+};

package/src/intellisense.ts

@@ -0,0 +1,286 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { parse } from "./parse.js";
+import { preprocess } from "./preprocess.js";
+import { findClangPlusPlus, installMarketplaceExtension, ensureLlvm, CLANGD_ID, reportInstall } from "./editor-install.js";
+import { pkg, projectRoot as PACKAGE_ROOT } from "./package-info.js";
+import type { ProjectConfig } from "./types.js";
+import type { PreprocessOptions } from "./ast.js";
+
+export type CluauppDiagnostic = {
+	line: number;
+	col: number;
+	message: string;
+	severity: "error";
+};
+
+function posix(file: string): string {
+	return String(file).replace(/\\/g, "/");
+}
+
+function collectFiles(dir: string, files: string[] = []): string[] {
+	if (!fs.existsSync(dir)) {
+		return files;
+	}
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			collectFiles(full, files);
+		} else {
+			files.push(full);
+		}
+	}
+	return files;
+}
+
+function isCppFile(file: string): boolean {
+	return /\.(cpp|cc|cxx|c|h|hpp|hh)$/i.test(file);
+}
+
+function clangCompileArgs(root: string): string[] {
+	const absRoot = posix(path.resolve(root));
+	const absInclude = posix(path.join(absRoot, "include"));
+	const absSrc = posix(path.join(absRoot, "src"));
+	const roblox = posix(path.join(absInclude, "cluaupp", "roblox.hpp"));
+	return [
+		"-xc++",
+		"-std=c++20",
+		"-ferror-limit=0",
+		"-I" + absInclude,
+		"-I" + absSrc,
+		"-Iinclude",
+		"-Isrc",
+		"-include",
+		roblox,
+	];
+}
+
+function compileCommandEntry(root: string, file: string) {
+	const absRoot = posix(path.resolve(root));
+	const absFile = posix(path.resolve(file));
+	return {
+		directory: absRoot,
+		file: absFile,
+		arguments: [clangPath(), ...clangCompileArgs(root), "-c", absFile],
+	};
+}
+
+function mergeJson(file: string, patch: Record<string, unknown>): boolean {
+	let current: Record<string, unknown> = {};
+	if (fs.existsSync(file)) {
+		try {
+			current = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
+		} catch {
+			current = {};
+		}
+	}
+	const next: Record<string, unknown> = { ...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 as Record<string, unknown>), ...(value as Record<string, unknown>) };
+		}
+	}
+	const json = `${JSON.stringify(next, null, "\t")}\n`;
+	if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === json) {
+		return false;
+	}
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	fs.writeFileSync(file, json, "utf8");
+	return true;
+}
+
+function copyDir(from: string, to: string): void {
+	fs.mkdirSync(to, { recursive: true });
+	for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+		const src = path.join(from, entry.name);
+		const dest = path.join(to, entry.name);
+		if (entry.isDirectory()) {
+			copyDir(src, dest);
+		} else {
+			fs.copyFileSync(src, dest);
+		}
+	}
+}
+
+function clangdEditorArgs(): string[] {
+	return [
+		"--compile-commands-dir=${workspaceFolder}",
+		"--header-insertion=never",
+		"--query-driver=**/clang++*,**/clang++.exe,**/g++*,**/g++.exe",
+	];
+}
+
+export function intelliSenseMode(): string {
+	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}`;
+}
+
+export function clangPath(): string {
+	return findClangPlusPlus() || "clang++";
+}
+
+export function writeCompileCommands(root: string, srcDir: string): boolean {
+	const files = collectFiles(srcDir).filter((file) => isCppFile(file)).sort();
+	const json = `${JSON.stringify(files.map((file) => compileCommandEntry(root, file)), null, "\t")}\n`;
+	const dest = path.join(root, "compile_commands.json");
+	if (fs.existsSync(dest) && fs.readFileSync(dest, "utf8") === json) {
+		return false;
+	}
+	fs.writeFileSync(dest, json, "utf8");
+	return true;
+}
+
+export function writeClangd(root: string): boolean {
+	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 = path.join(root, ".clangd");
+	if (fs.existsSync(dest) && fs.readFileSync(dest, "utf8") === contents) {
+		return false;
+	}
+	fs.writeFileSync(dest, contents, "utf8");
+	return true;
+}
+
+function writeVscode(root: string): void {
+	const settings = path.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(path.join(root, ".vscode", "extensions.json"), {
+		recommendations: ["llvm-vs-code-extensions.vscode-clangd"],
+	});
+	const props = path.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`;
+	fs.mkdirSync(path.dirname(props), { recursive: true });
+	if (!fs.existsSync(props) || fs.readFileSync(props, "utf8") !== json) {
+		fs.writeFileSync(props, json, "utf8");
+	}
+}
+
+export function diagnosticsFor(source: string, fileName?: string, options: PreprocessOptions = {}): CluauppDiagnostic[] {
+	try {
+		const prepared = options.filePath ? preprocess(source, options.filePath, options) : source;
+		parse(prepared, fileName || "input.cpp");
+		return [];
+	} catch (err) {
+		const error = err as { message?: string; line?: number; col?: number };
+		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" }];
+	}
+}
+
+export function syncEditorSupport(root: string, config: Partial<ProjectConfig> = {}): void {
+	const srcDir = path.join(root, config.rootDir || "src");
+	if (fs.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 = path.join(root, "compile_flags.txt");
+	if (!fs.existsSync(flagsFile) || fs.readFileSync(flagsFile, "utf8") !== flags) {
+		fs.writeFileSync(flagsFile, flags, "utf8");
+	}
+}
+
+export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
+	const from = path.join(cluauppRoot, "editors", "vscode");
+	if (!fs.existsSync(from)) {
+		return [];
+	}
+	const id = `kartzdev.cluaupp-diagnostics-${pkg.version}`;
+	const homes = [path.join(os.homedir(), ".cursor", "extensions"), path.join(os.homedir(), ".vscode", "extensions")];
+	const installed: string[] = [];
+	for (const home of homes) {
+		if (!fs.existsSync(path.dirname(home))) {
+			continue;
+		}
+		fs.mkdirSync(home, { recursive: true });
+		const dest = path.join(home, id);
+		copyDir(from, dest);
+		fs.writeFileSync(path.join(dest, "cluaupp.root"), path.resolve(cluauppRoot), "utf8");
+		installed.push(dest);
+	}
+	return installed;
+}
+
+export async function installEditorSupport(cluauppRoot = PACKAGE_ROOT) {
+	const local = installEditorExtension(cluauppRoot);
+	const llvm = ensureLlvm();
+	reportInstall(llvm, "LLVM clang++");
+	const clangd = await installMarketplaceExtension(CLANGD_ID, "clangd (LLVM)");
+	reportInstall(clangd, "clangd");
+	console.log("cluaupp: C++ completion is clangd — reload the editor (Ctrl+Shift+P → Developer: Reload Window)");
+	return { local, llvm, clangd };
+}