Auto merge of #153059 - GuillaumeGomez:rollup-bobduJ9, r=GuillaumeGomez

Rollup of 8 pull requests

Successful merges:

 - #149169 (ptr::replace: make calls on ZST null ptr not UB)
 - #150562 (Fix doc link used in suggestion for pinning self)
 - #152679 (rustc_expand: improve diagnostics for non-repeatable metavars)
 - #153017 (Implement debuginfo for unsafe binder types)
 - #152868 (delete some very old trivial `Box` tests)
 - #152922 (rustc_public: Make fields that shouldn't be exposed visible only in `rustc_public`)
 - #153029 (Rename `rustc::pass_by_value` lint as `rustc::disallowed_pass_by_ref`.)
 - #153051 (Migration of `LintDiagnostic` - part 3)

Author: bors

compiler/rustc_ast/src/visit.rs

@@ -757,9 +757,11 @@ macro_rules! common_visitor_and_walkers {
             ) -> V::Result;
         }
 
-        // this is only used by the MutVisitor. We include this symmetry here to make writing other functions easier
+        // This is only used by the MutVisitor. We include this symmetry here to make writing other
+        // functions easier.
         $(${ignore($lt)}
-            #[expect(unused, rustc::pass_by_value)]
+            #[cfg_attr(not(bootstrap), expect(unused, rustc::disallowed_pass_by_ref))]
+            #[cfg_attr(bootstrap, expect(unused, rustc::pass_by_value))]
             #[inline]
         )?
         fn visit_span<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, span: &$($lt)? $($mut)? Span) -> V::Result {

compiler/rustc_borrowck/src/lib.rs

@@ -2698,12 +2698,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
 
             let mut_span = tcx.sess.source_map().span_until_non_whitespace(span);
 
-            tcx.emit_diag_node_span_lint(
-                UNUSED_MUT,
-                lint_root,
-                span,
-                VarNeedNotMut { span: mut_span },
-            )
+            tcx.emit_node_span_lint(UNUSED_MUT, lint_root, span, VarNeedNotMut { span: mut_span })
         }
     }
 }

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -480,8 +480,7 @@ pub(crate) fn spanned_type_di_node<'ll, 'tcx>(
         },
         ty::Tuple(_) => build_tuple_type_di_node(cx, unique_type_id),
         ty::Pat(base, _) => return type_di_node(cx, base),
-        // FIXME(unsafe_binders): impl debug info
-        ty::UnsafeBinder(_) => unimplemented!(),
+        ty::UnsafeBinder(_) => build_unsafe_binder_type_di_node(cx, t, unique_type_id),
         ty::Alias(..)
         | ty::Param(_)
         | ty::Bound(..)
@@ -1488,6 +1487,56 @@ fn build_vtable_type_di_node<'ll, 'tcx>(
     .di_node
 }
 
+/// Creates the debuginfo node for `unsafe<'a> T` binder types.
+///
+/// We treat an unsafe binder like a struct with a single field named `inner`
+/// rather than delegating to the inner type's DI node directly. This way the
+/// debugger shows the binder's own type name, and the wrapped value is still
+/// accessible through the `inner` field.
+fn build_unsafe_binder_type_di_node<'ll, 'tcx>(
+    cx: &CodegenCx<'ll, 'tcx>,
+    binder_type: Ty<'tcx>,
+    unique_type_id: UniqueTypeId<'tcx>,
+) -> DINodeCreationResult<'ll> {
+    let ty::UnsafeBinder(inner) = binder_type.kind() else {
+        bug!(
+            "Only ty::UnsafeBinder is valid for build_unsafe_binder_type_di_node. Found {:?} instead.",
+            binder_type
+        )
+    };
+    let inner_type = inner.skip_binder();
+    let inner_type_di_node = type_di_node(cx, inner_type);
+
+    let type_name = compute_debuginfo_type_name(cx.tcx, binder_type, true);
+    type_map::build_type_with_children(
+        cx,
+        type_map::stub(
+            cx,
+            Stub::Struct,
+            unique_type_id,
+            &type_name,
+            None,
+            cx.size_and_align_of(binder_type),
+            NO_SCOPE_METADATA,
+            DIFlags::FlagZero,
+        ),
+        |cx, unsafe_binder_type_di_node| {
+            let inner_layout = cx.layout_of(inner_type);
+            smallvec![build_field_di_node(
+                cx,
+                unsafe_binder_type_di_node,
+                "inner",
+                inner_layout,
+                Size::ZERO,
+                DIFlags::FlagZero,
+                inner_type_di_node,
+                None,
+            )]
+        },
+        NO_GENERICS,
+    )
+}
+
 /// Get the global variable for the vtable.
 ///
 /// When using global variables, we may have created an addrspacecast to get a pointer to the

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -430,7 +430,19 @@ fn push_debuginfo_type_name<'tcx>(
                 push_closure_or_coroutine_name(tcx, def_id, args, qualified, output, visited);
             }
         }
