fix(types): emit A07003 when effects appear in must-not (#1539)

Source `must-not { io }` was parsed (`ClauseKind::MustNot`) and then
ignored. Spec A07003 is "Effect E in must-not list." A contract could
declare `effects { io }` and `must-not { io }` and type-check.

## Change

- Collect `must-not` effect names from contract/fn/extern clauses.
- Unknown names on that list are A07003 (same as unknown `effects`).
- If a declared, inferred, or callee effect (after group expansion) is
on the list, emit A07003.

## Validation

- `cargo test -p assura-types --locked --lib must_not`
- `cargo clippy -p assura-types --lib --locked -- -D warnings`

Signed-off-by: Sebastien Tardif <SebTardif@ncf.ca>

Author: SebTardif

crates/assura-types/src/checkers/effects.rs

@@ -344,6 +344,32 @@ impl EffectChecker {
     pub fn is_known(&self, effect: &str) -> bool {
         self.known_effects.contains(effect)
     }
+
+    /// A07003 when a used effect (or its expansion) is on the `must-not` list.
+    pub fn check_must_not(
+        &self,
+        used: &EffectSet,
+        forbidden: &EffectSet,
+        span: &Range<usize>,
+    ) -> Vec<EffectError> {
+        let used_exp = self.expand(used);
+        let forbidden_exp = self.expand(forbidden);
+        let mut errors = Vec::new();
+        let mut names: Vec<&str> = used_exp
+            .iter()
+            .filter(|name| forbidden_exp.contains(name))
+            .collect();
+        names.sort_unstable();
+        names.dedup();
+        for name in names {
+            errors.push(EffectError {
+                code: "A07003".into(),
+                message: format!("effect `{name}` is in the must-not list"),
+                span: span.clone(),
+            });
+        }
+        errors
+    }
 }
 
 impl EffectChecker {
@@ -357,6 +383,18 @@ impl EffectChecker {
                 continue;
             };
             let (declared, actual) = Self::extract_effects_from_clauses(clauses);
+            let must_not = Self::extract_must_not_from_clauses(clauses);
+            if let Some(ref forbidden) = must_not {
+                for ee in checker.check_known(forbidden, &decl.span) {
+                    errors.push(TypeError {
+                        code: ee.code,
+                        message: ee.message,
+                        span: ee.span,
+                        secondary: None,
+                        suggestion: None,
+                    });
+                }
+            }
             if let Some(ref declared_set) = declared {
                 for ee in checker.check_known(declared_set, &decl.span) {
                     errors.push(TypeError {
@@ -368,8 +406,8 @@ impl EffectChecker {
                     });
                 }
                 if matches!(&decl.node, Decl::FnDef(_)) {
-                    if let Some(actual_set) = actual {
-                        for ee in checker.check_containment(declared_set, &actual_set, &decl.span) {
+                    if let Some(ref actual_set) = actual {
+                        for ee in checker.check_containment(declared_set, actual_set, &decl.span) {
                             errors.push(TypeError {
                                 code: ee.code,
                                 message: ee.message,
@@ -389,6 +427,47 @@ impl EffectChecker {
                             suggestion: None,
                         });
                     }
+                    if let Some(ref forbidden) = must_not {
+                        for ee in checker.check_must_not(declared_set, forbidden, &decl.span) {
+                            errors.push(TypeError {
+                                code: ee.code,
+                                message: ee.message,
+                                span: ee.span,
+                                secondary: None,
+                                suggestion: None,
+                            });
+                        }
+                        if let Some(ref actual_set) = actual {
+                            for ee in checker.check_must_not(actual_set, forbidden, &decl.span) {
+                                errors.push(TypeError {
+                                    code: ee.code,
+                                    message: ee.message,
+                                    span: ee.span,
+                                    secondary: None,
+                                    suggestion: None,
+                                });
+                            }
+                        }
+                        for ee in checker.check_must_not(&callee_effects, forbidden, &decl.span) {
+                            errors.push(TypeError {
+                                code: ee.code,
+                                message: ee.message,
+                                span: ee.span,
+                                secondary: None,
+                                suggestion: None,
+                            });
+                        }
+                    }
+                } else if let Some(ref forbidden) = must_not {
+                    for ee in checker.check_must_not(declared_set, forbidden, &decl.span) {
+                        errors.push(TypeError {
+                            code: ee.code,
+                            message: ee.message,
+                            span: ee.span,
+                            secondary: None,
+                            suggestion: None,
+                        });
+                    }
                 }
             }
         }
@@ -423,6 +502,20 @@ impl EffectChecker {
         map
     }
 
+    fn extract_must_not_from_clauses(clauses: &[assura_parser::ast::Clause]) -> Option<EffectSet> {
+        let mut names = Vec::new();
+        for clause in clauses {
+            if clause.kind == ClauseKind::MustNot {
+                names.extend(Self::extract_effect_names_from_expr(&clause.body));
+            }
+        }
+        if names.is_empty() {
+            None
+        } else {
+            Some(EffectSet::from_effect_names(names))
+        }
+    }
+
     /// Extract declared and actual effect sets from a list of clauses.
     pub fn extract_effects_from_clauses(
         clauses: &[assura_parser::ast::Clause],

crates/assura-types/src/checks/effects_tests.rs

@@ -39,3 +39,51 @@ fn test_effect_polymorphism_basic() {
         "effect variable E should not produce A07003, got: {a07003_errors:?}"
     );
 }
+
+#[test]
+fn must_not_io_with_effects_io_a07003() {
+    let sf = parse_source(
+        r#"contract Forbidden {
+            effects { io }
+            must-not { io }
+            requires { true }
+        }"#,
+    );
+    let errs = run_effect_checks(&sf);
+    assert!(
+        errs.iter()
+            .any(|e| e.code == "A07003" && e.message.contains("must-not")),
+        "effects(io) + must-not(io) must be A07003, got: {errs:?}"
+    );
+}
+
+#[test]
+fn must_not_database_allows_effects_io() {
+    let sf = parse_source(
+        r#"contract OkIo {
+            effects { io }
+            must-not { database }
+            requires { true }
+        }"#,
+    );
+    let errs = run_effect_checks(&sf);
+    assert!(
+        !errs.iter().any(|e| e.message.contains("must-not")),
+        "io is not in must-not database, got: {errs:?}"
+    );
+}
+
+#[test]
+fn must_not_unknown_name_a07003() {
+    let sf = parse_source(
+        r#"contract BadForbid {
+            must-not { teleport }
+            requires { true }
+        }"#,
+    );
+    let errs = run_effect_checks(&sf);
+    assert!(
+        errs.iter().any(|e| e.code == "A07003"),
+        "unknown must-not name must be A07003, got: {errs:?}"
+    );
+}