Auto merge of rust-lang#127244 - matthiaskrgr:rollup-px1vahe, r=matth…

…iaskrgr

Rollup of 10 pull requests

Successful merges:

 - rust-lang#126883 (Parenthesize break values containing leading label)
 - rust-lang#127136 (Fix `FnMut::call_mut`/`Fn::call` shim for async closures that capture references)
 - rust-lang#127146 (Uplift fast rejection to new solver)
 - rust-lang#127152 (Bootstrap: Try renaming the file if removing fails)
 - rust-lang#127168 (Use the aligned size for alloca at args/ret when the pass mode is cast)
 - rust-lang#127203 (Fix import suggestion error when path segment failed not from starting)
 - rust-lang#127212 (Update books)
 - rust-lang#127224 (Make `FloatTy` checks exhaustive in pretty print)
 - rust-lang#127230 (chore: remove duplicate words)
 - rust-lang#127243 (Add test for adt_const_params)

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

compiler/rustc_ast/src/util/classify.rs

@@ -1,7 +1,8 @@
 //! Routines the parser and pretty-printer use to classify AST nodes.
 
 use crate::ast::ExprKind::*;
-use crate::{ast, token::Delimiter};
+use crate::ast::{self, MatchKind};
+use crate::token::Delimiter;
 
 /// This classification determines whether various syntactic positions break out
 /// of parsing the current expression (true) or continue parsing more of the
@@ -81,6 +82,82 @@ pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
  }
 }
 
+/// Returns whether the leftmost token of the given expression is the label of a
+/// labeled loop or block, such as in `'inner: loop { break 'inner 1 } + 1`.
+///
+/// Such expressions are not allowed as the value of an unlabeled break.
+///
+/// ```ignore (illustrative)
+/// 'outer: {
+/// break 'inner: loop { break 'inner 1 } + 1; // invalid syntax
+///
+/// break 'outer 'inner: loop { break 'inner 1 } + 1; // okay
+///
+/// break ('inner: loop { break 'inner 1 } + 1); // okay
+///
+/// break ('inner: loop { break 'inner 1 }) + 1; // okay
+/// }
+/// ```
+pub fn leading_labeled_expr(mut expr: &ast::Expr) -> bool {
+ loop {
+ match &expr.kind {
+ Block(_, label) | ForLoop { label, .. } | Loop(_, label, _) | While(_, _, label) => {
+ return label.is_some();
+ }
+
+ Assign(e, _, _)
+ | AssignOp(_, e, _)
+ | Await(e, _)
+ | Binary(_, e, _)
+ | Call(e, _)
+ | Cast(e, _)
+ | Field(e, _)
+ | Index(e, _, _)
+ | Match(e, _, MatchKind::Postfix)
+ | Range(Some(e), _, _)
+ | Try(e) => {
+ expr = e;
+ }
+ MethodCall(method_call) => {
+ expr = &method_call.receiver;
+ }
+
+ AddrOf(..)
+ | Array(..)
+ | Become(..)
+ | Break(..)
+ | Closure(..)
+ | ConstBlock(..)
+ | Continue(..)
+ | FormatArgs(..)
+ | Gen(..)
+ | If(..)
+ | IncludedBytes(..)
+ | InlineAsm(..)
+ | Let(..)
+ | Lit(..)
+ | MacCall(..)
+ | Match(_, _, MatchKind::Prefix)
+ | OffsetOf(..)
+ | Paren(..)
+ | Path(..)
+ | Range(None, _, _)
+ | Repeat(..)
+ | Ret(..)
+ | Struct(..)
+ | TryBlock(..)
+ | Tup(..)
+ | Type(..)
+ | Unary(..)
+ | Underscore
+ | Yeet(..)
+ | Yield(..)
+ | Err(..)
+ | Dummy => return false,
+ }
+ }
+}
+
 pub enum TrailingBrace<'a> {
  /// Trailing brace in a macro call, like the one in `x as *const brace! {}`.
  /// We will suggest changing the macro call to a different delimiter.

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -5,6 +5,7 @@ use ast::{ForLoopKind, MatchKind};
 use itertools::{Itertools, Position};
 use rustc_ast::ptr::P;
 use rustc_ast::token;
