cluaupp 0.2.3 → 1.3.0

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);
-}

package/src/emitter/translators.ts

@@ -1,168 +0,0 @@
-import type Parser from "tree-sitter";
-import { compileSource } from "../compile.js";
-
-type SyntaxNode = Parser.SyntaxNode;
-
-const TYPE_MAP: Record<string, string> = {
-	"std::string": "string",
-	"std::string_view": "string",
-	string: "string",
-	string_view: "string",
-	bool: "boolean",
-	int: "number",
-	int8_t: "number",
-	int16_t: "number",
-	int32_t: "number",
-	int64_t: "number",
-	uint8_t: "number",
-	uint16_t: "number",
-	uint32_t: "number",
-	uint64_t: "number",
-	float: "number",
-	double: "number",
-	size_t: "number",
-	void: "()",
-	auto: "any",
-};
-
-export function translateCppType(cppType: string): string {
-	const trimmed = cppType
-		.replace(/\b(?:const|constexpr|volatile|static|inline|restrict)\b/g, "")
-		.replace(/\s+/g, " ")
-		.replace(/&/g, "")
-		.replace(/\*/g, "")
-		.trim();
-	if (!trimmed) {
-		return "any";
-	}
-	if (TYPE_MAP[trimmed]) {
-		return TYPE_MAP[trimmed];
-	}
-	const generic = trimmed.match(/^(?:std::)?(?:vector|array|span|LuaArray)\s*<\s*([^>]+)\s*>$/);
-	if (generic) {
-		return `{${translateCppType(generic[1])}}`;
-	}
-	const optional = trimmed.match(/^(?:std::)?optional\s*<\s*([^>]+)\s*>$/);
-	if (optional) {
-		return `${translateCppType(optional[1])}?`;
-	}
-	return trimmed.replace(/^::/, "");
-}
-
-export function translateGetService(node: SyntaxNode): string | null {
-	const functionNode = node.childForFieldName("function") || node.namedChildren[0];
-	if (!functionNode) {
-		return null;
-	}
-	const text = functionNode.text.replace(/\s+/g, "");
-	const generic = text.match(/GetService<(\w+)>/);
-	if (generic) {
-		return generic[1];
-	}
-	if (!text.includes("GetService")) {
-		return null;
-	}
-	const args = functionNode.namedChildren.find((child) => child.type === "template_argument_list");
-	if (args) {
-		const ident = args.namedChildren.find((child) => child.type === "type_identifier" || child.type === "identifier");
-		if (ident) {
-			return ident.text;
-		}
-	}
-	const callText = node.text.replace(/\s+/g, "");
-	const match = callText.match(/GetService<(\w+)>/);
-	return match ? match[1] : null;
-}
-
-export function translateConstant(node: SyntaxNode): string | null {
-	const declarator = node.childForFieldName("declarator");
-	if (!declarator) {
-		return null;
-	}
-	const name = identifierOf(declarator);
-	const valueNode =
-		node.childForFieldName("value") ||
-		declarator.childForFieldName("value") ||
-		namedOf(declarator, "initializer") ||
-		node.namedChildren[node.namedChildren.length - 1];
-	if (!name || !valueNode || valueNode === declarator) {
-		return null;
-	}
-	let value = valueNode.text.replace(/;$/, "").trim();
-	if (value.startsWith("=")) {
-		value = value.slice(1).trim();
-	}
-	if (!value) {
-		return null;
-	}
-	return `const ${name} = ${value}`;
-}
-
-export function translateAlias(node: SyntaxNode, mapType: (cppType: string) => string): string | null {
-	const nameNode = node.childForFieldName("name") || namedOf(node, "type_identifier") || node.namedChildren[1];
-	const typeNode = node.childForFieldName("type") || namedOf(node, "type_descriptor") || node.namedChildren[0];
-	if (!nameNode || !typeNode) {
-		return null;
-	}
-	return `type ${nameNode.text} = ${mapType(typeNode.text)}`;
-}
-
-export function translateStruct(node: SyntaxNode, mapType: (cppType: string) => string): string | null {
-	const nameNode = node.childForFieldName("name") || namedOf(node, "type_identifier");
-	const body = node.childForFieldName("body") || namedOf(node, "field_declaration_list");
-	if (!nameNode) {
-		return null;
-	}
-	if (!body) {
-		return `type ${nameNode.text} = {}`;
-	}
-	const fields: string[] = [];
-	for (const field of body.namedChildren) {
-		if (field.type !== "field_declaration") {
-			continue;
-		}
-		const fieldType = field.childForFieldName("type");
-		const fieldDecl = field.childForFieldName("declarator");
-		const fieldName = fieldDecl ? identifierOf(fieldDecl) : namedOf(field, "field_identifier")?.text;
-		if (!fieldName) {
-			continue;
-		}
-		fields.push(`\t${fieldName}: ${mapType(fieldType?.text || "any")},`);
-	}
-	if (fields.length === 0) {
-		return `type ${nameNode.text} = {}`;
-	}
-	return `type ${nameNode.text} = {\n${fields.join("\n")}\n}`;
-}
-
-export function translateFunction(node: SyntaxNode, fileName: string): string | null {
-	try {
-		const luau = compileSource(node.text, fileName, { skipHeader: true });
-		const trimmed = String(luau || "").trim();
-		return trimmed || null;
-	} catch {
-		const name = identifierOf(node.childForFieldName("declarator") || node) || "fn";
-		return `-- function ${name} (não traduzida)`;
-	}
-}
-
-function identifierOf(node: SyntaxNode): string | null {
-	if (node.type === "identifier" || node.type === "field_identifier" || node.type === "type_identifier") {
-		return node.text;
-	}
-	const direct = node.childForFieldName("declarator") || namedOf(node, "identifier") || namedOf(node, "field_identifier");
-	if (direct) {
-		return identifierOf(direct);
-	}
-	for (const child of node.namedChildren) {
-		const found = identifierOf(child);
-		if (found) {
-			return found;
-		}
-	}
-	return null;
-}
-
-function namedOf(node: SyntaxNode, type: string): SyntaxNode | null {
-	return node.namedChildren.find((child) => child.type === type) || null;
-}

