Auto merge of #161289 - JonathanBrouwer:rollup-WQrI9Qf, r=JonathanBrouwer

Rollup of 11 pull requests

Successful merges:

 - #161024 (resolving cyclic glob vis-max)
 - #161231 (passes: `rustc_scalable_vector` fields are not dead)
 - #161238 (remove scalar size mismatch interpreter error, make it an ICE instead)
 - #160345 (Resolver: add `checked` methods for `Cm(Ref)Cell`)
 - #161129 (Avoid ICE when recovering parenthesized type parameters)
 - #161235 (Compute job time in post-merge-report from the actual GitHub duration)
 - #161239 (Fix `#[repr(transparent)]` wrapper types not working with `Complex<T>`)
 - #161244 (Add regression test for indexing an unsized static without a body)
 - #161257 (Ignore target feature test when LLVM fails to compile minicore)
 - #161258 (perf: return early from in_external_macro for root contexts)
 - #161278 (Add regression test for normalization failure on erased closure in async block)

Author: bors

compiler/rustc_abi/src/layout/ty.rs

@@ -120,7 +120,7 @@ pub trait TyAbiInterface<'a, C>: Sized + std::fmt::Debug + std::fmt::Display {
     fn is_tuple(this: TyAndLayout<'a, Self>) -> bool;
     fn is_unit(this: TyAndLayout<'a, Self>) -> bool;
     fn is_transparent(this: TyAndLayout<'a, Self>) -> bool;
-    fn is_complex_number(this: TyAndLayout<'a, Self>, cx: &C) -> bool;
+    fn is_complex_number_lang_item(this: TyAndLayout<'a, Self>, cx: &C) -> bool;
     fn is_scalable_vector(this: TyAndLayout<'a, Self>) -> bool;
     /// See [`TyAndLayout::pass_indirectly_in_non_rustic_abis`] for details.
     fn is_pass_indirectly_in_non_rustic_abis_flag_set(this: TyAndLayout<'a, Self>) -> bool;
@@ -228,11 +228,13 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
         Ty::is_transparent(self)
     }
 
+    /// Returns `true` if this type needs to match the ABI of the C `_Complex` type. See
+    /// [`TyAndLayout::complex_number_primitive`] for details.
     pub fn is_complex_number<C>(self, cx: &C) -> bool
     where
         Ty: TyAbiInterface<'a, C> + Copy,
     {
-        Ty::is_complex_number(self.peel_transparent_wrappers(cx), cx)
+        self.complex_number_primitive(cx).is_some()
     }
 
     pub fn is_scalable_vector<C>(self) -> bool
@@ -299,23 +301,47 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
         found
     }
 
-    pub fn complex_float<C>(&self, cx: &C) -> Option<Float>
+    /// If this type should match the ABI of the C `_Complex` type, returns the primitive that is
+    /// used for its parts. This only returns `Some(T)` for `core::num::Complex<T>` where `T` is
+    /// either a float or an integer. `repr(transparent)` wrapper types are automatically handled.
+    pub fn complex_number_primitive<C>(&self, cx: &C) -> Option<Primitive>
     where
         Ty: TyAbiInterface<'a, C> + Copy,
     {
-        if !Ty::is_complex_number(*self, cx) {
+        let complex = self.peel_transparent_wrappers(cx);
+        if !Ty::is_complex_number_lang_item(complex, cx) {
             return None;
         }
 
-        let BackendRepr::ScalarPair { a, b, .. } = self.backend_repr else {
-            return None;
-        };
-
-        debug_assert_eq!(a, b);
+        let part = complex.field(cx, 0).peel_transparent_wrappers(cx);
+
+        if let BackendRepr::Scalar(scalar) = part.backend_repr {
+            // Only Complex<{ float }> and Complex<{ integer }> have special layout.
+            let primitive = scalar.primitive();
+            match primitive {
+                // Explicitly spell out all the float types so that any new ones have to be added to
+                // one of the match branches.
+                Primitive::Int(..)
+                | Primitive::Float(Float::F16 | Float::F32 | Float::F64 | Float::F128) => {
+                    Some(primitive)
+                }
+                Primitive::Pointer(..) => None,
+            }
+        } else {
+            None
+        }
+    }
 
-        match a.primitive() {
-            Primitive::Float(f) => Some(f),
-            _ => None,
+    /// Returns `Some` if this type has the ABI of the C `_Complex` type with float parts. See
+    /// [`TyAndLayout::complex_number_primitive`] for details.
+    pub fn complex_float<C>(&self, cx: &C) -> Option<Float>
+    where
+        Ty: TyAbiInterface<'a, C> + Copy,
+    {
+        if let Some(Primitive::Float(float)) = self.complex_number_primitive(cx) {
+            Some(float)
+        } else {
+            None
         }
     }
 

compiler/rustc_ast_lowering/src/lib.rs

@@ -411,6 +411,9 @@ enum ImplTraitContext {
     FeatureGated(ImplTraitPosition, Symbol),
     /// `impl Trait` is not accepted in this position.
     Disallowed(ImplTraitPosition),
+
+    /// An error has already been emitted for this type.
+    AlreadyErrored(ErrorGuaranteed),
 }
 
 /// Position in which `impl Trait` is disallowed.
@@ -1318,11 +1321,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             span: data.span,
                         }
                     } else {
-                        self.emit_bad_parenthesized_trait_in_assoc_ty(data);
+                        let guar = self.emit_bad_parenthesized_trait_in_assoc_ty(data);
                         self.lower_angle_bracketed_parameter_data(
                             &data.as_angle_bracketed_args(),
                             ParamMode::Explicit,
-                            itctx,
+                            ImplTraitContext::AlreadyErrored(guar),
                         )
                         .0
                     }
@@ -1391,7 +1394,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn emit_bad_parenthesized_trait_in_assoc_ty(&self, data: &ParenthesizedArgs) {
+    fn emit_bad_parenthesized_trait_in_assoc_ty(
+        &self,
+        data: &ParenthesizedArgs,
+    ) -> ErrorGuaranteed {
         // Suggest removing empty parentheses: "Trait()" -> "Trait"
         let sub = if data.inputs.is_empty() {
             let parentheses_span =
@@ -1412,7 +1418,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 data.inputs.last().unwrap().span.shrink_to_hi().to(data.inputs_span.shrink_to_hi());
             AssocTyParenthesesSub::NotEmpty { open_param, close_param }
         };
-        self.dcx().emit_err(AssocTyParentheses { span: data.span, sub });
+        self.dcx().emit_err(AssocTyParentheses { span: data.span, sub })
     }
 
     #[instrument(level = "debug", skip(self))]
@@ -1735,6 +1741,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         });
                         hir::TyKind::Err(guar)
                     }
+                    ImplTraitContext::AlreadyErrored(guar) => {
+                        // `GenericArgs::Parenthesized` stores its inputs as `Param`s, so the def
+                        // collector visits `impl Trait` in a universal context and creates a
+                        // `DefKind::TyParam`. During recovery we reinterpret these arguments as
+                        // angle-bracketed, where lowering may otherwise expect an opaque type.
+                        // The parenthesized syntax has already been rejected, so avoid lowering
+                        // this `impl Trait` with the inconsistent `DefKind`.
+                        hir::TyKind::Err(guar)
+                    }
                 }
             }
             TyKind::Pat(ty, pat) => {

compiler/rustc_ast_lowering/src/path.rs

@@ -338,12 +338,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         } else {
                             None
                         };
-                        self.dcx().emit_err(GenericTypeWithParentheses { span: data.span, sub });
+                        let guar = self
+                            .dcx()
+                            .emit_err(GenericTypeWithParentheses { span: data.span, sub });
                         (
                             self.lower_angle_bracketed_parameter_data(
                                 &data.as_angle_bracketed_args(),
                                 param_mode,
-                                itctx,
+                                ImplTraitContext::AlreadyErrored(guar),
                             )
                             .0,
                             false,

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -311,7 +311,7 @@ pub(super) fn op_to_const<'tcx>(
                     imm.layout.ty,
                 );
                 let msg = "`op_to_const` on an immediate scalar pair must only be used on slice references to the beginning of an actual allocation";
-                let ptr = a.to_pointer(ecx).expect(msg);
+                let ptr = a.to_pointer(ecx);
                 let (prov, offset) =
                     ptr.into_pointer_or_addr().expect(msg).prov_and_relative_offset();
                 let alloc_id = prov.alloc_id();

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -1019,12 +1019,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
         // (Do nothing on `None` provenance, that cannot store immutability anyway.)
         if let ty::Ref(_, ty, mutbl) = val.layout.ty.kind()
             && *mutbl == Mutability::Not
-            && val
-                .to_scalar_and_meta()
-                .0
-                .to_pointer(ecx)?
-                .provenance
-                .is_some_and(|p| !p.immutable())
+            && val.to_scalar_and_meta().0.to_pointer(ecx).provenance.is_some_and(|p| !p.immutable())
         {
             // That next check is expensive, that's why we have all the guards above.
             let is_immutable = ty.is_freeze(*ecx.tcx, ecx.typing_env());

compiler/rustc_const_eval/src/interpret/call.rs

@@ -848,7 +848,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 assert!(receiver_place.layout.is_unsized());
 
                 // Get the required information from the vtable.
-                let vptr = receiver_place.meta().unwrap_meta().to_pointer(self)?;
+                let vptr = receiver_place.meta().unwrap_meta().to_pointer(self);
                 let dyn_ty = self.get_ptr_vtable_ty(vptr, Some(receiver_trait))?;
                 let adjusted_recv = receiver_place.ptr();
 

compiler/rustc_const_eval/src/interpret/cast.rs

@@ -293,7 +293,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         assert!(cast_to.ty.is_integral());
 
         let scalar = src.to_scalar();
-        let ptr = scalar.to_pointer(self)?;
+        let ptr = scalar.to_pointer(self);
         match ptr.into_pointer_or_addr() {
             Ok(ptr) => M::expose_provenance(self, ptr.provenance)?,
             Err(_) => {} // Do nothing, exposing an invalid pointer (`None` provenance) is a NOP.
@@ -464,8 +464,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 }
                 // Take apart the old pointer, and find the dynamic type.
                 let (old_data, old_vptr) = val.to_scalar_pair();
-                let old_data = old_data.to_pointer(self)?;
-                let old_vptr = old_vptr.to_pointer(self)?;
+                let old_data = old_data.to_pointer(self);
+                let old_vptr = old_vptr.to_pointer(self);
                 let ty = self.get_ptr_vtable_ty(old_vptr, Some(data_a))?;
 
                 // Sanity-check that `supertrait_vtable_slot` in this type's vtable indeed produces

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -488,7 +488,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 interp_ok(Some((full_size, full_align)))
             }
             ty::Dynamic(expected_trait, _) => {
-                let vtable = metadata.unwrap_meta().to_pointer(self)?;
+                let vtable = metadata.unwrap_meta().to_pointer(self);
                 // Read size and align from vtable (already checks size).
                 interp_ok(Some(self.get_vtable_size_and_align(vtable, Some(expected_trait))?))
             }

compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs

@@ -260,7 +260,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                         }
                         Op::SaturatingOp(mir_op) => self.saturating_arith(mir_op, &left, &right)?,
                         Op::WrappingOffset => {
-                            let ptr = left.to_scalar().to_pointer(self)?;
+                            let ptr = left.to_scalar().to_pointer(self);
                             let offset_count = right.to_scalar().to_target_isize(self)?;
                             let pointee_ty = left.layout.ty.builtin_deref(true).unwrap();
 

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -1641,7 +1641,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             Ok(int) => interp_ok(int.is_null()),
             Err(_) => {
                 // We can't cast this pointer to an integer. Can only happen during CTFE.
-                let ptr = scalar.to_pointer(self)?;
+                let ptr = scalar.to_pointer(self);
                 match self.ptr_try_get_alloc_id(ptr, 0) {
                     Ok((alloc_id, offset, _)) => {
                         let info = self.get_alloc_info(alloc_id);