Rollup of 11 pull requests

.mailmap

@@ -462,6 +462,8 @@ Mateusz Mikuła <oss@mateuszmikula.dev>
 Mateusz Mikuła <oss@mateuszmikula.dev> <mati865@gmail.com>
 Mateusz Mikuła <oss@mateuszmikula.dev> <mati865@users.noreply.github.com>
 Mateusz Mikuła <oss@mateuszmikula.dev> <matti@marinelayer.io>
+Matilde Morrone <contact@rosymati.com> <contact@matilde.pet>
+Matilde Morrone <contact@rosymati.com> <contact@morrone.dev>
 Matt Brubeck <mbrubeck@limpet.net> <mbrubeck@cs.hmc.edu>
 Matthew Auld <matthew.auld@intel.com>
 Matthew Jasper <mjjasper1@gmail.com>

compiler/rustc_abi/src/layout/coroutine.rs

@@ -136,20 +136,20 @@ fn coroutine_saved_local_eligibility<VariantIdx: Idx, FieldIdx: Idx, LocalIdx: I
 }
 
 /// Compute the full coroutine layout.
-pub(super) fn layout<
-    'a,
-    F: core::ops::Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + core::fmt::Debug + Copy,
-    VariantIdx: Idx,
-    FieldIdx: Idx,
-    LocalIdx: Idx,
->(
+pub(super) fn layout<'a, F, VariantIdx, FieldIdx, LocalIdx>(
     calc: &super::LayoutCalculator<impl HasDataLayout>,
     local_layouts: &IndexSlice<LocalIdx, F>,
     mut prefix_layouts: IndexVec<FieldIdx, F>,
     variant_fields: &IndexSlice<VariantIdx, IndexVec<FieldIdx, LocalIdx>>,
     storage_conflicts: &BitMatrix<LocalIdx, LocalIdx>,
     tag_to_layout: impl Fn(Scalar) -> F,
-) -> super::LayoutCalculatorResult<FieldIdx, VariantIdx, F> {
+) -> super::LayoutCalculatorResult<FieldIdx, VariantIdx, F>
+where
+    F: core::ops::Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + core::fmt::Debug + Copy,
+    VariantIdx: Idx,
+    FieldIdx: Idx,
+    LocalIdx: Idx,
+{
     use SavedLocalEligibility::*;
 
     let (ineligible_locals, assignments) =
@@ -171,8 +171,11 @@ pub(super) fn layout<
     let promoted_layouts = ineligible_locals.iter().map(|local| local_layouts[local]);
     prefix_layouts.push(tag_to_layout(tag));
     prefix_layouts.extend(promoted_layouts);
-    let prefix =
-        calc.univariant(&prefix_layouts, &ReprOptions::default(), StructKind::AlwaysSized)?;
+    let prefix = calc.layout_of_univariant(
+        &prefix_layouts,
+        &ReprOptions::default(),
+        StructKind::AlwaysSized,
+    )?;
 
     let (prefix_size, prefix_align) = (prefix.size, prefix.align);
 
@@ -225,7 +228,7 @@ pub(super) fn layout<
                 })
                 .map(|local| local_layouts[*local]);
 
