Error test cases, multifile error case

Author: Sdoba16

functional-tests/error-test-cases/name-collision/lib/groups.simf

@@ -0,0 +1,3 @@
+pub fn add(a: u32, b: u32) -> (bool, u32) {
+    jet::add_32(a, b)
+}

functional-tests/error-test-cases/name-collision/lib/math.simf

@@ -0,0 +1,4 @@
+pub fn add(a: u32, b: u32) -> (bool, u32) {
+    let (_, c): (bool, u32) = jet::add_32(a, b);
+    jet::add_32(c, 1)
+}

functional-tests/error-test-cases/name-collision/main.simf

@@ -0,0 +1,9 @@
+use lib::groups::add;
+use lib::math::add;
+
+fn main() {
+    let x: u32 = 5;
+    let y: u32 = 10;
+    let (_, result): (bool, u32) = add(x, y);
+    assert!(jet::eq_32(result, 16));
+}

src/driver.rs

@@ -1513,4 +1513,158 @@ pub(crate) mod tests {
             "Compiler must catch infinite alias cycles"
         );
     }
+
+    // --- C3 Error Display Tests ---
+
+    #[test]
+    fn display_c3_cycle_detected() {
+        let cycle = vec![
+            "main.simf".to_string(),
+            "libs/lib/A.simf".to_string(),
+            "libs/lib/B.simf".to_string(),
+            "main.simf".to_string(),
+        ];
+
+        let error = C3Error::CycleDetected(cycle);
+
+        let expected = r#"Circular dependency detected: "main.simf -> libs/lib/A.simf -> libs/lib/B.simf -> main.simf""#;
+
+        assert_eq!(error.to_string(), expected);
+    }
+
+    #[test]
+    fn display_c3_inconsistent_linearization() {
+        let conflicts = vec![
+            vec!["lib/x".to_string(), "lib/y".to_string()],
+            vec!["lib/y".to_string(), "lib/x".to_string()],
+        ];
+
+        let error = C3Error::InconsistentLinearization {
+            module: "main".to_string(),
+            conflicts,
+        };
+
+        let expected = r#"Inconsistent resolution order for module 'main'
+The compiler could not resolve the following conflicting import constraints:
+  [lib/x, lib/y]
+  [lib/y, lib/x]
+Try reordering your `use` statements to avoid cross-wiring."#
+            .to_string();
+
+        assert_eq!(error.to_string(), expected);
+    }
+
+    // --- Dependent File Error Display Tests ---
+
+    #[test]
+    #[ignore = "TODO(Error_Formatting): The compiler currently strips the .simf extension from file paths during graph construction. This test expects the extension to be preserved."]
+    fn test_display_error_in_imported_dependency() {
+        let temp_dir = TempDir::new().unwrap();
+        let root_path = create_simf_file(temp_dir.path(), "main.simf", "use lib::math::add;");
+
+        create_simf_file(
+            temp_dir.path(),
+            "libs/lib/math.simf",
+            "pub fn add(a: u32 b: u32) {}",
+        );
+
+        let mut lib_map = HashMap::new();
+        lib_map.insert("lib".to_string(), temp_dir.path().join("libs/lib"));
+
+        let (root_program, root_source) = parse_root(&root_path);
+        let mut handler = ErrorCollector::new();
+
+        let result =
+            ProjectGraph::new(root_source, Arc::from(lib_map), &root_program, &mut handler);
+
+        assert!(
+            result.is_none(),
+            "Graph construction should fail due to syntax error in dependency"
+        );
+        assert!(
+            handler.has_errors(),
+            "Handler should contain the imported module's error"
+        );
+
+        let err_msg = ErrorCollector::to_string(&handler);
+
+        assert!(
+            err_msg.contains("math.simf:1"),
+            "Error should correctly display the file name math.simf and line number. Got:\n{}",
+            err_msg
+        );
+        assert!(
+            err_msg.contains("pub fn add(a: u32 b: u32) {}"),
+            "Error should print the snippet from the imported file. Got:\n{}",
+            err_msg
+        );
+    }
+
+    #[test]
+    #[ignore = "TODO(Error_Formatting): The compiler currently strips the .simf extension from file paths during graph construction. This test expects the extension to be preserved."]
+    fn test_display_unresolved_item_in_dependency() {
+        let (graph, ids, _dir) = setup_graph(vec![
+            ("libs/lib/B.simf", "pub fn real() {}"),
+            ("libs/lib/A.simf", "use lib::B::ghost;\npub fn foo() {}"),
+            ("main.simf", "use lib::A::foo;"),
+        ]);
+
+        let id_a = *ids.get("A").unwrap();
+        let id_b = *ids.get("B").unwrap();
+        let id_root = *ids.get("main").unwrap();
+        let order = vec![id_b, id_a, id_root];
+
+        let mut handler = ErrorCollector::new();
+        let _ = graph.build_program(&order, &mut handler);
+
+        let err_msg = ErrorCollector::to_string(&handler);
+
+        assert!(
+            err_msg.contains("A.simf:1"),
+            "Error should point to A.simf where the bad import happened. Got:\n{}",
+            err_msg
+        );
+        assert!(
+            err_msg.contains("use lib::B::ghost;"),
+            "Error should print the snippet from A.simf"
+        );
+        assert!(
+            err_msg.contains("Unknown item `ghost`"),
+            "Error should correctly identify the missing item"
+        );
+    }
+
+    #[test]
+    #[ignore = "TODO(Error_Formatting): The compiler currently strips the .simf extension from file paths during graph construction. This test expects the extension to be preserved."]
+    fn test_display_private_item_access_in_dependency() {
+        let (graph, ids, _dir) = setup_graph(vec![
+            ("libs/lib/B.simf", "fn secret() {}"),
+            ("libs/lib/A.simf", "use lib::B::secret;\npub fn foo() {}"),
+            ("main.simf", "use lib::A::foo;"),
+        ]);
+
+        let id_a = *ids.get("A").unwrap();
+        let id_b = *ids.get("B").unwrap();
+        let id_root = *ids.get("main").unwrap();
+        let order = vec![id_b, id_a, id_root];
+
+        let mut handler = ErrorCollector::new();
+        let _ = graph.build_program(&order, &mut handler);
+
+        let err_msg = ErrorCollector::to_string(&handler);
+
+        assert!(
+            err_msg.contains("A.simf:1"),
+            "Error should point to A.simf where the privacy violation happened. Got:\n{}",
+            err_msg
+        );
+        assert!(
+            err_msg.contains("use lib::B::secret;"),
+            "Error should print the snippet from A.simf"
+        );
+        assert!(
+            err_msg.contains("Item `secret` is private"),
+            "Error should correctly identify the privacy violation"
+        );
+    }
 }

