@kumikijs/compiler 0.2.1 → 0.3.0

package/dist/index.d.ts

@@ -286,6 +286,14 @@ type Expr = {
   base: Expr;
   field: string;
   pos: Pos;
+  /**
+   * Dispatch decision filled in by the type checker (ADR-002): `"field"`
+   * means the receiver is a record with this field, so codegen lowers a
+   * field read instead of a method shortcut (kills the #23 shadow). Absent /
+   * `"shortcut"` keeps the name-based shortcut dispatch (back-compat — also
+   * the case when codegen runs without `check()`).
+   */
+  accessKind?: "field" | "shortcut";
 } | {
   kind: "Index";
   base: Expr;
@@ -463,6 +471,28 @@ type CodegenOptions = {
   includeTests?: boolean;
 };
 declare function codegen(program: Program, opts: CodegenOptions): string;
+/**
+ * Methods the code generator actually implements (the `methodCallJs` switch
+ * cases below). This is the single source of truth for what `obj.method(...)`
+ * calls are runnable; the typechecker uses it to flag unimplemented methods
+ * (E0801) at `check` time instead of letting them throw or misbehave at runtime.
+ * Keep this in exact sync with the `switch (method)` cases.
+ */
+declare const KNOWN_METHODS: ReadonlySet<string>;
+/**
+ * The method names codegen lowers in the parenthesis-free `recv.m` (FieldAccess)
+ * form — kept in sync with the `if (e.field === …)` chain in jsOfExpr's
+ * FieldAccess case. A subset of KNOWN_METHODS (enforced by a test): every
+ * no-paren shortcut must also accept the `recv.m()` shape.
+ */
+declare const FIELD_ACCESS_SHORTCUTS: ReadonlySet<string>;
+/**
+ * Every member name the runtime understands on a stdlib receiver — the union of
+ * the method-call methods and the no-paren shortcuts. Used by the type checker
+ * (ADR-002) to decide whether `recv.m` on a *known* receiver type is a real
+ * member (→ shortcut) or an unknown one (→ E0108). Flat, not per-type.
+ */
+declare const KNOWN_MEMBERS: ReadonlySet<string>;
 declare const RUNTIME_HELPERS = "\nfunction _setPath(obj, path, value) {\n  if (path.length === 0) return value;\n  const [head, ...rest] = path;\n  const cur = obj ?? {};\n  return { ...cur, [head]: _setPath(cur[head], rest, value) };\n}\nfunction _children(...xs) {\n  const out = [];\n  for (const x of xs) {\n    if (x === null || x === undefined) continue;\n    if (Array.isArray(x)) {\n      for (const y of x) if (y !== null && y !== undefined) out.push(y);\n    } else {\n      out.push(x);\n    }\n  }\n  return out;\n}\nfunction _attachProps(node, props) {\n  if (!node || !props) return node;\n  return { ...node, props: { ...(node.props || {}), ...props } };\n}\n";
 //#endregion
 //#region src/typecheck.d.ts
@@ -519,4 +549,4 @@ declare class ParseError extends Error {
 }
 declare function parse(tokens: Token[]): Program;
 //#endregion
-export { type AppDef, type BinOp, type CapabilityManifest, type CodegenOptions, type CompileFail, type CompileOk, type CompileResult, type Def, type EffectDef, type EventPattern, type Expr, type ExtendedCodegenOptions, type FnDef, type KumikiError, type Lvalue, type ManifestResult, type MatchArm, type MotionDef, ParseError, type Pattern, type PolicyExpr, type Pos, type Program, RUNTIME_HELPERS, type ReducerDef, type Refinement, type RetryExpr, STANDARD_CAPABILITIES, type SlotDef, type Statement, type TestDef, type ThemeDef, type ThemeValue, type TileArg, type TileDef, type TileExpr, type TileMatchArm, type TileProp, type Token, type TypeDef, type TypeExpr, type UiEventKind, check, codegen, compile, inlineRuntime, lex, parse, parseCapabilityManifest };
+export { type AppDef, type BinOp, type CapabilityManifest, type CodegenOptions, type CompileFail, type CompileOk, type CompileResult, type Def, type EffectDef, type EventPattern, type Expr, type ExtendedCodegenOptions, FIELD_ACCESS_SHORTCUTS, type FnDef, KNOWN_MEMBERS, KNOWN_METHODS, type KumikiError, type Lvalue, type ManifestResult, type MatchArm, type MotionDef, ParseError, type Pattern, type PolicyExpr, type Pos, type Program, RUNTIME_HELPERS, type ReducerDef, type Refinement, type RetryExpr, STANDARD_CAPABILITIES, type SlotDef, type Statement, type TestDef, type ThemeDef, type ThemeValue, type TileArg, type TileDef, type TileExpr, type TileMatchArm, type TileProp, type Token, type TypeDef, type TypeExpr, type UiEventKind, check, codegen, compile, inlineRuntime, lex, parse, parseCapabilityManifest };

package/dist/index.js

@@ -373,6 +373,7 @@ function jsOfExpr(e, ctx) {
 		case "UnaryOp": return `(${e.op === "!" ? "!" : "-"}${jsOfExpr(e.rhs, ctx)})`;
 		case "FieldAccess": {
 			const baseJs = jsOfExpr(e.base, ctx);
+			if (e.accessKind === "field") return `(${baseJs})[${JSON.stringify(e.field)}]`;
 			if (e.field === "get") return `_s.unwrap(${baseJs})`;
 			if (e.field === "is-some") return `(_s.variantIs(${baseJs}, "Some"))`;
 			if (e.field === "is-none") return `(_s.variantIs(${baseJs}, "None"))`;
@@ -432,6 +433,7 @@ function jsOfExpr(e, ctx) {
 				const args = e.args.map((a) => jsOfExpr(a, ctx));
 				return `_s.fmt ? _s.fmt(${args.join(", ")}) : ${args[0] ?? "\"\""}`;
 			}
+			if (cn === "panic") return `_s.panic(${e.args[0] ? jsOfExpr(e.args[0], ctx) : "\"\""})`;
 			const args = e.args.map((a) => jsOfExpr(a, ctx)).join(", ");
 			return `${jsName(cn)}(${args})`;
 		}
@@ -518,8 +520,63 @@ const KNOWN_METHODS = new Set([
 	"abs",
 	"neg",
 	"to-float",
+	"to-int",
+	"is-ok",
+	"is-err",
+	"values",
+	"entries",
+	"lower",
+	"upper",
+	"sort",
+	"ms"
+]);
+/**
+* The method names codegen lowers in the parenthesis-free `recv.m` (FieldAccess)
+* form — kept in sync with the `if (e.field === …)` chain in jsOfExpr's
+* FieldAccess case. A subset of KNOWN_METHODS (enforced by a test): every
+* no-paren shortcut must also accept the `recv.m()` shape.
+*/
+const FIELD_ACCESS_SHORTCUTS = new Set([
+	"get",
+	"is-some",
+	"is-none",
+	"is-ok",
+	"is-err",
+	"keys",
+	"values",
+	"entries",
+	"size",
+	"to-ms",
+	"ms",
+	"show",
+	"length",
+	"is-empty",
+	"lower",
+	"upper",
+	"trim",
+	"unique",
+	"reverse",
+	"sort",
+	"head",
+	"tail",
+	"last",
+	"to-list",
+	"get-err",
+	"to-option",
+	"parse-int",
+	"parse-float",
+	"abs",
+	"neg",
+	"to-float",
 	"to-int"
 ]);
+/**
+* Every member name the runtime understands on a stdlib receiver — the union of
+* the method-call methods and the no-paren shortcuts. Used by the type checker
+* (ADR-002) to decide whether `recv.m` on a *known* receiver type is a real
+* member (→ shortcut) or an unknown one (→ E0108). Flat, not per-type.
+*/
+const KNOWN_MEMBERS = new Set([...KNOWN_METHODS, ...FIELD_ACCESS_SHORTCUTS]);
 function methodCallJs(recv, method, args, ctx) {
 	const inner = makeEvalCtx(ctx.gen, ctx.localBinds);
 	inner.localBinds.add("$1");
@@ -3310,9 +3367,13 @@ function checkSlot(slot, sym, errors) {
 function checkTile(tile, sym, errors) {
 	const ctx = {
 		kind: "tile",
-		localBinds: /* @__PURE__ */ new Set()
+		localBinds: /* @__PURE__ */ new Set(),
+		localTypes: /* @__PURE__ */ new Map()
 	};
-	if (tile.in) ctx.localBinds.add("$1");
+	if (tile.in) {
+		ctx.localBinds.add("$1");
+		ctx.localTypes?.set("$1", tile.in);
+	}
 	checkTileExpr(tile.body, sym, errors, ctx);
 }
 function checkA11y(t, errors) {
@@ -3351,7 +3412,8 @@ function checkTileExpr(t, sym, errors, ctx) {
 			checkExpr(t.iter, sym, errors, ctx);
 			const inner = {
 				...ctx,
-				localBinds: new Set(ctx.localBinds)
+				localBinds: new Set(ctx.localBinds),
+				localTypes: new Map(ctx.localTypes ?? [])
 			};
 			inner.localBinds.add(t.bind);
 			checkTileExpr(t.body, sym, errors, inner);
@@ -3371,7 +3433,8 @@ function checkTileExpr(t, sym, errors, ctx) {
 			for (const arm of t.arms) {
 				const inner = {
 					...ctx,
-					localBinds: new Set(ctx.localBinds)
+					localBinds: new Set(ctx.localBinds),
+					localTypes: new Map(ctx.localTypes ?? [])
 				};
 				if (arm.pattern.kind === "PVariant") for (const b of arm.pattern.binds) inner.localBinds.add(b);
 				if (arm.pattern.kind === "PBind") inner.localBinds.add(arm.pattern.name);
@@ -3469,7 +3532,8 @@ function checkStmt(s, sym, errors, ctx, writtenRoots) {
 		checkExpr(s.iter, sym, errors, ctx);
 		const inner = {
 			...ctx,
-			localBinds: new Set(ctx.localBinds)
+			localBinds: new Set(ctx.localBinds),
+			localTypes: new Map(ctx.localTypes ?? [])
 		};
 		inner.localBinds.add(s.bind);
 		const bodyWrites = new Set(writtenRoots);
@@ -3493,7 +3557,8 @@ function checkStmt(s, sym, errors, ctx, writtenRoots) {
 		for (const arm of s.arms) {
 			const inner = {
 				...ctx,
-				localBinds: new Set(ctx.localBinds)
+				localBinds: new Set(ctx.localBinds),
+				localTypes: new Map(ctx.localTypes ?? [])
 			};
 			if (arm.pattern.kind === "PVariant") {
 				for (const b of arm.pattern.binds) if (b !== "_") inner.localBinds.add(b);
@@ -3510,6 +3575,11 @@ function checkStmt(s, sym, errors, ctx, writtenRoots) {
 	if (s.kind === "LetStmt") {
 		checkExpr(s.rhs, sym, errors, ctx);
 		ctx.localBinds.add(s.name);
+		const rt = inferType(s.rhs, sym, ctx);
+		if (rt) {
+			if (!ctx.localTypes) ctx.localTypes = /* @__PURE__ */ new Map();
+			ctx.localTypes.set(s.name, rt);
+		}
 		return;
 	}
 	if (s.kind === "Emit") {
@@ -3615,6 +3685,7 @@ function checkExpr(e, sym, errors, ctx) {
 			return;
 		case "FieldAccess":
 			checkExpr(e.base, sym, errors, ctx);
+			classifyFieldAccess(e, sym, errors, ctx);
 			return;
 		case "Index":
 			checkExpr(e.base, sym, errors, ctx);
@@ -3634,7 +3705,8 @@ function checkExpr(e, sym, errors, ctx) {
 			for (const a of e.args) {
 				const inner = {
 					...ctx,
-					localBinds: new Set(ctx.localBinds)
+					localBinds: new Set(ctx.localBinds),
+					localTypes: new Map(ctx.localTypes ?? [])
 				};
 				inner.localBinds.add("$1");
 				inner.localBinds.add("$2");
@@ -3658,7 +3730,8 @@ function checkExpr(e, sym, errors, ctx) {
 			for (const arm of e.arms) {
 				const inner = {
 					...ctx,
-					localBinds: new Set(ctx.localBinds)
+					localBinds: new Set(ctx.localBinds),
+					localTypes: new Map(ctx.localTypes ?? [])
 				};
 				if (arm.pattern.kind === "PVariant") {
 					for (const b of arm.pattern.binds) if (b !== "_") inner.localBinds.add(b);
@@ -3676,21 +3749,180 @@ function checkExpr(e, sym, errors, ctx) {
 			checkExpr(e.value, sym, errors, ctx);
 			const inner = {
 				...ctx,
-				localBinds: new Set(ctx.localBinds)
+				localBinds: new Set(ctx.localBinds),
+				localTypes: new Map(ctx.localTypes ?? [])
 			};
 			inner.localBinds.add(e.name);
+			const vt = inferType(e.value, sym, inner);
+			if (vt) inner.localTypes?.set(e.name, vt);
 			checkExpr(e.body, sym, errors, inner);
 			return;
 		}
 	}
 }
+const SCALAR_PRIMS = new Set([
+	"Int",
+	"Float",
+	"Text",
+	"Bool",
+	"Time",
+	"Bytes"
+]);
+const STDLIB_CONTAINERS = new Set([
+	"List",
+	"Map",
+	"Set",
+	"Option",
+	"Result"
+]);
+/** Unwrap type aliases (`TypeRef` → its `TypeDef` body) and nominal/refinement wrappers. */
+function unaliasType(t, sym, seen = /* @__PURE__ */ new Set()) {
+	if (!t) return null;
+	if (t.kind === "TypeRef") {
+		if (seen.has(t.name)) return null;
+		const def = sym.types.get(t.name);
+		if (!def) return t;
+		seen.add(t.name);
+		return unaliasType(def.body, sym, seen);
+	}
+	if (t.kind === "TypeNominal" || t.kind === "TypeRefinement") return unaliasType(t.inner, sym, seen);
+	return t;
+}
+function recordFieldType(rec, name) {
+	return rec.fields.find((f) => f.name === name)?.type ?? null;
+}
+const unitType = (pos) => ({
+	kind: "TypePrim",
+	name: "Unit",
+	pos
+});
+/** Best-effort static type of an expression; `null` = undecidable / dynamic. */
+function inferType(e, sym, ctx) {
+	switch (e.kind) {
+		case "Num": return {
+			kind: "TypePrim",
+			name: "Int",
+			pos: e.pos
+		};
+		case "Str": return {
+			kind: "TypePrim",
+			name: "Text",
+			pos: e.pos
+		};
+		case "Bool": return {
+			kind: "TypePrim",
+			name: "Bool",
+			pos: e.pos
+		};
+		case "Ref": {
+			const bound = ctx.localTypes?.get(e.name);
+			if (bound) return bound;
+			return sym.slots.get(e.name)?.type ?? null;
+		}
+		case "FieldAccess": {
+			const base = unaliasType(inferType(e.base, sym, ctx), sym);
+			if (!base) return null;
+			if (base.kind === "TypeRecord") return recordFieldType(base, e.field);
+			if (e.field === "get" && base.kind === "TypeApp" && (base.name === "Option" || base.name === "Result")) return base.args[0] ?? null;
+			return null;
+		}
+		case "Index": {
+			const base = unaliasType(inferType(e.base, sym, ctx), sym);
+			if (base?.kind === "TypeApp") {
+				if (base.name === "List" || base.name === "Set") return base.args[0] ?? null;
+				if (base.name === "Map") return base.args[1] ?? null;
+			}
+			return null;
+		}
+		case "MethodCall":
+			if (e.method === "get") {
+				const recv = unaliasType(inferType(e.receiver, sym, ctx), sym);
+				if (recv?.kind === "TypeApp") {
+					if (recv.name === "Map") return recv.args[1] ? {
+						kind: "TypeApp",
+						name: "Option",
+						args: [recv.args[1]],
+						pos: e.pos
+					} : null;
+					if (recv.name === "Option" || recv.name === "Result") return recv.args[0] ?? null;
+				}
+			}
+			return null;
+		case "RecordLit": return {
+			kind: "TypeRecord",
+			fields: e.fields.map((f) => ({
+				name: f.name,
+				type: inferType(f.value, sym, ctx) ?? unitType(f.value.pos)
+			})),
+			pos: e.pos
+		};
+		case "Variant": {
+			const inner = e.payload[0] ? inferType(e.payload[0], sym, ctx) ?? unitType(e.pos) : unitType(e.pos);
+			if (e.name === "Some" || e.name === "None") return {
+				kind: "TypeApp",
+				name: "Option",
+				args: [inner],
+				pos: e.pos
+			};
+			if (e.name === "Ok") return {
+				kind: "TypeApp",
+				name: "Result",
+				args: [inner],
+				pos: e.pos
+			};
+			return null;
+		}
+		default: return null;
+	}
+}
+/**
+* Decide whether `recv.field` is a record field read or a method shortcut, and
+* annotate the node so codegen lowers the right thing (ADR-002). Emits E0108
+* when the receiver type is KNOWN and `field` is neither a member nor a record
+* field; stays silent (shortcut) when the type is undecidable.
+*/
+function classifyFieldAccess(e, sym, errors, ctx) {
+	const t = unaliasType(inferType(e.base, sym, ctx), sym);
+	if (!t) return;
+	if (t.kind === "TypeRecord") {
+		if (recordFieldType(t, e.field)) {
+			e.accessKind = "field";
+			return;
+		}
+		if (e.field === "show") {
+			e.accessKind = "shortcut";
+			return;
+		}
+		errors.push({
+			code: "E0108",
+			kind: "undef-member",
+			message: `Record type has no field or method ".${e.field}"`,
+			pos: e.pos
+		});
+		return;
+	}
+	if (t.kind === "TypePrim" && SCALAR_PRIMS.has(t.name) || t.kind === "TypeApp" && STDLIB_CONTAINERS.has(t.name)) {
+		if (KNOWN_MEMBERS.has(e.field)) {
+			e.accessKind = "shortcut";
+			return;
+		}
+		const tn = t.kind === "TypeApp" ? t.name : t.name;
+		errors.push({
+			code: "E0108",
+			kind: "undef-member",
+			message: `Type "${tn}" has no member ".${e.field}"`,
+			pos: e.pos
+		});
+	}
+}
 function currentFnName(ctx) {
 	return ctx.fnName ?? "<fn>";
 }
 function checkFn(fn, sym, errors) {
 	const ctx = {
 		kind: "fn",
-		localBinds: /* @__PURE__ */ new Set()
+		localBinds: /* @__PURE__ */ new Set(),
+		localTypes: new Map(fn.params.map((p) => [p.name, p.type]))
 	};
 	ctx.fnName = fn.name;
 	for (const p of fn.params) ctx.localBinds.add(p.name);
@@ -3805,4 +4037,4 @@ function compile(source, opts) {
 	};
 }
 //#endregion
-export { ParseError, RUNTIME_HELPERS, STANDARD_CAPABILITIES, check, codegen, compile, inlineRuntime, lex, parse, parseCapabilityManifest };
+export { FIELD_ACCESS_SHORTCUTS, KNOWN_MEMBERS, KNOWN_METHODS, ParseError, RUNTIME_HELPERS, STANDARD_CAPABILITIES, check, codegen, compile, inlineRuntime, lex, parse, parseCapabilityManifest };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumikijs/compiler",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "type": "module",
   "description": "Kumiki compiler — lexer, parser, typechecker, and code generator.",
   "license": "Apache-2.0",
@@ -41,7 +41,7 @@
     "provenance": true
   },
   "dependencies": {
-    "@kumikijs/runtime": "0.2.1"
+    "@kumikijs/runtime": "0.3.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",