@venn-lang/core 0.1.0

package/src/typecheck/builtins.ts

@@ -0,0 +1,267 @@
+import type { TypeContext } from "./context.js";
+import {
+  BOOL,
+  baseOf,
+  callback,
+  DYNAMIC,
+  type FnType,
+  fn,
+  list,
+  NUMBER,
+  prim,
+  type RecordType,
+  STRING,
+  type Type,
+  type TypeVar,
+  type UnionType,
+  union,
+} from "./type.types.js";
+import { prune } from "./unify.js";
+
+/**
+ * The type of a built-in member: a property such as `length`, or a generic
+ * method such as `map`.
+ *
+ * These are where generics earn their keep. `list<T>.map` is
+ * `fn(fn(T, number) -> U) -> list<U>`, with a fresh `U` per use.
+ *
+ * @returns undefined when the receiver's type has no such member, so the caller
+ * can fall back to a record field or to `dynamic`.
+ */
+export function memberType(receiver: Type, name: string, ctx: TypeContext): Type | undefined {
+  const t = prune(receiver);
+  if (t.kind === "list") return listMember(t.element, name, ctx);
+  if (t.kind === "literal") return memberType(prim(baseOf(t.value)), name, ctx);
+  if (t.kind === "union") return unionMember(t, name, ctx);
+  if (t.kind === "prim" && t.name === "string") return stringMember(name);
+  if (t.kind === "prim" && t.name === "number") return numberMember(name);
+  if (t.kind === "record") return recordMember(t, name);
+  if (t.kind === "prim") return unitMember(t.name, name);
+  // A handle answers to what it published, and to nothing else: its inside is
+  // none of the reader's business, which is what makes it opaque.
+  if (t.kind === "opaque") return t.members?.get(name);
+  return undefined;
+}
+
+/**
+ * A member of a union is a member of every branch, or of none.
+ *
+ * Offering what only one branch has would be a lie the moment the value is the
+ * other one.
+ */
+function unionMember(type: UnionType, name: string, ctx: TypeContext): Type | undefined {
+  const found = type.members.map((member) => memberType(member, name, ctx));
+  if (found.some((member) => member === undefined)) return undefined;
+  return union(found as Type[]);
+}
+
+const DURATION: Type = { kind: "prim", name: "duration" };
+const SIZE: Type = { kind: "prim", name: "size" };
+const PERCENT: Type = { kind: "prim", name: "percent" };
+
+/**
+ * Reading a unit back as a plain number, in whichever unit you want it. The unit
+ * exists to keep `300ms + 2mb` from type-checking; once you are printing or
+ * comparing against raw data, these are the way across.
+ */
+const UNIT_MEMBERS: Record<string, Record<string, Type>> = {
+  duration: { ms: NUMBER, seconds: NUMBER, minutes: NUMBER, hours: NUMBER },
+  size: { bytes: NUMBER, kb: NUMBER, mb: NUMBER, gb: NUMBER },
+  percent: { ratio: NUMBER, percent: NUMBER, of: fn([NUMBER], NUMBER) },
+};
+
+function unitMember(unit: string, name: string): Type | undefined {
+  return UNIT_MEMBERS[unit]?.[name];
+}
+
+function listMember(element: Type, name: string, ctx: TypeContext): Type | undefined {
+  const u = (): TypeVar => ctx.fresh();
+  const self = list(element);
+  /** Every list callback is handed the index too; `p => p.age` may ignore it. */
+  const over = (result: Type): FnType => callback([element, NUMBER], result, 1);
+  const predicate = over(BOOL);
+  const table: Record<string, () => Type> = {
+    len: () => NUMBER,
+    first: () => element,
+    last: () => element,
+    reverse: () => self,
+    flatten: () => list(DYNAMIC),
+    isEmpty: () => BOOL,
+    sum: () => NUMBER,
+    average: () => NUMBER,
+    min: () => NUMBER,
+    max: () => NUMBER,
+    toMap: () => DYNAMIC,
+    // Selecting keeps the element type; only the shape of the result changes.
+    take: () => fn([NUMBER], self),
+    drop: () => fn([NUMBER], self),
+    takeLast: () => fn([NUMBER], self),
+    dropLast: () => fn([NUMBER], self),
+    takeWhile: () => fn([predicate], self),
+    dropWhile: () => fn([predicate], self),
+    distinct: () => self,
+    distinctBy: () => fn([over(u())], self),
+    sortBy: () => fn([over(u())], self),
+    minBy: () => fn([over(NUMBER)], element),
+    maxBy: () => fn([over(NUMBER)], element),
+    sumBy: () => fn([over(NUMBER)], NUMBER),
+    flatMap: () => flatMapType(over, u()),
+    // Grouping changes the shape: a list becomes a map, or a list of lists.
+    groupBy: () => fn([over(DYNAMIC)], DYNAMIC),
+    countBy: () => fn([over(DYNAMIC)], DYNAMIC),
+    keyBy: () => fn([over(DYNAMIC)], DYNAMIC),
+    partition: () => fn([predicate], list(self)),
+    chunk: () => fn([NUMBER], list(self)),
+    windows: () => fn([NUMBER], list(self)),
+    pairwise: () => list(self),
+    zip: () => fn([list(DYNAMIC)], list(list(DYNAMIC))),
+    unzip: () => list(list(DYNAMIC)),
+    map: () => mapType(over, u()),
+    filter: () => fn([predicate], list(element)),
+    find: () => fn([predicate], element),
+    some: () => fn([predicate], BOOL),
+    every: () => fn([predicate], BOOL),
+    forEach: () => fn([over(DYNAMIC)], NULL_VOID),
+    reduce: () => reduceType(element, u(), NUMBER),
+    contains: () => fn([element], BOOL),
+    indexOf: () => fn([element], NUMBER),
+    join: () => fn([STRING], STRING),
+    sort: () => fn([fn([element, element], NUMBER)], list(element)),
+    slice: () => fn([NUMBER, NUMBER], list(element)),
+    concat: () => fn([list(element)], list(element)),
+    push: () => fn([element], list(element)),
+  };
+  return table[name]?.();
+}
+
+const NULL_VOID = { kind: "prim", name: "null" } as const;
+
+/** The callback shape a list method hands its element to. */
+type Over = (result: Type) => FnType;
+
+function mapType(over: Over, into: Type): Type {
+  return fn([over(into)], list(into));
+}
+
+function flatMapType(over: Over, into: Type): Type {
+  return fn([over(list(into))], list(into));
+}
+
+/** `reduce` hands over the running total, the item, and the index. */
+function reduceType(element: Type, acc: Type, index: Type): Type {
+  return fn([callback([acc, element, index], acc, 2), acc], acc);
+}
+
+function stringMember(name: string): Type | undefined {
+  const table: Record<string, Type> = {
+    len: NUMBER,
+    upper: STRING,
+    lower: STRING,
+    trim: STRING,
+    reverse: STRING,
+    toNumber: NUMBER,
+    split: fn([STRING], list(STRING)),
+    replace: fn([STRING, STRING], STRING),
+    contains: fn([STRING], BOOL),
+    startsWith: fn([STRING], BOOL),
+    endsWith: fn([STRING], BOOL),
+    slice: fn([NUMBER, NUMBER], STRING),
+    repeat: fn([NUMBER], STRING),
+    padStart: fn([NUMBER, STRING], STRING),
+    padEnd: fn([NUMBER, STRING], STRING),
+    indexOf: fn([STRING], NUMBER),
+    words: list(STRING),
+    lines: list(STRING),
+    chars: list(STRING),
+    capitalize: STRING,
+    title: STRING,
+    slugify: STRING,
+    isEmpty: BOOL,
+    isBlank: BOOL,
+    trimStart: STRING,
+    trimEnd: STRING,
+    count: fn([STRING], NUMBER),
+    matches: fn([STRING], list(STRING)),
+    test: fn([STRING], BOOL),
+    before: fn([STRING], STRING),
+    after: fn([STRING], STRING),
+    ensureStart: fn([STRING], STRING),
+    ensureEnd: fn([STRING], STRING),
+  };
+  return table[name];
+}
+
+function numberMember(name: string): Type | undefined {
+  const table: Record<string, Type> = {
+    abs: NUMBER,
+    floor: NUMBER,
+    ceil: NUMBER,
+    sign: NUMBER,
+    sqrt: NUMBER,
+    isEven: BOOL,
+    isOdd: BOOL,
+    round: fn([NUMBER], NUMBER),
+    toFixed: fn([NUMBER], STRING),
+    clamp: fn([NUMBER, NUMBER], NUMBER),
+    pow: fn([NUMBER], NUMBER),
+    times: list(NUMBER),
+    toString: STRING,
+  };
+  return table[name] ?? TO_UNIT[name];
+}
+
+/**
+ * Reading a plain number as a unit, the way back from {@link UNIT_MEMBERS}. For
+ * every `X` a unit answers to, a number answers to `toX`.
+ */
+const TO_UNIT: Record<string, Type> = {
+  toMs: DURATION,
+  toSeconds: DURATION,
+  toMinutes: DURATION,
+  toHours: DURATION,
+  toBytes: SIZE,
+  toKb: SIZE,
+  toMb: SIZE,
+  toGb: SIZE,
+  toRatio: PERCENT,
+  toPercent: PERCENT,
+};
+
+function recordMember(receiver: RecordType, name: string): Type | undefined {
+  const table: Record<string, Type> = {
+    keys: list(STRING),
+    values: list(DYNAMIC),
+    entries: list(DYNAMIC),
+    len: NUMBER,
+    has: fn([STRING], BOOL),
+    get: fn([STRING], DYNAMIC),
+    merge: fn([DYNAMIC], DYNAMIC),
+    mergeDeep: fn([DYNAMIC], DYNAMIC),
+    // A map's callbacks are handed the key alongside the value, or the other
+    // way round for `mapKeys`. Taking the second one is optional.
+    mapValues: fn([callback([DYNAMIC, STRING], DYNAMIC, 1)], DYNAMIC),
+    mapKeys: fn([callback([STRING, DYNAMIC], STRING, 1)], DYNAMIC),
+    filterValues: fn([callback([DYNAMIC, STRING], BOOL, 1)], DYNAMIC),
+    pick: fn([STRING], DYNAMIC),
+    omit: fn([STRING], DYNAMIC),
+    invert: DYNAMIC,
+    isEmpty: BOOL,
+    getPath: fn([STRING], DYNAMIC),
+    hasPath: fn([STRING], BOOL),
+  };
+  return receiver.fields.has(name) ? undefined : table[name];
+}
+
+/**
+ * A member as the language reads it: the built-in when there is one, otherwise
+ * the field the map carries.
+ *
+ * {@link memberType} alone stops at built-ins so inference can report an unknown
+ * field. Tooling wants the answer, not the distinction.
+ */
+export function resolveMember(receiver: Type, name: string, ctx: TypeContext): Type | undefined {
+  const built = memberType(receiver, name, ctx);
+  if (built) return built;
+  const t = prune(receiver);
+  return t.kind === "record" ? t.fields.get(name) : undefined;
+}

