cluaupp 0.2.3 → 1.3.0

package/src/intellisense.ts

@@ -1,12 +1,12 @@
 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 { spawnSync } from "node:child_process";
 import { pkg, projectRoot as PACKAGE_ROOT } from "./package-info.js";
 import type { ProjectConfig } from "./types.js";
-import type { PreprocessOptions } from "./ast.js";
+import { CLPP_INSTALL_HINT } from "./clpp/contract.js";
+import { hasClpp } from "./clpp/runner.js";
+import { isSourceFile } from "./clpp/paths.js";
 
 export type CluauppDiagnostic = {
 	line: number;
@@ -15,57 +15,6 @@ export type CluauppDiagnostic = {
 	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 copyDir(from: string, to: string): void {
 	fs.mkdirSync(to, { recursive: true });
 	for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
@@ -96,17 +45,6 @@ function uniqueStrings(...lists: unknown[]): string[] {
 	return out;
 }
 
-function stripCppToolsSettings(current: Record<string, unknown>): Record<string, unknown> {
-	const next: Record<string, unknown> = {};
-	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: string): Record<string, unknown> {
 	if (!fs.existsSync(file)) {
 		return {};
@@ -117,7 +55,7 @@ function readJsonObject(file: string): Record<string, unknown> {
 			return parsed as Record<string, unknown>;
 		}
 	} catch {
-		// ignore corrupt editor json
+		// ignore
 	}
 	return {};
 }
@@ -131,62 +69,6 @@ function writeJson(file: string, value: Record<string, unknown>): void {
 	fs.writeFileSync(file, json, "utf8");
 }
 
-function clangdEditorArgs(): string[] {
-	return [
-		"--compile-commands-dir=${workspaceFolder}",
-		"--header-insertion=never",
-		"--query-driver=**/clang++*,**/clang++.exe,**/g++*,**/g++.exe",
-	];
-}
-
-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 settingsPath = path.join(root, ".vscode", "settings.json");
 	const current = readJsonObject(settingsPath);
@@ -194,19 +76,15 @@ function writeVscode(root: string): void {
 		...((current["files.associations"] && typeof current["files.associations"] === "object" && !Array.isArray(current["files.associations"]))
 			? (current["files.associations"] as Record<string, unknown>)
 			: {}),
-		"*.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,
 	});
 
@@ -214,44 +92,19 @@ function writeVscode(root: string): void {
 	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 = path.join(root, ".vscode", "c_cpp_properties.json");
-	if (fs.existsSync(props)) {
-		fs.unlinkSync(props);
-	}
 }
 
-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 diagnosticsFor(_source?: string, _fileName?: string): CluauppDiagnostic[] {
+	// Language diagnostics belong to `clpp install`. Do not spawn `clpp api compile`
+	// from the editor — that duplicates source=clpp and freezes on every keystroke.
+	return [];
 }
 
-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);
+export function syncEditorSupport(root: string, _config: Partial<ProjectConfig> = {}): void {
 	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[] {
@@ -275,12 +128,19 @@ export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
 	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 };
+export async function installEditorSupport() {
+	const local = installEditorExtension();
+	if (hasClpp()) {
+		const result = 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:", CLPP_INSTALL_HINT);
+		}
+	} else {
+		console.log("cluaupp:", CLPP_INSTALL_HINT);
+	}
+	return { local };
 }
+
+export const isClppSource = isSourceFile;

package/src/libs.ts

@@ -248,7 +248,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/src/lsp.ts

@@ -1,4 +1,3 @@
-import path from "node:path";
 import {
 	createConnection,
 	ProposedFeatures,
@@ -6,19 +5,9 @@ import {
 	TextDocumentSyncKind,
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import { diagnosticsFor } from "./intellisense.js";
 import { pkg } from "./package-info.js";
 
-function uriPath(uri: string): string {
-	let file = String(uri || "").replace(/^file:\/\//, "");
-	if (/^\/[A-Za-z]:/.test(file)) {
-		file = file.slice(1);
-	}
-	return decodeURIComponent(file);
-}
-
-export function start(options: { projectRoot?: string } = {}): void {
-	const projectRoot = options.projectRoot || process.cwd();
+export function start(_options: { projectRoot?: string } = {}): void {
 	const connection = createConnection(ProposedFeatures.all);
 	const documents = new TextDocuments(TextDocument);
 
@@ -29,31 +18,13 @@ export function start(options: { projectRoot?: string } = {}): void {
 		serverInfo: { name: "cluaupp", version: pkg.version },
 	}));
 
-	const publish = (document: TextDocument) => {
-		const file = uriPath(document.uri);
-		const items = diagnosticsFor(document.getText(), file, {
-			filePath: file,
-			includeDirs: [path.dirname(file), path.join(projectRoot, "src"), path.join(projectRoot, "include")],
-		});
-		connection.sendDiagnostics({
-			uri: document.uri,
-			diagnostics: items.map((item) => ({
-				range: {
-					start: { line: Math.max(0, (item.line || 1) - 1), character: Math.max(0, (item.col || 1) - 1) },
-					end: { line: Math.max(0, (item.line || 1) - 1), character: Math.max(1, item.col || 1) },
-				},
-				severity: 1,
-				source: "cluaupp",
-				message: item.message,
-			})),
-		});
+	const clear = (uri: string) => {
+		connection.sendDiagnostics({ uri, diagnostics: [] });
 	};
 
-	documents.onDidOpen((event) => publish(event.document));
-	documents.onDidChangeContent((event) => publish(event.document));
-	documents.onDidClose((event) => {
-		connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
-	});
+	documents.onDidOpen((event) => clear(event.document.uri));
+	documents.onDidChangeContent((event) => clear(event.document.uri));
+	documents.onDidClose((event) => clear(event.document.uri));
 
 	documents.listen(connection);
 	connection.listen();

package/src/preprocess.ts

@@ -1,180 +1,8 @@
-import fs from "node:fs";
-import path from "node:path";
-import type { ModuleInclude, PreprocessOptions } from "./ast.js";
-
-export const SOURCE_EXTS = [".cpp", ".cc", ".cxx", ".c", ".h", ".hpp", ".hh"];
-
-export function isSourceFile(fileName: string): boolean {
-	return SOURCE_EXTS.includes(path.extname(fileName).toLowerCase());
-}
-
-export function isHeaderFile(fileName: string): boolean {
-	return [".h", ".hpp", ".hh"].includes(path.extname(fileName).toLowerCase());
-}
-
-export function toLuauPath(filePath: string): string {
-	return filePath.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
-}
-
-export function isEngineStub(filePath: string): boolean {
-	const normalized = filePath.replace(/\\/g, "/").toLowerCase();
-	return (
-		normalized.includes("/include/cluaupp/") ||
-		normalized.includes("/include/cluau/") ||
-		normalized.endsWith("/roblox.hpp") ||
-		normalized.endsWith("/roblox.h")
-	);
-}
-
-function includeVariants(name: string): string[] {
-	const variants = [name];
-	if (/\.h$/i.test(name)) {
-		variants.push(name.replace(/\.h$/i, ".hpp"), name.replace(/\.h$/i, ".hh"));
-	} else if (/\.hpp$/i.test(name)) {
-		variants.push(name.replace(/\.hpp$/i, ".h"), name.replace(/\.hpp$/i, ".hh"));
-	} else if (/\.hh$/i.test(name)) {
-		variants.push(name.replace(/\.hh$/i, ".h"), name.replace(/\.hh$/i, ".hpp"));
-	}
-	return [...new Set(variants)];
-}
-
-export function siblingImplementation(headerPath: string | null | undefined): string | null {
-	if (!headerPath || !isHeaderFile(headerPath)) {
-		return null;
-	}
-	const base = headerPath.replace(/\.(h|hpp|hh)$/i, "");
-	for (const ext of [".cpp", ".cc", ".cxx", ".c"]) {
-		if (fs.existsSync(base + ext)) {
-			return base + ext;
-		}
-	}
-	return null;
-}
-
-export function siblingHeader(implPath: string | null | undefined): string | null {
-	if (!implPath || isHeaderFile(implPath)) {
-		return null;
-	}
-	const base = String(implPath).replace(/\.(cpp|cc|cxx|c)$/i, "");
-	if (base === String(implPath)) {
-		return null;
-	}
-	for (const ext of [".h", ".hpp", ".hh"]) {
-		if (fs.existsSync(base + ext)) {
-			return base + ext;
-		}
-	}
-	return null;
-}
-
-export function implOutName(rel: string): string {
-	return String(rel)
-		.replace(/\\/g, "/")
-		.replace(/\.(cpp|cc|cxx|c)$/i, "Impl.luau");
-}
-
-export function resolveInclude(name: string, fromFile: string, includeDirs?: string[]): string | null {
-	const bases = [path.dirname(fromFile), ...(includeDirs || [])];
-	for (const base of bases) {
-		for (const variant of includeVariants(name)) {
-			const candidate = path.resolve(base, variant);
-			if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
-				return candidate;
-			}
-		}
-	}
-	return null;
-}
-
-export function scanHeaderExports(source: string): { consts: string[]; structs: string[]; hasProtos: boolean } {
-	const consts: string[] = [];
-	const structs: string[] = [];
-	for (const match of String(source).matchAll(/\bconst\s+(?:int|bool|float|double|auto|string)\s+(\w+)/g)) {
-		if (!consts.includes(match[1])) {
-			consts.push(match[1]);
-		}
-	}
-	for (const match of String(source).matchAll(/\bstruct\s+(\w+)/g)) {
-		if (!structs.includes(match[1])) {
-			structs.push(match[1]);
-		}
-	}
-	const hasProtos = /\b(?:void|int|bool|float|double|auto|string|[\w:]+)\s+\w+\s*\([^;]*\)\s*;/.test(String(source));
-	return { consts, structs, hasProtos };
-}
-
-function pushModuleInclude(options: PreprocessOptions, resolved: string, impl: string | null): void {
-	options.moduleIncludes = options.moduleIncludes || [];
-	const srcDir = options.srcDir || null;
-	const moduleFile = impl || resolved;
-	const rel = srcDir ? path.relative(srcDir, moduleFile).replace(/\\/g, "/") : path.basename(moduleFile);
-	const headerText = fs.readFileSync(resolved, "utf8");
-	options.moduleIncludes.push({
-		name: path.basename(resolved).replace(/\.(h|hpp|hh)$/i, ""),
-		outRel: rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau"),
-		header: resolved,
-		impl: impl || null,
-		exports: scanHeaderExports(headerText),
-	});
-}
-
-export function applyPragmas(source: string, options: PreprocessOptions): void {
-	let nstrict = false;
-	let strict = false;
-	for (const line of String(source).split(/\r?\n/)) {
-		if (/^\s*#\s*pragma\s+nstrict\b/i.test(line)) {
-			nstrict = true;
-		} else if (/^\s*#\s*pragma\s+strict\b/i.test(line)) {
-			strict = true;
-		}
-	}
-	if (nstrict) {
-		options.strict = false;
-	} else if (strict) {
-		options.strict = true;
-	}
-}
-
-export function preprocess(source: string, filePath: string | null, options: PreprocessOptions = {}): string {
-	if (!options.pragmaResolved) {
-		options.pragmaResolved = true;
-		applyPragmas(source, options);
-	}
-	const seen = options.seen || new Set<string>();
-	options.seen = seen;
-	const includeDirs = options.includeDirs || [];
-	const resolvedSelf = filePath ? path.resolve(filePath) : null;
-	if (resolvedSelf) {
-		seen.add(resolvedSelf);
-	}
-
-	const lines = String(source).split(/\r?\n/);
-	const out: string[] = [];
-
-	for (const line of lines) {
-		const quoted = line.match(/^\s*#\s*include\s+"([^"]+)"/);
-		if (quoted) {
-			const resolved = resolveInclude(quoted[1], filePath || process.cwd(), includeDirs);
-			if (!resolved || isEngineStub(resolved) || seen.has(resolved)) {
-				continue;
-			}
-			const impl = siblingImplementation(resolved);
-			const including = filePath ? path.resolve(filePath) : null;
-			const ownHeader = Boolean(impl && including && path.resolve(impl) === including);
-			if (!ownHeader) {
-				pushModuleInclude(options, resolved, impl);
-				continue;
-			}
-			seen.add(resolved);
-			const inner = fs.readFileSync(resolved, "utf8");
-			out.push(preprocess(inner, resolved, { ...options, seen }));
-			continue;
-		}
-		if (/^\s*#\s*include\s+</.test(line)) {
-			continue;
-		}
-		out.push(line);
-	}
-
-	return out.join("\n");
-}
+export {
+	SOURCE_EXTS,
+	isSourceFile,
+	isHeaderFile,
+	isEngineStub,
+	toLuauPath,
+	siblingHeader,
+} from "./clpp/paths.js";

package/src/system-understander.ts

@@ -40,7 +40,7 @@ export interface ArchitectureReport {
 	reasoning: string[];
 }
 
-const EXT = "(cpp|cc|cxx|c|h|hpp|hh)";
+const EXT = "(clpp|clp|clh)";
 const EXT_REGEX = new RegExp(`\\.${EXT}$`, "i");
 const SCORE_THRESHOLD = 2;
 

package/src/transpile.ts

@@ -1,64 +1,30 @@
 import path from "node:path";
-import type { CompileOptions, CompileServiceResult, TranspilerState } from "./types.js";
-import { ASTCollector } from "./parser/collector.js";
-import { parseCpp } from "./parser/index.js";
-import { LuauCodeEmitter } from "./emitter/luau-codegen.js";
-import { compileService } from "./compile.js";
-import { determineArchitecture } from "./system-understander.js";
+import type { CompileOptions, CompileServiceResult } from "./types.js";
+import { compileService, compileServiceAsync } from "./compile.js";
 import type { RojoMapper } from "./utils/rojo-mapper.js";
 
-function shouldMerge(name: string, contents: string): boolean {
-	const file = String(name || "").replace(/\\/g, "/");
-	if (/\.json$/i.test(file) || /\.meta\.json$/i.test(file)) {
-		return false;
-	}
-	const trimmed = String(contents || "").trim();
-	return !(trimmed.startsWith("{") || trimmed.startsWith("["));
+export function transpileSource(
+	source: string,
+	fileName: string,
+	options: CompileOptions,
+	_mapper?: RojoMapper,
+): CompileServiceResult {
+	return compileService(source, fileName, options);
 }
 
-export function collectState(source: string, mapper: RojoMapper, options: CompileOptions): TranspilerState {
-	const tree = parseCpp(source);
-	if (!tree) {
-		const state = LuauCodeEmitter.emptyState(options.strict === true);
-		return state;
-	}
-	const collector = new ASTCollector(mapper, {
-		fileName: options.relativeName || options.filePath || "input.cpp",
-		sourcePath: options.filePath,
-		srcDir: options.srcDir,
-		outDir: options.outDir,
-		strict: options.strict,
-	});
-	const state = collector.collect(tree.rootNode);
-	const report = determineArchitecture(options.relativeName || options.filePath || "input.cpp", null, tree.rootNode);
-	for (const service of report.injectedServices) {
-		state.robloxServices.add(service);
-	}
-	for (const line of report.reasoning) {
-		state.headerLines.push(`-- ${line}`);
-	}
-	return state;
-}
-
-export function transpileSource(source: string, fileName: string, options: CompileOptions, mapper: RojoMapper): CompileServiceResult {
-	const state = collectState(source, mapper, options);
-	if (state.strict) {
-		options.strict = true;
-	}
-	const compiled = compileService(source, fileName, options);
-	return {
-		...compiled,
-		files: compiled.files.map((file) => ({
-			...file,
-			contents: shouldMerge(file.name, file.contents) ? LuauCodeEmitter.merge(state, file.contents) : file.contents,
-		})),
-	};
+export function transpileSourceAsync(
+	source: string,
+	fileName: string,
+	options: CompileOptions,
+	_mapper?: RojoMapper,
+): Promise<CompileServiceResult> {
+	return compileServiceAsync(source, fileName, options);
 }
 
 export function outputNameFor(inputFile: string, outputPath: string): string {
 	if (/\.luau$/i.test(outputPath)) {
 		return outputPath;
 	}
-	const base = path.basename(inputFile).replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+	const base = path.basename(inputFile).replace(/\.(clpp|clp|clh)$/i, ".luau");
 	return path.join(outputPath, base);
 }

package/src/types.ts

@@ -53,6 +53,7 @@ export interface BuildOptions {
 	format?: boolean;
 	analyze?: boolean;
 	rojo?: string;
+	strict?: boolean;
 }
 
 export interface BuildResult {