cluaupp 1.5.2 → 2.0.0-beta.2

package/src/compiler/stdlib.ts

@@ -0,0 +1,256 @@
+/**
+ * CL++ standard library modules (`@clpp.axiom`, `@clpp.text`, `@clpp.math`, `@clpp.http`) on the
+ * Roblox target. Each function has a CL++ signature and a lowering: an inline Luau template using
+ * fast built-ins, or a call into the CluauppLibs runtime (`Axiom`) / a file-local helper.
+ *
+ * Templates use `$1…$n` for arguments; `@n` marks arguments that are evaluated more than once,
+ * so the emitter only inlines when those arguments are side-effect free.
+ */
+
+import { T, type FnParam, type Type } from "./types.js";
+
+export type StdModule = "axiom" | "text" | "math" | "http" | "json" | "time";
+
+export interface StdFunction {
+	name: string;
+	params: FnParam[];
+	ret: Type;
+	/** Inline Luau template, or null to call the runtime / helper. */
+	inline: string | null;
+	/** Helper (from runtime.ts) the lowering needs. */
+	helper?: string;
+	/** Runtime library member to call when not inlined. */
+	runtime?: string;
+}
+
+const typeOf: Record<string, Type> = {
+	float: T.float,
+	int: T.int,
+	bool: T.bool,
+	string: T.string,
+	Vector2: T.datatype("Vector2"),
+	Vector3: T.datatype("Vector3"),
+	Color3: T.datatype("Color3"),
+	CFrame: T.datatype("CFrame"),
+	UDim2: T.datatype("UDim2"),
+	floats: T.list(T.float),
+	strings: T.list(T.string),
+	list: T.list(T.any, false),
+	any: T.any,
+	strings2: T.list(T.string),
+};
+
+function sig(spec: string, inline: string | null, extra: Partial<StdFunction> = {}): StdFunction {
+	const m = /^(\w+)\(([^)]*)\)\s*->\s*(\w+)$/.exec(spec);
+	if (!m) {
+		throw new Error(`bad std signature ${spec}`);
+	}
+	const params = m[2]
+		.split(",")
+		.map((p) => p.trim())
+		.filter(Boolean)
+		.map((p, i) => {
+			const optional = p.endsWith("?");
+			const [tname, pname] = p.replace("?", "").split(/\s+/);
+			return { name: pname || `p${i}`, type: typeOf[tname] ?? T.any, optional };
+		});
+	return { name: m[1], params, ret: typeOf[m[3]] ?? T.void, inline, ...extra };
+}
+
+const AXIOM: StdFunction[] = [
+	sig("Clamp(float value, float min, float max) -> float", "math.min(math.max($1, $2), $3)"),
+	sig("Map(float value, float inMin, float inMax, float outMin, float outMax) -> float", null),
+	sig("Wrap(float value, float min, float max) -> float", null),
+	sig("Sign(float value) -> float", "math.sign($1)"),
+	sig("Round(float value, float places?) -> float", null),
+	sig("Snap(float value, float step) -> float", null),
+	sig("PingPong(float t, float length) -> float", null),
+	sig("Saturate(float value) -> float", "math.min(math.max($1, 0), 1)"),
+	sig("Fract(float value) -> float", "@1 - math.floor(@1)"),
+	sig("InvLerp(float from, float to, float value) -> float", null),
+	sig("Approach(float current, float target, float maxDelta) -> float", null),
+	sig("IsFinite(float value) -> bool", "@1 == @1 and @1 ~= math.huge and @1 ~= -math.huge"),
+	sig("Abs(float value) -> float", "math.abs($1)"),
+	sig("Min(float a, float b) -> float", "math.min($1, $2)"),
+	sig("Max(float a, float b) -> float", "math.max($1, $2)"),
+	sig("Pow(float base, float exp) -> float", "$1 ^ $2"),
+	sig("Sqrt(float value) -> float", "math.sqrt($1)"),
+	sig("Cbrt(float value) -> float", null),
+	sig("Hypot(float a, float b) -> float", "math.sqrt(@1 * @1 + @2 * @2)"),
+	sig("Log(float value) -> float", "math.log($1)"),
+	sig("Log2(float value) -> float", "math.log($1, 2)"),
+	sig("Log10(float value) -> float", "math.log10($1)"),
+	sig("Exp(float value) -> float", "math.exp($1)"),
+	sig("Smoothstep(float edge0, float edge1, float x) -> float", null),
+	sig("Smootherstep(float edge0, float edge1, float x) -> float", null),
+	sig("Gcd(float a, float b) -> float", null),
+	sig("Lcm(float a, float b) -> float", null),
+	sig("IsEven(float value) -> bool", "$1 % 2 == 0"),
+	sig("IsOdd(float value) -> bool", "$1 % 2 == 1"),
+	sig("IsNaN(float value) -> bool", "@1 ~= @1"),
+	sig("Factorial(float n) -> float", null),
+	sig("Scale(float value, float index) -> float", null),
+	sig("Lerp(float from, float to, float alpha) -> float", "@1 + (@2 - @1) * $3"),
+	sig("LerpClamped(float from, float to, float alpha) -> float", "@1 + (@2 - @1) * math.min(math.max($3, 0), 1)"),
+	sig("LerpVector2(Vector2 from, Vector2 to, float alpha) -> Vector2", "$1:Lerp($2, $3)"),
+	sig("LerpVector3(Vector3 from, Vector3 to, float alpha) -> Vector3", "$1:Lerp($2, $3)"),
+	sig("LerpVector(Vector3 from, Vector3 to, float alpha) -> Vector3", "$1:Lerp($2, $3)"),
+	sig("LerpColor3(Color3 from, Color3 to, float alpha) -> Color3", "$1:Lerp($2, $3)"),
+	sig("LerpCFrame(CFrame from, CFrame to, float alpha) -> CFrame", "$1:Lerp($2, $3)"),
+	sig("SlerpCFrame(CFrame from, CFrame to, float alpha) -> CFrame", "$1:Lerp($2, $3)"),
+	sig("LerpUDim2(UDim2 from, UDim2 to, float alpha) -> UDim2", "$1:Lerp($2, $3)"),
+	sig("LerpAngle(float from, float to, float alpha) -> float", null),
+	sig("Inverse(float from, float to, float value) -> float", null),
+	sig("Project(Vector3 a, Vector3 b) -> Vector3", null),
+	sig("Reject(Vector3 a, Vector3 b) -> Vector3", null),
+	sig("Reflect(Vector3 incident, Vector3 normal) -> Vector3", null),
+	sig("Angle(Vector3 a, Vector3 b) -> float", "$1:Angle($2)"),
+	sig("Distance(Vector3 a, Vector3 b) -> float", "($2 - $1).Magnitude"),
+	sig("Distance2(Vector2 a, Vector2 b) -> float", "($2 - $1).Magnitude"),
+	sig("Orthonormal(Vector3 forward, Vector3 up?) -> Vector3", null),
+	sig("Slerp(Vector3 a, Vector3 b, float t) -> Vector3", null),
+	sig("LookAt(Vector3 from, Vector3 target) -> Vector3", null),
+	sig("Flat(Vector3 value) -> Vector3", null),
+	sig("Dot(Vector3 a, Vector3 b) -> float", "$1:Dot($2)"),
+	sig("Cross(Vector3 a, Vector3 b) -> Vector3", "$1:Cross($2)"),
+	sig("Length(Vector3 v) -> float", "$1.Magnitude"),
+	sig("Normalize(Vector3 v) -> Vector3", null),
+	sig("CubicBezier(float t, Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3) -> Vector3", null),
+	sig("QuadraticBezier(float t, Vector3 p0, Vector3 p1, Vector3 p2) -> Vector3", null),
+	sig("Hover(float t, Vector3 base, Vector3 amplitude) -> Vector3", null),
+	sig("Float(float t, Vector3 base, Vector3 amplitude) -> Vector3", null),
+	sig("FloatSpin(float t, Vector3 base) -> Vector3", null),
+	sig("AabbContains(Vector3 point, Vector3 min, Vector3 max) -> bool", null),
+	sig("SphereContains(Vector3 point, Vector3 center, float radius) -> bool", "($1 - $2).Magnitude <= $3"),
+	sig("RayPlane(Vector3 origin, Vector3 dir, Vector3 point, Vector3 normal) -> Vector3", null),
+	sig("Barycentric(Vector3 p, Vector3 a, Vector3 b, Vector3 c) -> Vector3", null),
+	sig("ClosestPointOnSegment(Vector3 p, Vector3 a, Vector3 b) -> Vector3", null),
+	sig("Deg(float rad) -> float", "math.deg($1)"),
+	sig("Rad(float deg) -> float", "math.rad($1)"),
+	sig("DeltaAngle(float from, float to) -> float", null),
+	sig("AngleDiff(float from, float to) -> float", null),
+	sig("DeltaAngleDegrees(float from, float to) -> float", null),
+	sig("NormalizeAngle(float angle) -> float", null),
+	sig("Sin(float x) -> float", "math.sin($1)"),
+	sig("Cos(float x) -> float", "math.cos($1)"),
+	sig("Tan(float x) -> float", "math.tan($1)"),
+	sig("Asin(float x) -> float", "math.asin($1)"),
+	sig("Acos(float x) -> float", "math.acos($1)"),
+	sig("Atan2(float y, float x) -> float", "math.atan2($1, $2)"),
+	sig("RandomRange(float min, float max) -> float", null),
+	sig("Random(float min, float max) -> float", null),
+	sig("Weighted(floats weights) -> int", null),
+	sig("Gaussian(float mean?, float std?) -> float", null),
+	sig("Average(floats values) -> float", null),
+	sig("Sum(floats values) -> float", null),
+	sig("HashU32(float n) -> int", null),
+	sig("Value1(float x) -> float", null),
+	sig("Value2(float x, float y) -> float", null),
+	sig("Value3(float x, float y, float z) -> float", null),
+	sig("FromHSV(float h, float s, float v) -> Color3", "Color3.fromHSV($1, $2, $3)"),
+	sig("Contrast(Color3 color, float amount) -> Color3", null),
+	sig("LerpHSV(Color3 a, Color3 b, float t) -> Color3", null),
+	sig("Floor(float value) -> float", "math.floor($1)"),
+	sig("Ceil(float value) -> float", "math.ceil($1)"),
+	sig("Trunc(float value) -> float", null),
+	sig("Pi() -> float", "math.pi"),
+];
+
+const TEXT: StdFunction[] = [
+	sig("trim(string text) -> string", null, { helper: "trim" }),
+	sig("lower(string text) -> string", "string.lower($1)"),
+	sig("upper(string text) -> string", "string.upper($1)"),
+	sig("contains(string text, string part) -> bool", "string.find($1, $2, 1, true) ~= nil"),
+	sig("split(string text, string separator) -> strings", "string.split($1, $2)"),
+	sig("replace(string text, string target, string replacement) -> string", null, { helper: "replace" }),
+	sig("startsWith(string text, string part) -> bool", "string.sub($1, 1, #@2) == @2"),
+	sig("endsWith(string text, string part) -> bool", null, { helper: "endsWith" }),
+	sig("repeat(string text, int count) -> string", "string.rep($1, $2)"),
+	sig("toNumber(string text) -> float", null, { helper: "toNumber" }),
+	sig("indexOf(string text, string part) -> int", null, { helper: "indexOf" }),
+	sig("joinAll(list parts, string separator) -> string", null, { helper: "joinAll" }),
+];
+
+const MATH: StdFunction[] = [sig("abs(float n) -> float", "math.abs($1)")];
+
+const HTTP: StdFunction[] = [sig("host(string url) -> string", null, { helper: "urlHost" })];
+
+/** @clpp.json on Roblox: HttpService JSONEncode/JSONDecode plus dotted-path helpers. */
+const JSON_FNS: StdFunction[] = [
+	sig("Parse(string text) -> any", null, { helper: "jsonParse" }),
+	sig("Valid(string text) -> bool", null, { helper: "jsonValid" }),
+	sig("Stringify(any value) -> string", null, { helper: "jsonStringify" }),
+	sig("Pretty(any value) -> string", null, { helper: "jsonPretty" }),
+	sig("Get(any value, string path) -> any", null, { helper: "jsonGet" }),
+	sig("Has(any value, string path) -> bool", null, { helper: "jsonHas" }),
+	sig("Set(any target, string key, any value) -> any", null, { helper: "jsonSet" }),
+	sig("Object() -> any", "{}"),
+	sig("Keys(any object) -> strings", null, { helper: "jsonKeys" }),
+];
+
+/** @clpp.time on Roblox: os.clock / DateTime / os.date / task.wait. */
+const TIME: StdFunction[] = [
+	sig("Now() -> float", "DateTime.now().UnixTimestampMillis / 1000"),
+	sig("Clock() -> float", "os.clock()"),
+	sig("Sleep(float ms) -> void", "task.wait($1 / 1000)"),
+	sig("Date() -> string", 'os.date("%Y-%m-%d")'),
+	sig("TimeOfDay() -> string", 'os.date("%H:%M:%S")'),
+	sig("Format(string pattern) -> string", "os.date($1)"),
+	sig("Year() -> int", 'os.date("*t").year'),
+	sig("Month() -> int", 'os.date("*t").month'),
+	sig("Day() -> int", 'os.date("*t").day'),
+	sig("Hour() -> int", 'os.date("*t").hour'),
+	sig("Minute() -> int", 'os.date("*t").min'),
+	sig("Second() -> int", 'os.date("*t").sec'),
+	sig("Weekday() -> int", 'os.date("*t").wday - 1'),
+	sig("DayOfYear() -> int", 'os.date("*t").yday'),
+];
+
+const MODULES: Record<StdModule, Map<string, StdFunction>> = {
+	axiom: new Map(AXIOM.map((f) => [f.name, f])),
+	text: new Map(TEXT.map((f) => [f.name, f])),
+	math: new Map(MATH.map((f) => [f.name, f])),
+	http: new Map(HTTP.map((f) => [f.name, f])),
+	json: new Map(JSON_FNS.map((f) => [f.name, f])),
+	time: new Map(TIME.map((f) => [f.name, f])),
+};
+
+for (const f of AXIOM) {
+	if (!f.inline) {
+		f.runtime = f.name;
+	}
+}
+
+/** Desktop-only CL++ modules and what to use on Roblox instead. */
+export const DESKTOP_ONLY: Record<string, string> = {
+	"@clpp.fs": "Roblox games have no file system; persist data with DataStoreService (or CluauppLibs Keep)",
+	"@clpp.os": "Roblox games have no process environment; use attributes or a config module",
+	"@clpp.window": "the Roblox client owns the window; use RunService.RenderStepped and UserInputService",
+	"@clpp.gfx": "draw with GUI objects (Frame, ImageLabel) or EditableImage",
+	"@clpp.ui": "build UI with ScreenGui/Frame/TextButton, or CluauppLibs Gleam",
+	"@clpp.gui": "build UI with ScreenGui instances, or the declarative CluauppLibs Gleam",
+	"@clpp.audio": "play Sound instances (SoundService) instead",
+	"@clpp.input": "read input with UserInputService/ContextActionService (scripts cannot drive the mouse)",
+	"@clpp.io": "there is no console input on Roblox; use print/warn",
+};
+
+export const STD_PATHS: Record<string, StdModule | "unsupported"> = {
+	"@clpp.axiom": "axiom",
+	"@clpp.Axion": "axiom",
+	"@clpp.mathutils": "axiom",
+	"@clpp.text": "text",
+	"@clpp.math": "math",
+	"@clpp.http": "http",
+	"@clpp.json": "json",
+	"@clpp.time": "time",
+	"@clpp.fs": "unsupported",
+	"@clpp.os": "unsupported",
+};
+
+export function stdModule(name: StdModule): Map<string, StdFunction> {
+	return MODULES[name];
+}
+
+export function stdFunctionType(f: StdFunction): Type {
+	return T.func(f.params, f.ret);
+}

