cluaupp 1.0.0 → 1.4.0

package/src/flare/emit.ts

@@ -0,0 +1,231 @@
+import type { FlareEmitResult, FlareField, FlareQuery, FlarePacket, FlareSchema, FlareType } from "./types.js";
+
+const CLPP_TYPE: Record<FlareType, string> = {
+	u8: "int",
+	u16: "int",
+	u32: "int",
+	i8: "int",
+	i16: "int",
+	i32: "int",
+	f32: "double",
+	f64: "double",
+	bool: "bool",
+	string: "string",
+	Vector3: "Vector3",
+	Vector2: "Vector2",
+	CFrame: "CFrame",
+	Color3: "Color3",
+	UDim: "UDim",
+	UDim2: "UDim2",
+	BrickColor: "BrickColor",
+	buffer: "buffer",
+	Instance: "Instance",
+	Player: "Player",
+};
+
+const WRITE: Record<FlareType, (cursor: string, value: string) => string> = {
+	u8: (c, v) => `Flare.writeu8(${c}, ${v})`,
+	u16: (c, v) => `Flare.writeu16(${c}, ${v})`,
+	u32: (c, v) => `Flare.writeu32(${c}, ${v})`,
+	i8: (c, v) => `Flare.writei8(${c}, ${v})`,
+	i16: (c, v) => `Flare.writei16(${c}, ${v})`,
+	i32: (c, v) => `Flare.writei32(${c}, ${v})`,
+	f32: (c, v) => `Flare.writef32(${c}, ${v})`,
+	f64: (c, v) => `Flare.writef64(${c}, ${v})`,
+	bool: (c, v) => `Flare.writebool(${c}, ${v})`,
+	string: (c, v) => `Flare.writestring(${c}, ${v})`,
+	Vector3: (c, v) => `Flare.writeVector3(${c}, ${v})`,
+	Vector2: (c, v) => `Flare.writeVector2(${c}, ${v})`,
+	CFrame: (c, v) => `Flare.writeCFrame(${c}, ${v})`,
+	Color3: (c, v) => `Flare.writeColor3(${c}, ${v})`,
+	UDim: (c, v) => `Flare.writeUDim(${c}, ${v})`,
+	UDim2: (c, v) => `Flare.writeUDim2(${c}, ${v})`,
+	BrickColor: (c, v) => `Flare.writeBrickColor(${c}, ${v})`,
+	buffer: (c, v) => `Flare.writebuffer(${c}, ${v})`,
+	Instance: (c, v) => `Flare.writeInstance(${c}, ${v})`,
+	Player: (c, v) => `Flare.writeInstance(${c}, ${v})`,
+};
+
+const READ: Record<FlareType, (cursor: string) => string> = {
+	u8: (c) => `Flare.readu8(${c})`,
+	u16: (c) => `Flare.readu16(${c})`,
+	u32: (c) => `Flare.readu32(${c})`,
+	i8: (c) => `Flare.readi8(${c})`,
+	i16: (c) => `Flare.readi16(${c})`,
+	i32: (c) => `Flare.readi32(${c})`,
+	f32: (c) => `Flare.readf32(${c})`,
+	f64: (c) => `Flare.readf64(${c})`,
+	bool: (c) => `Flare.readbool(${c})`,
+	string: (c) => `Flare.readstring(${c})`,
+	Vector3: (c) => `Flare.readVector3(${c})`,
+	Vector2: (c) => `Flare.readVector2(${c})`,
+	CFrame: (c) => `Flare.readCFrame(${c})`,
+	Color3: (c) => `Flare.readColor3(${c})`,
+	UDim: (c) => `Flare.readUDim(${c})`,
+	UDim2: (c) => `Flare.readUDim2(${c})`,
+	BrickColor: (c) => `Flare.readBrickColor(${c})`,
+	buffer: (c) => `Flare.readbuffer(${c})`,
+	Instance: (c) => `Flare.readInstance(${c})`,
+	Player: (c) => `Flare.readInstance(${c})`,
+};
+
+function params(fields: FlareField[]): string {
+	return fields.map((field) => field.name).join(", ");
+}
+
+function clppParams(fields: FlareField[]): string {
+	return fields.map((field) => `${CLPP_TYPE[field.type]} ${field.name}`).join(", ");
+}
+
+function writeFields(fields: FlareField[], cursor = "cursor"): string {
+	if (fields.length === 0) {
+		return `\treturn ${cursor}`;
+	}
+	return fields.map((field) => `\t${WRITE[field.type](cursor, field.name)}`).join("\n") + `\n\treturn ${cursor}`;
+}
+
+function readFields(fields: FlareField[], cursor = "cursor"): string {
+	if (fields.length === 0) {
+		return "\treturn";
+	}
+	const lines = fields.map((field) => `\tlocal ${field.name} = ${READ[field.type](cursor)}`);
+	return `${lines.join("\n")}\n\treturn ${params(fields)}`;
+}
+
+function emitPacketLuau(packet: FlarePacket): string {
+	const args = params(packet.fields);
+	const fnArgs = args || "";
+	return `-- packet ${packet.name} (#${packet.id})
+local function write${packet.name}(cursor${fnArgs ? `, ${fnArgs}` : ""})
+${writeFields(packet.fields)}
+end
+
+local function read${packet.name}(cursor)
+${readFields(packet.fields)}
+end
+
+local ${packet.name} = session.packet({
+	id = ${packet.id},
+	from = "${packet.from === "Client" ? "client" : "server"}",
+	reliable = ${packet.reliable},
+	write = write${packet.name},
+	read = read${packet.name},
+})
+`;
+}
+
+function emitQueryLuau(query: FlareQuery): string {
+	const args = params(query.request);
+	return `-- query ${query.name} (#${query.id})
+local function write${query.name}Req(cursor${args ? `, ${args}` : ""})
+${writeFields(query.request)}
+end
+
+local function read${query.name}Req(cursor)
+${readFields(query.request)}
+end
+
+local function write${query.name}Res(cursor, value)
+	${WRITE[query.returns]("cursor", "value")}
+	return cursor
+end
+
+local function read${query.name}Res(cursor)
+	return ${READ[query.returns]("cursor")}
+end
+
+local ${query.name} = session.query({
+	id = ${query.id},
+	writeReq = write${query.name}Req,
+	readReq = read${query.name}Req,
+	writeRes = write${query.name}Res,
+	readRes = read${query.name}Res,
+})
+`;
+}
+
+export function emitFlareLuau(schema: FlareSchema): string {
+	const names = [...schema.packets.map((p) => p.name), ...schema.queries.map((q) => q.name)];
+	const body = [
+		...schema.packets.map(emitPacketLuau),
+		...schema.queries.map(emitQueryLuau),
+	].join("\n");
+	return `--!native
+--!optimize 2
+--!strict
+-- Generated by Cluaupp Flare from ${schema.sourcePath}
+-- Do not edit. Change the .flare schema and run cluaupp build.
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local Flare = require(ReplicatedStorage.CluauppLibs.Flare)
+
+local session = Flare.open(script)
+
+${body}
+return {
+${names.map((name) => `\t${name} = ${name},`).join("\n")}
+}
+`;
+}
+
+function emitPacketHeader(ns: string, packet: FlarePacket): string {
+	const data = clppParams(packet.fields);
+	const clientFire = data;
+	const serverFire = packet.from === "Server" ? data : "";
+	const struct = `${ns}${packet.name}`;
+	const lines = [`struct ${struct} {`];
+	if (packet.from === "Client") {
+		lines.push(`\tvoid FireServer(${clientFire});`);
+		lines.push(`\tRBXScriptConnection Connect(func fn);`);
+	} else {
+		lines.push(`\tvoid Fire(Player player${serverFire ? `, ${serverFire}` : ""});`);
+		lines.push(`\tvoid FireAll(${serverFire});`);
+		lines.push(`\tRBXScriptConnection Connect(func fn);`);
+	}
+	lines.push(`};`);
+	return lines.join("\n");
+}
+
+function emitQueryHeader(ns: string, query: FlareQuery): string {
+	const req = clppParams(query.request);
+	const ret = CLPP_TYPE[query.returns];
+	return `struct ${ns}${query.name} {
+	${ret} Invoke(${req});
+	void On(func fn);
+};`;
+}
+
+export function emitFlareHeader(schema: FlareSchema): string {
+	const ns = schema.name;
+	const structs = [
+		...schema.packets.map((packet) => emitPacketHeader(ns, packet)),
+		...schema.queries.map((query) => emitQueryHeader(ns, query)),
+	];
+	const fields = [
+		...schema.packets.map((packet) => `\t${ns}${packet.name} ${packet.name};`),
+		...schema.queries.map((query) => `\t${ns}${query.name} ${query.name};`),
+	];
+	return `#pragma once
+// cluaupp generated — do not edit. Change the .flare schema and run cluaupp build.
+// Generated by Cluaupp Flare from ${schema.sourcePath}
+// Tag + params in the .flare file. This header is IntelliSense; runtime is the generated .luau.
+
+${structs.join("\n\n")}
+
+struct ${ns} {
+${fields.join("\n")}
+};
+`;
+}
+
+export function emitFlare(schema: FlareSchema, relDir: string): FlareEmitResult {
+	const headerRel = `${relDir}${relDir.endsWith("/") || relDir === "" ? "" : "/"}${schema.name}.clh`.replace(/^\//, "");
+	const luauRel = `${relDir}${relDir.endsWith("/") || relDir === "" ? "" : "/"}${schema.name}.luau`.replace(/^\//, "");
+	return {
+		headerRel,
+		headerPath: headerRel,
+		header: emitFlareHeader(schema),
+		luauRel,
+		luau: emitFlareLuau(schema),
+	};
+}

package/src/flare/index.ts

@@ -0,0 +1,50 @@
+import fs from "node:fs";
+import path from "node:path";
+import { emitFlare } from "./emit.js";
+import { parseFlare } from "./parse.js";
+import type { FlareEmitResult, FlareSchema } from "./types.js";
+
+export type { FlareEmitResult, FlareSchema } from "./types.js";
+export { parseFlare } from "./parse.js";
+export { emitFlare, emitFlareHeader, emitFlareLuau } from "./emit.js";
+
+export function isFlareFile(fileName: string): boolean {
+	return path.extname(fileName).toLowerCase() === ".flare";
+}
+
+export function isGeneratedHeader(filePath: string): boolean {
+	if (path.extname(filePath).toLowerCase() !== ".clh") {
+		return false;
+	}
+	if (!fs.existsSync(filePath)) {
+		return false;
+	}
+	const head = fs.readFileSync(filePath, "utf8").slice(0, 400);
+	return /cluaupp generated/i.test(head);
+}
+
+export function collectFlareFiles(dir: string, files: string[] = []): string[] {
+	if (!fs.existsSync(dir)) {
+		return files;
+	}
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			collectFlareFiles(full, files);
+		} else if (isFlareFile(entry.name)) {
+			files.push(full);
+		}
+	}
+	return files;
+}
+
+export function compileFlareFile(file: string, srcDir: string): { schema: FlareSchema; emit: FlareEmitResult } {
+	const source = fs.readFileSync(file, "utf8");
+	const rel = path.relative(srcDir, file).replace(/\\/g, "/");
+	const stem = path.basename(file, path.extname(file));
+	const schema = parseFlare(source, rel, stem);
+	const relDir = path.posix.dirname(rel);
+	const dir = relDir === "." ? "" : relDir;
+	const emit = emitFlare(schema, dir);
+	return { schema, emit };
+}

