cluaupp 0.1.4 → 0.2.0

package/src/compile.ts

@@ -0,0 +1,118 @@
+import path from "node:path";
+import { parse } from "./parse.js";
+import { emit } from "./emit.js";
+import { preprocess, isHeaderFile, toLuauPath, siblingImplementation, siblingHeader, implOutName } from "./preprocess.js";
+import { collectLibraries, insertPreamble } from "./libs.js";
+import { planOutput } from "./architecture.js";
+import { emitHeaderModule, primaryHeaderName } from "./headers.js";
+import type { AstProgram, ModuleInclude, PreprocessOptions } from "./ast.js";
+import type { CompileOptions, CompileServiceResult } from "./types.js";
+
+function shouldAttachRequires(name: string, contents: string): boolean {
+	const file = String(name || "").replace(/\\/g, "/");
+	if (/\.json$/i.test(file) || /\.meta\.json$/i.test(file)) {
+		return false;
+	}
+	const trimmed = String(contents || "").trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+		return false;
+	}
+	return true;
+}
+
+function attachRequires(contents: string, source: string, ast: AstProgram, options: PreprocessOptions, outName: string): string {
+	if (!shouldAttachRequires(outName, contents)) {
+		return contents;
+	}
+	const libraries = String(contents).includes("CluauppLibs") ? [] : collectLibraries(source, ast);
+	return insertPreamble(contents, options.moduleIncludes || [], libraries, outName);
+}
+
+function posixRel(from: string, file: string): string {
+	return path.relative(from, file).replace(/\\/g, "/");
+}
+
+function wireHeaderImpl(ast: AstProgram, fileName: string, options: PreprocessOptions): void {
+	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: ModuleInclude) => spec.name === options.headerImplName)) {
+		options.moduleIncludes.push({
+			name: options.headerImplName,
+			outRel: implOut,
+			exports: { consts: [], structs: [] },
+		});
+	}
+}
+
+function compileHeader(source: string, fileName: string, options: PreprocessOptions, ast: AstProgram): CompileServiceResult {
+	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: [],
+	};
+}
+
+export function compileSource(source: string, fileName?: string, options: CompileOptions = {}): string {
+	const opts = options as PreprocessOptions;
+	opts.moduleIncludes = opts.moduleIncludes || [];
+	const prepared = preprocess(source, opts.filePath || null, opts);
+	const ast = parse(prepared, fileName || "input.cpp");
+	if (isHeaderFile(fileName || "") || isHeaderFile(opts.filePath || "")) {
+		return compileHeader(source, fileName || "header.h", opts, ast).files[0].contents;
+	}
+	const luau = emit(ast, opts);
+	return attachRequires(luau, source, ast, opts, opts.outName || fileName || "input.cpp");
+}
+
+export function compileService(source: string, fileName?: string, options: CompileOptions = {}): CompileServiceResult {
+	const opts = options as PreprocessOptions;
+	opts.moduleIncludes = opts.moduleIncludes || [];
+	const prepared = preprocess(source, opts.filePath || null, opts);
+	const ast = parse(prepared, fileName || "input.cpp");
+	if (isHeaderFile(fileName || "") || isHeaderFile(opts.filePath || "") || isHeaderFile(opts.relativeName || "")) {
+		return compileHeader(source, fileName || "header.h", opts, ast);
+	}
+	const implHeader = opts.filePath ? siblingHeader(opts.filePath) : null;
+	if (implHeader) {
+		opts.skipInit = true;
+	}
+	const planned = planOutput(ast, fileName || "input.cpp", {
+		...opts,
+		relativeName: opts.relativeName || fileName,
+		source: prepared,
+		siblingHeader: implHeader,
+	});
+	if (planned.files) {
+		return {
+			...planned,
+			files: planned.files.map((file: { name: string; contents: string }) => ({
+				...file,
+				contents: attachRequires(file.contents, source, ast, opts, file.name),
+			})),
+		};
+	}
+	const luau = attachRequires(emit(ast, opts), source, ast, opts, planned.outName || opts.outName || fileName || "input.cpp");
+	const name =
+		planned.outName ||
+		opts.outName ||
+		String(fileName || "input.cpp").replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+	return {
+		kind: planned.kind || "flat",
+		plan: planned.plan,
+		files: [{ name, contents: luau }],
+		stale: planned.stale || [],
+	};
+}

package/src/editor-install.ts

