Add --no-partialeq <regex> flag

Related to rust-lang#965.

- [x] Add a new RegexSet member to bindgen::Builder (similar to the whitelisted_types set).

- [x] A Builder method to add strings to that RegexSet.

- [x] Plumbing in src/options.rs to convert --no-partialeq <regex> CLI flags into invocations of the builder method.

- [x] Make the MonotoneFramework::constrain function in src/ir/analysis/derive_partialeq.rs check if the given item is explicitly marked not to be Partialeq, and if so, insert it into the self.cannot_derive_partialeq set via return self.insert(id).

- [] Tests!

- [] When the no-partialeq type is transitively referenced by a whitelisted item

- [] When the no-partialeq type is explicitly whitelisted

- [] When the no-partialeq type is marked opaque

Author: alexeyzab

src/ir/analysis/derive_partial_eq.rs

@@ -7,6 +7,7 @@ use ir::comp::FieldMethods;
 use ir::context::{BindgenContext, ItemId};
 use ir::derive::CanTriviallyDerivePartialEq;
 use ir::item::IsOpaque;
+use ir::item::ItemCanonicalName;
 use ir::traversal::EdgeKind;
 use ir::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
 use ir::ty::TypeKind;
@@ -144,6 +145,11 @@ impl<'ctx> MonotoneFramework for CannotDerivePartialEq<'ctx> {
             };
         }
 
+        let name = item.canonical_name(self.ctx);
+        if self.ctx.options().no_partialeq_types.matches(&name) {
+            return self.insert(id)
+        }
+
         if ty.layout(self.ctx).map_or(false, |l| {
             l.align > RUST_DERIVE_IN_ARRAY_LIMIT
         })

src/lib.rs

@@ -499,6 +499,20 @@ impl Builder {
             output_vector.push(path.into());
         }
 
+        self.options
+            .no_partialeq_types
+            .get_items()
+            .iter()
+            .map(|item| {
+                output_vector.push("--no-partialeq".into());
+                output_vector.push(
+                    item.trim_left_matches("^")
+                        .trim_right_matches("$")
+                        .into(),
+                );
+            })
+            .count();
+
         output_vector
     }
 
@@ -1098,6 +1112,13 @@ impl Builder {
             ))
         }
     }
+
+    /// Don't derive `PartialEq` for a given type. Regular
+    /// expressions are supported.
+    pub fn no_partialeq(mut self, arg: String) -> Builder {
+        self.options.no_partialeq_types.insert(arg);
+        self
+    }
 }
 
 /// Configuration options for generated bindings.
@@ -1272,6 +1293,9 @@ pub struct BindgenOptions {
     /// The absolute path to the rustfmt configuration file, if None, the standard rustfmt
     /// options are used.
     pub rustfmt_configuration_file: Option<PathBuf>,
+
+    /// The set of types that we should not derive `PartialEq` for.
+    pub no_partialeq_types: RegexSet,
 }
 
 /// TODO(emilio): This is sort of a lie (see the error message that results from
@@ -1361,6 +1385,7 @@ impl Default for BindgenOptions {
             time_phases: false,
             rustfmt_bindings: false,
             rustfmt_configuration_file: None,
+            no_partialeq_types: Default::default(),
         }
     }
 }

src/options.rs

@@ -262,6 +262,13 @@ where
                 .takes_value(true)
                 .multiple(false)
                 .number_of_values(1),
+            Arg::with_name("no-partialeq")
+                .long("no-partialeq")
+                .help("Avoid deriving PartialEq for types matching <regex>.")
+                .value_name("regex")
+                .takes_value(true)
+                .multiple(true)
+                .number_of_values(1),
         ]) // .args()
         .get_matches_from(args);
 
@@ -530,6 +537,12 @@ where
         builder = builder.rustfmt_configuration_file(Some(path));
     }
 
+    if let Some(no_partialeq) = matches.values_of("no-partialeq") {
+        for regex in no_partialeq {
+            builder = builder.no_partialeq(String::from(regex));
+        }
+    }
+
     let verbose = matches.is_present("verbose");
 
     Ok((builder, output, verbose))