1use 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
42pub struct CheckHooks {
44 pub record: Option<Rc<dyn Fn(&Rc<Expr>, &Ty)>>,
46 pub resolve_hook: Option<Rc<dyn Fn(&Rc<Expr>, Option<Target>)>>,
48}
49fn 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}
61fn 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}
88fn 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}
118pub 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
148fn binding(cx: &Ctx) -> Ctx {
150 let mut c = cx.child();
151 c.binding = true;
152 c
153}
154
155pub 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 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 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()); 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()); 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 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 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; }
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 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 }; 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 }; let b_kind = if bm.kind == MKind::Der && bm.hidden {
381 "hidden"
382 } else {
383 kind_name(bm.kind)
384 };
385 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 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; }
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_})")); }
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; }
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 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 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 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 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 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 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 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>) {}