core: Rename funnel shift rhs parameter to right

`rhs` is confusing since for the `Shl` and `Shr` traits, that is the
name used for the value to shift by (i.e. `self >> rhs`).

Author: tgross35

library/core/src/intrinsics/fallback.rs

@@ -151,11 +151,11 @@ impl_disjoint_bitor! {
 pub const trait FunnelShift: Copy + 'static {
     /// See [`super::unchecked_funnel_shl`]; we just need the trait indirection to handle
     /// different types since calling intrinsics with generics doesn't work.
-    unsafe fn unchecked_funnel_shl(self, rhs: Self, shift: u32) -> Self;
+    unsafe fn unchecked_funnel_shl(self, right: Self, shift: u32) -> Self;
 
     /// See [`super::unchecked_funnel_shr`]; we just need the trait indirection to handle
     /// different types since calling intrinsics with generics doesn't work.
-    unsafe fn unchecked_funnel_shr(self, rhs: Self, shift: u32) -> Self;
+    unsafe fn unchecked_funnel_shr(self, right: Self, shift: u32) -> Self;
 }
 
 macro_rules! impl_funnel_shifts {
@@ -164,7 +164,7 @@ macro_rules! impl_funnel_shifts {
         impl const FunnelShift for $type {
             #[cfg_attr(miri, track_caller)]
             #[inline]
-            unsafe fn unchecked_funnel_shl(self, rhs: Self, shift: u32) -> Self {
+            unsafe fn unchecked_funnel_shl(self, right: Self, shift: u32) -> Self {
                 // This implementation is also used by Miri so we have to check the precondition.
                 // SAFETY: this is guaranteed by the caller
                 unsafe { super::assume(shift < $type::BITS) };
@@ -181,20 +181,20 @@ macro_rules! impl_funnel_shifts {
                     unsafe {
                         super::disjoint_bitor(
                             super::unchecked_shl(self, shift),
-                            super::unchecked_shr(rhs, $type::BITS - shift),
+                            super::unchecked_shr(right, $type::BITS - shift),
                         )
                     }
                 }
             }
 
             #[cfg_attr(miri, track_caller)]
             #[inline]
-            unsafe fn unchecked_funnel_shr(self, rhs: Self, shift: u32) -> Self {
+            unsafe fn unchecked_funnel_shr(self, right: Self, shift: u32) -> Self {
                 // This implementation is also used by Miri so we have to check the precondition.
                 // SAFETY: this is guaranteed by the caller
                 unsafe { super::assume(shift < $type::BITS) };
                 if shift == 0 {
-                    rhs
+                    right
                 } else {
                     // SAFETY:
                     //  - `shift < T::BITS`, which satisfies `unchecked_shr`
@@ -206,7 +206,7 @@ macro_rules! impl_funnel_shifts {
                     unsafe {
                         super::disjoint_bitor(
                             super::unchecked_shl(self, $type::BITS - shift),
-                            super::unchecked_shr(rhs, shift),
+                            super::unchecked_shr(right, shift),
                         )
                     }
                 }

library/core/src/num/uint_macros.rs

@@ -415,9 +415,9 @@ macro_rules! uint_impl {
             return intrinsics::rotate_right(self, n);
         }
 
-        /// Performs a left funnel shift (concatenates `self` with `rhs`, with `self`
-        /// making up the most significant half, then shifts the combined value left
-        /// by `n`, and most significant half is extracted to produce the result).
+        /// Performs a left funnel shift (concatenates `self` with `low`, with `self`
+        /// making up the high half, then shifts the combined value left
+        /// by `n`, and the high half is extracted to produce the result).
         ///
         /// Please note this isn't the same operation as the `<<` shifting operator or
         /// [`rotate_left`](Self::rotate_left), although `a.funnel_shl(a, n)` is *equivalent*
@@ -444,15 +444,15 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
-        pub const fn funnel_shl(self, rhs: Self, n: u32) -> Self {
+        pub const fn funnel_shl(self, right: Self, n: u32) -> Self {
             assert!(n < Self::BITS, "attempt to funnel shift left with overflow");
             // SAFETY: just checked that `shift` is in-range
-            unsafe { intrinsics::unchecked_funnel_shl(self, rhs, n) }
+            unsafe { intrinsics::unchecked_funnel_shl(self, right, n) }
         }
 
-        /// Performs a right funnel shift (concatenates `self` and `rhs`, with `self`
-        /// making up the most significant half, then shifts the combined value right
-        /// by `n`, and least significant half is extracted to produce the result).
+        /// Performs a right funnel shift (concatenates `self` and `right`, with `self`
+        /// making up the high half, then shifts the combined value right
+        /// by `n`, and the low half is extracted to produce the result).
         ///
         /// Please note this isn't the same operation as the `>>` shifting operator or
         /// [`rotate_right`](Self::rotate_right), although `a.funnel_shr(a, n)` is *equivalent*
@@ -479,10 +479,10 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
-        pub const fn funnel_shr(self, rhs: Self, n: u32) -> Self {
+        pub const fn funnel_shr(self, right: Self, n: u32) -> Self {
             assert!(n < Self::BITS, "attempt to funnel shift right with overflow");
             // SAFETY: just checked that `shift` is in-range
-            unsafe { intrinsics::unchecked_funnel_shr(self, rhs, n) }
+            unsafe { intrinsics::unchecked_funnel_shr(self, right, n) }
         }
 
         /// Performs a carry-less multiplication, returning the lower bits.