Skip to main content

decl_lang/
checker.rs

1//! Static checks over the AST + resolved types — a port of the reference
2//! implementation's checker.ts (chapters 3–4). Implemented:
3//!   E3001 duplicate module name         E3003 unknown type name
4//!   E4010 mixed range endpoints         E4011 empty range / array size
5//!   E4012 structurally empty intersection
6//!   E4013 non-discriminable record union arms
7//!   E4014 more than one non-record object arm in a union
8//!   E4015 map key not string-shaped     E4030 inheritance widening
9//!   E4032 illegal member-kind transition
10//!   E4052 ?? mixed with &&/|| unparenthesized
11//!   E4094 context variable without / with an invalid context declaration
12//! plus the expression pass of infer.rs (inference, assignability, absence).
13use crate::ast::*;
14use crate::engine::Engine;
15use crate::infer::Ty;
16use crate::infer::*;
17use crate::semantics::*;
18use crate::subsume::{structurally_empty, subsumes};
19use std::cell::{Cell, RefCell};
20use std::collections::{HashMap, HashSet};
21use std::rc::Rc;
22
23fn str_shaped(k: &RT) -> bool {
24    match &k.k {
25        RTk::Prim(n) => n == "string",
26        RTk::Pattern { .. } => true,
27        RTk::Lit(Value::Str(_)) => true,
28        RTk::Union(arms) => arms.borrow().iter().all(str_shaped),
29        RTk::Pred { base, .. } => str_shaped(base),
30        _ => false,
31    }
32}
33fn kind_name(k: MKind) -> &'static str {
34    match k {
35        MKind::Req => "req",
36        MKind::Opt => "opt",
37        MKind::Dflt => "dflt",
38        MKind::Der => "der",
39    }
40}
41
42/// the language server's tables, filled while the checker runs (infer.rs hooks)
43pub struct CheckHooks {
44    /// called with every expression's inferred type as the checker settles it (the language server's hover and hints)
45    pub record: Option<Rc<dyn Fn(&Rc<Expr>, &Ty)>>,
46    /// called with every name's resolution target, or none for an unresolved name (navigation)
47    pub resolve_hook: Option<Rc<dyn Fn(&Rc<Expr>, Option<Target>)>>,
48}
49// ---------------- union discrimination (§3.12) ----------------
50/// a literal value encoded with its kind, so "1" (string) is not 1 (int)
51fn enc_lit(v: &Value) -> String {
52    match v {
53        Value::Null => "null".into(),
54        Value::Int(i) => format!("i{i}"),
55        Value::Float(f) => format!("f{f}"),
56        Value::Bool(b) => format!("b{b}"),
57        Value::Str(sv) => format!("s{sv}"),
58        other => format!("o{other:?}"),
59    }
60}
61/// the literal values a leaf's member admits (a literal, or a union of
62/// literals), or None when the member is not literal-typed
63fn member_lit_set(leaf: &RT, name: &str) -> Option<Vec<String>> {
64    rec_members(leaf)
65        .iter()
66        .find(|x| x.name == name)
67        .and_then(|x| x.ty.clone())
68        .and_then(|t| match &t.k {
69            RTk::Lit(v) => Some(vec![enc_lit(v)]),
70            RTk::Union(a) => {
71                let a = a.borrow();
72                if a.iter().all(|x| matches!(&x.k, RTk::Lit(_))) {
73                    Some(
74                        a.iter()
75                            .filter_map(|x| match &x.k {
76                                RTk::Lit(v) => Some(enc_lit(v)),
77                                _ => None,
78                            })
79                            .collect(),
80                    )
81                } else {
82                    None
83                }
84            }
85            _ => None,
86        })
87}
88/// leaves grouped so that two sharing a value for `name` land together
89/// (transitively): a value both admit cannot tell them apart
90fn lit_components<'a>(leaves: &[&'a RT], name: &str) -> Vec<Vec<&'a RT>> {
91    let mut parent: Vec<usize> = (0..leaves.len()).collect();
92    fn find(parent: &mut [usize], i: usize) -> usize {
93        if parent[i] != i {
94            let r = find(parent, parent[i]);
95            parent[i] = r;
96        }
97        parent[i]
98    }
99    let mut by_val: HashMap<String, usize> = HashMap::new();
100    for (i, l) in leaves.iter().enumerate() {
101        for v in member_lit_set(l, name).unwrap_or_default() {
102            if let Some(&seen) = by_val.get(&v) {
103                let a = find(&mut parent, i);
104                let b = find(&mut parent, seen);
105                parent[a] = b;
106            } else {
107                by_val.insert(v, i);
108            }
109        }
110    }
111    let mut groups: HashMap<usize, Vec<&RT>> = HashMap::new();
112    for (i, l) in leaves.iter().enumerate() {
113        let r = find(&mut parent, i);
114        groups.entry(r).or_default().push(l);
115    }
116    groups.into_values().collect()
117}
118/// a set of leaf records is discriminable (§3.12) when some member — a literal
119/// in every leaf — partitions them into more than one group with disjoint
120/// values, and each group of more than one leaf is discriminable in turn by a
121/// further member (hierarchical discrimination; members found by structure)
122pub fn discriminable(leaves: &[RT], used: &HashSet<String>) -> bool {
123    if leaves.len() <= 1 {
124        return true;
125    }
126    let refs: Vec<&RT> = leaves.iter().collect();
127    let names: Vec<String> = rec_members(&leaves[0])
128        .iter()
129        .map(|m| m.name.clone())
130        .filter(|n| !used.contains(n) && leaves.iter().all(|l| member_lit_set(l, n).is_some()))
131        .collect();
132    for n in names {
133        let comps = lit_components(&refs, &n);
134        if comps.len() >= 2 {
135            let mut used2 = used.clone();
136            used2.insert(n.clone());
137            if comps.iter().all(|c| {
138                let owned: Vec<RT> = c.iter().map(|r| (*r).clone()).collect();
139                discriminable(&owned, &used2)
140            }) {
141                return true;
142            }
143        }
144    }
145    false
146}
147
148/// the context of a binding site: the value the expression gives is bound at evaluation (§3.18, v0.4.4)
149fn binding(cx: &Ctx) -> Ctx {
150    let mut c = cx.child();
151    c.binding = true;
152    c
153}
154
155/// The static checks of a module (§3, §4, §6, §9.7): its declarations, in the
156/// environment of a linked universe when one is given, with the hooks recording
157/// types and resolutions for a client. Returns every finding in the order the
158/// declarations are checked.
159pub fn check_module(
160    decls: &[Decl],
161    linked: Option<Rc<Env>>,
162    hooks: Option<&CheckHooks>,
163) -> Vec<Diag> {
164    let out: Rc<RefCell<Vec<Diag>>> = Rc::new(RefCell::new(vec![]));
165    // reports are anchored to the expression under inference (the context's
166    // `pos`, shared by child contexts), else to the declaration being checked
167    let pos: Rc<RefCell<Option<Rc<Expr>>>> = Rc::new(RefCell::new(None));
168    let cur_decl: Rc<Cell<Option<Loc>>> = Rc::new(Cell::new(None));
169    let report: Report = {
170        let out = out.clone();
171        let pos = pos.clone();
172        let cur = cur_decl.clone();
173        Rc::new(move |code: &str, message: String| {
174            let loc = pos.borrow().as_ref().and_then(expr_loc).or(cur.get());
175            let mut d = Diag::error(message, String::new(), Some(code));
176            d.loc = loc;
177            out.borrow_mut().push(d)
178        })
179    };
180    let rep = |code: &str, message: String| report(code, message);
181
182    let env = match &linked {
183        Some(e) => e.clone(),
184        None => {
185            let e = Env::new();
186            e.load(decls);
187            e
188        }
189    };
190    // installs env.const_eval / env.expr_eval (§4.13, §3.16); kept alive for the check
191    let _eng = if env.const_eval.borrow().is_none() {
192        Some(Engine::new(env.clone()))
193    } else {
194        None
195    };
196    *env.const_diag_sink.borrow_mut() = Some(out.clone()); // constant-evaluation errors surface here
197    for n in env.duplicates.borrow().iter() {
198        rep("E3001", format!("duplicate name {n} in module"));
199    }
200    out.borrow_mut().extend(env.finalize_unit_space()); // §3.16 unit/dimension spaces
201
202    // ---------- §4.13: constant positions ----------
203    let tparams: RefCell<HashSet<String>> = RefCell::new(HashSet::new());
204    let is_input = |n: &str| env.inputs.borrow().contains_key(n);
205    let is_output = |n: &str| env.outputs.borrow().iter().any(|(o, _, _)| o == n);
206    let check_endpoint = |v: Option<&Value>, where_: &str| {
207        let Some(Value::Str(v)) = v else { return };
208        if tparams.borrow().contains(v.as_ref()) || v.contains('.') {
209            return;
210        }
211        if is_input(v) || is_output(v) {
212            rep(
213                "E4021",
214                format!("non-constant {where_}: {v} is an input/output, not a module const"),
215            );
216        } else if !env.consts.borrow().contains_key(v.as_ref()) {
217            rep("E3003", format!("unknown name {v} in a {where_}"));
218        }
219    };
220    let const_violation = |e: &Rc<Expr>| -> Option<String> {
221        let mut found: Option<String> = None;
222        walk_expr_tree(e, true, &mut |x| {
223            if found.is_some() {
224                return;
225            }
226            found = match &**x {
227                Expr::Ctx(n) => Some(format!("context variable {n}")),
228                Expr::Referrers { .. } => Some("$referrers".into()),
229                Expr::Name(n) if is_input(n) => Some(format!("input {n}")),
230                Expr::Name(n) if is_output(n) => Some(format!("output {n}")),
231                _ => None,
232            };
233        });
234        found
235    };
236
237    // ---------- AST-level walks ----------
238    let is_bool_op = |e: &Expr| matches!(e, Expr::Bin { op, .. } if op == "&&" || op == "||");
239    let walk_expr = |e: &Rc<Expr>| {
240        walk_expr_tree(e, true, &mut |x| {
241            if let Expr::Bin { op, l, r } = &**x {
242                if op == "??" && (is_bool_op(l) || is_bool_op(r)) {
243                    rep(
244                        "E4052",
245                        "`??` mixed with `&&`/`||` without parentheses".into(),
246                    );
247                }
248            }
249        });
250    };
251
252    // D30: context obligations
253    fn ctx_uses(m: &MemberAst, used: &mut Vec<String>) {
254        let mut scan = |e: &Rc<Expr>| {
255            walk_expr_tree(e, false, &mut |x| {
256                if let Expr::Ctx(n) = &**x {
257                    if ["$parent", "$root", "$key"].contains(&n.as_str()) && !used.contains(n) {
258                        used.push(n.clone());
259                    }
260                }
261            });
262        };
263        match m {
264            MemberAst::Value { dflt: Some(d), .. } => scan(d),
265            MemberAst::Derived { expr, .. } => scan(expr),
266            MemberAst::Assert { cond, .. } => scan(cond),
267            MemberAst::When { cond, body, .. } => {
268                scan(cond);
269                for b in body {
270                    ctx_uses(b, used);
271                }
272            }
273            _ => {}
274        }
275    }
276    let check_record_ctx = |members: &[MemberAst], depth: i32, decl_name: Option<&str>| {
277        let declared: Vec<(&String, &TypeAst)> = members
278            .iter()
279            .filter_map(|m| {
280                if let MemberAst::Context { variable, ty, .. } = m {
281                    Some((variable, ty))
282                } else {
283                    None
284                }
285            })
286            .collect();
287        for (v, t) in &declared {
288            let is_ref = matches!(t, TypeAst::Named { name, .. } if name == "ref");
289            if (v.as_str() == "$parent" || v.as_str() == "$root") && !is_ref {
290                rep(
291                    "E4094",
292                    format!(
293                        "{v} declaration must be ref<...> ({})",
294                        decl_name.unwrap_or("anonymous")
295                    ),
296                );
297            }
298            if v.as_str() == "$key" && is_ref {
299                rep(
300                    "E4094",
301                    "$key declares a plain value type, not ref<...>".into(),
302                );
303            }
304        }
305        if depth > 1 {
306            return; // lexically nested: parent evident, no declaration required
307        }
308        let mut used: Vec<String> = vec![];
309        for m in members {
310            ctx_uses(m, &mut used);
311        }
312        for u in used {
313            if !declared.iter().any(|(v, _)| **v == u) {
314                rep(
315                    "E4094",
316                    format!(
317                        "{u} used without a context declaration in {}",
318                        decl_name.unwrap_or("anonymous type")
319                    ),
320                );
321            }
322        }
323    };
324
325    // inheritance (extension)
326    let check_extension = |name: &str, args: &[TypeAst], ext: &TypeAst, decl_name: Option<&str>| {
327        let Ok(base) = env.resolve(
328            &TypeAst::Named {
329                name: name.to_string(),
330                args: args.to_vec(),
331                preds: None,
332                ext: None,
333                loc: None,
334            },
335            None,
336        ) else {
337            return;
338        }; // unknown base reported by the resolution pass
339        let RTk::Rec(brec) = &base.k else {
340            rep("E4031", format!("extending non-record type {name}"));
341            return;
342        };
343        let TypeAst::Record {
344            members: ext_members,
345            ..
346        } = ext
347        else {
348            return;
349        };
350        let bmembers = brec.members.borrow();
351        for om in ext_members {
352            let (oname, o_kind, o_type): (&str, &str, Option<&TypeAst>) = match om {
353                MemberAst::Assert { .. } | MemberAst::When { .. } | MemberAst::Context { .. } => {
354                    continue
355                }
356                MemberAst::Derived {
357                    name, ty, hidden, ..
358                } => (name, if *hidden { "hidden" } else { "der" }, ty.as_ref()),
359                MemberAst::Value {
360                    name,
361                    opt,
362                    ty,
363                    dflt,
364                    ..
365                } => (
366                    name,
367                    if dflt.is_some() {
368                        "dflt"
369                    } else if *opt {
370                        "opt"
371                    } else {
372                        "req"
373                    },
374                    Some(ty),
375                ),
376            };
377            let Some(bm) = bmembers.iter().find(|x| x.name == oname) else {
378                continue;
379            }; // addition
380            let b_kind = if bm.kind == MKind::Der && bm.hidden {
381                "hidden"
382            } else {
383                kind_name(bm.kind)
384            };
385            // §5.9: overriding narrows; a hidden member stays hidden, a visible one visible
386            let allowed: &[&str] = match b_kind {
387                "req" => &["req", "dflt", "der"],
388                "opt" => &["req", "opt", "dflt", "der"],
389                "dflt" => &["req", "dflt", "der"],
390                "der" => &["der"],
391                _ => &["hidden"],
392            };
393            if !allowed.contains(&o_kind) {
394                rep(
395                    "E4032",
396                    format!(
397                        "illegal member-kind transition for {oname}: {b_kind} -> {o_kind} ({})",
398                        decl_name.unwrap_or(name)
399                    ),
400                );
401                continue;
402            }
403            let ot = try_resolve(&env, o_type);
404            if let (Some(ot), Some(bt)) = (ot, &bm.ty) {
405                if !subsumes(&env, &ot, bt) {
406                    rep(
407                        "E4030",
408                        format!(
409                            "override widens inherited member {oname} ({})",
410                            decl_name.unwrap_or(name)
411                        ),
412                    );
413                }
414            }
415        }
416    };
417
418    struct Walk<'a> {
419        rep: &'a dyn Fn(&str, String),
420        check_endpoint: &'a dyn Fn(Option<&Value>, &str),
421        const_violation: &'a dyn Fn(&Rc<Expr>) -> Option<String>,
422        walk_expr: &'a dyn Fn(&Rc<Expr>),
423        check_record_ctx: &'a dyn Fn(&[MemberAst], i32, Option<&str>),
424        check_extension: &'a dyn Fn(&str, &[TypeAst], &TypeAst, Option<&str>),
425    }
426    impl<'a> Walk<'a> {
427        fn walk_type(&self, t: Option<&TypeAst>, depth: i32, decl_name: Option<&str>) {
428            let Some(t) = t else { return };
429            match t {
430                TypeAst::Range { lo, hi, .. } => {
431                    let kinds = [js_typeof(lo), js_typeof(hi)];
432                    if kinds[0] != kinds[1] && !kinds.contains(&"string") {
433                        (self.rep)(
434                            "E4010",
435                            format!("mixed range endpoints: {}..{}", js_str(lo), js_str(hi)),
436                        );
437                    }
438                    (self.check_endpoint)(Some(lo), "range endpoint");
439                    (self.check_endpoint)(Some(hi), "range endpoint");
440                }
441                TypeAst::Record { members, .. } => {
442                    (self.check_record_ctx)(members, depth, decl_name);
443                    for m in members {
444                        self.walk_member(m, depth, decl_name);
445                    }
446                }
447                TypeAst::Map { key, val, .. } => {
448                    self.walk_type(Some(key), depth, decl_name);
449                    self.walk_type(Some(val), depth, decl_name);
450                }
451                TypeAst::Array { elem, lo, hi, .. } => {
452                    (self.check_endpoint)(lo.as_ref(), "array size");
453                    (self.check_endpoint)(hi.as_ref(), "array size");
454                    self.walk_type(Some(elem), depth, decl_name);
455                }
456                TypeAst::Union { arms, .. } | TypeAst::Isect { arms, .. } => arms
457                    .iter()
458                    .for_each(|a| self.walk_type(Some(a), depth, decl_name)),
459                TypeAst::Func { params, ret, .. } => {
460                    params
461                        .iter()
462                        .for_each(|p| self.walk_type(Some(p), depth, decl_name));
463                    self.walk_type(Some(ret), depth, decl_name);
464                }
465                TypeAst::Named {
466                    name,
467                    args,
468                    preds,
469                    ext,
470                    ..
471                } => {
472                    args.iter()
473                        .for_each(|a| self.walk_type(Some(a), depth, decl_name));
474                    if let Some(x) = ext {
475                        (self.check_extension)(name, args, x, decl_name);
476                        self.walk_type(Some(x), depth + 1, decl_name);
477                    }
478                    for p in preds.iter().flatten() {
479                        if let Some(bad) = (self.const_violation)(p) {
480                            (self.rep)(
481                                "E4021",
482                                format!("non-constant predicate argument: {bad} (§4.13)"),
483                            );
484                        }
485                        (self.walk_expr)(p);
486                    }
487                }
488                TypeAst::Prim { .. } | TypeAst::Lit { .. } | TypeAst::Pattern { .. } => {}
489            }
490        }
491        fn walk_member(&self, m: &MemberAst, depth: i32, decl_name: Option<&str>) {
492            match m {
493                MemberAst::Value { ty, dflt, .. } => {
494                    self.walk_type(Some(ty), depth + 1, decl_name);
495                    if let Some(d) = dflt {
496                        (self.walk_expr)(d);
497                    }
498                }
499                MemberAst::Derived { ty, expr, .. } => {
500                    self.walk_type(ty.as_ref(), depth + 1, decl_name);
501                    (self.walk_expr)(expr);
502                }
503                MemberAst::Context { ty, .. } => self.walk_type(Some(ty), depth + 1, decl_name),
504                MemberAst::Assert { cond, .. } => (self.walk_expr)(cond),
505                MemberAst::When { cond, body, .. } => {
506                    (self.walk_expr)(cond);
507                    body.iter()
508                        .for_each(|x| self.walk_member(x, depth, decl_name));
509                }
510            }
511        }
512    }
513    let walk = Walk {
514        rep: &rep,
515        check_endpoint: &check_endpoint,
516        const_violation: &const_violation,
517        walk_expr: &walk_expr,
518        check_record_ctx: &check_record_ctx,
519        check_extension: &check_extension,
520    };
521
522    // ---------- resolution-level checks ----------
523    let resolve_reported: RefCell<HashSet<String>> = RefCell::new(HashSet::new());
524    let pattern_unknown = regex::Regex::new(r"pattern interpolation of .*: unknown type").unwrap();
525    let map_resolve_err = |msg: &str, where_: &str| {
526        let key = format!("{msg}|{where_}");
527        if !resolve_reported.borrow_mut().insert(key) {
528            return; // one resolution failure, one report
529        }
530        if msg.contains("unknown dimension") || msg.contains("circular dimension") {
531            rep("E3003", format!("{msg} (in {where_})"));
532        } else if msg.contains("unknown unit") {
533            rep("E4073", format!("{msg} (in {where_})"));
534        } else if pattern_unknown.is_match(msg) || msg.contains("unknown type") {
535            rep("E3003", format!("{msg} (in {where_})"));
536        } else if msg.contains("recursive type alias") {
537            rep("E4012", format!("{msg} (in {where_})"));
538        } else if msg.contains("generic arity") {
539            rep("E4022", format!("{msg} (in {where_})"));
540        } else if msg.contains("outside parameter") {
541            rep("E4023", format!("{msg} (in {where_})"));
542        } else if msg.contains("non-constant value argument") {
543            rep("E4021", format!("{msg} (in {where_})"));
544        } else if msg.contains("pattern interpolation") {
545            rep("E4117", format!("{msg} (in {where_})"));
546        } else if msg.contains("malformed pattern") {
547            rep("E4119", format!("{msg} (in {where_})"));
548        } else {
549            rep("E4001", format!("{msg} (in {where_})")); // never drop a resolution failure silently
550        }
551    };
552    let resolve_or_report = |t: Option<&TypeAst>, where_: &str| -> Option<RT> {
553        let t = t?;
554        match env.resolve(t, None) {
555            Ok(rt) => Some(rt),
556            Err(msg) => {
557                map_resolve_err(&msg, where_);
558                None
559            }
560        }
561    };
562
563    fn check_resolved(
564        env: &Rc<Env>,
565        rep: &dyn Fn(&str, String),
566        rt: &RT,
567        name: &str,
568        seen: &mut HashSet<usize>,
569    ) {
570        let id = Rc::as_ptr(rt) as usize;
571        if seen.contains(&id) {
572            return;
573        }
574        seen.insert(id);
575        match &rt.k {
576            RTk::Range { lo, hi, .. } => {
577                let ks = [js_typeof(lo), js_typeof(hi)];
578                if !ks.contains(&"string") && ks[0] != ks[1] {
579                    rep(
580                        "E4010",
581                        format!("mixed range endpoints after constant substitution in {name}"),
582                    );
583                }
584                if structurally_empty(env, rt) {
585                    rep("E4011", format!("empty range in {name}"));
586                }
587            }
588            RTk::Arr { elem, .. } => {
589                if structurally_empty(env, rt) {
590                    rep("E4011", format!("empty array size in {name}"));
591                }
592                check_resolved(env, rep, elem, name, seen);
593            }
594            RTk::IsectN(arms) => {
595                if structurally_empty(env, rt) {
596                    rep(
597                        "E4012",
598                        format!("structurally empty intersection in {name}"),
599                    );
600                }
601                arms.iter()
602                    .for_each(|a| check_resolved(env, rep, a, name, seen));
603            }
604            RTk::Map { key, val } => {
605                if !str_shaped(key) {
606                    rep("E4015", format!("map key type not string-shaped in {name}"));
607                }
608                check_resolved(env, rep, val, name, seen);
609            }
610            RTk::Union(arms) => {
611                let arms = arms.borrow();
612                let leaves: Vec<RT> = arms.iter().flat_map(leaf_recs).collect();
613                if leaves.len() >= 2 && !discriminable(&leaves, &HashSet::new()) {
614                    rep(
615                        "E4013",
616                        format!("record union arms not discriminable in {name}"),
617                    );
618                }
619                let non_rec_obj = arms
620                    .iter()
621                    .filter(|a| matches!(a.k, RTk::Map { .. } | RTk::Quantity(_)))
622                    .count();
623                if non_rec_obj > 1 {
624                    rep(
625                        "E4014",
626                        format!("more than one non-record object arm in {name}"),
627                    );
628                }
629                arms.iter()
630                    .for_each(|a| check_resolved(env, rep, a, name, seen));
631            }
632            RTk::Rec(_) => {
633                for m in rec_members(rt).iter() {
634                    if let Some(t) = &m.ty {
635                        check_resolved(env, rep, t, name, seen);
636                    }
637                }
638            }
639            RTk::Pred { base, .. } => check_resolved(env, rep, base, name, seen),
640            RTk::Ref(target) => check_resolved(env, rep, target, name, seen),
641            _ => {}
642        }
643    }
644
645    let type_order = env.type_order.borrow().clone();
646    let type_entry = |n: &str| env.type_asts.borrow().get(n).cloned();
647    for name in &type_order {
648        let Some(decl) = type_entry(name) else {
649            continue;
650        };
651        if !decl.params.is_empty() {
652            continue; // generic declarations check at instantiation (§3.15)
653        }
654        match env.resolve(&named(name), None) {
655            Ok(rt) => check_resolved(&env, &rep, &rt, name, &mut HashSet::new()),
656            Err(msg) => map_resolve_err(&msg, name),
657        }
658    }
659
660    // AST walks over all declarations
661    for d in decls {
662        cur_decl.set(d.loc);
663        *tparams.borrow_mut() = match &d.body {
664            DeclBody::Type { params, .. } => params.iter().map(|p| p.name.clone()).collect(),
665            _ => HashSet::new(),
666        };
667        match &d.body {
668            DeclBody::Type { name, ty, .. } => walk.walk_type(Some(ty), 1, Some(name)),
669            DeclBody::Const { ty, expr, .. } => {
670                walk.walk_type(ty.as_ref(), 0, None);
671                walk_expr(expr);
672            }
673            DeclBody::Func {
674                params, ret, body, ..
675            } => {
676                params
677                    .iter()
678                    .for_each(|p| walk.walk_type(p.ty.as_ref(), 0, None));
679                walk.walk_type(ret.as_ref(), 0, None);
680                walk_expr(body);
681            }
682            DeclBody::Output { ty, expr, .. } => {
683                walk.walk_type(Some(ty), 0, None);
684                walk_expr(expr);
685            }
686            DeclBody::Input { ty, fallback, .. } => {
687                walk.walk_type(Some(ty), 0, None);
688                if let Some(f) = fallback {
689                    walk_expr(f);
690                }
691            }
692            _ => {}
693        }
694    }
695
696    // ---------- expression pass: inference, assignability, absence (§3.18, §4.10) ----------
697    let mut cx0 = make_ctx(env.clone(), report.clone());
698    cx0.pos = pos.clone();
699    if let Some(h) = hooks {
700        cx0.record = h.record.clone();
701        cx0.resolve_hook = h.resolve_hook.clone();
702    }
703    let cx0 = cx0;
704    let is_bool_ty = |t: &Ty| match &t.rt {
705        None => true,
706        Some(r) => {
707            matches!(&r.k, RTk::Prim(n) if n == "bool") || matches!(&r.k, RTk::Lit(Value::Bool(_)))
708        }
709    };
710    let rec_ctx = |cx: &Ctx, rt: &RT, ast: Option<&TypeAst>| -> Ctx {
711        // a lexically-nested record's $parent is evident — the enclosing record,
712        // the context we came from (D30); a named type declares its own context,
713        // so only an anonymous inline type takes this, and a declaration overrides
714        let enclosing = cx.vars.get("$this").cloned();
715        let mut c = cx.child();
716        for m in rec_members(rt).iter() {
717            c.vars.insert(
718                m.name.clone(),
719                Ty {
720                    rt: member_ty(m),
721                    abs: m.kind == MKind::Opt,
722                },
723            );
724        }
725        if let Some(e) = enclosing {
726            c.vars.insert("$parent".into(), e);
727        }
728        c.vars.insert("$this".into(), tyv(Some(rt.clone())));
729        c.vars
730            .insert("$path".into(), tyv(Some(ty(RTk::Prim("string".into())))));
731        if let Some(TypeAst::Record { members, .. }) = ast {
732            for m in members {
733                if let MemberAst::Context { variable, ty, .. } = m {
734                    c.vars
735                        .insert(variable.clone(), tyv(try_resolve(&env, Some(ty))));
736                }
737            }
738        }
739        c
740    };
741    fn check_member_ast(
742        env: &Rc<Env>,
743        rep: &dyn Fn(&str, String),
744        is_bool_ty: &dyn Fn(&Ty) -> bool,
745        cx: &Ctx,
746        m: &MemberAst,
747    ) {
748        match m {
749            MemberAst::Value {
750                ty, dflt: Some(d), ..
751            } => {
752                check_expr(&binding(cx), d, try_resolve(env, Some(ty)).as_ref());
753            }
754            MemberAst::Derived { ty, expr, .. } => {
755                check_expr(&binding(cx), expr, try_resolve(env, ty.as_ref()).as_ref());
756            }
757            MemberAst::Assert { cond, tail, .. } => {
758                if !is_bool_ty(&require_val(
759                    cx,
760                    cond,
761                    infer(cx, cond),
762                    "as an assert condition",
763                )) {
764                    rep("E4001", "assert condition is not bool".into());
765                }
766                match tail {
767                    Some(Tail::Inline { template, .. }) => {
768                        for p in template {
769                            if let TPart::Expr(x) = p {
770                                infer(cx, x);
771                            }
772                        }
773                    }
774                    Some(Tail::Ref { args, .. }) => {
775                        for a in args {
776                            require_val(cx, a, infer(cx, a), "as a diagnostic argument");
777                        }
778                    }
779                    None => {}
780                }
781            }
782            MemberAst::When { cond, body, .. } => {
783                if !is_bool_ty(&require_val(
784                    cx,
785                    cond,
786                    infer(cx, cond),
787                    "as a when condition",
788                )) {
789                    rep("E4001", "when condition is not bool".into());
790                }
791                let c2 = apply_guards(cx, guards_of(cond, true));
792                for b in body {
793                    check_member_ast(env, rep, is_bool_ty, &c2, b);
794                }
795            }
796            _ => {}
797        }
798    }
799
800    let seen_recs: RefCell<HashSet<usize>> = RefCell::new(HashSet::new());
801    fn check_record_exprs(
802        env: &Rc<Env>,
803        rep: &dyn Fn(&str, String),
804        is_bool_ty: &dyn Fn(&Ty) -> bool,
805        rec_ctx: &dyn Fn(&Ctx, &RT, Option<&TypeAst>) -> Ctx,
806        seen: &RefCell<HashSet<usize>>,
807        rt: &RT,
808        cx: &Ctx,
809        ast: Option<&TypeAst>,
810    ) {
811        let RTk::Rec(rec) = &rt.k else { return };
812        let id = Rc::as_ptr(rt) as usize;
813        if seen.borrow().contains(&id) {
814            return;
815        }
816        seen.borrow_mut().insert(id);
817        let cx_r = rec_ctx(cx, rt, ast);
818        // member expressions and asserts check in their declaring module's
819        // scope (§8.3) — same rule the engine follows at evaluation
820        let cx_for = |menv: &Option<Rc<Env>>| -> Ctx {
821            match menv {
822                Some(m) if !Rc::ptr_eq(m, &cx_r.env) => cx_r.with_env(m.clone()),
823                _ => cx_r.clone(),
824            }
825        };
826        // D30/E4090: an embedded type's declared bounds must hold at this
827        // site — the container is the parent, the collection's key or index
828        // type is what $key ranges over (none for a direct member)
829        let check_embedding = |member_rt: &RT, member_name: &str, key_rt: Option<&RT>| {
830            let RTk::Rec(mrec) = &member_rt.k else { return };
831            let site = format!(
832                "{}.{member_name}",
833                rt.name.borrow().clone().unwrap_or_else(|| "record".into())
834            );
835            let who = member_rt
836                .name
837                .borrow()
838                .clone()
839                .unwrap_or_else(|| "the member type".into());
840            for (var, cty) in mrec.ctx_decls.borrow().iter() {
841                if var == "$parent" {
842                    let RTk::Ref(bound) = &cty.k else { continue };
843                    if !subsumes(env, rt, bound) {
844                        rep(
845                            "E4090",
846                            format!("embedding site {site} fails {who}'s $parent bound (§7.3)"),
847                        );
848                    }
849                } else if var == "$key" {
850                    match key_rt {
851                        None => rep("E4090", format!("embedding site {site} gives $key no meaning: {who} is a direct member, not a collection element (§7.3)")),
852                        Some(k) => {
853                            if !subsumes(env, k, cty) {
854                                rep("E4090", format!("embedding site {site} fails {who}'s $key bound (§7.3)"));
855                            }
856                        }
857                    }
858                }
859            }
860        };
861        let int_rt: RT = ty(RTk::Prim("int".into()));
862        if let Some(cyc) = member_cycle(rt, None, &HashSet::new()) {
863            rep(
864                "E4113",
865                format!(
866                    "{}: dependency cycle visible in the type structure: {} (§9.3)",
867                    rt.name.borrow().clone().unwrap_or_else(|| "record".into()),
868                    cyc.join(" -> ")
869                ),
870            );
871        }
872        let members = rec.members.borrow().clone();
873        for m in members.iter() {
874            if m.kind == MKind::Der {
875                if let Some(x) = &m.expr {
876                    check_expr(&binding(&cx_for(&m.menv)), x, m.ty.as_ref());
877                }
878            }
879            if m.kind == MKind::Dflt {
880                if let Some(d) = &m.dflt {
881                    check_expr(&binding(&cx_for(&m.menv)), d, m.ty.as_ref());
882                }
883            }
884            let Some(mt) = &m.ty else { continue };
885            let nested: Option<(RT, Option<RT>)> = match &mt.k {
886                RTk::Rec(_) => Some((mt.clone(), None)),
887                RTk::Arr { elem, .. } if is_rec(elem) => Some((elem.clone(), Some(int_rt.clone()))),
888                RTk::Map { key, val } if is_rec(val) => Some((val.clone(), Some(key.clone()))),
889                _ => None,
890            };
891            if let Some((n, key_rt)) = nested {
892                check_embedding(&n, &m.name, key_rt.as_ref());
893                check_record_exprs(
894                    env,
895                    rep,
896                    is_bool_ty,
897                    rec_ctx,
898                    seen,
899                    &n,
900                    &cx_for(&m.menv),
901                    None,
902                );
903            }
904        }
905        let asserts = rec.asserts.borrow().clone();
906        for a in &asserts {
907            let m = if a.when {
908                MemberAst::When {
909                    cond: a.cond.clone(),
910                    body: a.body.clone(),
911                    annotations: vec![],
912                    loc: None,
913                }
914            } else {
915                MemberAst::Assert {
916                    name: a.name.clone(),
917                    cond: a.cond.clone(),
918                    tail: a.tail.clone(),
919                    annotations: vec![],
920                    loc: None,
921                }
922            };
923            check_member_ast(env, rep, is_bool_ty, &cx_for(&a.menv), &m);
924        }
925    }
926
927    for name in &type_order {
928        let Some(decl) = type_entry(name) else {
929            continue;
930        };
931        if !decl.params.is_empty() {
932            continue;
933        }
934        let Ok(rt) = env.resolve(&named(name), None) else {
935            continue;
936        };
937        check_record_exprs(
938            &env,
939            &rep,
940            &is_bool_ty,
941            &rec_ctx,
942            &seen_recs,
943            &rt,
944            &cx0,
945            Some(&decl.ast),
946        );
947    }
948    // D30/E4090 for $root: every record type owned (transitively) by an
949    // evaluation root must have its declared $root bound met by the root's
950    // own type — checked once per root declaration
951    // §7.3: the root's own type gives $parent and $key no meaning — the root
952    // has no owner and sits under no key — so a declaration of either on it
953    // (directly, or on a union arm) is an error at the root
954    fn check_root_type(rep: &dyn Fn(&str, String), root_name: &str, root_rt: &RT) {
955        let arms: Vec<RT> = match &root_rt.k {
956            RTk::Union(arms) => arms.borrow().clone(),
957            _ => vec![root_rt.clone()],
958        };
959        for t in &arms {
960            let RTk::Rec(r) = &t.k else { continue };
961            let who = t.name.borrow().clone().unwrap_or_else(|| "its type".into());
962            for (var, _) in r.ctx_decls.borrow().iter() {
963                if var == "$parent" {
964                    rep("E4090", format!("root {root_name} gives $parent no meaning: {who} is the evaluation root's own type (§7.3)"));
965                } else if var == "$key" {
966                    rep("E4090", format!("root {root_name} gives $key no meaning: {who} is the evaluation root's own type, not a collection element (§7.3)"));
967                }
968            }
969        }
970    }
971    fn walk_root_bounds(
972        env: &Rc<Env>,
973        rep: &dyn Fn(&str, String),
974        root_name: &str,
975        root_rt: &RT,
976        t: &RT,
977        seen: &mut HashSet<usize>,
978    ) {
979        let id = Rc::as_ptr(t) as usize;
980        if !seen.insert(id) {
981            return;
982        }
983        match &t.k {
984            RTk::Rec(r) => {
985                for (var, cty) in r.ctx_decls.borrow().iter() {
986                    if var != "$root" {
987                        continue;
988                    }
989                    let RTk::Ref(bound) = &cty.k else { continue };
990                    if !subsumes(env, root_rt, bound) {
991                        rep(
992                            "E4090",
993                            format!(
994                                "root {root_name} fails {}'s $root bound (§7.3)",
995                                t.name
996                                    .borrow()
997                                    .clone()
998                                    .unwrap_or_else(|| "a member type".into())
999                            ),
1000                        );
1001                    }
1002                }
1003                for m in rec_members(t).iter() {
1004                    if let Some(mt) = &m.ty {
1005                        walk_root_bounds(env, rep, root_name, root_rt, mt, seen);
1006                    }
1007                }
1008            }
1009            RTk::Arr { elem, .. } => walk_root_bounds(env, rep, root_name, root_rt, elem, seen),
1010            RTk::Map { val, .. } => walk_root_bounds(env, rep, root_name, root_rt, val, seen),
1011            RTk::Union(arms) => arms
1012                .borrow()
1013                .iter()
1014                .for_each(|a| walk_root_bounds(env, rep, root_name, root_rt, a, seen)),
1015            RTk::IsectN(arms) => arms
1016                .iter()
1017                .for_each(|a| walk_root_bounds(env, rep, root_name, root_rt, a, seen)),
1018            RTk::Pred { base, .. } => walk_root_bounds(env, rep, root_name, root_rt, base, seen),
1019            _ => {}
1020        }
1021    }
1022    for d in decls {
1023        cur_decl.set(d.loc);
1024        let (name, ty_ast) = match &d.body {
1025            DeclBody::Output { name, ty, .. } | DeclBody::Input { name, ty, .. } => (name, ty),
1026            _ => continue,
1027        };
1028        if let Some(rt) = try_resolve(&env, Some(ty_ast)) {
1029            check_root_type(&rep, name, &rt);
1030            walk_root_bounds(&env, &rep, name, &rt, &rt, &mut HashSet::new());
1031        }
1032    }
1033    for d in decls {
1034        cur_decl.set(d.loc);
1035        match &d.body {
1036            DeclBody::Const { name, ty, expr } => {
1037                let exp = ty
1038                    .as_ref()
1039                    .and_then(|t| resolve_or_report(Some(t), &format!("const {name}")));
1040                check_expr(&cx0, expr, exp.as_ref());
1041            }
1042            DeclBody::Func {
1043                name,
1044                params,
1045                ret,
1046                body,
1047            } => {
1048                let mut cx_f = cx0.child();
1049                for p in params {
1050                    cx_f.vars.insert(
1051                        p.name.clone(),
1052                        tyv(resolve_or_report(p.ty.as_ref(), &format!("func {name}"))),
1053                    );
1054                    cx_f.locals.insert(p.name.clone());
1055                }
1056                let exp = ret
1057                    .as_ref()
1058                    .and_then(|t| resolve_or_report(Some(t), &format!("func {name}")));
1059                check_expr(&cx_f, body, exp.as_ref());
1060            }
1061            DeclBody::Output { name, ty, expr } => {
1062                let exp = resolve_or_report(Some(ty), &format!("output {name}"));
1063                check_expr(&binding(&cx0), expr, exp.as_ref());
1064            }
1065            DeclBody::Input {
1066                name,
1067                ty,
1068                fallback: Some(f),
1069            } => {
1070                let exp = resolve_or_report(Some(ty), &format!("input {name}"));
1071                check_expr(&binding(&cx0), f, exp.as_ref());
1072            }
1073            DeclBody::Input {
1074                name,
1075                ty,
1076                fallback: None,
1077            } => {
1078                resolve_or_report(Some(ty), &format!("input {name}"));
1079            }
1080            DeclBody::Diagnostic {
1081                params, template, ..
1082            } => {
1083                let mut cx_d = cx0.child();
1084                for p in params {
1085                    cx_d.vars
1086                        .insert(p.name.clone(), tyv(try_resolve(&env, p.ty.as_ref())));
1087                    cx_d.locals.insert(p.name.clone());
1088                }
1089                for p in template {
1090                    if let TPart::Expr(x) = p {
1091                        infer(&cx_d, x);
1092                    }
1093                }
1094            }
1095            DeclBody::Unit {
1096                name,
1097                factor: Some(f),
1098                ..
1099            } => {
1100                if let Some(bad) = const_violation(f) {
1101                    rep(
1102                        "E4021",
1103                        format!("non-constant unit factor for {name}: {bad} (§3.16)"),
1104                    );
1105                }
1106            }
1107            _ => {}
1108        }
1109    }
1110
1111    // ---------- §5.10: annotations are metadata; an unknown one is a warning ----------
1112    // known: `@deprecated` and `@doc` anywhere, `@render` on an output
1113    // (docs/tooling/05_render.md); the warning keeps a typo visible (W0001)
1114    for d in decls {
1115        let known: &[&str] = if matches!(d.body, DeclBody::Output { .. }) {
1116            &["deprecated", "doc", "render"]
1117        } else {
1118            &["deprecated", "doc"]
1119        };
1120        warn_unknown(&out, &d.annotations, known);
1121        match &d.body {
1122            DeclBody::Type { ty, .. }
1123            | DeclBody::Output { ty, .. }
1124            | DeclBody::Input { ty, .. } => annotated_members(&out, Some(ty)),
1125            DeclBody::Const { ty, .. } => annotated_members(&out, ty.as_ref()),
1126            DeclBody::Func { params, ret, .. } => {
1127                for p in params {
1128                    annotated_members(&out, p.ty.as_ref());
1129                }
1130                annotated_members(&out, ret.as_ref());
1131            }
1132            _ => {}
1133        }
1134    }
1135    *env.const_diag_sink.borrow_mut() = None;
1136    let result = out.borrow().clone();
1137    result
1138}
1139
1140fn warn_unknown(out: &RefCell<Vec<Diag>>, anns: &[Annotation], known: &[&str]) {
1141    for a in anns {
1142        if !known.contains(&a.name.as_str()) {
1143            let mut d = Diag::error(
1144                format!("unknown annotation @{}", a.name),
1145                String::new(),
1146                Some("W0001"),
1147            );
1148            d.severity = "warn".into();
1149            d.loc = a.loc;
1150            out.borrow_mut().push(d);
1151        }
1152    }
1153}
1154fn annotated_members(out: &RefCell<Vec<Diag>>, t: Option<&TypeAst>) {
1155    match t {
1156        Some(TypeAst::Record { members, .. }) => {
1157            for m in members {
1158                annotated_member(out, m);
1159            }
1160        }
1161        Some(TypeAst::Map { key, val, .. }) => {
1162            annotated_members(out, Some(key));
1163            annotated_members(out, Some(val));
1164        }
1165        Some(TypeAst::Array { elem, .. }) => annotated_members(out, Some(elem)),
1166        Some(TypeAst::Union { arms, .. }) | Some(TypeAst::Isect { arms, .. }) => {
1167            for a in arms {
1168                annotated_members(out, Some(a));
1169            }
1170        }
1171        Some(TypeAst::Func { params, ret, .. }) => {
1172            for p in params {
1173                annotated_members(out, Some(p));
1174            }
1175            annotated_members(out, Some(ret));
1176        }
1177        Some(TypeAst::Named { args, ext, .. }) => {
1178            for a in args {
1179                annotated_members(out, Some(a));
1180            }
1181            annotated_members(out, ext.as_deref());
1182        }
1183        _ => {}
1184    }
1185}
1186fn annotated_member(out: &RefCell<Vec<Diag>>, m: &MemberAst) {
1187    warn_unknown(out, m.annotations(), &["deprecated", "doc"]);
1188    match m {
1189        MemberAst::Value { ty, .. } | MemberAst::Context { ty, .. } => {
1190            annotated_members(out, Some(ty))
1191        }
1192        MemberAst::Derived { ty, .. } => annotated_members(out, ty.as_ref()),
1193        MemberAst::When { body, .. } => {
1194            for m in body {
1195                annotated_member(out, m);
1196            }
1197        }
1198        MemberAst::Assert { .. } => {}
1199    }
1200}
1201
1202#[allow(dead_code)]
1203fn _unused(_: &HashMap<String, String>) {}