Auto merge of #124111 - matthiaskrgr:rollup-cmmkryf, r=matthiaskrgr

Rollup of 5 pull requests
Successful merges:
- #124041 (Fix copy path button)
- #124047 (Match ergonomics 2024: miscellaneous code cleanups)
- #124064 (Move confusing comment about otherwise blocks in `lower_match_tree`)
- #124090 (llvm: update riscv target feature to match LLVM 19)
- #124100 (fix: make `str::from_raw_parts_mut` `mut`)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_ast/src/ast.rs

@@ -568,7 +568,7 @@ impl Pat {
 // In a type expression `_` is an inference variable.
 PatKind::Wild => TyKind::Infer,
 // An IDENT pattern with no binding mode would be valid as path to a type. E.g. `u32`.
-PatKind::Ident(BindingAnnotation::NONE, ident,None) => {
+PatKind::Ident(BindingMode::NONE, ident,None) => {
 TyKind::Path(None,Path::from_ident(*ident))
 }
 PatKind::Path(qself, path) => TyKind::Path(qself.clone(), path.clone()),
@@ -675,7 +675,7 @@ impl Pat {
 pubfndescr(&self) -> Option<String>{
 match&self.kind{
 PatKind::Wild => Some("_".to_string()),
-PatKind::Ident(BindingAnnotation::NONE, ident,None) => Some(format!("{ident}")),
+PatKind::Ident(BindingMode::NONE, ident,None) => Some(format!("{ident}")),
 PatKind::Ref(pat, mutbl) => pat.descr().map(|d| format!("&{}{d}", mutbl.prefix_str())),
  _ => None,
 }
@@ -707,14 +707,25 @@ pub enum ByRef {
 No,
 }
 
-/// Explicit binding annotations given in the HIR for a binding. Note
-/// that this is not the final binding *mode* that we infer after type
-/// inference.
+implByRef{
+pubfncap_ref_mutability(mutself,mutbl:Mutability) -> Self{
+ifletByRef::Yes(old_mutbl) = &mutself{
+*old_mutbl = cmp::min(*old_mutbl, mutbl);
+}
+self
+}
+}
+
+/// The mode of a binding (`mut`, `ref mut`, etc).
+/// Used for both the explicit binding annotations given in the HIR for a binding
+/// and the final binding mode that we infer after type inference/match ergonomics.
+/// `.0` is the by-reference mode (`ref`, `ref mut`, or by value),
+/// `.1` is the mutability of the binding.
 #[derive(Clone,Copy,Debug,Eq,PartialEq)]
 #[derive(Encodable,Decodable,HashStable_Generic)]
-pubstructBindingAnnotation(pubByRef,pubMutability);
+pubstructBindingMode(pubByRef,pubMutability);
 
-implBindingAnnotation{
+implBindingMode{
 pubconstNONE:Self = Self(ByRef::No,Mutability::Not);
 pubconstREF:Self = Self(ByRef::Yes(Mutability::Not),Mutability::Not);
 pubconstMUT:Self = Self(ByRef::No,Mutability::Mut);
@@ -732,13 +743,6 @@ impl BindingAnnotation {
 Self::MUT_REF_MUT => "mut ref mut ",
 }
 }
-
-pubfncap_ref_mutability(mutself,mutbl:Mutability) -> Self{
-ifletByRef::Yes(old_mutbl) = &mutself.0{
-*old_mutbl = cmp::min(*old_mutbl, mutbl);
-}
-self
-}
 }
 
 #[derive(Clone,Encodable,Decodable,Debug)]
@@ -769,7 +773,7 @@ pub enum PatKind {
 /// or a unit struct/variant pattern, or a const pattern (in the last two cases the third
 /// field must be `None`). Disambiguation cannot be done with parser alone, so it happens
 /// during name resolution.
-Ident(BindingAnnotation,Ident,Option<P<Pat>>),
+Ident(BindingMode,Ident,Option<P<Pat>>),
 
 /// A struct or struct variant pattern (e.g., `Variant {x, y, ..}`).
 Struct(Option<P<QSelf>>,Path,ThinVec<PatField>,PatFieldsRest),
@@ -2382,7 +2386,7 @@ pub type ExplicitSelf = Spanned<SelfKind>;
 implParam{
 /// Attempts to cast parameter to `ExplicitSelf`.
 pubfnto_self(&self) -> Option<ExplicitSelf>{
-ifletPatKind::Ident(BindingAnnotation(ByRef::No, mutbl), ident, _) = self.pat.kind{
+ifletPatKind::Ident(BindingMode(ByRef::No, mutbl), ident, _) = self.pat.kind{
 if ident.name == kw::SelfLower{
 returnmatchself.ty.kind{
 TyKind::ImplicitSelf => Some(respan(self.pat.span,SelfKind::Value(mutbl))),
@@ -2434,7 +2438,7 @@ impl Param {
  attrs,
 pat:P(Pat{
 id:DUMMY_NODE_ID,
-kind:PatKind::Ident(BindingAnnotation(ByRef::No, mutbl), eself_ident,None),
+kind:PatKind::Ident(BindingMode(ByRef::No, mutbl), eself_ident,None),
  span,
 tokens:None,
 }),

compiler/rustc_ast_lowering/src/delegation.rs

@@ -178,7 +178,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 let pat_id = self.lower_node_id(pat_node_id);
 let pat = self.arena.alloc(hir::Pat{
 hir_id: pat_id,
-kind: hir::PatKind::Binding(hir::BindingAnnotation::NONE, pat_id,Ident::empty(),None),
+kind: hir::PatKind::Binding(hir::BindingMode::NONE, pat_id,Ident::empty(),None),
 span: ty.span,
 default_binding_modes:false,
 });

compiler/rustc_ast_lowering/src/expr.rs

@@ -643,7 +643,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 let(pat, task_context_hid) = self.pat_ident_binding_mode(
  span,
 Ident::with_dummy_span(sym::_task_context),
- hir::BindingAnnotation::MUT,
+ hir::BindingMode::MUT,
 );
 let param = hir::Param{
 hir_id:self.next_id(),
@@ -805,11 +805,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
 // debuggers and debugger extensions expect it to be called `__awaitee`. They use
 // this name to identify what is being awaited by a suspended async functions.
 let awaitee_ident = Ident::with_dummy_span(sym::__awaitee);
-let(awaitee_pat, awaitee_pat_hid) = self.pat_ident_binding_mode(
- gen_future_span,
- awaitee_ident,
- hir::BindingAnnotation::MUT,
-);
+let(awaitee_pat, awaitee_pat_hid) =
+self.pat_ident_binding_mode(gen_future_span, awaitee_ident, hir::BindingMode::MUT);
 
 let task_context_ident = Ident::with_dummy_span(sym::_task_context);
 
@@ -1648,7 +1645,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 // `mut iter`
 let iter = Ident::with_dummy_span(sym::iter);
 let(iter_pat, iter_pat_nid) =
-self.pat_ident_binding_mode(head_span, iter, hir::BindingAnnotation::MUT);
+self.pat_ident_binding_mode(head_span, iter, hir::BindingMode::MUT);
 
 let match_expr = {
 let iter = self.expr_ident(head_span, iter, iter_pat_nid);

compiler/rustc_ast_lowering/src/item.rs

@@ -1179,9 +1179,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 // Check if this is a binding pattern, if so, we can optimize and avoid adding a
 // `let <pat> = __argN;` statement. In this case, we do not rename the parameter.
 let(ident, is_simple_parameter) = match parameter.pat.kind{
- hir::PatKind::Binding(hir::BindingAnnotation(ByRef::No, _), _, ident, _) => {
-(ident,true)
-}
+ hir::PatKind::Binding(hir::BindingMode(ByRef::No, _), _, ident, _) => (ident,true),
 // For `ref mut` or wildcard arguments, we can't reuse the binding, but
 // we can keep the same name for the parameter.
 // This lets rustdoc render it correctly in documentation.
@@ -1244,7 +1242,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 // because the user may have specified a `ref mut` binding in the next
 // statement.
 let(move_pat, move_id) =
-self.pat_ident_binding_mode(desugared_span, ident, hir::BindingAnnotation::MUT);
+self.pat_ident_binding_mode(desugared_span, ident, hir::BindingMode::MUT);
 let move_expr = self.expr_ident(desugared_span, ident, new_parameter_id);
 let move_stmt = self.stmt_let_pat(
 None,

compiler/rustc_ast_lowering/src/lib.rs

@@ -1895,7 +1895,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 implicit_self: decl.inputs.get(0).map_or(hir::ImplicitSelfKind::None, |arg| {
 let is_mutable_pat = matches!(
  arg.pat.kind,
-PatKind::Ident(hir::BindingAnnotation(_,Mutability::Mut), ..)
+PatKind::Ident(hir::BindingMode(_,Mutability::Mut), ..)
 );
 
 match&arg.ty.kind{
@@ -2478,18 +2478,18 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 }
 
 fnpat_ident(&mutself,span:Span,ident:Ident) -> (&'hir hir::Pat<'hir>,HirId){
-self.pat_ident_binding_mode(span, ident, hir::BindingAnnotation::NONE)
+self.pat_ident_binding_mode(span, ident, hir::BindingMode::NONE)
 }
 
 fnpat_ident_mut(&mutself,span:Span,ident:Ident) -> (hir::Pat<'hir>,HirId){
-self.pat_ident_binding_mode_mut(span, ident, hir::BindingAnnotation::NONE)
+self.pat_ident_binding_mode_mut(span, ident, hir::BindingMode::NONE)
 }
 
 fnpat_ident_binding_mode(
 &mutself,
 span:Span,
 ident:Ident,
-bm: hir::BindingAnnotation,
+bm: hir::BindingMode,
 ) -> (&'hir hir::Pat<'hir>,HirId){
 let(pat, hir_id) = self.pat_ident_binding_mode_mut(span, ident, bm);
 (self.arena.alloc(pat), hir_id)
@@ -2499,7 +2499,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 &mutself,
 span:Span,
 ident:Ident,
-bm: hir::BindingAnnotation,
+bm: hir::BindingMode,
 ) -> (hir::Pat<'hir>,HirId){
 let hir_id = self.next_id();
 

compiler/rustc_ast_lowering/src/pat.rs

@@ -243,7 +243,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 fnlower_pat_ident(
 &mutself,
 p:&Pat,
-annotation:BindingAnnotation,
+annotation:BindingMode,
 ident:Ident,
 lower_sub:implFnOnce(&mutSelf) -> Option<&'hir hir::Pat<'hir>>,
 ) -> hir::PatKind<'hir>{

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -276,8 +276,8 @@ impl<'a> AstValidator<'a> {
 fncheck_decl_no_pat(decl:&FnDecl,mutreport_err:implFnMut(Span,Option<Ident>,bool)){
 forParam{ pat, .. }in&decl.inputs{
 match pat.kind{
-PatKind::Ident(BindingAnnotation::NONE, _,None) | PatKind::Wild => {}
-PatKind::Ident(BindingAnnotation::MUT, ident,None) => {
+PatKind::Ident(BindingMode::NONE, _,None) | PatKind::Wild => {}
+PatKind::Ident(BindingMode::MUT, ident,None) => {
 report_err(pat.span,Some(ident),true)
 }
  _ => report_err(pat.span,None,false),

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -17,7 +17,7 @@ use rustc_ast::util::classify;
 use rustc_ast::util::comments::{Comment,CommentStyle};
 use rustc_ast::util::parser;
 use rustc_ast::{selfas ast,AttrArgs,AttrArgsEq,BlockCheckMode,PatKind};
-use rustc_ast::{attr,BindingAnnotation,ByRef,DelimArgs,RangeEnd,RangeSyntax,Term};
+use rustc_ast::{attr,BindingMode,ByRef,DelimArgs,RangeEnd,RangeSyntax,Term};
 use rustc_ast::{GenericArg,GenericBound,SelfKind};
 use rustc_ast::{InlineAsmOperand,InlineAsmRegOrRegClass};
 use rustc_ast::{InlineAsmOptions,InlineAsmTemplatePiece};
@@ -1558,7 +1558,7 @@ impl<'a> State<'a> {
 match&pat.kind{
 PatKind::Wild => self.word("_"),
 PatKind::Never => self.word("!"),
-PatKind::Ident(BindingAnnotation(by_ref, mutbl), ident, sub) => {
+PatKind::Ident(BindingMode(by_ref, mutbl), ident, sub) => {
 if mutbl.is_mut(){
 self.word_nbsp("mut");
 }
@@ -1654,7 +1654,7 @@ impl<'a> State<'a> {
 if mutbl.is_mut(){
 self.word("mut ");
 }
-ifletPatKind::Ident(ast::BindingAnnotation::MUT, ..) = inner.kind{
+ifletPatKind::Ident(ast::BindingMode::MUT, ..) = inner.kind{
 self.popen();
 self.print_pat(inner);
 self.pclose();

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -377,7 +377,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 if p.span == self.expr_span{
 self.pat = Some(p);
 }
-iflet hir::PatKind::Binding(hir::BindingAnnotation::NONE, _, i, sub) = p.kind{
+iflet hir::PatKind::Binding(hir::BindingMode::NONE, _, i, sub) = p.kind{
 if i.span == self.expr_span || p.span == self.expr_span{
 self.pat = Some(p);
 }

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -5,7 +5,7 @@ use core::ops::ControlFlow;
 use hir::{ExprKind,Param};
 use rustc_errors::{Applicability,Diag};
 use rustc_hir::intravisit::Visitor;
-use rustc_hir::{selfas hir,BindingAnnotation,ByRef,Node};
+use rustc_hir::{selfas hir,BindingMode,ByRef,Node};
 use rustc_infer::traits;
 use rustc_middle::mir::{Mutability,Place,PlaceRef,ProjectionElem};
 use rustc_middle::ty::{self,InstanceDef,ToPredicate,Ty,TyCtxt};
@@ -303,7 +303,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
 {
 match*decl.local_info(){
 LocalInfo::User(BindingForm::Var(mir::VarBindingForm{
-binding_mode:BindingAnnotation(ByRef::No,Mutability::Not),
+binding_mode:BindingMode(ByRef::No,Mutability::Not),
 opt_ty_info:Some(sp),
 opt_match_place: _,
 pat_span: _,
@@ -398,7 +398,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
 let upvar_hir_id = captured_place.get_root_variable();
 
 ifletNode::Pat(pat) = self.infcx.tcx.hir_node(upvar_hir_id)
- && let hir::PatKind::Binding(hir::BindingAnnotation::NONE, _, upvar_ident, _) =
+ && let hir::PatKind::Binding(hir::BindingMode::NONE, _, upvar_ident, _) =
  pat.kind
 {
 if upvar_ident.name == kw::SelfLower{
@@ -729,7 +729,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
 debug!("local_decl: {:?}", local_decl);
 let pat_span = match*local_decl.local_info(){
 LocalInfo::User(BindingForm::Var(mir::VarBindingForm{
-binding_mode:BindingAnnotation(ByRef::No,Mutability::Not),
+binding_mode:BindingMode(ByRef::No,Mutability::Not),
 opt_ty_info: _,
 opt_match_place: _,
  pat_span,
@@ -1086,7 +1086,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
 }
 
 LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm{
-binding_mode:BindingAnnotation(ByRef::No, _),
+binding_mode:BindingMode(ByRef::No, _),
  opt_ty_info,
  ..
 })) => {
@@ -1154,7 +1154,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
 }
 
 LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm{
-binding_mode:BindingAnnotation(ByRef::Yes(_), _),
+binding_mode:BindingMode(ByRef::Yes(_), _),
  ..
 })) => {
 let pattern_span:Span = local_decl.source_info.span;
@@ -1356,7 +1356,7 @@ pub fn mut_borrow_of_mutable_ref(local_decl: &LocalDecl<'_>, local_name: Option<
 match*local_decl.local_info(){
 // Check if mutably borrowing a mutable reference.
 LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm{
-binding_mode:BindingAnnotation(ByRef::No,Mutability::Not),
+binding_mode:BindingMode(ByRef::No,Mutability::Not),
  ..
 })) => matches!(local_decl.ty.kind(), ty::Ref(_, _, hir::Mutability::Mut)),
 LocalInfo::User(mir::BindingForm::ImplicitSelf(kind)) => {