-            let mut variant = calc.univariant(
+            let mut variant = calc.layout_of_univariant(
                 &variant_only_tys.collect::<IndexVec<_, _>>(),
                 &ReprOptions::default(),
                 StructKind::Prefixed(prefix_size, prefix_align.abi),

compiler/rustc_abi/src/lib.rs

@@ -2027,10 +2027,10 @@ pub enum Variants<FieldIdx: Idx, VariantIdx: Idx> {
     /// 2. the never type
     Empty,
 
-    /// The type has a single valid variant.
+    /// The type has a single valid variant. Such types are called "univariant".
     ///
     /// This is the case for:
-    /// 1. enums with a single inhabited variant
+    /// 1. enums with a single inhabited variant, aka. "univariant enums"
     /// 2. structs, unions, and non-ADTs (except coroutines; see below),
     ///    as those can't have multiple variants
     Single {
@@ -2195,6 +2195,18 @@ impl Niche {
     }
 }
 
+/// Whether niche optimizations should be performed during layout calculation.
+///
+/// [`UnsafeCell`] and [`UnsafePinned`] both disable niche optimizations.
+///
+/// [`UnsafeCell`]: std::cell::UnsafeCell
+/// [`UnsafePinned`]: std::pin::UnsafePinned
+#[derive(PartialEq, Eq, Clone, Copy)]
+pub enum NicheOptimizations {
+    Enabled,
+    Disabled,
+}
+
 // NOTE: This struct is generic over the FieldIdx and VariantIdx for rust-analyzer usage.
 #[derive(PartialEq, Eq, Hash, Clone)]
 #[cfg_attr(feature = "nightly", derive(StableHash))]

compiler/rustc_builtin_macros/src/asm.rs

@@ -588,13 +588,7 @@ pub(super) fn expand_asm<'cx>(
                 return ExpandResult::Retry(());
             };
             let expr = match mac {
-                Ok(inline_asm) => Box::new(ast::Expr {
-                    id: ast::DUMMY_NODE_ID,
-                    kind: ast::ExprKind::InlineAsm(Box::new(inline_asm)),
-                    span: sp,
-                    attrs: ast::AttrVec::new(),
-                    tokens: None,
-                }),
+                Ok(inline_asm) => ecx.expr(sp, ast::ExprKind::InlineAsm(Box::new(inline_asm))),
                 Err(guar) => DummyResult::raw_expr(sp, Some(guar)),
             };
             MacEager::expr(expr)
@@ -618,13 +612,7 @@ pub(super) fn expand_naked_asm<'cx>(
                 return ExpandResult::Retry(());
             };
             let expr = match mac {
-                Ok(inline_asm) => Box::new(ast::Expr {
-                    id: ast::DUMMY_NODE_ID,
-                    kind: ast::ExprKind::InlineAsm(Box::new(inline_asm)),
-                    span: sp,
-                    attrs: ast::AttrVec::new(),
-                    tokens: None,
-                }),
+                Ok(inline_asm) => ecx.expr(sp, ast::ExprKind::InlineAsm(Box::new(inline_asm))),
                 Err(guar) => DummyResult::raw_expr(sp, Some(guar)),
             };
             MacEager::expr(expr)
@@ -648,17 +636,11 @@ pub(super) fn expand_global_asm<'cx>(
                 return ExpandResult::Retry(());
             };
             match mac {
-                Ok(inline_asm) => MacEager::items(smallvec![Box::new(ast::Item {
-                    attrs: ast::AttrVec::new(),
-                    id: ast::DUMMY_NODE_ID,
-                    kind: ast::ItemKind::GlobalAsm(Box::new(inline_asm)),
-                    vis: ast::Visibility {
-                        span: sp.shrink_to_lo(),
-                        kind: ast::VisibilityKind::Inherited,
-                    },
-                    span: sp,
-                    tokens: None,
-                })]),
+                Ok(inline_asm) => MacEager::items(smallvec![ecx.item(
+                    sp,
+                    ast::AttrVec::new(),
+                    ast::ItemKind::GlobalAsm(Box::new(inline_asm))
+                )]),
                 Err(guar) => DummyResult::any(sp, guar),
             }
         }

compiler/rustc_builtin_macros/src/assert.rs

@@ -1,8 +1,8 @@
 mod context;
 
 use rustc_ast::token::Delimiter;
