Auto merge of #1312 - emilio:constness-woes, r=fitzgen

ir: Handle *const T at the codegen level.

Followup to #1311.

src/codegen/mod.rs

@@ -3054,7 +3054,7 @@ impl TryToRustTy for Type {
             }
             TypeKind::Pointer(inner) |
             TypeKind::Reference(inner) => {
-                let is_const = self.is_const() || ctx.resolve_type(inner).is_const();
+                let is_const = ctx.resolve_type(inner).is_const();
 
                 let inner = inner.into_resolver().through_type_refs().resolve(ctx);
                 let inner_ty = inner.expect_type();

src/ir/context.rs

@@ -1925,9 +1925,44 @@ impl BindgenContext {
         wrapped_id: TypeId,
         parent_id: Option<ItemId>,
         ty: &clang::Type,
+    ) -> TypeId {
+        self.build_wrapper(
+            with_id,
+            wrapped_id,
+            parent_id,
+            ty,
+            ty.is_const(),
+        )
+    }
+
+    /// A wrapper over a type that adds a const qualifier explicitly.
+    ///
+    /// Needed to handle const methods in C++, wrapping the type .
+    pub fn build_const_wrapper(
+        &mut self,
+        with_id: ItemId,
+        wrapped_id: TypeId,
+        parent_id: Option<ItemId>,
+        ty: &clang::Type,
+    ) -> TypeId {
+        self.build_wrapper(
+            with_id,
+            wrapped_id,
+            parent_id,
+            ty,
+            /* is_const = */ true,
+        )
+    }
+
+    fn build_wrapper(
+        &mut self,
+        with_id: ItemId,
+        wrapped_id: TypeId,
+        parent_id: Option<ItemId>,
+        ty: &clang::Type,
+        is_const: bool,
     ) -> TypeId {
         let spelling = ty.spelling();
-        let is_const = ty.is_const();
         let layout = ty.fallible_layout().ok();
         let type_kind = TypeKind::ResolvedTypeRef(wrapped_id);
         let ty = Type::new(Some(spelling), layout, type_kind, is_const);

src/ir/function.rs

@@ -402,14 +402,27 @@ impl FunctionSig {
             let is_virtual = is_method && cursor.method_is_virtual();
             let is_static = is_method && cursor.method_is_static();
             if !is_static && !is_virtual {
-                let class = Item::parse(cursor.semantic_parent(), None, ctx)
+                let parent = cursor.semantic_parent();
+                let class = Item::parse(parent, None, ctx)
                     .expect("Expected to parse the class");
                 // The `class` most likely is not finished parsing yet, so use
                 // the unchecked variant.
                 let class = class.as_type_id_unchecked();
 
+                let class = if is_const {
+                    let const_class_id = ctx.next_item_id();
+                    ctx.build_const_wrapper(
+                        const_class_id,
+                        class,
+                        None,
+                        &parent.cur_type(),
+                    )
+                } else {
+                    class
+                };
+
                 let ptr =
-                    Item::builtin_type(TypeKind::Pointer(class), is_const, ctx);
+                    Item::builtin_type(TypeKind::Pointer(class), false, ctx);
                 args.insert(0, (Some("this".into()), ptr));
             } else if is_virtual {
                 let void = Item::builtin_type(TypeKind::Void, false, ctx);

src/ir/item.rs

@@ -1449,8 +1449,8 @@ impl ClangItemParser for Item {
                 return Ok(Item::new_opaque_type(id, ty, ctx));
             }
 
-            if let Some(id) = Item::type_param(Some(id), location, ctx) {
-                return Ok(id);
+            if let Some(param_id) = Item::type_param(None, location, ctx) {
+                return Ok(ctx.build_ty_wrapper(id, param_id, None, ty));
             }
         }
 

src/ir/layout.rs

@@ -88,7 +88,8 @@ impl Opaque {
     pub fn from_clang_ty(ty: &clang::Type) -> Type {
         let layout = Layout::new(ty.size(), ty.align());
         let ty_kind = TypeKind::Opaque;
-        Type::new(None, Some(layout), ty_kind, false)
+        let is_const = ty.is_const();
+        Type::new(None, Some(layout), ty_kind, is_const)
     }
 
     /// Return the known rust type we should use to create a correctly-aligned

src/ir/ty.rs

@@ -1195,22 +1195,7 @@ impl Type {
 
         let name = if name.is_empty() { None } else { Some(name) };
 
-        // Just using ty.is_const() is wrong here, because when we declare an
-        // argument like 'int* const arg0', arg0 is considered
-        // const but the pointer itself points to mutable data.
-        //
-        // Without canonicalizing the type to the pointer type, we'll get the
-        // following mapping:
-        //
-        // arg0: *const c_int
-        //
-        // So by canonicalizing the type first, we can check constness by
-        // calling is_const() on the pointer type.
-        let is_const = if let Some(pty) = ty.pointee_type() {
-            pty.is_const()
-        } else {
-            ty.is_const()
-        };
+        let is_const = ty.is_const();
 
         let ty = Type::new(name, layout, kind, is_const);
         // TODO: maybe declaration.canonical()?

tests/expectations/tests/const-const-mut-ptr.rs

@@ -0,0 +1,32 @@
+/* automatically generated by rust-bindgen */
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct foo {
+    pub bar: *const *const *mut *const ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<foo>())).bar as *const _ as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        unsafe { ::std::mem::zeroed() }
+    }
+}

tests/headers/const-const-mut-ptr.h

@@ -0,0 +1,3 @@
+struct foo {
+  const int** const* const* bar;
+};