cluaupp 0.1.2 → 0.1.5

package/src/parse.js

@@ -199,8 +199,18 @@ function parse(source, fileName) {
 		return left;
 	}
 
+	function parseShift() {
+		let left = parseBinary();
+		while (at("op", "<<")) {
+			eat("op", "<<");
+			const right = parseBinary();
+			left = { type: "binary", op: "<<", left, right };
+		}
+		return left;
+	}
+
 	function parseExpr() {
-		const left = parseBinary();
+		const left = parseShift();
 		if (at("op", "=")) {
 			i += 1;
 			return { type: "assign", left, right: parseExpr() };
@@ -223,6 +233,58 @@ function parse(source, fileName) {
 		return body;
 	}
 
+	function parseSwitch() {
+		eat("kw", "switch");
+		eat("op", "(");
+		const discriminant = parseExpr();
+		eat("op", ")");
+		eat("op", "{");
+		const cases = [];
+		let current = null;
+		const flush = () => {
+			if (current) {
+				cases.push(current);
+				current = null;
+			}
+		};
+		while (!at("eof") && !at("op", "}")) {
+			skipSemicolons();
+			if (at("op", "}")) {
+				break;
+			}
+			if (at("kw", "case")) {
+				i += 1;
+				const value = parseExpr();
+				eat("op", ":");
+				if (current && current.body.length === 0 && !current.isDefault) {
+					current.values.push(value);
+				} else {
+					flush();
+					current = { values: [value], body: [], isDefault: false };
+				}
+				continue;
+			}
+			if (at("kw", "default")) {
+				i += 1;
+				eat("op", ":");
+				flush();
+				current = { values: [], body: [], isDefault: true };
+				continue;
+			}
+			if (!current) {
+				throw error("switch body needs case or default before statements");
+			}
+			if (at("op", "{")) {
+				current.body.push(...parseBlock());
+				continue;
+			}
+			current.body.push(parseStmt());
+		}
+		flush();
+		eat("op", "}");
+		return { type: "switch", discriminant, cases };
+	}
+
 	function parseIf() {
 		eat("kw", "if");
 		eat("op", "(");
@@ -285,6 +347,9 @@ function parse(source, fileName) {
 		if (at("kw", "if")) {
 			return parseIf();
 		}
+		if (at("kw", "switch")) {
+			return parseSwitch();
+		}
 		if (at("kw", "for")) {
 			return parseFor();
 		}
@@ -293,6 +358,11 @@ function parse(source, fileName) {
 			const value = at("op", ";") || at("op", "}") ? null : parseExpr();
 			return { type: "return", value };
 		}
+		if (at("kw", "break")) {
+			i += 1;
+			skipSemicolons();
+			return { type: "break" };
+		}
 		if (at("kw", "while")) {
 			i += 1;
 			eat("op", "(");
@@ -312,12 +382,25 @@ function parse(source, fileName) {
 		return { name: "arg", valueType };
 	}
 
+	function parseQualifiedName() {
+		const parts = [eat("ident").value];
+		while (at("op", "::")) {
+			i += 1;
+			parts.push(eat("ident").value);
+		}
+		return {
+			parts,
+			name: parts[parts.length - 1],
+			owner: parts.length > 1 ? parts.slice(0, -1).join("::") : null,
+		};
+	}
+
 	function parseFunction() {
 		const returnType = parseType();
 		if (!returnType || !at("ident")) {
 			throw error("invalid function declaration");
 		}
-		const name = eat("ident").value;
+		const qualified = parseQualifiedName();
 		eat("op", "(");
 		const params = [];
 		if (!at("op", ")")) {
@@ -330,10 +413,96 @@ function parse(source, fileName) {
 		eat("op", ")");
 		if (at("op", ";")) {
 			i += 1;
-			return { type: "proto", name, returnType, params };
+			return { type: "proto", name: qualified.name, owner: qualified.owner, returnType, params };
 		}
 		const body = parseBlock();
-		return { type: "function", name, returnType, params, body };
+		return { type: "function", name: qualified.name, owner: qualified.owner, returnType, params, body };
+	}
+
+	function parseStruct() {
+		eat("kw");
+		const name = at("ident") ? eat("ident").value : "_anon";
+		if (at("op", ";")) {
+			i += 1;
+			return { type: "struct", name, fields: [], methods: [] };
+		}
+		eat("op", "{");
+		const fields = [];
+		const methods = [];
+		while (!at("eof") && !at("op", "}")) {
+			skipSemicolons();
+			if (at("op", "}")) {
+				break;
+			}
+			if (at("kw", "public") || at("kw", "private") || at("kw", "protected")) {
+				i += 1;
+				if (at("op", ":")) {
+					i += 1;
+				}
+				continue;
+			}
+			if (at("kw", "struct") || at("kw", "class")) {
+				const nested = parseStruct();
+				if (nested.instance) {
+					fields.push({
+						type: "decl",
+						name: nested.instance.name,
+						valueType: nested.name,
+						value:
+							nested.instance.value || {
+								type: "initlist",
+								fields: nested.fields.map((field) => ({
+									name: field.name,
+									value: field.value || { type: "null" },
+								})),
+							},
+						isConst: false,
+						owner: name,
+					});
+				} else {
+					fields.push(...nested.fields);
+					methods.push(...nested.methods);
+				}
+				continue;
+			}
+			const saved = i;
+			const isConst = at("kw", "const");
+			if (isConst) {
+				i += 1;
+			}
+			const valueType = parseType();
+			if (valueType && at("ident")) {
+				if (peek(1).value === "(") {
+					i = saved;
+					const method = parseFunction();
+					method.owner = method.owner || name;
+					methods.push(method);
+					continue;
+				}
+				const fieldName = eat("ident").value;
+				let value = null;
+				if (at("op", "=")) {
+					i += 1;
+					value = parseExpr();
+				}
+				skipSemicolons();
+				fields.push({ type: "decl", name: fieldName, valueType, value, isConst, owner: name });
+				continue;
+			}
+			i = saved;
+			skipBalanced();
+		}
+		eat("op", "}");
+		let instance = null;
+		if (at("ident")) {
+			instance = { name: eat("ident").value, value: null };
+			if (at("op", "=")) {
+				i += 1;
+				instance.value = parseExpr();
+			}
+		}
+		skipSemicolons();
+		return { type: "struct", name, fields, methods, instance };
 	}
 
 	function parseTopLevelDecl(isConst, valueType) {
@@ -414,7 +583,13 @@ function parse(source, fileName) {
 				skipSemicolons();
 				continue;
 			}
-			if (at("kw", "struct") || at("kw", "class") || at("kw", "enum") || at("kw", "template") || at("kw", "typedef") || at("kw", "extern")) {
+			if (at("kw", "struct") || at("kw", "class")) {
+				const parsed = parseStruct();
+				decls.push(...parsed.fields);
+				decls.push(...parsed.methods);
+				continue;
+			}
+			if (at("kw", "enum") || at("kw", "template") || at("kw", "typedef") || at("kw", "extern")) {
 				skipTypeDecl();
 				continue;
 			}
@@ -426,7 +601,7 @@ function parse(source, fileName) {
 			const maybeType = parseType();
 			if (maybeType && at("ident")) {
 				const next = peek(1);
-				if (next.value === "(") {
+				if (next.value === "(" || next.value === "::") {
 					i = saved;
 					decls.push(parseFunction());
 					skipSemicolons();
@@ -438,6 +613,12 @@ function parse(source, fileName) {
 				}
 			}
 			i = saved;
+			if (at("ident") && (peek(1).value === "::" || peek(1).value === "(" || peek(1).value === "." || peek(1).value === "->")) {
+				const expr = parseExpr();
+				skipSemicolons();
+				decls.push({ type: "expr", expr });
+				continue;
+			}
 			decls.push(parseFunction());
 			skipSemicolons();
 		}

package/src/preprocess.js

@@ -27,18 +27,120 @@ function isEngineStub(filePath) {
 	);
 }
 
+function includeVariants(name) {
+	const variants = [name];
+	if (/\.h$/i.test(name)) {
+		variants.push(name.replace(/\.h$/i, ".hpp"), name.replace(/\.h$/i, ".hh"));
+	} else if (/\.hpp$/i.test(name)) {
+		variants.push(name.replace(/\.hpp$/i, ".h"), name.replace(/\.hpp$/i, ".hh"));
+	} else if (/\.hh$/i.test(name)) {
+		variants.push(name.replace(/\.hh$/i, ".h"), name.replace(/\.hh$/i, ".hpp"));
+	}
+	return [...new Set(variants)];
+}
+
+function siblingImplementation(headerPath) {
+	if (!headerPath || !isHeaderFile(headerPath)) {
+		return null;
+	}
+	const base = headerPath.replace(/\.(h|hpp|hh)$/i, "");
+	for (const ext of [".cpp", ".cc", ".cxx", ".c"]) {
+		if (fs.existsSync(base + ext)) {
+			return base + ext;
+		}
+	}
+	return null;
+}
+
+function siblingHeader(implPath) {
+	if (!implPath || isHeaderFile(implPath)) {
+		return null;
+	}
+	const base = String(implPath).replace(/\.(cpp|cc|cxx|c)$/i, "");
+	if (base === String(implPath)) {
+		return null;
+	}
+	for (const ext of [".h", ".hpp", ".hh"]) {
+		if (fs.existsSync(base + ext)) {
+			return base + ext;
+		}
+	}
+	return null;
+}
+
+function implOutName(rel) {
+	return String(rel)
+		.replace(/\\/g, "/")
+		.replace(/\.(cpp|cc|cxx|c)$/i, "Impl.luau");
+}
+
 function resolveInclude(name, fromFile, includeDirs) {
 	const bases = [path.dirname(fromFile), ...(includeDirs || [])];
 	for (const base of bases) {
-		const candidate = path.resolve(base, name);
-		if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
-			return candidate;
+		for (const variant of includeVariants(name)) {
+			const candidate = path.resolve(base, variant);
+			if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+				return candidate;
+			}
 		}
 	}
 	return null;
 }
 
+function scanHeaderExports(source) {
+	const consts = [];
+	const structs = [];
+	for (const match of String(source).matchAll(/\bconst\s+(?:int|bool|float|double|auto|string)\s+(\w+)/g)) {
+		if (!consts.includes(match[1])) {
+			consts.push(match[1]);
+		}
+	}
+	for (const match of String(source).matchAll(/\bstruct\s+(\w+)/g)) {
+		if (!structs.includes(match[1])) {
+			structs.push(match[1]);
+		}
+	}
+	const hasProtos = /\b(?:void|int|bool|float|double|auto|string|[\w:]+)\s+\w+\s*\([^;]*\)\s*;/.test(String(source));
+	return { consts, structs, hasProtos };
+}
+
+function pushModuleInclude(options, resolved, impl) {
+	options.moduleIncludes = options.moduleIncludes || [];
+	const srcDir = options.srcDir || null;
+	const moduleFile = impl || resolved;
+	const rel = srcDir ? path.relative(srcDir, moduleFile).replace(/\\/g, "/") : path.basename(moduleFile);
+	const headerText = fs.readFileSync(resolved, "utf8");
+	options.moduleIncludes.push({
+		name: path.basename(resolved).replace(/\.(h|hpp|hh)$/i, ""),
+		outRel: rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau"),
+		header: resolved,
+		impl: impl || null,
+		exports: scanHeaderExports(headerText),
+	});
+}
+
+function applyPragmas(source, options) {
+	let nstrict = false;
+	let strict = false;
+	for (const line of String(source).split(/\r?\n/)) {
+		if (/^\s*#\s*pragma\s+nstrict\b/i.test(line)) {
+			nstrict = true;
+		} else if (/^\s*#\s*pragma\s+strict\b/i.test(line)) {
+			strict = true;
+		}
+	}
+	if (nstrict) {
+		options.strict = false;
+	} else if (strict) {
+		options.strict = true;
+	}
+}
+
 function preprocess(source, filePath, options = {}) {
+	if (!options.pragmaResolved) {
+		options.pragmaResolved = true;
+		applyPragmas(source, options);
+	}
 	const seen = options.seen || new Set();
 	const includeDirs = options.includeDirs || [];
 	const resolvedSelf = filePath ? path.resolve(filePath) : null;
@@ -56,6 +158,13 @@ function preprocess(source, filePath, options = {}) {
 			if (!resolved || isEngineStub(resolved) || seen.has(resolved)) {
 				continue;
 			}
+			const impl = siblingImplementation(resolved);
+			const including = filePath ? path.resolve(filePath) : null;
+			const ownHeader = Boolean(impl && including && path.resolve(impl) === including);
+			if (!ownHeader) {
+				pushModuleInclude(options, resolved, impl);
+				continue;
+			}
 			seen.add(resolved);
 			const inner = fs.readFileSync(resolved, "utf8");
 			out.push(preprocess(inner, resolved, { ...options, seen }));
@@ -75,6 +184,12 @@ module.exports = {
 	isSourceFile,
 	isHeaderFile,
 	toLuauPath,
+	applyPragmas,
 	preprocess,
+	scanHeaderExports,
 	isEngineStub,
+	siblingImplementation,
+	siblingHeader,
+	implOutName,
+	resolveInclude,
 };

package/src/server/leaderstats.server.cpp

@@ -0,0 +1,28 @@
+#include <cluaupp/roblox.hpp>
+
+void CreateLeaderstats(Player* player) {
+	if (player->FindFirstChild("leaderstats") != nullptr) {
+		return;
+	}
+
+	auto* leaderstats = new Folder(player);
+	leaderstats->Name = "leaderstats";
+
+	auto* coins = new IntValue(leaderstats);
+	coins->Name = "Coins";
+	coins->Value = 0;
+
+	auto* level = new IntValue(leaderstats);
+	level->Name = "Level";
+	level->Value = 0;
+}
+
+void init() {
+	auto* players = GetService<Players>();
+
+	for (auto* player : players->GetPlayers()) {
+		CreateLeaderstats(player);
+	}
+
+	players->PlayerAdded.Connect(CreateLeaderstats);
+}

package/src/shared/config.cpp

@@ -0,0 +1,5 @@
+#include "config.h"
+
+int startingCoins() {
+	return STARTING_COINS;
+}

package/src/shared/config.h

@@ -0,0 +1,3 @@
+#include <cluaupp/roblox.hpp>
+
+const int STARTING_COINS = 0;

package/src/understand.js

@@ -94,7 +94,18 @@ const INTENTS = {
 	data: {
 		role: "controller",
 		module: "DataController",
-		tokens: ["DataStore", "DataStoreService", "DataService", "SetAsync", "GetAsync", "UpdateAsync", "ProfileStore"],
+		tokens: [
+			"DataStore",
+			"DataStoreService",
+			"DataService",
+			"SetAsync",
+			"GetAsync",
+			"UpdateAsync",
+			"ProfileStore",
+			"GetChangedSignal",
+			"WaitFor",
+			"Paths",
+		],
 	},
 	character: {
 		role: "controller",
@@ -187,19 +198,28 @@ function toPascalServiceName(fileName) {
 
 function parseFileTag(fileName) {
 	const base = path.basename(fileName);
+	if (new RegExp(`\\.legacy\\.plugin\\.${EXT}$`, "i").test(base)) {
+		return { key: "legacy.plugin", emit: "legacy", runtime: "plugin", rojo: "Script", runContext: "Plugin" };
+	}
 	if (new RegExp(`\\.legacy\\.server\\.${EXT}$`, "i").test(base)) {
-		return { key: "legacy.server", emit: "legacy", runtime: "server", rojo: "Script" };
+		return { key: "legacy.server", emit: "legacy", runtime: "server", rojo: "Script", runContext: null };
 	}
 	if (new RegExp(`\\.legacy\\.client\\.${EXT}$`, "i").test(base)) {
-		return { key: "legacy.client", emit: "legacy", runtime: "client", rojo: "LocalScript" };
+		return { key: "legacy.client", emit: "legacy", runtime: "client", rojo: "LocalScript", runContext: null };
+	}
+	if (new RegExp(`\\.legacy\\.${EXT}$`, "i").test(base)) {
+		return { key: "legacy", emit: "legacy", runtime: "server", rojo: "Script", runContext: null };
+	}
+	if (new RegExp(`\\.plugin\\.${EXT}$`, "i").test(base)) {
+		return { key: "plugin", emit: "service", runtime: "plugin", rojo: "Script", runContext: "Plugin" };
 	}
 	if (new RegExp(`\\.server\\.${EXT}$`, "i").test(base)) {
-		return { key: "server", emit: "service", runtime: "server", rojo: "Script" };
+		return { key: "server", emit: "service", runtime: "server", rojo: "Script", runContext: "Server" };
 	}
 	if (new RegExp(`\\.client\\.${EXT}$`, "i").test(base)) {
-		return { key: "client", emit: "service", runtime: "client", rojo: "LocalScript" };
+		return { key: "client", emit: "service", runtime: "client", rojo: "LocalScript", runContext: "Client" };
 	}
-	return { key: "module", emit: "module", runtime: "shared", rojo: "ModuleScript" };
+	return { key: "module", emit: "module", runtime: "shared", rojo: "ModuleScript", runContext: null };
 }
 
 function scoreIntents(named) {
@@ -362,9 +382,37 @@ function classifyFunctions(ast, intents) {
 			absorb,
 		});
 	}
+	keepReferencedFunctions(ast, classified);
 	return classified;
 }
 
+function keepReferencedFunctions(ast, classified) {
+	const kept = new Set(["init"]);
+	for (const item of classified) {
+		if (item.absorb !== "cache") {
+			kept.add(item.name);
+		}
+	}
+
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const decl of ast.body || []) {
+			if (decl.type !== "function" || !kept.has(decl.name)) {
+				continue;
+			}
+			const named = namesIn(decl);
+			for (const item of classified) {
+				if (item.absorb === "cache" && named.has(item.name)) {
+					item.absorb = "none";
+					kept.add(item.name);
+					changed = true;
+				}
+			}
+		}
+	}
+}
+
 function analyze(ast, fileName) {
 	const tag = parseFileTag(fileName);
 	const named = namesIn(ast);
@@ -420,6 +468,7 @@ function analyze(ast, fileName) {
 		serviceName,
 		typesName: `${serviceName}Types`,
 		isClient: tag.runtime === "client",
+		runContext: tag.runContext || null,
 		intents,
 		primaryDomain,
 		roles,
@@ -432,10 +481,20 @@ function analyze(ast, fileName) {
 	};
 }
 
+function modernScriptOutName(relativeName) {
+	const rel = String(relativeName).replace(/\\/g, "/");
+	if (/\.plugin\.(cpp|cc|cxx|c|h|hpp|hh)$/i.test(rel)) {
+		return rel.replace(/\.plugin\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+	}
+	return rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+}
+
 function legacyOutName(relativeName) {
 	return String(relativeName)
 		.replace(/\\/g, "/")
+		.replace(/\.legacy\.plugin\./i, ".")
 		.replace(/\.legacy\.(server|client)\./i, ".$1.")
+		.replace(/\.legacy\./i, ".server.")
 		.replace(new RegExp(`\\.${EXT}$`, "i"), ".luau");
 }
 
@@ -449,5 +508,6 @@ module.exports = {
 	scoreIntents,
 	analyze,
 	legacyOutName,
+	modernScriptOutName,
 	looksLikeCacheSetup,
 };

package/templates/game/.clangd

@@ -1,5 +1,16 @@
 CompileFlags:
   Add:
+    - -xc++
     - -std=c++20
+    - -ferror-limit=0
     - -Iinclude
     - -Isrc
+
+Diagnostics:
+  Suppress: '*'
+
+---
+If:
+  PathMatch: (out|libs)/.*
+Index:
+  Background: Skip

package/templates/game/.vscode/c_cpp_properties.json

@@ -2,14 +2,18 @@
 	"configurations": [
 		{
 			"name": "Cluaupp",
+			"compilerPath": "C:/Program Files/LLVM/bin/clang++.exe",
 			"cStandard": "c17",
 			"cppStandard": "c++20",
-			"intelliSenseMode": "windows-gcc-x64",
+			"intelliSenseMode": "windows-clang-x64",
 			"includePath": [
 				"${workspaceFolder}/include",
 				"${workspaceFolder}/src"
 			],
-			"defines": [],
+			"forcedInclude": [
+				"${workspaceFolder}/include/cluaupp/roblox.hpp"
+			],
+			"compileCommands": "${workspaceFolder}/compile_commands.json",
 			"browse": {
 				"path": [
 					"${workspaceFolder}/include",

package/templates/game/.vscode/extensions.json

@@ -0,0 +1,6 @@
+{
+	"recommendations": [
+		"ms-vscode.cpptools",
+		"kartzdev.cluaupp-intellisense"
+	]
+}

package/templates/game/.vscode/settings.json

@@ -1,6 +1,9 @@
 {
+	"C_Cpp.intelliSenseEngine": "default",
 	"C_Cpp.default.cppStandard": "c++20",
-	"C_Cpp.default.intelliSenseMode": "windows-gcc-x64",
+	"C_Cpp.default.cStandard": "c17",
+	"C_Cpp.default.compilerPath": "C:/Program Files/LLVM/bin/clang++.exe",
+	"C_Cpp.default.intelliSenseMode": "windows-clang-x64",
 	"C_Cpp.default.includePath": [
 		"${workspaceFolder}/include",
 		"${workspaceFolder}/src"
@@ -8,5 +11,16 @@
 	"C_Cpp.default.browse.path": [
 		"${workspaceFolder}/include",
 		"${workspaceFolder}/src"
-	]
+	],
+	"clangd.enable": false,
+	"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"
+	}
 }

package/templates/game/cluaupp.config.json

@@ -1,6 +1,6 @@
 {
 	"rootDir": "src",
 	"outDir": "out",
-	"strict": true,
-	"architecture": true
+	"strict": false,
+	"architecture": false
 }

package/templates/game/compile_flags.txt

@@ -1,3 +1,5 @@
+-xc++
 -std=c++20
+-ferror-limit=0
 -Iinclude
 -Isrc

package/templates/game/src/client/init.client.cpp

@@ -1,3 +1,4 @@
+#pragma strict
 #include <cluaupp/roblox.hpp>
 
 void init() {

package/templates/game/src/server/leaderstats.server.cpp

@@ -1,3 +1,4 @@
+#pragma strict
 #include <cluaupp/roblox.hpp>
 
 void CreateLeaderstats(Player* player) {