Properly resolve associated constants of primitive types

Associated constants of primitive types are resolved as `Res::Err` in
the HIR. To force a resolution, the primitive type must be recognized as
certain. Since they are not ADT, they don't have a `DefId`. By allowing
the `Certainty` type to embed a `TypeKind` which is either a `PrimTy` or
a `DefId`, we allow primitives types to be resolved, and the associated
constants as well.

Also, in method calls, if the receiver is not certain, consider that the
overall call is not either.

Author: samueltardieu

clippy_utils/src/lib.rs

@@ -6,6 +6,7 @@
 #![feature(assert_matches)]
 #![feature(unwrap_infallible)]
 #![feature(array_windows)]
+#![feature(try_trait_v2)]
 #![recursion_limit = "512"]
 #![allow(
     clippy::missing_errors_doc,

clippy_utils/src/ty/type_certainty/certainty.rs

@@ -1,15 +1,22 @@
 use rustc_hir::def_id::DefId;
 use std::fmt::Debug;
+use std::ops::{ControlFlow, FromResidual, Try};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TypeKind {
+    PrimTy,
+    AdtDef(DefId),
+}
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Certainty {
     /// Determining the type requires contextual information.
     Uncertain,
 
     /// The type can be determined purely from subexpressions. If the argument is `Some(..)`, the
-    /// specific `DefId` is known. Such arguments are needed to handle path segments whose `res` is
-    /// `Res::Err`.
-    Certain(Option<DefId>),
+    /// specific primitive type or `DefId` is known. Such arguments are needed to handle path
+    /// segments whose `res` is `Res::Err`.
+    Certain(Option<TypeKind>),
 
     /// The heuristic believes that more than one `DefId` applies to a type---this is a bug.
     Contradiction,
@@ -23,7 +30,7 @@ pub trait TryJoin: Sized {
     fn try_join(self, other: Self) -> Option<Self>;
 }
 
-impl Meet for Option<DefId> {
+impl Meet for Option<TypeKind> {
     fn meet(self, other: Self) -> Self {
         match (self, other) {
             (None, _) | (_, None) => None,
@@ -32,11 +39,11 @@ impl Meet for Option<DefId> {
     }
 }
 
-impl TryJoin for Option<DefId> {
+impl TryJoin for Option<TypeKind> {
     fn try_join(self, other: Self) -> Option<Self> {
         match (self, other) {
             (Some(lhs), Some(rhs)) => (lhs == rhs).then_some(Some(lhs)),
-            (Some(def_id), _) | (_, Some(def_id)) => Some(Some(def_id)),
+            (Some(ty_kind), _) | (_, Some(ty_kind)) => Some(Some(ty_kind)),
             (None, None) => Some(None),
         }
     }
@@ -79,29 +86,37 @@ impl Certainty {
     /// Join two `Certainty`s after clearing their `DefId`s. This method should be used when `self`
     /// or `other` do not necessarily refer to types, e.g., when they are aggregations of other
     /// `Certainty`s.
-    pub fn join_clearing_def_ids(self, other: Self) -> Self {
-        self.clear_def_id().join(other.clear_def_id())
+    pub fn join_clearing_types(self, other: Self) -> Self {
+        self.clear_type().join(other.clear_type())
     }
 
-    pub fn clear_def_id(self) -> Certainty {
+    pub fn clear_type(self) -> Certainty {
         if matches!(self, Certainty::Certain(_)) {
             Certainty::Certain(None)
         } else {
             self
         }
     }
 
+    pub fn with_prim_ty(self) -> Certainty {
+        if matches!(self, Certainty::Certain(_)) {
+            Certainty::Certain(Some(TypeKind::PrimTy))
+        } else {
+            self
+        }
+    }
+
     pub fn with_def_id(self, def_id: DefId) -> Certainty {
         if matches!(self, Certainty::Certain(_)) {
-            Certainty::Certain(Some(def_id))
+            Certainty::Certain(Some(TypeKind::AdtDef(def_id)))
         } else {
             self
         }
     }
 
     pub fn to_def_id(self) -> Option<DefId> {
         match self {
-            Certainty::Certain(inner) => inner,
+            Certainty::Certain(Some(TypeKind::AdtDef(def_id))) => Some(def_id),
             _ => None,
         }
     }
@@ -120,3 +135,28 @@ pub fn meet(iter: impl Iterator<Item = Certainty>) -> Certainty {
 pub fn join(iter: impl Iterator<Item = Certainty>) -> Certainty {
     iter.fold(Certainty::Uncertain, Certainty::join)
 }
+
+pub struct NoCertainty(Certainty);
+
+impl FromResidual<NoCertainty> for Certainty {
+    fn from_residual(residual: NoCertainty) -> Self {
+        residual.0
+    }
+}
+
+impl Try for Certainty {
+    type Output = Certainty;
+
+    type Residual = NoCertainty;
+
+    fn from_output(output: Self::Output) -> Self {
+        output
+    }
+
+    fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
+        match self {
+            Certainty::Certain(_) => ControlFlow::Continue(self),
+            _ => ControlFlow::Break(NoCertainty(self)),
+        }
+    }
+}

clippy_utils/src/ty/type_certainty/mod.rs

@@ -22,7 +22,7 @@ use rustc_middle::ty::{self, AdtDef, GenericArgKind, Ty};
 use rustc_span::Span;
 
 mod certainty;
-use certainty::{Certainty, Meet, join, meet};
+use certainty::{Certainty, Meet, TypeKind, join, meet};
 
 pub fn expr_type_is_certain(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     expr_type_certainty(cx, expr, false).is_certain()
@@ -46,11 +46,12 @@ fn expr_type_certainty(cx: &LateContext<'_>, expr: &Expr<'_>, in_arg: bool) -> C
             } else {
                 Certainty::Uncertain
             };
-            lhs.join_clearing_def_ids(rhs)
+            lhs.join_clearing_types(rhs)
         },
 
         ExprKind::MethodCall(method, receiver, args, _) => {
-            let mut receiver_type_certainty = expr_type_certainty(cx, receiver, false);
+            let mut receiver_type_certainty = expr_type_certainty(cx, receiver, false)?;
+
             // Even if `receiver_type_certainty` is `Certain(Some(..))`, the `Self` type in the method
             // identified by `type_dependent_def_id(..)` can differ. This can happen as a result of a `deref`,
             // for example. So update the `DefId` in `receiver_type_certainty` (if any).
@@ -66,7 +67,7 @@ fn expr_type_certainty(cx: &LateContext<'_>, expr: &Expr<'_>, in_arg: bool) -> C
                         .chain(args.iter().map(|arg| expr_type_certainty(cx, arg, true))),
                 )
             } else {
-                Certainty::Uncertain
+                return Certainty::Uncertain;
             };
             lhs.join(rhs)
         },
@@ -117,12 +118,13 @@ fn expr_type_certainty(cx: &LateContext<'_>, expr: &Expr<'_>, in_arg: bool) -> C
         _ => Certainty::Uncertain,
     };
 
-    let expr_ty = cx.typeck_results().expr_ty(expr);
-    if let Some(def_id) = adt_def_id(expr_ty) {
-        certainty.with_def_id(def_id)
-    } else {
-        certainty.clear_def_id()
-    }
+    let result = match cx.typeck_results().expr_ty(expr).kind() {
+        ty::Adt(adt_def, _) => certainty.with_def_id(adt_def.did()),
+        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) => certainty.with_prim_ty(),
+        _ => certainty.clear_type(),
+    };
+
+    result
 }
 
 struct CertaintyVisitor<'cx, 'tcx> {
@@ -209,7 +211,11 @@ fn qpath_certainty(cx: &LateContext<'_>, qpath: &QPath<'_>, resolves_to_type: bo
             .map_or(Certainty::Uncertain, |def_id| {
                 let generics = cx.tcx.generics_of(def_id);
                 if generics.is_empty() {
-                    Certainty::Certain(if resolves_to_type { Some(def_id) } else { None })
+                    Certainty::Certain(if resolves_to_type {
+                        Some(TypeKind::AdtDef(def_id))
+                    } else {
+                        None
+                    })
                 } else {
                     Certainty::Uncertain
                 }
@@ -230,7 +236,7 @@ fn param_certainty(cx: &LateContext<'_>, param: &Param<'_>) -> Certainty {
     let body_params = cx.tcx.hir_body_owned_by(owner_did).params;
     std::iter::zip(body_params, inputs)
         .find(|(p, _)| p.hir_id == param.hir_id)
-        .map_or(Certainty::Uncertain, |(_, ty)| type_certainty(cx, ty).clear_def_id())
+        .map_or(Certainty::Uncertain, |(_, ty)| type_certainty(cx, ty).clear_type())
 }
 
 fn path_segment_certainty(
@@ -263,7 +269,7 @@ fn path_segment_certainty(
                     .args
                     .map_or(Certainty::Uncertain, |args| generic_args_certainty(cx, args));
                 // See the comment preceding `qpath_certainty`. `def_id` could refer to a type or a value.
-                let certainty = lhs.join_clearing_def_ids(rhs);
+                let certainty = lhs.join_clearing_types(rhs);
                 if resolves_to_type {
                     if let DefKind::TyAlias = cx.tcx.def_kind(def_id) {
                         adt_def_id(cx.tcx.type_of(def_id).instantiate_identity())
@@ -279,9 +285,7 @@ fn path_segment_certainty(
             }
         },
 
-        Res::PrimTy(_) | Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } | Res::SelfCtor(_) => {
-            Certainty::Certain(None)
-        },
+        Res::PrimTy(_) => Certainty::Certain(Some(TypeKind::PrimTy)),
 
         // `get_parent` because `hir_id` refers to a `Pat`, and we're interested in the node containing the `Pat`.
         Res::Local(hir_id) => match cx.tcx.parent_hir_node(hir_id) {
@@ -299,13 +303,13 @@ fn path_segment_certainty(
                 if resolves_to_type {
                     certainty
                 } else {
-                    certainty.clear_def_id()
+                    certainty.clear_type()
                 }
             },
             _ => Certainty::Uncertain,
         },
 
-        _ => Certainty::Uncertain,
+        _ => Certainty::Certain(None),
     };
     debug_assert!(resolves_to_type || certainty.to_def_id().is_none());
     certainty

tests/ui/unnecessary_cast.fixed

@@ -310,4 +310,17 @@ mod fixable {
         let _ = threshold;
         //~^ unnecessary_cast
     }
+
+    fn with_prim_ty() {
+        let threshold = 20;
+        let threshold = if threshold == 0 {
+            i64::MAX
+        } else if threshold <= 60 {
+            10
+        } else {
+            0
+        };
+        let _ = threshold;
+        //~^ unnecessary_cast
+    }
 }

tests/ui/unnecessary_cast.rs

@@ -310,4 +310,17 @@ mod fixable {
         let _ = threshold as i64;
         //~^ unnecessary_cast
     }
+
+    fn with_prim_ty() {
+        let threshold = 20;
+        let threshold = if threshold == 0 {
+            i64::MAX
+        } else if threshold <= 60 {
+            10
+        } else {
+            0
+        };
+        let _ = threshold as i64;
+        //~^ unnecessary_cast
+    }
 }

tests/ui/unnecessary_cast.stderr

@@ -283,5 +283,11 @@ error: casting to the same type is unnecessary (`i64` -> `i64`)
 LL |         let _ = threshold as i64;
    |                 ^^^^^^^^^^^^^^^^ help: try: `threshold`
 
-error: aborting due to 47 previous errors
+error: casting to the same type is unnecessary (`i64` -> `i64`)
+  --> tests/ui/unnecessary_cast.rs:323:17
+   |
+LL |         let _ = threshold as i64;
+   |                 ^^^^^^^^^^^^^^^^ help: try: `threshold`
+
+error: aborting due to 48 previous errors