Follow multiple transparent links in Option layout

src/bindgen/ir/function.rs

@@ -17,6 +17,7 @@ use crate::bindgen::library::Library;
 use crate::bindgen::monomorph::Monomorphs;
 use crate::bindgen::rename::{IdentifierType, RenameRule};
 use crate::bindgen::reserved;
+use crate::bindgen::transparent_types::TransparentTypes;
 use crate::bindgen::utilities::IterHelpers;
 use crate::bindgen::writer::{Source, SourceWriter};
 
@@ -127,10 +128,14 @@ impl Function {
         &self.path
     }
 
-    pub fn simplify_standard_types(&mut self, config: &Config) {
-        self.ret.simplify_standard_types(config);
+    pub fn simplify_standard_types(
+        &mut self,
+        config: &Config,
+        transparent_types: &TransparentTypes,
+    ) {
+        self.ret.simplify_standard_types(config, transparent_types);
         for arg in &mut self.args {
-            arg.ty.simplify_standard_types(config);
+            arg.ty.simplify_standard_types(config, transparent_types);
         }
     }
 

src/bindgen/ir/global.rs

@@ -10,6 +10,7 @@ use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
 use crate::bindgen::dependencies::Dependencies;
 use crate::bindgen::ir::{AnnotationSet, Cfg, Documentation, Item, ItemContainer, Path, Type};
 use crate::bindgen::library::Library;
+use crate::bindgen::transparent_types::TransparentTypes;
 use crate::bindgen::writer::{Source, SourceWriter};
 
 #[derive(Debug, Clone)]
@@ -61,8 +62,12 @@ impl Static {
         }
     }
 
-    pub fn simplify_standard_types(&mut self, config: &Config) {
-        self.ty.simplify_standard_types(config);
+    pub fn simplify_standard_types(
+        &mut self,
+        config: &Config,
+        transparent_types: &TransparentTypes,
+    ) {
+        self.ty.simplify_standard_types(config, transparent_types);
     }
 }
 

src/bindgen/ir/structure.rs

@@ -16,6 +16,7 @@ use crate::bindgen::mangle;
 use crate::bindgen::monomorph::Monomorphs;
 use crate::bindgen::rename::{IdentifierType, RenameRule};
 use crate::bindgen::reserved;
+use crate::bindgen::transparent_types::TransparentTypes;
 use crate::bindgen::utilities::IterHelpers;
 use crate::bindgen::writer::{ListType, Source, SourceWriter};
 
@@ -142,9 +143,13 @@ impl Struct {
         }
     }
 
-    pub fn simplify_standard_types(&mut self, config: &Config) {
+    pub fn simplify_standard_types(
+        &mut self,
+        config: &Config,
+        transparent_types: &TransparentTypes,
+    ) {
         for field in &mut self.fields {
-            field.ty.simplify_standard_types(config);
+            field.ty.simplify_standard_types(config, transparent_types);
         }
     }
 

src/bindgen/ir/ty.rs

@@ -12,6 +12,7 @@ use crate::bindgen::dependencies::Dependencies;
 use crate::bindgen::ir::{GenericParams, GenericPath, Path};
 use crate::bindgen::library::Library;
 use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::transparent_types::TransparentTypes;
 use crate::bindgen::utilities::IterHelpers;
 use crate::bindgen::writer::{Source, SourceWriter};
 
@@ -588,7 +589,11 @@ impl Type {
         }))
     }
 
