Auto merge of #164708 - JonathanBrouwer:rollup-Td0LIV7, r=JonathanBrouwer

Rollup of 6 pull requests

Successful merges:

 - #164383 (handle higher-ranked preds in imperfect derives diagnostic)
 - #164620 (Wrap expected_ty for cfi-{diag,recover} in with_no_trimmed_paths)
 - #164684 (Remove redundant `PartialOrd` chaining methods)
 - #158076 (Offload safe mutable args with `Region` and `PartitioningStrategy`)
 - #164680 (Add regression test for async fn declared with #[eii])
 - #164696 (Add `#[default]` for `newtype_index!`)

Author: bors

compiler/rustc_codegen_llvm/src/builder.rs

@@ -2081,18 +2081,20 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
                 );
 
                 let mut expected_ty = String::from("fn(");
-                for (i, arg) in fn_abi.args.iter().enumerate() {
-                    if i > 0 {
-                        expected_ty.push_str(", ");
+                ty::print::with_no_trimmed_paths!({
+                    for (i, arg) in fn_abi.args.iter().enumerate() {
+                        if i > 0 {
+                            expected_ty.push_str(", ");
+                        }
+                        use std::fmt::Write;
+                        write!(&mut expected_ty, "{}", arg.layout.ty).unwrap();
                     }
-                    use std::fmt::Write;
-                    write!(&mut expected_ty, "{}", arg.layout.ty).unwrap();
-                }
-                expected_ty.push(')');
-                if !fn_abi.ret.layout.ty.is_unit() {
-                    use std::fmt::Write;
-                    write!(&mut expected_ty, " -> {}", fn_abi.ret.layout.ty).unwrap();
-                }
+                    expected_ty.push(')');
+                    if !fn_abi.ret.layout.ty.is_unit() {
+                        use std::fmt::Write;
+                        write!(&mut expected_ty, " -> {}", fn_abi.ret.layout.ty).unwrap();
+                    }
+                });
 
                 // 4 for cfi-icall (indirect call)
                 let check_kind = 4;

compiler/rustc_hir_typeck/src/intrinsicck.rs

@@ -1,11 +1,13 @@
 use hir::HirId;
 use rustc_abi::Primitive::Pointer;
 use rustc_abi::VariantIdx;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::codes::*;
 use rustc_errors::struct_span_code_err;
 use rustc_hir as hir;
 use rustc_index::Idx;
 use rustc_middle::ty::layout::{LayoutError, SizeSkeleton};
+use rustc_middle::ty::offload_meta::is_region_ty;
 use rustc_middle::ty::{self, Ty, TyCtxt, Unnormalized};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{ErrorGuaranteed, bug};
@@ -134,6 +136,28 @@ fn check_transmute<'tcx>(
     }
 }
 
+fn contains_nested_offload_region<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
+    let mut visited = FxHashSet::default();
+    let mut stack = vec![ty];
+    let mut is_root = true;
+
+    while let Some(ty) = stack.pop() {
+        if !is_root && is_region_ty(tcx, ty) {
+            return true;
+        }
+        is_root = false;
+
+        if let ty::Adt(def, args) = *ty.kind()
+            && visited.insert(def.did())
+        {
+            stack.extend(def.all_fields().map(|field| field.ty(tcx, args).skip_norm_wip()));
+        }
+        stack.extend(ty.walk().skip(1).filter_map(|arg| arg.as_type()));
+    }
+
+    false
+}
+
 fn check_offload<'tcx>(
     tcx: TyCtxt<'tcx>,
     typing_env: ty::TypingEnv<'tcx>,