package/src/typecheck/catalog.types.ts

@@ -0,0 +1,16 @@
+import type { FnType, Type } from "./type.types.js";
+
+/**
+ * What the checker knows that the file itself does not: the types the loaded
+ * plugins contribute.
+ *
+ * The core has no idea what a plugin is, and must not: it asks this interface
+ * two questions and takes the answers. Whoever owns the registry, the runtime or
+ * the language server, is the one that can answer them.
+ */
+export interface TypeCatalog {
+  /** A named type: `http.Request`. Undefined when nothing declares it. */
+  typeOf(name: string): Type | undefined;
+  /** A verb's signature: `http.serve`, `http.on`. */
+  signatureOf(target: string): FnType | undefined;
+}

package/src/typecheck/check-deco.ts

@@ -0,0 +1,174 @@
+import { walkAst } from "../ast/index.js";
+import { buildProblem, CODES } from "../codes/index.js";
+import { acceptedKinds, readSignature, spanOf, wrongKind } from "../expand/index.js";
+import type { Annotation, DecoDecl, Document, Expr, Param } from "../generated/ast.js";
+import { isAnnotation, isDecoDecl } from "../generated/ast.js";
+import type { Problem } from "../problem/index.js";
+import { checkBlock } from "./check-stmts.js";
+import { expect, type Infer, inferExpr } from "./infer.js";
+import { mono } from "./scheme.js";
+import { DYNAMIC, type Type } from "./type.types.js";
+import { emptyEnv, type TypeEnv } from "./type-env.js";
+import { typeRefToType } from "./type-ref.js";
+
+/**
+ * A `deco`'s body, checked the way a `fn`'s is.
+ *
+ * The kind on the first parameter is a real type, so the body holds a typed
+ * handle: hovering `target` says `Fn`, completing `target.` offers what an `Fn`
+ * offers, and the checker knows what `target.params` is without anyone teaching
+ * it a second vocabulary.
+ */
+export function checkDecoBody(decl: DecoDecl, env: TypeEnv, infer: Infer): void {
+  let scope = env;
+  for (const param of decl.params?.params ?? []) {
+    const type = decoParamType(param, infer);
+    infer.types?.set(param, type);
+    scope = scope.with(param.name, mono(type));
+  }
+  checkBlock(decl.body, scope, infer);
+}
+
+/**
+ * What a `deco`'s parameter is.
+ *
+ * An unwritten one stays `dynamic` rather than an open question: a decorator's
+ * arguments arrive from every `@name(…)` in the file, and letting the first use
+ * decide for all of them would turn the second into an error nobody made.
+ */
+function decoParamType(param: Param, infer: Infer): Type {
+  if (!param.paramType) return DYNAMIC;
+  const { ctx, named, catalog } = infer;
+  return typeRefToType({ ref: param.paramType, ctx, named, catalog });
+}
+
+/**
+ * What a document's `deco`s answer for statically: a signature that reads, and
+ * arguments that match it.
+ *
+ * The signature is read with the very reader expansion uses, so the sentence
+ * `venn check` prints is the sentence a run prints. Expansion does not happen
+ * here (the checker looks at the program as written), which is why the signature
+ * is read twice, and read the same.
+ */
+export function checkDecos(args: { document: Document; infer: Infer; uri: string }): Problem[] {
+  const problems: Problem[] = [];
+  for (const decl of args.document.decls.filter(isDecoDecl)) {
+    const read = readSignature(decl);
+    if (!read.ok) problems.push(signatureProblem(decl, read.title, args.uri));
+  }
+  return [...problems, ...checkUses({ ...args, declared: args.infer.decos ?? new Map() })];
+}
+
+/**
+ * Every `deco` a use site in this file could name, local or imported, keyed by
+ * the name an `@` writes. Only the ones whose signature reads, since a use of a
+ * broken one has nothing to be checked against.
+ *
+ * An imported one contributes no VN2015 of its own: that is the other file's
+ * fault, reported when the other file is checked, and a span into a document
+ * this run never opened would point nowhere.
+ */
+export function decosInReach(args: {
+  document: Document;
+  imported?: ReadonlyMap<string, { readonly decl: DecoDecl }>;
+}): Map<string, DecoDecl> {
+  const found = new Map<string, DecoDecl>();
+  for (const [name, from] of args.imported ?? []) {
+    if (readSignature(from.decl).ok) found.set(name, from.decl);
+  }
+  for (const decl of args.document.decls.filter(isDecoDecl)) {
+    if (readSignature(decl).ok) found.set(decl.name, decl);
+  }
+  return found;
+}
+
+function signatureProblem(decl: DecoDecl, title: string, uri: string): Problem {
+  return buildProblem({ spec: CODES.VN2015_DECO_SIGNATURE, span: spanOf(decl, uri), title });
+}
+
+/** Everything a use site needs to be checked against the `deco` it names. */
+interface Uses {
+  document: Document;
+  infer: Infer;
+  uri: string;
+  declared: ReadonlyMap<string, DecoDecl>;
+}
+
+function checkUses(args: Uses): Problem[] {
+  if (args.declared.size === 0) return [];
+  const problems: Problem[] = [];
+  for (const node of walkAst(args.document)) {
+    if (isAnnotation(node)) problems.push(...checkUse(node, args));
+  }
+  return problems;
+}
+
+/**
+ * `@retry(3)` against `deco retry(target: Flow, times: number)`: is it on
+ * something it decorates, and were it given what it asks for.
+ */
+function checkUse(annotation: Annotation, args: Uses): Problem[] {
+  const decl = args.declared.get(annotation.name);
+  if (!decl) return [];
+  const wrong = misplaced(annotation, decl, args.uri);
+  return wrong ? [wrong] : checkArgs(annotation, decl, args);
+}
+
+/**
+ * The very refusal expansion would make, made while the file is still open.
+ *
+ * A run reaches it too, and with the same sentence, because both ask
+ * {@link wrongKind}. `venn check` never expands, so this is the only place the
+ * type error a signature exists to produce reaches an editor.
+ */
+function misplaced(annotation: Annotation, decl: DecoDecl, uri: string): Problem | undefined {
+  const node = annotation.$container;
+  const title = node && wrongKind({ name: annotation.name, kinds: acceptedKinds(decl), node });
+  if (!title) return undefined;
+  const spec = CODES.VN2014_DECORATOR_TARGET;
+  return buildProblem({ spec, span: spanOf(annotation, uri), title });
+}
+
+/**
+ * The arguments are read against an empty scope on purpose: they are part of the
+ * shape of the program and not of its execution, so nothing exists yet for a
+ * name inside one to refer to. That is the same reason a bare word there is a
+ * word and not a variable.
+ */
+function checkArgs(annotation: Annotation, decl: DecoDecl, args: Uses): Problem[] {
+  const params = (decl.params?.params ?? []).slice(1);
+  const given = annotation.args?.args ?? [];
+  if (given.length !== params.length) {
+    return [arityProblem({ annotation, params, given, uri: args.uri })];
+  }
+  for (const [at, arg] of given.entries()) checkArg(arg.value, params[at], args.infer);
+  return [];
+}
+
+function checkArg(value: Expr, param: Param | undefined, infer: Infer): void {
+  if (!param) return;
+  expect(infer, value, inferExpr(value, emptyEnv(), infer), decoParamType(param, infer));
+}
+
+function arityProblem(args: {
+  annotation: Annotation;
+  params: readonly Param[];
+  given: readonly unknown[];
+  uri: string;
+}): Problem {
+  const title = arityTitle(args.annotation.name, args.params.length, args.given.length);
+  return buildProblem({
+    spec: CODES.VN3017_DECO_ARGUMENTS,
+    span: spanOf(args.annotation, args.uri),
+    title,
+  });
+}
+
+function arityTitle(name: string, want: number, got: number): string {
+  return `@${name} takes ${wanted(want)}, and was given ${got === 0 ? "none" : got}.`;
+}
+
+function wanted(count: number): string {
+  return count === 0 ? "no arguments" : `${count} argument${count === 1 ? "" : "s"}`;
+}

