cluaupp 0.1.2 → 0.1.5

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) {
@@ -15,6 +15,133 @@ function emit(ast, options = {}) {
 	}
 
 	const indentOf = (n) => "\t".repeat(n);
+	let switchId = 0;
+
+	const classOwners = new Set();
+	const classFields = new Set();
+	const classMethods = new Set();
+	for (const decl of ast.body || []) {
+		if (decl.owner) {
+			classOwners.add(decl.owner);
+		}
+		if (decl.type === "decl" && decl.owner) {
+			classFields.add(decl.name);
+		}
+		if ((decl.type === "function" || decl.type === "proto") && decl.owner && decl.name) {
+			classMethods.add(decl.name);
+		}
+	}
+	const ownedFns = (ast.body || []).filter((decl) => decl.type === "function");
+	const classModule = ownedFns.length > 0 && ownedFns.every((decl) => Boolean(decl.owner));
+	const nestedTypes = new Set();
+	for (const decl of ast.body || []) {
+		if (decl.type === "decl" && decl.owner && decl.valueType && classOwners.has(decl.valueType) && decl.valueType !== decl.owner) {
+			nestedTypes.add(decl.valueType);
+		}
+	}
+	const structRoots = [...classOwners].filter((name) => !nestedTypes.has(name));
+	const structModule = !classModule && ownedFns.length === 0 && structRoots.length > 0;
+
+	const localNames = new Set();
+	let selfOwner = null;
+
+	const isBareGlobal = (name) => {
+		return (
+			name === "print" ||
+			name === "warn" ||
+			name === "error" ||
+			name === "game" ||
+			name === "workspace" ||
+			name === "script" ||
+			name === "cout" ||
+			name === "cerr" ||
+			name === "endl" ||
+			isLibraryType(name) ||
+			isInstanceType(name) ||
+			isDatatype(name)
+		);
+	};
+
+	const emitSelfIdent = (name) => {
+		if (name === "this") {
+			return "self";
+		}
+		if (!selfOwner || localNames.has(name) || isBareGlobal(name)) {
+			return name;
+		}
+		if (classFields.has(name)) {
+			return `self.${name}`;
+		}
+		return name;
+	};
+
+	const emitMethodArg = (arg) => {
+		if (arg && arg.type === "ident" && selfOwner && classMethods.has(arg.name) && !localNames.has(arg.name)) {
+			return `function(...) self:${arg.name}(...) end`;
+		}
+		return emitExpr(arg);
+	};
+
+	const flattenShift = (node) => {
+		const parts = [];
+		let current = node;
+		while (current && current.type === "binary" && current.op === "<<") {
+			parts.unshift(current.right);
+			current = current.left;
+		}
+		return { stream: current, args: parts };
+	};
+
+	const isEndl = (node) => node && node.type === "ident" && node.name === "endl";
+
+	const streamPrint = (stream) => {
+		if (!stream) {
+			return null;
+		}
+		if (stream.type === "ident") {
+			if (stream.name === "cout") {
+				return "print";
+			}
+			if (stream.name === "cerr") {
+				return "warn";
+			}
+			return null;
+		}
+		if (stream.type === "member" && stream.object && stream.object.type === "ident" && stream.object.name === "cout") {
+			const mapped = { print: "print", warn: "warn", error: "error", ping: "print", endl: "print" };
+			return mapped[stream.name] || "print";
+		}
+		return null;
+	};
+
+	const emitCout = (node) => {
+		const { stream, args } = flattenShift(node);
+		const fn = streamPrint(stream);
+		if (!fn) {
+			return null;
+		}
+		const linesOut = [];
+		let current = [];
+		const flush = () => {
+			if (current.length === 0) {
+				return;
+			}
+			linesOut.push(`${fn}(${current.map(emitExpr).join(", ")})`);
+			current = [];
+		};
+		for (const arg of args) {
+			if (isEndl(arg)) {
+				flush();
+				continue;
+			}
+			current.push(arg);
+		}
+		flush();
+		if (linesOut.length === 0) {
+			linesOut.push(`${fn}()`);
+		}
+		return linesOut;
+	};
 
 	const emitExpr = (node) => {
 		if (!node) {
@@ -30,7 +157,7 @@ function emit(ast, options = {}) {
 			case "string":
 				return `"${node.value}"`;
 			case "ident":
-				return node.name;
+				return emitSelfIdent(node.name);
 			case "initlist": {
 				const entries = (node.fields || []).map((field) => `${field.name} = ${emitExpr(field.value)}`);
 				if (entries.length === 0) {
@@ -57,19 +184,39 @@ function emit(ast, options = {}) {
 			case "member":
 				return `${emitExpr(node.object)}.${node.name}`;
 			case "call": {
-				const args = node.args.map(emitExpr).join(", ");
+				const args = node.args.map(emitMethodArg).join(", ");
 				if (!node.object) {
 					if (isDatatype(node.name)) {
 						return `${node.name}.new(${args})`;
 					}
+					if (selfOwner && classMethods.has(node.name) && !localNames.has(node.name)) {
+						return `self:${node.name}(${args})`;
+					}
 					return `${node.name}(${args})`;
 				}
 				const obj = emitExpr(node.object);
+				if (node.access === "::" && node.object.type === "ident" && node.object.name === "cout") {
+					if (node.name === "endl") {
+						return "print()";
+					}
+					const mapped = { print: "print", warn: "warn", error: "error", ping: "print" };
+					return `${mapped[node.name] || "print"}(${args})`;
+				}
 				if (node.access === "::") {
 					if (MODULE_COLON.has(node.name)) {
 						return `${obj}:${node.name}(${args})`;
 					}
-					return `${obj}.${node.name}(${args})`;
+					const staticNs =
+						node.object.type === "ident" &&
+						(isLibraryType(node.object.name) ||
+							isDatatype(node.object.name) ||
+							node.object.name === "DataService" ||
+							node.object.name === "FormatNumber" ||
+							node.object.name === "Enum");
+					if (staticNs) {
+						return `${obj}.${node.name}(${args})`;
+					}
+					return `${obj}:${node.name}(${args})`;
 				}
 				if (isDatatype(obj) || (node.object.type === "ident" && isDatatype(node.object.name))) {
 					return `${obj}.${node.name}(${args})`;
@@ -80,6 +227,12 @@ function emit(ast, options = {}) {
 			case "assign":
 				return `${emitExpr(node.left)} = ${emitExpr(node.right)}`;
 			case "binary": {
+				if (node.op === "<<") {
+					const printed = emitCout(node);
+					if (printed) {
+						return printed.join("; ");
+					}
+				}
 				const ops = { "!=": "~=", "&&": "and", "||": "or" };
 				const op = ops[node.op] || node.op;
 				return `${emitExpr(node.left)} ${op} ${emitExpr(node.right)}`;
@@ -110,9 +263,24 @@ function emit(ast, options = {}) {
 	const emitNewDecl = (node, indent) => {
 		const prefix = indentOf(indent);
 		const typeAnn = inferredType(node);
+		const created = node.value;
+		if (node.owner && indent === 0 && classModule) {
+			const value = node.value ? emitExpr(node.value) : "nil";
+			if (created && created.type === "new" && isInstanceType(created.className) && !isLibraryType(created.className)) {
+				const linesOut = [`${prefix}${node.owner}.${node.name} = Instance.new("${created.className}")`];
+				if (created.args[0]) {
+					linesOut.push(`${prefix}${node.owner}.${node.name}.Parent = ${emitExpr(created.args[0])}`);
+				}
+				return linesOut;
+			}
+			if (created && created.type === "new" && (isDatatype(created.className) || isLibraryType(created.className))) {
+				const args = created.args.map(emitExpr).join(", ");
+				return [`${prefix}${node.owner}.${node.name} = ${created.className}.new(${args})`];
+			}
+			return [`${prefix}${node.owner}.${node.name} = ${value}`];
+		}
 		const kind = node.isConst ? "const" : "local";
 		const typed = typeAnn ? `: ${typeAnn}` : "";
-		const created = node.value;
 		if (created && created.type === "new" && isInstanceType(created.className) && !isLibraryType(created.className)) {
 			const linesOut = [`${prefix}${kind} ${node.name}${typed} = Instance.new("${created.className}")`];
 			if (created.args[0]) {
@@ -132,9 +300,35 @@ function emit(ast, options = {}) {
 		const prefix = indentOf(indent);
 		switch (node.type) {
 			case "decl":
+				if (node.name) {
+					localNames.add(node.name);
+				}
 				return emitNewDecl(node, indent);
-			case "expr":
-				return [`${prefix}${emitExpr(node.expr)}`];
+			case "expr": {
+				const expr = node.expr;
+				if (expr && expr.type === "binary" && expr.op === "<<") {
+					const printed = emitCout(expr);
+					if (printed) {
+						return printed.map((line) => `${prefix}${line}`);
+					}
+				}
+				if (
+					expr &&
+					expr.type === "assign" &&
+					expr.right &&
+					expr.right.type === "new" &&
+					isInstanceType(expr.right.className) &&
+					!isLibraryType(expr.right.className)
+				) {
+					const left = emitExpr(expr.left);
+					const linesOut = [`${prefix}${left} = Instance.new("${expr.right.className}")`];
+					if (expr.right.args[0]) {
+						linesOut.push(`${prefix}${left}.Parent = ${emitExpr(expr.right.args[0])}`);
+					}
+					return linesOut;
+				}
+				return [`${prefix}${emitExpr(expr)}`];
+			}
 			case "return":
 				return node.value ? [`${prefix}return ${emitExpr(node.value)}`] : [`${prefix}return`];
 			case "if": {
@@ -167,6 +361,52 @@ function emit(ast, options = {}) {
 				out.push(`${prefix}end`);
 				return out;
 			}
+			case "break":
+				return [`${prefix}break`];
+			case "switch": {
+				switchId += 1;
+				const id = `__switch${switchId}`;
+				const disc = node.discriminant;
+				const simple =
+					disc &&
+					(disc.type === "ident" || disc.type === "number" || disc.type === "string" || disc.type === "bool");
+				const subject = simple ? emitExpr(disc) : id;
+				const out = [`${prefix}repeat`];
+				const inner = indent + 1;
+				const innerP = indentOf(inner);
+				if (!simple) {
+					out.push(`${innerP}local ${id} = ${emitExpr(disc)}`);
+				}
+				const regular = (node.cases || []).filter((item) => !item.isDefault);
+				const fallback = (node.cases || []).find((item) => item.isDefault);
+				const testOf = (item) =>
+					(item.values || []).map((value) => `${subject} == ${emitExpr(value)}`).join(" or ");
+				for (let index = 0; index < regular.length; index += 1) {
+					const item = regular[index];
+					const keyword = index === 0 ? "if" : "elseif";
+					out.push(`${innerP}${keyword} ${testOf(item)} then`);
+					for (const stmt of item.body || []) {
+						out.push(...emitStmt(stmt, inner + 1));
+					}
+				}
+				if (fallback) {
+					if (regular.length === 0) {
+						for (const stmt of fallback.body || []) {
+							out.push(...emitStmt(stmt, inner));
+						}
+					} else {
+						out.push(`${innerP}else`);
+						for (const stmt of fallback.body || []) {
+							out.push(...emitStmt(stmt, inner + 1));
+						}
+					}
+				}
+				if (regular.length > 0) {
+					out.push(`${innerP}end`);
+				}
+				out.push(`${prefix}until true`);
+				return out;
+			}
 			default:
 				return [];
 		}
@@ -191,25 +431,97 @@ function emit(ast, options = {}) {
 		return `: ${typeAnn}`;
 	};
 
+	const emitFieldLiteral = (decl) => {
+		if (decl.value && decl.value.type === "initlist") {
+			const inner = (decl.value.fields || [])
+				.map((field) => `${field.name} = ${emitExpr(field.value)}`)
+				.join(", ");
+			return `{ ${inner} }`;
+		}
+		if (decl.valueType && nestedTypes.has(decl.valueType)) {
+			const nested = (ast.body || []).filter((item) => item.type === "decl" && item.owner === decl.valueType);
+			const inner = nested.map((item) => `${item.name} = ${emitFieldLiteral(item)}`).join(", ");
+			return `{ ${inner} }`;
+		}
+		return decl.value ? emitExpr(decl.value) : "nil";
+	};
+
+	const emitStructConstructor = (root) => {
+		const fields = (ast.body || []).filter((decl) => decl.type === "decl" && decl.owner === root);
+		const inner = fields.map((field) => `\t\t${field.name} = ${emitFieldLiteral(field)},`).join("\n");
+		lines.push(`const function ${root}()`);
+		lines.push("	return {");
+		if (inner) {
+			lines.push(inner);
+		}
+		lines.push("	}");
+		lines.push("end");
+		lines.push("");
+		lines.push(`return ${root}`);
+		lines.push("");
+	};
+
+	if (classModule) {
+		for (const owner of classOwners) {
+			lines.push(`local ${owner} = {}`);
+			lines.push("");
+		}
+	}
+
+	if (structModule) {
+		for (const root of structRoots) {
+			emitStructConstructor(root);
+		}
+		return lines.join("\n");
+	}
+
 	for (const decl of ast.body) {
 		if (decl.type === "decl") {
 			lines.push(...emitNewDecl(decl, 0));
 			lines.push("");
 			continue;
 		}
+		if (decl.type === "expr") {
+			lines.push(emitExpr(decl.expr));
+			lines.push("");
+			continue;
+		}
 		if (decl.type !== "function") {
 			continue;
 		}
-		lines.push(`local function ${decl.name}(${paramList(decl)})${returnAnn(decl)}`);
+		selfOwner = decl.owner || null;
+		localNames.clear();
+		for (const param of decl.params || []) {
+			const paramName = typeof param === "string" ? param : param.name;
+			if (paramName) {
+				localNames.add(paramName);
+			}
+		}
+		if (decl.owner) {
+			lines.push(`function ${decl.owner}:${decl.name}(${paramList(decl)})${returnAnn(decl)}`);
+		} else {
+			lines.push(`const function ${decl.name}(${paramList(decl)})${returnAnn(decl)}`);
+		}
 		for (const stmt of decl.body) {
 			lines.push(...emitStmt(stmt, 1));
 		}
 		lines.push("end");
 		lines.push("");
+		selfOwner = null;
+		localNames.clear();
 	}
 
 	const hasInit = ast.body.some((decl) => decl.type === "function" && decl.name === "init");
-	if (hasInit && !options.skipInit) {
+	if (classModule) {
+		for (const owner of classOwners) {
+			if (hasInit) {
+				lines.push(`${owner}.Start = ${owner}.init`);
+				lines.push(`${owner}.Init = ${owner}.init`);
+			}
+			lines.push(`return ${owner}`);
+			lines.push("");
+		}
+	} else if (hasInit && !options.skipInit) {
 		lines.push("init()");
 		lines.push("");
 	}

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,
+};