From d926c1b06e885db77fa96881b7ef53d8aef33ffe Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Tue, 24 Feb 2026 11:59:19 +0100 Subject: [PATCH] Migrate `rustc_mir_build` to use `TyCtxt::emit_diag_node_span_lint` --- compiler/rustc_mir_build/src/builder/mod.rs | 2 +- .../rustc_mir_build/src/check_unsafety.rs | 73 ++++++++++--------- compiler/rustc_mir_build/src/errors.rs | 48 ++++++------ .../src/thir/pattern/check_match.rs | 6 +- .../safe-calls.stderr | 2 +- tests/ui/rust-2024/unsafe-env.e2021.stderr | 2 +- tests/ui/rust-2024/unsafe-env.e2024.stderr | 6 +- ...edition-2024-unsafe_op_in_unsafe_fn.stderr | 2 +- .../edition_2024_default.stderr | 2 +- .../in_2024_compatibility.stderr | 2 +- .../rfc-2585-unsafe_op_in_unsafe_fn.stderr | 12 +-- .../wrapping-unsafe-block-sugg.stderr | 16 ++-- 12 files changed, 87 insertions(+), 86 deletions(-) diff --git a/compiler/rustc_mir_build/src/builder/mod.rs b/compiler/rustc_mir_build/src/builder/mod.rs index c8ca7bfccc07..383581157174 100644 --- a/compiler/rustc_mir_build/src/builder/mod.rs +++ b/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, diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs index 24c85b7ec3f5..e3fa4802518a 100644 --- a/compiler/rustc_mir_build/src/check_unsafety.rs +++ b/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, diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs index 5a93c7cbdc7a..fead221b9a0c 100644 --- a/compiler/rustc_mir_build/src/errors.rs +++ b/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, } -#[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, } -#[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, } -#[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, } -#[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, } -#[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, } -#[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, } -#[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, } -#[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, } -#[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, } -#[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, } -#[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, } -#[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, } -#[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(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 diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs index 9231b425c4c3..5ebfd8000ef8 100644 --- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs +++ b/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. diff --git a/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr b/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr index e16841b369db..43cb9eb12e17 100644 --- a/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr +++ b/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 = 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 note: the lint level is defined here --> $DIR/safe-calls.rs:65:8 | diff --git a/tests/ui/rust-2024/unsafe-env.e2021.stderr b/tests/ui/rust-2024/unsafe-env.e2021.stderr index a73db9fd60c7..fc3279af43bb 100644 --- a/tests/ui/rust-2024/unsafe-env.e2021.stderr +++ b/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 = 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 note: the lint level is defined here --> $DIR/unsafe-env.rs:7:8 | diff --git a/tests/ui/rust-2024/unsafe-env.e2024.stderr b/tests/ui/rust-2024/unsafe-env.e2024.stderr index cb48ae231f27..0473e9a2c4ae 100644 --- a/tests/ui/rust-2024/unsafe-env.e2024.stderr +++ b/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 = 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 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 = note: consult the function's documentation for information on how to avoid undefined behavior + = note: for more information, see 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 = note: consult the function's documentation for information on how to avoid undefined behavior + = note: for more information, see error[E0133]: call to unsafe function `set_var` is unsafe and requires unsafe block --> $DIR/unsafe-env.rs:22:5 diff --git a/tests/ui/unsafe/edition-2024-unsafe_op_in_unsafe_fn.stderr b/tests/ui/unsafe/edition-2024-unsafe_op_in_unsafe_fn.stderr index b6804511ac23..01189f15c3fe 100644 --- a/tests/ui/unsafe/edition-2024-unsafe_op_in_unsafe_fn.stderr +++ b/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 = 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 = note: `#[warn(unsafe_op_in_unsafe_fn)]` (part of `#[warn(rust_2024_compatibility)]`) on by default warning: 1 warning emitted diff --git a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/edition_2024_default.stderr b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/edition_2024_default.stderr index 35f9d3a4ebc4..23cb42013633 100644 --- a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/edition_2024_default.stderr +++ b/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 = 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 = note: `#[warn(unsafe_op_in_unsafe_fn)]` (part of `#[warn(rust_2024_compatibility)]`) on by default warning: 1 warning emitted diff --git a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/in_2024_compatibility.stderr b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/in_2024_compatibility.stderr index 0c4070068d0b..d9d42695d5b3 100644 --- a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/in_2024_compatibility.stderr +++ b/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 = 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 note: the lint level is defined here --> $DIR/in_2024_compatibility.rs:1:9 | diff --git a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/rfc-2585-unsafe_op_in_unsafe_fn.stderr b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/rfc-2585-unsafe_op_in_unsafe_fn.stderr index 3e43840cf6cb..5ba70b882f81 100644 --- a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/rfc-2585-unsafe_op_in_unsafe_fn.stderr +++ b/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 = 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 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 = 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 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 = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior + = note: for more information, see 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 = 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 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 = 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 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 = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior + = note: for more information, see error: unnecessary `unsafe` block --> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:30:5 diff --git a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/wrapping-unsafe-block-sugg.stderr b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/wrapping-unsafe-block-sugg.stderr index f7dbf39e6f26..3308a0807db6 100644 --- a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/wrapping-unsafe-block-sugg.stderr +++ b/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 = 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 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 = note: consult the function's documentation for information on how to avoid undefined behavior + = note: for more information, see 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 = 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 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 = 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 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 = 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 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 = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior + = note: for more information, see 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 = 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 = 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 = note: consult the function's documentation for information on how to avoid undefined behavior + = note: for more information, see = 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