cluaupp 0.2.2 → 1.0.0

package/src/parser/collector.ts

@@ -1,148 +0,0 @@
-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,
-	translateCppType,
-	translateGetService,
-	translateStruct,
-} from "../emitter/translators.js";
-
-type SyntaxNode = Parser.SyntaxNode;
-
-function emptyState(strict = false): TranspilerState {
-	return {
-		robloxServices: new Set<string>(),
-		moduleRequires: new Map<string, string>(),
-		customTypes: [],
-		constants: [],
-		functions: [],
-		headerLines: [],
-		strict,
-	};
-}
-
-export class ASTCollector {
-	private state: TranspilerState;
-
-	constructor(
-		private mapper: RojoMapper,
-		private context: CollectorContext = { fileName: "input.cpp" },
-	) {
-		this.state = emptyState(context.strict === true);
-	}
-
-	public collect(rootNode: SyntaxNode): TranspilerState {
-		this.visit(rootNode, false);
-		return this.state;
-	}
-
-	private visit(node: SyntaxNode, inFunction: boolean): void {
-		if (node.type === "preproc_include") {
-			this.collectInclude(node);
-		} else if (node.type === "call_expression") {
-			this.collectGetService(node);
-		} else if (!inFunction && node.type === "function_definition") {
-			this.visitChildren(node, true);
-			return;
-		} else if (!inFunction && node.type === "declaration") {
-			this.collectDeclaration(node);
-		} else if (!inFunction && (node.type === "type_definition" || node.type === "alias_declaration")) {
-			this.collectAlias(node);
-		} else if (!inFunction && (node.type === "struct_specifier" || node.type === "class_specifier")) {
-			this.collectStruct(node);
-		} else if (!inFunction && node.type === "preproc_call" && /pragma\s+strict/.test(node.text)) {
-			this.state.strict = true;
-		}
-
-		this.visitChildren(node, inFunction);
-	}
-
-	private visitChildren(node: SyntaxNode, inFunction: boolean): void {
-		for (let i = 0; i < node.childCount; i += 1) {
-			const child = node.child(i);
-			if (child) {
-				this.visit(child, inFunction);
-			}
-		}
-	}
-
-	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;
-		}
-		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);
-		}
-	}
-
-	private collectGetService(node: SyntaxNode): void {
-		const service = translateGetService(node);
-		if (service) {
-			this.state.robloxServices.add(service);
-		}
-	}
-
-	private collectDeclaration(node: SyntaxNode): void {
-		const text = node.text.trimStart();
-		if (!(text.startsWith("const") || text.startsWith("constexpr"))) {
-			return;
-		}
-		const translated = translateConstant(node);
-		if (translated) {
-			this.state.constants.push(translated);
-		}
-	}
-
-	private collectAlias(node: SyntaxNode): void {
-		const translated = translateAlias(node, translateCppType);
-		if (translated) {
-			this.state.customTypes.push(translated);
-		}
-	}
-
-	private collectStruct(node: SyntaxNode): void {
-		const translated = translateStruct(node, translateCppType);
-		if (translated) {
-			this.state.customTypes.push(translated);
-		}
-	}
-}
-
-export { emptyState };

package/src/parser/index.ts

@@ -1,27 +0,0 @@
-import Parser from "tree-sitter";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { projectRoot } from "../package-info.js";
-
-const nodeRequire = createRequire(path.join(projectRoot, "package.json"));
-
-export type CppParser = Parser;
-
-export function createCppParserSync(): CppParser | null {
-	try {
-		const Cpp = nodeRequire("tree-sitter-cpp");
-		const parser = new Parser();
-		parser.setLanguage(Cpp);
-		parser.parse("int main() { return 0; }");
-		return parser;
-	} catch {
-		return null;
-	}
-}
-
-export function parseCpp(source: string, parser = createCppParserSync()): Parser.Tree | null {
-	if (!parser) {
-		return null;
-	}
-	return parser.parse(source);
-}

package/src/tree-sitter-cpp.d.ts

@@ -1,4 +0,0 @@
-declare module "tree-sitter-cpp" {
-	const language: unknown;
-	export default language;
-}

package/src/understand.ts

