bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rename cast_ref_to_mut lint to invalid_reference_casting

Browse source
This commit is contained in:
Urgau 2023-07-06 21:45:24 +02:00
parent a161ab00db
commit 3dbbf23e29
9 changed files with 28 additions and 28 deletions
Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_lint/messages.ftl
View file

@ -155,8 +155,6 @@ lint_builtin_unused_doc_comment = unused doc comment
lint_builtin_while_true = denote infinite loops with `loop {"{"} ... {"}"}` lint_builtin_while_true = denote infinite loops with `loop {"{"} ... {"}"}`
.suggestion = use `loop` .suggestion = use `loop`
lint_cast_ref_to_mut = casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
lint_check_name_deprecated = lint name `{$lint_name}` is deprecated and does not have an effect anymore. Use: {$new_name} lint_check_name_deprecated = lint name `{$lint_name}` is deprecated and does not have an effect anymore. Use: {$new_name}
lint_check_name_unknown = unknown lint: `{$lint_name}` lint_check_name_unknown = unknown lint: `{$lint_name}`
@ -322,6 +320,8 @@ lint_invalid_nan_comparisons_eq_ne = incorrect NaN comparison, NaN cannot be dir
lint_invalid_nan_comparisons_lt_le_gt_ge = incorrect NaN comparison, NaN is not orderable lint_invalid_nan_comparisons_lt_le_gt_ge = incorrect NaN comparison, NaN is not orderable
lint_invalid_reference_casting = casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
lint_lintpass_by_hand = implementing `LintPass` by hand lint_lintpass_by_hand = implementing `LintPass` by hand
.help = try using `declare_lint_pass!` or `impl_lint_pass!` instead .help = try using `declare_lint_pass!` or `impl_lint_pass!` instead

6
compiler/rustc_lint/src/lib.rs
View file

@ -50,7 +50,6 @@ extern crate tracing;
mod array_into_iter; mod array_into_iter;
pub mod builtin; pub mod builtin;
mod cast_ref_to_mut;
mod context; mod context;
mod deref_into_dyn_supertrait; mod deref_into_dyn_supertrait;
mod drop_forget_useless; mod drop_forget_useless;
@ -78,6 +77,7 @@ mod opaque_hidden_inferred_bound;
mod pass_by_value; mod pass_by_value;
mod passes; mod passes;
mod redundant_semicolon; mod redundant_semicolon;
mod reference_casting;
mod traits; mod traits;
mod types; mod types;
mod unused; mod unused;
@ -99,7 +99,6 @@ use rustc_span::Span;
use array_into_iter::ArrayIntoIter; use array_into_iter::ArrayIntoIter;
use builtin::*; use builtin::*;
use cast_ref_to_mut::*;
use deref_into_dyn_supertrait::*; use deref_into_dyn_supertrait::*;
use drop_forget_useless::*; use drop_forget_useless::*;
use enum_intrinsics_non_enums::EnumIntrinsicsNonEnums; use enum_intrinsics_non_enums::EnumIntrinsicsNonEnums;
@ -119,6 +118,7 @@ use noop_method_call::*;
use opaque_hidden_inferred_bound::*; use opaque_hidden_inferred_bound::*;
use pass_by_value::*; use pass_by_value::*;
use redundant_semicolon::*; use redundant_semicolon::*;
use reference_casting::*;
use traits::*; use traits::*;
use types::*; use types::*;
use unused::*; use unused::*;
@ -218,7 +218,7 @@ late_lint_methods!(
BoxPointers: BoxPointers, BoxPointers: BoxPointers,
PathStatements: PathStatements, PathStatements: PathStatements,
LetUnderscore: LetUnderscore, LetUnderscore: LetUnderscore,
CastRefToMut: CastRefToMut, InvalidReferenceCasting: InvalidReferenceCasting,
// Depends on referenced function signatures in expressions // Depends on referenced function signatures in expressions
UnusedResults: UnusedResults, UnusedResults: UnusedResults,
NonUpperCaseGlobals: NonUpperCaseGlobals, NonUpperCaseGlobals: NonUpperCaseGlobals,

6
compiler/rustc_lint/src/lints.rs
View file

@ -743,10 +743,10 @@ pub enum InvalidFromUtf8Diag {
}, },
} }
// cast_ref_to_mut.rs // reference_casting.rs
#[derive(LintDiagnostic)] #[derive(LintDiagnostic)]
#[diag(lint_cast_ref_to_mut)] #[diag(lint_invalid_reference_casting)]
pub struct CastRefToMutDiag; pub struct InvalidReferenceCastingDiag;
// hidden_unicode_codepoints.rs // hidden_unicode_codepoints.rs
#[derive(LintDiagnostic)] #[derive(LintDiagnostic)]

