cluaupp 0.2.2 → 1.0.0

package/src/emit.ts

@@ -1,531 +0,0 @@
-// @ts-nocheck
-import { isInstanceType, isMethod, isDatatype, luauType } from "./api.js";
-import { isLibraryType, isLibraryMethod, MODULE_COLON } from "./libs.js";
-
-function emit(ast, options = {}) {
-	const strict = options.strict === true;
-	const lines = [];
-	if (!options.skipHeader) {
-		if (strict) {
-			lines.push("--!strict");
-		}
-		lines.push("-- Compiled by Cluaupp — C++ × Luau");
-		lines.push("");
-	}
-
-	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) {
-			return "nil";
-		}
-		switch (node.type) {
-			case "null":
-				return "nil";
-			case "bool":
-				return node.value ? "true" : "false";
-			case "number":
-				return node.value;
-			case "string":
-				return `"${node.value}"`;
-			case "ident":
-				return emitSelfIdent(node.name);
-			case "initlist": {
-				const entries = (node.fields || []).map((field) => `${field.name} = ${emitExpr(field.value)}`);
-				if (entries.length === 0) {
-					return "{}";
-				}
-				return `{ ${entries.join(", ")} }`;
-			}
-			case "unary": {
-				const inner = emitExpr(node.argument);
-				if (node.op === "!") {
-					return `not ${inner}`;
-				}
-				return `-${inner}`;
-			}
-			case "getService":
-				return `game:GetService("${node.service}")`;
-			case "new": {
-				if (isLibraryType(node.className) || !isInstanceType(node.className)) {
-					const args = node.args.map(emitExpr).join(", ");
-					return `${node.className}.new(${args})`;
-				}
-				return `Instance.new("${node.className}")`;
-			}
-			case "member":
-				return `${emitExpr(node.object)}.${node.name}`;
-			case "call": {
-				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})`;
-					}
-					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})`;
-				}
-				const colon = isMethod(node.name) || isLibraryMethod(node.name);
-				return `${obj}${colon ? ":" : "."}${node.name}(${args})`;
-			}
-			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)}`;
-			}
-			default:
-				return "nil";
-		}
-	};
-
-	const inferredType = (node) => {
-		const created = node.value;
-		if (created && created.type === "new" && (isInstanceType(created.className) || isLibraryType(created.className) || isDatatype(created.className))) {
-			return created.className;
-		}
-		if (created && created.type === "call" && !created.object && isDatatype(created.name)) {
-			return created.name;
-		}
-		if (created && created.type === "getService") {
-			return created.service;
-		}
-		const fromCpp = luauType(node.valueType);
-		if (fromCpp && fromCpp !== "auto") {
-			return fromCpp;
-		}
-		return null;
-	};
-
-	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}` : "";
-		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]) {
-				linesOut.push(`${prefix}${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}${kind} ${node.name}${typed} = ${created.className}.new(${args})`];
-		}
-		const value = node.value ? emitExpr(node.value) : "nil";
-		return [`${prefix}${kind} ${node.name}${typed} = ${value}`];
-	};
-
-	const emitStmt = (node, indent) => {
-		const prefix = indentOf(indent);
-		switch (node.type) {
-			case "decl":
-				if (node.name) {
-					localNames.add(node.name);
-				}
-				return emitNewDecl(node, indent);
-			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": {
-				const out = [`${prefix}if ${emitExpr(node.test)} then`];
-				for (const stmt of node.consequent) {
-					out.push(...emitStmt(stmt, indent + 1));
-				}
-				if (node.alternate) {
-					out.push(`${prefix}else`);
-					for (const stmt of node.alternate) {
-						out.push(...emitStmt(stmt, indent + 1));
-					}
-				}
-				out.push(`${prefix}end`);
-				return out;
-			}
-			case "while": {
-				const out = [`${prefix}while ${emitExpr(node.test)} do`];
-				for (const stmt of node.body) {
-					out.push(...emitStmt(stmt, indent + 1));
-				}
-				out.push(`${prefix}end`);
-				return out;
-			}
-			case "foreach": {
-				const out = [`${prefix}for _, ${node.name} in ${emitExpr(node.iter)} do`];
-				for (const stmt of node.body) {
-					out.push(...emitStmt(stmt, indent + 1));
-				}
-				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 [];
-		}
-	};
-
-	const paramList = (fn) =>
-		fn.params
-			.map((param) => {
-				if (typeof param === "string") {
-					return param;
-				}
-				const typeAnn = luauType(param.valueType);
-				return typeAnn ? `${param.name}: ${typeAnn}` : param.name;
-			})
-			.join(", ");
-
-	const returnAnn = (fn) => {
-		const typeAnn = luauType(fn.returnType);
-		if (!typeAnn || typeAnn === "()") {
-			return "";
-		}
-		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;
-		}
-		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 (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("");
-	}
-
-	return lines.join("\n");
-}
-
-export { emit };

package/src/emitter/luau-codegen.ts