-    fn simplified_type(&self, config: &Config) -> Option<Self> {
+    fn simplified_type(
+        &self,
+        config: &Config,
+        transparent_types: &TransparentTypes,
+    ) -> Option<Self> {
         let path = match *self {
             Type::Path(ref p) => p,
             _ => return None,
@@ -603,12 +608,25 @@ impl Type {
         }
 
         let unsimplified_generic = &path.generics()[0];
-        let generic = match unsimplified_generic.simplified_type(config) {
+        let mut generic = match unsimplified_generic.simplified_type(config, transparent_types) {
             Some(generic) => Cow::Owned(generic),
             None => Cow::Borrowed(unsimplified_generic),
         };
         match path.name() {
             "Option" => {
+                // Repeatedly follow any typedefs or transparent structs until we reach a type that
+                // has its own "real" type in C/C++.
+                while let Some(transparent) = transparent_types.is_transparent(&generic) {
+                    // Make sure to do another round of simplifying each time we follow a typedef
+                    // or transparent struct link.
+                    generic = match transparent.simplified_type(config, transparent_types) {
+                        Some(generic) => Cow::Owned(generic),
+                        None => Cow::Owned(transparent),
+                    };
+                }
+
+                // Once we've found the base type for the Option's generic, see if we can take
+                // advantage of any nullable/zeroable layout optimizations.
                 if let Some(nullable) = generic.make_nullable() {
                     return Some(nullable);
                 }
@@ -637,9 +655,13 @@ impl Type {
         }
     }
 
-    pub fn simplify_standard_types(&mut self, config: &Config) {
-        self.visit_types(|ty| ty.simplify_standard_types(config));
-        if let Some(ty) = self.simplified_type(config) {
+    pub fn simplify_standard_types(
+        &mut self,
+        config: &Config,
+        transparent_types: &TransparentTypes,
+    ) {
+        self.visit_types(|ty| ty.simplify_standard_types(config, transparent_types));
+        if let Some(ty) = self.simplified_type(config, transparent_types) {
             *self = ty;
         }
     }

src/bindgen/ir/typedef.rs

@@ -15,6 +15,7 @@ use crate::bindgen::ir::{
 use crate::bindgen::library::Library;
 use crate::bindgen::mangle;
 use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::transparent_types::TransparentTypes;
 use crate::bindgen::writer::{Source, SourceWriter};
 
 /// A type alias that is represented as a C typedef
@@ -66,8 +67,13 @@ impl Typedef {
         }
     }
 
-    pub fn simplify_standard_types(&mut self, config: &Config) {
-        self.aliased.simplify_standard_types(config);
+    pub fn simplify_standard_types(
+        &mut self,
+        config: &Config,
+        transparent_types: &TransparentTypes,
+    ) {
+        self.aliased
+            .simplify_standard_types(config, transparent_types);
     }
 
     pub fn transfer_annotations(&mut self, out: &mut HashMap<Path, AnnotationSet>) {

src/bindgen/ir/union.rs

@@ -15,6 +15,7 @@ use crate::bindgen::library::Library;
 use crate::bindgen::mangle;
 use crate::bindgen::monomorph::Monomorphs;
 use crate::bindgen::rename::{IdentifierType, RenameRule};
+use crate::bindgen::transparent_types::TransparentTypes;
 use crate::bindgen::utilities::IterHelpers;
 use crate::bindgen::writer::{ListType, Source, SourceWriter};
 
@@ -95,9 +96,13 @@ impl Union {
         }
     }
 
-    pub fn simplify_standard_types(&mut self, config: &Config) {
+    pub fn simplify_standard_types(
+        &mut self,
+        config: &Config,
+        transparent_types: &TransparentTypes,
+    ) {
         for field in &mut self.fields {
-            field.ty.simplify_standard_types(config);
+            field.ty.simplify_standard_types(config, transparent_types);
         }
     }
 

src/bindgen/library.rs

@@ -12,6 +12,7 @@ use crate::bindgen::error::Error;
 use crate::bindgen::ir::{Constant, Enum, Function, Item, ItemContainer, ItemMap};
 use crate::bindgen::ir::{OpaqueItem, Path, Static, Struct, Typedef, Union};
 use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::transparent_types::TransparentTypes;
 use crate::bindgen::ItemType;
 
 #[derive(Debug, Clone)]
@@ -358,21 +359,24 @@ impl Library {
 
     fn simplify_standard_types(&mut self) {
         let config = &self.config;
+        let mut transparent_types = TransparentTypes::default();
+        transparent_types.add_structs(&self.structs);
+        transparent_types.add_typedefs(&self.typedefs);
 
         self.structs.for_all_items_mut(|x| {
-            x.simplify_standard_types(config);
+            x.simplify_standard_types(config, &transparent_types);
         });
         self.unions.for_all_items_mut(|x| {
-            x.simplify_standard_types(config);
+            x.simplify_standard_types(config, &transparent_types);
         });
         self.globals.for_all_items_mut(|x| {
-            x.simplify_standard_types(config);
+            x.simplify_standard_types(config, &transparent_types);
         });
         self.typedefs.for_all_items_mut(|x| {
-            x.simplify_standard_types(config);
+            x.simplify_standard_types(config, &transparent_types);
         });
         for x in &mut self.functions {
-            x.simplify_standard_types(config);
+            x.simplify_standard_types(config, &transparent_types);
         }
     }
 

src/bindgen/mod.rs

@@ -52,6 +52,7 @@ mod monomorph;
 mod parser;
 mod rename;
 mod reserved;
+mod transparent_types;
 mod utilities;
 mod writer;
 

src/bindgen/transparent_types.rs

@@ -0,0 +1,49 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::collections::HashMap;
+
+use crate::bindgen::ir::{GenericParams, ItemMap, Path, Struct, Type, Typedef};
+
+/// Keeps track of named types that have the same underlying representation as some other type.
+/// This happens via `#[repr(transparent)]` structs and via typedefs.
+#[derive(Default)]
+pub struct TransparentTypes {
+    transparent: HashMap<Path, (Type, GenericParams)>,
+}
+
+impl TransparentTypes {
+    pub fn add_structs(&mut self, structs: &ItemMap<Struct>) {
+        structs.for_all_items(|s| {
+            if s.is_transparent {
+                self.transparent.insert(
+                    s.path.clone(),
+                    (s.fields[0].ty.clone(), s.generic_params.clone()),
+                );
+            }
+        });
+    }
+
+    pub fn add_typedefs(&mut self, structs: &ItemMap<Typedef>) {
+        structs.for_all_items(|t| {
+            self.transparent.insert(
+                t.path.clone(),
+                (t.aliased.clone(), t.generic_params.clone()),
+            );
+        });
+    }
+
+    pub fn is_transparent(&self, ty: &Type) -> Option<Type> {
+        let generic_path = match ty {
+            Type::Path(p) => p,
+            _ => return None,
+        };
+        let (resolved, generic_params) = self.transparent.get(generic_path.path())?;
+        let mappings = generic_params
+            .iter()
+            .zip(generic_path.generics())
+            .collect::<Vec<_>>();
+        Some(resolved.specialize(&mappings))
+    }
+}

tests/expectations/exclude_generic_monomorph.both.c

@@ -22,7 +22,7 @@ ctypedef uint64_t Option_Foo
 #include <stdlib.h>
 
 typedef struct Bar {
-  Option_Foo foo;
+  uint64_t foo;
 } Bar;
 
 void root(struct Bar f);

tests/expectations/exclude_generic_monomorph.both.compat.c

@@ -22,7 +22,7 @@ ctypedef uint64_t Option_Foo
 #include <stdlib.h>
 
 typedef struct Bar {
-  Option_Foo foo;
+  uint64_t foo;
 } Bar;
 
 #ifdef __cplusplus

tests/expectations/exclude_generic_monomorph.c

@@ -22,7 +22,7 @@ ctypedef uint64_t Option_Foo
 #include <stdlib.h>
 
 typedef struct {
-  Option_Foo foo;
+  uint64_t foo;
 } Bar;
 
 void root(Bar f);

tests/expectations/exclude_generic_monomorph.compat.c

@@ -22,7 +22,7 @@ ctypedef uint64_t Option_Foo
 #include <stdlib.h>
 
 typedef struct {
-  Option_Foo foo;
+  uint64_t foo;
 } Bar;
 
 #ifdef __cplusplus

tests/expectations/exclude_generic_monomorph.cpp

@@ -22,7 +22,7 @@ ctypedef uint64_t Option_Foo
 #include <stdlib.h>
 
 typedef struct Bar {
-  Option_Foo foo;
+  uint64_t foo;
 } Bar;
 
 void root(struct Bar f);

tests/expectations/exclude_generic_monomorph.pyx

@@ -25,6 +25,6 @@ cdef extern from *:
 cdef extern from *:
 
   ctypedef struct Bar:
-    Option_Foo foo;
+    uint64_t foo;
 
   void root(Bar f);

tests/expectations/exclude_generic_monomorph.tag.c

@@ -22,7 +22,7 @@ ctypedef uint64_t Option_Foo
 #include <stdlib.h>
 
 struct Bar {
-  Option_Foo foo;
+  uint64_t foo;
 };
 
 void root(struct Bar f);

tests/expectations/exclude_generic_monomorph.tag.compat.c

@@ -22,7 +22,7 @@ ctypedef uint64_t Option_Foo
 #include <stdlib.h>
 
 struct Bar {
-  Option_Foo foo;
+  uint64_t foo;
 };
 
 #ifdef __cplusplus

tests/expectations/exclude_generic_monomorph.tag.pyx

@@ -25,6 +25,6 @@ cdef extern from *:
 cdef extern from *:
 
   cdef struct Bar:
-    Option_Foo foo;
+    uint64_t foo;
 
   void root(Bar f);

tests/expectations/nested_nonnull.both.c

@@ -0,0 +1,21 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef int32_t (*DoFn)(int32_t x, int32_t y);
+
+typedef struct StructWithOptionalFunctionPointer {
+  DoFn func;
+  int32_t (*maybe_func)(int32_t x, int32_t y);
+} StructWithOptionalFunctionPointer;
+
+typedef uint32_t *NonNullAlias_u32;
+
+typedef struct StructWithOptionalNonNullPointer {
+  NonNullAlias_u32 data;
+  uint32_t *maybe_data;
+} StructWithOptionalNonNullPointer;
+
+void root(struct StructWithOptionalFunctionPointer swofp,
+          struct StructWithOptionalNonNullPointer swonnp);