Map stdint.h + size_t types to Rust native ones.

uint8_t -> u8
size_t -> usize

This is consistent with how libc 0.2 is defining these types.

See the second paragraph of [1] and the discussion in [2] for rationale.

This is a [breaking-change] because re-generating bindings after this change
will change the type signatures of some functions and structs.

[1] https://github.com/rust-lang/rfcs/blob/master/text/1291-promote-libc.md#changes-from-today
[2] rust-lang/rust#28096

Author: Jorge Aparicio

Changelog.md

@@ -7,6 +7,7 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ### Breaking
 - Change the way to link to a library in the cli interface (see the `-l` option
   in the output of `--help`)
+- Map stdint.h + size_t types to Rust native ones (#256)
 
 ### Added
 - `-no-rust-enums` generate integer constants instead of enums

src/gen.rs

@@ -416,8 +416,24 @@ fn ctypedef_to_rs(
         ty: &Type)
         -> Vec<P<ast::Item>> {
     fn mk_item(ctx: &mut GenCtx, name: &str, ty: &Type) -> P<ast::Item> {
+        let rust_ty = match &name[..] {
+            // Alias these types to `usize`, e.g. `type size_t = usize`, instead of aliasing them to
+            // an arch-dependent type, i.e. `type size_t = u64` on 64-bit archs and
+            // `type size_t = u32` on 32-bit archs
+            "size_t" | "uintptr_t" => mk_ty(ctx, false, vec!["usize".to_string()]),
+            // Same as above
+            "ptrdiff_t" | "intptr_t" | "ssize_t" => mk_ty(ctx, false, vec!["isize".to_string()]),
+            "uint8_t" => mk_ty(ctx, false, vec!["u8".to_string()]),
+            "int8_t" => mk_ty(ctx, false, vec!["i8".to_string()]),
+            "uint16_t" => mk_ty(ctx, false, vec!["u16".to_string()]),
+            "int16_t" => mk_ty(ctx, false, vec!["i16".to_string()]),
+            "uint32_t" => mk_ty(ctx, false, vec!["u32".to_string()]),
+            "int32_t" => mk_ty(ctx, false, vec!["i32".to_string()]),
+            "uint64_t" => mk_ty(ctx, false, vec!["u64".to_string()]),
+            "int64_t" => mk_ty(ctx, false, vec!["i64".to_string()]),
+            _ => cty_to_rs(ctx, ty),
+        };
         let rust_name = rust_type_id(ctx, name);
-        let rust_ty = cty_to_rs(ctx, ty);
         let base = ast::ItemKind::Ty(
             P(ast::Ty {
                 id: ast::DUMMY_NODE_ID,

tests/headers/signed.h

@@ -0,0 +1,3 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/types.h>

tests/headers/unsigned.h

@@ -0,0 +1,2 @@
+#include <stddef.h>
+#include <stdint.h>

tests/test_ints.rs

@@ -0,0 +1,34 @@
+use bindgen;
+
+#[test]
+fn unsigned() {
+    let bindings = bindgen::builder()
+        .header("tests/headers/unsigned.h")
+        .generate()
+        .unwrap()
+        .to_string();
+
+    assert!(bindings.contains("pub type size_t = usize;"));
+    assert!(bindings.contains("pub type uintptr_t = usize;"));
+    assert!(bindings.contains("pub type uint8_t = u8;"));
+    assert!(bindings.contains("pub type uint16_t = u16;"));
+    assert!(bindings.contains("pub type uint32_t = u32;"));
+    assert!(bindings.contains("pub type uint64_t = u64;"));
+}
+
+#[test]
+fn signed() {
+    let bindings = bindgen::builder()
+        .header("tests/headers/signed.h")
+        .generate()
+        .unwrap()
+        .to_string();
+
+    assert!(bindings.contains("pub type ptrdiff_t = isize;"));
+    assert!(bindings.contains("pub type intptr_t = isize;"));
+    assert!(bindings.contains("pub type ssize_t = isize;"));
+    assert!(bindings.contains("pub type int8_t = i8;"));
+    assert!(bindings.contains("pub type int16_t = i16;"));
+    assert!(bindings.contains("pub type int32_t = i32;"));
+    assert!(bindings.contains("pub type int64_t = i64;"));
+}

tests/tests.rs

@@ -14,3 +14,4 @@ mod test_func;
 mod test_struct;
 mod test_union;
 mod test_builtins;
+mod test_ints;