Rename the module at its normal location

Author: randomPoison

c2rust-transpile/src/build_files/mod.rs

@@ -107,7 +107,7 @@ pub fn emit_build_files<'lcmd>(
     })
 }
 
-#[derive(Serialize)]
+#[derive(Clone, Debug, Serialize)]
 struct Module {
     path: Option<String>,
     name: String,
@@ -116,19 +116,23 @@ struct Module {
 }
 
 #[derive(Debug, Default)]
-struct ModuleTree(BTreeMap<String, ModuleTree>);
+struct ModuleTree {
+    children: BTreeMap<String, ModuleTree>,
+    path_modules: Vec<Module>,
+}
 
 impl ModuleTree {
     /// Convert the tree representation into a linear vector
     /// and push it into `res`
     fn linearize(&self, res: &mut Vec<Module>) {
-        for (name, child) in self.0.iter() {
+        res.extend(self.path_modules.iter().cloned());
+        for (name, child) in self.children.iter() {
             child.linearize_internal(name, res);
         }
     }
 
     fn linearize_internal(&self, name: &str, res: &mut Vec<Module>) {
-        if self.0.is_empty() {
+        if self.path_modules.is_empty() && self.children.is_empty() {
             res.push(Module {
                 name: name.to_string(),
                 path: None,
@@ -151,6 +155,55 @@ impl ModuleTree {
             });
         }
     }
+
+    fn insert_nested(&mut self, path: Vec<String>) {
+        let mut cur = self;
+        for name in path {
+            cur = cur.children.entry(name).or_default();
+        }
+    }
+
+    fn insert_path_module(
+        &mut self,
+        parent_path: &[String],
+        file_name: String,
+        module_name: String,
+    ) {
+        let mut cur = self;
+        for name in parent_path {
+            cur = cur.children.entry(name.clone()).or_default();
+        }
+        let name = cur.unique_child_name(&module_name);
+        cur.path_modules.push(Module {
+            path: Some(file_name),
+            name,
+            open: false,
+            close: false,
+        });
+    }
+
+    fn unique_child_name(&self, module_name: &str) -> String {
+        if !self.child_name_exists(module_name) {
+            return module_name.to_owned();
+        }
+
+        for i in 1.. {
+            let candidate = format!("{module_name}{i}");
+            if !self.child_name_exists(&candidate) {
+                return candidate;
+            }
+        }
+
+        unreachable!("We tried all the numbers and couln't find one that didn't collide")
+    }
+
+    fn child_name_exists(&self, module_name: &str) -> bool {
+        self.children.contains_key(module_name)
+            || self
+                .path_modules
+                .iter()
+                .any(|module| module.name == module_name)
+    }
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -182,7 +235,7 @@ fn convert_module_list(
     });
 
     let mut res = vec![];
-    let mut module_tree = ModuleTree(BTreeMap::new());
+    let mut module_tree = ModuleTree::default();
     // A C file can have the same stem as a sibling directory, such as
     // `hash.c` and `hash/sha1.c`. The current nested module emitter cannot
     // represent both at `mod hash`, so emit the file module with an explicit
@@ -207,28 +260,21 @@ fn convert_module_list(
                 .then_some(*module)
         })
         .collect::<BTreeSet<_>>();
-    let mut used_flat_names = BTreeSet::new();
 
+    let mut collision_relpaths = vec![];
     for m in &modules {
         match m.strip_prefix(build_dir) {
             Ok(relpath) if !tcfg.is_binary(m) && !collision_modules.contains(m) => {
                 // The module is inside the build directory, use nested modules
-                let mut cur = &mut module_tree;
-                for name in module_path(relpath) {
-                    cur = cur.0.entry(name).or_default();
-                }
+                module_tree.insert_nested(module_path(relpath));
+            }
+            Ok(relpath) if !tcfg.is_binary(m) => {
+                collision_relpaths.push(relpath.to_path_buf());
             }
             _ => {
                 let relpath = diff_paths(m, build_dir).unwrap();
                 let path = Some(relpath.to_str().unwrap().to_string());
-                let name = if collision_modules.contains(m) {
-                    unique_collision_module_name(
-                        m.strip_prefix(build_dir).unwrap(),
-                        &mut used_flat_names,
-                    )
-                } else {
-                    get_module_name(m, true, false, false).unwrap()
-                };
+                let name = get_module_name(m, true, false, false).unwrap();
                 res.push(Module {
                     path,
                     name,
@@ -238,6 +284,12 @@ fn convert_module_list(
             }
         }
     }
+    for relpath in collision_relpaths {
+        let mut path = module_path(&relpath);
+        let module_name = format!("{}_", path.pop().unwrap());
+        let file_name = relpath.file_name().unwrap().to_str().unwrap().to_string();
+        module_tree.insert_path_module(&path, file_name, module_name);
+    }
     module_tree.linearize(&mut res);
     res
 }
@@ -251,21 +303,6 @@ fn module_path(path: &Path) -> Vec<String> {
         .collect()
 }
 
-fn unique_collision_module_name(path: &Path, used_names: &mut BTreeSet<String>) -> String {
-    let base = format!("c2rust_{}", module_path(path).into_iter().join("_"));
-    if used_names.insert(base.clone()) {
-        return base;
-    }
-
-    for i in 1.. {
-        let candidate = format!("{base}_{i}");
-        if used_names.insert(candidate.clone()) {
-            return candidate;
-        }
-    }
-    unreachable!()
-}
-
 fn emit_thin_binaries(
     tcfg: &TranspilerConfig,
     build_dir: &Path,

c2rust-transpile/tests/module_paths.rs

@@ -73,16 +73,23 @@ fn sibling_file_and_directory_modules_do_not_collide() {
         c2rust_transpile::create_temp_compile_commands(&[
             src.join("main.c"),
             src.join("hash.c"),
+            src.join("hash_.c"),
             src.join("hash/sha1.c"),
         ]);
 
     c2rust_transpile::transpile(config(output_dir.clone()), &compile_commands_path, &["-w"]);
 
     let lib_rs = fs::read_to_string(output_dir.join("lib.rs")).unwrap();
     assert!(
-        lib_rs.contains("#[path = \"src/hash.rs\"]\npub mod c2rust_src_hash;"),
+        lib_rs.contains("pub mod hash_;"),
+        "generated module tree should include the non-colliding hash_.rs \
+         module normally:\n{lib_rs}"
+    );
+    assert!(
+        lib_rs.contains("#[path = \"hash.rs\"]\n    pub mod hash_1;"),
         "generated module tree should include the sibling hash.rs module via an \
-         explicit path module instead of shadowing it with the hash/ directory:\n{lib_rs}"
+         explicit path module inside its parent instead of shadowing it with \
+         the hash/ directory:\n{lib_rs}"
     );
     assert!(
         lib_rs.contains("pub mod sha1;"),

c2rust-transpile/tests/module_paths/sibling_file_and_directory/hash_.c

@@ -0,0 +1,3 @@
+int hash_utility(void) {
+    return 7;
+}