cluaupp 0.2.2 → 1.0.0

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

package/src/lex.ts

@@ -1,155 +0,0 @@
-import type { Token } from "./ast.js";
-
-const KEYWORDS = new Set([
-	"if",
-	"else",
-	"for",
-	"while",
-	"return",
-	"new",
-	"auto",
-	"const",
-	"void",
-	"int",
-	"bool",
-	"float",
-	"double",
-	"true",
-	"false",
-	"nullptr",
-	"class",
-	"struct",
-	"public",
-	"private",
-	"protected",
-	"namespace",
-	"using",
-	"template",
-	"typedef",
-	"extern",
-	"enum",
-	"switch",
-	"case",
-	"default",
-	"break",
-]);
-
-export function tokenize(source: string): Token[] {
-	const tokens: Token[] = [];
-	let i = 0;
-	let line = 1;
-	let col = 1;
-
-	const push = (type: string, value: string, startLine: number, startCol: number, start: number, end: number) => {
-		tokens.push({ type, value, line: startLine, col: startCol, start, end });
-	};
-
-	while (i < source.length) {
-		const c = source[i];
-
-		if (c === "\n") {
-			i += 1;
-			line += 1;
-			col = 1;
-			continue;
-		}
-		if (c === " " || c === "\t" || c === "\r") {
-			i += 1;
-			col += 1;
-			continue;
-		}
-		if (c === "#") {
-			while (i < source.length && source[i] !== "\n") {
-				i += 1;
-			}
-			continue;
-		}
-		if (c === "/" && source[i + 1] === "/") {
-			while (i < source.length && source[i] !== "\n") {
-				i += 1;
-			}
-			continue;
-		}
-		if (c === "/" && source[i + 1] === "*") {
-			i += 2;
-			col += 2;
-			while (i < source.length && !(source[i] === "*" && source[i + 1] === "/")) {
-				if (source[i] === "\n") {
-					line += 1;
-					col = 1;
-				} else {
-					col += 1;
-				}
-				i += 1;
-			}
-			i += 2;
-			col += 2;
-			continue;
-		}
-
-		const startLine = line;
-		const startCol = col;
-
-		if (c === '"') {
-			const start = i;
-			i += 1;
-			col += 1;
-			let value = "";
-			while (i < source.length && source[i] !== '"') {
-				if (source[i] === "\\" && i + 1 < source.length) {
-					value += source[i] + source[i + 1];
-					i += 2;
-					col += 2;
-					continue;
-				}
-				value += source[i];
-				i += 1;
-				col += 1;
-			}
-			i += 1;
-			col += 1;
-			push("string", value, startLine, startCol, start, i);
-			continue;
-		}
-
-		if (/[0-9]/.test(c)) {
-			const start = i;
-			let value = "";
-			while (i < source.length && /[0-9.]/.test(source[i])) {
-				value += source[i];
-				i += 1;
-				col += 1;
-			}
-			push("number", value, startLine, startCol, start, i);
-			continue;
-		}
-
-		if (/[A-Za-z_]/.test(c)) {
-			const start = i;
-			let value = "";
-			while (i < source.length && /[A-Za-z0-9_]/.test(source[i])) {
-				value += source[i];
-				i += 1;
-				col += 1;
-			}
-			push(KEYWORDS.has(value) ? "kw" : "ident", value, startLine, startCol, start, i);
-			continue;
-		}
-
-		const two = source.slice(i, i + 2);
-		const start = i;
-		if (["->", "==", "!=", "<=", ">=", "&&", "||", "::", "<<", ">>"].includes(two)) {
-			push("op", two, startLine, startCol, start, i + 2);
-			i += 2;
-			col += 2;
-			continue;
-		}
-
-		push("op", c, startLine, startCol, start, i + 1);
-		i += 1;
-		col += 1;
-	}
-
-	push("eof", "", line, col, source.length, source.length);
-	return tokens;
-}