@@ -1,187 +0,0 @@
-import type { TranspilerState } from "../types.js";
-
-const GET_SERVICE = /^const\s+([A-Za-z_][\w]*)\s*=\s*game:GetService\("([A-Za-z_][\w]*)"\)\s*$/;
-const REQUIRE_LINE = /^const\s+([A-Za-z_][\w]*)\s*=\s*require\((.+)\)\s*$/;
-
-export class LuauCodeEmitter {
-	public static emptyState(strict = false): TranspilerState {
-		return {
-			robloxServices: new Set<string>(),
-			moduleRequires: new Map<string, string>(),
-			customTypes: [],
-			constants: [],
-			functions: [],
-			headerLines: [],
-			strict,
-		};
-	}
-
-	public static emit(state: TranspilerState): string {
-		const output: string[] = [];
-		if (state.strict) {
-			output.push("--!strict");
-		}
-		if (state.headerLines.length > 0) {
-			output.push(...state.headerLines);
-		} else {
-			output.push("-- Compiled by Cluaupp — C++ × Luau");
-		}
-		output.push("");
-
-		if (state.robloxServices.size > 0) {
-			for (const service of Array.from(state.robloxServices).sort()) {
-				output.push(`const ${service} = game:GetService("${service}")`);
-			}
-			output.push("");
-		}
-
-		if (state.moduleRequires.size > 0) {
-			for (const [alias, requirePath] of Array.from(state.moduleRequires.entries()).sort(([a], [b]) => a.localeCompare(b))) {
-				output.push(`const ${alias} = require(${requirePath})`);
-			}
-			output.push("");
-		}
-
-		if (state.customTypes.length > 0) {
-			output.push(...state.customTypes);
-			output.push("");
-		}
-
-		if (state.constants.length > 0) {
-			output.push(...state.constants);
-			output.push("");
-		}
-
-		if (state.functions.length > 0) {
-			output.push(...state.functions);
-		} else {
-			output.push("-- Nenhum método ou lógica detectado para transcompilação.");
-		}
-
-		return output.join("\n").replace(/\n{3,}/g, "\n\n") + "\n";
-	}
-
-	public static merge(state: TranspilerState, compiledLuau: string): string {
-		const trimmed = String(compiledLuau || "").trim();
-		if (!trimmed || trimmed.startsWith("{") || trimmed.startsWith("[")) {
-			return compiledLuau;
-		}
-
-		const harvested = harvestPreamble(compiledLuau);
-		for (const service of harvested.services) {
-			state.robloxServices.add(service);
-		}
-		for (const [alias, requirePath] of harvested.requires) {
-			if (!state.moduleRequires.has(alias)) {
-				state.moduleRequires.set(alias, requirePath);
-			}
-		}
-
-		const output: string[] = [];
-		output.push(...(harvested.header.length > 0 ? harvested.header : ["-- Compiled by Cluaupp — C++ × Luau"]));
-		for (const line of state.headerLines) {
-			if (line && !output.includes(line)) {
-				output.push(line);
-			}
-		}
-		if (state.strict && !output.some((line) => line.startsWith("--!strict"))) {
-			output.unshift("--!strict");
-		}
-		output.push("");
-
-		if (state.robloxServices.size > 0) {
-			for (const service of Array.from(state.robloxServices).sort()) {
-				output.push(`const ${service} = game:GetService("${service}")`);
-			}
-			output.push("");
-		}
-
-		if (state.moduleRequires.size > 0) {
-			for (const [alias, requirePath] of Array.from(state.moduleRequires.entries()).sort(([a], [b]) => a.localeCompare(b))) {
-				output.push(`const ${alias} = require(${requirePath})`);
-			}
-			output.push("");
-		}
-
-		const rest = harvested.body.trim();
-		const extraTypes = state.customTypes.filter((line) => !bodyHasDecl(rest, line, /^type\s+(\w+)/));
-		const extraConsts = state.constants.filter((line) => !bodyHasDecl(rest, line, /^const\s+(\w+)/));
-		if (extraTypes.length > 0) {
-			output.push(...extraTypes, "");
-		}
-		if (extraConsts.length > 0) {
-			output.push(...extraConsts, "");
-		}
-		if (rest) {
-			output.push(rest);
-		} else if (state.customTypes.length || state.constants.length || state.functions.length) {
-			if (state.customTypes.length) {
-				output.push(...state.customTypes, "");
-			}
-			if (state.constants.length) {
-				output.push(...state.constants, "");
-			}
-			if (state.functions.length) {
-				output.push(...state.functions);
-			}
-		}
-
-		return `${output.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd()}\n`;
-	}
-}
-
-function harvestPreamble(luau: string): {
-	header: string[];
-	services: Set<string>;
-	requires: Map<string, string>;
-	body: string;
-} {
-	const lines = luau.split(/\r?\n/);
-	const header: string[] = [];
-	const services = new Set<string>();
-	const requires = new Map<string, string>();
-	let i = 0;
-
-	while (i < lines.length && (lines[i].startsWith("--") || lines[i].trim() === "")) {
-		if (lines[i].startsWith("--")) {
-			header.push(lines[i]);
-		}
-		i += 1;
-	}
-
-	while (i < lines.length) {
-		const line = lines[i];
-		if (line.trim() === "") {
-			i += 1;
-			continue;
-		}
-		const service = line.match(GET_SERVICE);
-		if (service && service[1] === service[2]) {
-			services.add(service[1]);
-			i += 1;
-			continue;
-		}
-		const required = line.match(REQUIRE_LINE);
-		if (required) {
-			requires.set(required[1], required[2]);
-			i += 1;
-			continue;
-		}
-		break;
-	}
-
-	return {
-		header,
-		services,
-		requires,
-		body: lines.slice(i).join("\n"),
-	};
-}
-
-function bodyHasDecl(body: string, line: string, pattern: RegExp): boolean {
-	const match = line.match(pattern);
-	if (!match) {
-		return body.includes(line);
-	}
-	return new RegExp(`^(?:export\\s+)?(?:type|const)\\s+${match[1]}\\b`, "m").test(body);
-}