package/src/compiler/types.ts

@@ -0,0 +1,313 @@
+/**
+ * CL++ type model for the Roblox host: the CL++ core types plus Roblox classes, datatypes,
+ * enums and signals. Types are plain immutable objects; struct/enum details live in registries
+ * keyed by `id` (`<moduleId>::<Name>`).
+ */
+
+export interface FnParam {
+	name: string;
+	type: Type;
+	optional: boolean;
+}
+
+export type Type =
+	| { k: "any" }
+	| { k: "unknown" }
+	| { k: "never" }
+	| { k: "void" }
+	| { k: "null" }
+	| { k: "int" }
+	| { k: "float" }
+	| { k: "bool" }
+	| { k: "string" }
+	| { k: "buffer" }
+	| { k: "thread" }
+	| { k: "lit"; value: string | number | boolean }
+	| { k: "list"; elem: Type; typed: boolean }
+	| { k: "dict"; key: Type; value: Type }
+	| { k: "tuple"; elems: Type[] }
+	| { k: "table"; fields: Record<string, Type> }
+	| { k: "struct"; id: string; name: string; args: Type[] }
+	| { k: "enum"; id: string; name: string }
+	| { k: "variant"; id: string; name: string; alternatives: Type[] }
+	| { k: "option"; inner: Type }
+	| { k: "result"; ok: Type; err: Type }
+	| { k: "task"; result: Type }
+	| { k: "func"; params: FnParam[]; ret: Type; variadic: Type | null; generics?: string[]; overloads?: Type[] }
+	| { k: "union"; members: Type[] }
+	| { k: "param"; name: string }
+	| { k: "instance"; cls: string; dm?: DataModelNode }
+	| { k: "datatype"; name: string }
+	| { k: "rbxEnumItem"; enumName: string }
+	| { k: "rbxEnum"; enumName: string }
+	| { k: "rbxEnums" }
+	| { k: "rbxSignal"; args: Type[] }
+	| { k: "clSignal"; params: Type[] | null }
+	| { k: "namespace"; ns: Namespace }
+	| { k: "infer"; resolved: Type | null };
+
+export type Namespace =
+	| { kind: "module"; moduleId: string; alias: string }
+	| { kind: "luauModule"; alias: string }
+	| { kind: "library"; name: string }
+	| { kind: "datatype"; name: string }
+	| { kind: "instanceStatic" }
+	| { kind: "struct"; id: string; name: string }
+	| { kind: "enum"; id: string; name: string }
+	| { kind: "clNamespace"; name: string; moduleId: string }
+	| { kind: "stdlib"; module: "axiom" | "text" | "math" | "http" | "json" | "time"; alias: string }
+	| { kind: "result" };
+
+/** A node of the typed DataModel (from the project layout): `game.ReplicatedStorage.Shared.Combat`. */
+export interface DataModelNode {
+	name: string;
+	className: string;
+	path: string[];
+	children: Map<string, DataModelNode>;
+	/** Absolute path of the `.clp` that compiles to this ModuleScript/Script, when known. */
+	sourceFile?: string;
+}
+
+export const T = {
+	any: { k: "any" } as Type,
+	unknown: { k: "unknown" } as Type,
+	never: { k: "never" } as Type,
+	void: { k: "void" } as Type,
+	null: { k: "null" } as Type,
+	int: { k: "int" } as Type,
+	float: { k: "float" } as Type,
+	bool: { k: "bool" } as Type,
+	string: { k: "string" } as Type,
+	buffer: { k: "buffer" } as Type,
+	thread: { k: "thread" } as Type,
+	instance: (cls: string): Type => ({ k: "instance", cls }),
+	datatype: (name: string): Type => ({ k: "datatype", name }),
+	list: (elem: Type, typed = true): Type => ({ k: "list", elem, typed }),
+	dict: (key: Type, value: Type): Type => ({ k: "dict", key, value }),
+	option: (inner: Type): Type => (inner.k === "option" || inner.k === "any" || inner.k === "unknown" || inner.k === "null" ? inner : { k: "option", inner }),
+	func: (params: FnParam[], ret: Type, variadic: Type | null = null): Type => ({ k: "func", params, ret, variadic }),
+};
+
+/** Follow solved inference slots. */
+export function prune(t: Type): Type {
+	let cur = t;
+	while (cur.k === "infer" && cur.resolved) {
+		cur = cur.resolved;
+	}
+	return cur;
+}
+
+export function isNumeric(t: Type): boolean {
+	const p = prune(t);
+	return p.k === "int" || p.k === "float" || (p.k === "lit" && typeof p.value === "number");
+}
+
+export function isIntLike(t: Type): boolean {
+	const p = prune(t);
+	return p.k === "int" || (p.k === "lit" && typeof p.value === "number" && Number.isInteger(p.value)) || p.k === "enum";
+}
+
+export function isDynamic(t: Type): boolean {
+	const p = prune(t);
+	return p.k === "any" || p.k === "unknown" || (p.k === "infer" && !p.resolved);
+}
+
+export function isStringLike(t: Type): boolean {
+	const p = prune(t);
+	return p.k === "string" || (p.k === "lit" && typeof p.value === "string");
+}
+
+export function isBoolLike(t: Type): boolean {
+	const p = prune(t);
+	return p.k === "bool" || (p.k === "lit" && typeof p.value === "boolean");
+}
+
+/** Widen literal types: `"Idle"` → string, `3` → int. */
+export function widen(t: Type): Type {
+	const p = prune(t);
+	if (p.k === "lit") {
+		if (typeof p.value === "string") {
+			return T.string;
+		}
+		if (typeof p.value === "boolean") {
+			return T.bool;
+		}
+		return Number.isInteger(p.value) ? T.int : T.float;
+	}
+	return p;
+}
+
+/** Remove `null`/option wrappers. */
+export function nonNull(t: Type): Type {
+	const p = prune(t);
+	if (p.k === "option") {
+		return p.inner;
+	}
+	if (p.k === "union") {
+		const members = p.members.filter((m) => prune(m).k !== "null");
+		return members.length === 1 ? members[0] : { k: "union", members };
+	}
+	return p;
+}
+
+export function isNullable(t: Type): boolean {
+	const p = prune(t);
+	return p.k === "option" || p.k === "null" || (p.k === "union" && p.members.some((m) => prune(m).k === "null"));
+}
+
+/** Tables that CL++ treats as values (copied on assignment). */
+export function isValueTable(t: Type): boolean {
+	const p = prune(t);
+	return p.k === "struct" || p.k === "list" || p.k === "dict" || p.k === "result";
+}
+
+export function sameType(a: Type, b: Type): boolean {
+	const x = prune(a);
+	const y = prune(b);
+	if (x === y) {
+		return true;
+	}
+	if (x.k !== y.k) {
+		return false;
+	}
+	switch (x.k) {
+		case "lit":
+			return x.value === (y as typeof x).value;
+		case "list":
+			return sameType(x.elem, (y as typeof x).elem);
+		case "dict":
+			return sameType(x.key, (y as typeof x).key) && sameType(x.value, (y as typeof x).value);
+		case "struct":
+			return x.id === (y as typeof x).id && x.args.length === (y as typeof x).args.length && x.args.every((a2, i) => sameType(a2, (y as typeof x).args[i]));
+		case "enum":
+		case "variant":
+			return x.id === (y as typeof x).id;
+		case "option":
+			return sameType(x.inner, (y as typeof x).inner);
+		case "result":
+			return sameType(x.ok, (y as typeof x).ok) && sameType(x.err, (y as typeof x).err);
+		case "task":
+			return sameType(x.result, (y as typeof x).result);
+		case "instance":
+			return x.cls === (y as typeof x).cls;
+		case "datatype":
+			return x.name === (y as typeof x).name;
+		case "rbxEnumItem":
+		case "rbxEnum":
+			return x.enumName === (y as typeof x).enumName;
+		case "param":
+			return x.name === (y as typeof x).name;
+		case "tuple":
+			return x.elems.length === (y as typeof x).elems.length && x.elems.every((e, i) => sameType(e, (y as typeof x).elems[i]));
+		case "union":
+			return x.members.length === (y as typeof x).members.length && x.members.every((m) => (y as typeof x).members.some((n) => sameType(m, n)));
+		default:
+			return true;
+	}
+}
+
+/** CL++ notation, for diagnostics and hover. */
+export function typeToString(t: Type, depth = 0): string {
+	const p = prune(t);
+	if (depth > 6) {
+		return "…";
+	}
+	const s = (x: Type) => typeToString(x, depth + 1);
+	switch (p.k) {
+		case "any":
+			return "any";
+		case "unknown":
+			return "unknown";
+		case "never":
+			return "never";
+		case "void":
+			return "void";
+		case "null":
+			return "null";
+		case "int":
+		case "float":
+		case "bool":
+		case "string":
+		case "buffer":
+		case "thread":
+			return p.k;
+		case "lit":
+			return typeof p.value === "string" ? JSON.stringify(p.value) : String(p.value);
+		case "list":
+			return p.typed ? `array<${s(p.elem)}>` : "list";
+		case "dict":
+			return `dictionary<${s(p.key)}, ${s(p.value)}>`;
+		case "tuple":
+			return `(${p.elems.map(s).join(", ")})`;
+		case "table":
+			return `{ ${Object.entries(p.fields).slice(0, 6).map(([k, v]) => `${k}: ${s(v)}`).join(", ")} }`;
+		case "struct":
+			return p.args.length ? `${p.name}<${p.args.map(s).join(", ")}>` : p.name;
+		case "enum":
+		case "variant":
+			return p.name;
+		case "option":
+			return `${s(p.inner)}?`;
+		case "result":
+			return `Result<${s(p.ok)}, ${s(p.err)}>`;
+		case "task":
+			return isDynamic(p.result) || p.result.k === "void" ? "task" : `task<${s(p.result)}>`;
+		case "func": {
+			const params = p.params.map((x) => `${s(x.type)}${x.optional ? "?" : ""}`);
+			if (p.variadic) {
+				params.push(`...${s(p.variadic)}`);
+			}
+			return `func(${params.join(", ")}) -> ${s(p.ret)}`;
+		}
+		case "union":
+			return p.members.map(s).join(" | ");
+		case "param":
+			return p.name;
+		case "instance":
+			return p.cls;
+		case "datatype":
+			return p.name;
+		case "rbxEnumItem":
+			return `Enum.${p.enumName}`;
+		case "rbxEnum":
+			return `Enum.${p.enumName} (enum)`;
+		case "rbxEnums":
+			return "Enum";
+		case "rbxSignal":
+			return `RBXScriptSignal<${p.args.map(s).join(", ")}>`;
+		case "clSignal":
+			return p.params ? `signal(${p.params.map(s).join(", ")})` : "signal";
+		case "namespace":
+			return nsToString(p.ns);
+		case "infer":
+			return "unknown";
+		default:
+			return "unknown";
+	}
+}
+
+function nsToString(ns: Namespace): string {
+	switch (ns.kind) {
+		case "module":
+		case "luauModule":
+			return `module ${ns.alias}`;
+		case "library":
+			return `library ${ns.name}`;
+		case "datatype":
+			return `${ns.name} (datatype)`;
+		case "instanceStatic":
+			return "Instance";
+		case "struct":
+			return `struct ${ns.name}`;
+		case "enum":
+			return `enum ${ns.name}`;
+		case "clNamespace":
+			return `namespace ${ns.name}`;
+		case "stdlib":
+			return `module ${ns.alias}`;
+		case "result":
+			return "Result";
+		default:
+			return "namespace";
+	}
+}

