cluaupp 1.4.1 → 1.5.0

package/src/flare/parse.ts

@@ -1,6 +1,6 @@
 import type { FlareField, FlareQuery, FlarePacket, FlareSchema, FlareSide, FlareType } from "./types.js";
 
-const TYPES: Record<string, FlareType> = {
+export const FLARE_TYPE_ALIASES: Record<string, FlareType> = {
 	u8: "u8",
 	u16: "u16",
 	u32: "u32",
@@ -28,14 +28,14 @@ const TYPES: Record<string, FlareType> = {
 	Player: "Player",
 };
 
-const IDENT = "[A-Za-z_][A-Za-z0-9_]*";
+export const FLARE_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];
+	const mapped = FLARE_TYPE_ALIASES[raw];
 	if (!mapped) {
 		fail(file, line, `unknown type '${raw}'`);
 	}
@@ -53,7 +53,7 @@ function parseFields(list: string, file: string, line: number): FlareField[] {
 		if (!piece) {
 			continue;
 		}
-		const match = piece.match(new RegExp(`^(${IDENT})\\s+(${IDENT})$`));
+		const match = piece.match(new RegExp(`^(${FLARE_IDENT})\\s+(${FLARE_IDENT})$`));
 		if (!match) {
 			fail(file, line, `expected 'Type name' in '${piece}'`);
 		}
@@ -101,7 +101,7 @@ export function parseFlare(source: string, filePath: string, defaultName: string
 
 		const packet = line.match(
 			new RegExp(
-				`^packet\\s+(${IDENT})\\s*\\((.*)\\)\\s+from\\s+(Client|Server)(?:\\s+(unreliable|reliable))?\\s*$`,
+				`^packet\\s+(${FLARE_IDENT})\\s*\\((.*)\\)\\s+from\\s+(Client|Server)(?:\\s+(unreliable|reliable))?\\s*$`,
 				"i",
 			),
 		);
@@ -121,7 +121,7 @@ export function parseFlare(source: string, filePath: string, defaultName: string
 			continue;
 		}
 
-		const query = line.match(new RegExp(`^query\\s+(${IDENT})\\s*\\((.*)\\)\\s*->\\s*(${IDENT})\\s*$`, "i"));
+		const query = line.match(new RegExp(`^query\\s+(${FLARE_IDENT})\\s*\\((.*)\\)\\s*->\\s*(${FLARE_IDENT})\\s*$`, "i"));
 		if (query) {
 			if (queryId > 255) {
 				fail(file, lineNo, "too many queries (max 255)");

package/src/intellisense.ts

@@ -82,6 +82,7 @@ function writeVscode(root: string): void {
 		"*.server.clpp": "clpp",
 		"*.client.clpp": "clpp",
 		"*.plugin.clpp": "clpp",
+		"*.flare": "flare",
 	};
 	writeJson(settingsPath, {
 		...current,
@@ -92,7 +93,7 @@ function writeVscode(root: string): void {
 	const extensions = readJsonObject(extensionsPath);
 	writeJson(extensionsPath, {
 		...extensions,
-		recommendations: uniqueStrings(extensions.recommendations),
+		recommendations: uniqueStrings(extensions.recommendations, ["kartzdev.cluaupp-flare"]),
 		unwantedRecommendations: uniqueStrings(extensions.unwantedRecommendations, ["ms-vscode.cpptools"]),
 	});
 }
@@ -112,7 +113,7 @@ export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
 	if (!fs.existsSync(from)) {
 		return [];
 	}
-	const id = `kartzdev.cluaupp-diagnostics-${pkg.version}`;
+	const id = `kartzdev.cluaupp-flare-${pkg.version}`;
 	const homes = [path.join(os.homedir(), ".cursor", "extensions"), path.join(os.homedir(), ".vscode", "extensions")];
 	const installed: string[] = [];
 	for (const home of homes) {
@@ -123,6 +124,16 @@ export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
 		const dest = path.join(home, id);
 		copyDir(from, dest);
 		fs.writeFileSync(path.join(dest, "cluaupp.root"), path.resolve(cluauppRoot), "utf8");
+		const manifestPath = path.join(dest, "package.json");
+		if (fs.existsSync(manifestPath)) {
+			try {
+				const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as Record<string, unknown>;
+				manifest.version = pkg.version;
+				fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, "\t")}\n`, "utf8");
+			} catch {
+				// keep the copied manifest
+			}
+		}
 		installed.push(dest);
 	}
 	return installed;
@@ -130,6 +141,12 @@ export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
 
 export async function installEditorSupport() {
 	const local = installEditorExtension();
+	if (local.length > 0) {
+		console.log("cluaupp: Flare IntelliSense installed");
+		for (const dest of local) {
+			console.log(" ", dest);
+		}
+	}
 	if (hasClpp()) {
 		const result = spawnSync("clpp", ["install"], { encoding: "utf8", windowsHide: true });
 		if (result.status === 0) {

package/src/lsp.ts

@@ -1,30 +1,173 @@
 import {
-	createConnection,
+	CompletionItemKind,
+	DiagnosticSeverity,
+	MarkupKind,
+	ParameterInformation,
 	ProposedFeatures,
+	SignatureInformation,
+	SymbolKind,
 	TextDocuments,
 	TextDocumentSyncKind,
+	createConnection,
+	type CompletionItem,
+	type Diagnostic,
+	type DocumentSymbol,
+	type Hover,
+	type SignatureHelp,
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
+import {
+	completionsAt,
+	hoverAt,
+	isFlareDocument,
+	signatureAt,
+	symbolsIn,
+	diagnoseFlare,
+	type FlareCompletionKind,
+	type FlareSeverity,
+} from "./flare/language.js";
 import { pkg } from "./package-info.js";
 
+const KIND: Record<FlareCompletionKind, CompletionItemKind> = {
+	keyword: CompletionItemKind.Keyword,
+	type: CompletionItemKind.TypeParameter,
+	snippet: CompletionItemKind.Snippet,
+	value: CompletionItemKind.EnumMember,
+	field: CompletionItemKind.Field,
+};
+
+const SEVERITY: Record<FlareSeverity, DiagnosticSeverity> = {
+	error: DiagnosticSeverity.Error,
+	warning: DiagnosticSeverity.Warning,
+	hint: DiagnosticSeverity.Hint,
+};
+
+const SYMBOL: Record<"packet" | "query" | "option", SymbolKind> = {
+	packet: SymbolKind.Event,
+	query: SymbolKind.Method,
+	option: SymbolKind.Namespace,
+};
+
+function flareDiagnostics(document: TextDocument): Diagnostic[] {
+	return diagnoseFlare(document.getText(), document.uri).map((item) => ({
+		range: {
+			start: { line: item.line, character: item.start },
+			end: { line: item.line, character: Math.max(item.end, item.start + 1) },
+		},
+		message: item.message,
+		severity: SEVERITY[item.severity],
+		source: "flare",
+	}));
+}
+
 export function start(_options: { projectRoot?: string } = {}): void {
 	const connection = createConnection(ProposedFeatures.all);
 	const documents = new TextDocuments(TextDocument);
 
 	connection.onInitialize(() => ({
 		capabilities: {
-			textDocumentSync: TextDocumentSyncKind.Full,
+			textDocumentSync: TextDocumentSyncKind.Incremental,
+			completionProvider: {
+				triggerCharacters: [" ", "(", ",", ">", "="],
+				resolveProvider: false,
+			},
+			hoverProvider: true,
+			documentSymbolProvider: true,
+			signatureHelpProvider: {
+				triggerCharacters: ["(", ","],
+			},
 		},
-		serverInfo: { name: "cluaupp", version: pkg.version },
+		serverInfo: { name: "cluaupp-flare", version: pkg.version },
 	}));
 
-	const clear = (uri: string) => {
-		connection.sendDiagnostics({ uri, diagnostics: [] });
+	const publish = (document: TextDocument) => {
+		if (!isFlareDocument(document.uri)) {
+			connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
+			return;
+		}
+		connection.sendDiagnostics({ uri: document.uri, diagnostics: flareDiagnostics(document) });
 	};
 
-	documents.onDidOpen((event) => clear(event.document.uri));
-	documents.onDidChangeContent((event) => clear(event.document.uri));
-	documents.onDidClose((event) => clear(event.document.uri));
+	documents.onDidOpen((event) => publish(event.document));
+	documents.onDidChangeContent((event) => publish(event.document));
+	documents.onDidClose((event) => {
+		connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
+	});
+
+	connection.onCompletion((params): CompletionItem[] => {
+		const document = documents.get(params.textDocument.uri);
+		if (!document || !isFlareDocument(document.uri)) {
+			return [];
+		}
+		return completionsAt(document.getText(), params.position.line, params.position.character).map((item) => ({
+			label: item.label,
+			kind: KIND[item.kind],
+			detail: item.detail,
+			documentation: { kind: MarkupKind.Markdown, value: item.documentation },
+			insertText: item.insertText,
+			insertTextFormat: item.snippet ? 2 : 1,
+			sortText: item.sortText,
+		}));
+	});
+
+	connection.onHover((params): Hover | null => {
+		const document = documents.get(params.textDocument.uri);
+		if (!document || !isFlareDocument(document.uri)) {
+			return null;
+		}
+		const hover = hoverAt(document.getText(), params.position.line, params.position.character);
+		if (!hover) {
+			return null;
+		}
+		return {
+			contents: { kind: MarkupKind.Markdown, value: hover.contents },
+			range: {
+				start: { line: params.position.line, character: hover.start },
+				end: { line: params.position.line, character: hover.end },
+			},
+		};
+	});
+
+	connection.onDocumentSymbol((params): DocumentSymbol[] => {
+		const document = documents.get(params.textDocument.uri);
+		if (!document || !isFlareDocument(document.uri)) {
+			return [];
+		}
+		return symbolsIn(document.getText()).map((symbol) => ({
+			name: symbol.name,
+			detail: symbol.detail,
+			kind: SYMBOL[symbol.kind],
+			range: {
+				start: { line: symbol.line, character: 0 },
+				end: { line: symbol.line, character: Math.max(symbol.end, 1) },
+			},
+			selectionRange: {
+				start: { line: symbol.line, character: symbol.start },
+				end: { line: symbol.line, character: Math.max(symbol.end, symbol.start + 1) },
+			},
+		}));
+	});
+
+	connection.onSignatureHelp((params): SignatureHelp | null => {
+		const document = documents.get(params.textDocument.uri);
+		if (!document || !isFlareDocument(document.uri)) {
+			return null;
+		}
+		const signature = signatureAt(document.getText(), params.position.line, params.position.character);
+		if (!signature) {
+			return null;
+		}
+		const info = SignatureInformation.create(
+			signature.label,
+			signature.documentation,
+			...signature.parameters.map((parameter) => ParameterInformation.create(parameter.label, parameter.documentation)),
+		);
+		return {
+			signatures: [info],
+			activeSignature: 0,
+			activeParameter: signature.activeParameter,
+		};
+	});
 
 	documents.listen(connection);
 	connection.listen();

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

@@ -2,5 +2,7 @@
 	"unwantedRecommendations": [
 		"ms-vscode.cpptools"
 	],
-	"recommendations": []
+	"recommendations": [
+		"kartzdev.cluaupp-flare"
+	]
 }

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

@@ -5,6 +5,7 @@
 		"*.clh": "clpp",
 		"*.server.clpp": "clpp",
 		"*.client.clpp": "clpp",
-		"*.plugin.clpp": "clpp"
+		"*.plugin.clpp": "clpp",
+		"*.flare": "flare"
 	}
 }

package/templates/game/include/clpp/libs/roster.clh

@@ -5,7 +5,10 @@
 // Table = u16 count + key/value pairs. Array = u16 len + values. Methods also work as Roster::X(rawTable).
 
 struct Roster {
+	// Construct with `new Roster()` / `new Roster(table)` — emits Luau Roster.new.
+	// `New` is the CL++ name because `new` is a keyword.
 	static Roster New();
+	static Roster New(auto initial);
 
 	int Size();
 	int Length();
@@ -13,6 +16,7 @@ struct Roster {
 	auto GetData();
 
 	auto At(int index);
+	// Array value search (1-based index). Dictionary keys: Has / Get / Set / Remove.
 	int Find(auto value);
 	int Find(auto value, int initPos);
 	int Find(auto value, int initPos, int maxPos);
@@ -23,6 +27,7 @@ struct Roster {
 	auto Shift();
 	int Unshift(auto value);
 	auto RemoveAt(int index);
+	Roster Remove(auto key);
 
 	Roster Map(func mapper);
 	Roster Filter(func predicate);
@@ -74,6 +79,7 @@ struct Roster {
 	static auto Shift(auto data);
 	static int Unshift(auto data, auto value);
 	static auto RemoveAt(auto data, int index);
+	static Roster Remove(auto data, auto key);
 	static Roster Map(auto data, func mapper);
 	static Roster Filter(auto data, func predicate);
 	static auto Reduce(auto data, func reducer, auto initial);

package/templates/game/src/ReplicatedStorage/Shared/Net/Net.flare

@@ -0,0 +1,5 @@
+opt name = Net
+
+packet Ready() from Client
+packet Welcome(i32 userId, f64 clock) from Server
+query Session() -> i32

package/templates/game/src/ServerScriptService/Boot/DataBoot.server.clpp

@@ -4,7 +4,7 @@
 #include "../../ReplicatedStorage/Shared/Constants/Datas/TemplateData.clh"
 
 void init() {
-	PlayerTemplate playerData;
+	PlayerTemplate playerData = PlayerTemplate();
 	Keep.Server.Init(DataServiceOptions {
 		.Template = playerData,
 		.StoreName = "PlayerData",