get rid of the internal unlikely macro

Author: RalfJung

library/core/src/intrinsics.rs

@@ -986,7 +986,10 @@ pub const unsafe fn assume(b: bool) {
 /// any safety invariants.
 ///
 /// This intrinsic does not have a stable counterpart.
-#[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_likely", issue = "none"))]
+#[cfg_attr(
+ bootstrap,
+ rustc_const_stable(feature = "const_likely", since = "CURRENT_RUSTC_VERSION")
+)]
 #[cfg_attr(not(bootstrap), rustc_const_stable_indirect)]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
@@ -1007,7 +1010,10 @@ pub const fn likely(b: bool) -> bool {
 /// any safety invariants.
 ///
 /// This intrinsic does not have a stable counterpart.
-#[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_likely", issue = "none"))]
+#[cfg_attr(
+ bootstrap,
+ rustc_const_stable(feature = "const_likely", since = "CURRENT_RUSTC_VERSION")
+)]
 #[cfg_attr(not(bootstrap), rustc_const_stable_indirect)]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]

library/core/src/num/int_macros.rs

@@ -449,7 +449,7 @@ macro_rules! int_impl {
  #[inline]
 pubconstfn checked_add(self, rhs:Self) -> Option<Self> {
 let(a, b) = self.overflowing_add(rhs);
-if unlikely!(b){None} else {Some(a)}
+ifintrinsics::unlikely(b){None} else {Some(a)}
 }
 
 /// Strict integer addition. Computes `self + rhs`, panicking
@@ -545,7 +545,7 @@ macro_rules! int_impl {
  #[inline]
 pubconstfn checked_add_unsigned(self, rhs: $UnsignedT) -> Option<Self> {
 let(a, b) = self.overflowing_add_unsigned(rhs);
-if unlikely!(b){None} else {Some(a)}
+ifintrinsics::unlikely(b){None} else {Some(a)}
 }
 
 /// Strict addition with an unsigned integer. Computes `self + rhs`,
@@ -601,7 +601,7 @@ macro_rules! int_impl {
  #[inline]
 pubconstfn checked_sub(self, rhs:Self) -> Option<Self> {
 let(a, b) = self.overflowing_sub(rhs);
-if unlikely!(b){None} else {Some(a)}
+ifintrinsics::unlikely(b){None} else {Some(a)}
 }
 
 /// Strict integer subtraction. Computes `self - rhs`, panicking if
@@ -697,7 +697,7 @@ macro_rules! int_impl {
  #[inline]
 pubconstfn checked_sub_unsigned(self, rhs: $UnsignedT) -> Option<Self> {
 let(a, b) = self.overflowing_sub_unsigned(rhs);
-if unlikely!(b){None} else {Some(a)}
+ifintrinsics::unlikely(b){None} else {Some(a)}
 }
 
 /// Strict subtraction with an unsigned integer. Computes `self - rhs`,
@@ -753,7 +753,7 @@ macro_rules! int_impl {
  #[inline]
 pubconstfn checked_mul(self, rhs:Self) -> Option<Self> {
 let(a, b) = self.overflowing_mul(rhs);
-if unlikely!(b){None} else {Some(a)}
+ifintrinsics::unlikely(b){None} else {Some(a)}
 }
 
 /// Strict integer multiplication. Computes `self * rhs`, panicking if
@@ -849,7 +849,7 @@ macro_rules! int_impl {
  without modifying the original"]
  #[inline]
 pubconstfn checked_div(self, rhs:Self) -> Option<Self> {
-if unlikely!(rhs == 0 || ((self == Self::MIN) && (rhs == -1))){
+ifintrinsics::unlikely(rhs == 0 || ((self == Self::MIN) && (rhs == -1))){
 None
 } else {
 // SAFETY: div by zero and by INT_MIN have been checked above
@@ -924,7 +924,7 @@ macro_rules! int_impl {
  #[inline]
 pubconstfn checked_div_euclid(self, rhs:Self) -> Option<Self> {
 // Using `&` helps LLVM see that it is the same check made in division.
-if unlikely!(rhs == 0 || ((self == Self::MIN)&(rhs == -1))){
+ifintrinsics::unlikely(rhs == 0 || ((self == Self::MIN)&(rhs == -1))){
 None
 } else {
 Some(self.div_euclid(rhs))
@@ -997,7 +997,7 @@ macro_rules! int_impl {
  without modifying the original"]
  #[inline]
 pubconstfn checked_rem(self, rhs:Self) -> Option<Self> {
-if unlikely!(rhs == 0 || ((self == Self::MIN) && (rhs == -1))){
+ifintrinsics::unlikely(rhs == 0 || ((self == Self::MIN) && (rhs == -1))){
 None
 } else {
 // SAFETY: div by zero and by INT_MIN have been checked above
@@ -1071,7 +1071,7 @@ macro_rules! int_impl {
  #[inline]
 pubconstfn checked_rem_euclid(self, rhs:Self) -> Option<Self> {
 // Using `&` helps LLVM see that it is the same check made in division.
-if unlikely!(rhs == 0 || ((self == Self::MIN)&(rhs == -1))){
+ifintrinsics::unlikely(rhs == 0 || ((self == Self::MIN)&(rhs == -1))){
 None
 } else {
 Some(self.rem_euclid(rhs))
@@ -1142,7 +1142,7 @@ macro_rules! int_impl {
  #[inline]
 pubconstfn checked_neg(self) -> Option<Self> {
 let(a, b) = self.overflowing_neg();
-if unlikely!(b){None} else {Some(a)}
+ifintrinsics::unlikely(b){None} else {Some(a)}
 }
 
 /// Unchecked negation. Computes `-self`, assuming overflow cannot occur.
@@ -2564,7 +2564,7 @@ macro_rules! int_impl {
  without modifying the original"]
 pubconstfn overflowing_div(self, rhs:Self) -> (Self,bool){
 // Using `&` helps LLVM see that it is the same check made in division.
-if unlikely!((self == Self::MIN)&(rhs == -1)){
+ifintrinsics::unlikely((self == Self::MIN)&(rhs == -1)){
 (self,true)
 } else {
 (self / rhs,false)
@@ -2595,7 +2595,7 @@ macro_rules! int_impl {
  without modifying the original"]
 pubconstfn overflowing_div_euclid(self, rhs:Self) -> (Self,bool){
 // Using `&` helps LLVM see that it is the same check made in division.
-if unlikely!((self == Self::MIN)&(rhs == -1)){
+ifintrinsics::unlikely((self == Self::MIN)&(rhs == -1)){
 (self,true)
 } else {
 (self.div_euclid(rhs),false)
@@ -2625,7 +2625,7 @@ macro_rules! int_impl {
  #[must_use = "this returns the result of the operation, \
  without modifying the original"]
 pubconstfn overflowing_rem(self, rhs:Self) -> (Self,bool){
-if unlikely!(rhs == -1){
+ifintrinsics::unlikely(rhs == -1){
 (0,self == Self::MIN)
 } else {
 (self % rhs,false)
@@ -2657,7 +2657,7 @@ macro_rules! int_impl {
  #[inline]
  #[track_caller]
 pubconstfn overflowing_rem_euclid(self, rhs:Self) -> (Self,bool){
-if unlikely!(rhs == -1){
+ifintrinsics::unlikely(rhs == -1){
 (0,self == Self::MIN)
 } else {
 (self.rem_euclid(rhs),false)
@@ -2686,7 +2686,7 @@ macro_rules! int_impl {
  without modifying the original"]
  #[allow(unused_attributes)]
 pubconstfn overflowing_neg(self) -> (Self,bool){
-if unlikely!(self == Self::MIN){
+ifintrinsics::unlikely(self == Self::MIN){
 (Self::MIN,true)
 } else {
 (-self,false)

library/core/src/num/mod.rs

@@ -16,13 +16,6 @@ macro_rules! try_opt {
 };
 }
 
-#[cfg_attr(bootstrap, allow_internal_unstable(const_likely))]
-macro_rules! unlikely {
-($e: expr) => {
- intrinsics::unlikely($e)
-};
-}
-
 // Use this when the generated code should differ between signed and unsigned types.
 macro_rules! sign_dependent_expr {
 (signed ? if signed { $signed_case:expr }if unsigned { $unsigned_case:expr }) => {

library/core/src/num/uint_macros.rs

@@ -491,7 +491,7 @@ macro_rules! uint_impl {
 // Per <https://github.com/rust-lang/rust/pull/124114#issuecomment-2066173305>,
 // LLVM is happy to re-form the intrinsic later if useful.
 
-if unlikely!(intrinsics::add_with_overflow(self, rhs).1){
+ifintrinsics::unlikely(intrinsics::add_with_overflow(self, rhs).1){
 None
 } else {
 // SAFETY: Just checked it doesn't overflow
@@ -593,7 +593,7 @@ macro_rules! uint_impl {
  #[inline]
 pubconstfn checked_add_signed(self, rhs: $SignedT) -> Option<Self> {
 let(a, b) = self.overflowing_add_signed(rhs);
-if unlikely!(b){None} else {Some(a)}
+ifintrinsics::unlikely(b){None} else {Some(a)}
 }
 
 /// Strict addition with a signed integer. Computes `self + rhs`,
@@ -845,7 +845,7 @@ macro_rules! uint_impl {
  #[inline]
 pubconstfn checked_mul(self, rhs:Self) -> Option<Self> {
 let(a, b) = self.overflowing_mul(rhs);
-if unlikely!(b){None} else {Some(a)}
+ifintrinsics::unlikely(b){None} else {Some(a)}
 }
 
 /// Strict integer multiplication. Computes `self * rhs`, panicking if
@@ -940,7 +940,7 @@ macro_rules! uint_impl {
  without modifying the original"]
  #[inline]
 pubconstfn checked_div(self, rhs:Self) -> Option<Self> {
-if unlikely!(rhs == 0){
+ifintrinsics::unlikely(rhs == 0){
 None
 } else {
 // SAFETY: div by zero has been checked above and unsigned types have no other
@@ -1001,7 +1001,7 @@ macro_rules! uint_impl {
  without modifying the original"]
  #[inline]
 pubconstfn checked_div_euclid(self, rhs:Self) -> Option<Self> {
-if unlikely!(rhs == 0){
+ifintrinsics::unlikely(rhs == 0){
 None
 } else {
 Some(self.div_euclid(rhs))
@@ -1061,7 +1061,7 @@ macro_rules! uint_impl {
  without modifying the original"]
  #[inline]
 pubconstfn checked_rem(self, rhs:Self) -> Option<Self> {
-if unlikely!(rhs == 0){
+ifintrinsics::unlikely(rhs == 0){
 None
 } else {
 // SAFETY: div by zero has been checked above and unsigned types have no other
@@ -1123,7 +1123,7 @@ macro_rules! uint_impl {
  without modifying the original"]
  #[inline]
 pubconstfn checked_rem_euclid(self, rhs:Self) -> Option<Self> {
-if unlikely!(rhs == 0){
+ifintrinsics::unlikely(rhs == 0){
 None
 } else {
 Some(self.rem_euclid(rhs))
@@ -1362,7 +1362,7 @@ macro_rules! uint_impl {
  #[inline]
 pubconstfn checked_neg(self) -> Option<Self> {
 let(a, b) = self.overflowing_neg();
-if unlikely!(b){None} else {Some(a)}
+ifintrinsics::unlikely(b){None} else {Some(a)}
 }
 
 /// Strict negation. Computes `-self`, panicking unless `self ==

library/core/tests/lib.rs

@@ -1,5 +1,4 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(const_likely))]
 #![cfg_attr(bootstrap, feature(strict_provenance))]
 #![cfg_attr(not(bootstrap), feature(strict_provenance_lints))]
 #![cfg_attr(target_has_atomic = "128", feature(integer_atomics))]