+use rustc_ast::util::classify;
 use rustc_ast::util::literal::escape_byte_str_symbol;
 use rustc_ast::util::parser::{self, AssocOp, Fixity};
 use rustc_ast::{self as ast, BlockCheckMode};
@@ -610,9 +611,12 @@ impl<'a> State<'a> {
  }
  if let Some(expr) = opt_expr {
  self.space();
- self.print_expr_maybe_paren(
+ self.print_expr_cond_paren(
  expr,
- parser::PREC_JUMP,
+ // Parenthesize if required by precedence, or in the
+ // case of `break 'inner: loop { break 'inner 1 } + 1`
+ expr.precedence().order() < parser::PREC_JUMP
+ || (opt_label.is_none() && classify::leading_labeled_expr(expr)),
  fixup.subsequent_subexpression(),
  );
  }

compiler/rustc_codegen_llvm/src/abi.rs

@@ -226,7 +226,8 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
  // when passed by value, making it smaller.
  // - On some ABIs, the Rust layout { u16, u16, u16 } may be padded up to 8 bytes
  // when passed by value, making it larger.
- let copy_bytes = cmp::min(scratch_size.bytes(), self.layout.size.bytes());
+ let copy_bytes =
+ cmp::min(cast.unaligned_size(bx).bytes(), self.layout.size.bytes());
  // Allocate some scratch space...
  let llscratch = bx.alloca(scratch_size, scratch_align);
  bx.lifetime_start(llscratch, scratch_size);

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -403,7 +403,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  //
  // Why only in unoptimized builds?
  // - In unoptimized builds LLVM uses FastISel which does not support switches, so it
- // must fall back to the to the slower SelectionDAG isel. Therefore, using `br` gives
+ // must fall back to the slower SelectionDAG isel. Therefore, using `br` gives
  // significant compile time speedups for unoptimized builds.
  // - In optimized builds the above doesn't hold, and using `br` sometimes results in
  // worse generated code because LLVM can no longer tell that the value being switched
@@ -1521,7 +1521,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  // when passed by value, making it smaller.
  // - On some ABIs, the Rust layout { u16, u16, u16 } may be padded up to 8 bytes
  // when passed by value, making it larger.
- let copy_bytes = cmp::min(scratch_size.bytes(), arg.layout.size.bytes());
+ let copy_bytes = cmp::min(cast.unaligned_size(bx).bytes(), arg.layout.size.bytes());
  // Allocate some scratch space...
  let llscratch = bx.alloca(scratch_size, scratch_align);
  bx.lifetime_start(llscratch, scratch_size);

compiler/rustc_codegen_ssa/src/mir/locals.rs

@@ -47,7 +47,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  let expected_ty = self.monomorphize(self.mir.local_decls[local].ty);
  if expected_ty != op.layout.ty {
  warn!(
- "Unexpected initial operand type: expected {expected_ty:?}, found {:?}.\
+ "Unexpected initial operand type:\nexpected {expected_ty:?},\nfound {:?}.\n\
  See <https://github.com/rust-lang/rust/issues/114858>.",
  op.layout.ty
  );

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -230,10 +230,20 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
  let layout = start_bx.layout_of(fx.monomorphize(decl.ty));
  assert!(!layout.ty.has_erasable_regions());
 
- if local == mir::RETURN_PLACE && fx.fn_abi.ret.is_indirect() {
- debug!("alloc: {:?} (return place) -> place", local);
- let llretptr = start_bx.get_param(0);
- return LocalRef::Place(PlaceRef::new_sized(llretptr, layout));
+ if local == mir::RETURN_PLACE {
+ match fx.fn_abi.ret.mode {
+ PassMode::Indirect { .. } => {
+ debug!("alloc: {:?} (return place) -> place", local);
+ let llretptr = start_bx.get_param(0);
+ return LocalRef::Place(PlaceRef::new_sized(llretptr, layout));
+ }
+ PassMode::Cast { ref cast, .. } => {
+ debug!("alloc: {:?} (return place) -> place", local);
+ let size = cast.size(&start_bx);
+ return LocalRef::Place(PlaceRef::alloca_size(&mut start_bx, size, layout));
+ }
+ _ => {}
+ };
  }
 
  if memory_locals.contains(local) {

compiler/rustc_codegen_ssa/src/mir/place.rs

@@ -108,9 +108,17 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
  pub fn alloca<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
  bx: &mut Bx,
  layout: TyAndLayout<'tcx>,
+ ) -> Self {
+ Self::alloca_size(bx, layout.size, layout)
+ }
+
+ pub fn alloca_size<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
+ bx: &mut Bx,
+ size: Size,
+ layout: TyAndLayout<'tcx>,
  ) -> Self {
  assert!(layout.is_sized(), "tried to statically allocate unsized place");
- PlaceValue::alloca(bx, layout.size, layout.align.abi).with_type(layout)
+ PlaceValue::alloca(bx, size, layout.align.abi).with_type(layout)
  }
 
  /// Returns a place for an indirect reference to an unsized place.

compiler/rustc_const_eval/src/interpret/discriminant.rs

@@ -245,7 +245,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  // The tag of a `Single` enum is like the tag of the niched
  // variant: there's no tag as the discriminant is encoded
  // entirely implicitly. If `write_discriminant` ever hits this
- // case, we do a "validation read" to ensure the the right
+ // case, we do a "validation read" to ensure the right
  // discriminant is encoded implicitly, so any attempt to write
  // the wrong discriminant for a `Single` enum will reliably
  // result in UB.

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -499,7 +499,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  }
  }
 
