Use __BindegenComplex for C Complex Fix rust-lang#72

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

The global variable and struct members have different path
to set saw_complex.

Author: jeanphilippeD

src/codegen/mod.rs

@@ -38,6 +38,7 @@ fn root_import(ctx: &BindgenContext) -> P<ast::Item> {
 struct CodegenResult {
     items: Vec<P<ast::Item>>,
     saw_union: bool,
+    saw_complex: bool,
     items_seen: HashSet<ItemId>,
     /// The set of generated function/var names, needed because in C/C++ is
     /// legal to do something like:
@@ -64,6 +65,7 @@ impl CodegenResult {
         CodegenResult {
             items: vec![],
             saw_union: false,
+            saw_complex: false,
             items_seen: Default::default(),
             functions_seen: Default::default(),
             vars_seen: Default::default(),
@@ -73,6 +75,10 @@ impl CodegenResult {
     fn saw_union(&mut self) {
         self.saw_union = true;
     }
+    
+    fn saw_complex(&mut self) {
+        self.saw_complex = true;
+    }
 
     fn seen(&self, item: ItemId) -> bool {
         self.items_seen.contains(&item)
@@ -349,6 +355,9 @@ impl CodeGenerator for Type {
                 return;
             }
             TypeKind::Comp(ref ci) => ci.codegen(ctx, result, item),
+            TypeKind::Complex(..) => {
+                result.saw_complex();
+            }
             TypeKind::TemplateAlias(inner, _) => {
                 // NB: The inner Alias will pick the correct
                 // applicable_template_args.
@@ -774,6 +783,10 @@ impl CodeGenerator for CompInfo {
                     template_args_used[i] = true;
                 }
             }
+            
+            if let &TypeKind::Complex(..) = field_ty.kind() {
+                result.saw_complex();
+            }
 
             let ty = field.ty().to_rust_ty(ctx);
 
@@ -1487,6 +1500,17 @@ impl ToRustTy for Type {
                     }
                 }
             }
+            TypeKind::Complex(fk) => {
+                use ir::ty::FloatKind;
+                let float_path = match fk {
+                    FloatKind::Float => aster::ty::TyBuilder::new().f32(),
+                    FloatKind::Double | FloatKind::LongDouble => {
+                        aster::ty::TyBuilder::new().f64()
+                    }
+                };
+
+                quote_ty!(ctx.ext_cx(), __BindgenComplex<$float_path>)
+            }
             TypeKind::Function(ref fs) => {
                 let ty = fs.to_rust_ty(ctx, item);
                 let prefix = ctx.trait_prefix();
@@ -1756,10 +1780,14 @@ pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
         }
 
         let saw_union = result.saw_union;
+        let saw_complex = result.saw_complex;
         let mut result = result.items;
         if saw_union && !context.options().unstable_rust {
             utils::prepend_union_types(context, &mut result);
         }
+        if saw_complex {
+            utils::prepend_complex_type(context, &mut result);
+        }
         result
     })
 }
@@ -1841,6 +1869,24 @@ mod utils {
         result.extend(old_items.into_iter());
     }
 
+    pub fn prepend_complex_type(ctx: &BindgenContext,
+                                result: &mut Vec<P<ast::Item>>) {
+        let union_field_decl = 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![
+            union_field_decl,
+        ];
+        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

@@ -695,6 +695,18 @@ 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 => Some(FloatKind::Float),
+                        CXType_Double => Some(FloatKind::Double),
+                        CXType_LongDouble => Some(FloatKind::LongDouble),
+                        _ => None,
+                    }
+                    .expect("Not able to resolve complex floating type?");
+                TypeKind::Complex(float_kind)
+            },
             _ => return None,
         };
 

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 only exist for floating point.
+    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,87 @@
 #![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 Testdouble {
-    pub mMember: [f64; 2usize],
+pub struct TestDouble {
+    pub mMember: __BindgenComplex<f64>,
 }
 #[test]
