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 setting saw_complex.

Author: jeanphilippeD

src/codegen/mod.rs

@@ -13,7 +13,7 @@ use ir::item::{Item, ItemCanonicalName, ItemCanonicalPath, ItemId};
 use ir::item_kind::ItemKind;
 use ir::layout::Layout;
 use ir::module::Module;
-use ir::ty::{Type, TypeKind};
+use ir::ty::{FloatKind, Type, TypeKind};
 use ir::type_collector::ItemSet;
 use ir::var::Var;
 use self::helpers::{BlobTyBuilder, attributes};
@@ -336,6 +336,7 @@ impl CodeGenerator for Type {
             TypeKind::NullPtr |
             TypeKind::Int(..) |
             TypeKind::Float(..) |
+            TypeKind::Complex(..) |
             TypeKind::Array(..) |
             TypeKind::Pointer(..) |
             TypeKind::BlockPointer |
@@ -1560,6 +1561,33 @@ fn raw_type(ctx: &BindgenContext, name: &str) -> P<ast::Ty> {
     }
 }
 
+fn float_kind_rust_type(ctx: &BindgenContext, fk: FloatKind) -> P<ast::Ty> {
+    if ctx.options().convert_floats {
+        // TODO: we probably should just take the type layout into
+        // account?
+        //
+        // Also, maybe this one shouldn't be the default?
+        match fk {
+            FloatKind::Float => aster::ty::TyBuilder::new().f32(),
+            FloatKind::Double | FloatKind::LongDouble => {
+                aster::ty::TyBuilder::new().f64()
+            }
+        }
+    } else {
+        macro_rules! raw {
+            ($ty: ident) => {
+                raw_type(ctx, stringify!($ty))
+            }
+        }
+        // FIXME: `c_longdouble` doesn't seem to be defined in some
+        // systems, so we use `c_double` directly.
+        match fk {
+            FloatKind::Float => raw!(c_float),
+            FloatKind::Double | FloatKind::LongDouble => raw!(c_double),
+        }
+    }
+}
+
 impl ToRustTy for Type {
     type Extra = Item;
 
@@ -1608,29 +1636,10 @@ impl ToRustTy for Type {
                     }
                 }
             }
-            TypeKind::Float(fk) => {
-                use ir::ty::FloatKind;
-                if ctx.options().convert_floats {
-                    // TODO: we probably should just take the type layout into
-                    // account?
-                    //
-                    // Also, maybe this one shouldn't be the default?
-                    match fk {
-                        FloatKind::Float => aster::ty::TyBuilder::new().f32(),
-                        FloatKind::Double | FloatKind::LongDouble => {
-                            aster::ty::TyBuilder::new().f64()
-                        }
-                    }
-                } else {
-                    // FIXME: `c_longdouble` doesn't seem to be defined in some
-                    // systems, so we use `c_double` directly.
-                    match fk {
-                        FloatKind::Float => raw!(c_float),
-                        FloatKind::Double | FloatKind::LongDouble => {
-                            raw!(c_double)
-                        }
-                    }
-                }
+            TypeKind::Float(fk) => float_kind_rust_type(ctx, fk),
+            TypeKind::Complex(fk) => {
+                let float_path = float_kind_rust_type(ctx, fk);
+                quote_ty!(ctx.ext_cx(), __BindgenComplex<$float_path>)
             }
             TypeKind::Function(ref fs) => {
                 let ty = fs.to_rust_ty(ctx, item);
@@ -1905,6 +1914,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.saw_complex() {
+            utils::prepend_complex_type(context, &mut result);
+        }
         result
     })
 }
@@ -1986,6 +1998,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 complex was detected anywhere
+    saw_complex: Cell<bool>,
 }
 
 impl<'ctx> BindgenContext<'ctx> {
@@ -134,6 +138,7 @@ impl<'ctx> BindgenContext<'ctx> {
             index: index,
             translation_unit: translation_unit,
             options: options,
+            saw_complex: Cell::new(false),
         };
 
         me.add_item(root_module, None, None);
@@ -697,6 +702,19 @@ impl<'ctx> BindgenContext<'ctx> {
             CXType_Float => TypeKind::Float(FloatKind::Float),
             CXType_Double => TypeKind::Float(FloatKind::Double),
             CXType_LongDouble => TypeKind::Float(FloatKind::LongDouble),
+            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?"),
+                };
+
+                self.saw_complex.set(true);
+                TypeKind::Complex(float_kind)
+            }
             _ => return None,
         };
 
@@ -929,6 +947,11 @@ impl<'ctx> BindgenContext<'ctx> {
             self.rust_ident_raw("std")
         }
     }
+
+    /// Whether a complex was detected anywhere
+    pub fn saw_complex(&self) -> bool {
+        return self.saw_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(..) |
@@ -384,6 +385,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),
 
@@ -461,6 +465,7 @@ impl Type {
             TypeKind::Named(..) |
             TypeKind::Int(..) |
             TypeKind::Float(..) |
+            TypeKind::Complex(..) |
             TypeKind::Function(..) |
             TypeKind::Enum(..) |
             TypeKind::Reference(..) |
@@ -751,17 +756,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>;
+}

tests/expectations/tests/convert-floats.rs

@@ -4,17 +4,25 @@
 #![allow(non_snake_case)]
 
 
+#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
+#[repr(C)]
+pub struct __BindgenComplex<T> {
+    pub re: T,
+    pub im: T,
+}
 #[repr(C)]
 #[derive(Debug, Copy)]
 pub struct foo {
     pub bar: ::std::os::raw::c_float,
     pub baz: ::std::os::raw::c_float,
     pub bazz: ::std::os::raw::c_double,
     pub bazzz: *mut ::std::os::raw::c_double,
+    pub complexFloat: __BindgenComplex<::std::os::raw::c_float>,
+    pub complexDouble: __BindgenComplex<::std::os::raw::c_double>,
 }
 #[test]
 fn bindgen_test_layout_foo() {
-    assert_eq!(::std::mem::size_of::<foo>() , 24usize);
+    assert_eq!(::std::mem::size_of::<foo>() , 48usize);
     assert_eq!(::std::mem::align_of::<foo>() , 8usize);
 }
 impl Clone for foo {