Take into account the enum variant's value in cast_possible_truncation

Jarcho · Jarcho · commit d275208257d7 · 2022-01-31T21:27:10.000-05:00
diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -2,10 +2,12 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::expr_or_init;
 use clippy_utils::ty::is_isize_or_usize;
+use rustc_ast::ast;
+use rustc_attr::IntType;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, FloatTy, Ty};
+use rustc_middle::ty::{self, FloatTy, Ty, VariantDiscr};
 
 use super::{utils, CAST_POSSIBLE_TRUNCATION};
 
@@ -110,25 +112,39 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         },
 
         (ty::Adt(def, _), true) if def.is_enum() => {
-            if let ExprKind::Path(p) = &cast_expr.kind
-                && let Res::Def(DefKind::Ctor(..), _) = cx.qpath_res(p, cast_expr.hir_id)
+            let from_nbits: u64 = if let ExprKind::Path(p) = &cast_expr.kind
+                && let Res::Def(DefKind::Ctor(..), id) = cx.qpath_res(p, cast_expr.hir_id)
             {
-                return
-            }
-
-            let from_nbits = utils::enum_ty_to_nbits(def, cx.tcx);
-            let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
-
-            let suffix = if is_isize_or_usize(cast_to) {
-                if from_nbits > 32 {
-                    " on targets with 32-bit wide pointers"
-                } else {
-                    return;
+                let i = def.variant_index_with_ctor_id(id);
+                match def.variants[i].discr {
+                    VariantDiscr::Explicit(id) => utils::read_explicit_enum_value(cx.tcx, id).unwrap().nbits(),
+                    VariantDiscr::Relative(x) => {
+                        match def.variants[(i.as_usize() - x as usize).into()].discr {
+                            VariantDiscr::Explicit(id) => {
+                                utils::read_explicit_enum_value(cx.tcx, id).unwrap().add(x).nbits()
+                            }
+                            VariantDiscr::Relative(_) => (32 - x.leading_zeros()).into(),
+                        }
+                    }
                 }
-            } else if to_nbits < from_nbits {
-                ""
             } else {
-                return;
+                utils::enum_ty_to_nbits(def, cx.tcx)
+            };
+            let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
+
+            let cast_from_ptr_size = def.repr.int.map_or(false, |ty| {
+                matches!(
+                    ty,
+                    IntType::SignedInt(ast::IntTy::Isize) | IntType::UnsignedInt(ast::UintTy::Usize)
+                )
+            });
+            let suffix = match (cast_from_ptr_size, is_isize_or_usize(cast_to)) {
+                (false, false) if from_nbits > to_nbits => "",
+                (true, false) if to_nbits < 32 => "",
+                (true, false) if to_nbits < 64 => " on targets with 64-bit wide pointers",
+                (false, true) if from_nbits > 64 => "",
+                (false, true) if from_nbits > 32 => " on targets with 32-bit wide pointers",
+                _ => return,
             };
 
             format!(
diff --git a/clippy_lints/src/casts/utils.rs b/clippy_lints/src/casts/utils.rs
@@ -1,5 +1,6 @@
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
 use rustc_middle::ty::{self, AdtDef, IntTy, Ty, TyCtxt, UintTy, VariantDiscr};
+use rustc_span::def_id::DefId;
 use rustc_target::abi::Size;
 
 /// Returns the size in bits of an integral type.
@@ -26,48 +27,83 @@ pub(super) fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_>) -> u64 {
     }
 }
 
+pub(super) enum EnumValue {
+    Unsigned(u128),
+    Signed(i128),
+}
+impl EnumValue {
+    pub(super) fn add(self, n: u32) -> Self {
+        match self {
+            Self::Unsigned(x) => Self::Unsigned(x + u128::from(n)),
+            Self::Signed(x) => Self::Signed(x + i128::from(n)),
+        }
+    }
+
+    pub(super) fn nbits(self) -> u64 {
+        match self {
+            Self::Unsigned(x) => 128 - x.leading_zeros(),
+            Self::Signed(x) if x < 0 => 128 - (-(x + 1)).leading_zeros() + 1,
+            Self::Signed(x) => 128 - x.leading_zeros(),
+        }
+        .into()
+    }
+}
+
+#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+pub(super) fn read_explicit_enum_value(tcx: TyCtxt<'_>, id: DefId) -> Option<EnumValue> {
+    if let Ok(ConstValue::Scalar(Scalar::Int(value))) = tcx.const_eval_poly(id) {
+        match tcx.type_of(id).kind() {
+            ty::Int(_) => Some(EnumValue::Signed(match value.size().bytes() {
+                1 => i128::from(value.assert_bits(Size::from_bytes(1)) as u8 as i8),
+                2 => i128::from(value.assert_bits(Size::from_bytes(2)) as u16 as i16),
+                4 => i128::from(value.assert_bits(Size::from_bytes(4)) as u32 as i32),
+                8 => i128::from(value.assert_bits(Size::from_bytes(8)) as u64 as i64),
+                16 => value.assert_bits(Size::from_bytes(16)) as i128,
+                _ => return None,
+            })),
+            ty::Uint(_) => Some(EnumValue::Unsigned(match value.size().bytes() {
+                1 => value.assert_bits(Size::from_bytes(1)),
+                2 => value.assert_bits(Size::from_bytes(2)),
+                4 => value.assert_bits(Size::from_bytes(4)),
+                8 => value.assert_bits(Size::from_bytes(8)),
+                16 => value.assert_bits(Size::from_bytes(16)),
+                _ => return None,
+            })),
+            _ => None,
+        }
+    } else {
+        None
+    }
+}
+
 pub(super) fn enum_ty_to_nbits(adt: &AdtDef, tcx: TyCtxt<'_>) -> u64 {
     let mut explicit = 0i128;
     let (start, end) = adt
         .variants
         .iter()
-        .fold((i128::MAX, i128::MIN), |(start, end), variant| match variant.discr {
+        .fold((0, i128::MIN), |(start, end), variant| match variant.discr {
             VariantDiscr::Relative(x) => match explicit.checked_add(i128::from(x)) {
                 Some(x) => (start, end.max(x)),
                 None => (i128::MIN, end),
             },
-            VariantDiscr::Explicit(id) => {
-                let ty = tcx.type_of(id);
-                if let Ok(ConstValue::Scalar(Scalar::Int(value))) = tcx.const_eval_poly(id) {
-                    #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
-                    let value = match (value.size().bytes(), ty.kind()) {
-                        (1, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(1)) as u8 as i8),
-                        (1, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(1)) as u8),
-                        (2, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(2)) as u16 as i16),
-                        (2, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(2)) as u16),
-                        (4, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(4)) as u32 as i32),
-                        (4, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(4)) as u32),
-                        (8, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(8)) as u64 as i64),
-                        (8, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(8)) as u64),
-                        (16, ty::Int(_)) => value.assert_bits(Size::from_bytes(16)) as i128,
-                        (16, ty::Uint(_)) => match i128::try_from(value.assert_bits(Size::from_bytes(16))) {
-                            Ok(x) => x,
-                            // Requires 128 bits
-                            Err(_) => return (i128::MIN, end),
-                        },
-                        // Shouldn't happen if compilation was successful
-                        _ => return (start, end),
-                    };
-                    explicit = value;
-                    (start.min(value), end.max(value))
-                } else {
-                    // Shouldn't happen if compilation was successful
-                    (start, end)
-                }
+            VariantDiscr::Explicit(id) => match read_explicit_enum_value(tcx, id) {
+                Some(EnumValue::Signed(x)) => {
+                    explicit = x;
+                    (start.min(x), end.max(x))
+                },
+                Some(EnumValue::Unsigned(x)) => match i128::try_from(x) {
+                    Ok(x) => {
+                        explicit = x;
+                        (start, end.max(x))
+                    },
+                    Err(_) => (i128::MIN, end),
+                },
+                None => (start, end),
             },
         });
 
