chore: M5 CI/Workflow Sweep - final synchronisation

Author: hyperpolymath

src/codegen/ats_gen.rs

@@ -389,19 +389,19 @@ mod tests {
 
     #[test]
     fn test_parse_pattern() {
-        assert_eq!(parse_pattern("alloc").unwrap(), OwnershipPattern::Alloc);
-        assert_eq!(parse_pattern("free").unwrap(), OwnershipPattern::Free);
-        assert_eq!(parse_pattern("borrow").unwrap(), OwnershipPattern::Borrow);
+        assert_eq!(parse_pattern("alloc").expect("TODO: handle error"), OwnershipPattern::Alloc);
+        assert_eq!(parse_pattern("free").expect("TODO: handle error"), OwnershipPattern::Free);
+        assert_eq!(parse_pattern("borrow").expect("TODO: handle error"), OwnershipPattern::Borrow);
         assert_eq!(
-            parse_pattern("transfer").unwrap(),
+            parse_pattern("transfer").expect("TODO: handle error"),
             OwnershipPattern::Transfer
         );
         assert!(parse_pattern("invalid").is_err());
     }
 
     #[test]
     fn test_generate_module_empty() {
-        let module = generate_module("test", &[], &[], &[]).unwrap();
+        let module = generate_module("test", &[], &[], &[]).expect("TODO: handle error");
         assert_eq!(module.name, "test");
         assert!(module.viewtypes.is_empty());
         assert!(module.functions.is_empty());
@@ -426,7 +426,7 @@ mod tests {
             },
         ];
 
-        let module = generate_module("test", &[], &rules, &[]).unwrap();
+        let module = generate_module("test", &[], &rules, &[]).expect("TODO: handle error");
         assert_eq!(module.functions.len(), 2);
         assert_eq!(module.functions[0].name, "safe_my_alloc");
         assert_eq!(module.functions[1].name, "safe_my_free");
@@ -438,7 +438,7 @@ mod tests {
     #[test]
     fn test_render_module_produces_sats_and_dats() {
         let module = ATSModule::new("test");
-        let (sats, dats) = render_module(&module).unwrap();
+        let (sats, dats) = render_module(&module).expect("TODO: handle error");
         assert!(sats.contains("PMPL-1.0-or-later"));
         assert!(dats.contains("PMPL-1.0-or-later"));
         assert!(sats.contains("static signatures"));

src/codegen/compiler.rs

@@ -271,7 +271,7 @@ mod tests {
     #[test]
     fn test_build_command_structure() {
         let manifest = test_manifest();
-        let cmd = build_command(&manifest, "generated/ats/test_safe.dats", false).unwrap();
+        let cmd = build_command(&manifest, "generated/ats/test_safe.dats", false).expect("TODO: handle error");
 
         assert_eq!(cmd.program, "patscc");
         assert!(cmd.args.contains(&"-DATS_MEMALLOC_LIBC".to_string()));
@@ -285,7 +285,7 @@ mod tests {
     #[test]
     fn test_build_command_release() {
         let manifest = test_manifest();
-        let cmd = build_command(&manifest, "test.dats", true).unwrap();
+        let cmd = build_command(&manifest, "test.dats", true).expect("TODO: handle error");
 
         // Release mode should add -O2 via -ccopt
         let ccopt_indices: Vec<usize> = cmd
@@ -304,7 +304,7 @@ mod tests {
     #[test]
     fn test_typecheck_command() {
         let manifest = test_manifest();
-        let cmd = typecheck_command(&manifest, "test.dats").unwrap();
+        let cmd = typecheck_command(&manifest, "test.dats").expect("TODO: handle error");
 
         assert_eq!(cmd.program, "patsopt");
         assert!(cmd.args.contains(&"--typecheck".to_string()));
@@ -328,7 +328,7 @@ mod tests {
     fn test_build_command_without_patshome() {
         let mut manifest = test_manifest();
         manifest.ats2.patshome = None;
-        let cmd = build_command(&manifest, "test.dats", false).unwrap();
+        let cmd = build_command(&manifest, "test.dats", false).expect("TODO: handle error");
         assert!(cmd.env.is_empty());
     }
 }

src/codegen/parser.rs

@@ -263,7 +263,7 @@ mod tests {
     #[test]
     fn test_parse_simple_function() {
         let source = "void* malloc(size_t size);\n";
-        let sigs = parse_c_source(source).unwrap();
+        let sigs = parse_c_source(source).expect("TODO: handle error");
         assert_eq!(sigs.len(), 1);
         assert_eq!(sigs[0].name, "malloc");
         assert!(sigs[0].return_type.contains("void*"));
@@ -273,7 +273,7 @@ mod tests {
     #[test]
     fn test_parse_free_function() {
         let source = "void free(void* ptr);\n";
-        let sigs = parse_c_source(source).unwrap();
+        let sigs = parse_c_source(source).expect("TODO: handle error");
         assert_eq!(sigs.len(), 1);
         assert_eq!(sigs[0].name, "free");
         assert!(sigs[0].likely_free);
@@ -283,7 +283,7 @@ mod tests {
     #[test]
     fn test_parse_borrow_function() {
         let source = "size_t strlen(const char* s);\n";
-        let sigs = parse_c_source(source).unwrap();
+        let sigs = parse_c_source(source).expect("TODO: handle error");
         assert_eq!(sigs.len(), 1);
         assert_eq!(sigs[0].name, "strlen");
         assert!(!sigs[0].likely_alloc);
@@ -299,7 +299,7 @@ int printf(const char* fmt);
 FILE* fopen(const char* path, const char* mode);
 int fclose(FILE* fp);
 "#;
-        let sigs = parse_c_source(source).unwrap();
+        let sigs = parse_c_source(source).expect("TODO: handle error");
         assert_eq!(sigs.len(), 5);
     }
 
@@ -368,7 +368,7 @@ void free(void* ptr);
     #[test]
     fn test_void_params() {
         let source = "int getpid(void);\n";
-        let sigs = parse_c_source(source).unwrap();
+        let sigs = parse_c_source(source).expect("TODO: handle error");
         assert_eq!(sigs.len(), 1);
         assert!(sigs[0].params.is_empty());
     }

src/manifest/mod.rs

@@ -387,7 +387,7 @@ pattern = "alloc"
 [ats2]
 patsopt = "patsopt"
 "#;
-        let manifest: Manifest = toml::from_str(toml_str).unwrap();
+        let manifest: Manifest = toml::from_str(toml_str).expect("TODO: handle error");
         assert_eq!(manifest.project.name, "test");
         assert_eq!(manifest.c_sources.len(), 1);
         assert_eq!(manifest.ownership_rules.len(), 1);