cluaupp 0.1.2 → 0.1.5

package/src/layout.js

@@ -0,0 +1,129 @@
+"use strict";
+
+const SECTION = {
+	api: "API",
+	constants: "CONSTANTES",
+	variables: "VARIAVEIS",
+	types: "TIPAGENS",
+	support: "FUNÇÕES DE SUPORTE",
+	principal: "FUNÇÕES PRINCIPAIS",
+	cleanup: "LIMPEZA",
+	returns: "RETORNO",
+};
+
+const CLEANUP_FN = /^(OnClose|OnPlayerRemoving|Cleanup|Shutdown|OnDestroy)$/i;
+const PRINCIPAL_FN = /^(init|start|main|setup)/i;
+const ENTRY_FN = /^(init|main)$/i;
+
+function isGetService(node) {
+	return Boolean(node && node.type === "getService");
+}
+
+function isDataServiceAlias(node) {
+	let current = node;
+	while (current && current.type === "member") {
+		if (current.object && current.object.type === "ident" && current.object.name === "DataService") {
+			return true;
+		}
+		current = current.object;
+	}
+	return false;
+}
+
+function isJanitorDecl(decl) {
+	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;
+}
+
+function isApiDecl(decl) {
+	if (!decl || decl.type !== "decl") {
+		return false;
+	}
+	return isGetService(decl.value) || isDataServiceAlias(decl.value);
+}
+
+function classifyDecl(decl) {
+	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;
+}
+
+function organizeDecls(keep) {
+	const groups = {
+		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;
+}
+
+function janitorNames(keep) {
+	return (keep || []).filter(isJanitorDecl).map((decl) => decl.name);
+}
+
+function emitSection(_title, body) {
+	const text = String(body || "").trimEnd();
+	if (!text) {
+		return "";
+	}
+	return `${text}\n\n`;
+}
+
+function joinBlocks(parts) {
+	return parts.filter((part) => Boolean(part && String(part).trim())).join("\n\n");
+}
+
+function commentLine(title) {
+	return `-- ${title}`;
+}
+
+module.exports = {
+	SECTION,
+	CLEANUP_FN,
+	PRINCIPAL_FN,
+	ENTRY_FN,
+	isJanitorDecl,
+	isApiDecl,
+	classifyDecl,
+	organizeDecls,
+	janitorNames,
+	emitSection,
+	joinBlocks,
+	commentLine,
+};

package/src/lex.js

@@ -28,6 +28,10 @@ const KEYWORDS = new Set([
 	"typedef",
 	"extern",
 	"enum",
+	"switch",
+	"case",
+	"default",
+	"break",
 ]);
 
 function tokenize(source) {
@@ -36,8 +40,8 @@ function tokenize(source) {
 	let line = 1;
 	let col = 1;
 
-	const push = (type, value, startLine, startCol) => {
-		tokens.push({ type, value, line: startLine, col: startCol });
+	const push = (type, value, startLine, startCol, start, end) => {
+		tokens.push({ type, value, line: startLine, col: startCol, start, end });
 	};
 
 	while (i < source.length) {
@@ -87,6 +91,7 @@ function tokenize(source) {
 		const startCol = col;
 
 		if (c === '"') {
+			const start = i;
 			i += 1;
 			col += 1;
 			let value = "";
@@ -103,46 +108,49 @@ function tokenize(source) {
 			}
 			i += 1;
 			col += 1;
-			push("string", value, startLine, startCol);
+			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);
+			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);
+			push(KEYWORDS.has(value) ? "kw" : "ident", value, startLine, startCol, start, i);
 			continue;
 		}
 
 		const two = source.slice(i, i + 2);
-		if (["->", "==", "!=", "<=", ">=", "&&", "||", "::"].includes(two)) {
-			push("op", two, startLine, startCol);
+		const start = i;
+		if (["->", "==", "!=", "<=", ">=", "&&", "||", "::", "<<", ">>"].includes(two)) {
+			push("op", two, startLine, startCol, start, i + 2);
 			i += 2;
 			col += 2;
 			continue;
 		}
 
-		push("op", c, startLine, startCol);
+		push("op", c, startLine, startCol, start, i + 1);
 		i += 1;
 		col += 1;
 	}
 
-	push("eof", "", line, col);
+	push("eof", "", line, col, source.length, source.length);
 	return tokens;
 }
 

package/src/libs.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const path = require("path");
+
 const TYPE_EXPORTS = {
 	Janitor: "Janitor",
 	Promise: "Promise",
@@ -100,12 +102,12 @@ const LIBRARY_METHODS = new Set([
 	"Remove",
 	"RemoveNoClean",
 	"RemoveList",
+	"RemoveListNoClean",
 	"GetAll",
 	"Cleanup",
 	"Destroy",
 	"LinkToInstance",
 	"LinkToInstances",
-	"Has",
 	"Then",
 	"Catch",
 	"Finally",
@@ -297,46 +299,189 @@ function collectLibraries(source, ast) {
 	return unique;
 }
 
+const ROJO_ROOTS = {
+	shared: { service: "ReplicatedStorage", expr: "ReplicatedStorage.Cluaupp" },
+	server: { service: "ServerScriptService", expr: "ServerScriptService.Cluaupp" },
+	client: { service: "StarterPlayer", expr: "StarterPlayer.StarterPlayerScripts.Cluaupp" },
+};
+
+const SERVICE_ORDER = ["ReplicatedStorage", "ServerScriptService", "StarterPlayer"];
+
+const SERVICE_GET = {
+	ReplicatedStorage: 'const ReplicatedStorage = game:GetService("ReplicatedStorage")',
+	ServerScriptService: 'const ServerScriptService = game:GetService("ServerScriptService")',
+	StarterPlayer: 'const StarterPlayer = game:GetService("StarterPlayer")',
+};
+
 function requireCluauppLib(name) {
 	return `require(ReplicatedStorage.CluauppLibs.${name})`;
 }
 
-function emitRequires(libraries) {
-	if (!libraries.length) {
-		return "";
+function parseOutRel(toOutRel) {
+	const posix = String(toOutRel || "module.luau")
+		.replace(/\\/g, "/")
+		.replace(/\.luau$/i, "");
+	const parts = posix.split("/").filter(Boolean);
+	const tree = parts[0];
+	const root = ROJO_ROOTS[tree] || null;
+	const rest = root ? parts.slice(1) : parts;
+	return { tree, root, rest, posix };
+}
+
+function robloxRequireFrom(_fromOutRel, toOutRel) {
+	const { root, rest } = parseOutRel(toOutRel);
+	if (root) {
+		const tail = rest.join(".");
+		return tail ? `require(${root.expr}.${tail})` : `require(${root.expr})`;
+	}
+	const fromDir = path.posix.dirname(String(_fromOutRel || "module.luau").replace(/\\/g, "/"));
+	const toMod = String(toOutRel || "module.luau")
+		.replace(/\\/g, "/")
+		.replace(/\.luau$/i, "");
+	let rel = path.posix.relative(fromDir, toMod);
+	if (!rel || rel === ".") {
+		rel = path.posix.basename(toMod);
 	}
-	const lines = ['local ReplicatedStorage = game:GetService("ReplicatedStorage")'];
+	const parts = rel.split("/");
+	let expr = "script.Parent";
+	for (const part of parts) {
+		if (part === "..") {
+			expr += ".Parent";
+		} else if (part && part !== ".") {
+			expr += `.${part}`;
+		}
+	}
+	return `require(${expr})`;
+}
+
+function emitLibraryLines(libraries) {
+	const api = [];
+	const types = [];
 	for (const spec of libraries) {
-		lines.push(`local ${spec.bind} = ${requireCluauppLib(spec.file)}`);
+		api.push(`const ${spec.bind} = ${requireCluauppLib(spec.file)}`);
 		const exported = TYPE_EXPORTS[spec.bind];
 		if (exported) {
-			lines.push(`type ${spec.bind} = ${spec.bind}.${exported}`);
+			types.push(`type ${spec.bind} = ${spec.bind}.${exported}`);
 		}
 		const extra = EXTRA_TYPE_EXPORTS[spec.bind];
 		if (extra) {
 			for (const [alias, exportedName] of Object.entries(extra)) {
-				lines.push(`type ${alias} = ${spec.bind}.${exportedName}`);
+				types.push(`type ${alias} = ${spec.bind}.${exportedName}`);
 			}
 		}
 	}
-	return `${lines.join("\n")}\n`;
+	return { api, types };
+}
+
+function emitRequireParts(libraries) {
+	if (!libraries.length) {
+		return { api: "", types: "" };
+	}
+	const { api, types } = emitLibraryLines(libraries);
+	api.unshift(SERVICE_GET.ReplicatedStorage);
+	return {
+		api: `${api.join("\n")}\n`,
+		types: types.length ? `${types.join("\n")}\n` : "",
+	};
+}
+
+function emitRequires(libraries) {
+	const { api, types } = emitRequireParts(libraries);
+	return [api, types].filter((part) => Boolean(part && part.trim())).join("\n");
 }
 
 function insertRequires(luau, libraries) {
-	const block = emitRequires(libraries);
+	const block = emitRequires(libraries).trimEnd();
 	if (!block) {
 		return luau;
 	}
-	const marker = "-- Compiled by Cluaupp — C++ × Luau";
-	const index = luau.indexOf(marker);
-	if (index === -1) {
-		return `${block}\n${luau}`;
+	return insertBlock(luau, block);
+}
+
+function moduleIsUsed(luau, spec) {
+	if (String(luau).includes(spec.name)) {
+		return true;
 	}
-	const insertAt = luau.indexOf("\n", index);
-	if (insertAt === -1) {
-		return `${luau}\n${block}`;
+	const exported = [...((spec.exports && spec.exports.consts) || []), ...((spec.exports && spec.exports.structs) || [])];
+	return exported.some((name) => String(luau).includes(name));
+}
+
+function moduleRequireLines(modules, fromOutRel, luau) {
+	const lines = [];
+	const services = new Set();
+	const seen = new Set();
+	for (const spec of modules || []) {
+		if (!spec || !spec.name || seen.has(spec.name)) {
+			continue;
+		}
+		if (fromOutRel && !moduleIsUsed(luau, spec)) {
+			continue;
+		}
+		seen.add(spec.name);
+		const { root } = parseOutRel(spec.outRel);
+		if (root) {
+			services.add(root.service);
+		}
+		lines.push(`const ${spec.name} = ${robloxRequireFrom(fromOutRel, spec.outRel)}`);
+		for (const name of (spec.exports && spec.exports.consts) || []) {
+			if (name !== spec.name) {
+				lines.push(`const ${name} = ${spec.name}.${name}`);
+			}
+		}
+		if (((spec.exports && spec.exports.structs) || []).includes(spec.name) || (spec.exports && spec.exports.hasProtos)) {
+			lines.push(`type ${spec.name} = ${spec.name}.${spec.name}`);
+		}
+	}
+	return { lines, services };
+}
+
+function insertModuleRequires(luau, modules, fromOutRel) {
+	return insertPreamble(luau, modules, [], fromOutRel);
+}
+
+function stripServiceGets(luau, services) {
+	let next = String(luau);
+	for (const name of services) {
+		const line = SERVICE_GET[name];
+		if (!line) {
+			continue;
+		}
+		next = next.replace(new RegExp(`^${line.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "m"), "");
+	}
+	return next;
+}
+
+function insertPreamble(luau, modules, libraries, fromOutRel) {
+	const { lines: moduleLines, services } = moduleRequireLines(modules, fromOutRel, luau);
+	const libList = libraries || [];
+	if (libList.length) {
+		services.add("ReplicatedStorage");
+	}
+	if (moduleLines.length === 0 && libList.length === 0) {
+		return luau;
+	}
+	const { api: libApi, types: libTypes } = emitLibraryLines(libList);
+	const blockLines = [];
+	for (const name of SERVICE_ORDER) {
+		if (services.has(name)) {
+			blockLines.push(SERVICE_GET[name]);
+		}
+	}
+	blockLines.push(...moduleLines);
+	blockLines.push(...libApi);
+	blockLines.push(...libTypes);
+	const body = stripServiceGets(luau, services);
+	return insertBlock(body, blockLines.join("\n"));
+}
+
+function insertBlock(luau, block) {
+	const match = String(luau).match(/^(?:--[^\n]*\n)+/);
+	if (!match) {
+		return `${block}\n${luau}`;
 	}
-	return `${luau.slice(0, insertAt + 1)}\n${block}${luau.slice(insertAt + 1)}`;
+	const insertAt = match[0].length;
+	const rest = luau.slice(insertAt).replace(/^\n*/, "\n");
+	return `${luau.slice(0, insertAt)}\n${block}\n${rest}`;
 }
 
 module.exports = {
@@ -352,4 +497,6 @@ module.exports = {
 	requireCluauppLib,
 	emitRequires,
 	insertRequires,
+	insertModuleRequires,
+	insertPreamble,
 };

package/src/lsp.js

@@ -0,0 +1,227 @@
+"use strict";
+
+const { completeAt, hoverAt, definitionAt, diagnosticsFor } = require("./intellisense");
+
+function readMessage(buffer) {
+	const headerEnd = buffer.indexOf("\r\n\r\n");
+	if (headerEnd < 0) {
+		return null;
+	}
+	const header = buffer.slice(0, headerEnd).toString("utf8");
+	const match = header.match(/Content-Length:\s*(\d+)/i);
+	if (!match) {
+		return null;
+	}
+	const length = Number(match[1]);
+	const start = headerEnd + 4;
+	if (buffer.length < start + length) {
+		return null;
+	}
+	const json = buffer.slice(start, start + length).toString("utf8");
+	return { message: JSON.parse(json), rest: buffer.slice(start + length) };
+}
+
+function send(message) {
+	const json = JSON.stringify(message);
+	const payload = Buffer.from(json, "utf8");
+	process.stdout.write(`Content-Length: ${payload.length}\r\n\r\n`);
+	process.stdout.write(payload);
+}
+
+function posToOffset(text, position) {
+	const lines = text.split(/\n/);
+	let offset = 0;
+	for (let i = 0; i < position.line; i += 1) {
+		offset += (lines[i] || "").length + 1;
+	}
+	return offset + (position.character || 0);
+}
+
+function kindNumber(kind) {
+	switch (kind) {
+		case "method":
+		case "function":
+			return 3;
+		case "constructor":
+			return 4;
+		case "property":
+		case "variable":
+			return 6;
+		case "class":
+			return 7;
+		case "enum":
+			return 13;
+		case "keyword":
+			return 14;
+		case "event":
+			return 23;
+		case "file":
+			return 17;
+		default:
+			return 1;
+	}
+}
+
+function start(options = {}) {
+	const projectRoot = options.projectRoot || process.cwd();
+	const documents = new Map();
+	let buffer = Buffer.alloc(0);
+	let id = 0;
+
+	const uriPath = (uri) => {
+		let file = String(uri || "").replace(/^file:\/\//, "");
+		if (/^\/[A-Za-z]:/.test(file)) {
+			file = file.slice(1);
+		}
+		return decodeURIComponent(file);
+	};
+
+	const docText = (uri) => documents.get(uri) || "";
+
+	const publishDiagnostics = (uri) => {
+		const file = uriPath(uri);
+		const text = docText(uri);
+		const items = diagnosticsFor(text, file, {
+			filePath: file,
+			projectRoot,
+			includeDirs: [pathDirname(file), require("path").join(projectRoot, "src"), require("path").join(projectRoot, "include")],
+		});
+		send({
+			jsonrpc: "2.0",
+			method: "textDocument/publishDiagnostics",
+			params: {
+				uri,
+				diagnostics: items.map((item) => ({
+					range: {
+						start: { line: Math.max(0, (item.line || 1) - 1), character: Math.max(0, (item.col || 1) - 1) },
+						end: { line: Math.max(0, (item.line || 1) - 1), character: Math.max(1, item.col || 1) },
+					},
+					severity: 1,
+					source: "cluaupp",
+					message: item.message,
+				})),
+			},
+		});
+	};
+
+	const pathDirname = (file) => require("path").dirname(file);
+
+	const handle = (message) => {
+		const { method, params, id: reqId } = message;
+		if (method === "initialize") {
+			send({
+				jsonrpc: "2.0",
+				id: reqId,
+				result: {
+					capabilities: {
+						textDocumentSync: 1,
+						completionProvider: { triggerCharacters: [".", ":", ">", "<", '"', "/"] },
+						hoverProvider: true,
+						definitionProvider: true,
+					},
+					serverInfo: { name: "cluaupp", version: require("../package.json").version },
+				},
+			});
+			return;
+		}
+		if (method === "initialized" || method === "shutdown") {
+			if (reqId !== undefined) {
+				send({ jsonrpc: "2.0", id: reqId, result: null });
+			}
+			return;
+		}
+		if (method === "exit") {
+			process.exit(0);
+		}
+		if (method === "textDocument/didOpen") {
+			documents.set(params.textDocument.uri, params.textDocument.text);
+			publishDiagnostics(params.textDocument.uri);
+			return;
+		}
+		if (method === "textDocument/didChange") {
+			const last = params.contentChanges[params.contentChanges.length - 1];
+			if (last && last.text !== undefined && !last.range) {
+				documents.set(params.textDocument.uri, last.text);
+			}
+			publishDiagnostics(params.textDocument.uri);
+			return;
+		}
+		if (method === "textDocument/didClose") {
+			documents.delete(params.textDocument.uri);
+			return;
+		}
+		if (method === "textDocument/completion") {
+			const uri = params.textDocument.uri;
+			const text = docText(uri);
+			const offset = posToOffset(text, params.position);
+			const items = completeAt(text, offset, { projectRoot, file: uriPath(uri) });
+			send({
+				jsonrpc: "2.0",
+				id: reqId,
+				result: {
+					isIncomplete: false,
+					items: items.map((item) => ({
+						label: item.name,
+						kind: kindNumber(item.kind),
+						detail: item.detail,
+						sortText: `${item.kind === "keyword" ? "2" : "0"}_${item.name}`,
+						insertText: item.name,
+					})),
+				},
+			});
+			return;
+		}
+		if (method === "textDocument/hover") {
+			const uri = params.textDocument.uri;
+			const text = docText(uri);
+			const offset = posToOffset(text, params.position);
+			const hover = hoverAt(text, offset, { projectRoot, file: uriPath(uri) });
+			send({
+				jsonrpc: "2.0",
+				id: reqId,
+				result: hover
+					? { contents: { kind: "markdown", value: `**${hover.name}**\n\n\`${hover.detail || hover.type || ""}\`` } }
+					: null,
+			});
+			return;
+		}
+		if (method === "textDocument/definition") {
+			const uri = params.textDocument.uri;
+			const text = docText(uri);
+			const offset = posToOffset(text, params.position);
+			const def = definitionAt(text, offset, { projectRoot, file: uriPath(uri) });
+			if (!def) {
+				send({ jsonrpc: "2.0", id: reqId, result: null });
+				return;
+			}
+			send({
+				jsonrpc: "2.0",
+				id: reqId,
+				result: {
+					uri: "file:///" + String(def.file).replace(/\\/g, "/"),
+					range: {
+						start: { line: Math.max(0, (def.line || 1) - 1), character: 0 },
+						end: { line: Math.max(0, (def.line || 1) - 1), character: 0 },
+					},
+				},
+			});
+			return;
+		}
+		if (reqId !== undefined) {
+			send({ jsonrpc: "2.0", id: reqId, result: null });
+		}
+		id += 1;
+	};
+
+	process.stdin.on("data", (chunk) => {
+		buffer = Buffer.concat([buffer, chunk]);
+		let parsed = readMessage(buffer);
+		while (parsed) {
+			handle(parsed.message);
+			buffer = parsed.rest;
+			parsed = readMessage(buffer);
+		}
+	});
+}
+
+module.exports = { start };