@@ -205,7 +229,23 @@ fn check_offload<'tcx>(
     {
         let norm_input_ty = normalize(input_ty);
         let norm_arg_ty = normalize(arg_ty);
-        if norm_input_ty != norm_arg_ty {
+
+        if contains_nested_offload_region(tcx, norm_input_ty)
+            || contains_nested_offload_region(tcx, norm_arg_ty)
+        {
+            let guar = tcx
+                .sess
+                .dcx()
+                .struct_span_err(
+                    span,
+                    format!(
+                        "offload kernel argument {i} contains a `Region` nested inside another \
+                        type. Pass the `Region` by value so it can be mapped like a slice"
+                    ),
+                )
+                .emit_err();
+            result = Err(guar);
+        } else if norm_input_ty != norm_arg_ty {
             let guar = tcx
                 .sess
                 .dcx()

compiler/rustc_index_macros/src/lib.rs

@@ -26,6 +26,7 @@ mod newtype;
 ///
 /// Accepted attributes for customization:
 /// - `#[stable_hash]`: derives `StableHash`.
+/// - `#[default]`: derives `std::default::Default` returning `Self::ZERO`.
 /// - `#[encodable]`: derives `Encodable`/`Decodable`.
 /// - `#[orderable]`: derives `PartialOrd`/`Ord`, plus step-related methods.
 /// - `#[debug_format = "Foo({})"]`: derives `Debug` with particular output.

compiler/rustc_index_macros/src/newtype.rs

@@ -24,6 +24,7 @@ impl Parse for Newtype {
         let mut encodable = false;
         let mut ord = false;
         let mut stable_hash = false;
+        let mut default = false;
         let mut gate_rustc_only = quote! {};
         let mut gate_rustc_only_cfg = quote! { all() };
 
@@ -46,6 +47,10 @@ impl Parse for Newtype {
                     stable_hash = true;
                     false
                 }
+                "default" => {
+                    default = true;
+                    false
+                }
                 "max" => {
                     let Meta::NameValue(MetaNameValue { value: Expr::Lit(lit), .. }) = &attr.meta
                     else {
@@ -185,6 +190,19 @@ impl Parse for Newtype {
             quote! {}
         };
 
+        let default_impl = if default {
+            quote! {
+                impl std::default::Default for #name {
+                    #[inline]
+                    fn default() -> Self {
+                        Self::ZERO
+                    }
+                }
+            }
+        } else {
+            quote! {}
+        };
+
         let debug_impl = quote! {
             impl ::std::fmt::Debug for #name {
                 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
@@ -323,6 +341,8 @@ impl Parse for Newtype {
 
             #stable_hash_impl
 
+            #default_impl
+
             impl From<#name> for u32 {
                 #[inline]
                 fn from(v: #name) -> u32 {

compiler/rustc_middle/src/ty/offload_meta.rs

@@ -1,5 +1,6 @@
 use bitflags::bitflags;
 use rustc_abi::{BackendRepr, TyAbiInterface};
+use rustc_span::sym;
 use rustc_target::callconv::ArgAbi;
 
 use crate::ty::{self, PseudoCanonicalInput, Ty, TyCtxt, TypingEnv};
@@ -75,6 +76,25 @@ impl OffloadMetadata {
     where
         Ty<'tcx>: TyAbiInterface<'tcx, C>,
     {
+        if let Some(elem_ty) = region_element_ty(tcx, ty) {
+            let ptr = OffloadMetadata::from_ty(tcx, Ty::new_slice(tcx, elem_ty));
+            let len = OffloadMetadata::from_ty(tcx, tcx.types.usize);
+            // `Region` is a `{ ptr, len }` pair, but field order is not guaranteed.
+            return arg_abi
+                .layout
+                .fields
+                .index_by_increasing_offset()
+                .filter(|&i| arg_abi.layout.field(cx, i).size.bytes() != 0)
+                .map(|i| {
+                    if arg_abi.layout.field(cx, i).ty == tcx.types.usize {
+                        (len, tcx.types.usize)
+                    } else {
+                        (ptr, Ty::new_mut_ptr(tcx, elem_ty))
+                    }
+                })
+                .collect();
+        }
+
         match arg_abi.layout.backend_repr {
             BackendRepr::ScalarPair { a: _, b: _, b_offset: _ } => (0..2)
                 .map(|i| {
@@ -87,6 +107,22 @@ impl OffloadMetadata {
     }
 }
 
+pub fn is_region_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
+    matches!(
+        ty.kind(),
+        ty::Adt(def, _) if Some(def.did()) == tcx.get_diagnostic_item(sym::offload_region)
+    )
+}
+
+fn region_element_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
+    if is_region_ty(tcx, ty) {
+        let ty::Adt(_, args) = ty.kind() else { unreachable!() };
+        Some(args.type_at(1))
+    } else {
+        None
+    }
+}
+
 // FIXME(Sa4dUs): implement a solid logic to determine the payload size
 fn get_payload_size<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> OffloadSize {
     match ty.kind() {

compiler/rustc_span/src/hygiene.rs

@@ -134,15 +134,10 @@ impl fmt::Debug for ExpnId {
 rustc_index::newtype_index! {
     /// A unique ID associated with a macro invocation and expansion.
     #[debug_format = "expn{}"]
+    #[default]
     pub struct LocalExpnId {}
 }
 
-impl Default for LocalExpnId {
-    fn default() -> LocalExpnId {
-        LocalExpnId::ROOT
-    }
-}
-
 // To ensure correctness of incremental compilation,
 // `LocalExpnId` must not implement `Ord` or `PartialOrd`.
 // See https://github.com/rust-lang/rust/issues/90317.

compiler/rustc_span/src/symbol.rs

@@ -1515,6 +1515,7 @@ symbols! {
         offload,
         offload_get_num_devices,
         offload_kernel,
+        offload_region,
         offset,
         offset_of,
         offset_of_enum,

compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs

@@ -6788,7 +6788,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     tcx,
                     ObligationCause::dummy(),
                     param_env,
-                    ty::TraitRef::new(tcx, trait_def_id, trait_args),
+                    parent_trait_pred.rebind(ty::TraitRef::new(tcx, trait_def_id, trait_args)),
                 );
                 self.predicate_may_hold(&obligation)
             })

compiler/rustc_type_ir/src/lib.rs

@@ -375,6 +375,7 @@ rustc_index::newtype_index! {
     /// type -- an idealized representative of "types in general" that we
     /// use for checking generic functions.
     #[stable_hash]
+    #[default]
     #[encodable]
     #[orderable]
     #[debug_format = "U{}"]
@@ -422,12 +423,6 @@ impl UniverseIndex {
     }
 }
 
-impl Default for UniverseIndex {
-    fn default() -> Self {
-        Self::ROOT
-    }
-}
-
 rustc_index::newtype_index! {
     #[stable_hash]
     #[encodable]

library/core/src/array/mod.rs

@@ -430,20 +430,12 @@ const impl<T: [const] PartialOrd, const N: usize> PartialOrd for [T; N] {
     }
 
     #[inline]
-    fn __chaining_lt(&self, other: &[T; N]) -> ControlFlow<bool> {
-        <[T] as PartialOrd>::__chaining_lt(self, other)
+    fn __chaining_less(&self, other: &[T; N]) -> ControlFlow<bool> {
+        <[T] as PartialOrd>::__chaining_less(self, other)
     }
     #[inline]
-    fn __chaining_le(&self, other: &[T; N]) -> ControlFlow<bool> {
-        <[T] as PartialOrd>::__chaining_le(self, other)
-    }
-    #[inline]
-    fn __chaining_ge(&self, other: &[T; N]) -> ControlFlow<bool> {
-        <[T] as PartialOrd>::__chaining_ge(self, other)
-    }
-    #[inline]
-    fn __chaining_gt(&self, other: &[T; N]) -> ControlFlow<bool> {
-        <[T] as PartialOrd>::__chaining_gt(self, other)
+    fn __chaining_greater(&self, other: &[T; N]) -> ControlFlow<bool> {
+        <[T] as PartialOrd>::__chaining_greater(self, other)
     }
 }