cluaupp 0.2.1 → 0.2.3

package/package.json

@@ -1,87 +1,98 @@
-{
-	"name": "cluaupp",
-	"version": "0.2.1",
-	"description": "Cluaupp — the definitive merge of C++ and modern Luau. Source-to-source transpiler with first-class Roblox APIs.",
-	"author": "KartzDev",
-	"license": "MIT",
-	"bin": {
-		"cluaupp": "bin/cluaupp.js",
-		"cluau": "bin/cluaupp.js"
-	},
-	"main": "./generated/compile.js",
-	"exports": {
-		".": "./generated/compile.js",
-		"./package.json": "./package.json"
-	},
-	"files": [
-		"bin",
-		"src",
-		"generated",
-		"include",
-		"templates",
-		"examples",
-		"editors",
-		"runtime",
-		"README.md",
-		"LICENSE",
-		"CHANGELOG.md",
-		"docs"
-	],
-	"scripts": {
-		"cluaupp": "node bin/cluaupp.js",
-		"cluau": "node bin/cluaupp.js",
-		"build": "tsc",
-		"build:cli": "tsc",
-		"dev:cli": "tsx src/cli.ts",
-		"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",
-		"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",
-		"dev": "node scripts/dev.js",
-		"stop": "node scripts/stop.js",
-		"prepublishOnly": "tsc && npm test"
-	},
-	"engines": {
-		"node": ">=18"
-	},
-	"keywords": [
-		"luau",
-		"roblox",
-		"cpp",
-		"c++",
-		"transpiler",
-		"compiler",
-		"rojo",
-		"cluaupp",
-		"cluau"
-	],
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/KartzRbx/Cluaupp.git"
-	},
-	"bugs": {
-		"url": "https://github.com/KartzRbx/Cluaupp/issues"
-	},
-	"homepage": "https://github.com/KartzRbx/Cluaupp#readme",
-	"dependencies": {
-		"commander": "^15.0.0",
-		"comment-json": "^5.0.0",
-		"tree-sitter": "0.21.1",
-		"tree-sitter-c": "0.23.2",
-		"tree-sitter-cpp": "0.23.4",
-		"vscode-languageserver": "^10.1.1",
-		"vscode-languageserver-textdocument": "^1.0.14"
-	},
-	"overrides": {
-		"tree-sitter-c": "0.23.2"
-	},
-	"devDependencies": {
-		"@types/node": "^22.20.3",
-		"tsx": "^4.23.13",
-		"typescript": "^7.0.2"
-	}
-}
+{
+	"name": "cluaupp",
+	"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",
+	"bin": {
+		"cluaupp": "bin/cluaupp.js",
+		"cluau": "bin/cluaupp.js"
+	},
+	"main": "./generated/compile.js",
+	"exports": {
+		".": "./generated/compile.js",
+		"./package.json": "./package.json"
+	},
+	"files": [
+		"bin",
+		"src",
+		"generated",
+		"include",
+		"templates",
+		"examples",
+		"editors",
+		"runtime",
+		"README.md",
+		"LICENSE",
+		"CHANGELOG.md",
+		"docs"
+	],
+	"scripts": {
+		"cluaupp": "node bin/cluaupp.js",
+		"cluau": "node bin/cluaupp.js",
+		"build": "tsc",
+		"build:cli": "tsc",
+		"dev:cli": "tsx src/cli.ts",
+		"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": "tsx web/src/check-content.ts",
+		"vendor-libs": "node scripts/vendor-libs.js",
+		"docs": "moonwave dev",
+		"docs:build": "moonwave build",
+		"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"
+	},
+	"engines": {
+		"node": ">=18"
+	},
+	"keywords": [
+		"luau",
+		"roblox",
+		"cpp",
+		"c++",
+		"transpiler",
+		"compiler",
+		"rojo",
+		"cluaupp",
+		"cluau"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/KartzRbx/Cluaupp.git"
+	},
+	"bugs": {
+		"url": "https://github.com/KartzRbx/Cluaupp/issues"
+	},
+	"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",
+		"tree-sitter-c": "0.23.2",
+		"tree-sitter-cpp": "0.23.4",
+		"vscode-languageserver": "^10.1.1",
+		"vscode-languageserver-textdocument": "^1.0.14"
+	},
+	"overrides": {
+		"tree-sitter-c": "0.23.2"
+	},
+	"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",
+		"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/compile.ts

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import { parse } from "./parse.js";
 import { emit } from "./emit.js";
@@ -5,7 +6,7 @@ import { preprocess, isHeaderFile, toLuauPath, siblingImplementation, siblingHea
 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 { AstNode, AstProgram, ModuleInclude, PreprocessOptions } from "./ast.js";
 import type { CompileOptions, CompileServiceResult } from "./types.js";
 
 function shouldAttachRequires(name: string, contents: string): boolean {
@@ -32,12 +33,53 @@ function posixRel(from: string, file: string): string {
 	return path.relative(from, file).replace(/\\/g, "/");
 }
 
+function declKey(decl: AstNode): string {
+	return `${decl.owner || ""}::${decl.name}`;
+}
+
+function mergeSiblingImpl(ast: AstProgram, implPath: string, options: PreprocessOptions): void {
+	const implOptions: PreprocessOptions = {
+		...options,
+		moduleIncludes: [],
+		seen: new Set(),
+		pragmaResolved: false,
+	};
+	const prepared = preprocess(fs.readFileSync(implPath, "utf8"), implPath, implOptions);
+	const implAst = parse(prepared, path.basename(implPath)) as AstProgram;
+	if (!Array.isArray(ast.body)) {
+		ast.body = [];
+	}
+	const existing = new Set(
+		(ast.body || [])
+			.filter((decl) => decl && (decl.type === "function" || decl.type === "proto") && decl.name)
+			.map(declKey),
+	);
+	for (const decl of implAst.body || []) {
+		if ((decl.type !== "function" && decl.type !== "proto") || !decl.name) {
+			continue;
+		}
+		const key = declKey(decl);
+		if (existing.has(key)) {
+			continue;
+		}
+		existing.add(key);
+		ast.body.push({
+			type: "proto",
+			name: decl.name,
+			owner: decl.owner,
+			returnType: decl.returnType,
+			params: decl.params,
+		});
+	}
+}
+
 function wireHeaderImpl(ast: AstProgram, fileName: string, options: PreprocessOptions): void {
 	const headerPath = options.filePath || null;
 	const impl = headerPath ? siblingImplementation(headerPath) : null;
 	if (!impl) {
 		return;
 	}
+	mergeSiblingImpl(ast, impl, options);
 	const typeName = primaryHeaderName(ast, options.relativeName || fileName);
 	const implRel = options.srcDir ? posixRel(options.srcDir, impl) : path.basename(impl).replace(/\\/g, "/");
 	const implOut = implOutName(implRel);

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[] {