cluaupp 0.2.2 → 1.0.0

package/src/clpp/paths.ts

@@ -0,0 +1,117 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const SOURCE_EXTS = [".clpp", ".clp", ".clh"];
+
+export function isSourceFile(fileName: string): boolean {
+	return SOURCE_EXTS.includes(path.extname(fileName).toLowerCase());
+}
+
+export function isEngineStub(filePath: string): boolean {
+	const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+	return (
+		normalized.includes("/include/cluaupp/") ||
+		normalized.includes("/include/clpp/") ||
+		normalized.includes("/include/cluau/") ||
+		normalized.includes("/stdlib/") ||
+		normalized.endsWith("/roblox.hpp") ||
+		normalized.endsWith("/roblox.h") ||
+		normalized.endsWith("/roblox.clh")
+	);
+}
+
+export function isHeaderFile(fileName: string): boolean {
+	return path.extname(fileName).toLowerCase() === ".clh";
+}
+
+export function isImplFile(fileName: string): boolean {
+	const ext = path.extname(fileName).toLowerCase();
+	return ext === ".clp" || ext === ".clpp";
+}
+
+export function toLuauPath(filePath: string): string {
+	return String(filePath).replace(/\.(clpp|clp|clh)$/i, ".luau");
+}
+
+export function fileStem(fileName: string): string {
+	let name = path.basename(fileName);
+	const lower = name.toLowerCase();
+	for (const ext of [".clpp", ".clp", ".clh"]) {
+		if (lower.endsWith(ext)) {
+			name = name.slice(0, -ext.length);
+			break;
+		}
+	}
+	const tagged = name.toLowerCase();
+	for (const tag of [".legacy.server", ".legacy.client", ".legacy", ".server", ".client", ".plugin"]) {
+		if (tagged.endsWith(tag)) {
+			name = name.slice(0, -tag.length);
+			break;
+		}
+	}
+	return name;
+}
+
+export function scriptKind(fileName: string): "server" | "client" | "plugin" | "legacy" | "module" | "header" {
+	const name = path.basename(fileName).toLowerCase();
+	if (name.endsWith(".clh")) {
+		return "header";
+	}
+	if (name.includes(".legacy.")) {
+		return "legacy";
+	}
+	if (name.includes(".server.")) {
+		return "server";
+	}
+	if (name.includes(".client.")) {
+		return "client";
+	}
+	if (name.includes(".plugin.")) {
+		return "plugin";
+	}
+	return "module";
+}
+
+export function emitKind(fileName: string): "flat" | "module" | "legacy" {
+	const kind = scriptKind(fileName);
+	if (kind === "legacy") {
+		return "legacy";
+	}
+	if (kind === "module" || kind === "header") {
+		return "module";
+	}
+	return "flat";
+}
+
+export function isTaggedScript(fileName: string): boolean {
+	const kind = scriptKind(fileName);
+	return kind === "server" || kind === "client" || kind === "plugin" || kind === "legacy";
+}
+
+export function siblingHeader(implPath: string | null | undefined): string | null {
+	if (!implPath || isHeaderFile(implPath)) {
+		return null;
+	}
+	const dir = path.dirname(implPath);
+	const stem = fileStem(implPath);
+	const candidate = path.join(dir, `${stem}.clh`);
+	if (fs.existsSync(candidate)) {
+		return candidate;
+	}
+	return null;
+}
+
+export function collectSources(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()) {
+			collectSources(full, files);
+		} else if (isSourceFile(entry.name)) {
+			files.push(full);
+		}
+	}
+	return files;
+}

package/src/clpp/postprocess.ts