-fn bindgen_test_layout_Testdouble() {
-    assert_eq!(::std::mem::size_of::<Testdouble>() , 16usize);
-    assert_eq!(::std::mem::align_of::<Testdouble>() , 8usize);
+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 {
+impl Clone for TestDouble {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct TestdoublePtr {
-    pub mMember: *mut [f64; 2usize],
+pub struct TestDoublePtr {
+    pub mMember: *mut __BindgenComplex<f64>,
 }
 #[test]
-fn bindgen_test_layout_TestdoublePtr() {
-    assert_eq!(::std::mem::size_of::<TestdoublePtr>() , 8usize);
-    assert_eq!(::std::mem::align_of::<TestdoublePtr>() , 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 TestdoublePtr {
+impl Clone for TestDoublePtr {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct Testfloat {
-    pub mMember: [f32; 2usize],
+pub struct TestFloat {
+    pub mMember: __BindgenComplex<f32>,
 }
 #[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_TestFloat() {
+    assert_eq!(::std::mem::size_of::<TestFloat>() , 8usize);
+    assert_eq!(::std::mem::align_of::<TestFloat>() , 4usize);
 }
-impl Clone for Testfloat {
+impl Clone for TestFloat {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct TestfloatPtr {
-    pub mMember: *mut [f32; 2usize],
+pub struct TestFloatPtr {
+    pub mMember: *mut __BindgenComplex<f32>,
 }
 #[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_TestFloatPtr() {
+    assert_eq!(::std::mem::size_of::<TestFloatPtr>() , 8usize);
+    assert_eq!(::std::mem::align_of::<TestFloatPtr>() , 8usize);
 }
-impl Clone for TestfloatPtr {
+impl Clone for TestFloatPtr {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct Testint {
-    pub mMember: [::std::os::raw::c_int; 2usize],
+pub struct TestLongDouble {
+    pub mMember: __BindgenComplex<f64>,
 }
 #[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_TestLongDouble() {
+    assert_eq!(::std::mem::size_of::<TestLongDouble>() , 32usize);
+    assert_eq!(::std::mem::align_of::<TestLongDouble>() , 16usize);
 }
-impl Clone for Testint {
+impl Clone for TestLongDouble {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct TestintPtr {
-    pub mMember: *mut [::std::os::raw::c_int; 2usize],
+pub struct TestLongDoublePtr {
+    pub mMember: *mut __BindgenComplex<f64>,
 }
 #[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_TestLongDoublePtr() {
+    assert_eq!(::std::mem::size_of::<TestLongDoublePtr>() , 8usize);
+    assert_eq!(::std::mem::align_of::<TestLongDoublePtr>() , 8usize);
 }
-impl Clone for TestintPtr {
+impl Clone for TestLongDoublePtr {
     fn clone(&self) -> Self { *self }
 }

tests/expectations/tests/complex_global.rs

@@ -0,0 +1,16 @@
+/* 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 = "globalValue"]
+    pub static mut globalValue: __BindgenComplex<f64>;
+}

tests/headers/complex.h

@@ -1,13 +1,13 @@
 
-#define COMPLEX_TEST(ty_)     \
-  struct Test##ty_ {          \
-    ty_ _Complex mMember;     \
-                              \
-  };                          \
-  struct Test##ty_##Ptr {     \
-    ty_ _Complex* mMember;    \
+#define COMPLEX_TEST(ty_, name_)  \
+  struct Test##name_ {            \
+    ty_ _Complex mMember;         \
+                                  \
+  };                              \
+  struct Test##name_##Ptr {       \
+    ty_ _Complex* mMember;        \
   };
 
-COMPLEX_TEST(double)
-COMPLEX_TEST(float)
-COMPLEX_TEST(int)
+COMPLEX_TEST(double, Double)
+COMPLEX_TEST(float, Float)
+COMPLEX_TEST(long double, LongDouble)

tests/headers/complex_global.h

@@ -0,0 +1 @@
+double _Complex globalValue;