Skip to main content

vibe/check/
mod.rs

1//! Type and effect checker.
2
3use crate::ast::*;
4use crate::effects::{binding_effect, capability_for, Effect};
5use crate::error::{DiagCode, Diagnostic};
6use crate::types::Type;
7use std::collections::{HashMap, HashSet};
8mod bindings;
9mod context;
10mod expressions;
11pub mod fabric_guard;
12mod helpers;
13mod statements;
14#[cfg(test)]
15mod tests;
16use context::collection_call;
17use context::snapshot_value;
18use context::{builtin_call, collect_enum_calls, infer_functions, resolved_call_effect};
19pub(crate) use context::{check_submission, CheckEnv};
20use expressions::walk_expr;
21use helpers::*;
22use statements::walk_stmt;
23
24#[derive(Debug)]
25pub struct CheckResult {
26    pub effect: Effect,
27}
28
29/// Collect up to 8 diagnostics instead of stopping at the first (audit §7.12).
30pub const MAX_DIAGNOSTICS: usize = 8;
31
32const VALID_IMPORT_NS: &[&str] = &[
33    "math",
34    "rdf",
35    "quin",
36    "graph",
37    "aura",
38    "pulse",
39    "capability",
40    "time",
41    "conservation",
42    "causal",
43    "dag",
44    "deontic",
45    "hid",
46    "cue",
47    "crypto",
48    "zk",
49    "web",
50    "ui",
51    "form",
52    "input",
53    "validate",
54    "selection",
55    "layout",
56    "cbor_ld",
57    "reflect",
58    "record",
59    "uri",
60    "error",
61    "num",
62    "decimal",
63    "autodiff",
64    "str",
65    "regex",
66    "list",
67    "deque",
68    "pqueue",
69    "set",
70    "simplex",
71    "hypergraph",
72    "sheaf",
73    "topology",
74    "homotopy",
75    "context",
76    "manifold",
77    "inference",
78    "ast",
79    "diagnostic",
80    "effect",
81    "code",
82    "task",
83    "supervisor",
84    "contract",
85    "state",
86    "value",
87    "runtime",
88    "continuation",
89    "memory",
90    "simd",
91    "channel",
92];
93
94/// Checks program-all.
95pub fn check_program_all(program: &Program) -> (CheckResult, Vec<Diagnostic>) {
96    let mut errors = Vec::new();
97    let mut aliases = HashMap::new();
98    collect_import_errors(program, &mut aliases, &mut errors);
99    fabric_guard::check_program_fabric(program, &mut errors);
100
101    let granted: Vec<&str> = program.requires.iter().map(|c| c.id.as_str()).collect();
102    let mut max_effect = Effect::Pure;
103    let mut env = CheckEnv::default();
104    collect_enum_calls(program, &mut env);
105    env.functions = infer_functions(program, &aliases, &granted);
106    let mut mutables = HashSet::new();
107    for item in &program.items {
108        if errors.len() >= MAX_DIAGNOSTICS {
109            break;
110        }
111        match check_item(item, &mut env, &mut mutables, &aliases, &granted) {
112            Ok(e) => max_effect = max_effect.join(e),
113            Err(e) => {
114                if !errors
115                    .iter()
116                    .any(|x| x.span == e.span && x.message == e.message)
117                {
118                    errors.push(e);
119                }
120            }
121        }
122    }
123    (CheckResult { effect: max_effect }, errors)
124}
125
126/// Checks program.
127pub fn check_program(program: &Program) -> Result<CheckResult, Diagnostic> {
128    let (result, errors) = check_program_all(program);
129    match errors.into_iter().next() {
130        Some(e) => Err(e),
131        None => Ok(result),
132    }
133}
134
135/// After a successful check, fail closed on prefixed names missing from a loaded vocab chunk.
136pub fn check_program_with_vocab(
137    program: &Program,
138    chunks: &[crate::vocab::VocabChunk],
139) -> Result<CheckResult, Diagnostic> {
140    let result = check_program(program)?;
141    if let Some((prefix, local, span)) = crate::vocab::unknown_prefixed(program, chunks)
142        .into_iter()
143        .next()
144    {
145        return Err(Diagnostic::new(
146            DiagCode::E100,
147            span,
148            format!("unknown vocab term `{prefix}:{local}` (not in loaded chunk)"),
149        ));
150    }
151    Ok(result)
152}
153
154fn collect_import_errors(
155    program: &Program,
156    aliases: &mut HashMap<String, String>,
157    errors: &mut Vec<Diagnostic>,
158) {
159    let mut seen_aliases = HashSet::new();
160    for imp in &program.imports {
161        if errors.len() >= MAX_DIAGNOSTICS {
162            return;
163        }
164        let path = imp.path.as_str();
165        // The vibe:0.1/ prefix is optional (T64). The version lives on
166        // the AST tag, not in a sacred string prefix. Both
167        // `import "vibe:0.1/math" as math;` and `import "math" as math;`
168        // are valid.
169        let ns = path
170            .strip_prefix("vibe:0.1/")
171            .or_else(|| path.strip_prefix("vibe:0.3/"))
172            .unwrap_or(path);
173        if !VALID_IMPORT_NS.contains(&ns)
174            && !crate::extension_registry::is_extension_namespace(ns)
175        {
176            errors.push(Diagnostic::new(
177                DiagCode::E100,
178                imp.span,
179                format!(
180                    "unknown namespace '{ns}'; valid: {}",
181                    VALID_IMPORT_NS.join(", ")
182                ),
183            ));
184            continue;
185        }
186        let default_alias = ns.rsplit('/').next().unwrap_or(ns);
187        let alias = imp.alias.as_deref().unwrap_or(default_alias);
188        if !seen_aliases.insert(alias) {
189            errors.push(Diagnostic::new(
190                DiagCode::E100,
191                imp.span,
192                format!("duplicate import alias '{alias}'"),
193            ));
194            continue;
195        }
196        aliases.insert(alias.to_string(), ns.to_string());
197    }
198}
199
200fn check_item(
201    item: &Item,
202    env: &mut CheckEnv,
203    mutables: &mut HashSet<String>,
204    aliases: &HashMap<String, String>,
205    granted: &[&str],
206) -> Result<Effect, Diagnostic> {
207    match item {
208        Item::Function(f) => check_function_in(f, env, aliases, granted),
209        Item::Hook(h) => check_hook(h, env, aliases, granted),
210        Item::Const(c) => {
211            let effect = walk_expr(&c.value, env, aliases, granted, Effect::Pure, false, false)?;
212            if effect > Effect::Pure {
213                return Err(Diagnostic::new(
214                    DiagCode::E200,
215                    c.span,
216                    "constant expression exceeds Pure effect class",
217                ));
218            }
219            env.insert(
220                c.name.clone(),
221                c.ty.as_ref().map(Type::from_ast).unwrap_or(Type::Unknown),
222            );
223            if let Some(value) = snapshot_value(&c.value, env) {
224                env.values.insert(c.name.clone(), value);
225            } else {
226                env.values.remove(&c.name);
227            }
228            Ok(effect)
229        }
230        Item::Statement(s) => walk_stmt(
231            s,
232            env,
233            mutables,
234            aliases,
235            granted,
236            Effect::External,
237            false,
238            false,
239        ),
240        Item::Enum(_) => Ok(Effect::Pure),
241        Item::Field(f) => {
242            let ty = crate::types::Type::from_ast(&f.ty);
243            let is_physical = matches!(
244                ty,
245                crate::types::Type::F64
246                    | crate::types::Type::Quantity
247                    | crate::types::Type::I64
248                    | crate::types::Type::U64
249            );
250            if is_physical && f.unit.is_none() {
251                return Err(Diagnostic::new(
252                    DiagCode::E100,
253                    f.span,
254                    format!(
255                        "field '{}' has physical type '{}' but no unit IRI — \
256                         physical fields require an explicit unit (X5). \
257                         Use `qudt:DimensionlessUnit` for dimensionless quantities.",
258                        f.name, f.ty.name
259                    ),
260                ));
261            }
262            Ok(Effect::Pure)
263        }
264        Item::Material(m) => {
265            let mut effect = Effect::Pure;
266            for prop in &m.properties {
267                effect = effect.join(walk_expr(
268                    &prop.value,
269                    env,
270                    aliases,
271                    granted,
272                    Effect::External,
273                    false,
274                    false,
275                )?);
276            }
277            Ok(effect)
278        }
279        Item::Cell(c) => {
280            let declared = c.effect.map(Effect::from_class).unwrap_or(Effect::Pure);
281            let mut cell_env = env.clone();
282            for p in &c.params {
283                cell_env.insert(p.name.clone(), Type::from_ast(&p.ty));
284            }
285            let mut effect = Effect::Pure;
286            if let Some(w) = &c.when {
287                let we = walk_expr(w, &mut cell_env, aliases, granted, declared, false, false)?;
288                effect = effect.join(we);
289            }
290            let e = walk_expr(
291                &c.expr,
292                &mut cell_env,
293                aliases,
294                granted,
295                declared,
296                false,
297                false,
298            )?;
299            if e.join(effect) > declared {
300                return Err(Diagnostic::new(
301                    DiagCode::E200,
302                    c.span,
303                    "cell expression exceeds declared effect class",
304                ));
305            }
306            Ok(effect.join(e))
307        }
308        Item::Law(l) => {
309            walk_expr(
310                &l.condition,
311                env,
312                aliases,
313                granted,
314                Effect::Pure,
315                false,
316                false,
317            )?;
318            walk_expr(
319                &l.consequence,
320                env,
321                aliases,
322                granted,
323                Effect::External,
324                false,
325                false,
326            )?;
327            Ok(Effect::External)
328        }
329        Item::Bind(b) => {
330            for endpoint in [&b.left, &b.right] {
331                if let Some(name) = root_name(endpoint) {
332                    env.values.remove(name);
333                }
334            }
335            walk_expr(
336                &b.left,
337                env,
338                aliases,
339                granted,
340                Effect::External,
341                false,
342                false,
343            )?;
344            walk_expr(
345                &b.right,
346                env,
347                aliases,
348                granted,
349                Effect::External,
350                false,
351                false,
352            )?;
353            if let Some((lo, hi)) = &b.clamp {
354                walk_expr(lo, env, aliases, granted, Effect::Pure, false, false)?;
355                walk_expr(hi, env, aliases, granted, Effect::Pure, false, false)?;
356            }
357            Ok(Effect::Pure)
358        }
359        Item::Present(p) => {
360            let mut effect = Effect::Pure;
361            for prop in &p.properties {
362                let e = walk_expr(
363                    &prop.value,
364                    env,
365                    aliases,
366                    granted,
367                    Effect::External,
368                    false,
369                    false,
370                )?;
371                effect = effect.join(e);
372            }
373            Ok(effect)
374        }
375    }
376}
377
378/// Checks cell.
379pub fn check_cell(expr: &Expr) -> Result<CheckResult, Diagnostic> {
380    let mut env = CheckEnv::default();
381    let aliases = HashMap::new();
382    let effect = walk_expr(expr, &mut env, &aliases, &[], Effect::Pure, true, false)?;
383    fabric_guard::check_expr_fabric(expr)?;
384    if effect > Effect::Pure {
385        return Err(Diagnostic::new(
386            DiagCode::E200,
387            expr.span,
388            "Pure cell cannot perform External effects",
389        ));
390    }
391    Ok(CheckResult { effect })
392}
393
394/// Checks function.
395fn check_function_in(
396    f: &FunctionDecl,
397    outer: &CheckEnv,
398    aliases: &HashMap<String, String>,
399    granted: &[&str],
400) -> Result<Effect, Diagnostic> {
401    let declared = f.effect.map(Effect::from_class).unwrap_or(Effect::Pure);
402    let mut env = outer.function_scope();
403    env.expected_return = f.ret.as_ref().map(Type::from_ast);
404    let mut mutables = HashSet::new();
405    for p in &f.params {
406        env.insert(p.name.clone(), Type::from_ast(&p.ty));
407    }
408    let has_budget = !f.budget.is_empty();
409    for arg in &f.budget {
410        env.budget_expression = true;
411        let effect = walk_expr(
412            &arg.value,
413            &mut env,
414            aliases,
415            granted,
416            Effect::Pure,
417            false,
418            false,
419        )?;
420        env.budget_expression = false;
421        if effect > Effect::Pure {
422            return Err(Diagnostic::new(
423                DiagCode::E200,
424                arg.span,
425                "budget expression must be Pure",
426            ));
427        }
428    }
429    let body = walk_block(
430        &f.body,
431        &mut env,
432        &mut mutables,
433        aliases,
434        granted,
435        declared,
436        false,
437        has_budget,
438    )?;
439    if body > declared && f.effect.is_some() {
440        return Err(Diagnostic::new(
441            DiagCode::E200,
442            f.span,
443            "function body exceeds declared effect class",
444        ));
445    }
446    Ok(body.join(declared))
447}
448
449fn check_hook(
450    h: &HookDecl,
451    outer: &CheckEnv,
452    aliases: &HashMap<String, String>,
453    granted: &[&str],
454) -> Result<Effect, Diagnostic> {
455    let is_tick = h.path == ["tick"];
456    let declared = if is_tick {
457        Effect::Hot
458    } else {
459        Effect::External
460    };
461    let mut env = outer.function_scope();
462    let mut mutables = HashSet::new();
463    for p in &h.params {
464        env.insert(p.name.clone(), Type::from_ast(&p.ty));
465    }
466    let has_budget = !h.budget.is_empty();
467    for arg in &h.budget {
468        env.budget_expression = true;
469        let effect = walk_expr(
470            &arg.value,
471            &mut env,
472            aliases,
473            granted,
474            Effect::Pure,
475            false,
476            false,
477        )?;
478        env.budget_expression = false;
479        if effect > Effect::Pure {
480            return Err(Diagnostic::new(
481                DiagCode::E200,
482                arg.span,
483                "budget expression must be Pure",
484            ));
485        }
486    }
487    walk_block(
488        &h.body,
489        &mut env,
490        &mut mutables,
491        aliases,
492        granted,
493        declared,
494        is_tick,
495        has_budget,
496    )
497}
498
499fn walk_block(
500    block: &Block,
501    env: &mut CheckEnv,
502    mutables: &mut HashSet<String>,
503    aliases: &HashMap<String, String>,
504    granted: &[&str],
505    ambient: Effect,
506    tick: bool,
507    budgeted: bool,
508) -> Result<Effect, Diagnostic> {
509    let mut scoped_env = env.clone();
510    let mut scoped_mutables = mutables.clone();
511    let mut e = Effect::Pure;
512    for s in &block.stmts {
513        e = e.join(walk_stmt(
514            s,
515            &mut scoped_env,
516            &mut scoped_mutables,
517            aliases,
518            granted,
519            ambient,
520            tick,
521            budgeted,
522        )?);
523    }
524    // The 0.1 evaluator shares Env across executable blocks. The checker keeps
525    // lexical type checking, but cannot retain stale callable facts for writes
526    // that may have happened at runtime in any branch/iteration.
527    env.values
528        .retain(|name, value| scoped_env.values.get(name) == Some(value));
529    Ok(e)
530}