-use rustc_ast::tokenstream::{DelimSpan, TokenStream};
-use rustc_ast::{DelimArgs, Expr, ExprKind, MacCall, Path, PathSegment, UnOp, token};
+use rustc_ast::tokenstream::TokenStream;
+use rustc_ast::{Expr, ExprKind, Path, UnOp, token};
 use rustc_ast_pretty::pprust;
 use rustc_errors::PResult;
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
@@ -34,14 +34,7 @@ pub(crate) fn expand_assert<'cx>(
     let panic_path = || {
         if use_panic_2021(span) {
             // On edition 2021, we always call `$crate::panic::panic_2021!()`.
-            Path {
-                span: call_site_span,
-                segments: cx
-                    .std_path(&[sym::panic, sym::panic_2021])
-                    .into_iter()
-                    .map(PathSegment::from_ident)
-                    .collect(),
-            }
+            cx.path(call_site_span, cx.std_path(&[sym::panic, sym::panic_2021]))
         } else {
             // Before edition 2021, we call `panic!()` unqualified,
             // such that it calls either `std::panic!()` or `core::panic!()`.
@@ -51,16 +44,9 @@ pub(crate) fn expand_assert<'cx>(
 
     // Simply uses the user provided message instead of generating custom outputs
     let expr = if let Some(tokens) = custom_message {
-        let then = cx.expr(
+        let then = cx.expr_macro_call(
             call_site_span,
-            ExprKind::MacCall(Box::new(MacCall {
-                path: panic_path(),
-                args: Box::new(DelimArgs {
-                    dspan: DelimSpan::from_single(call_site_span),
-                    delim: Delimiter::Parenthesis,
-                    tokens,
-                }),
-            })),
+            cx.macro_call(call_site_span, panic_path(), Delimiter::Parenthesis, tokens),
         );
         expr_if_not(cx, call_site_span, cond_expr, then, None)
     }

compiler/rustc_builtin_macros/src/assert/context.rs

@@ -1,8 +1,8 @@
 use rustc_ast::token::{self, Delimiter, IdentKind};
 use rustc_ast::tokenstream::{DelimSpan, TokenStream, TokenTree};
 use rustc_ast::{
-    BinOpKind, BorrowKind, DUMMY_NODE_ID, DelimArgs, Expr, ExprKind, ItemKind, MacCall, MethodCall,
-    Mutability, Path, PathSegment, Stmt, StructRest, UnOp, UseTree, UseTreeAndId, UseTreeKind,
+    BinOpKind, BorrowKind, DUMMY_NODE_ID, DelimArgs, Expr, ExprKind, ItemKind, MacCall, Mutability,
+    Path, Stmt, StructRest, UnOp, UseTree, UseTreeAndId, UseTreeKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashSet;
@@ -382,20 +382,15 @@ impl<'cx, 'a> Context<'cx, 'a> {
         );
         let try_capture_call = self
             .cx
-            .stmt_expr(expr_method_call(
-                self.cx,
-                PathSegment {
-                    args: None,
-                    id: DUMMY_NODE_ID,
-                    ident: Ident::new(sym::try_capture, self.span),
-                },
-                expr_paren(self.cx, self.span, self.cx.expr_addr_of(self.span, wrapper)),
+            .stmt_expr(self.cx.expr_method_call(
+                self.span,
+                self.cx.expr_paren(self.span, self.cx.expr_addr_of(self.span, wrapper)),
+                Ident::new(sym::try_capture, self.span),
                 thin_vec![expr_addr_of_mut(
                     self.cx,
                     self.span,
                     self.cx.expr_path(Path::from_ident(capture)),
                 )],
-                self.span,
             ))
             .add_trailing_semicolon();
         let local_bind_path = self.cx.expr_path(Path::from_ident(local_bind));
@@ -448,17 +443,3 @@ fn escape_to_fmt(s: &str) -> String {
 fn expr_addr_of_mut(cx: &ExtCtxt<'_>, sp: Span, e: Box<Expr>) -> Box<Expr> {
     cx.expr(sp, ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, e))
 }
-
-fn expr_method_call(
-    cx: &ExtCtxt<'_>,
-    seg: PathSegment,
-    receiver: Box<Expr>,
-    args: ThinVec<Box<Expr>>,
-    span: Span,
-) -> Box<Expr> {
-    cx.expr(span, ExprKind::MethodCall(Box::new(MethodCall { seg, receiver, args, span })))
-}
-
-fn expr_paren(cx: &ExtCtxt<'_>, sp: Span, e: Box<Expr>) -> Box<Expr> {
-    cx.expr(sp, ExprKind::Paren(e))
-}