-        ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binders)"),
+        ty::UnsafeBinder(inner) => {
+            if cpp_like_debuginfo {
+                output.push_str("unsafe$<");
+            } else {
+                output.push_str("unsafe ");
+            }
+
+            push_debuginfo_type_name(tcx, inner.skip_binder(), qualified, output, visited);
+
+            if cpp_like_debuginfo {
+                push_close_angle_bracket(cpp_like_debuginfo, output);
+            }
+        }
         ty::Param(_)
         | ty::Error(_)
         | ty::Infer(_)

compiler/rustc_codegen_ssa/src/target_features.rs

@@ -75,7 +75,7 @@ pub(crate) fn from_target_feature_attr(
                         // For "neon" specifically, we emit an FCW instead of a hard error.
                         // See <https://github.com/rust-lang/rust/issues/134375>.
                         if tcx.sess.target.arch == Arch::AArch64 && name.as_str() == "neon" {
-                            tcx.emit_diag_node_span_lint(
+                            tcx.emit_node_span_lint(
                                 AARCH64_SOFTFLOAT_NEON,
                                 tcx.local_def_id_to_hir_id(did),
                                 feature_span,

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -256,5 +256,5 @@ pub(super) fn lint<'tcx, L>(
 {
     let (span, frames) = get_span_and_frames(tcx, &machine.stack);
 
-    tcx.emit_diag_node_span_lint(lint, machine.best_lint_scope(*tcx), span, decorator(frames));
+    tcx.emit_node_span_lint(lint, machine.best_lint_scope(*tcx), span, decorator(frames));
 }

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -718,7 +718,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                     .level
                     .is_error();
                 let span = ecx.cur_span();
-                ecx.tcx.emit_diag_node_span_lint(
+                ecx.tcx.emit_node_span_lint(
                     rustc_session::lint::builtin::LONG_RUNNING_CONST_EVAL,
                     hir_id,
                     span,

compiler/rustc_expand/src/base.rs

@@ -277,7 +277,16 @@ impl<'cx> MacroExpanderResult<'cx> {
         // Emit the SEMICOLON_IN_EXPRESSIONS_FROM_MACROS deprecation lint.
         let is_local = true;
 
-        let parser = ParserAnyMacro::from_tts(cx, tts, site_span, arm_span, is_local, macro_ident);
+        let parser = ParserAnyMacro::from_tts(
+            cx,
+            tts,
+            site_span,
+            arm_span,
+            is_local,
+            macro_ident,
+            vec![],
+            vec![],
+        );
         ExpandResult::Ready(Box::new(parser))
     }
 }

compiler/rustc_expand/src/mbe/diagnostics.rs

@@ -222,11 +222,13 @@ impl<'dcx> CollectTrackerAndEmitter<'dcx, '_> {
 
 pub(super) fn emit_frag_parse_err(
     mut e: Diag<'_>,
-    parser: &Parser<'_>,
+    parser: &mut Parser<'_>,
     orig_parser: &mut Parser<'_>,
     site_span: Span,
     arm_span: Span,
     kind: AstFragmentKind,
+    bindings: Vec<Ident>,
+    matched_rule_bindings: Vec<Ident>,
 ) -> ErrorGuaranteed {
     // FIXME(davidtwco): avoid depending on the error message text
     if parser.token == token::Eof
@@ -285,6 +287,54 @@ pub(super) fn emit_frag_parse_err(
         },
         _ => annotate_err_with_kind(&mut e, kind, site_span),
     };
+
+    let matched_rule_bindings_names: Vec<_> =
+        matched_rule_bindings.iter().map(|bind| bind.name).collect();
+    let bindings_name: Vec<_> = bindings.iter().map(|bind| bind.name).collect();
+    if parser.token.kind == token::Dollar {
+        parser.bump();
+        if let token::Ident(name, _) = parser.token.kind {
+            if let Some(matched_name) = rustc_span::edit_distance::find_best_match_for_name(
+                &matched_rule_bindings_names[..],
+                name,
+                None,
+            ) {
+                e.span_suggestion_verbose(
+                    parser.token.span,
+                    "there is a macro metavariable with similar name",
+                    format!("{matched_name}"),
+                    Applicability::MaybeIncorrect,
+                );
+            } else if bindings_name.contains(&name) {
+                e.span_label(
+                    parser.token.span,
+                    format!(
+                        "there is an macro metavariable with this name in another macro matcher"
+                    ),
+                );
+            } else if let Some(matched_name) =
+                rustc_span::edit_distance::find_best_match_for_name(&bindings_name[..], name, None)
+            {
+                e.span_suggestion_verbose(
+                    parser.token.span,
+                    "there is a macro metavariable with a similar name in another macro matcher",
+                    format!("{matched_name}"),
+                    Applicability::MaybeIncorrect,
+                );
+            } else {
+                let msg = matched_rule_bindings_names
+                    .iter()
+                    .map(|sym| format!("${}", sym))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+
+                e.span_label(parser.token.span, format!("macro metavariable not found"));
+                if !matched_rule_bindings_names.is_empty() {
+                    e.note(format!("available metavariable names are: {msg}"));
+                }
+            }
+        }
+    }
     e.emit()
 }
 

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -55,6 +55,8 @@ pub(crate) struct ParserAnyMacro<'a> {
     arm_span: Span,
     /// Whether or not this macro is defined in the current crate
     is_local: bool,
+    bindings: Vec<Ident>,
+    matched_rule_bindings: Vec<Ident>,
 }
 
 impl<'a> ParserAnyMacro<'a> {
@@ -67,13 +69,22 @@ impl<'a> ParserAnyMacro<'a> {
             arm_span,
             is_trailing_mac,
             is_local,
+            bindings,
+            matched_rule_bindings,
         } = *self;
         let snapshot = &mut parser.create_snapshot_for_diagnostic();
         let fragment = match parse_ast_fragment(parser, kind) {
             Ok(f) => f,
             Err(err) => {
                 let guar = diagnostics::emit_frag_parse_err(
-                    err, parser, snapshot, site_span, arm_span, kind,
+                    err,
+                    parser,
+                    snapshot,
+                    site_span,
+                    arm_span,
+                    kind,
+                    bindings,
+                    matched_rule_bindings,
                 );
                 return kind.dummy(site_span, guar);
             }
@@ -108,6 +119,9 @@ impl<'a> ParserAnyMacro<'a> {
         arm_span: Span,
         is_local: bool,
         macro_ident: Ident,
+        // bindings and lhs is for diagnostics
+        bindings: Vec<Ident>,
+        matched_rule_bindings: Vec<Ident>,
     ) -> Self {
         Self {
             parser: Parser::new(&cx.sess.psess, tts, None),
@@ -121,6 +135,8 @@ impl<'a> ParserAnyMacro<'a> {
             is_trailing_mac: cx.current_expansion.is_trailing_mac,
             arm_span,
             is_local,
+            bindings,
+            matched_rule_bindings,
         }
     }
 }
@@ -359,7 +375,7 @@ fn expand_macro<'cx>(
 
     match try_success_result {
         Ok((rule_index, rule, named_matches)) => {
-            let MacroRule::Func { rhs, .. } = rule else {
+            let MacroRule::Func { lhs, rhs, .. } = rule else {
                 panic!("try_match_macro returned non-func rule");
             };
             let mbe::TokenTree::Delimited(rhs_span, _, rhs) = rhs else {
@@ -387,8 +403,32 @@ fn expand_macro<'cx>(
                 cx.resolver.record_macro_rule_usage(node_id, rule_index);
             }
 
+            let mut bindings = vec![];
+            for rule in rules {
+                let MacroRule::Func { lhs, .. } = rule else { continue };
+                for param in lhs {
+                    let MatcherLoc::MetaVarDecl { bind, .. } = param else { continue };
+                    bindings.push(*bind);
+                }
+            }
+
+            let mut matched_rule_bindings = vec![];
+            for param in lhs {
+                let MatcherLoc::MetaVarDecl { bind, .. } = param else { continue };
+                matched_rule_bindings.push(*bind);
+            }
+
             // Let the context choose how to interpret the result. Weird, but useful for X-macros.
-            Box::new(ParserAnyMacro::from_tts(cx, tts, sp, arm_span, is_local, name))
+            Box::new(ParserAnyMacro::from_tts(
+                cx,
+                tts,
+                sp,
+                arm_span,
+                is_local,
+                name,
+                bindings,
+                matched_rule_bindings,
+            ))
         }
         Err(CanRetry::No(guar)) => {
             debug!("Will not retry matching as an error was emitted already");