cluaupp 0.1.4 → 0.1.5

package/src/architecture.js

@@ -2,17 +2,23 @@
 
 const path = require("path");
 const { emit } = require("./emit");
-const { collectLibraries, insertRequires, requireCluauppLib } = require("./libs");
+const { requireCluauppLib } = require("./libs");
 const { organizeDecls, janitorNames, emitSection, joinBlocks, SECTION, ENTRY_FN } = require("./layout");
 const {
 	VALUE_CLASSES,
 	analyze,
 	toPascalServiceName,
 	legacyOutName,
+	modernScriptOutName,
 } = require("./understand");
+const { implOutName } = require("./preprocess");
 
 function header(plan) {
-	const lines = ["--!strict", "-- Compiled by Cluaupp — C++ × Luau"];
+	const lines = [];
+	if (plan && plan.strict) {
+		lines.push("--!strict");
+	}
+	lines.push("-- Compiled by Cluaupp — C++ × Luau");
 	if (plan && plan.reasoning) {
 		for (const line of plan.reasoning) {
 			lines.push(`-- ${line}`);
@@ -328,9 +334,7 @@ function emitDomainController(plan, ast, options) {
 		return decl.type === "decl" || decl.type === "proto" || decl.type === "function" || decl.type === "expr";
 	});
 	const groups = organizeDecls(keep);
-	const subset = { type: "program", body: keep };
 	const name = plan.roles.domain;
-	const libs = collectLibraries(options.source || "", subset);
 	const entry = keep.find((decl) => decl.type === "function" && ENTRY_FN.test(decl.name || ""));
 	const bootExprs = keep.filter((decl) => decl.type === "expr");
 	const janitors = janitorNames(keep);
@@ -356,7 +360,7 @@ function emitDomainController(plan, ast, options) {
 	const startFn = `function ${name}.Start()\n	${name}.Stop()\n${boot}\nend`;
 	const stopFn = `function ${name}.Stop()\n${stopLines.join("\n")}\nend`;
 	const body = `${header(plan).trimEnd()}\n\n${emitSection(SECTION.api, emitDecls(groups.api, options))}${emitSection(SECTION.constants, emitDecls(groups.constants, options))}${emitSection(SECTION.variables, joinBlocks([emitDecls(groups.variables, options), `local ${name} = {}`]))}${emitSection(SECTION.support, emitDecls(groups.support, options))}${emitSection(SECTION.principal, joinBlocks([emitDecls(groups.principal, options), startFn]))}${emitSection(SECTION.cleanup, joinBlocks([emitDecls(groups.cleanup, options), stopFn]))}${emitSection(SECTION.returns, `return ${name}`)}`;
-	return insertRequires(body, libs);
+	return body;
 }
 
 function emitModule(plan, ast, options) {
@@ -366,7 +370,6 @@ function emitModule(plan, ast, options) {
 function emitScriptMeta(runContext) {
 	return `${JSON.stringify(
 		{
-			className: "Script",
 			properties: {
 				RunContext: `Enum.RunContext.${runContext}`,
 			},
@@ -380,7 +383,7 @@ function serviceBootName(plan) {
 	if (plan.isClient) {
 		return "init.client.luau";
 	}
-	return "init.luau";
+	return "init.server.luau";
 }
 
 function serviceFiles(plan, ast, options, dir) {
@@ -404,33 +407,75 @@ function serviceFiles(plan, ast, options, dir) {
 	return files;
 }
 
+function serviceFolderStale(plan, rel) {
+	const dir = path.posix.dirname(rel).replace(/^\.$/, "");
+	const serviceDir = dir && dir !== "." ? dir : plan.isClient ? "client" : "server";
+	const folder = `${serviceDir}/${plan.serviceName}`;
+	return [
+		folder,
+		`${folder}/init.luau`,
+		`${folder}/init.server.luau`,
+		`${folder}/init.client.luau`,
+		`${folder}/init.meta.json`,
+		`${folder}/Main.luau`,
+		`${folder}/PlayersManager.luau`,
+		`${folder}/CacheController.luau`,
+		`${folder}/${plan.typesName}.luau`,
+		plan.roles && plan.roles.domain ? `${folder}/${plan.roles.domain}.luau` : null,
+	].filter(Boolean);
+}
+
 function planOutput(ast, fileName, options = {}) {
 	const plan = analyze(ast, fileName);
+	plan.strict = options.strict === true;
 	const rel = (options.relativeName || fileName).replace(/\\/g, "/");
 	const dir = path.dirname(rel).replace(/^\.$/, "");
 	const outDir = dir && dir !== "." ? dir : "";
 	const prefix = outDir ? `${outDir}/` : "";
+	const stale = serviceFolderStale(plan, rel);
 
-	if (options.architecture === false) {
-		return { kind: "flat", plan, files: null };
+	if (options.siblingHeader) {
+		return {
+			kind: "module",
+			plan,
+			files: [{ name: implOutName(rel), contents: emitModule(plan, ast, { ...options, skipInit: true }) }],
+			stale: [],
+		};
 	}
 
-	if (plan.kind === "legacy") {
-		return { kind: "legacy", plan, files: null, stale: [], outName: legacyOutName(rel) };
+	if (options.architecture === true) {
+		if (plan.kind === "legacy") {
+			return { kind: "legacy", plan, files: null, stale: [], outName: legacyOutName(rel) };
+		}
+
+		if (plan.kind === "service") {
+			const serviceDir = outDir || (plan.isClient ? "client" : "server");
+			const folder = `${serviceDir}/${plan.serviceName}`;
+			const serviceStale = plan.isClient
+				? [`${folder}/init.luau`, `${folder}/init.server.luau`, `${folder}/init.meta.json`]
+				: [`${folder}/init.luau`, `${folder}/init.client.luau`];
+			return {
+				kind: "service",
+				plan,
+				files: serviceFiles(plan, ast, options, serviceDir),
+				stale: serviceStale,
+			};
+		}
+
+		if (plan.kind === "config" || plan.kind === "module") {
+			return {
+				kind: plan.kind,
+				plan,
+				files: [{ name: `${prefix}${plan.serviceName}.luau`, contents: emitModule(plan, ast, options) }],
+				stale: [rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau")],
+			};
+		}
+
+		return { kind: "flat", plan, files: null, stale: [], outName: modernScriptOutName(rel) };
 	}
 
-	if (plan.kind === "service") {
-		const serviceDir = outDir || (plan.isClient ? "client" : "server");
-		const folder = `${serviceDir}/${plan.serviceName}`;
-		const stale = plan.isClient
-			? [`${folder}/init.luau`, `${folder}/init.server.luau`, `${folder}/init.meta.json`]
-			: [`${folder}/init.server.luau`, `${folder}/init.client.luau`];
-		return {
-			kind: "service",
-			plan,
-			files: serviceFiles(plan, ast, options, serviceDir),
-			stale,
-		};
+	if (plan.kind === "legacy") {
+		return { kind: "legacy", plan, files: null, stale, outName: legacyOutName(rel) };
 	}
 
 	if (plan.kind === "config" || plan.kind === "module") {
@@ -438,11 +483,14 @@ function planOutput(ast, fileName, options = {}) {
 			kind: plan.kind,
 			plan,
 			files: [{ name: `${prefix}${plan.serviceName}.luau`, contents: emitModule(plan, ast, options) }],
-			stale: [rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau")],
+			stale: [rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau"), ...stale],
 		};
 	}
 
-	return { kind: "flat", plan, files: null, stale: [] };
+	const outName = modernScriptOutName(rel);
+	const stripped = rel.replace(/\.(server|client|plugin)\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+	const extraStale = stripped !== outName ? [stripped] : [];
+	return { kind: "flat", plan, files: null, stale: [...stale, ...extraStale], outName };
 }
 
 module.exports = {

package/src/cli.js

@@ -3,7 +3,7 @@
 const fs = require("fs");
 const path = require("path");
 const { compileService } = require("./compile");
-const { isSourceFile, isHeaderFile, toLuauPath, siblingImplementation } = require("./preprocess");
+const { isSourceFile, toLuauPath } = require("./preprocess");
 const { syncEditorSupport, installEditorSupport } = require("./intellisense");
 const pkg = require("../package.json");
 
@@ -12,7 +12,7 @@ function printHelp() {
 
 Usage:
   cluaupp init [folder]    create a game (src/server, src/client, src/shared)
-  cluaupp build [folder]   transpile src → out (PascalCase services)
+  cluaupp build [folder]   transpile src → out (one file per .cpp)
   cluaupp watch [folder]   rebuild on save
   cluaupp lsp [folder]     language server (stdio JSON-RPC)
   cluaupp intellisense     install Cursor/VS Code IntelliSense
@@ -110,10 +110,10 @@ function loadConfig(root) {
 	for (const name of configNames) {
 		const file = path.join(root, name);
 		if (fs.existsSync(file)) {
-			return { rootDir: "src", outDir: "out", strict: true, ...JSON.parse(fs.readFileSync(file, "utf8")) };
+			return { rootDir: "src", outDir: "out", strict: false, architecture: false, ...JSON.parse(fs.readFileSync(file, "utf8")) };
 		}
 	}
-	return { rootDir: "src", outDir: "out", strict: true };
+	return { rootDir: "src", outDir: "out", strict: false, architecture: false };
 }
 
 function collectCpp(dir, files = []) {
@@ -146,10 +146,6 @@ function collectFiles(dir, files = []) {
 	return files;
 }
 
-function siblingCpp(file) {
-	return siblingImplementation(file) || file.replace(/\.(h|hpp|hh)$/i, ".cpp");
-}
-
 function resolveKey(file) {
 	const resolved = path.resolve(file);
 	return process.platform === "win32" ? resolved.toLowerCase() : resolved;
@@ -223,14 +219,10 @@ function pruneOut(root, config, written, failedPrefixes) {
 function compileProject(root, config) {
 	const srcDir = path.join(root, config.rootDir);
 	const files = collectCpp(srcDir);
-	const fileSet = new Set(files.map((file) => path.resolve(file)));
 	const jobs = [];
 	const errors = [];
 
 	for (const file of files) {
-		if (isHeaderFile(file) && fileSet.has(path.resolve(siblingCpp(file)))) {
-			continue;
-		}
 		const source = fs.readFileSync(file, "utf8");
 		const rel = posixRel(srcDir, file);
 		try {
@@ -239,7 +231,7 @@ function compileProject(root, config) {
 				filePath: file,
 				relativeName: rel,
 				outName: toLuauPath(rel),
-				architecture: config.architecture !== false,
+				architecture: config.architecture === true,
 				includeDirs: [path.dirname(file), srcDir, path.join(root, "include")],
 				srcDir,
 			});

package/src/compile.js

@@ -1,35 +1,89 @@
 "use strict";
 
+const path = require("path");
 const { parse } = require("./parse");
 const { emit } = require("./emit");
-const { preprocess } = require("./preprocess");
-const { collectLibraries, insertRequires, insertModuleRequires } = require("./libs");
+const { preprocess, isHeaderFile, toLuauPath, siblingImplementation, siblingHeader, implOutName } = require("./preprocess");
+const { collectLibraries, insertPreamble } = require("./libs");
 const { planOutput } = require("./architecture");
+const { emitHeaderModule, primaryHeaderName } = require("./headers");
+
+function shouldAttachRequires(name) {
+	return !/\.(json)$/i.test(String(name || ""));
+}
 
 function attachRequires(contents, source, ast, options, outName) {
-	let next = contents;
-	if (!next.includes("CluauppLibs")) {
-		next = insertRequires(next, collectLibraries(source, ast));
+	if (!shouldAttachRequires(outName)) {
+		return contents;
+	}
+	const libraries = String(contents).includes("CluauppLibs") ? [] : collectLibraries(source, ast);
+	return insertPreamble(contents, options.moduleIncludes || [], libraries, outName);
+}
+
+function posixRel(from, file) {
+	return path.relative(from, file).replace(/\\/g, "/");
+}
+
+function wireHeaderImpl(ast, fileName, options) {
+	const headerPath = options.filePath || null;
+	const impl = headerPath ? siblingImplementation(headerPath) : null;
+	if (!impl) {
+		return;
+	}
+	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) => spec.name === options.headerImplName)) {
+		options.moduleIncludes.push({
+			name: options.headerImplName,
+			outRel: implOut,
+			exports: { consts: [], structs: [] },
+		});
 	}
-	return insertModuleRequires(next, options.moduleIncludes || [], outName);
+}
+
+function compileHeader(source, fileName, options, prepared, ast) {
+	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: [],
+	};
 }
 
 function compileSource(source, fileName, options = {}) {
 	options.moduleIncludes = options.moduleIncludes || [];
-	const prepared = options.filePath ? preprocess(source, options.filePath, options) : source;
+	const prepared = preprocess(source, options.filePath || null, options);
 	const ast = parse(prepared, fileName || "input.cpp");
+	if (isHeaderFile(fileName) || isHeaderFile(options.filePath || "")) {
+		return compileHeader(source, fileName, options, prepared, ast).files[0].contents;
+	}
 	const luau = emit(ast, options);
 	return attachRequires(luau, source, ast, options, options.outName || fileName);
 }
 
 function compileService(source, fileName, options = {}) {
 	options.moduleIncludes = options.moduleIncludes || [];
-	const prepared = options.filePath ? preprocess(source, options.filePath, options) : source;
+	const prepared = preprocess(source, options.filePath || null, options);
 	const ast = parse(prepared, fileName || "input.cpp");
+	if (isHeaderFile(fileName) || isHeaderFile(options.filePath || "") || isHeaderFile(options.relativeName || "")) {
+		return compileHeader(source, fileName, options, prepared, ast);
+	}
+	const implHeader = options.filePath ? siblingHeader(options.filePath) : null;
+	if (implHeader) {
+		options.skipInit = true;
+	}
 	const planned = planOutput(ast, fileName || "input.cpp", {
 		...options,
 		relativeName: options.relativeName || fileName,
 		source: prepared,
+		siblingHeader: implHeader,
 	});
 	if (planned.files) {
 		return {

package/src/emit.js

@@ -4,7 +4,7 @@ const { isInstanceType, isMethod, isDatatype, luauType } = require("./api");
 const { isLibraryType, isLibraryMethod, MODULE_COLON } = require("./libs");
 
 function emit(ast, options = {}) {
-	const strict = options.strict !== false;
+	const strict = options.strict === true;
 	const lines = [];
 	if (!options.skipHeader) {
 		if (strict) {

package/src/headers.js

@@ -0,0 +1,234 @@
+"use strict";
+
+const path = require("path");
+const { luauType } = require("./api");
+
+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");
+}
+
+module.exports = {
+	emitHeaderModule,
+	primaryHeaderName,
+	collectHeaderShape,
+};