Use __BindegenComplex for C Complex Fix rust-lang#72

C complex only exists for floating point types.
C Complex are built in types

long double _Complex is not supported.
Long double would be an f128, runing generated binding test produces:
assertion failed: `(left == right)` (left: `16`, right: `32`)',
tests/expectations/tests/complex.rs:72
We test global long double _Complex because it does not require
layout tests.

Handle all the different way a complex can be present in
BindgenContext calling generated_bindegen_complex to indicate
that __BindgenContext will need to be added.

Author: jeanphilippeD

src/codegen/helpers.rs

@@ -71,3 +71,51 @@ impl BlobTyBuilder {
         }
     }
 }
+
+pub mod ast_ty {
+    use aster;
+    use ir::context::BindgenContext;
+    use ir::ty::FloatKind;
+    use syntax::ast;
+    use syntax::ptr::P;
+
+    pub fn raw_type(ctx: &BindgenContext, name: &str) -> P<ast::Ty> {
+        let ident = ctx.rust_ident_raw(&name);
+        match ctx.options().ctypes_prefix {
+            Some(ref prefix) => {
+                let prefix = ctx.rust_ident_raw(prefix);
+                quote_ty!(ctx.ext_cx(), $prefix::$ident)
+            }
+            None => quote_ty!(ctx.ext_cx(), ::std::os::raw::$ident),
+        }
+    }
+
+    pub fn float_kind_rust_type(ctx: &BindgenContext,
+                                fk: FloatKind)
+                                -> P<ast::Ty> {
+        macro_rules! raw {
+            ($ty: ident) => {
+                raw_type(ctx, stringify!($ty))
+            }
+        }
+        // TODO: we probably should just take the type layout into
+        // account?
+        //
+        // Also, maybe this one shouldn't be the default?
+        //
+        // FIXME: `c_longdouble` doesn't seem to be defined in some
+        // systems, so we use `c_double` directly.
+        use ir::ty::FloatKind;
+        match (fk, ctx.options().convert_floats) {
+            (FloatKind::Float, true) => aster::ty::TyBuilder::new().f32(),
+            (FloatKind::Double, true) |
+            (FloatKind::LongDouble, true) => aster::ty::TyBuilder::new().f64(),
+            (FloatKind::Float, false) => raw!(c_float),
+            (FloatKind::Double, false) |
+            (FloatKind::LongDouble, false) => raw!(c_double),
+            (FloatKind::Float128, _) => {
+                aster::ty::TyBuilder::new().array(16).u8()
+            }
+        }
+    }
+}

src/codegen/mod.rs

@@ -336,6 +336,7 @@ impl CodeGenerator for Type {
             TypeKind::NullPtr |
             TypeKind::Int(..) |
             TypeKind::Float(..) |
+            TypeKind::Complex(..) |
             TypeKind::Array(..) |
             TypeKind::Pointer(..) |
             TypeKind::BlockPointer |
@@ -1549,21 +1550,12 @@ impl ItemToRustTy for Item {
     }
 }
 
