Auto merge of rust-lang#126962 - workingjubilee:rollup-2qz7dbs, r=wor…

…kingjubilee

Rollup of 14 pull requests

Successful merges:

 - rust-lang#126618 (Mark assoc tys live only if the corresponding trait is live)
 - rust-lang#126746 (Deny `use<>` for RPITITs)
 - rust-lang#126868 (not use offset when there is not ends with brace)
 - rust-lang#126884 (Do not ICE when suggesting dereferencing closure arg)
 - rust-lang#126885 (Remove internal `PathBuf::as_mut_vec`)
 - rust-lang#126893 (Eliminate the distinction between PREC_POSTFIX and PREC_PAREN precedence level)
 - rust-lang#126915 (Don't suggest awaiting in closure patterns)
 - rust-lang#126916 (Specify target specific linker for `riscv64gc-gnu` job)
 - rust-lang#126926 (Tweak a confusing comment in `create_match_candidates`)
 - rust-lang#126927 (core: VaArgSafe is an unsafe trait)
 - rust-lang#126932 (Tweak `FlatPat::new` to avoid a temporarily-invalid state)
 - rust-lang#126941 (Migrate `run-make/llvm-ident` to `rmake.rs`)
 - rust-lang#126946 (Add missing slash in `const_eval_select` doc comment)
 - rust-lang#126947 (Delegation: ast lowering refactor)

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

compiler/rustc_ast/src/util/parser.rs

@@ -233,8 +233,7 @@ pub const PREC_JUMP: i8 = -30;
 pub const PREC_RANGE: i8 = -10;
 // The range 2..=14 is reserved for AssocOp binary operator precedences.
 pub const PREC_PREFIX: i8 = 50;
-pub const PREC_POSTFIX: i8 = 60;
-pub const PREC_PAREN: i8 = 99;
+pub const PREC_UNAMBIGUOUS: i8 = 60;
 pub const PREC_FORCE_PAREN: i8 = 100;
 
 #[derive(Debug, Clone, Copy)]
@@ -325,37 +324,35 @@ impl ExprPrecedence {
  | ExprPrecedence::Let
  | ExprPrecedence::Unary => PREC_PREFIX,
 
- // Unary, postfix
- ExprPrecedence::Await
+ // Never need parens
+ ExprPrecedence::Array
+ | ExprPrecedence::Await
+ | ExprPrecedence::Block
  | ExprPrecedence::Call
- | ExprPrecedence::MethodCall
+ | ExprPrecedence::ConstBlock
  | ExprPrecedence::Field
+ | ExprPrecedence::ForLoop
+ | ExprPrecedence::FormatArgs
+ | ExprPrecedence::Gen
+ | ExprPrecedence::If
  | ExprPrecedence::Index
- | ExprPrecedence::Try
  | ExprPrecedence::InlineAsm
+ | ExprPrecedence::Lit
+ | ExprPrecedence::Loop
  | ExprPrecedence::Mac
- | ExprPrecedence::FormatArgs
+ | ExprPrecedence::Match
+ | ExprPrecedence::MethodCall
  | ExprPrecedence::OffsetOf
- | ExprPrecedence::PostfixMatch => PREC_POSTFIX,
-
- // Never need parens
- ExprPrecedence::Array
+ | ExprPrecedence::Paren
+ | ExprPrecedence::Path
+ | ExprPrecedence::PostfixMatch
  | ExprPrecedence::Repeat
+ | ExprPrecedence::Struct
+ | ExprPrecedence::Try
+ | ExprPrecedence::TryBlock
  | ExprPrecedence::Tup
- | ExprPrecedence::Lit
- | ExprPrecedence::Path
- | ExprPrecedence::Paren
- | ExprPrecedence::If
  | ExprPrecedence::While
- | ExprPrecedence::ForLoop
- | ExprPrecedence::Loop
- | ExprPrecedence::Match
- | ExprPrecedence::ConstBlock
- | ExprPrecedence::Block
- | ExprPrecedence::TryBlock
- | ExprPrecedence::Gen
- | ExprPrecedence::Struct
- | ExprPrecedence::Err => PREC_PAREN,
+ | ExprPrecedence::Err => PREC_UNAMBIGUOUS,
  }
  }
 }

compiler/rustc_ast_lowering/messages.ftl

