bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #103556 - clubby789:specialize-option-partial-eq, r=scottmcm

Browse source 
Manually implement PartialEq for Option<T> and specialize non-nullable types

This PR manually implements `PartialEq` and `StructuralPartialEq` for `Option`, which seems to produce slightly better codegen than the automatically derived implementation.

It also allows specializing on the `core::num::NonZero*` and `core::ptr::NonNull` types, taking advantage of the niche optimization by transmuting the `Option<T>` to `T` to be compared directly, which can be done in just two instructions.

A comparison of the original, new and specialized code generation is available [here](https://godbolt.org/z/dE4jxdYsa).
This commit is contained in:
bors 2022-11-26 08:56:20 +00:00
commit 8841bee954
4 changed files with 128 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

68
library/core/src/option.rs
View file

@ -512,7 +512,7 @@ use crate::{
};
/// The `Option` type. See [the module level documentation](self) for more.
#[derive(Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
#[derive(Copy, PartialOrd, Eq, Ord, Debug, Hash)]
#[rustc_diagnostic_item = "Option"]
#[stable(feature = "rust1", since = "1.0.0")]
pub enum Option<T> {
@ -2035,6 +2035,72 @@ impl<'a, T> const From<&'a mut Option<T>> for Option<&'a mut T> {
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> crate::marker::StructuralPartialEq for Option<T> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: PartialEq> PartialEq for Option<T> {
#[inline]
fn eq(&self, other: &Self) -> bool {
SpecOptionPartialEq::eq(self, other)
}
}
#[unstable(feature = "spec_option_partial_eq", issue = "none", reason = "exposed only for rustc")]
#[doc(hidden)]
pub trait SpecOptionPartialEq: Sized {
fn eq(l: &Option<Self>, other: &Option<Self>) -> bool;
}
#[unstable(feature = "spec_option_partial_eq", issue = "none", reason = "exposed only for rustc")]
impl<T: PartialEq> SpecOptionPartialEq for T {
#[inline]
default fn eq(l: &Option<T>, r: &Option<T>) -> bool {
match (l, r) {
(Some(l), Some(r)) => *l == *r,
(None, None) => true,
_ => false,
}
}
}
macro_rules! non_zero_option {
( $( #[$stability: meta] $NZ:ty; )+ ) => {
$(
#[$stability]
impl SpecOptionPartialEq for $NZ {
#[inline]
fn eq(l: &Option<Self>, r: &Option<Self>) -> bool {
l.map(Self::get).unwrap_or(0) == r.map(Self::get).unwrap_or(0)
}
}
)+
};
}
non_zero_option! {
#[stable(feature = "nonzero", since = "1.28.0")] crate::num::NonZeroU8;
#[stable(feature = "nonzero", since = "1.28.0")] crate::num::NonZeroU16;
#[stable(feature = "nonzero", since = "1.28.0")] crate::num::NonZeroU32;
#[stable(feature = "nonzero", since = "1.28.0")] crate::num::NonZeroU64;
#[stable(feature = "nonzero", since = "1.28.0")] crate::num::NonZeroU128;
#[stable(feature = "nonzero", since = "1.28.0")] crate::num::NonZeroUsize;
#[stable(feature = "signed_nonzero", since = "1.34.0")] crate::num::NonZeroI8;
#[stable(feature = "signed_nonzero", since = "1.34.0")] crate::num::NonZeroI16;
#[stable(feature = "signed_nonzero", since = "1.34.0")] crate::num::NonZeroI32;
#[stable(feature = "signed_nonzero", since = "1.34.0")] crate::num::NonZeroI64;
#[stable(feature = "signed_nonzero", since = "1.34.0")] crate::num::NonZeroI128;
#[stable(feature = "signed_nonzero", since = "1.34.0")] crate::num::NonZeroIsize;
}
#[stable(feature = "nonnull", since = "1.25.0")]
impl<T> SpecOptionPartialEq for crate::ptr::NonNull<T> {
#[inline]
fn eq(l: &Option<Self>, r: &Option<Self>) -> bool {
l.map(Self::as_ptr).unwrap_or_else(|| crate::ptr::null_mut())
== r.map(Self::as_ptr).unwrap_or_else(|| crate::ptr::null_mut())
}
}
/////////////////////////////////////////////////////////////////////////////
// The Option Iterators
/////////////////////////////////////////////////////////////////////////////