package/src/headers.ts

@@ -1,233 +0,0 @@
-// @ts-nocheck
-import path from "node:path";
-import { luauType } from "./api.js";
-
-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");
-}
-
-export {
-	emitHeaderModule,
-	primaryHeaderName,
-	collectHeaderShape,
-};

package/src/layout.ts

@@ -1,114 +0,0 @@
-import type { AstNode } from "./ast.js";
-
-export const SECTION = {
-	api: "API",
-	constants: "CONSTANTS",
-	variables: "VARIABLES",
-	types: "TYPES",
-	support: "HELPERS FUNCTIONS",
-	principal: "MAIN FUNCTIONS",
-	cleanup: "JANITOR",
-	returns: "RETURN",
-};
-
-export const CLEANUP_FN = /^(OnClose|OnPlayerRemoving|Cleanup|Shutdown|OnDestroy)$/i;
-export const PRINCIPAL_FN = /^(init|start|main|setup)/i;
-export const ENTRY_FN = /^(init|main)$/i;
-
-function isGetService(node: AstNode | null | undefined): boolean {
-	return Boolean(node && node.type === "getService");
-}
-
-function isDataServiceAlias(node: AstNode | null | undefined): boolean {
-	let current: AstNode | undefined = node || undefined;
-	while (current && current.type === "member") {
-		if (current.object && current.object.type === "ident" && current.object.name === "DataService") {
-			return true;
-		}
-		current = current.object;
-	}
-	return false;
-}
-
-export function isJanitorDecl(decl: AstNode | null | undefined): boolean {
-	if (!decl || decl.type !== "decl") {
-		return false;
-	}
-	const name = String(decl.name || "").toLowerCase();
-	const typeName = String(decl.valueType || "").toLowerCase();
-	const created = decl.value && decl.value.type === "new" && decl.value.className === "Janitor";
-	return name.includes("janitor") || typeName.includes("janitor") || created;
-}
-
-export function isApiDecl(decl: AstNode | null | undefined): boolean {
-	if (!decl || decl.type !== "decl") {
-		return false;
-	}
-	return isGetService(decl.value) || isDataServiceAlias(decl.value);
-}
-
-export function classifyDecl(decl: AstNode | null | undefined): string | null {
-	if (!decl || decl.type === "proto") {
-		return null;
-	}
-	if (decl.type === "decl") {
-		if (isApiDecl(decl)) {
-			return "api";
-		}
-		if (isJanitorDecl(decl)) {
-			return "variables";
-		}
-		if (decl.isConst) {
-			return "constants";
-		}
-		return "variables";
-	}
-	if (decl.type === "function") {
-		if (CLEANUP_FN.test(decl.name || "")) {
-			return "cleanup";
-		}
-		if (PRINCIPAL_FN.test(decl.name || "")) {
-			return "principal";
-		}
-		return "support";
-	}
-	return null;
-}
-
-export function organizeDecls(keep: AstNode[]): Record<string, AstNode[]> {
-	const groups: Record<string, AstNode[]> = {
-		api: [],
-		constants: [],
-		variables: [],
-		support: [],
-		principal: [],
-		cleanup: [],
-	};
-	for (const decl of keep) {
-		const bucket = classifyDecl(decl);
-		if (bucket && groups[bucket]) {
-			groups[bucket].push(decl);
-		}
-	}
-	return groups;
-}
-
-export function janitorNames(keep: AstNode[] | null | undefined): string[] {
-	return (keep || []).filter(isJanitorDecl).map((decl) => decl.name);
-}
-
-export function emitSection(_title: string, body: string): string {
-	const text = String(body || "").trimEnd();
-	if (!text) {
-		return "";
-	}
-	return `${text}\n\n`;
-}
-
-export function joinBlocks(parts: Array<string | null | undefined>): string {
-	return parts.filter((part) => Boolean(part && String(part).trim())).join("\n\n");
-}
-
-export function commentLine(title: string): string {
-	return `-- ${title}`;
-}