test: strengthen is_some+unwrap assertions (MPI cycle 2) (#1452)

## Summary

Multi-perspective improvement cycle (2026-08-03), Test Auditor–led.

- **Test integrity:** Replaced 27 `assert!(x.is_some())` + `x.unwrap()`
pairs with `.expect(...)` / `expect(...).field` so failures surface the
assertion message instead of a bare unwrap panic. Touches types,
pipeline, config, diagnostics, resolve, parser snapshots, and CVC5 shell
tests.
- **Docs:** `docs/CRATES-IO.md` documents the dual-version packaging
footgun when monorepo shared crates (for example `rowan`) diverge from
crates.io (lesson from #1451).

## Test plan

- [x] `cargo test -p assura-pipeline --lib --locked`
- [x] `cargo test -p assura-config --lib --locked`
- [x] `cargo test -p assura-diagnostics --lib --locked`
- [x] `cargo test -p assura-types --lib --locked`
- [x] `cargo test -p assura-resolve --lib --locked`
- [x] `cargo test -p assura-parser --test snapshots --locked`
- [x] `bash scripts/guards.sh`
- [ ] CI green

## Not in this PR

- Release PR **#1450** (0.4.1) is open and CONFLICTING after #1451.
Needs maintainer re-sync and **explicit** approval before merge
(publishes crates).
- Human launch issues #1410 / #1411 / #1396; blocked #436.

---------

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

Author: SebTardif

crates/assura-config/src/lib_tests.rs

@@ -718,8 +718,7 @@ fn load_project_config_reads_valid_toml() {
     .unwrap();
 
     let result = load_project_config(dir.path(), find_root_here);
-    assert!(result.is_some(), "should parse valid assura.toml");
-    let (config, root) = result.unwrap();
+    let (config, root) = result.expect("should parse valid assura.toml");
     assert_eq!(config.package.name, "test-proj");
     assert_eq!(config.package.version, "1.0.0");
     assert_eq!(config.verify.layer, 2);

crates/assura-diagnostics/src/lib.rs

@@ -402,9 +402,10 @@ mod tests {
     fn test_explain_all_catalog_codes() {
         let catalog = error_catalog();
         for entry in &catalog {
-            let found = explain(entry.code);
-            assert!(found.is_some(), "should find {}", entry.code);
-            assert_eq!(found.unwrap().code, entry.code);
+            let found = explain(entry.code).unwrap_or_else(|| {
+                panic!("should find {}", entry.code);
+            });
+            assert_eq!(found.code, entry.code);
         }
     }
 

crates/assura-parser/tests/snapshots.rs

@@ -469,8 +469,7 @@ fn recovery_multiple_contracts_one_broken() {
         "#,
     );
     // Parser should recover from Bad and still parse AlsoGood
-    assert!(ast.is_some(), "expected AST despite one broken contract");
-    let sf = ast.unwrap();
+    let sf = ast.expect("expected AST despite one broken contract");
     // Should have at least 2 contract declarations (Good and AlsoGood)
     let contract_count = sf
         .decls

crates/assura-pipeline/src/lib_tests.rs

@@ -639,8 +639,7 @@ fn compile_full_produces_codegen_output() {
         "unexpected errors: {:?}",
         output.diagnostics
     );
-    assert!(output.generated.is_some(), "codegen should produce output");
-    let generated = output.generated.unwrap();
+    let generated = output.generated.expect("codegen should produce output");
     assert!(
         !generated.files.is_empty(),
         "generated project should have files"

crates/assura-resolve/src/resolve_tests.rs

@@ -879,8 +879,10 @@ type Outer {
         .expect("Outer scope not found");
     // Int is in root scope; lookup from Outer scope should find it
     let int_sym = table.lookup("Int", outer_scope);
-    assert!(int_sym.is_some(), "Int should be found via scope chain");
-    assert_eq!(int_sym.unwrap().kind, SymbolKind::BuiltinType);
+    assert_eq!(
+        int_sym.expect("Int should be found via scope chain").kind,
+        SymbolKind::BuiltinType
+    );
     // Nonexistent name should return None
     let missing = table.lookup("DoesNotExist", outer_scope);
     assert!(missing.is_none(), "missing name should return None");

crates/assura-smt/src/tests_cvc5_shell.rs

@@ -511,8 +511,7 @@ fn shell_old_ident_encoding() {
     let inner = Spanned::no_span(Expr::Ident("x".into()));
     let result = encode_old_smtlib(&inner, expr_to_smtlib);
     // old(x) for an ident should produce the old snapshot name
-    assert!(result.is_some(), "old(x) should encode");
-    let smt = result.unwrap();
+    let smt = result.expect("old(x) should encode");
     assert!(
         smt.contains("old"),
         "old(x) should contain 'old' in the name, got: {smt}"

crates/assura-types/src/tests/domain_checkers/fixed_width.rs

@@ -63,8 +63,7 @@ fn fixed_width_u8_overflow_add() {
     // U8 + U8: 255 + 255 = 510 > 255 -> overflow
     let checker = FixedWidthChecker::new();
     let err = checker.check_arithmetic_overflow(&AstBinOp::Add, &Type::U8, &Type::U8, &(0..1));
-    assert!(err.is_some(), "U8 + U8 should detect potential overflow");
-    let e = err.unwrap();
+    let e = err.expect("U8 + U8 should detect potential overflow");
     assert_eq!(e.code, "A10101");
     assert!(e.message.contains("checked_add"));
 }
@@ -74,8 +73,10 @@ fn fixed_width_i8_overflow_add() {
     // I8 + I8: 127 + 127 = 254 > 127 -> overflow
     let checker = FixedWidthChecker::new();
     let err = checker.check_arithmetic_overflow(&AstBinOp::Add, &Type::I8, &Type::I8, &(0..1));
-    assert!(err.is_some(), "I8 + I8 should detect potential overflow");
-    assert_eq!(err.unwrap().code, "A10101");
+    assert_eq!(
+        err.expect("I8 + I8 should detect potential overflow").code,
+        "A10101"
+    );
 }
 
 #[test]
@@ -92,17 +93,18 @@ fn fixed_width_mul_overflow() {
     // U8 * U8: 255 * 255 = 65025 > 255 -> overflow
     let checker = FixedWidthChecker::new();
     let err = checker.check_arithmetic_overflow(&AstBinOp::Mul, &Type::U8, &Type::U8, &(0..1));
-    assert!(err.is_some(), "U8 * U8 should detect potential overflow");
-    let e = err.unwrap();
+    let e = err.expect("U8 * U8 should detect potential overflow");
     assert!(e.message.contains("checked_mul"));
 }
 
 #[test]
 fn fixed_width_narrowing_cast_u32_to_u16() {
     // U32 -> U16: max 4294967295 > 65535 -> unsafe
     let err = FixedWidthChecker::check_cast_safety(&Type::U32, &Type::U16, &(0..1));
-    assert!(err.is_some(), "U32 -> U16 should be unsafe narrowing");
-    assert_eq!(err.unwrap().code, "A10102");
+    assert_eq!(
+        err.expect("U32 -> U16 should be unsafe narrowing").code,
+        "A10102"
+    );
 }
 
 #[test]
@@ -121,8 +123,10 @@ fn fixed_width_signed_unsigned_comparison() {
         &Type::U32,
         &(0..1),
     );
-    assert!(err.is_some(), "I32 vs U32 comparison should warn");
-    assert_eq!(err.unwrap().code, "A10103");
+    assert_eq!(
+        err.expect("I32 vs U32 comparison should warn").code,
+        "A10103"
+    );
 }
 
 #[test]
@@ -141,8 +145,10 @@ fn fixed_width_same_signedness_ok() {
 fn fixed_width_division_by_zero() {
     let rhs = Spanned::no_span(AstExpr::Literal(AstLit::Int("0".into())));
     let err = FixedWidthChecker::check_division_by_zero(&AstBinOp::Div, &rhs, &Type::U32, &(0..1));
-    assert!(err.is_some(), "division by literal 0 should be flagged");
-    assert_eq!(err.unwrap().code, "A10104");
+    assert_eq!(
+        err.expect("division by literal 0 should be flagged").code,
+        "A10104"
+    );
 }
 
 #[test]
@@ -181,8 +187,10 @@ fn fixed_width_cast_i32_to_u32() {
     // I32 -> U32: signed-to-unsigned, range [-2^31, 2^31-1] does not
     // fit in [0, 2^32-1] because of negative values -> unsafe
     let err = FixedWidthChecker::check_cast_safety(&Type::I32, &Type::U32, &(0..1));
-    assert!(err.is_some(), "I32 -> U32 cast should be unsafe");
-    assert_eq!(err.unwrap().code, "A10102");
+    assert_eq!(
+        err.expect("I32 -> U32 cast should be unsafe").code,
+        "A10102"
+    );
 }
 
 #[test]
@@ -222,8 +230,7 @@ fn fixed_width_check_binop_combined() {
 fn fixed_width_modulo_by_zero() {
     let rhs = Spanned::no_span(AstExpr::Literal(AstLit::Int("0".into())));
     let err = FixedWidthChecker::check_division_by_zero(&AstBinOp::Mod, &rhs, &Type::I32, &(0..1));
-    assert!(err.is_some(), "modulo by zero should be flagged");
-    let e = err.unwrap();
+    let e = err.expect("modulo by zero should be flagged");
     assert_eq!(e.code, "A10104");
     assert!(e.message.contains("modulo"));
 }
@@ -233,8 +240,10 @@ fn fixed_width_sub_overflow_unsigned() {
     // U8 - U8: 0 - 255 = -255 < 0 -> overflow (underflow)
     let checker = FixedWidthChecker::new();
     let err = checker.check_arithmetic_overflow(&AstBinOp::Sub, &Type::U8, &Type::U8, &(0..1));
-    assert!(err.is_some(), "U8 - U8 should detect potential underflow");
-    assert_eq!(err.unwrap().code, "A10101");
+    assert_eq!(
+        err.expect("U8 - U8 should detect potential underflow").code,
+        "A10101"
+    );
 }
 
 #[test]

crates/assura-types/src/tests/domain_checkers/remaining.rs

@@ -1648,8 +1648,11 @@ fn error_propagation_dc_swallow_a12001() {
         },
     );
     let err = checker.validate_catch("CRITICAL_ERROR", ErrorAction::Swallow, 0..10);
-    assert!(err.is_some(), "swallowing must_propagate error should fail");
-    assert_eq!(err.unwrap().code, "A12001");
+    assert_eq!(
+        err.expect("swallowing must_propagate error should fail")
+            .code,
+        "A12001"
+    );
 }
 
 // InterfaceChecker: missing method triggers A13001

crates/assura-types/src/tests/integration/domain.rs

@@ -389,8 +389,10 @@ fn circular_buffer_check_index_wired() {
     checker.declare("buf".into(), 4);
     // Index 0 on empty buffer: check_index should flag it
     let err = checker.check_index("buf", 5, &(0..1));
-    assert!(err.is_some(), "index 5 on capacity-4 buffer should error");
-    assert_eq!(err.unwrap().code, "A23001");
+    assert_eq!(
+        err.expect("index 5 on capacity-4 buffer should error").code,
+        "A23001"
+    );
 }
 
 // =========================================================================
@@ -622,8 +624,10 @@ fn resource_limit_unbounded_detected() {
     let checker = ResourceLimitChecker::new();
     // No limit declared for "cpu"
     let err = checker.check_unbounded("cpu");
-    assert!(err.is_some(), "unbounded resource should be detected");
-    assert_eq!(err.unwrap().code, "A46002");
+    assert_eq!(
+        err.expect("unbounded resource should be detected").code,
+        "A46002"
+    );
 }
 
 #[test]
@@ -836,17 +840,21 @@ fn ulp_bound_violation_detected() {
     let mut checker = NumericalPrecisionChecker::new();
     checker.declare("y".into(), 64, 1.0, 0..1);
     let err = checker.check_ulp_bound("y", 2.5);
-    assert!(err.is_some(), "ULP 2.5 > min 1.0 should trigger A42002");
-    assert_eq!(err.unwrap().code, "A42002");
+    assert_eq!(
+        err.expect("ULP 2.5 > min 1.0 should trigger A42002").code,
+        "A42002"
+    );
 }
 
 #[test]
 fn cancellation_detected() {
     let mut checker = NumericalPrecisionChecker::new();
     checker.declare("z".into(), 64, 1.0, 0..1);
     let err = checker.check_cancellation("z", 0.99999);
-    assert!(err.is_some(), "ratio 0.99999 should trigger A42003");
-    assert_eq!(err.unwrap().code, "A42003");
+    assert_eq!(
+        err.expect("ratio 0.99999 should trigger A42003").code,
+        "A42003"
+    );
 }
 
 #[test]

crates/assura-types/src/tests/interactions.rs

@@ -1386,8 +1386,11 @@ fn test_error_propagation_must_propagate_swallow_rejected() {
 
     // Swallowing a must_propagate error should produce A12001
     let err = checker.validate_catch("SQLITE_CORRUPT", ErrorAction::Swallow, 0..10);
-    assert!(err.is_some(), "swallowing must_propagate error should fail");
-    assert_eq!(err.unwrap().code, "A12001");
+    assert_eq!(
+        err.expect("swallowing must_propagate error should fail")
+            .code,
+        "A12001"
+    );
 
     // Propagating is fine
     let err = checker.validate_catch("SQLITE_CORRUPT", ErrorAction::Propagate, 0..10);
@@ -1425,8 +1428,10 @@ fn test_error_propagation_must_not_mask() {
         ErrorAction::TranslateTo("SQLITE_OK".into()),
         0..10,
     );
-    assert!(err.is_some(), "forbidden translation should fail");
-    assert_eq!(err.unwrap().code, "A12002");
+    assert_eq!(
+        err.expect("forbidden translation should fail").code,
+        "A12002"
+    );
 
     // Allowed translation should pass
     let err = checker.validate_catch(
@@ -1450,8 +1455,10 @@ fn test_error_propagation_must_check() {
 
     // Unchecked call to must_check function -> A12003
     let err = checker.validate_unchecked_call("sqlite3_reset", 0..10);
-    assert!(err.is_some(), "unchecked must_check call should fail");
-    assert_eq!(err.unwrap().code, "A12003");
+    assert_eq!(
+        err.expect("unchecked must_check call should fail").code,
+        "A12003"
+    );
 
     // Non-must_check function is fine
     let err = checker.validate_unchecked_call("sqlite3_open", 0..10);