cluaupp 0.1.0

package/src/emit.js

@@ -0,0 +1,213 @@
+"use strict";
+
+const { isInstanceType, isMethod, isDatatype, luauType } = require("./api");
+const { isLibraryType, isLibraryMethod, MODULE_COLON } = require("./libs");
+
+function emit(ast, options = {}) {
+	const strict = options.strict !== false;
+	const lines = [];
+	if (!options.skipHeader) {
+		if (strict) {
+			lines.push("--!strict");
+		}
+		lines.push("-- Compiled by Cluaupp — C++ × Luau");
+		lines.push("");
+	}
+
+	const indentOf = (n) => "\t".repeat(n);
+
+	const emitExpr = (node) => {
+		if (!node) {
+			return "nil";
+		}
+		switch (node.type) {
+			case "null":
+				return "nil";
+			case "bool":
+				return node.value ? "true" : "false";
+			case "number":
+				return node.value;
+			case "string":
+				return `"${node.value}"`;
+			case "ident":
+				return node.name;
+			case "unary": {
+				const inner = emitExpr(node.argument);
+				if (node.op === "!") {
+					return `not ${inner}`;
+				}
+				return `-${inner}`;
+			}
+			case "getService":
+				return `game:GetService("${node.service}")`;
+			case "new": {
+				if (isLibraryType(node.className) || !isInstanceType(node.className)) {
+					const args = node.args.map(emitExpr).join(", ");
+					return `${node.className}.new(${args})`;
+				}
+				return `Instance.new("${node.className}")`;
+			}
+			case "member":
+				return `${emitExpr(node.object)}.${node.name}`;
+			case "call": {
+				const args = node.args.map(emitExpr).join(", ");
+				if (!node.object) {
+					if (isDatatype(node.name)) {
+						return `${node.name}.new(${args})`;
+					}
+					return `${node.name}(${args})`;
+				}
+				const obj = emitExpr(node.object);
+				if (node.access === "::") {
+					if (MODULE_COLON.has(node.name)) {
+						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})`;
+				}
+				const colon = isMethod(node.name) || isLibraryMethod(node.name);
+				return `${obj}${colon ? ":" : "."}${node.name}(${args})`;
+			}
+			case "assign":
+				return `${emitExpr(node.left)} = ${emitExpr(node.right)}`;
+			case "binary": {
+				const ops = { "!=": "~=", "&&": "and", "||": "or" };
+				const op = ops[node.op] || node.op;
+				return `${emitExpr(node.left)} ${op} ${emitExpr(node.right)}`;
+			}
+			default:
+				return "nil";
+		}
+	};
+
+	const inferredType = (node) => {
+		const created = node.value;
+		if (created && created.type === "new" && (isInstanceType(created.className) || isLibraryType(created.className) || isDatatype(created.className))) {
+			return created.className;
+		}
+		if (created && created.type === "call" && !created.object && isDatatype(created.name)) {
+			return created.name;
+		}
+		if (created && created.type === "getService") {
+			return created.service;
+		}
+		const fromCpp = luauType(node.valueType);
+		if (fromCpp && fromCpp !== "auto") {
+			return fromCpp;
+		}
+		return null;
+	};
+
+	const emitNewDecl = (node, indent) => {
+		const prefix = indentOf(indent);
+		const typeAnn = inferredType(node);
+		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]) {
+				linesOut.push(`${prefix}${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}${kind} ${node.name}${typed} = ${created.className}.new(${args})`];
+		}
+		const value = node.value ? emitExpr(node.value) : "nil";
+		return [`${prefix}${kind} ${node.name}${typed} = ${value}`];
+	};
+
+	const emitStmt = (node, indent) => {
+		const prefix = indentOf(indent);
+		switch (node.type) {
+			case "decl":
+				return emitNewDecl(node, indent);
+			case "expr":
+				return [`${prefix}${emitExpr(node.expr)}`];
+			case "return":
+				return node.value ? [`${prefix}return ${emitExpr(node.value)}`] : [`${prefix}return`];
+			case "if": {
+				const out = [`${prefix}if ${emitExpr(node.test)} then`];
+				for (const stmt of node.consequent) {
+					out.push(...emitStmt(stmt, indent + 1));
+				}
+				if (node.alternate) {
+					out.push(`${prefix}else`);
+					for (const stmt of node.alternate) {
+						out.push(...emitStmt(stmt, indent + 1));
+					}
+				}
+				out.push(`${prefix}end`);
+				return out;
+			}
+			case "while": {
+				const out = [`${prefix}while ${emitExpr(node.test)} do`];
+				for (const stmt of node.body) {
+					out.push(...emitStmt(stmt, indent + 1));
+				}
+				out.push(`${prefix}end`);
+				return out;
+			}
+			case "foreach": {
+				const out = [`${prefix}for _, ${node.name} in ${emitExpr(node.iter)} do`];
+				for (const stmt of node.body) {
+					out.push(...emitStmt(stmt, indent + 1));
+				}
+				out.push(`${prefix}end`);
+				return out;
+			}
+			default:
+				return [];
+		}
+	};
+
+	const paramList = (fn) =>
+		fn.params
+			.map((param) => {
+				if (typeof param === "string") {
+					return param;
+				}
+				const typeAnn = luauType(param.valueType);
+				return typeAnn ? `${param.name}: ${typeAnn}` : param.name;
+			})
+			.join(", ");
+
+	const returnAnn = (fn) => {
+		const typeAnn = luauType(fn.returnType);
+		if (!typeAnn || typeAnn === "()") {
+			return "";
+		}
+		return `: ${typeAnn}`;
+	};
+
+	for (const decl of ast.body) {
+		if (decl.type === "decl") {
+			lines.push(...emitNewDecl(decl, 0));
+			lines.push("");
+			continue;
+		}
+		if (decl.type !== "function") {
+			continue;
+		}
+		lines.push(`local function ${decl.name}(${paramList(decl)})${returnAnn(decl)}`);
+		for (const stmt of decl.body) {
+			lines.push(...emitStmt(stmt, 1));
+		}
+		lines.push("end");
+		lines.push("");
+	}
+
+	const hasInit = ast.body.some((decl) => decl.type === "function" && decl.name === "init");
+	if (hasInit && !options.skipInit) {
+		lines.push("init()");
+		lines.push("");
+	}
+
+	return lines.join("\n");
+}
+
+module.exports = { emit };

package/src/lex.js

@@ -0,0 +1,149 @@
+"use strict";
+
+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",
+]);
+
+function tokenize(source) {
+	const tokens = [];
+	let i = 0;
+	let line = 1;
+	let col = 1;
+
+	const push = (type, value, startLine, startCol) => {
+		tokens.push({ type, value, line: startLine, col: startCol });
+	};
+
+	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 === '"') {
+			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);
+			continue;
+		}
+
+		if (/[0-9]/.test(c)) {
+			let value = "";
+			while (i < source.length && /[0-9.]/.test(source[i])) {
+				value += source[i];
+				i += 1;
+				col += 1;
+			}
+			push("number", value, startLine, startCol);
+			continue;
+		}
+
+		if (/[A-Za-z_]/.test(c)) {
+			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);
+			continue;
+		}
+
+		const two = source.slice(i, i + 2);
+		if (["->", "==", "!=", "<=", ">=", "&&", "||", "::"].includes(two)) {
+			push("op", two, startLine, startCol);
+			i += 2;
+			col += 2;
+			continue;
+		}
+
+		push("op", c, startLine, startCol);
+		i += 1;
+		col += 1;
+	}
+
+	push("eof", "", line, col);
+	return tokens;
+}
+
+module.exports = { tokenize };

package/src/libs.js

@@ -0,0 +1,355 @@
+"use strict";
+
+const TYPE_EXPORTS = {
+	Janitor: "Janitor",
+	Promise: "Promise",
+	Net: "Net",
+	Icon: "Icon",
+	StateMachine: "StateMachine",
+	Spring: "Spring",
+	StickyBillboard: "StickyBillboard",
+	EzVisualz: "EzVisualz",
+	Module3D: "Module3D",
+	MathUtils: "MathUtils",
+	Twinkle: "Twinkle",
+	VfxUtil: "VfxUtil",
+	FormatNumber: "FormatNumber",
+	Fusion: "Fusion",
+	Iris: "Iris",
+	Cmdr: "Cmdr",
+	Chrono: "Chrono",
+	DataService: "DataService",
+	Display: "Display",
+};
+
+const EXTRA_TYPE_EXPORTS = {
+	DataService: {
+		Data: "Data",
+		DataPath: "Path",
+		DataServiceServer: "ServerApi",
+		DataServiceClient: "ClientApi",
+	},
+};
+
+const MODULES = {
+	Janitor: { file: "Janitor", bind: "Janitor" },
+	Promise: { file: "Promise", bind: "Promise" },
+	Net: { file: "Net", bind: "Net" },
+	NetEvent: { file: "Net", bind: "Net" },
+	NetFunction: { file: "Net", bind: "Net" },
+	MathUtils: { file: "MathUtils", bind: "MathUtils" },
+	FormatNumber: { file: "FormatNumber", bind: "FormatNumber" },
+	Module3D: { file: "Module3D", bind: "Module3D" },
+	Model3D: { file: "Module3D", bind: "Module3D" },
+	Twinkle: { file: "Twinkle", bind: "Twinkle" },
+	DataService: { file: "DataService", bind: "DataService" },
+	EzVisualz: { file: "EzVisualz", bind: "EzVisualz" },
+	EzVisual: { file: "EzVisualz", bind: "EzVisualz" },
+	Spring: { file: "Spring", bind: "Spring" },
+	Display: { file: "Display", bind: "Display" },
+	StickyBillboard: { file: "StickyBillboard", bind: "StickyBillboard" },
+	Icon: { file: "TopbarPlus", bind: "Icon" },
+	TopbarPlus: { file: "TopbarPlus", bind: "Icon" },
+	Cmdr: { file: "Cmdr", bind: "Cmdr" },
+	Chrono: { file: "Chrono", bind: "Chrono" },
+	Iris: { file: "Iris", bind: "Iris" },
+	Fusion: { file: "Fusion", bind: "Fusion" },
+	StateMachine: { file: "StateMachine", bind: "StateMachine" },
+	VfxUtil: { file: "VfxUtil", bind: "VfxUtil" },
+	ArrayIndexer: { file: "ArrayIndexer", bind: "ArrayIndexer" },
+	Occlude: { file: "Occlude", bind: "Occlude" },
+};
+
+const INCLUDE_TO_MODULE = {
+	janitor: "Janitor",
+	promise: "Promise",
+	net: "Net",
+	math: "MathUtils",
+	mathutils: "MathUtils",
+	formatnumber: "FormatNumber",
+	module3d: "Module3D",
+	dataservice: "DataService",
+	dataservicev2: "DataService",
+	ezvisual: "EzVisualz",
+	ezvisualz: "EzVisualz",
+	twinkle: "Twinkle",
+	spring: "Spring",
+	display: "Display",
+	stickybillboard: "StickyBillboard",
+	topbarplus: "Icon",
+	icon: "Icon",
+	cmdr: "Cmdr",
+	chrono: "Chrono",
+	iris: "Iris",
+	fusion: "Fusion",
+	statemachine: "StateMachine",
+	robloxstatemachine: "StateMachine",
+	vfx: "VfxUtil",
+	vfxutil: "VfxUtil",
+	arrayindexer: "ArrayIndexer",
+	occlude: "Occlude",
+	libs: null,
+};
+
+const LIBRARY_TYPES = new Set(Object.keys(MODULES));
+
+const LIBRARY_METHODS = new Set([
+	"Add",
+	"AddObject",
+	"AddPromise",
+	"Remove",
+	"RemoveNoClean",
+	"RemoveList",
+	"GetAll",
+	"Cleanup",
+	"Destroy",
+	"LinkToInstance",
+	"LinkToInstances",
+	"Has",
+	"Then",
+	"Catch",
+	"Finally",
+	"Await",
+	"Cancel",
+	"Fire",
+	"FireAll",
+	"On",
+	"OnClient",
+	"OnServer",
+	"Invoke",
+	"InvokeServer",
+	"InvokeClient",
+	"Attach3D",
+	"Update",
+	"SetCFrame",
+	"GetCFrame",
+	"SetDepthMultiplier",
+	"GetDepthMultiplier",
+	"GetPersisted",
+	"GetTransient",
+	"HasTransient",
+	"SetTransient",
+	"UpdateTransient",
+	"ClearTransient",
+	"ArrayInsert",
+	"ArrayInsertTransient",
+	"ArrayRemove",
+	"ArrayRemoveTransient",
+	"GetOrderedList",
+	"GetOrderedListWithPriority",
+	"GetChangedSignal",
+	"GetPathChangedSignal",
+	"GetIndexChangedSignal",
+	"GetArrayInsertedSignal",
+	"GetArrayRemovedSignal",
+	"Typed",
+	"WaitFor",
+	"WaitForData",
+	"HasData",
+	"GetProfile",
+	"GetBufferStats",
+	"Init",
+	"Observe",
+	"Impulse",
+	"SetGoal",
+	"Set",
+	"Get",
+	"Step",
+	"Fade",
+	"FrameSlide",
+	"FrameZoom",
+	"FrameBounce",
+	"ShowText",
+	"SetButtonStyle",
+	"FadeSlideRunoff",
+	"Abbreviate",
+	"Comma",
+	"Compact",
+	"Play",
+	"Pause",
+	"Resume",
+	"Stop",
+	"BindEvent",
+	"bindEvent",
+	"BindFunction",
+	"RegisterDefaultCommands",
+	"RegisterHook",
+	"RegisterType",
+	"RegisterCommand",
+	"ChangeState",
+	"GetState",
+	"GetCurrentState",
+	"GetPreviousState",
+	"GetData",
+	"ChangeData",
+	"LoadDirectory",
+	"setLabel",
+	"setImage",
+	"setEnabled",
+	"setName",
+	"setOrder",
+	"setWidth",
+	"align",
+	"setLeft",
+	"setMid",
+	"setRight",
+	"bindToggleItem",
+	"modifyTheme",
+	"setTheme",
+	"notify",
+	"clearNotices",
+	"select",
+	"deselect",
+	"autoDeselect",
+	"SetText",
+	"SetEnabled",
+	"SetMaxDistance",
+	"SetActive",
+	"GetActive",
+	"End",
+	"Scale",
+	"DestroyAfter",
+	"Burst",
+	"CloneOnto",
+	"Shutdown",
+	"Append",
+	"PushConfig",
+	"PopConfig",
+	"ForceRefresh",
+]);
+
+const MODULE_COLON = new Set(["Attach3D", "RegisterDefaultCommands", "RegisterHook", "Connect", "LoadDirectory"]);
+
+function isLibraryType(name) {
+	return LIBRARY_TYPES.has(name);
+}
+
+function isLibraryMethod(name) {
+	return LIBRARY_METHODS.has(name);
+}
+
+function walk(node, visit) {
+	if (!node || typeof node !== "object") {
+		return;
+	}
+	visit(node);
+	for (const value of Object.values(node)) {
+		if (Array.isArray(value)) {
+			for (const item of value) {
+				walk(item, visit);
+			}
+		} else if (value && typeof value === "object") {
+			walk(value, visit);
+		}
+	}
+}
+
+function modulesFromIncludes(source) {
+	const found = new Set();
+	for (const line of String(source).split(/\r?\n/)) {
+		const match = line.match(/^\s*#\s*include\s+<cluaupp\/(?:libs\/)?([A-Za-z0-9]+)\.hpp>/);
+		if (!match) {
+			continue;
+		}
+		const key = match[1].toLowerCase();
+		const mapped = INCLUDE_TO_MODULE[key];
+		if (mapped) {
+			found.add(mapped);
+		}
+		if (key === "libs") {
+			found.add("Janitor");
+			found.add("Promise");
+			found.add("Net");
+			found.add("MathUtils");
+			found.add("FormatNumber");
+			found.add("Module3D");
+			found.add("Twinkle");
+			found.add("DataService");
+		}
+	}
+	return found;
+}
+
+function collectLibraries(source, ast) {
+	const used = modulesFromIncludes(source);
+	walk(ast, (node) => {
+		if (node.type === "ident" && MODULES[node.name]) {
+			used.add(node.name === "NetEvent" || node.name === "NetFunction" ? "Net" : node.name);
+		}
+		if (node.type === "new" && MODULES[node.className]) {
+			used.add(node.className === "NetEvent" || node.className === "NetFunction" ? "Net" : node.className);
+		}
+		if (node.type === "call" && node.object && node.object.type === "ident" && MODULES[node.object.name]) {
+			const name = node.object.name;
+			used.add(name === "NetEvent" || name === "NetFunction" ? "Net" : name);
+		}
+	});
+	const unique = [];
+	const seenBind = new Set();
+	for (const name of used) {
+		const spec = MODULES[name];
+		if (!spec || seenBind.has(spec.bind)) {
+			continue;
+		}
+		seenBind.add(spec.bind);
+		unique.push(spec);
+	}
+	return unique;
+}
+
+function requireCluauppLib(name) {
+	return `require(ReplicatedStorage.CluauppLibs.${name})`;
+}
+
+function emitRequires(libraries) {
+	if (!libraries.length) {
+		return "";
+	}
+	const lines = ['local ReplicatedStorage = game:GetService("ReplicatedStorage")'];
+	for (const spec of libraries) {
+		lines.push(`local ${spec.bind} = ${requireCluauppLib(spec.file)}`);
+		const exported = TYPE_EXPORTS[spec.bind];
+		if (exported) {
+			lines.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}`);
+			}
+		}
+	}
+	return `${lines.join("\n")}\n`;
+}
+
+function insertRequires(luau, libraries) {
+	const block = emitRequires(libraries);
+	if (!block) {
+		return luau;
+	}
+	const marker = "-- Compiled by Cluaupp — C++ × Luau";
+	const index = luau.indexOf(marker);
+	if (index === -1) {
+		return `${block}\n${luau}`;
+	}
+	const insertAt = luau.indexOf("\n", index);
+	if (insertAt === -1) {
+		return `${luau}\n${block}`;
+	}
+	return `${luau.slice(0, insertAt + 1)}\n${block}${luau.slice(insertAt + 1)}`;
+}
+
+module.exports = {
+	MODULES,
+	TYPE_EXPORTS,
+	EXTRA_TYPE_EXPORTS,
+	LIBRARY_TYPES,
+	LIBRARY_METHODS,
+	MODULE_COLON,
+	isLibraryType,
+	isLibraryMethod,
+	collectLibraries,
+	requireCluauppLib,
+	emitRequires,
+	insertRequires,
+};