cluaupp 0.2.2 → 0.2.3

package/generated/parse.js

@@ -46,21 +46,124 @@ function parse(source, fileName) {
         eat("op", ">");
         return name;
     };
+    const CAST_NAMES = new Set(["static_cast", "const_cast", "reinterpret_cast", "dynamic_cast"]);
+    function skipSpecifiers() {
+        let isConst = false;
+        while (at("kw", "static") || at("kw", "inline") || at("kw", "constexpr") || at("kw", "const")) {
+            if (at("kw", "constexpr") || at("kw", "const")) {
+                isConst = true;
+            }
+            i += 1;
+        }
+        return isConst;
+    }
+    function looksLikePrimaryStart() {
+        if (at("ident") || at("number") || at("string")) {
+            return true;
+        }
+        if (at("kw", "true") || at("kw", "false") || at("kw", "nullptr") || at("kw", "new")) {
+            return true;
+        }
+        return at("op", "(") || at("op", "{") || at("op", "[") || at("op", "-") || at("op", "!");
+    }
+    function parseLambda() {
+        eat("op", "[");
+        while (!at("eof") && !at("op", "]")) {
+            i += 1;
+        }
+        eat("op", "]");
+        const params = [];
+        if (at("op", "(")) {
+            i += 1;
+            if (!at("op", ")")) {
+                params.push(parseParam());
+                while (at("op", ",")) {
+                    i += 1;
+                    params.push(parseParam());
+                }
+            }
+            eat("op", ")");
+        }
+        const body = parseBlock();
+        return { type: "lambda", params, body };
+    }
+    function parseNamedCast() {
+        i += 1;
+        eat("op", "<");
+        const valueType = parseType() || "any";
+        eat("op", ">");
+        const args = parseArgs();
+        return { type: "cast", valueType, argument: args[0] || { type: "null" } };
+    }
+    function parseParenPrimary() {
+        eat("op", "(");
+        const saved = i;
+        skipSpecifiers();
+        const valueType = parseType();
+        if (valueType && at("op", ")")) {
+            i += 1;
+            if (looksLikePrimaryStart()) {
+                return { type: "cast", valueType, argument: parseUnary() };
+            }
+        }
+        i = saved;
+        const expr = parseExpr();
+        eat("op", ")");
+        return expr;
+    }
+    function eatGeneric() {
+        let text = "";
+        let depth = 0;
+        while (!at("eof")) {
+            const token = peek();
+            if (at("op", "<")) {
+                depth += 1;
+                text += "<";
+                i += 1;
+                continue;
+            }
+            if (at("op", ">")) {
+                depth -= 1;
+                text += ">";
+                i += 1;
+                if (depth === 0) {
+                    return text;
+                }
+                continue;
+            }
+            if (token.type === "string") {
+                text += `"${token.value}"`;
+            }
+            else {
+                text += token.value;
+            }
+            i += 1;
+        }
+        return text;
+    }
     function parseType() {
         if (at("kw", "const")) {
             i += 1;
         }
+        let name = null;
         if (at("kw", "auto") || at("kw", "void") || at("kw", "int") || at("kw", "bool") || at("kw", "float") || at("kw", "double")) {
-            const name = eat("kw").value;
-            while (at("op", "*")) {
+            name = eat("kw").value;
+        }
+        else if (at("ident")) {
+            name = eat("ident").value;
+            while (at("op", "::")) {
                 i += 1;
+                if (at("ident")) {
+                    name += `::${eat("ident").value}`;
+                }
             }
-            return name;
         }
-        if (!at("ident")) {
+        else {
             return null;
         }
-        const name = eat("ident").value;
+        if (at("op", "<")) {
+            name += eatGeneric();
+        }
         while (at("op", "*")) {
             i += 1;
         }
@@ -129,14 +232,17 @@ function parse(source, fileName) {
             eat("op", ")");
             return { type: "getService", service };
         }
+        if (at("ident") && CAST_NAMES.has(peek().value) && peek(1).value === "<") {
+            return parseNamedCast();
+        }
         if (at("ident")) {
             return { type: "ident", name: eat("ident").value };
         }
+        if (at("op", "[")) {
+            return parseLambda();
+        }
         if (at("op", "(")) {
-            i += 1;
-            const expr = parseExpr();
-            eat("op", ")");
-            return expr;
+            return parseParenPrimary();
         }
         if (at("op", "{")) {
             return parseInitList();
@@ -309,11 +415,8 @@ function parse(source, fileName) {
         throw error("only range-for is supported: for (auto* x : list)");
     }
     function parseDeclOrExpr() {
-        const isConst = at("kw", "const");
-        if (isConst) {
-            i += 1;
-        }
         const saved = i;
+        const isConst = skipSpecifiers();
         const maybeType = parseType();
         if (maybeType && at("ident") && (peek(1).value === "=" || peek(1).value === ";")) {
             const name = eat("ident").value;
@@ -325,9 +428,6 @@ function parse(source, fileName) {
             return { type: "decl", name, valueType: maybeType, value, isConst: isConst || maybeType === "const" };
         }
         i = saved;
-        if (isConst) {
-            i = saved - 1;
-        }
         return { type: "expr", expr: parseExpr() };
     }
     function parseStmt() {
@@ -380,6 +480,7 @@ function parse(source, fileName) {
         };
     }
     function parseFunction() {
+        skipSpecifiers();
         const returnType = parseType();
         if (!returnType || !at("ident")) {
             throw error("invalid function declaration");
@@ -449,10 +550,7 @@ function parse(source, fileName) {
                 continue;
             }
             const saved = i;
-            const isConst = at("kw", "const");
-            if (isConst) {
-                i += 1;
-            }
+            const isConst = skipSpecifiers();
             const valueType = parseType();
             if (valueType && at("ident")) {
                 if (peek(1).value === "(") {
@@ -573,10 +671,7 @@ function parse(source, fileName) {
                 continue;
             }
             const saved = i;
-            const isConst = at("kw", "const");
-            if (isConst) {
-                i += 1;
-            }
+            const isConst = skipSpecifiers();
             const maybeType = parseType();
             if (maybeType && at("ident")) {
                 const next = peek(1);

package/include/cluaupp/datatypes.hpp

@@ -17,6 +17,10 @@ using Enum::Axis;
 
 using string = const char*;
 
+// Variadic join. Cluaupp emits Luau a .. b .. c.
+template <typename... Args>
+string string_concat(Args... args);
+
 struct Instance;
 struct Player;
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cluaupp",
-	"version": "0.2.2",
+	"version": "0.2.3",
 	"description": "Cluaupp — the definitive merge of C++ and modern Luau. Source-to-source transpiler with first-class Roblox APIs.",
 	"author": "KartzDev",
 	"license": "MIT",
@@ -36,11 +36,12 @@
 		"prepare": "tsc",
 		"test": "node test/out.test.js && node test/types.test.js && node test/modules.test.js && node test/security.test.js && node test/understander.test.js",
 		"generate-api": "node scripts/generate-api.js",
-		"check-highlight": "node scripts/check-highlight.js",
+		"check-highlight": "tsx web/src/check-content.ts",
 		"vendor-libs": "node scripts/vendor-libs.js",
 		"docs": "moonwave dev",
 		"docs:build": "moonwave build",
-		"site": "node scripts/generate-api.js && node scripts/check-highlight.js",
+		"site": "vite build --config web/vite.config.mts && npm run check-highlight",
+		"site:dev": "vite --config web/vite.config.mts",
 		"dev": "node scripts/dev.js",
 		"stop": "node scripts/stop.js",
 		"prepublishOnly": "tsc && npm test"
@@ -68,6 +69,7 @@
 	},
 	"homepage": "https://github.com/KartzRbx/Cluaupp#readme",
 	"dependencies": {
+		"cluaupp": "^0.2.2",
 		"commander": "^15.0.0",
 		"comment-json": "^5.0.0",
 		"tree-sitter": "0.21.1",
@@ -81,7 +83,16 @@
 	},
 	"devDependencies": {
 		"@types/node": "^22.20.3",
+		"@types/react": "^19.3.0",
+		"@types/react-dom": "^19.3.0",
+		"@vitejs/plugin-react": "^6.0.1",
+		"@vitejs/plugin-vue": "^6.0.1",
+		"react": "^19.1.1",
+		"react-dom": "^19.1.1",
+		"react-router-dom": "^7.8.2",
 		"tsx": "^4.23.13",
-		"typescript": "^7.0.2"
+		"typescript": "^7.0.2",
+		"vite": "^8.0.0",
+		"vue": "^3.5.21"
 	}
 }

package/src/api.ts

@@ -45,9 +45,23 @@ export function luauType(name: string | null | undefined): string | null {
 	if (!name) {
 		return null;
 	}
-	const cleaned = String(name).replace(/\*+$/, "").replace(/^const\s+/, "").replace(/^Enum::/, "Enum.");
+	const cleaned = String(name)
+		.replace(/\*+$/, "")
+		.replace(/^const\s+/, "")
+		.replace(/^Enum::/, "Enum.")
+		.replace(/\s+/g, " ")
+		.trim();
 	if (cleaned in LUAU_TYPES) {
 		return LUAU_TYPES[cleaned];
 	}
+	const generic = cleaned.match(/^(?:std::)?(?:vector|array|span|LuaArray)\s*<\s*([^>]+)\s*>$/);
+	if (generic) {
+		const inner = luauType(generic[1]) || generic[1];
+		return `{${inner}}`;
+	}
+	const optional = cleaned.match(/^(?:std::)?optional\s*<\s*([^>]+)\s*>$/);
+	if (optional) {
+		return `${luauType(optional[1]) || optional[1]}?`;
+	}
 	return cleaned;
 }

package/src/emit.ts

@@ -31,6 +31,7 @@ function emit(ast, options = {}) {
 		}
 	}
 	const ownedFns = (ast.body || []).filter((decl) => decl.type === "function");
+	const hasOwnedMethods = ownedFns.some((decl) => Boolean(decl.owner));
 	const classModule = ownedFns.length > 0 && ownedFns.every((decl) => Boolean(decl.owner));
 	const nestedTypes = new Set();
 	for (const decl of ast.body || []) {
@@ -142,6 +143,38 @@ function emit(ast, options = {}) {
 		return linesOut;
 	};
 
+	const isStringConcatCall = (node) => node && node.type === "call" && !node.object && node.name === "string_concat";
+
+	const emitStringConcat = (args) => {
+		const parts = (args || []).map(emitExpr);
+		if (parts.length === 0) {
+			return `""`;
+		}
+		if (parts.length === 1) {
+			return parts[0];
+		}
+		return `(${parts.join(" .. ")})`;
+	};
+
+	const isStringExpr = (node) => {
+		if (!node) {
+			return false;
+		}
+		if (node.type === "string") {
+			return true;
+		}
+		if (isStringConcatCall(node)) {
+			return true;
+		}
+		if (node.type === "binary" && node.op === "+" && (isStringExpr(node.left) || isStringExpr(node.right))) {
+			return true;
+		}
+		if (node.type === "member" && (node.name === "Name" || node.name === "Text" || node.name === "DisplayName")) {
+			return true;
+		}
+		return false;
+	};
+
 	const emitExpr = (node) => {
 		if (!node) {
 			return "nil";
@@ -164,6 +197,28 @@ function emit(ast, options = {}) {
 				}
 				return `{ ${entries.join(", ")} }`;
 			}
+			case "cast":
+				if (node.valueType === "void") {
+					return emitExpr(node.argument);
+				}
+				return emitExpr(node.argument);
+			case "lambda": {
+				const params = (node.params || [])
+					.map((param) => {
+						if (typeof param === "string") {
+							return param;
+						}
+						const typeAnn = luauType(param.valueType);
+						return typeAnn ? `${param.name}: ${typeAnn}` : param.name;
+					})
+					.join(", ");
+				const inner = [];
+				for (const stmt of node.body || []) {
+					inner.push(...emitStmt(stmt, 1));
+				}
+				const body = inner.length > 0 ? `\n${inner.join("\n")}\n` : "\n";
+				return `function(${params})${body}end`;
+			}
 			case "unary": {
 				const inner = emitExpr(node.argument);
 				if (node.op === "!") {
@@ -183,6 +238,9 @@ function emit(ast, options = {}) {
 			case "member":
 				return `${emitExpr(node.object)}.${node.name}`;
 			case "call": {
+				if (isStringConcatCall(node)) {
+					return emitStringConcat(node.args);
+				}
 				const args = node.args.map(emitMethodArg).join(", ");
 				if (!node.object) {
 					if (isDatatype(node.name)) {
@@ -194,6 +252,9 @@ function emit(ast, options = {}) {
 					return `${node.name}(${args})`;
 				}
 				const obj = emitExpr(node.object);
+				if (classMethods.has(node.name) && !localNames.has(node.name)) {
+					return `${obj}:${node.name}(${args})`;
+				}
 				if (node.access === "::" && node.object.type === "ident" && node.object.name === "cout") {
 					if (node.name === "endl") {
 						return "print()";
@@ -232,6 +293,9 @@ function emit(ast, options = {}) {
 						return printed.join("; ");
 					}
 				}
+				if (node.op === "+" && (isStringExpr(node.left) || isStringExpr(node.right))) {
+					return `${emitExpr(node.left)} .. ${emitExpr(node.right)}`;
+				}
 				const ops = { "!=": "~=", "&&": "and", "||": "or" };
 				const op = ops[node.op] || node.op;
 				return `${emitExpr(node.left)} ${op} ${emitExpr(node.right)}`;
@@ -292,6 +356,9 @@ function emit(ast, options = {}) {
 			return [`${prefix}${kind} ${node.name}${typed} = ${created.className}.new(${args})`];
 		}
 		const value = node.value ? emitExpr(node.value) : "nil";
+		if (!node.value && node.valueType && classOwners.has(node.valueType)) {
+			return [`${prefix}${kind} ${node.name}${typed} = ${node.valueType}`];
+		}
 		return [`${prefix}${kind} ${node.name}${typed} = ${value}`];
 	};
 
@@ -305,6 +372,9 @@ function emit(ast, options = {}) {
 				return emitNewDecl(node, indent);
 			case "expr": {
 				const expr = node.expr;
+				if (expr && expr.type === "cast" && expr.valueType === "void") {
+					return [];
+				}
 				if (expr && expr.type === "binary" && expr.op === "<<") {
 					const printed = emitCout(expr);
 					if (printed) {
@@ -456,11 +526,9 @@ function emit(ast, options = {}) {
 		lines.push("	}");
 		lines.push("end");
 		lines.push("");
-		lines.push(`return ${root}`);
-		lines.push("");
 	};
 
-	if (classModule) {
+	if (hasOwnedMethods) {
 		for (const owner of classOwners) {
 			lines.push(`local ${owner} = {}`);
 			lines.push("");
@@ -471,6 +539,16 @@ function emit(ast, options = {}) {
 		for (const root of structRoots) {
 			emitStructConstructor(root);
 		}
+		if (structRoots.length === 1) {
+			lines.push(`return ${structRoots[0]}`);
+		} else {
+			lines.push("return {");
+			for (const root of structRoots) {
+				lines.push(`	${root} = ${root},`);
+			}
+			lines.push("}");
+		}
+		lines.push("");
 		return lines.join("\n");
 	}
 

package/src/intellisense.ts

@@ -66,32 +66,6 @@ function compileCommandEntry(root: string, file: string) {
 	};
 }
 
-function mergeJson(file: string, patch: Record<string, unknown>): boolean {
-	let current: Record<string, unknown> = {};
-	if (fs.existsSync(file)) {
-		try {
-			current = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
-		} catch {
-			current = {};
-		}
-	}
-	const next: Record<string, unknown> = { ...current, ...patch };
-	for (const key of Object.keys(patch)) {
-		const value = patch[key];
-		const existing = current[key];
-		if (value && typeof value === "object" && !Array.isArray(value) && existing && typeof existing === "object" && !Array.isArray(existing)) {
-			next[key] = { ...(existing as Record<string, unknown>), ...(value as Record<string, unknown>) };
-		}
-	}
-	const json = `${JSON.stringify(next, null, "\t")}\n`;
-	if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === json) {
-		return false;
-	}
-	fs.mkdirSync(path.dirname(file), { recursive: true });
-	fs.writeFileSync(file, json, "utf8");
-	return true;
-}
-
 function copyDir(from: string, to: string): void {
 	fs.mkdirSync(to, { recursive: true });
 	for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
@@ -105,6 +79,58 @@ function copyDir(from: string, to: string): void {
 	}
 }
 
+function uniqueStrings(...lists: unknown[]): string[] {
+	const seen = new Set<string>();
+	const out: string[] = [];
+	for (const list of lists) {
+		if (!Array.isArray(list)) {
+			continue;
+		}
+		for (const item of list) {
+			if (typeof item === "string" && item && !seen.has(item)) {
+				seen.add(item);
+				out.push(item);
+			}
+		}
+	}
+	return out;
+}
+
+function stripCppToolsSettings(current: Record<string, unknown>): Record<string, unknown> {
+	const next: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(current)) {
+		if (key === "C_Cpp" || key.startsWith("C_Cpp.")) {
+			continue;
+		}
+		next[key] = value;
+	}
+	return next;
+}
+
+function readJsonObject(file: string): Record<string, unknown> {
+	if (!fs.existsSync(file)) {
+		return {};
+	}
+	try {
+		const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+			return parsed as Record<string, unknown>;
+		}
+	} catch {
+		// ignore corrupt editor json
+	}
+	return {};
+}
+
+function writeJson(file: string, value: Record<string, unknown>): void {
+	const json = `${JSON.stringify(value, null, "\t")}\n`;
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === json) {
+		return;
+	}
+	fs.writeFileSync(file, json, "utf8");
+}
+
 function clangdEditorArgs(): string[] {
 	return [
 		"--compile-commands-dir=${workspaceFolder}",
@@ -113,17 +139,6 @@ function clangdEditorArgs(): string[] {
 	];
 }
 
-export function intelliSenseMode(): string {
-	const arch = process.arch === "arm64" ? "arm64" : "x64";
-	if (process.platform === "win32") {
-		return `windows-clang-${arch}`;
-	}
-	if (process.platform === "darwin") {
-		return `macos-clang-${arch}`;
-	}
-	return `linux-clang-${arch}`;
-}
-
 export function clangPath(): string {
 	return findClangPlusPlus() || "clang++";
 }
@@ -173,54 +188,39 @@ Index:
 }
 
 function writeVscode(root: string): void {
-	const settings = path.join(root, ".vscode", "settings.json");
-	mergeJson(settings, {
-		"C_Cpp.intelliSenseEngine": "Disabled",
-		"C_Cpp.default.cppStandard": "c++20",
-		"C_Cpp.default.cStandard": "c17",
-		"C_Cpp.default.compilerPath": clangPath(),
-		"C_Cpp.default.intelliSenseMode": intelliSenseMode(),
-		"C_Cpp.default.includePath": ["${workspaceFolder}/include", "${workspaceFolder}/src"],
+	const settingsPath = path.join(root, ".vscode", "settings.json");
+	const current = readJsonObject(settingsPath);
+	const associations = {
+		...((current["files.associations"] && typeof current["files.associations"] === "object" && !Array.isArray(current["files.associations"]))
+			? (current["files.associations"] as Record<string, unknown>)
+			: {}),
+		"*.hpp": "cpp",
+		"*.h": "cpp",
+		"*.server.cpp": "cpp",
+		"*.client.cpp": "cpp",
+		"*.plugin.cpp": "cpp",
+		"*.legacy.cpp": "cpp",
+		"*.legacy.server.cpp": "cpp",
+		"*.legacy.client.cpp": "cpp",
+	};
+	writeJson(settingsPath, {
+		...stripCppToolsSettings(current),
 		"clangd.enable": true,
 		"clangd.arguments": clangdEditorArgs(),
-		"files.associations": {
-			"*.hpp": "cpp",
-			"*.h": "cpp",
-			"*.server.cpp": "cpp",
-			"*.client.cpp": "cpp",
-			"*.plugin.cpp": "cpp",
-			"*.legacy.cpp": "cpp",
-			"*.legacy.server.cpp": "cpp",
-			"*.legacy.client.cpp": "cpp",
-		},
+		"files.associations": associations,
 	});
-	mergeJson(path.join(root, ".vscode", "extensions.json"), {
-		recommendations: ["llvm-vs-code-extensions.vscode-clangd"],
+
+	const extensionsPath = path.join(root, ".vscode", "extensions.json");
+	const extensions = readJsonObject(extensionsPath);
+	writeJson(extensionsPath, {
+		...extensions,
+		recommendations: uniqueStrings(extensions.recommendations, ["llvm-vs-code-extensions.vscode-clangd"]),
+		unwantedRecommendations: uniqueStrings(extensions.unwantedRecommendations, ["ms-vscode.cpptools"]),
 	});
+
 	const props = path.join(root, ".vscode", "c_cpp_properties.json");
-	const nextProps = {
-		configurations: [
-			{
-				name: "Cluaupp",
-				compilerPath: clangPath(),
-				cStandard: "c17",
-				cppStandard: "c++20",
-				intelliSenseMode: intelliSenseMode(),
-				includePath: ["${workspaceFolder}/include", "${workspaceFolder}/src"],
-				forcedInclude: ["${workspaceFolder}/include/cluaupp/roblox.hpp"],
-				compileCommands: "${workspaceFolder}/compile_commands.json",
-				browse: {
-					path: ["${workspaceFolder}/include", "${workspaceFolder}/src"],
-					limitSymbolsToIncludedHeaders: true,
-				},
-			},
-		],
-		version: 4,
-	};
-	const json = `${JSON.stringify(nextProps, null, "\t")}\n`;
-	fs.mkdirSync(path.dirname(props), { recursive: true });
-	if (!fs.existsSync(props) || fs.readFileSync(props, "utf8") !== json) {
-		fs.writeFileSync(props, json, "utf8");
+	if (fs.existsSync(props)) {
+		fs.unlinkSync(props);
 	}
 }
 

package/src/lex.ts

@@ -32,6 +32,9 @@ const KEYWORDS = new Set([
 	"case",
 	"default",
 	"break",
+	"static",
+	"constexpr",
+	"inline",
 ]);
 
 export function tokenize(source: string): Token[] {