cluaupp 0.2.3 → 1.0.0

package/src/compile.ts

@@ -1,160 +1,37 @@
-import fs from "node:fs";
 import path from "node:path";
-import { parse } from "./parse.js";
-import { emit } from "./emit.js";
-import { preprocess, isHeaderFile, toLuauPath, siblingImplementation, siblingHeader, implOutName } from "./preprocess.js";
-import { collectLibraries, insertPreamble } from "./libs.js";
-import { planOutput } from "./architecture.js";
-import { emitHeaderModule, primaryHeaderName } from "./headers.js";
-import type { AstNode, AstProgram, ModuleInclude, PreprocessOptions } from "./ast.js";
 import type { CompileOptions, CompileServiceResult } from "./types.js";
-
-function shouldAttachRequires(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();
-	if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-		return false;
-	}
-	return true;
-}
-
-function attachRequires(contents: string, source: string, ast: AstProgram, options: PreprocessOptions, outName: string): string {
-	if (!shouldAttachRequires(outName, contents)) {
-		return contents;
-	}
-	const libraries = String(contents).includes("CluauppLibs") ? [] : collectLibraries(source, ast);
-	return insertPreamble(contents, options.moduleIncludes || [], libraries, outName);
-}
-
-function posixRel(from: string, file: string): string {
-	return path.relative(from, file).replace(/\\/g, "/");
-}
-
-function declKey(decl: AstNode): string {
-	return `${decl.owner || ""}::${decl.name}`;
-}
-
-function mergeSiblingImpl(ast: AstProgram, implPath: string, options: PreprocessOptions): void {
-	const implOptions: PreprocessOptions = {
-		...options,
-		moduleIncludes: [],
-		seen: new Set(),
-		pragmaResolved: false,
-	};
-	const prepared = preprocess(fs.readFileSync(implPath, "utf8"), implPath, implOptions);
-	const implAst = parse(prepared, path.basename(implPath)) as AstProgram;
-	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: AstProgram, fileName: string, options: PreprocessOptions): void {
-	const headerPath = options.filePath || null;
-	const impl = headerPath ? siblingImplementation(headerPath) : null;
-	if (!impl) {
-		return;
-	}
-	mergeSiblingImpl(ast, impl, options);
-	const typeName = primaryHeaderName(ast, options.relativeName || fileName);
-	const implRel = options.srcDir ? posixRel(options.srcDir, impl) : path.basename(impl).replace(/\\/g, "/");
-	const implOut = implOutName(implRel);
-	options.headerImplName = `${typeName}Module`;
-	options.moduleIncludes = options.moduleIncludes || [];
-	if (!options.moduleIncludes.some((spec: ModuleInclude) => spec.name === options.headerImplName)) {
-		options.moduleIncludes.push({
-			name: options.headerImplName,
-			outRel: implOut,
-			exports: { consts: [], structs: [] },
-		});
-	}
-}
-
-function compileHeader(source: string, fileName: string, options: PreprocessOptions, ast: AstProgram): CompileServiceResult {
-	wireHeaderImpl(ast, fileName, options);
-	const rel = (options.relativeName || fileName || "header.h").replace(/\\/g, "/");
-	const outName = toLuauPath(rel);
-	const luau = attachRequires(emitHeaderModule(ast, options), source, ast, options, outName);
-	return {
-		kind: "module",
-		plan: { kind: "module", strict: options.strict === true },
-		files: [{ name: outName, contents: luau }],
-		stale: [],
-	};
-}
+import { compileViaClpp } from "./clpp/runner.js";
+import { clppLuauToGame, shouldSkipInit } from "./clpp/postprocess.js";
+import { emitKind, siblingHeader, toLuauPath } from "./clpp/paths.js";
 
 export function compileSource(source: string, fileName?: string, options: CompileOptions = {}): string {
-	const opts = options as PreprocessOptions;
-	opts.moduleIncludes = opts.moduleIncludes || [];
-	const prepared = preprocess(source, opts.filePath || null, opts);
-	const ast = parse(prepared, fileName || "input.cpp");
-	if (isHeaderFile(fileName || "") || isHeaderFile(opts.filePath || "")) {
-		return compileHeader(source, fileName || "header.h", opts, ast).files[0].contents;
-	}
-	const luau = emit(ast, opts);
-	return attachRequires(luau, source, ast, opts, opts.outName || fileName || "input.cpp");
+	return compileService(source, fileName, options).files[0]?.contents ?? "";
 }
 
 export function compileService(source: string, fileName?: string, options: CompileOptions = {}): CompileServiceResult {
-	const opts = options as PreprocessOptions;
-	opts.moduleIncludes = opts.moduleIncludes || [];
-	const prepared = preprocess(source, opts.filePath || null, opts);
-	const ast = parse(prepared, fileName || "input.cpp");
-	if (isHeaderFile(fileName || "") || isHeaderFile(opts.filePath || "") || isHeaderFile(opts.relativeName || "")) {
-		return compileHeader(source, fileName || "header.h", opts, ast);
-	}
-	const implHeader = opts.filePath ? siblingHeader(opts.filePath) : null;
-	if (implHeader) {
-		opts.skipInit = true;
-	}
-	const planned = 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 || toLuauPath(relative);
+	const header = options.filePath ? siblingHeader(options.filePath) : null;
+	const skipInit = options.skipInit === true || shouldSkipInit(relative, Boolean(header));
+	const diskPath = options.filePath ? path.resolve(options.filePath) : null;
+	const artifact = compileViaClpp({
+		source,
+		fileName: diskPath ? diskPath.replace(/\\/g, "/") : relative,
+		strict: options.strict,
+		cwd: diskPath ? path.dirname(diskPath) : options.srcDir,
+	});
+	const luau = 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: { name: string; contents: string }) => ({
-				...file,
-				contents: attachRequires(file.contents, source, ast, opts, file.name),
-			})),
-		};
-	}
-	const luau = attachRequires(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: emitKind(relative),
+		plan: { kind: emitKind(relative), strict: options.strict === true },
+		files: [{ name: outName, contents: luau }],
+		stale: [],
 	};
 }

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 { compileViaClpp, 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,30 @@ 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[] {
+export function diagnosticsFor(source: string, fileName?: string): CluauppDiagnostic[] {
+	if (!hasClpp()) {
+		return [];
+	}
 	try {
-		const prepared = options.filePath ? preprocess(source, options.filePath, options) : source;
-		parse(prepared, fileName || "input.cpp");
+		compileViaClpp({ source, fileName: fileName || "input.clpp" });
 		return [];
 	} catch (err) {
-		const error = err as { message?: string; line?: number; col?: number };
-		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" }];
 	}
 }
 
-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 +139,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,
@@ -31,10 +30,7 @@ export function start(options: { projectRoot?: string } = {}): void {
 
 	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")],
-		});
+		const items = diagnosticsFor(document.getText(), file);
 		connection.sendDiagnostics({
 			uri: document.uri,
 			diagnostics: items.map((item) => ({

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;