-fn raw_type(ctx: &BindgenContext, name: &str) -> P<ast::Ty> {
-    let ident = ctx.rust_ident_raw(&name);
-    match ctx.options().ctypes_prefix {
-        Some(ref prefix) => {
-            let prefix = ctx.rust_ident_raw(prefix);
-            quote_ty!(ctx.ext_cx(), $prefix::$ident)
-        }
-        None => quote_ty!(ctx.ext_cx(), ::std::os::raw::$ident),
-    }
-}
-
 impl ToRustTy for Type {
     type Extra = Item;
 
     fn to_rust_ty(&self, ctx: &BindgenContext, item: &Item) -> P<ast::Ty> {
+        use self::helpers::ast_ty::*;
+
         macro_rules! raw {
             ($ty: ident) => {
                 raw_type(ctx, stringify!($ty))
@@ -1608,24 +1600,12 @@ impl ToRustTy for Type {
                     }
                 }
             }
-            TypeKind::Float(fk) => {
-                // TODO: we probably should just take the type layout into
-                // account?
-                //
-                // Also, maybe this one shouldn't be the default?
-                //
-                // FIXME: `c_longdouble` doesn't seem to be defined in some
-                // systems, so we use `c_double` directly.
-                use ir::ty::FloatKind;
-                match (fk, ctx.options().convert_floats) {
-                    (FloatKind::Float, true) => aster::ty::TyBuilder::new().f32(),
-                    (FloatKind::Double, true) |
-                    (FloatKind::LongDouble, true) => aster::ty::TyBuilder::new().f64(),
-                    (FloatKind::Float, false) => raw!(c_float),
-                    (FloatKind::Double, false) |
-                    (FloatKind::LongDouble, false) => raw!(c_double),
-                    (FloatKind::Float128, _) => aster::ty::TyBuilder::new().array(16).u8(),
-                }
+            TypeKind::Float(fk) => float_kind_rust_type(ctx, fk),
+            TypeKind::Complex(fk) => {
+                let float_path = float_kind_rust_type(ctx, fk);
+
+                ctx.generated_bindegen_complex();
+                quote_ty!(ctx.ext_cx(), __BindgenComplex<$float_path>)
             }
             TypeKind::Function(ref fs) => {
                 let ty = fs.to_rust_ty(ctx, item);
@@ -1900,6 +1880,9 @@ pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
         if saw_union && !context.options().unstable_rust {
             utils::prepend_union_types(context, &mut result);
         }
+        if context.need_bindegen_complex_type() {
+            utils::prepend_complex_type(context, &mut result);
+        }
         result
     })
 }
@@ -1981,6 +1964,22 @@ mod utils {
         result.extend(old_items.into_iter());
     }
 
+    pub fn prepend_complex_type(ctx: &BindgenContext,
+                                result: &mut Vec<P<ast::Item>>) {
+        let complex_type = quote_item!(ctx.ext_cx(),
+            #[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
+            #[repr(C)]
+            pub struct __BindgenComplex<T> {
+                pub re: T,
+                pub im: T
+            }
+        )
+            .unwrap();
+
+        let items = vec![complex_type];
+        let old_items = mem::replace(result, items);
+        result.extend(old_items.into_iter());
+    }
 
     pub fn build_templated_path(item: &Item,
                                 ctx: &BindgenContext,

src/ir/context.rs

@@ -5,6 +5,7 @@ use cexpr;
 use clang::{self, Cursor};
 use parse::ClangItemParser;
 use std::borrow::Cow;
+use std::cell::Cell;
 use std::collections::{HashMap, hash_map};
 use std::collections::btree_map::{self, BTreeMap};
 use std::fmt;
@@ -99,6 +100,9 @@ pub struct BindgenContext<'ctx> {
 
     /// The options given by the user via cli or other medium.
     options: BindgenOptions,
+
+    /// Whether a bindgen complex was generated
+    generated_bindegen_complex: Cell<bool>,
 }
 
 impl<'ctx> BindgenContext<'ctx> {
@@ -134,6 +138,7 @@ impl<'ctx> BindgenContext<'ctx> {
             index: index,
             translation_unit: translation_unit,
             options: options,
+            generated_bindegen_complex: Cell::new(false),
         };
 
         me.add_item(root_module, None, None);
@@ -698,6 +703,17 @@ impl<'ctx> BindgenContext<'ctx> {
             CXType_Double => TypeKind::Float(FloatKind::Double),
             CXType_LongDouble => TypeKind::Float(FloatKind::LongDouble),
             CXType_Float128 => TypeKind::Float(FloatKind::Float128),
+            CXType_Complex => {
+                let float_type = ty.elem_type()
+                    .expect("Not able to resolve complex type?");
+                let float_kind = match float_type.kind() {
+                    CXType_Float => FloatKind::Float,
+                    CXType_Double => FloatKind::Double,
+                    CXType_LongDouble => FloatKind::LongDouble,
+                    _ => panic!("Non floating-type complex?"),
+                };
+                TypeKind::Complex(float_kind)
+            }
             _ => return None,
         };
 
@@ -930,6 +946,16 @@ impl<'ctx> BindgenContext<'ctx> {
             self.rust_ident_raw("std")
         }
     }
+
+    /// Call if a binden complex is generated
+    pub fn generated_bindegen_complex(&self) {
+        self.generated_bindegen_complex.set(true)
+    }
+
+    /// Whether we need to generate the binden complex type
+    pub fn need_bindegen_complex_type(&self) -> bool {
+        self.generated_bindegen_complex.get()
+    }
 }
 
 /// An iterator over whitelisted items.

src/ir/ty.rs

