cluaupp 0.2.1 → 0.2.3

package/src/parse.ts

@@ -48,21 +48,128 @@ function parse(source, fileName) {
 		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;
 		}
@@ -132,14 +239,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();
@@ -320,11 +430,8 @@ function parse(source, fileName) {
 	}
 
 	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;
@@ -336,9 +443,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() };
 	}
 
@@ -395,6 +499,7 @@ function parse(source, fileName) {
 	}
 
 	function parseFunction() {
+		skipSpecifiers();
 		const returnType = parseType();
 		if (!returnType || !at("ident")) {
 			throw error("invalid function declaration");
@@ -465,10 +570,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 === "(") {
@@ -593,10 +695,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/src/parser/collector.ts

@@ -1,6 +1,8 @@
+import path from "node:path";
 import type Parser from "tree-sitter";
 import type { CollectorContext, TranspilerState } from "../types.js";
 import type { RojoMapper } from "../utils/rojo-mapper.js";
+import { siblingHeader } from "../preprocess.js";
 import {
 	translateAlias,
 	translateConstant,
@@ -28,7 +30,7 @@ export class ASTCollector {
 
 	constructor(
 		private mapper: RojoMapper,
-		context: CollectorContext = { fileName: "input.cpp" },
+		private context: CollectorContext = { fileName: "input.cpp" },
 	) {
 		this.state = emptyState(context.strict === true);
 	}
@@ -68,12 +70,43 @@ export class ASTCollector {
 		}
 	}
 
+	private includeTarget(raw: string): string | null {
+		const from = this.context.sourcePath;
+		if (!from) {
+			return null;
+		}
+		const cleaned = raw.replace(/[<>'"]/g, "").trim();
+		if (!cleaned || raw.includes("<")) {
+			return null;
+		}
+		return path.resolve(path.dirname(from), cleaned);
+	}
+
+	private isOwnHeader(raw: string): boolean {
+		const from = this.context.sourcePath;
+		if (!from) {
+			return false;
+		}
+		const target = this.includeTarget(raw);
+		if (!target) {
+			return false;
+		}
+		if (path.resolve(from) === target) {
+			return true;
+		}
+		const header = siblingHeader(from);
+		return Boolean(header && path.resolve(header) === target);
+	}
+
 	private collectInclude(node: SyntaxNode): void {
 		const pathNode = node.childForFieldName("path") || node.namedChildren[0] || node.child(1);
 		if (!pathNode) {
 			return;
 		}
-		const resolved = this.mapper.resolveIncludeToRequire(pathNode.text);
+		if (this.isOwnHeader(pathNode.text)) {
+			return;
+		}
+		const resolved = this.mapper.resolveIncludeToRequire(pathNode.text, this.context.sourcePath);
 		if (resolved) {
 			this.state.moduleRequires.set(resolved.alias, resolved.path);
 		}

package/src/utils/rojo-mapper.ts

@@ -64,7 +64,24 @@ export class RojoMapper {
 		this.bindings = this.walkTree(this.config.tree, []);
 	}
 
-	public resolveIncludeToRequire(includePath: string): RequireBinding | null {
+	private resolveQuotedFile(raw: string, fromFile?: string): string | null {
+		const bases: string[] = [];
+		if (fromFile) {
+			bases.push(path.dirname(fromFile));
+		}
+		if (this.srcDir) {
+			bases.push(this.srcDir);
+		}
+		for (const base of bases) {
+			const candidate = path.resolve(base, raw);
+			if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+				return candidate;
+			}
+		}
+		return null;
+	}
+
+	public resolveIncludeToRequire(includePath: string, fromFile?: string): RequireBinding | null {
 		const raw = includePath.replace(/[<>'"]/g, "").trim();
 		if (!raw) {
 			return null;
@@ -82,12 +99,18 @@ export class RojoMapper {
 			return library;
 		}
 
-		const fromTree = this.resolveFromRojoTree(cleanPath, baseName);
+		const resolvedFile = this.resolveQuotedFile(raw, fromFile);
+		const lookupPath =
+			resolvedFile && this.srcDir
+				? posix(path.relative(this.srcDir, resolvedFile)).replace(/\.h(pp|h)?$/i, "")
+				: cleanPath;
+
+		const fromTree = this.resolveFromRojoTree(lookupPath, baseName);
 		if (fromTree) {
 			return fromTree;
 		}
 
-		const segments = cleanPath.split("/").filter(Boolean);
+		const segments = lookupPath.split("/").filter(Boolean);
 		if (segments[0] === "src") {
 			segments.shift();
 		}

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

@@ -1,5 +1,8 @@
 {
 	"recommendations": [
 		"llvm-vs-code-extensions.vscode-clangd"
+	],
+	"unwantedRecommendations": [
+		"ms-vscode.cpptools"
 	]
 }

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

@@ -1,13 +1,4 @@
 {
-	"C_Cpp.intelliSenseEngine": "Disabled",
-	"C_Cpp.default.cppStandard": "c++20",
-	"C_Cpp.default.cStandard": "c17",
-	"C_Cpp.default.compilerPath": "clang++",
-	"C_Cpp.default.intelliSenseMode": "windows-clang-x64",
-	"C_Cpp.default.includePath": [
-		"${workspaceFolder}/include",
-		"${workspaceFolder}/src"
-	],
 	"clangd.enable": true,
 	"clangd.arguments": [
 		"--compile-commands-dir=${workspaceFolder}",

package/templates/game/src/shared/config.h

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

package/examples/game/.vscode/c_cpp_properties.json

@@ -1,27 +0,0 @@
-{
-	"configurations": [
-		{
-			"name": "Cluaupp",
-			"compilerPath": "clang++",
-			"cStandard": "c17",
-			"cppStandard": "c++20",
-			"intelliSenseMode": "windows-clang-x64",
-			"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
-}

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

@@ -1,27 +0,0 @@
-{
-	"configurations": [
-		{
-			"name": "Cluaupp",
-			"compilerPath": "clang++",
-			"cStandard": "c17",
-			"cppStandard": "c++20",
-			"intelliSenseMode": "windows-clang-x64",
-			"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
-}