@@ -130,6 +130,9 @@ ast_lowering_never_pattern_with_guard =
 
 ast_lowering_no_precise_captures_on_apit = `use<...>` precise capturing syntax not allowed in argument-position `impl Trait`
 
+ast_lowering_no_precise_captures_on_rpitit = `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
+ .note = currently, return-position `impl Trait` in traits and trait implementations capture all lifetimes in scope
+
 ast_lowering_previously_used_here = previously used here
 
 ast_lowering_register1 = register `{$reg1_name}`

compiler/rustc_ast_lowering/src/delegation.rs

@@ -66,14 +66,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
  let Ok(sig_id) = sig_id else {
  return false;
  };
- if let Some(local_sig_id) = sig_id.as_local() {
+ self.has_self(sig_id, span)
+ }
+
+ fn has_self(&self, def_id: DefId, span: Span) -> bool {
+ if let Some(local_sig_id) = def_id.as_local() {
  // The value may be missing due to recursive delegation.
  // Error will be emmited later during HIR ty lowering.
  self.resolver.delegation_fn_sigs.get(&local_sig_id).map_or(false, |sig| sig.has_self)
  } else {
- match self.tcx.def_kind(sig_id) {
+ match self.tcx.def_kind(def_id) {
  DefKind::Fn => false,
- DefKind::AssocFn => self.tcx.associated_item(sig_id).fn_has_self_parameter,
+ DefKind::AssocFn => self.tcx.associated_item(def_id).fn_has_self_parameter,
  _ => span_bug!(span, "unexpected DefKind for delegation item"),
  }
  }
@@ -107,12 +111,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
  span: Span,
  ) -> Result<DefId, ErrorGuaranteed> {
  let sig_id = if self.is_in_trait_impl { item_id } else { path_id };
- let sig_id =
- self.resolver.get_partial_res(sig_id).and_then(|r| r.expect_full_res().opt_def_id());
- sig_id.ok_or_else(|| {
- self.tcx
- .dcx()
- .span_delayed_bug(span, "LoweringContext: couldn't resolve delegation item")
+ self.get_resolution_id(sig_id, span)
+ }
+
+ fn get_resolution_id(&self, node_id: NodeId, span: Span) -> Result<DefId, ErrorGuaranteed> {
+ let def_id =
+ self.resolver.get_partial_res(node_id).and_then(|r| r.expect_full_res().opt_def_id());
+ def_id.ok_or_else(|| {
+ self.tcx.dcx().span_delayed_bug(
+ span,
+ format!("LoweringContext: couldn't resolve node {:?} in delegation item", node_id),
+ )
  })
  }
 
@@ -122,7 +131,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  predicates: &[],
  has_where_clause_predicates: false,
  where_clause_span: span,
- span: span,
+ span,
  })
  }
 
@@ -222,12 +231,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  }));
 
  let path = self.arena.alloc(hir::Path { span, res: Res::Local(param_id), segments });
-
- hir::Expr {
- hir_id: self.next_id(),
- kind: hir::ExprKind::Path(hir::QPath::Resolved(None, path)),
- span,
- }
+ self.mk_expr(hir::ExprKind::Path(hir::QPath::Resolved(None, path)), span)
  }
 
  fn lower_delegation_body(
@@ -236,19 +240,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
  param_count: usize,
  span: Span,
  ) -> BodyId {
- let path = self.lower_qpath(
- delegation.id,
- &delegation.qself,
- &delegation.path,
- ParamMode::Optional,
- ImplTraitContext::Disallowed(ImplTraitPosition::Path),
- None,
- );
  let block = delegation.body.as_deref();
 
  self.lower_body(|this| {
- let mut parameters: Vec<hir::Param<'_>> = Vec::new();
- let mut args: Vec<hir::Expr<'hir>> = Vec::new();
+ let mut parameters: Vec<hir::Param<'_>> = Vec::with_capacity(param_count);
+ let mut args: Vec<hir::Expr<'_>> = Vec::with_capacity(param_count);
 
  for idx in 0..param_count {
  let (param, pat_node_id) = this.generate_param(span);
@@ -264,55 +260,49 @@ impl<'hir> LoweringContext<'_, 'hir> {
  };
  self_resolver.visit_block(block);
  let block = this.lower_block(block, false);
- hir::Expr {
- hir_id: this.next_id(),
- kind: hir::ExprKind::Block(block, None),
- span: block.span,
- }
+ this.mk_expr(hir::ExprKind::Block(block, None), block.span)
  } else {
  let pat_hir_id = this.lower_node_id(pat_node_id);
  this.generate_arg(pat_hir_id, span)
  };
  args.push(arg);
  }
 
- let args = self.arena.alloc_from_iter(args);
- let final_expr = this.generate_call(path, args);
+ let final_expr = this.finalize_body_lowering(delegation, args, span);
  (this.arena.alloc_from_iter(parameters), final_expr)
  })
  }
 
- fn generate_call(
+ // Generates fully qualified call for the resulting body.
+ fn finalize_body_lowering(
  &mut self,
- path: hir::QPath<'hir>,
- args: &'hir [hir::Expr<'hir>],
+ delegation: &Delegation,
+ args: Vec<hir::Expr<'hir>>,
+ span: Span,
  ) -> hir::Expr<'hir> {
- let callee = self.arena.alloc(hir::Expr {
- hir_id: self.next_id(),
- kind: hir::ExprKind::Path(path),
- span: path.span(),
- });
+ let path = self.lower_qpath(
+ delegation.id,
+ &delegation.qself,
+ &delegation.path,
+ ParamMode::Optional,
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ None,
+ );
 
- let expr = self.arena.alloc(hir::Expr {
- hir_id: self.next_id(),
- kind: hir::ExprKind::Call(callee, args),
- span: path.span(),
- });
+ let args = self.arena.alloc_from_iter(args);
+ let path_expr = self.arena.alloc(self.mk_expr(hir::ExprKind::Path(path), span));
+ let call = self.arena.alloc(self.mk_expr(hir::ExprKind::Call(path_expr, args), span));
 
  let block = self.arena.alloc(hir::Block {
  stmts: &[],
- expr: Some(expr),
+ expr: Some(call),
  hir_id: self.next_id(),
  rules: hir::BlockCheckMode::DefaultBlock,
- span: path.span(),
+ span,
  targeted_by_break: false,
  });
 
- hir::Expr {
- hir_id: self.next_id(),
- kind: hir::ExprKind::Block(block, None),
- span: path.span(),
- }
+ self.mk_expr(hir::ExprKind::Block(block, None), span)
  }
 
  fn generate_delegation_error(
@@ -333,11 +323,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  let header = self.generate_header_error();
  let sig = hir::FnSig { decl, header, span };
 
- let body_id = self.lower_body(|this| {
- let expr =
- hir::Expr { hir_id: this.next_id(), kind: hir::ExprKind::Err(err), span: span };
- (&[], expr)
- });
+ let body_id = self.lower_body(|this| (&[], this.mk_expr(hir::ExprKind::Err(err), span)));
  DelegationResults { generics, body_id, sig }
  }
 
@@ -349,6 +335,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
  abi: abi::Abi::Rust,
  }
  }
+
+ #[inline]
+ fn mk_expr(&mut self, kind: hir::ExprKind<'hir>, span: Span) -> hir::Expr<'hir> {
+ hir::Expr { hir_id: self.next_id(), kind, span }
+ }
 }
 
 struct SelfResolver<'a> {

compiler/rustc_ast_lowering/src/errors.rs

@@ -424,6 +424,14 @@ pub(crate) struct NoPreciseCapturesOnApit {
  pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(ast_lowering_no_precise_captures_on_rpitit)]
+#[note]
+pub(crate) struct NoPreciseCapturesOnRpitit {
+ #[primary_span]
+ pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(ast_lowering_yield_in_closure)]
 pub(crate) struct YieldInClosure {

compiler/rustc_ast_lowering/src/lib.rs

@@ -1594,6 +1594,26 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  };
  debug!(?captured_lifetimes_to_duplicate);
 
+ match fn_kind {
+ // Deny `use<>` on RPITIT in trait/trait-impl for now.
+ Some(FnDeclKind::Trait | FnDeclKind::Impl) => {
+ if let Some(span) = bounds.iter().find_map(|bound| match *bound {
+ ast::GenericBound::Use(_, span) => Some(span),
+ _ => None,
+ }) {
+ self.tcx.dcx().emit_err(errors::NoPreciseCapturesOnRpitit { span });
+ }
+ }
+ None
+ | Some(
+ FnDeclKind::Fn
+ | FnDeclKind::Inherent
+ | FnDeclKind::ExternFn
+ | FnDeclKind::Closure
+ | FnDeclKind::Pointer,
+ ) => {}
+ }
+
  self.lower_opaque_inner(
  opaque_ty_node_id,
  origin,

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

@@ -217,7 +217,7 @@ impl<'a> State<'a> {
  fn print_expr_call(&mut self, func: &ast::Expr, args: &[P<ast::Expr>], fixup: FixupContext) {
  let prec = match func.kind {
  ast::ExprKind::Field(..) => parser::PREC_FORCE_PAREN,
- _ => parser::PREC_POSTFIX,
+ _ => parser::PREC_UNAMBIGUOUS,
  };
 
  // Independent of parenthesization related to precedence, we must
@@ -257,7 +257,7 @@ impl<'a> State<'a> {
  // boundaries, `$receiver.method()` can be parsed back as a statement
  // containing an expression if and only if `$receiver` can be parsed as
  // a statement containing an expression.
- self.print_expr_maybe_paren(receiver, parser::PREC_POSTFIX, fixup);
+ self.print_expr_maybe_paren(receiver, parser::PREC_UNAMBIGUOUS, fixup);
 
  self.word(".");
  self.print_ident(segment.ident);
@@ -489,7 +489,7 @@ impl<'a> State<'a> {
  self.space();
  }
  MatchKind::Postfix => {
- self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX, fixup);
+ self.print_expr_maybe_paren(expr, parser::PREC_UNAMBIGUOUS, fixup);
  self.word_nbsp(".match");
  }
  }
@@ -549,7 +549,7 @@ impl<'a> State<'a> {
  self.print_block_with_attrs(blk, attrs);
  }
  ast::ExprKind::Await(expr, _) => {
- self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX, fixup);
+ self.print_expr_maybe_paren(expr, parser::PREC_UNAMBIGUOUS, fixup);
  self.word(".await");
  }
  ast::ExprKind::Assign(lhs, rhs, _) => {
@@ -568,14 +568,14 @@ impl<'a> State<'a> {
  self.print_expr_maybe_paren(rhs, prec, fixup.subsequent_subexpression());
  }
  ast::ExprKind::Field(expr, ident) => {
- self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX, fixup);
+ self.print_expr_maybe_paren(expr, parser::PREC_UNAMBIGUOUS, fixup);
  self.word(".");
  self.print_ident(*ident);
  }
  ast::ExprKind::Index(expr, index, _) => {
  self.print_expr_maybe_paren(
  expr,
- parser::PREC_POSTFIX,
+ parser::PREC_UNAMBIGUOUS,
  fixup.leftmost_subexpression(),
  );
  self.word("[");
@@ -713,7 +713,7 @@ impl<'a> State<'a> {
  }
  }
  ast::ExprKind::Try(e) => {
- self.print_expr_maybe_paren(e, parser::PREC_POSTFIX, fixup);
+ self.print_expr_maybe_paren(e, parser::PREC_UNAMBIGUOUS, fixup);
  self.word("?")
  }
  ast::ExprKind::TryBlock(blk) => {

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -1151,7 +1151,9 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, '_, 'tcx> {
  // Get the arguments for the found method, only specifying that `Self` is the receiver type.
  let Some(possible_rcvr_ty) = typeck_results.node_type_opt(rcvr.hir_id) else { return };
  let args = GenericArgs::for_item(tcx, method_def_id, |param, _| {
- if param.index == 0 {
+ if let ty::GenericParamDefKind::Lifetime = param.kind {
+ tcx.lifetimes.re_erased.into()
+ } else if param.index == 0 && param.name == kw::SelfUpper {
  possible_rcvr_ty.into()
  } else if param.index == closure_param.index {
  closure_ty.into()
@@ -1168,7 +1170,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, '_, 'tcx> {
  Obligation::misc(tcx, span, self.mir_def_id(), self.param_env, pred)
  }));
 
- if ocx.select_all_or_error().is_empty() {
+ if ocx.select_all_or_error().is_empty() && count > 0 {
  diag.span_suggestion_verbose(
  tcx.hir().body(*body).value.peel_blocks().span.shrink_to_lo(),
  "dereference the return value",