- // If the shadowed binding has an an itializer expression,
+ // If the shadowed binding has an itializer expression,
  // use the initializer expression'ty to try to find the method again.
  // For example like: `let mut x = Vec::new();`,
  // `Vec::new()` is the itializer expression.
@@ -968,7 +968,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  }
 
  // Make sure that, if any traits other than the found ones were involved,
- // we don't don't report an unimplemented trait.
+ // we don't report an unimplemented trait.
  // We don't want to say that `iter::Cloned` is not an iterator, just
  // because of some non-Clone item being iterated over.
  for (predicate, _parent_pred, _cause) in unsatisfied_predicates {
@@ -2129,7 +2129,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let target_ty = self
  .autoderef(sugg_span, rcvr_ty)
  .find(|(rcvr_ty, _)| {
- DeepRejectCtxt { treat_obligation_params: TreatParams::AsCandidateKey }
+ DeepRejectCtxt::new(self.tcx, TreatParams::ForLookup)
  .types_may_unify(*rcvr_ty, impl_ty)
  })
  .map_or(impl_ty, |(ty, _)| ty)

compiler/rustc_middle/src/ty/closure.rs

@@ -237,7 +237,7 @@ impl<'tcx> TyCtxt<'tcx> {
 /// Eg: 1. `foo.x` which is represented using `projections=[Field(x)]` is an ancestor of
 /// `foo.x.y` which is represented using `projections=[Field(x), Field(y)]`.
 /// Note both `foo.x` and `foo.x.y` start off of the same root variable `foo`.
-/// 2. Since we only look at the projections here function will return `bar.x` as an a valid
+/// 2. Since we only look at the projections here function will return `bar.x` as a valid
 /// ancestor of `foo.x.y`. It's the caller's responsibility to ensure that both projections
 /// list are being applied to the same root variable.
 pub fn is_ancestor_or_same_capture(

compiler/rustc_middle/src/ty/context.rs

@@ -373,17 +373,6 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
  .map(|assoc_item| assoc_item.def_id)
  }
 
- fn args_may_unify_deep(
- self,
- obligation_args: ty::GenericArgsRef<'tcx>,
- impl_args: ty::GenericArgsRef<'tcx>,
- ) -> bool {
- ty::fast_reject::DeepRejectCtxt {
- treat_obligation_params: ty::fast_reject::TreatParams::ForLookup,
- }
- .args_may_unify(obligation_args, impl_args)
- }
-
  // This implementation is a bit different from `TyCtxt::for_each_relevant_impl`,
  // since we want to skip over blanket impls for non-rigid aliases, and also we
  // only want to consider types that *actually* unify with float/int vars.