@@ -0,0 +1,182 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+export const CLANGD_ID = "llvm-vs-code-extensions.vscode-clangd";
+
+export type InstallResult = {
+	status: string;
+	id?: string;
+	path?: string;
+	how?: string;
+	detail?: string;
+	hint?: string;
+};
+
+function which(command: string): string | null {
+	const finder = process.platform === "win32" ? "where" : "which";
+	const result = spawnSync(finder, [command], { encoding: "utf8", windowsHide: true });
+	if (result.status !== 0) {
+		return null;
+	}
+	return String(result.stdout || "")
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.find((line) => line && !line.toLowerCase().includes("info:")) || null;
+}
+
+export function editorBin(): string | null {
+	const found = which("cursor") || which("code");
+	if (found) {
+		return found;
+	}
+	const local = process.env.LOCALAPPDATA || "";
+	const fallbacks = [
+		path.join(local, "Programs", "cursor", "resources", "app", "bin", "cursor.cmd"),
+		path.join(local, "Programs", "Microsoft VS Code", "bin", "code.cmd"),
+		"/usr/bin/cursor",
+		"/usr/local/bin/cursor",
+		"/usr/bin/code",
+		"/usr/local/bin/code",
+	];
+	return fallbacks.find((file) => fs.existsSync(file)) || null;
+}
+
+function extensionHomes(): string[] {
+	return [path.join(os.homedir(), ".cursor", "extensions"), path.join(os.homedir(), ".vscode", "extensions")];
+}
+
+export function isExtensionInstalled(id: string): boolean {
+	for (const home of extensionHomes()) {
+		if (!fs.existsSync(home)) {
+			continue;
+		}
+		try {
+			if (fs.readdirSync(home).some((name) => name.startsWith(`${id}-`))) {
+				return true;
+			}
+		} catch {
+			// ignore
+		}
+	}
+	const bin = editorBin();
+	if (!bin) {
+		return false;
+	}
+	const listed = spawnSync(bin, ["--list-extensions"], { encoding: "utf8", windowsHide: true, timeout: 20000 });
+	return String(listed.stdout || "").split(/\r?\n/).includes(id);
+}
+
+function llvmCandidates(): string[] {
+	if (process.platform === "win32") {
+		return [
+			"C:/Program Files/LLVM/bin/clang++.exe",
+			"C:/Program Files (x86)/LLVM/bin/clang++.exe",
+			path.join(process.env.ProgramFiles || "C:/Program Files", "LLVM", "bin", "clang++.exe"),
+			"C:/msys64/ucrt64/bin/clang++.exe",
+			"C:/msys64/mingw64/bin/clang++.exe",
+		];
+	}
+	return ["/usr/bin/clang++", "/usr/local/bin/clang++", "/opt/homebrew/bin/clang++"];
+}
+
+export function findClangPlusPlus(): string | null {
+	for (const candidate of llvmCandidates()) {
+		if (candidate && fs.existsSync(candidate)) {
+			return candidate.replace(/\\/g, "/");
+		}
+	}
+	return which("clang++");
+}
+
+export function ensureLlvm(): InstallResult {
+	const found = findClangPlusPlus();
+	if (found) {
+		return { status: "already", path: found };
+	}
+	if (process.platform === "win32" && which("winget")) {
+		console.log("cluaupp: installing LLVM.LLVM (clang++ / clangd) via winget");
+		const result = spawnSync(
+			"winget",
+			["install", "--id", "LLVM.LLVM", "-e", "--accept-package-agreements", "--accept-source-agreements"],
+			{ encoding: "utf8", windowsHide: true, timeout: 300000 },
+		);
+		const after = findClangPlusPlus();
+		if (after) {
+			return { status: "installed", path: after, how: "winget" };
+		}
+		return {
+			status: "missing",
+			detail: String(result.stderr || result.stdout || "").trim() || "winget did not install LLVM",
+			hint: "winget install --id LLVM.LLVM -e",
+		};
+	}
+	const hint =
+		process.platform === "darwin"
+			? "brew install llvm"
+			: process.platform === "win32"
+				? "winget install --id LLVM.LLVM -e"
+				: "sudo apt install clang";
+	return { status: "missing", hint };
+}
+
+function spawnInstall(bin: string, target: string) {
+	const result = spawnSync(bin, ["--install-extension", target, "--force"], {
+		encoding: "utf8",
+		windowsHide: true,
+		timeout: 180000,
+	});
+	return {
+		ok: result.status === 0 && !/not found/i.test(String(result.stderr || "") + String(result.stdout || "")),
+		stdout: String(result.stdout || ""),
+		stderr: String(result.stderr || ""),
+		status: result.status,
+	};
+}
+
+export async function installMarketplaceExtension(id: string, label?: string): Promise<InstallResult> {
+	if (isExtensionInstalled(id)) {
+		return { status: "already", id };
+	}
+	const bin = editorBin();
+	if (!bin) {
+		return { status: "missing-editor", id };
+	}
+	console.log("cluaupp: installing", label || id);
+	const marketplace = spawnInstall(bin, id);
+	if (marketplace.ok) {
+		return { status: "installed", id, how: "marketplace" };
+	}
+	return { status: "failed", id, detail: marketplace.stderr || marketplace.stdout };
+}
+
+export function reportInstall(result: InstallResult | null | undefined, label?: string, extraMissing?: string): void {
+	if (!result) {
+		return;
+	}
+	const name = label || result.id;
+	if (result.status === "already") {
+		console.log("cluaupp:", name, "already installed");
+		return;
+	}
+	if (result.status === "installed") {
+		console.log("cluaupp: installed", name, result.how ? `(${result.how})` : "");
+		return;
+	}
+	if (result.status === "missing-editor") {
+		console.error("cluaupp: Cursor/VS Code CLI not found. Install", name, "from the marketplace.");
+		return;
+	}
+	if (result.status === "missing") {
+		console.error("cluaupp: LLVM clang++ not found.", result.hint || extraMissing || "");
+		if (result.detail) {
+			console.error(" ", result.detail.split(/\r?\n/)[0]);
+		}
+		return;
+	}
+	console.error("cluaupp: could not install", name + ":", result.detail || "unknown error");
+	if (extraMissing) {
+		console.error(" ", extraMissing);
+	}
+}

package/src/{emit.js → emit.ts}

@@ -1,10 +1,9 @@
-"use strict";
-
-const { isInstanceType, isMethod, isDatatype, luauType } = require("./api");
-const { isLibraryType, isLibraryMethod, MODULE_COLON } = require("./libs");
+// @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 !== false;
+	const strict = options.strict === true;
 	const lines = [];
 	if (!options.skipHeader) {
 		if (strict) {
@@ -529,4 +528,4 @@ function emit(ast, options = {}) {
 	return lines.join("\n");
 }
 
-module.exports = { emit };
+export { emit };

package/src/emitter/luau-codegen.ts

@@ -0,0 +1,187 @@
+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

@@ -0,0 +1,168 @@
+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;
+}