src/error.rs

@@ -443,7 +443,6 @@ pub enum Error {
     FileNotFound(PathBuf),
     UnresolvedItem(Identifier),
     PrivateItem(String),
-    NameCollision(String),
     MainNoInputs,
     MainNoOutput,
     MainRequired,
@@ -564,10 +563,6 @@ impl fmt::Display for Error {
                 f,
                 "Item `{name}` is private"
             ),
-            Error::NameCollision(name) => write!(
-                f,
-                "The name `{name}` is defined multiple times in this scope"
-            ),
             Error::InvalidNumberOfArguments(expected, found) => write!(
                 f,
                 "Expected {expected} arguments, found {found} arguments"
@@ -774,18 +769,68 @@ let x: u32 = Left(
     }
 
     #[test]
-    fn display_private_item() {
-        let source = SourceFile::new(SourceName::Virtual(Arc::from(FILENAME)), Arc::from(FILE));
-        let error = Error::PrivateItem("SecretType".to_string())
-            .with_span(Span::new(8, 20))
+    fn display_error_inside_imported_module() {
+        let module_name = "libs/math.simf";
+        let module_content = "pub fn add(a: u32, b: u32) -> u64 {\n    a + b\n}";
+        let source = SourceFile::new(
+            SourceName::Virtual(Arc::from(module_name)),
+            Arc::from(module_content),
+        );
+
+        let error = Error::InvalidNumberOfArguments(2, 1)
+            .with_span(Span::new(40, 45))
             .with_source(source);
-        let expected = format!(
-            r#"
- --> {FILENAME}:1:9
+
+        let expected = r#"
+ --> libs/math.simf:2:6
   |
-1 | let a1: List<u32, 5> = None;
-  |         ^^^^^^^^^^^^ Item `SecretType` is private"#
+2 |     a + b
+  |      ^^^^^ Expected 2 arguments, found 1 arguments"#
+            .to_string();
+        assert_eq!(&expected[1..], &error.to_string());
+    }
+
+    #[test]
+    fn display_unresolved_import_in_main_file() {
+        let main_name = "main.simf";
+        let main_content = "use libs::math::multiply;\n\nfn main() {}";
+        let source = SourceFile::new(
+            SourceName::Virtual(Arc::from(main_name)),
+            Arc::from(main_content),
         );
+
+        let error = Error::UnresolvedItem("multiply".into())
+            .with_span(Span::new(16, 24))
+            .with_source(source);
+
+        let expected = r#"
+ --> main.simf:1:17
+  |
+1 | use libs::math::multiply;
+  |                 ^^^^^^^^ Unknown item `multiply`"#
+            .to_string();
+        assert_eq!(&expected[1..], &error.to_string());
+    }
+
+    #[test]
+    fn display_private_item_import_across_modules() {
+        let main_name = "src/auth_test.simf";
+        let main_content = "use libs::auth::SecretToken;\n\nfn main() {}";
+        let source = SourceFile::new(
+            SourceName::Virtual(Arc::from(main_name)),
+            Arc::from(main_content),
+        );
+
+        let error = Error::PrivateItem("SecretToken".into())
+            .with_span(Span::new(16, 27))
+            .with_source(source);
+
+        let expected = r#"
+ --> src/auth_test.simf:1:17
+  |
+1 | use libs::auth::SecretToken;
+  |                 ^^^^^^^^^^^ Item `SecretToken` is private"#
+            .to_string();
         assert_eq!(&expected[1..], &error.to_string());
     }
 }