cluaupp 0.1.4 → 0.2.0

package/src/parser/collector.ts

@@ -0,0 +1,115 @@
+import type Parser from "tree-sitter";
+import type { CollectorContext, TranspilerState } from "../types.js";
+import type { RojoMapper } from "../utils/rojo-mapper.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,
+		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 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 (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

@@ -0,0 +1,27 @@
+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/{preprocess.js → preprocess.ts}

@@ -1,23 +1,22 @@
-"use strict";
+import fs from "node:fs";
+import path from "node:path";
+import type { ModuleInclude, PreprocessOptions } from "./ast.js";
 
-const fs = require("fs");
-const path = require("path");
+export const SOURCE_EXTS = [".cpp", ".cc", ".cxx", ".c", ".h", ".hpp", ".hh"];
 
-const SOURCE_EXTS = [".cpp", ".cc", ".cxx", ".c", ".h", ".hpp", ".hh"];
-
-function isSourceFile(fileName) {
+export function isSourceFile(fileName: string): boolean {
 	return SOURCE_EXTS.includes(path.extname(fileName).toLowerCase());
 }
 
-function isHeaderFile(fileName) {
+export function isHeaderFile(fileName: string): boolean {
 	return [".h", ".hpp", ".hh"].includes(path.extname(fileName).toLowerCase());
 }
 
-function toLuauPath(filePath) {
+export function toLuauPath(filePath: string): string {
 	return filePath.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
 }
 
-function isEngineStub(filePath) {
+export function isEngineStub(filePath: string): boolean {
 	const normalized = filePath.replace(/\\/g, "/").toLowerCase();
 	return (
 		normalized.includes("/include/cluaupp/") ||
@@ -27,7 +26,7 @@ function isEngineStub(filePath) {
 	);
 }
 
-function includeVariants(name) {
+function includeVariants(name: string): string[] {
 	const variants = [name];
 	if (/\.h$/i.test(name)) {
 		variants.push(name.replace(/\.h$/i, ".hpp"), name.replace(/\.h$/i, ".hh"));
@@ -39,7 +38,7 @@ function includeVariants(name) {
 	return [...new Set(variants)];
 }
 
-function siblingImplementation(headerPath) {
+export function siblingImplementation(headerPath: string | null | undefined): string | null {
 	if (!headerPath || !isHeaderFile(headerPath)) {
 		return null;
 	}
@@ -52,7 +51,29 @@ function siblingImplementation(headerPath) {
 	return null;
 }
 
-function resolveInclude(name, fromFile, includeDirs) {
+export function siblingHeader(implPath: string | null | undefined): string | null {
+	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;
+}
+
+export function implOutName(rel: string): string {
+	return String(rel)
+		.replace(/\\/g, "/")
+		.replace(/\.(cpp|cc|cxx|c)$/i, "Impl.luau");
+}
+
+export function resolveInclude(name: string, fromFile: string, includeDirs?: string[]): string | null {
 	const bases = [path.dirname(fromFile), ...(includeDirs || [])];
 	for (const base of bases) {
 		for (const variant of includeVariants(name)) {
@@ -65,9 +86,9 @@ function resolveInclude(name, fromFile, includeDirs) {
 	return null;
 }
 
-function scanHeaderExports(source) {
-	const consts = [];
-	const structs = [];
+export function scanHeaderExports(source: string): { consts: string[]; structs: string[]; hasProtos: boolean } {
+	const consts: string[] = [];
+	const structs: string[] = [];
 	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]);
@@ -78,10 +99,11 @@ function scanHeaderExports(source) {
 			structs.push(match[1]);
 		}
 	}
-	return { consts, structs };
+	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) {
+function pushModuleInclude(options: PreprocessOptions, resolved: string, impl: string | null): void {
 	options.moduleIncludes = options.moduleIncludes || [];
 	const srcDir = options.srcDir || null;
 	const moduleFile = impl || resolved;
@@ -96,8 +118,30 @@ function pushModuleInclude(options, resolved, impl) {
 	});
 }
 
-function preprocess(source, filePath, options = {}) {
-	const seen = options.seen || new Set();
+export function applyPragmas(source: string, options: PreprocessOptions): void {
+	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;
+	}
+}
+
+export function preprocess(source: string, filePath: string | null, options: PreprocessOptions = {}): string {
+	if (!options.pragmaResolved) {
+		options.pragmaResolved = true;
+		applyPragmas(source, options);
+	}
+	const seen = options.seen || new Set<string>();
+	options.seen = seen;
 	const includeDirs = options.includeDirs || [];
 	const resolvedSelf = filePath ? path.resolve(filePath) : null;
 	if (resolvedSelf) {
@@ -105,7 +149,7 @@ function preprocess(source, filePath, options = {}) {
 	}
 
 	const lines = String(source).split(/\r?\n/);
-	const out = [];
+	const out: string[] = [];
 
 	for (const line of lines) {
 		const quoted = line.match(/^\s*#\s*include\s+"([^"]+)"/);
@@ -134,15 +178,3 @@ function preprocess(source, filePath, options = {}) {
 
 	return out.join("\n");
 }
-
-module.exports = {
-	SOURCE_EXTS,
-	isSourceFile,
-	isHeaderFile,
-	toLuauPath,
-	preprocess,
-	scanHeaderExports,
-	isEngineStub,
-	siblingImplementation,
-	resolveInclude,
-};