@@ -1,322 +0,0 @@
-// @ts-nocheck
-import path from "node:path";
-import { luauType } from "./api.js";
-import {
-	INTENTS,
-	walk,
-	namesIn,
-	parseFileTag,
-	scoreIntents,
-	determineArchitecture,
-} from "./system-understander.js";
-
-const VALUE_CLASSES = {
-	IntValue: { luau: "number", instance: "IntValue", fallback: "0" },
-	NumberValue: { luau: "number", instance: "NumberValue", fallback: "0" },
-	StringValue: { luau: "string", instance: "StringValue", fallback: '""' },
-	BoolValue: { luau: "boolean", instance: "BoolValue", fallback: "false" },
-};
-
-const EXT = "(cpp|cc|cxx|c|h|hpp|hh)";
-
-function capitalize(word) {
-	if (!word) {
-		return word;
-	}
-	return word.charAt(0).toUpperCase() + word.slice(1);
-}
-
-function toPascalServiceName(fileName) {
-	let base = path.basename(fileName).replace(new RegExp(`\\.${EXT}$`, "i"), "");
-	base = base.replace(/\.legacy\.(server|client)$/i, "");
-	base = base.replace(/\.(server|client)$/i, "");
-	if (/^init$/i.test(base)) {
-		const folder = path.basename(path.dirname(fileName) || "");
-		if (folder && folder !== "." && folder !== "src") {
-			return capitalize(folder);
-		}
-		return "Init";
-	}
-	if (/stats$/i.test(base) && !/Stats$/.test(base)) {
-		return capitalize(base.slice(0, -5)) + "Stats";
-	}
-	if (/[-_]/.test(base)) {
-		return base
-			.split(/[-_]+/)
-			.filter(Boolean)
-			.map(capitalize)
-			.join("");
-	}
-	return capitalize(base);
-}
-
-function literal(node) {
-	if (!node) {
-		return null;
-	}
-	if (node.type === "number") {
-		return node.value;
-	}
-	if (node.type === "string") {
-		return `"${node.value}"`;
-	}
-	if (node.type === "bool") {
-		return node.value ? "true" : "false";
-	}
-	if (node.type === "null") {
-		return "nil";
-	}
-	return null;
-}
-
-function collectStats(ast) {
-	const stats = [];
-	let folderName = null;
-	const seen = new Set();
-
-	for (const decl of ast.body || []) {
-		if (decl.type !== "function" || !decl.body) {
-			continue;
-		}
-		const locals = new Map();
-		for (const stmt of decl.body) {
-			if (stmt.type === "decl" && stmt.value && stmt.value.type === "new") {
-				locals.set(stmt.name, {
-					className: stmt.value.className,
-					statName: null,
-					defaultValue: null,
-				});
-			}
-			if (stmt.type !== "expr" || !stmt.expr || stmt.expr.type !== "assign") {
-				continue;
-			}
-			const left = stmt.expr.left;
-			if (!left || left.type !== "member" || !left.object || left.object.type !== "ident") {
-				continue;
-			}
-			const record = locals.get(left.object.name);
-			if (!record) {
-				continue;
-			}
-			if (left.name === "Name" && stmt.expr.right && stmt.expr.right.type === "string") {
-				record.statName = stmt.expr.right.value;
-				if (record.className === "Folder") {
-					folderName = record.statName;
-				}
-			}
-			if (left.name === "Value") {
-				record.defaultValue = literal(stmt.expr.right);
-			}
-		}
-		for (const record of locals.values()) {
-			const spec = VALUE_CLASSES[record.className];
-			if (!spec || !record.statName || seen.has(record.statName)) {
-				continue;
-			}
-			seen.add(record.statName);
-			stats.push({
-				name: record.statName,
-				instance: spec.instance,
-				luau: spec.luau,
-				defaultValue: record.defaultValue != null ? record.defaultValue : spec.fallback,
-			});
-		}
-	}
-
-	return { stats, folderName: folderName || (stats.length > 0 ? "leaderstats" : null) };
-}
-
-function collectConsts(ast) {
-	const consts = [];
-	for (const decl of ast.body || []) {
-		if (decl.type === "decl" && decl.isConst) {
-			consts.push({
-				name: decl.name,
-				luau: luauType(decl.valueType) || "number",
-				value: literal(decl.value) || "nil",
-			});
-		}
-	}
-	return consts;
-}
-
-function onlyConsts(ast) {
-	const body = ast.body || [];
-	if (body.length === 0) {
-		return false;
-	}
-	return body.every((node) => node.type === "decl" || node.type === "proto");
-}
-
-function looksLikeCacheSetup(fn) {
-	if (!fn || !fn.body) {
-		return false;
-	}
-	const named = namesIn(fn);
-	return [...Object.keys(VALUE_CLASSES), "Folder"].some((name) => named.has(name));
-}
-
-function isTrivial(ast) {
-	const fns = (ast.body || []).filter((node) => node.type === "function");
-	if (fns.length === 0) {
-		return (ast.body || []).every((node) => node.type === "proto" || node.type === "decl");
-	}
-	if (fns.some((fn) => fn.name !== "init")) {
-		return false;
-	}
-	const init = fns.find((fn) => fn.name === "init");
-	const named = namesIn(init || { body: [] }, { strings: false });
-	const interesting = [...named].filter((name) => !["print", "warn", "error"].includes(name) && !/^[0-9.]+$/.test(name));
-	return interesting.length === 0;
-}
-
-function classifyFunctions(ast, intents) {
-	const primary = intents.find((item) => item.name !== "players" && item.name !== "cache");
-	const classified = [];
-	for (const decl of ast.body || []) {
-		if (decl.type !== "function" || decl.name === "init") {
-			continue;
-		}
-		const named = namesIn(decl);
-		const localIntents = scoreIntents(named);
-		let absorb = "none";
-		if (looksLikeCacheSetup(decl)) {
-			absorb = "cache";
-		}
-		const top = localIntents[0];
-		classified.push({
-			name: decl.name,
-			decl,
-			intent: top ? top.name : primary ? primary.name : "domain",
-			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 report = determineArchitecture(fileName, ast);
-	const tag = report.fileTag;
-	const named = namesIn(ast);
-	const { stats, folderName } = collectStats(ast);
-	const consts = collectConsts(ast);
-	const intents = scoreIntents(named, tag.runtime);
-	const functions = classifyFunctions(ast, intents);
-	const trivial = isTrivial(ast);
-	const constsOnly = onlyConsts(ast);
-	const hasPlayers = intents.some((item) => item.name === "players");
-	const hasCache = intents.some((item) => item.name === "cache") || stats.length > 0;
-	const primaryDomain = intents.find((item) => item.name !== "players" && item.name !== "cache") || null;
-	const serviceName = toPascalServiceName(fileName);
-	const configLike =
-		tag.emit === "module" &&
-		(constsOnly || (consts.length > 0 && !hasPlayers && stats.length === 0 && !primaryDomain));
-
-	let kind = "flat";
-	if (tag.emit === "legacy") {
-		kind = "legacy";
-	} else if (tag.emit === "module") {
-		kind = configLike ? "config" : "module";
-	} else if (tag.emit === "service") {
-		kind = trivial ? "flat" : "service";
-	}
-
-	const roles = {
-		players: kind === "service" && hasPlayers,
-		cache: kind === "service" && (hasCache || stats.length > 0),
-		domain: null,
-	};
-	if (kind === "service" && primaryDomain) {
-		roles.domain = primaryDomain.module;
-	} else if (kind === "service" && !roles.cache && !roles.players) {
-		roles.domain = `${serviceName}Controller`;
-	}
-
-	const reasoning = [
-		...report.reasoning,
-		kind === "service"
-			? `roles ${["Main", roles.players ? "PlayersManager" : null, roles.cache ? "CacheController" : null, roles.domain, `${serviceName}Types`].filter(Boolean).join(", ")}`
-			: `kind ${kind}`,
-	];
-
-	return {
-		tag,
-		kind,
-		onlyConsts: constsOnly,
-		trivial,
-		serviceName,
-		typesName: `${serviceName}Types`,
-		isClient: tag.runtime === "client",
-		runContext: tag.runContext || null,
-		intents,
-		primaryDomain,
-		roles,
-		stats,
-		folderName,
-		consts,
-		functions,
-		fileName,
-		understand: report,
-		reasoning,
-	};
-}
-
-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");
-}
-
-export {
-	VALUE_CLASSES,
-	INTENTS,
-	walk,
-	namesIn,
-	parseFileTag,
-	toPascalServiceName,
-	scoreIntents,
-	analyze,
-	legacyOutName,
-	modernScriptOutName,
-	looksLikeCacheSetup,
-	determineArchitecture,
-};

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
-}

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

@@ -1,6 +0,0 @@
-#pragma strict
-#include <cluaupp/roblox.hpp>
-
-void init() {
-	print("Cluaupp client ok");
-}

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

@@ -1,29 +0,0 @@
-#pragma strict
-#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/templates/game/src/shared/config.cpp

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

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

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