Include libc dependency only when needed (#1373)

* Fixes #1362

Since most C types are now imported from `std::ffi`, there is less need
to always include the `libc` library. This changes it so that it's only
included when actually needed.

To implement this, `TypeConverter` now tracks external crates,
separately from `Translator`. The two lists are merged afterwards. While
working on this, I also spotted a bug that `f128` wasn't being included
from `TypeConverter` and a few other places, so I included fixes for
that as well.

Author: kkysen

c2rust-transpile/src/convert_type.rs

@@ -2,8 +2,10 @@ use crate::c_ast::CDeclId;
 use crate::c_ast::*;
 use crate::diagnostics::TranslationResult;
 use crate::renamer::*;
+use crate::{CrateSet, ExternCrate};
 use c2rust_ast_builder::{mk, properties::*};
 use failure::format_err;
+use indexmap::IndexSet;
 use std::collections::{HashMap, HashSet};
 use std::ops::Index;
 use syn::*;
@@ -20,6 +22,7 @@ pub struct TypeConverter {
     fields: HashMap<CDeclId, Renamer<FieldKey>>,
     suffix_names: HashMap<(CDeclId, &'static str), String>,
     features: HashSet<&'static str>,
+    extern_crates: CrateSet,
 }
 
 pub const RESERVED_NAMES: [&str; 103] = [
@@ -146,13 +149,22 @@ impl TypeConverter {
             fields: HashMap::new(),
             suffix_names: HashMap::new(),
             features: HashSet::new(),
+            extern_crates: IndexSet::new(),
         }
     }
 
+    fn use_crate(&mut self, extern_crate: ExternCrate) {
+        self.extern_crates.insert(extern_crate);
+    }
+
     pub fn features_used(&self) -> &HashSet<&'static str> {
         &self.features
     }
 
+    pub fn extern_crates_used(&self) -> &CrateSet {
+        &self.extern_crates
+    }
+
     pub fn declare_decl_name(&mut self, decl_id: CDeclId, name: &str) -> String {
         self.renamer
             .insert(decl_id, name)
@@ -326,6 +338,7 @@ impl TypeConverter {
             CTypeKind::Char => Ok(mk().path_ty(mk().path(vec!["std", "ffi", "c_char"]))),
             CTypeKind::Double => Ok(mk().path_ty(mk().path(vec!["std", "ffi", "c_double"]))),
             CTypeKind::LongDouble | CTypeKind::Float128 => {
+                self.use_crate(ExternCrate::F128);
                 Ok(mk().path_ty(mk().path(vec!["f128", "f128"])))
             }
             CTypeKind::Float => Ok(mk().path_ty(mk().path(vec!["std", "ffi", "c_float"]))),
@@ -343,12 +356,21 @@ impl TypeConverter {
             CTypeKind::UInt32 => Ok(mk().path_ty(mk().path(vec!["u32"]))),
             CTypeKind::UInt64 => Ok(mk().path_ty(mk().path(vec!["u64"]))),
             CTypeKind::UIntPtr => Ok(mk().path_ty(mk().path(vec!["usize"]))),
-            CTypeKind::IntMax => Ok(mk().path_ty(mk().path(vec!["libc", "intmax_t"]))),
-            CTypeKind::UIntMax => Ok(mk().path_ty(mk().path(vec!["libc", "uintmax_t"]))),
+            CTypeKind::IntMax => {
+                self.use_crate(ExternCrate::Libc);
+                Ok(mk().path_ty(mk().path(vec!["libc", "intmax_t"])))
+            }
+            CTypeKind::UIntMax => {
+                self.use_crate(ExternCrate::Libc);
+                Ok(mk().path_ty(mk().path(vec!["libc", "uintmax_t"])))
+            }
             CTypeKind::Size => Ok(mk().path_ty(mk().path(vec!["usize"]))),
             CTypeKind::SSize => Ok(mk().path_ty(mk().path(vec!["isize"]))),
             CTypeKind::PtrDiff => Ok(mk().path_ty(mk().path(vec!["isize"]))),
-            CTypeKind::WChar => Ok(mk().path_ty(mk().path(vec!["libc", "wchar_t"]))),
+            CTypeKind::WChar => {
+                self.use_crate(ExternCrate::Libc);
+                Ok(mk().path_ty(mk().path(vec!["libc", "wchar_t"])))
+            }
 
             CTypeKind::Pointer(qtype) => self.convert_pointer(ctxt, qtype),
 

c2rust-transpile/src/translator/builtins.rs

@@ -308,6 +308,7 @@ impl<'c> Translation<'c> {
                             mk().block(vec![mk().expr_stmt(minus_one)]),
                             Some(mk().lit_expr(mk().int_lit(0, "isize"))),
                         );
+                        self.use_crate(ExternCrate::Libc);
                         let size_t = mk().path_ty(vec!["libc", "size_t"]);
                         mk().cast_expr(if_expr, size_t)
                     }))
@@ -752,6 +753,7 @@ impl<'c> Translation<'c> {
         arg_types: &[LibcFnArgType],
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
         let name = &builtin_name[10..];
+        self.use_crate(ExternCrate::Libc);
         let mem = mk().path_expr(vec!["libc", name]);
         let args = self.convert_exprs(ctx.used(), args, None)?;
         args.and_then(|args| {
@@ -765,13 +767,13 @@ impl<'c> Translation<'c> {
                 ))
                 .context(TranslationErrorKind::Generic))?
             }
-            let size_t = || mk().path_ty(vec!["libc", "size_t"]);
             let args_casted = args
                 .into_iter()
                 .zip(arg_types)
                 .map(|(arg, &ty)| {
                     if ty == LibcFnArgType::Size {
-                        mk().cast_expr(arg, size_t())
+                        self.use_crate(ExternCrate::Libc);
+                        mk().cast_expr(arg, mk().path_ty(vec!["libc", "size_t"]))
                     } else {
                         arg
                     }

c2rust-transpile/src/translator/mod.rs

@@ -492,8 +492,6 @@ pub fn translate(
     };
 
     {
-        t.use_crate(ExternCrate::Libc);
-
         // Sort the top-level declarations by file and source location so that we
         // preserve the ordering of all declarations in each file.
         t.ast_context.sort_top_decls();
@@ -767,9 +765,6 @@ pub fn translate(
             store.add_item(initializer_static);
         }
 
-        let pragmas = t.get_pragmas();
-        let crates = t.extern_crates.borrow().clone();
-
         let mut mod_items: Vec<Box<Item>> = Vec::new();
 
         // Keep track of new uses we need while building header submodules
@@ -869,6 +864,15 @@ pub fn translate(
                 items: all_items.into_iter().map(|x| *x).collect(),
             }
         });
+
+        let pragmas = t.get_pragmas();
+        let extern_crates = t.extern_crates.borrow();
+        let type_converter = t.type_converter.borrow();
+        let crates = extern_crates
+            .union(type_converter.extern_crates_used())
+            .copied()
+            .collect();
+
         (translation, pragmas, crates)
     }
 }
