Auto merge of #149941 - jhpratt:rollup-9p1xc2t, r=jhpratt

Rollup of 10 pull requests

Successful merges:

 - rust-lang/rust#145278 (Update `rustc_codegen_gcc` rotate operation document)
 - rust-lang/rust#148837 (Use `let...else` instead of `match foo { ... _ => return };` and `if let ... else return`)
 - rust-lang/rust#149177 (Add proper suggestion for associated function with unknown field)
 - rust-lang/rust#149843 (Inherit attributes in delegation)
 - rust-lang/rust#149860 (Fix: Prevent macro-expanded extern crates from shadowing extern arguments)
 - rust-lang/rust#149874 (Weak for Arc pointer is marked as DynSend/DynSync)
 - rust-lang/rust#149903 (Remove unused code in `cfg_old`)
 - rust-lang/rust#149911 (bootstrap: Don't pass an unused `--color` to compiletest)
 - rust-lang/rust#149916 (Add a sanity check in case of any duplicate nodes)
 - rust-lang/rust#149924 (`declare_lint_pass` for `INLINE_ALWAYS_MISMATCHING_TARGET_FEATURES`)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

src/intrinsic/mod.rs

@@ -460,9 +460,10 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                         }
                         sym::bitreverse => self.bit_reverse(width, args[0].immediate()),
                         sym::rotate_left | sym::rotate_right => {
-                            // TODO(antoyo): implement using algorithm from:
+                            // Using optimized branchless algorithm from:
                             // https://blog.regehr.org/archives/1063
-                            // for other platforms.
+                            // This implementation uses the pattern (x<<n) | (x>>(-n&(width-1)))
+                            // which generates efficient code for other platforms.
                             let is_left = name == sym::rotate_left;
                             let val = args[0].immediate();
                             let raw_shift = args[1].immediate();

src/intrinsic/simd.rs

@@ -774,24 +774,23 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
                 return Err(());
             }};
         }
-        let (elem_ty_str, elem_ty, cast_type) = if let ty::Float(ref f) = *in_elem.kind() {
-            let elem_ty = bx.cx.type_float_from_ty(*f);
-            match f.bit_width() {
-                16 => ("", elem_ty, Some(bx.cx.double_type)),
-                32 => ("f", elem_ty, None),
-                64 => ("", elem_ty, None),
-                _ => {
-                    return_error!(InvalidMonomorphization::FloatingPointVector {
-                        span,
-                        name,
-                        f_ty: *f,
-                        in_ty
-                    });
-                }
-            }
-        } else {
+        let ty::Float(ref f) = *in_elem.kind() else {
             return_error!(InvalidMonomorphization::FloatingPointType { span, name, in_ty });
         };
+        let elem_ty = bx.cx.type_float_from_ty(*f);
+        let (elem_ty_str, elem_ty, cast_type) = match f.bit_width() {
+            16 => ("", elem_ty, Some(bx.cx.double_type)),
+            32 => ("f", elem_ty, None),
+            64 => ("", elem_ty, None),
+            _ => {
+                return_error!(InvalidMonomorphization::FloatingPointVector {
+                    span,
+                    name,
+                    f_ty: *f,
+                    in_ty
+                });
+            }
+        };
 
         let vec_ty = bx.cx.type_vector(elem_ty, in_len);