$NetBSD: patch-rust-1.39.0,v 1.1 2019/11/17 11:50:01 ryoon Exp $ From 9696bc1795c75b1b527e2b70d9baf3ced9e3c154 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Mon, 23 Sep 2019 17:54:37 +0200 Subject: [PATCH] ir: Make Ord and PartialOrd implementations agree. See https://github.com/rust-lang/rust/issues/64710. Bogus implementations were introduced in 230545e7c, d3e39dc62, and 379bb1663. --- third_party/rust/bindgen/src/ir/analysis/has_vtable.rs.orig 2019-10-16 19:30:29.000000000 +0000 +++ third_party/rust/bindgen/src/ir/analysis/has_vtable.rs @@ -9,17 +9,17 @@ use std::ops; use {HashMap, Entry}; /// The result of the `HasVtableAnalysis` for an individual item. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum HasVtableResult { - /// The item has a vtable, but the actual vtable pointer is in a base - /// member. - BaseHasVtable, + /// The item does not have a vtable pointer. + No, /// The item has a vtable and the actual vtable pointer is within this item. SelfHasVtable, - /// The item does not have a vtable pointer. - No + /// The item has a vtable, but the actual vtable pointer is in a base + /// member. + BaseHasVtable, } impl Default for HasVtableResult { @@ -28,21 +28,6 @@ impl Default for HasVtableResult { } } -impl cmp::PartialOrd for HasVtableResult { - fn partial_cmp(&self, rhs: &Self) -> Option { - use self::HasVtableResult::*; - - match (*self, *rhs) { - (x, y) if x == y => Some(cmp::Ordering::Equal), - (BaseHasVtable, _) => Some(cmp::Ordering::Greater), - (_, BaseHasVtable) => Some(cmp::Ordering::Less), - (SelfHasVtable, _) => Some(cmp::Ordering::Greater), - (_, SelfHasVtable) => Some(cmp::Ordering::Less), - _ => unreachable!(), - } - } -} - impl HasVtableResult { /// Take the least upper bound of `self` and `rhs`. pub fn join(self, rhs: Self) -> Self { $NetBSD: patch-rust-1.39.0,v 1.1 2019/11/17 11:50:01 ryoon Exp $ --- third_party/rust/bindgen/src/ir/analysis/sizedness.rs.orig 2019-10-16 19:30:29.000000000 +0000 +++ third_party/rust/bindgen/src/ir/analysis/sizedness.rs @@ -22,13 +22,14 @@ use {HashMap, Entry}; /// /// We initially assume that all types are `ZeroSized` and then update our /// understanding as we learn more about each type. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum SizednessResult { - /// Has some size that is known to be greater than zero. That doesn't mean - /// it has a static size, but it is not zero sized for sure. In other words, - /// it might contain an incomplete array or some other dynamically sized - /// type. - NonZeroSized, + /// The type is zero-sized. + /// + /// This means that if it is a C++ type, and is not being used as a base + /// member, then we must add an `_address` byte to enforce the + /// unique-address-per-distinct-object-instance rule. + ZeroSized, /// Whether this type is zero-sized or not depends on whether a type /// parameter is zero-sized or not. @@ -52,12 +53,11 @@ pub enum SizednessResult { /// https://github.com/rust-lang-nursery/rust-bindgen/issues/586 DependsOnTypeParam, - /// The type is zero-sized. - /// - /// This means that if it is a C++ type, and is not being used as a base - /// member, then we must add an `_address` byte to enforce the - /// unique-address-per-distinct-object-instance rule. - ZeroSized, + /// Has some size that is known to be greater than zero. That doesn't mean + /// it has a static size, but it is not zero sized for sure. In other words, + /// it might contain an incomplete array or some other dynamically sized + /// type. + NonZeroSized, } impl Default for SizednessResult { @@ -66,21 +66,6 @@ impl Default for SizednessResult { } } -impl cmp::PartialOrd for SizednessResult { - fn partial_cmp(&self, rhs: &Self) -> Option { - use self::SizednessResult::*; - - match (*self, *rhs) { - (x, y) if x == y => Some(cmp::Ordering::Equal), - (NonZeroSized, _) => Some(cmp::Ordering::Greater), - (_, NonZeroSized) => Some(cmp::Ordering::Less), - (DependsOnTypeParam, _) => Some(cmp::Ordering::Greater), - (_, DependsOnTypeParam) => Some(cmp::Ordering::Less), - _ => unreachable!(), - } - } -} - impl SizednessResult { /// Take the least upper bound of `self` and `rhs`. pub fn join(self, rhs: Self) -> Self { $NetBSD: patch-rust-1.39.0,v 1.1 2019/11/17 11:50:01 ryoon Exp $ --- third_party/rust/bindgen/src/ir/derive.rs.orig 2019-10-16 19:30:29.000000000 +0000 +++ third_party/rust/bindgen/src/ir/derive.rs @@ -92,10 +92,10 @@ pub trait CanDeriveOrd { /// /// Initially we assume that we can derive trait for all types and then /// update our understanding as we learn more about each type. -#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)] pub enum CanDerive { - /// No, we cannot. - No, + /// Yes, we can derive automatically. + Yes, /// The only thing that stops us from automatically deriving is that /// array with more than maximum number of elements is used. @@ -103,8 +103,8 @@ pub enum CanDerive { /// This means we probably can "manually" implement such trait. Manually, - /// Yes, we can derive automatically. - Yes, + /// No, we cannot. + No, } impl Default for CanDerive { @@ -113,22 +113,6 @@ impl Default for CanDerive { } } -impl cmp::PartialOrd for CanDerive { - fn partial_cmp(&self, rhs: &Self) -> Option { - use self::CanDerive::*; - - let ordering = match (*self, *rhs) { - (x, y) if x == y => cmp::Ordering::Equal, - (No, _) => cmp::Ordering::Greater, - (_, No) => cmp::Ordering::Less, - (Manually, _) => cmp::Ordering::Greater, - (_, Manually) => cmp::Ordering::Less, - _ => unreachable!() - }; - Some(ordering) - } -} - impl CanDerive { /// Take the least upper bound of `self` and `rhs`. pub fn join(self, rhs: Self) -> Self {