@@ -4392,6 +4396,7 @@ impl<'c> Translation<'c> {
             {
                 let target_ty = self.convert_type(target_cty.ctype)?;
                 val.and_then(|x| {
+                    self.use_crate(ExternCrate::Libc);
                     let intptr_t = mk().path_ty(vec!["libc", "intptr_t"]);
                     let intptr = mk().cast_expr(x, intptr_t.clone());
                     Ok(WithStmts::new_unsafe_val(transmute_expr(
@@ -4444,6 +4449,7 @@ impl<'c> Translation<'c> {
                     })
                 } else if target_ty_kind.is_pointer() && source_ty_kind.is_bool() {
                     val.and_then(|x| {
+                        self.use_crate(ExternCrate::Libc);
                         Ok(WithStmts::new_val(mk().cast_expr(
                             mk().cast_expr(x, mk().path_ty(vec!["libc", "size_t"])),
                             target_ty,
@@ -4722,9 +4728,12 @@ impl<'c> Translation<'c> {
             ))
         } else if resolved_ty.is_floating_type() {
             match self.ast_context[ty_id].kind {
-                CTypeKind::LongDouble => Ok(WithStmts::new_val(
-                    mk().path_expr(vec!["f128", "f128", "ZERO"]),
-                )),
+                CTypeKind::LongDouble => {
+                    self.use_crate(ExternCrate::F128);
+                    Ok(WithStmts::new_val(
+                        mk().path_expr(vec!["f128", "f128", "ZERO"]),
+                    ))
+                }
                 _ => Ok(WithStmts::new_val(
                     mk().lit_expr(mk().float_unsuffixed_lit("0.")),
                 )),