package/src/flare/parse.ts

@@ -0,0 +1,147 @@
+import type { FlareField, FlareQuery, FlarePacket, FlareSchema, FlareSide, FlareType } from "./types.js";
+
+const TYPES: Record<string, FlareType> = {
+	u8: "u8",
+	u16: "u16",
+	u32: "u32",
+	i8: "i8",
+	i16: "i16",
+	i32: "i32",
+	int: "i32",
+	f32: "f32",
+	f64: "f64",
+	float: "f32",
+	double: "f64",
+	number: "f64",
+	bool: "bool",
+	boolean: "bool",
+	string: "string",
+	Vector3: "Vector3",
+	Vector2: "Vector2",
+	CFrame: "CFrame",
+	Color3: "Color3",
+	UDim: "UDim",
+	UDim2: "UDim2",
+	BrickColor: "BrickColor",
+	buffer: "buffer",
+	Instance: "Instance",
+	Player: "Player",
+};
+
+const IDENT = "[A-Za-z_][A-Za-z0-9_]*";
+
+function fail(file: string, line: number, message: string): never {
+	throw new Error(`cluaupp flare: ${file}:${line}: ${message}`);
+}
+
+function parseType(raw: string, file: string, line: number): FlareType {
+	const mapped = TYPES[raw];
+	if (!mapped) {
+		fail(file, line, `unknown type '${raw}'`);
+	}
+	return mapped;
+}
+
+function parseFields(list: string, file: string, line: number): FlareField[] {
+	const trimmed = list.trim();
+	if (!trimmed) {
+		return [];
+	}
+	const fields: FlareField[] = [];
+	for (const part of trimmed.split(",")) {
+		const piece = part.trim();
+		if (!piece) {
+			continue;
+		}
+		const match = piece.match(new RegExp(`^(${IDENT})\\s+(${IDENT})$`));
+		if (!match) {
+			fail(file, line, `expected 'Type name' in '${piece}'`);
+		}
+		fields.push({ type: parseType(match[1], file, line), name: match[2] });
+	}
+	return fields;
+}
+
+function parseSide(raw: string, file: string, line: number): FlareSide {
+	const side = raw.toLowerCase();
+	if (side === "client") {
+		return "Client";
+	}
+	if (side === "server") {
+		return "Server";
+	}
+	fail(file, line, `from must be Client or Server, got '${raw}'`);
+}
+
+export function parseFlare(source: string, filePath: string, defaultName: string): FlareSchema {
+	const file = filePath.replace(/\\/g, "/");
+	let name = defaultName;
+	const packets: FlarePacket[] = [];
+	const queries: FlareQuery[] = [];
+	let packetId = 1;
+	let queryId = 1;
+
+	const lines = String(source).replace(/\r\n/g, "\n").split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const lineNo = i + 1;
+		let line = lines[i].trim();
+		if (!line || line.startsWith("#") || line.startsWith("//")) {
+			continue;
+		}
+
+		const opt = line.match(/^opt\s+name\s*=\s*(.+)$/i);
+		if (opt) {
+			const value = opt[1].trim().replace(/^["']|["']$/g, "");
+			if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+				fail(file, lineNo, `opt name must be an identifier`);
+			}
+			name = value;
+			continue;
+		}
+
+		const packet = line.match(
+			new RegExp(
+				`^packet\\s+(${IDENT})\\s*\\((.*)\\)\\s+from\\s+(Client|Server)(?:\\s+(unreliable|reliable))?\\s*$`,
+				"i",
+			),
+		);
+		if (packet) {
+			const reliable = String(packet[4] || "reliable").toLowerCase() !== "unreliable";
+			if (packetId > 255) {
+				fail(file, lineNo, "too many packets (max 255)");
+			}
+			packets.push({
+				kind: "packet",
+				name: packet[1],
+				id: packetId++,
+				from: parseSide(packet[3], file, lineNo),
+				reliable,
+				fields: parseFields(packet[2], file, lineNo),
+			});
+			continue;
+		}
+
+		const query = line.match(new RegExp(`^query\\s+(${IDENT})\\s*\\((.*)\\)\\s*->\\s*(${IDENT})\\s*$`, "i"));
+		if (query) {
+			if (queryId > 255) {
+				fail(file, lineNo, "too many queries (max 255)");
+			}
+			queries.push({
+				kind: "query",
+				name: query[1],
+				id: queryId++,
+				request: parseFields(query[2], file, lineNo),
+				returns: parseType(query[3], file, lineNo),
+			});
+			continue;
+		}
+
+		fail(file, lineNo, `expected packet Tag(Type name, ...) from Client|Server or query Tag(...) -> Type`);
+	}
+
+	if (packets.length === 0 && queries.length === 0) {
+		fail(file, 1, "schema is empty — add a packet or query");
+	}
+
+	return { name, sourcePath: file, packets, queries };
+}

