cluaupp 0.1.5 → 0.2.1

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,7 @@ function siblingImplementation(headerPath) {
 	return null;
 }
 
-function siblingHeader(implPath) {
+export function siblingHeader(implPath: string | null | undefined): string | null {
 	if (!implPath || isHeaderFile(implPath)) {
 		return null;
 	}
@@ -68,13 +67,13 @@ function siblingHeader(implPath) {
 	return null;
 }
 
-function implOutName(rel) {
+export function implOutName(rel: string): string {
 	return String(rel)
 		.replace(/\\/g, "/")
 		.replace(/\.(cpp|cc|cxx|c)$/i, "Impl.luau");
 }
 
-function resolveInclude(name, fromFile, includeDirs) {
+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)) {
@@ -87,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]);
@@ -104,7 +103,7 @@ function scanHeaderExports(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;
@@ -119,7 +118,7 @@ function pushModuleInclude(options, resolved, impl) {
 	});
 }
 
-function applyPragmas(source, options) {
+export function applyPragmas(source: string, options: PreprocessOptions): void {
 	let nstrict = false;
 	let strict = false;
 	for (const line of String(source).split(/\r?\n/)) {
@@ -136,12 +135,13 @@ function applyPragmas(source, options) {
 	}
 }
 
-function preprocess(source, filePath, options = {}) {
+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();
+	const seen = options.seen || new Set<string>();
+	options.seen = seen;
 	const includeDirs = options.includeDirs || [];
 	const resolvedSelf = filePath ? path.resolve(filePath) : null;
 	if (resolvedSelf) {
@@ -149,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+"([^"]+)"/);
@@ -178,18 +178,3 @@ function preprocess(source, filePath, options = {}) {
 
 	return out.join("\n");
 }
-
-module.exports = {
-	SOURCE_EXTS,
-	isSourceFile,
-	isHeaderFile,
-	toLuauPath,
-	applyPragmas,
-	preprocess,
-	scanHeaderExports,
-	isEngineStub,
-	siblingImplementation,
-	siblingHeader,
-	implOutName,
-	resolveInclude,
-};