package/src/typecheck/check-stmts.ts

@@ -0,0 +1,151 @@
+import { callArgs } from "../ast/index.js";
+import type { Block, Expr, FragmentDecl, Statement } from "../generated/ast.js";
+import * as ast from "../generated/ast.js";
+import { callType } from "./action-signature.js";
+import { expect, type Infer, inferExpr } from "./infer.js";
+import { mono } from "./scheme.js";
+import { DYNAMIC, type Type } from "./type.types.js";
+import type { TypeEnv } from "./type-env.js";
+import { typeRefToType } from "./type-ref.js";
+import { prune } from "./unify.js";
+
+/** Walk a statement, inferring the expressions it contains under `env`. */
+export function checkStatement(node: Statement, env: TypeEnv, infer: Infer): TypeEnv {
+  if (ast.isLetStmt(node)) return bindLet(node, env, infer);
+  if (ast.isExpectStmt(node)) return expectStmt(node, env, infer);
+  if (ast.isActionCall(node)) return actionArgs(node, env, infer);
+  if (ast.isRunStmt(node)) return runArgs(node, env, infer);
+  if (ast.isIfStmt(node)) return ifStmt(node, env, infer);
+  if (ast.isForEachStmt(node)) return forEach(node, env, infer);
+  if (ast.isWhileStmt(node)) return blockAfterCond(node.cond, node.body, env, infer);
+  if (ast.isRepeatStmt(node)) return repeat(node, env, infer);
+  if (ast.isTryStmt(node)) return tryStmt(node, env, infer);
+  if (ast.isReturnStmt(node)) return maybeInfer(node.value, env, infer);
+  if (ast.isStepDecl(node) || ast.isGroupDecl(node)) return nested(node.body, env, infer);
+  if (ast.isParallelStmt(node) || ast.isRaceStmt(node)) return nested(node.body, env, infer);
+  if (ast.isLifecycleDecl(node)) return nested(node.body, env, infer);
+  return env;
+}
+
+/** Check a nested block, then keep the outer scope: its bindings do not escape. */
+function nested(block: Block, env: TypeEnv, infer: Infer): TypeEnv {
+  checkBlock(block, env, infer);
+  return env;
+}
+
+/** A `let`/`const` binds its inferred type; the binding is visible from here on. */
+function bindLet(node: ast.LetStmt, env: TypeEnv, infer: Infer): TypeEnv {
+  const type = isCall(node) ? boundCall(node, env, infer) : inferExpr(node.value, env, infer);
+  const declared = declaredTypeOf(node, infer);
+  // An annotation the checker parses and never reads is worse than no
+  // annotation: the author believes something is being enforced.
+  if (declared) expect(infer, node.value, type, declared);
+  // Record it on the declaration too, so a hover on the name knows the type.
+  infer.types?.set(node, declared ?? type);
+  return env.with(node.name, mono(declared ?? type));
+}
+
+function declaredTypeOf(node: ast.LetStmt, infer: Infer): Type | undefined {
+  if (!node.declaredType) return undefined;
+  const { ctx, named, catalog } = infer;
+  return typeRefToType({ ref: node.declaredType, ctx, named, catalog });
+}
+
+/** Trailing arguments or an options map are what make a binding a verb call. */
+function isCall(node: ast.LetStmt): boolean {
+  return node.args.length > 0 || node.opts !== undefined;
+}
+
+function boundCall(node: ast.LetStmt, env: TypeEnv, infer: Infer): Type {
+  return callType({ target: targetOf(node.value), args: node.args, opts: node.opts }, env, infer);
+}
+
+/** The dotted name a call was written with, such as `http.serve`. */
+function targetOf(value: Expr): string {
+  return (value as { $cstNode?: { text?: string } }).$cstNode?.text?.trim() ?? "";
+}
+
+function expectStmt(node: ast.ExpectStmt, env: TypeEnv, infer: Infer): TypeEnv {
+  if (node.subject) inferExpr(node.subject, env, infer);
+  for (const check of node.checks) inferExpr(check, env, infer);
+  return env;
+}
+
+/**
+ * A verb written as a statement, in either spelling.
+ *
+ * `callArgs` because the arguments live in different places on the node: bare
+ * ones hang off the statement, bracketed ones sit in the call. Reading only the
+ * first makes `http.on(api, route)` look like a call with no arguments, and then
+ * nothing tells `route` what it is handed.
+ */
+function actionArgs(node: ast.ActionCall, env: TypeEnv, infer: Infer): TypeEnv {
+  callType({ target: node.target, args: callArgs(node), opts: node.opts }, env, infer);
+  return env;
+}
+
+function runArgs(node: ast.RunStmt, env: TypeEnv, infer: Infer): TypeEnv {
+  for (const arg of node.args?.args ?? []) inferExpr(arg.value, env, infer);
+  return node.bind ? env.with(node.bind, mono(DYNAMIC)) : env;
+}
+
+function ifStmt(node: ast.IfStmt, env: TypeEnv, infer: Infer): TypeEnv {
+  inferExpr(node.cond, env, infer);
+  checkBlockOrIf(node.then, env, infer);
+  if (node.otherwise) checkBlockOrIf(node.otherwise, env, infer);
+  return env;
+}
+
+function checkBlockOrIf(node: Block | ast.IfStmt, env: TypeEnv, infer: Infer): void {
+  if (ast.isIfStmt(node)) ifStmt(node, env, infer);
+  else checkBlock(node, env, infer);
+}
+
+/** `forEach item in source`: the item's type is the source's element type. */
+function forEach(node: ast.ForEachStmt, env: TypeEnv, infer: Infer): TypeEnv {
+  const source = prune(inferExpr(node.source, env, infer));
+  const item: Type = source.kind === "list" ? source.element : DYNAMIC;
+  checkBlock(node.body, env.with(node.item, mono(item)), infer);
+  return env;
+}
+
+function repeat(node: ast.RepeatStmt, env: TypeEnv, infer: Infer): TypeEnv {
+  inferExpr(node.count, env, infer);
+  const inner = node.index ? env.with(node.index, mono({ kind: "prim", name: "number" })) : env;
+  checkBlock(node.body, inner, infer);
+  return env;
+}
+
+function tryStmt(node: ast.TryStmt, env: TypeEnv, infer: Infer): TypeEnv {
+  checkBlock(node.body, env, infer);
+  if (node.handler) {
+    const scope = node.error ? env.with(node.error, mono(DYNAMIC)) : env;
+    checkBlock(node.handler, scope, infer);
+  }
+  if (node.finalizer) checkBlock(node.finalizer, env, infer);
+  return env;
+}
+
+function blockAfterCond(cond: Expr, body: Block, env: TypeEnv, infer: Infer): TypeEnv {
+  inferExpr(cond, env, infer);
+  checkBlock(body, env, infer);
+  return env;
+}
+
+function maybeInfer(expr: Expr | undefined, env: TypeEnv, infer: Infer): TypeEnv {
+  if (expr) inferExpr(expr, env, infer);
+  return env;
+}
+
+/** A block opens its own scope; bindings inside it do not escape. */
+export function checkBlock(block: Block, env: TypeEnv, infer: Infer): void {
+  let scope = env;
+  for (const stmt of block.stmts) scope = checkStatement(stmt, scope, infer);
+}
+
+/** A fragment's params are in scope throughout its body. */
+export function checkFragment(decl: FragmentDecl, env: TypeEnv, infer: Infer): void {
+  let scope = env;
+  for (const param of decl.params?.params ?? []) scope = scope.with(param.name, mono(DYNAMIC));
+  checkBlock(decl.body, scope, infer);
+}