@@ -0,0 +1,93 @@
+import { insertPreamble, MODULES, requireCluauppLib } from "../libs.js";
+import type { CompileArtifact } from "./contract.js";
+import { isTaggedScript } from "./paths.js";
+
+export type PostprocessOptions = {
+	relativeName: string;
+	outName: string;
+	srcDir?: string;
+	rootDir?: string;
+	strict?: boolean;
+	skipInit?: boolean;
+};
+
+function insertAfterHeader(luau: string, block: string): string {
+	const match = String(luau).match(/^(?:--[^\n]*\n)+/);
+	if (!match) {
+		return `${block}\n${luau}`;
+	}
+	const insertAt = match[0].length;
+	const rest = luau.slice(insertAt).replace(/^\n*/, "\n");
+	return `${luau.slice(0, insertAt)}\n${block}\n${rest}`;
+}
+
+function rewriteClppLibs(luau: string): string {
+	return String(luau).replace(/require\(\s*ClppLibs\.([A-Za-z0-9_]+)\s*\)/g, (_all, name: string) => {
+		return requireCluauppLib(name);
+	});
+}
+
+function ensureReplicatedStorage(luau: string): string {
+	if (!luau.includes("CluauppLibs")) {
+		return luau;
+	}
+	if (/GetService\(\s*"ReplicatedStorage"\s*\)/.test(luau)) {
+		return luau;
+	}
+	return insertAfterHeader(luau, 'const ReplicatedStorage = game:GetService("ReplicatedStorage")');
+}
+
+function stripInitCall(luau: string): string {
+	return String(luau).replace(/\ninit\(\)\s*\n?$/m, "\n");
+}
+
+function ensureStrict(luau: string, strict?: boolean): string {
+	if (!strict || /^\s*--!strict\b/m.test(luau)) {
+		return luau;
+	}
+	if (luau.startsWith("--")) {
+		return `--!strict\n${luau}`;
+	}
+	return `--!strict\n${luau}`;
+}
+
+function librarySpecs(names: string[] | undefined) {
+	const specs: Array<{ file: string; bind: string }> = [];
+	const seen = new Set<string>();
+	for (const name of names || []) {
+		const spec = (MODULES as Record<string, { file: string; bind: string }>)[name];
+		if (!spec || seen.has(spec.bind)) {
+			continue;
+		}
+		seen.add(spec.bind);
+		specs.push(spec);
+	}
+	return specs;
+}
+
+function missingLibraries(luau: string, names: string[] | undefined) {
+	return librarySpecs(names).filter((spec) => {
+		return !luau.includes(`CluauppLibs.${spec.file}`) && !new RegExp(`\\bconst ${spec.bind}\\b`).test(luau);
+	});
+}
+
+export function shouldSkipInit(fileName: string, hasSiblingHeader: boolean): boolean {
+	if (!hasSiblingHeader) {
+		return false;
+	}
+	return !isTaggedScript(fileName);
+}
+
+export function clppLuauToGame(artifact: CompileArtifact, options: PostprocessOptions): string {
+	let luau = rewriteClppLibs(artifact.luau || "");
+	luau = ensureReplicatedStorage(luau);
+	if (options.skipInit) {
+		luau = stripInitCall(luau);
+	}
+	luau = ensureStrict(luau, options.strict);
+	const missing = missingLibraries(luau, artifact.libraries);
+	if (missing.length > 0) {
+		luau = insertPreamble(luau, [], missing, options.outName);
+	}
+	return luau;
+}

package/src/clpp/runner.ts

@@ -0,0 +1,102 @@
+import { spawnSync } from "node:child_process";
+import { CLPP_INSTALL_HINT, type CompileArtifact, type CompileRequest, type LanguageManifest } from "./contract.js";
+
+const MISSING_CLPP = `cluaupp: clpp not found. ${CLPP_INSTALL_HINT}`;
+
+function whichClpp(): string | null {
+	if (process.env.CLPP_PATH) {
+		return process.env.CLPP_PATH;
+	}
+	const finder = process.platform === "win32" ? "where" : "which";
+	const found = spawnSync(finder, ["clpp"], { encoding: "utf8", windowsHide: true });
+	if (found.status !== 0) {
+		return null;
+	}
+	const line = String(found.stdout || "")
+		.split(/\r?\n/)
+		.map((item) => item.trim())
+		.find((item) => item.length > 0);
+	return line || "clpp";
+}
+
+export function hasClpp(): boolean {
+	return Boolean(whichClpp());
+}
+
+export function resolveClppBinary(): string {
+	const bin = whichClpp();
+	if (!bin) {
+		throw new Error(MISSING_CLPP);
+	}
+	return bin;
+}
+
+function parseArtifact(stdout: string, fileName: string, fallbackError: string): CompileArtifact {
+	const text = String(stdout || "").trim();
+	try {
+		const parsed = JSON.parse(text) as CompileArtifact;
+		if (parsed && typeof parsed === "object") {
+			return parsed;
+		}
+	} catch {
+		// fall through
+	}
+	return {
+		ok: false,
+		luau: "",
+		fileName,
+		outputHint: "",
+		scriptKind: null,
+		isScript: false,
+		isHeader: false,
+		rojoClass: "ModuleScript",
+		libraries: [],
+		error: fallbackError || "clpp returned invalid JSON",
+	};
+}
+
+export function compileViaClpp(request: CompileRequest): CompileArtifact {
+	const bin = resolveClppBinary();
+	const payload = JSON.stringify({
+		source: request.source,
+		fileName: request.fileName,
+		strict: request.strict,
+	});
+	const result = spawnSync(bin, ["api", "compile"], {
+		input: payload,
+		encoding: "utf8",
+		cwd: request.cwd,
+		maxBuffer: 16 * 1024 * 1024,
+		windowsHide: true,
+	});
+	const stderr = String(result.stderr || "").trim();
+	const artifact = parseArtifact(result.stdout, request.fileName, stderr || result.error?.message || "clpp api compile failed");
+	if (!artifact.ok) {
+		throw new Error(artifact.error || stderr || `clpp failed (${result.status})`);
+	}
+	return artifact;
+}
+
+export function clppManifest(): LanguageManifest {
+	const bin = resolveClppBinary();
+	const result = spawnSync(bin, ["api", "manifest"], {
+		encoding: "utf8",
+		windowsHide: true,
+	});
+	if (result.status !== 0) {
+		throw new Error(String(result.stderr || result.error?.message || "clpp api manifest failed"));
+	}
+	return JSON.parse(result.stdout) as LanguageManifest;
+}
+
+export function clppVersion(): string | null {
+	const bin = whichClpp();
+	if (!bin) {
+		return null;
+	}
+	const result = spawnSync(bin, ["--version"], { encoding: "utf8", windowsHide: true });
+	if (result.status !== 0) {
+		return null;
+	}
+	return String(result.stdout || "").trim() || null;
+}

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: [],
 	};
 }