Added C3 algorithm and fix linearization errors

Author: Sdoba16

src/driver/mod.rs

@@ -39,6 +39,12 @@ pub struct ProjectGraph {
     pub dependencies: HashMap<usize, Vec<usize>>,
 }
 
+#[derive(Debug)]
+pub enum C3Error {
+    CycleDetected(Vec<usize>),
+    InconsistentLinearization { module: usize },
+}
+
 fn parse_and_get_program(prog_file: &Path) -> Result<parse::Program, String> {
     let prog_text = std::fs::read_to_string(prog_file).map_err(|e| e.to_string())?;
     let file = prog_text.into();
@@ -51,6 +57,39 @@ fn parse_and_get_program(prog_file: &Path) -> Result<parse::Program, String> {
     }
 }
 
+// Function used by the C3 algorithm.
+fn merge(mut seqs: Vec<Vec<usize>>) -> Option<Vec<usize>> {
+    let mut result = Vec::new();
+
+    loop {
+        seqs.retain(|s| !s.is_empty());
+        if seqs.is_empty() {
+            return Some(result);
+        }
+
+        let mut candidate = None;
+
+        'outer: for seq in &seqs {
+            let head = seq[0];
+
+            if seqs.iter().all(|s| !s[1..].contains(&head)) {
+                candidate = Some(head);
+                break 'outer;
+            }
+        }
+
+        let head = candidate?;
+
+        result.push(head);
+
+        for seq in &mut seqs {
+            if seq.first() == Some(&head) {
+                seq.remove(0);
+            }
+        }
+    }
+}
+
 impl ProjectGraph {
     pub fn new(lib_cfg: &LibConfig, root_program: &parse::Program) -> Result<Self, String> {
         let mut modules: Vec<Module> = vec![Module {
@@ -87,7 +126,10 @@ impl ProjectGraph {
                 }
 
                 if let Some(&existing_id) = lookup.get(&path) {
-                    dependencies.entry(curr_id).or_default().push(existing_id);
+                    let deps = dependencies.entry(curr_id).or_default();
+                    if !deps.contains(&existing_id) {
+                        deps.push(existing_id);
+                    }
                     continue;
                 }
 
@@ -110,4 +152,54 @@ impl ProjectGraph {
             dependencies,
         })
     }
+
+    pub fn c3_linearize(&self) -> Result<Vec<usize>, C3Error> {
+        self.linearize_module(0)
+    }
+
+    fn linearize_module(&self, root: usize) -> Result<Vec<usize>, C3Error> {
+        let mut memo = HashMap::<usize, Vec<usize>>::new();
+        let mut visiting = Vec::<usize>::new();
+
+        self.linearize_rec(root, &mut memo, &mut visiting)
+    }
+
+    fn linearize_rec(
+        &self,
+        module: usize,
+        memo: &mut HashMap<usize, Vec<usize>>,
+        visiting: &mut Vec<usize>,
+    ) -> Result<Vec<usize>, C3Error> {
+        if let Some(result) = memo.get(&module) {
+            return Ok(result.clone());
+        }
+
+        if visiting.contains(&module) {
+            let cycle_start = visiting.iter().position(|m| *m == module).unwrap();
+            return Err(C3Error::CycleDetected(visiting[cycle_start..].to_vec()));
+        }
+
+        visiting.push(module);
+
+        let parents = self.dependencies.get(&module).cloned().unwrap_or_default();
+
+        let mut seqs: Vec<Vec<usize>> = Vec::new();
+
+        for parent in &parents {
+            let lin = self.linearize_rec(*parent, memo, visiting)?;
+            seqs.push(lin);
+        }
+
+        seqs.push(parents.clone());
+
+        let mut result = vec![module];
+        let merged = merge(seqs).ok_or(C3Error::InconsistentLinearization { module })?;
+
+        result.extend(merged);
+
+        visiting.pop();
+        memo.insert(module, result.clone());
+
+        Ok(result)
+    }
 }

src/driver/tests.rs

@@ -168,6 +168,69 @@ mod graph_construction_and_dependency_resolution {
     }
 }
 
+// Topological Sorting
+#[cfg(test)]
+mod c3_linearization {
+    use super::*;
+
+    #[test]
+    fn test_c3_simple_import() {
+        // Setup similar to above
+        let (graph, ids, _dir) = setup_graph(vec![
+            ("main.simf", "use lib::math::some_func;"),
+            ("libs/lib/math.simf", ""),
+        ]);
+
+        let order = graph.c3_linearize().expect("C3 failed");
+
+        let root_id = ids["main"];
+        let math_id = ids["math"];
+
+        // Assuming linearization order: Dependent (Root) -> Dependency (Math)
+        assert_eq!(order, vec![root_id, math_id]);
+    }
+
+    #[test]
+    fn test_c3_diamond_dependency_deduplication() {
+        // Setup:
+        // root -> imports A, B
+        // A -> imports Common
+        // B -> imports Common
+        // Expected: Common loaded ONLY ONCE.
+
+        let (graph, ids, _dir) = setup_graph(vec![
+            ("main.simf", "use lib::A::foo; use lib::B::bar;"),
+            ("libs/lib/A.simf", "use lib::Common::dummy1;"),
+            ("libs/lib/B.simf", "use lib::Common::dummy2;"),
+            ("libs/lib/Common.simf", ""),
+        ]);
+
+        let order = graph.c3_linearize().expect("C3 failed");
+
+        // Verify order using IDs from the helper map
+        let main_id = ids["main"];
+        let a_id = ids["A"];
+        let b_id = ids["B"];
+        let common_id = ids["Common"];
+
+        // In the `resolve_complication_order` function, the order was reversed.
+        // Therefore, `common` will be the first, and `main` will be last.
+        assert_eq!(order, vec![main_id, a_id, b_id, common_id]);
+    }
+
+    #[test]
+    fn test_c3_detects_cycle() {
+        let (graph, _, _dir) = setup_graph(vec![
+            ("main.simf", "use lib::A::entry;"),
+            ("libs/lib/A.simf", "use lib::B::func;"),
+            ("libs/lib/B.simf", "use lib::A::func;"),
+        ]);
+
+        let order = graph.c3_linearize();
+        matches!(order, Err(C3Error::CycleDetected(_)));
+    }
+}
+
 #[cfg(test)]
 mod error_diganostic_and_terminal_formatting {
     use super::*;