diff options
| -rw-r--r-- | compiler/rustc_macros/src/lib.rs | 2 | ||||
| -rw-r--r-- | compiler/rustc_macros/src/newtype.rs | 26 | ||||
| -rw-r--r-- | library/core/src/option.rs | 68 | ||||
| -rw-r--r-- | src/test/codegen/option-nonzero-eq.rs | 34 |
4 files changed, 128 insertions, 2 deletions
diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs index a2a01b66690..ac916bb6068 100644 --- a/compiler/rustc_macros/src/lib.rs +++ b/compiler/rustc_macros/src/lib.rs @@ -48,7 +48,7 @@ pub fn symbols(input: TokenStream) -> TokenStream { /// `u32::MAX`. You can also customize things like the `Debug` impl, /// what traits are derived, and so forth via the macro. #[proc_macro] -#[allow_internal_unstable(step_trait, rustc_attrs, trusted_step)] +#[allow_internal_unstable(step_trait, rustc_attrs, trusted_step, spec_option_partial_eq)] pub fn newtype_index(input: TokenStream) -> TokenStream { newtype::newtype(input) } diff --git a/compiler/rustc_macros/src/newtype.rs b/compiler/rustc_macros/src/newtype.rs index 0a77b734c76..fd3f5225155 100644 --- a/compiler/rustc_macros/src/newtype.rs +++ b/compiler/rustc_macros/src/newtype.rs @@ -192,6 +192,30 @@ impl Parse for Newtype { } } }; + let spec_partial_eq_impl = if let Lit::Int(max) = &max { + if let Ok(max_val) = max.base10_parse::<u32>() { + quote! { + impl core::option::SpecOptionPartialEq for #name { + #[inline] + fn eq(l: &Option<Self>, r: &Option<Self>) -> bool { + if #max_val < u32::MAX { + l.map(|i| i.private).unwrap_or(#max_val+1) == r.map(|i| i.private).unwrap_or(#max_val+1) + } else { + match (l, r) { + (Some(l), Some(r)) => r == l, + (None, None) => true, + _ => false + } + } + } + } + } + } else { + quote! {} + } + } else { + quote! {} + }; Ok(Self(quote! { #(#attrs)* @@ -293,6 +317,8 @@ impl Parse for Newtype { #step + #spec_partial_eq_impl + impl From<#name> for u32 { #[inline] fn from(v: #name) -> u32 { diff --git a/library/core/src/option.rs b/library/core/src/option.rs index f284b435955..505d964e518 100644 --- a/library/core/src/option.rs +++ b/library/core/src/option.rs @@ -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 ///////////////////////////////////////////////////////////////////////////// diff --git a/src/test/codegen/option-nonzero-eq.rs b/src/test/codegen/option-nonzero-eq.rs new file mode 100644 index 00000000000..598dcc19b49 --- /dev/null +++ b/src/test/codegen/option-nonzero-eq.rs @@ -0,0 +1,34 @@ +// compile-flags: -O -Zmerge-functions=disabled + +#![crate_type = "lib"] + +extern crate core; +use core::num::{NonZeroU32, NonZeroI64}; +use core::ptr::NonNull; + +// CHECK-lABEL: @non_zero_eq +#[no_mangle] +pub fn non_zero_eq(l: Option<NonZeroU32>, r: Option<NonZeroU32>) -> bool { + // CHECK: start: + // CHECK-NEXT: icmp eq i32 + // CHECK-NEXT: ret i1 + l == r +} + +// CHECK-lABEL: @non_zero_signed_eq +#[no_mangle] +pub fn non_zero_signed_eq(l: Option<NonZeroI64>, r: Option<NonZeroI64>) -> bool { + // CHECK: start: + // CHECK-NEXT: icmp eq i64 + // CHECK-NEXT: ret i1 + l == r +} + +// CHECK-lABEL: @non_null_eq +#[no_mangle] +pub fn non_null_eq(l: Option<NonNull<u8>>, r: Option<NonNull<u8>>) -> bool { + // CHECK: start: + // CHECK-NEXT: icmp eq {{(i8\*|ptr)}} + // CHECK-NEXT: ret i1 + l == r +} |