Migrate rustc_mir_build to use TyCtxt::emit_diag_node_span_lint

compiler/rustc_mir_build/src/builder/mod.rs

@@ -921,7 +921,7 @@ fn find_unreachable_code_from(
                 .as_ref()
                 .unwrap_crate_local()
                 .lint_root;
-            self.tcx.emit_node_span_lint(
+            self.tcx.emit_diag_node_span_lint(
                 lint::builtin::UNREACHABLE_CODE,
                 lint_root,
                 target_loc.span,

compiler/rustc_mir_build/src/check_unsafety.rs

@@ -108,7 +108,7 @@ fn emit_deprecated_safe_fn_call(&self, span: Span, kind: &UnsafeOpKind) -> bool
                     })
                     .unwrap_or_default();
 
-                self.tcx.emit_node_span_lint(
+                self.tcx.emit_diag_node_span_lint(
                     DEPRECATED_SAFE_2024,
                     self.hir_context,
                     span,
@@ -780,7 +780,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
         // FIXME: ideally we would want to trim the def paths, but this is not
         // feasible with the current lint emission API (see issue #106126).
         match self {
-            CallToUnsafeFunction(Some(did)) => tcx.emit_node_span_lint(
+            CallToUnsafeFunction(Some(did)) => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -790,7 +790,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            CallToUnsafeFunction(None) => tcx.emit_node_span_lint(
+            CallToUnsafeFunction(None) => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -799,7 +799,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            UseOfInlineAssembly => tcx.emit_node_span_lint(
+            UseOfInlineAssembly => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -808,7 +808,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            InitializingTypeWith => tcx.emit_node_span_lint(
+            InitializingTypeWith => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -817,7 +817,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            InitializingTypeWithUnsafeField => tcx.emit_node_span_lint(
+            InitializingTypeWithUnsafeField => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -826,7 +826,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            UseOfMutableStatic => tcx.emit_node_span_lint(
+            UseOfMutableStatic => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -835,7 +835,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            UseOfExternStatic => tcx.emit_node_span_lint(
+            UseOfExternStatic => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -844,7 +844,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            UseOfUnsafeField => tcx.emit_node_span_lint(
+            UseOfUnsafeField => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -853,7 +853,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            DerefOfRawPointer => tcx.emit_node_span_lint(
+            DerefOfRawPointer => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -862,7 +862,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            AccessToUnionField => tcx.emit_node_span_lint(
+            AccessToUnionField => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -871,7 +871,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            MutationOfLayoutConstrainedField => tcx.emit_node_span_lint(
+            MutationOfLayoutConstrainedField => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -880,7 +880,7 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            BorrowOfLayoutConstrainedField => tcx.emit_node_span_lint(
+            BorrowOfLayoutConstrainedField => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -889,29 +889,30 @@ fn emit_unsafe_op_in_unsafe_fn_lint(
                     unsafe_not_inherited_note,
                 },
             ),
-            CallToFunctionWith { function, missing, build_enabled } => tcx.emit_node_span_lint(
-                UNSAFE_OP_IN_UNSAFE_FN,
-                hir_id,
-                span,
-                UnsafeOpInUnsafeFnCallToFunctionWithRequiresUnsafe {
+            CallToFunctionWith { function, missing, build_enabled } => tcx
+                .emit_diag_node_span_lint(
+                    UNSAFE_OP_IN_UNSAFE_FN,
+                    hir_id,
                     span,
-                    function: with_no_trimmed_paths!(tcx.def_path_str(*function)),
-                    missing_target_features: DiagArgValue::StrListSepByAnd(
-                        missing.iter().map(|feature| Cow::from(feature.to_string())).collect(),
-                    ),
-                    missing_target_features_count: missing.len(),
-                    note: !build_enabled.is_empty(),
-                    build_target_features: DiagArgValue::StrListSepByAnd(
-                        build_enabled
-                            .iter()
-                            .map(|feature| Cow::from(feature.to_string()))
-                            .collect(),
-                    ),
-                    build_target_features_count: build_enabled.len(),
-                    unsafe_not_inherited_note,
-                },
-            ),
-            UnsafeBinderCast => tcx.emit_node_span_lint(
+                    UnsafeOpInUnsafeFnCallToFunctionWithRequiresUnsafe {
+                        span,
+                        function: with_no_trimmed_paths!(tcx.def_path_str(*function)),
+                        missing_target_features: DiagArgValue::StrListSepByAnd(
+                            missing.iter().map(|feature| Cow::from(feature.to_string())).collect(),
+                        ),
+                        missing_target_features_count: missing.len(),
+                        note: !build_enabled.is_empty(),
+                        build_target_features: DiagArgValue::StrListSepByAnd(
+                            build_enabled
+                                .iter()
+                                .map(|feature| Cow::from(feature.to_string()))
+                                .collect(),
+                        ),
+                        build_target_features_count: build_enabled.len(),
+                        unsafe_not_inherited_note,
+                    },
+                ),
+            UnsafeBinderCast => tcx.emit_diag_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
                 span,
@@ -1200,7 +1201,7 @@ pub(crate) fn check_unsafety(tcx: TyCtxt<'_>, def: LocalDefId) {
     warnings.sort_by_key(|w| w.block_span);
     for UnusedUnsafeWarning { hir_id, block_span, enclosing_unsafe } in warnings {
         let block_span = tcx.sess.source_map().guess_head_span(block_span);
-        tcx.emit_node_span_lint(
+        tcx.emit_diag_node_span_lint(
             UNUSED_UNSAFE,
             hir_id,
             block_span,

compiler/rustc_mir_build/src/errors.rs

@@ -3,13 +3,13 @@
     Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level,
     MultiSpan, Subdiagnostic, msg,
 };
-use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
+use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_middle::ty::{self, Ty};
 use rustc_pattern_analysis::errors::Uncovered;
 use rustc_pattern_analysis::rustc::RustcPatCtxt;
 use rustc_span::{Ident, Span, Symbol};
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("call to deprecated safe function `{$function}` is unsafe and requires unsafe block")]
 pub(crate) struct CallToDeprecatedSafeFnRequiresUnsafe {
     #[label("call to unsafe function")]
@@ -35,7 +35,7 @@ pub(crate) struct CallToDeprecatedSafeFnRequiresUnsafeSub {
     pub(crate) right: Span,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("call to unsafe function `{$function}` is unsafe and requires unsafe block", code = E0133)]
 #[note("consult the function's documentation for information on how to avoid undefined behavior")]
 pub(crate) struct UnsafeOpInUnsafeFnCallToUnsafeFunctionRequiresUnsafe {
@@ -46,7 +46,7 @@ pub(crate) struct UnsafeOpInUnsafeFnCallToUnsafeFunctionRequiresUnsafe {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("call to unsafe function is unsafe and requires unsafe block", code = E0133)]
 #[note("consult the function's documentation for information on how to avoid undefined behavior")]
 pub(crate) struct UnsafeOpInUnsafeFnCallToUnsafeFunctionRequiresUnsafeNameless {
@@ -56,7 +56,7 @@ pub(crate) struct UnsafeOpInUnsafeFnCallToUnsafeFunctionRequiresUnsafeNameless {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("use of inline assembly is unsafe and requires unsafe block", code = E0133)]
 #[note("inline assembly is entirely unchecked and can cause undefined behavior")]
 pub(crate) struct UnsafeOpInUnsafeFnUseOfInlineAssemblyRequiresUnsafe {
@@ -66,7 +66,7 @@ pub(crate) struct UnsafeOpInUnsafeFnUseOfInlineAssemblyRequiresUnsafe {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe block", code = E0133)]
 #[note(
     "initializing a layout restricted type's field with a value outside the valid range is undefined behavior"
@@ -78,7 +78,7 @@ pub(crate) struct UnsafeOpInUnsafeFnInitializingTypeWithRequiresUnsafe {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("initializing type with an unsafe field is unsafe and requires unsafe block", code = E0133)]
 #[note("unsafe fields may carry library invariants")]
 pub(crate) struct UnsafeOpInUnsafeFnInitializingTypeWithUnsafeFieldRequiresUnsafe {
@@ -88,7 +88,7 @@ pub(crate) struct UnsafeOpInUnsafeFnInitializingTypeWithUnsafeFieldRequiresUnsaf
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("use of mutable static is unsafe and requires unsafe block", code = E0133)]
 #[note(
     "mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior"
@@ -100,7 +100,7 @@ pub(crate) struct UnsafeOpInUnsafeFnUseOfMutableStaticRequiresUnsafe {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("use of extern static is unsafe and requires unsafe block", code = E0133)]
 #[note(
     "extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior"
@@ -112,7 +112,7 @@ pub(crate) struct UnsafeOpInUnsafeFnUseOfExternStaticRequiresUnsafe {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("use of unsafe field is unsafe and requires unsafe block", code = E0133)]
 #[note("unsafe fields may carry library invariants")]
 pub(crate) struct UnsafeOpInUnsafeFnUseOfUnsafeFieldRequiresUnsafe {
@@ -122,7 +122,7 @@ pub(crate) struct UnsafeOpInUnsafeFnUseOfUnsafeFieldRequiresUnsafe {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("dereference of raw pointer is unsafe and requires unsafe block", code = E0133)]
 #[note(
     "raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior"
@@ -134,7 +134,7 @@ pub(crate) struct UnsafeOpInUnsafeFnDerefOfRawPointerRequiresUnsafe {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("access to union field is unsafe and requires unsafe block", code = E0133)]
 #[note(
     "the field may not be properly initialized: using uninitialized data will cause undefined behavior"
@@ -146,7 +146,7 @@ pub(crate) struct UnsafeOpInUnsafeFnAccessToUnionFieldRequiresUnsafe {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag(
     "mutation of layout constrained field is unsafe and requires unsafe block",
     code = E0133
@@ -159,7 +159,7 @@ pub(crate) struct UnsafeOpInUnsafeFnMutationOfLayoutConstrainedFieldRequiresUnsa
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag(
     "borrow of layout constrained field with interior mutability is unsafe and requires unsafe block",
     code = E0133,
@@ -171,7 +171,7 @@ pub(crate) struct UnsafeOpInUnsafeFnBorrowOfLayoutConstrainedFieldRequiresUnsafe
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag(
     "unsafe binder cast is unsafe and requires unsafe block information that may be required to uphold safety guarantees of a type",
     code = E0133,
@@ -183,7 +183,7 @@ pub(crate) struct UnsafeOpInUnsafeFnUnsafeBinderCastRequiresUnsafe {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("call to function `{$function}` with `#[target_feature]` is unsafe and requires unsafe block", code = E0133)]
 #[help(
     "in order for the call to be safe, the context requires the following additional target {$missing_target_features_count ->
@@ -631,7 +631,7 @@ fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
     }
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("unnecessary `unsafe` block")]
 pub(crate) struct UnusedUnsafe {
     #[label("unnecessary `unsafe` block")]
@@ -755,7 +755,7 @@ pub(crate) struct NonConstPath {
     pub(crate) span: Span,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("unreachable pattern")]
 pub(crate) struct UnreachablePattern<'tcx> {
     #[label("no value can reach this")]
@@ -809,7 +809,7 @@ pub(crate) struct WantedConstant {
     pub(crate) const_path: String,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("unreachable {$descr}")]
 pub(crate) struct UnreachableDueToUninhabited<'desc, 'tcx> {
     pub descr: &'desc str,
@@ -874,7 +874,7 @@ pub(crate) struct UpperRangeBoundCannotBeMin {
     pub(crate) span: Span,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("pattern binding `{$name}` is named the same as one of the variants of the type `{$ty_path}`", code = E0170)]
 pub(crate) struct BindingsWithVariantName {
     #[suggestion(
@@ -887,7 +887,7 @@ pub(crate) struct BindingsWithVariantName {
     pub(crate) name: Ident,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag(
     "irrefutable `if let` {$count ->
     [one] pattern
@@ -905,7 +905,7 @@ pub(crate) struct IrrefutableLetPatternsIfLet {
     pub(crate) count: usize,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag(
     "irrefutable `if let` guard {$count ->
     [one] pattern
@@ -923,7 +923,7 @@ pub(crate) struct IrrefutableLetPatternsIfLetGuard {
     pub(crate) count: usize,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag(
     "irrefutable `let...else` {$count ->
     [one] pattern
@@ -941,7 +941,7 @@ pub(crate) struct IrrefutableLetPatternsLetElse {
     pub(crate) count: usize,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag(
     "irrefutable `while let` {$count ->
     [one] pattern

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -797,7 +797,7 @@ fn check_for_bindings_named_same_as_variants(
     {
         let variant_count = edef.variants().len();
         let ty_path = with_no_trimmed_paths!(cx.tcx.def_path_str(edef.did()));
-        cx.tcx.emit_node_span_lint(
+        cx.tcx.emit_diag_node_span_lint(
             BINDINGS_WITH_VARIANT_NAME,
             cx.hir_source,
             pat.span,
@@ -839,7 +839,7 @@ fn report_irrefutable_let_patterns(
 ) {
     macro_rules! emit_diag {
         ($lint:tt) => {{
-            tcx.emit_node_span_lint(IRREFUTABLE_LET_PATTERNS, id, span, $lint { count });
+            tcx.emit_diag_node_span_lint(IRREFUTABLE_LET_PATTERNS, id, span, $lint { count });
         }};
     }
 
@@ -924,7 +924,7 @@ fn report_unreachable_pattern<'p, 'tcx>(
             lint.covered_by_many = Some(multispan);
         }
     }
-    cx.tcx.emit_node_span_lint(UNREACHABLE_PATTERNS, hir_id, pat_span, lint);
+    cx.tcx.emit_diag_node_span_lint(UNREACHABLE_PATTERNS, hir_id, pat_span, lint);
 }
 
 /// Detect typos that were meant to be a `const` but were interpreted as a new pattern binding.

tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr

@@ -79,7 +79,6 @@ error[E0133]: call to function `sse2` with `#[target_feature]` is unsafe and req
 LL |     sse2();
    |     ^^^^^^ call to function with `#[target_feature]`
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = help: in order for the call to be safe, the context requires the following additional target feature: sse2
    = note: the sse2 target feature being enabled in the build configuration does not remove the requirement to list it in `#[target_feature]`
 note: an unsafe function restricts its caller, but its body is safe by default
@@ -87,6 +86,7 @@ note: an unsafe function restricts its caller, but its body is safe by default
    |
 LL | unsafe fn needs_unsafe_block() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 note: the lint level is defined here
   --> $DIR/safe-calls.rs:65:8
    |

tests/ui/rust-2024/unsafe-env.e2021.stderr

@@ -4,13 +4,13 @@ error[E0133]: call to unsafe function `unsafe_fn` is unsafe and requires unsafe
 LL |         unsafe_fn();
    |         ^^^^^^^^^^^ call to unsafe function
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
 note: an unsafe function restricts its caller, but its body is safe by default
   --> $DIR/unsafe-env.rs:8:1
    |
 LL | unsafe fn unsafe_fn() {
    | ^^^^^^^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 note: the lint level is defined here
   --> $DIR/unsafe-env.rs:7:8
    |

tests/ui/rust-2024/unsafe-env.e2024.stderr

@@ -4,13 +4,13 @@ error[E0133]: call to unsafe function `std::env::set_var` is unsafe and requires
 LL |     env::set_var("FOO", "BAR");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
 note: an unsafe function restricts its caller, but its body is safe by default
   --> $DIR/unsafe-env.rs:8:1
    |
 LL | unsafe fn unsafe_fn() {
    | ^^^^^^^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 note: the lint level is defined here
   --> $DIR/unsafe-env.rs:7:8
    |
@@ -23,8 +23,8 @@ error[E0133]: call to unsafe function `std::env::remove_var` is unsafe and requi
 LL |     env::remove_var("FOO");
    |     ^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 
 error[E0133]: call to unsafe function `unsafe_fn` is unsafe and requires unsafe block
   --> $DIR/unsafe-env.rs:14:9
@@ -32,8 +32,8 @@ error[E0133]: call to unsafe function `unsafe_fn` is unsafe and requires unsafe
 LL |         unsafe_fn();
    |         ^^^^^^^^^^^ call to unsafe function
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 
 error[E0133]: call to unsafe function `set_var` is unsafe and requires unsafe block
   --> $DIR/unsafe-env.rs:22:5

tests/ui/unsafe/edition-2024-unsafe_op_in_unsafe_fn.stderr

@@ -4,13 +4,13 @@ warning[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe blo
 LL |     unsf();
    |     ^^^^^^ call to unsafe function
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
 note: an unsafe function restricts its caller, but its body is safe by default
   --> $DIR/edition-2024-unsafe_op_in_unsafe_fn.rs:8:1
    |
 LL | unsafe fn foo() {
    | ^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: `#[warn(unsafe_op_in_unsafe_fn)]` (part of `#[warn(rust_2024_compatibility)]`) on by default
 
 warning: 1 warning emitted

tests/ui/unsafe/unsafe_op_in_unsafe_fn/edition_2024_default.stderr

@@ -4,13 +4,13 @@ warning[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe blo
 LL |     unsf();
    |     ^^^^^^ call to unsafe function
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
 note: an unsafe function restricts its caller, but its body is safe by default
   --> $DIR/edition_2024_default.rs:11:1
    |
 LL | unsafe fn foo() {
    | ^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: `#[warn(unsafe_op_in_unsafe_fn)]` (part of `#[warn(rust_2024_compatibility)]`) on by default
 
 warning: 1 warning emitted

tests/ui/unsafe/unsafe_op_in_unsafe_fn/in_2024_compatibility.stderr

@@ -4,13 +4,13 @@ error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
 LL |     unsf();
    |     ^^^^^^ call to unsafe function
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
 note: an unsafe function restricts its caller, but its body is safe by default
   --> $DIR/in_2024_compatibility.rs:6:1
    |
 LL | unsafe fn foo() {
    | ^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 note: the lint level is defined here
   --> $DIR/in_2024_compatibility.rs:1:9
    |

tests/ui/unsafe/unsafe_op_in_unsafe_fn/rfc-2585-unsafe_op_in_unsafe_fn.stderr

@@ -4,13 +4,13 @@ error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
 LL |     unsf();
    |     ^^^^^^ call to unsafe function
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
 note: an unsafe function restricts its caller, but its body is safe by default
   --> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:8:1
    |
 LL | unsafe fn deny_level() {
    | ^^^^^^^^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 note: the lint level is defined here
   --> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:1:9
    |
@@ -23,8 +23,8 @@ error[E0133]: dereference of raw pointer is unsafe and requires unsafe block
 LL |     *PTR;
    |     ^^^^ dereference of raw pointer
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 
 error[E0133]: use of mutable static is unsafe and requires unsafe block
   --> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:13:5
@@ -32,8 +32,8 @@ error[E0133]: use of mutable static is unsafe and requires unsafe block
 LL |     VOID = ();
    |     ^^^^ use of mutable static
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 
 error: unnecessary `unsafe` block
   --> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:16:5
@@ -53,13 +53,13 @@ error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
 LL |     unsf();
    |     ^^^^^^ call to unsafe function
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
 note: an unsafe function restricts its caller, but its body is safe by default
   --> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:23:1
    |
 LL | unsafe fn warning_level() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 note: the lint level is defined here
   --> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:22:8
    |
@@ -73,8 +73,8 @@ error[E0133]: dereference of raw pointer is unsafe and requires unsafe block
 LL |     *PTR;
    |     ^^^^ dereference of raw pointer
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 
 error[E0133]: use of mutable static is unsafe and requires unsafe block
   --> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:28:5
@@ -82,8 +82,8 @@ error[E0133]: use of mutable static is unsafe and requires unsafe block
 LL |     VOID = ();
    |     ^^^^ use of mutable static
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 
 error: unnecessary `unsafe` block
   --> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:30:5

tests/ui/unsafe/unsafe_op_in_unsafe_fn/wrapping-unsafe-block-sugg.stderr

@@ -4,13 +4,13 @@ error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
 LL |     unsf();
    |     ^^^^^^ call to unsafe function
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
 note: an unsafe function restricts its caller, but its body is safe by default
   --> $DIR/wrapping-unsafe-block-sugg.rs:11:1
    |
 LL | pub unsafe fn foo() {
    | ^^^^^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 note: the lint level is defined here
   --> $DIR/wrapping-unsafe-block-sugg.rs:4:9
    |
@@ -23,8 +23,8 @@ error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
 LL |     unsf();
    |     ^^^^^^ call to unsafe function
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 
 error[E0133]: dereference of raw pointer is unsafe and requires unsafe block
   --> $DIR/wrapping-unsafe-block-sugg.rs:25:13
@@ -32,13 +32,13 @@ error[E0133]: dereference of raw pointer is unsafe and requires unsafe block
 LL |     let y = *x;
    |             ^^ dereference of raw pointer
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
 note: an unsafe function restricts its caller, but its body is safe by default
   --> $DIR/wrapping-unsafe-block-sugg.rs:23:1
    |
 LL | pub unsafe fn bar(x: *const i32) -> i32 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 
 error[E0133]: dereference of raw pointer is unsafe and requires unsafe block
   --> $DIR/wrapping-unsafe-block-sugg.rs:29:9
@@ -46,8 +46,8 @@ error[E0133]: dereference of raw pointer is unsafe and requires unsafe block
 LL |     y + *x
    |         ^^ dereference of raw pointer
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 
 error[E0133]: use of mutable static is unsafe and requires unsafe block
   --> $DIR/wrapping-unsafe-block-sugg.rs:38:13
@@ -55,13 +55,13 @@ error[E0133]: use of mutable static is unsafe and requires unsafe block
 LL |     let y = BAZ;
    |             ^^^ use of mutable static
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
 note: an unsafe function restricts its caller, but its body is safe by default
   --> $DIR/wrapping-unsafe-block-sugg.rs:36:1
    |
 LL | pub unsafe fn baz() -> i32 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 
 error[E0133]: use of mutable static is unsafe and requires unsafe block
   --> $DIR/wrapping-unsafe-block-sugg.rs:42:9
@@ -69,8 +69,8 @@ error[E0133]: use of mutable static is unsafe and requires unsafe block
 LL |     y + BAZ
    |         ^^^ use of mutable static
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
 
 error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
   --> $DIR/wrapping-unsafe-block-sugg.rs:48:36
@@ -81,13 +81,13 @@ LL | macro_rules! unsafe_macro { () => (unsf()) }
 LL |     unsafe_macro!();
    |     --------------- in this macro invocation
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
 note: an unsafe function restricts its caller, but its body is safe by default
   --> $DIR/wrapping-unsafe-block-sugg.rs:58:1
    |
 LL | pub unsafe fn unsafe_in_macro() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: this error originates in the macro `unsafe_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
@@ -99,8 +99,8 @@ LL | macro_rules! unsafe_macro { () => (unsf()) }
 LL |     unsafe_macro!();
    |     --------------- in this macro invocation
    |
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: consult the function's documentation for information on how to avoid undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
    = note: this error originates in the macro `unsafe_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 8 previous errors