1use 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
29pub 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
94pub 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
126pub 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
135pub 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 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
378pub 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
394fn 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 env.values
528 .retain(|name, value| scoped_env.values.get(name) == Some(value));
529 Ok(e)
530}