Auto merge of #157174 - JonathanBrouwer:rollup-XgLtev4, r=JonathanBrouwer

Rollup of 8 pull requests

Successful merges:

 - #157006 (net tests: let the OS pick the port numbers)
 - #157126 (Avoid redundant note when a #[derive] is already suggested)
 - #151690 (std: Refactor `env::var` function)
 - #155826 (std::process: uefi: avoid panicking in Stdio From impls.)
 - #156109 (Migrate libraries from ptr::slice_from_raw_parts to .cast_slice)
 - #156642 (`offload_kernel` macro expansion)
 - #156823 (Add regression test)
 - #157162 (elaborate_drop: Avoid as_mut.unwrap dance, empty vectors are cheap.)

Failed merges:

 - #157173 (rustc-dev-guide subtree update)

Author: bors

compiler/rustc_builtin_macros/src/lib.rs

@@ -42,6 +42,7 @@ mod format_foreign;
 mod global_allocator;
 mod iter;
 mod log_syntax;
+mod offload;
 mod pattern_type;
 mod source_util;
 mod test;
@@ -116,6 +117,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         eii_declaration: eii::eii_declaration,
         eii_shared_macro: eii::eii_shared_macro,
         global_allocator: global_allocator::expand,
+        offload_kernel: offload::expand_kernel,
         test: test::expand_test,
         test_case: test::expand_test_case,
         unsafe_eii: eii::unsafe_eii,

compiler/rustc_builtin_macros/src/offload.rs

