Refactoring, tests, bug-fixing

Author: Sdoba16

examples/collisions/libs/accurate_math.simf

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

examples/collisions/libs/fast_math.simf

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

examples/collisions/main.simf

@@ -0,0 +1,5 @@
+use math::add;
+
+fn main() {
+    let result: (bool, u32) = add(20, 20);
+}

examples/visibility/helper.simf

@@ -0,0 +1,7 @@
+fn do_something_private() {
+    let x: u32 = 42;
+}
+
+pub fn do_something_public() {
+    do_something_private(); 
+}

examples/visibility/main.simf

@@ -0,0 +1,5 @@
+use secret_lib::do_something_public;
+
+fn main() {
+    do_something_public();
+}

src/ast.rs

@@ -1540,14 +1540,18 @@ impl AbstractSyntaxTree for Match {
     }
 }
 
+/// Analyze a parsed module program to extract assignments for a specific module.
+///
+/// This function searches the parsed program for a module matching the given `name`.
+/// If found, it evaluates the module's assignments and returns them as a map of
+/// witness names to their constant values. If the module is not present, an empty
+/// map is returned.
 fn analyze_named_module(
     name: ModuleName,
     from: &parse::ModuleProgram,
 ) -> Result<HashMap<WitnessName, Value>, RichError> {
     let unit = ResolvedType::unit();
 
-    // IMPORTANT! If modules allow imports, then we need to consider
-    // passing the resolution conetxt by calling `Scope::new(resolutions)`
     let mut scope = Scope::default();
     let items = from
         .items()

src/driver.rs

@@ -313,7 +313,17 @@ impl_eq_hash!(TypeAlias; name, ty);
 #[derive(Debug)]
 pub enum C3Error {
     CycleDetected(Vec<String>),
-    InconsistentLinearization { module: String },
+    /// Error for inconsistent MRO.
+    /// This can happen if the dependency graph has a shape that makes the
+    /// order of parent classes ambiguous.
+    /// Example: A depends on B and C, and B also depends on C.
+    /// The linearization of A is A + merge(linearization(B), linearization(C), [B, C]).
+    /// If B appears before C in one parent's linearization but C appears before B
+    /// in another's, the merge will fail.
+    InconsistentLinearization {
+        module: String,
+        conflicts: Vec<Vec<String>>,
+    },
 }
 
 impl fmt::Display for C3Error {
@@ -322,8 +332,22 @@ impl fmt::Display for C3Error {
             C3Error::CycleDetected(cycle) => {
                 write!(f, "Circular dependency detected: {:?}", cycle.join(" -> "))
             }
-            C3Error::InconsistentLinearization { module } => {
-                write!(f, "Inconsistent resolution order for module '{:?}'", module)
+            C3Error::InconsistentLinearization { module, conflicts } => {
+                writeln!(f, "Inconsistent resolution order for module '{}'", module)?;
+                writeln!(
+                    f,
+                    "The compiler could not resolve the following conflicting import constraints:"
+                )?;
+
+                // Loop through the matrix and print each conflicting sequence
+                for conflict in conflicts {
+                    writeln!(f, "  [{}]", conflict.join(", "))?;
+                }
+
+                write!(
+                    f,
+                    "Try reordering your `use` statements to avoid cross-wiring."
+                )
             }
         }
     }
@@ -489,12 +513,26 @@ impl ProjectGraph {
             seqs.push(line);
         }
 
-        seqs.push(parents.clone());
-
         let mut result = vec![module];
-        let merged = merge(seqs).ok_or(C3Error::InconsistentLinearization {
-            module: self.modules[module].source.name().to_string(),
-        })?;
+        let merged = match merge(seqs) {
+            Ok(m) => m,
+            Err(conflicts) => {
+                // Map the failing usize sequences into readable module names
+                let conflict_names: Vec<Vec<String>> = conflicts
+                    .into_iter()
+                    .map(|seq| {
+                        seq.into_iter()
+                            .map(|id| self.modules[id].source.name().to_string())
+                            .collect()
+                    })
+                    .collect();
+
+                return Err(C3Error::InconsistentLinearization {
+                    module: self.modules[module].source.name().to_string(),
+                    conflicts: conflict_names,
+                });
+            }
+        };
 
         result.extend(merged);
 
@@ -720,13 +758,18 @@ impl ProjectGraph {
     }
 }
 
-fn merge(mut seqs: Vec<Vec<usize>>) -> Option<Vec<usize>> {
+/// C3 Merge Algorithm
+///
+/// Merges a list of sequences (parent linearizations) into a single sequence.
+/// The algorithm ensures that the local precedence order of each sequence is preserved.
+// Change the return type to Result
+fn merge(mut seqs: Vec<Vec<usize>>) -> Result<Vec<usize>, Vec<Vec<usize>>> {
     let mut result = Vec::new();
 
     loop {
         seqs.retain(|s| !s.is_empty());
         if seqs.is_empty() {
-            return Some(result);
+            return Ok(result);
         }
 
         let mut candidate = None;
@@ -740,7 +783,9 @@ fn merge(mut seqs: Vec<Vec<usize>>) -> Option<Vec<usize>> {
             }
         }
 
-        let head = candidate?;
+        let Some(head) = candidate else {
+            return Err(seqs);
+        };
 
         result.push(head);
 
@@ -881,7 +926,6 @@ pub(crate) mod tests {
     use std::path::Path;
     use tempfile::TempDir;
 
-    // ProjectGraph::new tests
     // Creates a file with specific content in the temp directory
     pub(crate) fn create_simf_file(dir: &Path, rel_path: &str, content: &str) -> PathBuf {
         let full_path = dir.join(rel_path);
@@ -898,7 +942,6 @@ pub(crate) mod tests {
     }
 
     // Helper to mock the initial root program parsing
-    // (Assuming your parser works via a helper function)
     fn parse_root(path: &Path) -> (parse::Program, SourceFile) {
         // 1. Read file
         let content = std::fs::read_to_string(path).expect("Failed to read root file for parsing");

src/error.rs

@@ -443,6 +443,9 @@ pub enum Error {
     FileNotFound(PathBuf),
     UnresolvedItem(Identifier),
     PrivateItem(String),
+    NameCollision(String),
+    DependencyCycle(Vec<String>),
+    InconsistentLinearization(String, Vec<Vec<String>>),
     MainNoInputs,
     MainNoOutput,
     MainRequired,
@@ -535,6 +538,18 @@ impl fmt::Display for Error {
                 f,
                 "File `{}` not found", path.to_string_lossy()
             ),
+            Error::DependencyCycle(cycle) => {
+                let path_str = cycle.join(" -> ");
+                write!(f, "Cyclic dependency detected: {path_str}")
+            },
+            Error::InconsistentLinearization(module, conflicts) => {
+                writeln!(f, "Inconsistent module resolution (linearization failed) for module `{module}`.")?;
+                writeln!(f, "The compiler could not resolve the following conflicting import constraints:")?;
+                for conflict in conflicts {
+                    writeln!(f, "  [{}]", conflict.join(", "))?; 
+                }
+                write!(f, "Try reordering your `use` statements to avoid cross-wiring.")
+            },
             Error::MainNoInputs => write!(
                 f,
                 "Main function takes no input parameters"
@@ -563,6 +578,10 @@ 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"
@@ -634,7 +653,7 @@ impl fmt::Display for Error {
             Error::ArgumentTypeMismatch(name, declared, assigned) => write!(
                 f,
                 "Parameter `{name}` was declared with type `{declared}` but its assigned argument is of type `{assigned}`"
-            ),
+            )
         }
     }
 }