package/src/flare/types.ts

@@ -0,0 +1,61 @@
+export type FlareKind = "packet" | "query";
+export type FlareSide = "Client" | "Server";
+
+export type FlareType =
+	| "u8"
+	| "u16"
+	| "u32"
+	| "i8"
+	| "i16"
+	| "i32"
+	| "f32"
+	| "f64"
+	| "bool"
+	| "string"
+	| "Vector3"
+	| "Vector2"
+	| "CFrame"
+	| "Color3"
+	| "UDim"
+	| "UDim2"
+	| "BrickColor"
+	| "buffer"
+	| "Instance"
+	| "Player";
+
+export type FlareField = {
+	type: FlareType;
+	name: string;
+};
+
+export type FlarePacket = {
+	kind: "packet";
+	name: string;
+	id: number;
+	from: FlareSide;
+	reliable: boolean;
+	fields: FlareField[];
+};
+
+export type FlareQuery = {
+	kind: "query";
+	name: string;
+	id: number;
+	request: FlareField[];
+	returns: FlareType;
+};
+
+export type FlareSchema = {
+	name: string;
+	sourcePath: string;
+	packets: FlarePacket[];
+	queries: FlareQuery[];
+};
+
+export type FlareEmitResult = {
+	headerRel: string;
+	headerPath: string;
+	header: string;
+	luauRel: string;
+	luau: string;
+};