package/src/intellisense.ts

@@ -4,8 +4,6 @@ import path from "node:path";
 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 { hasClpp } from "./clpp/runner.js";
 import { isSourceFile } from "./clpp/paths.js";
 import { editorBin } from "./editor-install.js";
 
@@ -114,7 +112,7 @@ function writeVscode(root: string): void {
 }
 
 export function diagnosticsFor(_source?: string, _fileName?: string): CluauppDiagnostic[] {
-	// Language diagnostics belong to `clpp install`. Do not spawn `clpp api compile`
+	// CL++ diagnostics are reported by the compiler during build. Do not spawn a compiler
 	// from the editor — that duplicates source=clpp and freezes on every keystroke.
 	return [];
 }
@@ -204,16 +202,6 @@ export async function installEditorSupport() {
 			console.log(" ", dest);
 		}
 	}
-	if (hasClpp()) {
-		const result = spawnSync("clpp", ["install"], { encoding: "utf8", windowsHide: true });
-		if (result.status === 0) {
-			console.log(String(result.stderr || result.stdout || "clpp install ok").trim());
-		} else {
-			console.log("cluaupp:", CLPP_INSTALL_HINT);
-		}
-	} else {
-		console.log("cluaupp:", CLPP_INSTALL_HINT);
-	}
 	return { local };
 }
 