-    if start >= end {
+    if start > end {
+        // No variants.
         0
     } else {
         let neg_bits = if start < 0 {
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
@@ -23,6 +23,7 @@
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
+extern crate rustc_attr;
 extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_errors;
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
@@ -139,7 +139,9 @@ fn main() {
     impl E2 {
         fn test(self) {
             let _ = self as u8;
+            let _ = Self::B as u8;
             let _ = self as i16; // Don't lint. `255..=256` fits in i16
+            let _ = Self::A as u8; // Don't lint.
         }
     }
 
@@ -174,7 +176,9 @@ fn main() {
     impl E5 {
         fn test(self) {
             let _ = self as i8;
+            let _ = Self::A as i8;
             let _ = self as i16; // Don't lint. `-129..=127` fits in i16
+            let _ = Self::B as u8; // Don't lint.
         }
     }
 
@@ -189,6 +193,7 @@ fn main() {
             let _ = self as i16;
             let _ = Self::A as u16; // Don't lint. `2^16-1` fits in u16
             let _ = self as u32; // Don't lint. `2^16-1..=2^16` fits in u32
+            let _ = Self::A as u16; // Don't lint.
         }
     }
 
@@ -201,6 +206,7 @@ fn main() {
     impl E7 {
         fn test(self) {
             let _ = self as usize;
+            let _ = Self::A as usize; // Don't lint.
             let _ = self as u64; // Don't lint. `2^32-1..=2^32` fits in u64
         }
     }
@@ -227,6 +233,7 @@ fn main() {
     }
     impl E9 {
         fn test(self) {
+            let _ = Self::A as u8; // Don't lint.
             let _ = self as u128; // Don't lint. `0..=2^128-1` fits in u128
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,9 @@ fn main() {`
`139`	`139`	`impl E2 {`
`140`	`140`	`fn test(self) {`
`141`	`141`	`let _ = self as u8;`
	`142`	`+ let _ = Self::B as u8;`
`142`	`143`	let _ = self as i16; // Don't lint. `255..=256` fits in i16
	`144`	`+ let _ = Self::A as u8; // Don't lint.`
`143`	`145`	`}`
`144`	`146`	`}`
`145`	`147`
`@@ -174,7 +176,9 @@ fn main() {`
`174`	`176`	`impl E5 {`
`175`	`177`	`fn test(self) {`
`176`	`178`	`let _ = self as i8;`
	`179`	`+ let _ = Self::A as i8;`
`177`	`180`	let _ = self as i16; // Don't lint. `-129..=127` fits in i16
	`181`	`+ let _ = Self::B as u8; // Don't lint.`
`178`	`182`	`}`
`179`	`183`	`}`
`180`	`184`
`@@ -189,6 +193,7 @@ fn main() {`
`189`	`193`	`let _ = self as i16;`
`190`	`194`	let _ = Self::A as u16; // Don't lint. `2^16-1` fits in u16
`191`	`195`	let _ = self as u32; // Don't lint. `2^16-1..=2^16` fits in u32
	`196`	`+ let _ = Self::A as u16; // Don't lint.`
`192`	`197`	`}`
`193`	`198`	`}`
`194`	`199`
`@@ -201,6 +206,7 @@ fn main() {`
`201`	`206`	`impl E7 {`
`202`	`207`	`fn test(self) {`
`203`	`208`	`let _ = self as usize;`
	`209`	`+ let _ = Self::A as usize; // Don't lint.`
`204`	`210`	let _ = self as u64; // Don't lint. `2^32-1..=2^32` fits in u64
`205`	`211`	`}`
`206`	`212`	`}`
`@@ -227,6 +233,7 @@ fn main() {`
`227`	`233`	`}`
`228`	`234`	`impl E9 {`
`229`	`235`	`fn test(self) {`
	`236`	`+ let _ = Self::A as u8; // Don't lint.`
`230`	`237`	let _ = self as u128; // Don't lint. `0..=2^128-1` fits in u128
`231`	`238`	`}`
`232`	`239`	`}`