@@ -334,6 +334,7 @@ impl Type {
             TypeKind::Comp(..) |
             TypeKind::Int(..) |
             TypeKind::Float(..) |
+            TypeKind::Complex(..) |
             TypeKind::Function(..) |
             TypeKind::Enum(..) |
             TypeKind::Reference(..) |
@@ -386,6 +387,9 @@ pub enum TypeKind {
     /// A floating point type.
     Float(FloatKind),
 
+    /// A complex floating point type.
+    Complex(FloatKind),
+
     /// A type alias, with a name, that points to another type.
     Alias(String, ItemId),
 
@@ -463,6 +467,7 @@ impl Type {
             TypeKind::Named(..) |
             TypeKind::Int(..) |
             TypeKind::Float(..) |
+            TypeKind::Complex(..) |
             TypeKind::Function(..) |
             TypeKind::Enum(..) |
             TypeKind::Reference(..) |
@@ -801,17 +806,6 @@ impl Type {
                     .expect("Not able to resolve array element?");
                 TypeKind::Array(inner, ty.num_elements().unwrap())
             }
-            // A complex number is always a real and an imaginary part,
-            // so
-            // represent that as a two-item array.
-            CXType_Complex => {
-                let inner = Item::from_ty(ty.elem_type().as_ref().unwrap(),
-                                          location,
-                                          parent_id,
-                                          ctx)
-                    .expect("Not able to resolve array element?");
-                TypeKind::Array(inner, 2)
-            }
             #[cfg(not(feature="llvm_stable"))]
             CXType_Elaborated => {
                 return Self::from_clang_ty(potential_id,

tests/expectations/tests/complex.rs

@@ -4,81 +4,61 @@
 #![allow(non_snake_case)]
 
 
+#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
 #[repr(C)]
-#[derive(Debug, Copy)]
-pub struct Testdouble {
-    pub mMember: [f64; 2usize],
-}
-#[test]
-fn bindgen_test_layout_Testdouble() {
-    assert_eq!(::std::mem::size_of::<Testdouble>() , 16usize);
-    assert_eq!(::std::mem::align_of::<Testdouble>() , 8usize);
-}
-impl Clone for Testdouble {
-    fn clone(&self) -> Self { *self }
-}
-#[repr(C)]
-#[derive(Debug, Copy)]
-pub struct TestdoublePtr {
-    pub mMember: *mut [f64; 2usize],
-}
-#[test]
-fn bindgen_test_layout_TestdoublePtr() {
-    assert_eq!(::std::mem::size_of::<TestdoublePtr>() , 8usize);
-    assert_eq!(::std::mem::align_of::<TestdoublePtr>() , 8usize);
-}
-impl Clone for TestdoublePtr {
-    fn clone(&self) -> Self { *self }
+pub struct __BindgenComplex<T> {
+    pub re: T,
+    pub im: T,
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct Testfloat {
-    pub mMember: [f32; 2usize],
+pub struct TestDouble {
+    pub mMember: __BindgenComplex<f64>,
 }
 #[test]
-fn bindgen_test_layout_Testfloat() {
-    assert_eq!(::std::mem::size_of::<Testfloat>() , 8usize);
-    assert_eq!(::std::mem::align_of::<Testfloat>() , 4usize);
+fn bindgen_test_layout_TestDouble() {
+    assert_eq!(::std::mem::size_of::<TestDouble>() , 16usize);
+    assert_eq!(::std::mem::align_of::<TestDouble>() , 8usize);
 }
-impl Clone for Testfloat {
+impl Clone for TestDouble {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct TestfloatPtr {
-    pub mMember: *mut [f32; 2usize],
+pub struct TestDoublePtr {
+    pub mMember: *mut __BindgenComplex<f64>,
 }
 #[test]
-fn bindgen_test_layout_TestfloatPtr() {
-    assert_eq!(::std::mem::size_of::<TestfloatPtr>() , 8usize);
-    assert_eq!(::std::mem::align_of::<TestfloatPtr>() , 8usize);
+fn bindgen_test_layout_TestDoublePtr() {
+    assert_eq!(::std::mem::size_of::<TestDoublePtr>() , 8usize);
+    assert_eq!(::std::mem::align_of::<TestDoublePtr>() , 8usize);
 }
-impl Clone for TestfloatPtr {
+impl Clone for TestDoublePtr {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct Testint {
-    pub mMember: [::std::os::raw::c_int; 2usize],
+pub struct TestFloat {
+    pub mMember: __BindgenComplex<f32>,
 }
 #[test]
-fn bindgen_test_layout_Testint() {
-    assert_eq!(::std::mem::size_of::<Testint>() , 8usize);
-    assert_eq!(::std::mem::align_of::<Testint>() , 4usize);
+fn bindgen_test_layout_TestFloat() {
+    assert_eq!(::std::mem::size_of::<TestFloat>() , 8usize);
+    assert_eq!(::std::mem::align_of::<TestFloat>() , 4usize);
 }
-impl Clone for Testint {
+impl Clone for TestFloat {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct TestintPtr {
-    pub mMember: *mut [::std::os::raw::c_int; 2usize],
+pub struct TestFloatPtr {
+    pub mMember: *mut __BindgenComplex<f32>,
 }
 #[test]
-fn bindgen_test_layout_TestintPtr() {
-    assert_eq!(::std::mem::size_of::<TestintPtr>() , 8usize);
-    assert_eq!(::std::mem::align_of::<TestintPtr>() , 8usize);
+fn bindgen_test_layout_TestFloatPtr() {
+    assert_eq!(::std::mem::size_of::<TestFloatPtr>() , 8usize);
+    assert_eq!(::std::mem::align_of::<TestFloatPtr>() , 8usize);
 }
-impl Clone for TestintPtr {
+impl Clone for TestFloatPtr {
     fn clone(&self) -> Self { *self }
 }

tests/expectations/tests/complex_global.rs

@@ -0,0 +1,24 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
+#[repr(C)]
+pub struct __BindgenComplex<T> {
+    pub re: T,
+    pub im: T,
+}
+extern "C" {
+    #[link_name = "globalValueFloat"]
+    pub static mut globalValueFloat: __BindgenComplex<f32>;
+}
+extern "C" {
+    #[link_name = "globalValueDouble"]
+    pub static mut globalValueDouble: __BindgenComplex<f64>;
+}
+extern "C" {
+    #[link_name = "globalValueLongDouble"]
+    pub static mut globalValueLongDouble: __BindgenComplex<f64>;
+}