transpile: Support absolute paths in PathedMultiImports

Author: Rua

c2rust-transpile/src/rust_ast/item_store.rs

@@ -36,34 +36,47 @@ impl MultiImport {
 }
 
 #[derive(Debug, Default)]
-pub struct PathedMultiImports(IndexMap<Vec<String>, MultiImport>);
+pub struct PathedMultiImports(IndexMap<(bool, Vec<String>), MultiImport>);
 
 impl PathedMultiImports {
     pub fn new() -> Self {
         Self::default()
     }
 
-    pub fn get_mut(&mut self, path: Vec<String>) -> &mut MultiImport {
-        self.0.entry(path).or_insert(MultiImport::new())
+    pub fn get_mut(&mut self, is_absolute: bool, path: Vec<String>) -> &mut MultiImport {
+        self.0
+            .entry((is_absolute, path))
+            .or_insert(MultiImport::new())
     }
 
     pub fn into_items(self) -> Vec<Box<Item>> {
-        fn build_items((mut path, imports): (Vec<String>, MultiImport)) -> Box<Item> {
-            let mut leaves = imports.leaves;
-            let attrs = imports.attrs.unwrap_or_else(mk);
-
-            if leaves.len() == 1 {
-                path.push(leaves.pop().unwrap());
-
-                let path = mk().abs_path(path);
-                attrs.use_simple_item(path, None as Option<Ident>)
-            } else {
-                let path = mk().abs_path(path);
-                attrs.use_multiple_item(path, leaves.into_iter())
-            }
-        }
-
-        self.0.into_iter().map(build_items).collect()
+        self.0
+            .into_iter()
+            .map(|((is_absolute, mut path), imports)| {
+                let mut leaves = imports.leaves;
+                let attrs = imports.attrs.unwrap_or_else(mk);
+
+                if leaves.len() == 1 {
+                    path.push(leaves.pop().unwrap());
+
+                    let path = if is_absolute {
+                        mk().abs_path(path)
+                    } else {
+                        mk().path(path)
+                    };
+
+                    attrs.use_simple_item(path, None as Option<Ident>)
+                } else {
+                    let path = if is_absolute {
+                        mk().abs_path(path)
+                    } else {
+                        mk().path(path)
+                    };
+
+                    attrs.use_multiple_item(path, leaves.into_iter())
+                }
+            })
+            .collect()
     }
 }
 
@@ -89,12 +102,20 @@ impl ItemStore {
         self.foreign_items.push(item);
     }
 
-    pub fn add_use(&mut self, path: Vec<String>, ident: &str) {
-        self.uses.get_mut(path).insert(ident)
+    pub fn add_use(&mut self, is_absolute: bool, path: Vec<String>, ident: &str) {
+        self.uses.get_mut(is_absolute, path).insert(ident)
     }
 
-    pub fn add_use_with_attr(&mut self, path: Vec<String>, ident: &str, attrs: Builder) {
-        self.uses.get_mut(path).insert_with_attr(ident, attrs)
+    pub fn add_use_with_attr(
+        &mut self,
+        is_absolute: bool,
+        path: Vec<String>,
+        ident: &str,
+        attrs: Builder,
+    ) {
+        self.uses
+            .get_mut(is_absolute, path)
+            .insert_with_attr(ident, attrs)
     }
 
     pub fn drain(&mut self) -> (Vec<Box<Item>>, Vec<ForeignItem>, PathedMultiImports) {

c2rust-transpile/src/translator/assembly.rs

@@ -931,7 +931,7 @@ impl<'c> Translation<'c> {
 
                     // Import the trait into scope
                     self.with_cur_file_item_store(|item_store| {
-                        item_store.add_use(vec!["c2rust_asm_casts".into()], "AsmCastTrait");
+                        item_store.add_use(true, vec!["c2rust_asm_casts".into()], "AsmCastTrait");
                     });
 
                     let (output_name, inner_name) = operand_renames.get(tied_operand).unwrap();
@@ -1059,7 +1059,7 @@ impl<'c> Translation<'c> {
         }
 
         self.with_cur_file_item_store(|item_store| {
-            item_store.add_use(vec!["core".into(), "arch".into()], "asm");
+            item_store.add_use(true, vec!["core".into(), "arch".into()], "asm");
         });
 
         let mac = mk().mac(

c2rust-transpile/src/translator/builtins.rs

@@ -97,7 +97,7 @@ impl<'c> Translation<'c> {
                 // Long doubles require the Float trait from num_traits to call this method
                 if builtin_name == "__builtin_signbitl" {
                     self.with_cur_file_item_store(|item_store| {
-                        item_store.add_use(vec!["num_traits".into()], "Float");
+                        item_store.add_use(true, vec!["num_traits".into()], "Float");
                     });
                 }
 

c2rust-transpile/src/translator/mod.rs

@@ -1014,7 +1014,7 @@ fn make_submodule(
             None => continue,
         };
 
-        use_item_store.add_use_with_attr(use_path, &ident_name, vis);
+        use_item_store.add_use_with_attr(false, use_path, &ident_name, vis);
     }
 
     for foreign_item in foreign_items.iter() {
@@ -1024,7 +1024,7 @@ fn make_submodule(
         };
         let use_path = vec!["self".into(), mod_name.clone()];
 
-        use_item_store.add_use(use_path, &ident_name);
+        use_item_store.add_use(false, use_path, &ident_name);
     }
 
     for item in uses.into_items() {
@@ -4714,7 +4714,7 @@ impl<'c> Translation<'c> {
         self.use_crate(ExternCrate::NumTraits);
 
         self.with_cur_file_item_store(|item_store| {
-            item_store.add_use(vec!["num_traits".into()], "ToPrimitive");
+            item_store.add_use(true, vec!["num_traits".into()], "ToPrimitive");
         });
         let to_method_name = match target_ty_ctype {
             CTypeKind::Float => "to_f32",
@@ -5170,7 +5170,7 @@ impl<'c> Translation<'c> {
             .borrow_mut()
             .entry(decl_file_id)
             .or_default()
-            .add_use(module_path, ident_name);
+            .add_use(false, module_path, ident_name);
     }
 
     fn import_type(&self, ctype: CTypeId, decl_file_id: FileId) {

c2rust-transpile/src/translator/simd.rs

@@ -69,6 +69,7 @@ static SIMD_X86_64_ONLY: &[&str] = &[
 
 fn add_arch_use(store: &mut ItemStore, arch_name: &str, item_name: &str) {
     store.add_use_with_attr(
+        true,
         vec!["core".into(), "arch".into(), arch_name.into()],
         item_name,
         mk().call_attr("cfg", vec![mk().meta_namevalue("target_arch", arch_name)])