package/src/lsp.ts

@@ -61,7 +61,7 @@ function flareDiagnostics(document: TextDocument): Diagnostic[] {
 }
 
 export function start(_options: { projectRoot?: string } = {}): void {
-	const connection = createConnection(ProposedFeatures.all);
+	const connection = createConnection(ProposedFeatures.all, process.stdin, process.stdout);
 	const documents = new TextDocuments(TextDocument);
 
 	connection.onInitialize(() => ({

package/src/target/build-cache.ts

@@ -8,12 +8,9 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
-export const COMPILE_CACHE_SCHEMA = 1 as const;
+export const COMPILE_CACHE_SCHEMA = 2 as const;
 
-export interface CachedArtifact {
-	name: string;
-	contents: string;
-}
+export type CachedArtifact = import("../types.js").CompiledArtifact;
 
 export interface CachedJob {
 	rel: string;
@@ -45,7 +42,7 @@ function indexPath(projectRoot: string): string {
 }
 
 function jobPath(projectRoot: string, rel: string): string {
-	const safe = rel.replace(/[\\/]/g, "__");
+	const safe = hashText(rel);
 	return path.join(compileCacheDir(projectRoot), `${safe}.json`);
 }
 
@@ -56,7 +53,7 @@ export function loadCompileCacheIndex(projectRoot: string): CompileCacheIndex {
 	}
 	try {
 		const raw = JSON.parse(fs.readFileSync(file, "utf8")) as CompileCacheIndex;
-		if (!raw || typeof raw.entries !== "object") {
+		if (!raw || raw.schemaVersion !== COMPILE_CACHE_SCHEMA || !raw.entries || typeof raw.entries !== "object" || Array.isArray(raw.entries)) {
 			return { schemaVersion: COMPILE_CACHE_SCHEMA, entries: {} };
 		}
 		return { schemaVersion: COMPILE_CACHE_SCHEMA, entries: raw.entries };
@@ -82,7 +79,7 @@ export function readCachedJob(projectRoot: string, rel: string, sourceHash: stri
 	}
 	try {
 		const job = JSON.parse(fs.readFileSync(file, "utf8")) as CachedJob;
-		if (!job || job.sourceHash !== sourceHash || !Array.isArray(job.files)) {
+		if (!job || job.rel !== rel || job.sourceHash !== sourceHash || !Array.isArray(job.files) || !job.files.every(f => typeof f.name === "string" && typeof f.contents === "string")) {
 			return null;
 		}
 		return job;