@@ -0,0 +1,205 @@
+use rustc_ast::token::{Delimiter, Token, TokenKind};
+use rustc_ast::tokenstream::{DelimSpan, Spacing, TokenStream, TokenTree};
+use rustc_ast::{AttrItem, ast};
+use rustc_expand::base::{Annotatable, ExtCtxt};
+use rustc_session::config::Offload;
+use rustc_span::{Ident, Span, sym};
+use thin_vec::thin_vec;
+
+use crate::errors;
+
+fn compile_for_device(ecx: &mut ExtCtxt<'_>) -> bool {
+    ecx.sess.opts.unstable_opts.offload.contains(&Offload::Device)
+}
+
+fn outer_normal_attr(
+    kind: &Box<rustc_ast::NormalAttr>,
+    id: rustc_ast::AttrId,
+    span: Span,
+) -> rustc_ast::Attribute {
+    let style = rustc_ast::AttrStyle::Outer;
+    let kind = rustc_ast::AttrKind::Normal(kind.clone());
+    rustc_ast::Attribute { kind, id, style, span }
+}
+
+fn extract_fn(
+    item: &Annotatable,
+) -> Option<(ast::Visibility, ast::FnSig, Ident, ast::Generics, Option<Box<ast::Block>>)> {
+    match item {
+        Annotatable::Item(iitem) => match &iitem.kind {
+            ast::ItemKind::Fn(ast::Fn { sig, ident, generics, body, .. }) => {
+                Some((iitem.vis.clone(), sig.clone(), *ident, generics.clone(), body.clone()))
+            }
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
+/// The `offload_kernel` macro expands the function into two separate definitions:
+/// one on the host to handle the call, and one on the device for executing the kernel.
+///
+/// ```
+/// #[offload_kernel]
+/// fn foo(a: &[f32], b: &[f32], c: *mut f32) {
+///     *c = a[0] + b[0];
+/// }
+/// ```
+///
+/// This expands to the host-side function:
+///
+/// ```
+/// #[unsafe(no_mangle)]
+/// #[inline(never)]
+/// fn foo(_: &[f32], _: &[f32], _: *mut f32) {
+///     ::core::panicking::panic("not implemented")
+/// }
+/// ```
+///
+/// And the device-side kernel:
+///
+/// ```
+/// #[rustc_offload_kernel]
+/// #[unsafe(no_mangle)]
+/// unsafe extern "gpu-kernel" fn foo(a: &[f32], b: &[f32], c: *mut f32) {
+///     *c = a[0] + b[0];
+/// }
+/// ```
+pub(crate) fn expand_kernel(
+    ecx: &mut ExtCtxt<'_>,
+    expand_span: Span,
+    _meta_item: &ast::MetaItem,
+    item: Annotatable,
+) -> Vec<Annotatable> {
+    let dcx = ecx.sess.dcx();
+
+    let Some((vis, sig, ident, generics, body)) = extract_fn(&item) else {
+        dcx.emit_err(errors::AutoDiffInvalidApplication { span: item.span() });
+        return vec![item];
+    };
+
+    let span = ecx.with_def_site_ctxt(expand_span);
+
+    // device function
+    let mut device_fn = Box::new(ast::Fn {
+        defaultness: ast::Defaultness::Implicit,
+        sig: sig.clone(),
+        ident,
+        generics: generics.clone(),
+        contract: None,
+        body,
+        define_opaque: None,
+        eii_impls: Default::default(),
+    });
+
+    let extern_gpu_kernel = ast::Extern::from_abi(
+        Some(ast::StrLit {
+            symbol: sym::gpu_kernel,
+            suffix: None,
+            symbol_unescaped: sym::gpu_kernel,
+            style: ast::StrStyle::Cooked,
+            span,
+        }),
+        span,
+    );
+    device_fn.sig.header.ext = extern_gpu_kernel;
+    device_fn.sig.header.safety = ast::Safety::Unsafe(span);
+
+    // rustc_offload_kernel attr
+    let rustc_offload_kernel_attr =
+        Box::new(ast::NormalAttr::from_ident(Ident::with_dummy_span(sym::rustc_offload_kernel)));
+    let rustc_offload_kernel = outer_normal_attr(
+        &rustc_offload_kernel_attr,
+        ecx.sess.psess.attr_id_generator.mk_attr_id(),
+        span,
+    );
+
+    // unsafe(no_mangle) attr
+    let unsafe_item = AttrItem {
+        unsafety: ast::Safety::Unsafe(span),
+        path: ast::Path::from_ident(Ident::new(sym::no_mangle, span)),
+        args: ast::AttrItemKind::Unparsed(ast::AttrArgs::Empty),
+        tokens: None,
+    };
+
+    let no_mangle_attr = Box::new(ast::NormalAttr { item: unsafe_item, tokens: None });
+    let new_id = ecx.sess.psess.attr_id_generator.mk_attr_id();
+    let unsafe_no_mangle = outer_normal_attr(&no_mangle_attr, new_id, span);
+
+    let device_item = {
+        let mut item = ecx.item(
+            span,
+            thin_vec![rustc_offload_kernel, unsafe_no_mangle],
+            ast::ItemKind::Fn(device_fn),
+        );
+        item.vis = vis.clone();
+        Annotatable::Item(item)
+    };
+
+    // unimplemented! body
+    let macro_expr = ecx.expr_macro_call(
+        span,
+        ecx.macro_call(
+            span,
+            ecx.path_global(
+                span,
+                [sym::std, sym::unimplemented].map(|s| Ident::new(s, span)).to_vec(),
+            ),
+            Delimiter::Parenthesis,
+            TokenStream::default(),
+        ),
+    );
+    let stmt = ecx.stmt_expr(macro_expr);
+    let body = ecx.block(span, thin_vec![stmt]);
+
+    // host function
+    let mut host_fn = Box::new(ast::Fn {
+        defaultness: ast::Defaultness::Implicit,
+        sig: sig.clone(),
+        ident,
+        generics: generics.clone(),
+        contract: None,
+        body: Some(body),
+        define_opaque: None,
+        eii_impls: Default::default(),
+    });
+
+    for param in host_fn.sig.decl.inputs.iter_mut() {
+        param.pat = Box::new(ecx.pat_wild(param.pat.span));
+    }
+
+    // inline(never) attr
+    let ts: Vec<TokenTree> = vec![TokenTree::Token(
+        Token::new(TokenKind::Ident(sym::never, false.into()), span),
+        Spacing::Joint,
+    )];
+
+    let never_arg = ast::DelimArgs {
+        dspan: DelimSpan::from_single(span),
+        delim: Delimiter::Parenthesis,
+        tokens: TokenStream::from_iter(ts),
+    };
+
+    let inline_item = ast::AttrItem {
+        unsafety: ast::Safety::Default,
+        path: ast::Path::from_ident(Ident::with_dummy_span(sym::inline)),
+        args: rustc_ast::ast::AttrItemKind::Unparsed(ast::AttrArgs::Delimited(never_arg)),
+        tokens: None,
+    };
+    let inline_never_attr = Box::new(ast::NormalAttr { item: inline_item, tokens: None });
+
+    let new_id = ecx.sess.psess.attr_id_generator.mk_attr_id();
+    let inline_never = outer_normal_attr(&inline_never_attr, new_id, span);
+
+    let new_id = ecx.sess.psess.attr_id_generator.mk_attr_id();
+    let unsafe_no_mangle = outer_normal_attr(&no_mangle_attr, new_id, span);
+
+    let host_item = {
+        let mut item =
+            ecx.item(span, thin_vec![unsafe_no_mangle, inline_never], ast::ItemKind::Fn(host_fn));
+        item.vis = vis.clone();
+        Annotatable::Item(item)
+    };
+
+    if compile_for_device(ecx) { vec![device_item] } else { vec![host_item] }
+}

compiler/rustc_mir_transform/src/elaborate_drop.rs

@@ -842,9 +842,9 @@ where
         let mut values = Vec::with_capacity(adt.variants().len());
         let mut normal_blocks = Vec::with_capacity(adt.variants().len());
         let mut unwind_blocks =
-            if unwind.is_cleanup() { None } else { Some(Vec::with_capacity(adt.variants().len())) };
+            Vec::with_capacity(if unwind.is_cleanup() { 0 } else { adt.variants().len() });
         let mut dropline_blocks =
-            if dropline.is_none() { None } else { Some(Vec::with_capacity(adt.variants().len())) };
+            Vec::with_capacity(if dropline.is_none() { 0 } else { adt.variants().len() });
 
         let mut have_otherwise_with_drop_glue = false;
         let mut have_otherwise = false;
@@ -880,7 +880,6 @@ where
                     // I want to minimize the divergence between MSVC
                     // and non-MSVC.
 
-                    let unwind_blocks = unwind_blocks.as_mut().unwrap();
                     let unwind_ladder = vec![Unwind::InCleanup; fields.len() + 1];
                     let dropline_ladder: Vec<Option<BasicBlock>> = vec![None; fields.len() + 1];
                     let halfladder =
@@ -890,7 +889,7 @@ where
                 let (normal, _, drop_bb) = self.drop_ladder(fields, succ, unwind, dropline);
                 normal_blocks.push(normal);
                 if dropline.is_some() {
-                    dropline_blocks.as_mut().unwrap().push(drop_bb.unwrap());
+                    dropline_blocks.push(drop_bb.unwrap());
                 }
             } else {
                 have_otherwise = true;
@@ -911,28 +910,22 @@ where
         } else if !have_otherwise_with_drop_glue {
             normal_blocks.push(self.goto_block(succ, unwind));
             if let Unwind::To(unwind) = unwind {
-                unwind_blocks.as_mut().unwrap().push(self.goto_block(unwind, Unwind::InCleanup));
+                unwind_blocks.push(self.goto_block(unwind, Unwind::InCleanup));
             }
         } else {
             normal_blocks.push(self.drop_block(succ, unwind));
             if let Unwind::To(unwind) = unwind {
-                unwind_blocks.as_mut().unwrap().push(self.drop_block(unwind, Unwind::InCleanup));
+                unwind_blocks.push(self.drop_block(unwind, Unwind::InCleanup));
             }
         }
 
         (
             self.adt_switch_block(adt, normal_blocks, &values, succ, unwind),
             unwind.map(|unwind| {
-                self.adt_switch_block(
-                    adt,
-                    unwind_blocks.unwrap(),
-                    &values,
-                    unwind,
-                    Unwind::InCleanup,
-                )
+                self.adt_switch_block(adt, unwind_blocks, &values, unwind, Unwind::InCleanup)
             }),
             dropline.map(|dropline| {
-                self.adt_switch_block(adt, dropline_blocks.unwrap(), &values, dropline, unwind)
+                self.adt_switch_block(adt, dropline_blocks, &values, dropline, unwind)
             }),
         )
     }

compiler/rustc_span/src/symbol.rs

@@ -1040,6 +1040,7 @@ symbols! {
         global_asm,
         global_registration,
         globs,
+        gpu_kernel: "gpu-kernel",
         gpu_launch_sized_workgroup_mem,
         gt,
         guard,
@@ -1424,6 +1425,7 @@ symbols! {
         of,
         off,
         offload,
+        offload_kernel,
         offset,
         offset_of,
         offset_of_enum,
@@ -2163,6 +2165,7 @@ symbols! {
         underscore_imports,
         underscore_lifetimes,
         uniform_paths,
+        unimplemented,
         unit,
         universal_impl_trait,
         unix,

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

@@ -448,9 +448,22 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         if let Some((msg, span)) = type_def {
                             err.span_label(span, msg);
                         }
-                        for note in notes {
-                            // If it has a custom `#[rustc_on_unimplemented]` note, let's display it
-                            err.note(note);
+                        // `#[rustc_on_unimplemented]` notes for derivable traits (e.g. `Debug`'s
+                        // "add `#[derive(Debug)]` to `X` or manually `impl Debug for X`") duplicate
+                        // the `consider annotating X with #[derive(..)]` suggestion that
+                        // `suggest_derive` emits below, so skip them when that suggestion will be
+                        // shown. We keep the note otherwise (e.g. when a field isn't `Debug`, so
+                        // the derive can't be suggested) to avoid leaving the diagnostic without
+                        // actionable guidance.
+                        let derive_suggestion_will_be_shown = main_trait_predicate
+                            == leaf_trait_predicate
+                            && self.can_suggest_derive(&obligation, leaf_trait_predicate);
+                        if !derive_suggestion_will_be_shown {
+                            for note in notes {
+                                // If it has a custom `#[rustc_on_unimplemented]` note, let's display
+                                // it.
+                                err.note(note);
+                            }
                         }
                         if let Some(s) = parent_label {
                             let body = obligation.cause.body_id;

library/alloc/src/alloc.rs

@@ -204,12 +204,12 @@ impl Global {
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     fn alloc_impl_runtime(layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocError> {
         match layout.size() {
-            0 => Ok(NonNull::slice_from_raw_parts(layout.dangling_ptr(), 0)),
+            0 => Ok(layout.dangling_ptr().cast_slice(0)),
             // SAFETY: `layout` is non-zero in size,
             size => unsafe {
                 let raw_ptr = if zeroed { alloc_zeroed(layout) } else { alloc(layout) };
                 let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
-                Ok(NonNull::slice_from_raw_parts(ptr, size))
+                Ok(ptr.cast_slice(size))
             },
         }
     }
@@ -261,7 +261,7 @@ impl Global {
                 if zeroed {
                     raw_ptr.add(old_size).write_bytes(0, new_size - old_size);
                 }
-                Ok(NonNull::slice_from_raw_parts(ptr, new_size))
+                Ok(ptr.cast_slice(new_size))
             },
 
             // SAFETY: because `new_layout.size()` must be greater than or equal to `old_size`,
@@ -297,7 +297,7 @@ impl Global {
             // SAFETY: conditions must be upheld by the caller
             0 => unsafe {
                 self.deallocate(ptr, old_layout);
-                Ok(NonNull::slice_from_raw_parts(new_layout.dangling_ptr(), 0))
+                Ok(new_layout.dangling_ptr().cast_slice(0))
             },
 
             // SAFETY: `new_size` is non-zero. Other conditions must be upheld by the caller
@@ -307,7 +307,7 @@ impl Global {
 
                 let raw_ptr = realloc_nonnull(ptr, old_layout, new_size);
                 let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
-                Ok(NonNull::slice_from_raw_parts(ptr, new_size))
+                Ok(ptr.cast_slice(new_size))
             },
 
             // SAFETY: because `new_size` must be smaller than or equal to `old_layout.size()`,
@@ -388,7 +388,7 @@ impl Global {
     #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     const fn alloc_impl_const(layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocError> {
         match layout.size() {
-            0 => Ok(NonNull::slice_from_raw_parts(layout.dangling_ptr(), 0)),
+            0 => Ok(layout.dangling_ptr().cast_slice(0)),
             // SAFETY: `layout` is non-zero in size,
             size => unsafe {
                 let raw_ptr = core::intrinsics::const_allocate(layout.size(), layout.align());
@@ -397,7 +397,7 @@ impl Global {
                     // SAFETY: the pointer returned by `const_allocate` is valid to write to.
                     ptr.write_bytes(0, size);
                 }
-                Ok(NonNull::slice_from_raw_parts(ptr, size))
+                Ok(ptr.cast_slice(size))
             },
         }
     }