package/src/intellisense.ts

@@ -5,7 +5,7 @@ import { spawnSync } from "node:child_process";
 import { pkg, projectRoot as PACKAGE_ROOT } from "./package-info.js";
 import type { ProjectConfig } from "./types.js";
 import { CLPP_INSTALL_HINT } from "./clpp/contract.js";
-import { compileViaClpp, hasClpp } from "./clpp/runner.js";
+import { hasClpp } from "./clpp/runner.js";
 import { isSourceFile } from "./clpp/paths.js";
 
 export type CluauppDiagnostic = {
@@ -97,21 +97,10 @@ function writeVscode(root: string): void {
 	});
 }
 
-export function diagnosticsFor(source: string, fileName?: string): CluauppDiagnostic[] {
-	if (!hasClpp()) {
-		return [];
-	}
-	try {
-		compileViaClpp({ source, fileName: fileName || "input.clpp" });
-		return [];
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		const match = message.match(/:(\d+):(\d+):\s*(.*)$/);
-		if (match) {
-			return [{ line: Number(match[1]), col: Number(match[2]), message: match[3], severity: "error" }];
-		}
-		return [{ line: 1, col: 1, message, severity: "error" }];
-	}
+export function diagnosticsFor(_source?: string, _fileName?: string): CluauppDiagnostic[] {
+	// Language diagnostics belong to `clpp install`. Do not spawn `clpp api compile`
+	// from the editor — that duplicates source=clpp and freezes on every keystroke.
+	return [];
 }
 
 export function syncEditorSupport(root: string, _config: Partial<ProjectConfig> = {}): void {