cluaupp 0.1.2 → 0.1.4

package/src/editor-install.js

@@ -0,0 +1,218 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const https = require("https");
+const { spawnSync } = require("child_process");
+
+const CPPTOOLS_ID = "ms-vscode.cpptools";
+const GITHUB_LATEST = "https://api.github.com/repos/microsoft/vscode-cpptools/releases/latest";
+
+function which(command) {
+	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:"));
+}
+
+function editorBin() {
+	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() {
+	return [
+		path.join(os.homedir(), ".cursor", "extensions"),
+		path.join(os.homedir(), ".vscode", "extensions"),
+	];
+}
+
+function isCppToolsInstalled() {
+	for (const home of extensionHomes()) {
+		if (!fs.existsSync(home)) {
+			continue;
+		}
+		try {
+			if (fs.readdirSync(home).some((name) => name.startsWith(CPPTOOLS_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(CPPTOOLS_ID);
+}
+
+function vsixAssetName(platform = process.platform, arch = process.arch) {
+	const cpu = arch === "arm64" ? "arm64" : "x64";
+	if (platform === "win32") {
+		return `cpptools-windows-${cpu}.vsix`;
+	}
+	if (platform === "darwin") {
+		return `cpptools-macOS-${cpu}.vsix`;
+	}
+	return `cpptools-linux-${cpu}.vsix`;
+}
+
+function httpsJson(url) {
+	return new Promise((resolve, reject) => {
+		const request = https.get(
+			url,
+			{ headers: { "User-Agent": "cluaupp", Accept: "application/vnd.github+json" } },
+			(response) => {
+				if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+					response.resume();
+					httpsJson(response.headers.location).then(resolve, reject);
+					return;
+				}
+				const chunks = [];
+				response.on("data", (chunk) => chunks.push(chunk));
+				response.on("end", () => {
+					if (response.statusCode !== 200) {
+						reject(new Error("GitHub " + response.statusCode));
+						return;
+					}
+					try {
+						resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+					} catch (err) {
+						reject(err);
+					}
+				});
+			},
+		);
+		request.on("error", reject);
+	});
+}
+
+function downloadFile(url, dest) {
+	return new Promise((resolve, reject) => {
+		const follow = (current) => {
+			https
+				.get(current, { headers: { "User-Agent": "cluaupp" } }, (response) => {
+					if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+						response.resume();
+						follow(response.headers.location);
+						return;
+					}
+					if (response.statusCode !== 200) {
+						reject(new Error("download failed " + response.statusCode));
+						return;
+					}
+					const out = fs.createWriteStream(dest);
+					response.pipe(out);
+					out.on("finish", () => out.close(() => resolve(dest)));
+					out.on("error", reject);
+				})
+				.on("error", reject);
+		};
+		follow(url);
+	});
+}
+
+async function downloadCppToolsVsix() {
+	const name = vsixAssetName();
+	const dest = path.join(os.tmpdir(), name);
+	if (fs.existsSync(dest) && fs.statSync(dest).size > 1_000_000) {
+		return dest;
+	}
+	const release = await httpsJson(GITHUB_LATEST);
+	const asset = (release.assets || []).find((item) => item.name === name);
+	if (!asset || !asset.browser_download_url) {
+		throw new Error("no " + name + " in vscode-cpptools " + (release.tag_name || "latest"));
+	}
+	console.log("cluaupp: downloading", name, release.tag_name || "");
+	return downloadFile(asset.browser_download_url, dest);
+}
+
+function spawnInstall(bin, target) {
+	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,
+	};
+}
+
+async function installCppTools() {
+	if (isCppToolsInstalled()) {
+		return { status: "already", id: CPPTOOLS_ID };
+	}
+	const bin = editorBin();
+	if (!bin) {
+		return { status: "missing-editor", id: CPPTOOLS_ID };
+	}
+	console.log("cluaupp: installing", CPPTOOLS_ID);
+	const marketplace = spawnInstall(bin, CPPTOOLS_ID);
+	if (marketplace.ok) {
+		return { status: "installed", id: CPPTOOLS_ID, how: "marketplace" };
+	}
+	try {
+		const vsix = await downloadCppToolsVsix();
+		const fromFile = spawnInstall(bin, vsix);
+		if (fromFile.ok) {
+			return { status: "installed", id: CPPTOOLS_ID, how: "vsix", file: vsix };
+		}
+		return { status: "failed", id: CPPTOOLS_ID, detail: fromFile.stderr || fromFile.stdout || marketplace.stderr };
+	} catch (err) {
+		return { status: "failed", id: CPPTOOLS_ID, detail: err.message };
+	}
+}
+
+function reportCppTools(result) {
+	if (!result) {
+		return;
+	}
+	if (result.status === "already") {
+		console.log("cluaupp: Microsoft C/C++ already installed");
+		return;
+	}
+	if (result.status === "installed") {
+		console.log("cluaupp: installed", CPPTOOLS_ID, result.how === "vsix" ? "(VSIX — Cursor marketplace does not list it)" : "");
+		console.log("cluaupp: reload the editor (Ctrl+Shift+P → Developer: Reload Window)");
+		return;
+	}
+	if (result.status === "missing-editor") {
+		console.error("cluaupp: Cursor/VS Code CLI not found. Install ms-vscode.cpptools from the VSIX at");
+		console.error("  https://github.com/microsoft/vscode-cpptools/releases");
+		return;
+	}
+	console.error("cluaupp: could not install", CPPTOOLS_ID + ":", result.detail || "unknown error");
+	console.error("  download https://github.com/microsoft/vscode-cpptools/releases and: cursor --install-extension cpptools-windows-x64.vsix");
+}
+
+module.exports = {
+	CPPTOOLS_ID,
+	editorBin,
+	isCppToolsInstalled,
+	vsixAssetName,
+	installCppTools,
+	reportCppTools,
+};

package/src/emit.js

@@ -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("");
 	}