12
compiler/rustc_lint/src/cast_ref_to_mut.rs → compiler/rustc_lint/src/reference_casting.rs
View file

@ -3,10 +3,10 @@ use rustc_hir::{Expr, ExprKind, MutTy, TyKind, UnOp};
use rustc_middle::ty; use rustc_middle::ty;
use rustc_span::sym; use rustc_span::sym;
use crate::{lints::CastRefToMutDiag, LateContext, LateLintPass, LintContext}; use crate::{lints::InvalidReferenceCastingDiag, LateContext, LateLintPass, LintContext};
declare_lint! { declare_lint! {
/// The `cast_ref_to_mut` lint checks for casts of `&T` to `&mut T` /// The `invalid_reference_casting` lint checks for casts of `&T` to `&mut T`
/// without using interior mutability. /// without using interior mutability.
/// ///
/// ### Example /// ### Example
@ -28,14 +28,14 @@ declare_lint! {
/// ///
/// `UnsafeCell` is the only way to obtain aliasable data that is considered /// `UnsafeCell` is the only way to obtain aliasable data that is considered
/// mutable. /// mutable.
CAST_REF_TO_MUT, INVALID_REFERENCE_CASTING,
Deny, Deny,
"casts of `&T` to `&mut T` without interior mutability" "casts of `&T` to `&mut T` without interior mutability"
} }
declare_lint_pass!(CastRefToMut => [CAST_REF_TO_MUT]); declare_lint_pass!(InvalidReferenceCasting => [INVALID_REFERENCE_CASTING]);
impl<'tcx> LateLintPass<'tcx> for CastRefToMut { impl<'tcx> LateLintPass<'tcx> for InvalidReferenceCasting {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
let ExprKind::Unary(UnOp::Deref, e) = &expr.kind else { let ExprKind::Unary(UnOp::Deref, e) = &expr.kind else {
return; return;
@ -68,7 +68,7 @@ impl<'tcx> LateLintPass<'tcx> for CastRefToMut {
let e = e.peel_blocks(); let e = e.peel_blocks();
if let ty::Ref(..) = cx.typeck_results().node_type(e.hir_id).kind() { if let ty::Ref(..) = cx.typeck_results().node_type(e.hir_id).kind() {
cx.emit_spanned_lint(CAST_REF_TO_MUT, expr.span, CastRefToMutDiag); cx.emit_spanned_lint(INVALID_REFERENCE_CASTING, expr.span, InvalidReferenceCastingDiag);
} }
} }
} }

2
src/tools/miri/tests/fail/both_borrows/shr_frozen_violation1.rs
View file

@ -1,7 +1,7 @@
//@revisions: stack tree //@revisions: stack tree
//@[tree]compile-flags: -Zmiri-tree-borrows //@[tree]compile-flags: -Zmiri-tree-borrows
#![allow(cast_ref_to_mut)] #![allow(invalid_reference_casting)]
fn foo(x: &mut i32) -> i32 { fn foo(x: &mut i32) -> i32 {
*x = 5; *x = 5;

2
src/tools/miri/tests/fail/modifying_constants.rs
View file

@ -1,7 +1,7 @@
// This should fail even without validation/SB // This should fail even without validation/SB
//@compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows //@compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
#![allow(cast_ref_to_mut)] #![allow(invalid_reference_casting)]
fn main() { fn main() {
let x = &1; // the `&1` is promoted to a constant, but it used to be that only the pointer is marked static, not the pointee let x = &1; // the `&1` is promoted to a constant, but it used to be that only the pointer is marked static, not the pointee

2
tests/ui/const-generics/issues/issue-100313.stderr
View file

@ -4,7 +4,7 @@ error: casting `&T` to `&mut T` is undefined behavior, even if the reference is
LL | *(B as *const bool as *mut bool) = false; LL | *(B as *const bool as *mut bool) = false;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: `#[deny(cast_ref_to_mut)]` on by default = note: `#[deny(invalid_reference_casting)]` on by default
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/issue-100313.rs:10:13 --> $DIR/issue-100313.rs:10:13

0
tests/ui/lint/cast_ref_to_mut.rs → tests/ui/lint/reference_casting.rs
View file

22
tests/ui/lint/cast_ref_to_mut.stderr → tests/ui/lint/reference_casting.stderr
View file

@ -1,61 +1,61 @@
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell` error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
--> $DIR/cast_ref_to_mut.rs:19:9 --> $DIR/reference_casting.rs:19:9
| |
LL | (*(a as *const _ as *mut String)).push_str(" world"); LL | (*(a as *const _ as *mut String)).push_str(" world");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: `#[deny(cast_ref_to_mut)]` on by default = note: `#[deny(invalid_reference_casting)]` on by default
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell` error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
--> $DIR/cast_ref_to_mut.rs:21:9 --> $DIR/reference_casting.rs:21:9
| |
LL | *(a as *const _ as *mut _) = String::from("Replaced"); LL | *(a as *const _ as *mut _) = String::from("Replaced");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell` error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
--> $DIR/cast_ref_to_mut.rs:23:9 --> $DIR/reference_casting.rs:23:9
| |
LL | *(a as *const _ as *mut String) += " world"; LL | *(a as *const _ as *mut String) += " world";
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell` error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
--> $DIR/cast_ref_to_mut.rs:25:25 --> $DIR/reference_casting.rs:25:25
| |
LL | let _num = &mut *(num as *const i32 as *mut i32); LL | let _num = &mut *(num as *const i32 as *mut i32);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell` error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
--> $DIR/cast_ref_to_mut.rs:27:25 --> $DIR/reference_casting.rs:27:25
| |
LL | let _num = &mut *(num as *const i32).cast_mut(); LL | let _num = &mut *(num as *const i32).cast_mut();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell` error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
--> $DIR/cast_ref_to_mut.rs:29:20 --> $DIR/reference_casting.rs:29:20
| |
LL | let _num = *{ num as *const i32 }.cast_mut(); LL | let _num = *{ num as *const i32 }.cast_mut();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell` error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
--> $DIR/cast_ref_to_mut.rs:31:9 --> $DIR/reference_casting.rs:31:9
| |
LL | *std::ptr::from_ref(num).cast_mut() += 1; LL | *std::ptr::from_ref(num).cast_mut() += 1;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell` error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
--> $DIR/cast_ref_to_mut.rs:33:9 --> $DIR/reference_casting.rs:33:9
| |
LL | *std::ptr::from_ref({ num }).cast_mut() += 1; LL | *std::ptr::from_ref({ num }).cast_mut() += 1;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell` error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
--> $DIR/cast_ref_to_mut.rs:35:9 --> $DIR/reference_casting.rs:35:9
| |
LL | *{ std::ptr::from_ref(num) }.cast_mut() += 1; LL | *{ std::ptr::from_ref(num) }.cast_mut() += 1;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell` error: casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell`
--> $DIR/cast_ref_to_mut.rs:37:9 --> $DIR/reference_casting.rs:37:9
| |
LL | *(std::ptr::from_ref({ num }) as *mut i32) += 1; LL | *(std::ptr::from_ref({ num }) as *mut i32) += 1;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^