Handle the const struct * and struct * patterns.

Given that C keeps a different namespace for `struct`s and aliases. The
following patterns
```c
typedef const struct foo {
    void *inner;
} *foo;

typedef struct bar {
    void *inner;
} *bar;
```
are valid C code and produces both a `struct` and a pointer called `foo`
and `bar` in different namespaces. Given that Rust does not make this
distinction, we add the `_ptr` prefix to the pointer type aliases to
avoid any name collisions.

Author: pvdrz

bindgen-tests/tests/expectations/tests/struct_ptr.rs

@@ -0,0 +1,12 @@
+typedef const struct foo {
+    char inner;
+} *foo;
+
+typedef struct bar {
+    char inner;
+} *bar;
+
+void takes_foo_ptr(foo);
+void takes_foo_struct(struct foo);
+void takes_bar_ptr(bar);
+void takes_bar_struct(struct bar);

bindgen-tests/tests/headers/struct_ptr.h

@@ -1094,17 +1094,37 @@ impl Type {
                 }
                 CXType_Typedef => {
                     let inner = cursor.typedef_type().expect("Not valid Type?");
-                    let inner =
+                    let inner_id =
                         Item::from_ty_or_ref(inner, location, None, ctx);
-                    if inner == potential_id {
+                    if inner_id == potential_id {
                         warn!(
                             "Generating oqaque type instead of self-referential \
                             typedef");
                         // This can happen if we bail out of recursive situations
                         // within the clang parsing.
                         TypeKind::Opaque
                     } else {
-                        TypeKind::Alias(inner)
+                        // Check if this type definition is an alias to a pointer of a `const
+                        // struct` with the same name and add the `_ptr` suffix to it to avoid name
+                        // collisions.
+                        if !ctx.options().c_naming {
+                            if let Some(pointee_spelling) =
+                                inner.pointee_type().map(|ty| ty.spelling())
+                            {
+                                if let (Some(pointee_name), Some(name)) = (pointee_spelling
+                                    .strip_prefix("const struct ")
+                                    .or_else(|| {
+                                        pointee_spelling.strip_prefix("struct ")
+                                    }), name.as_mut())
+                                {
+                                    if pointee_name == name {
+                                        *name += "_ptr";
+                                    }
+                                }
+                            }
+                        }
+
+                        TypeKind::Alias(inner_id)
                     }
                 }
                 CXType_Enum => {