clippy_utils/src/ty.rs

   1 //! Util methods for [`rustc_middle::ty`]
   2
   3 #![allow(clippy::module_name_repetitions)]
   4
   5 use std::collections::HashMap;
   6
   7 use rustc_ast::ast::Mutability;
   8 use rustc_hir as hir;
   9 use rustc_hir::def_id::DefId;
  10 use rustc_hir::{TyKind, Unsafety};
  11 use rustc_infer::infer::TyCtxtInferExt;
  12 use rustc_lint::LateContext;
  13 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
  14 use rustc_middle::ty::{self, IntTy, Ty, TypeFoldable, UintTy};
  15 use rustc_span::sym;
  16 use rustc_span::symbol::Symbol;
  17 use rustc_span::DUMMY_SP;
  18 use rustc_trait_selection::traits::query::normalize::AtExt;
  19
  20 use crate::{match_def_path, must_use_attr};
  21
  22 pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
  23     ty.is_copy_modulo_regions(cx.tcx.at(DUMMY_SP), cx.param_env)
  24 }
  25
  26 /// Checks whether a type can be partially moved.
  27 pub fn can_partially_move_ty(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
  28     if has_drop(cx, ty) || is_copy(cx, ty) {
  29         return false;
  30     }
  31     match ty.kind() {
  32         ty::Param(_) => false,
  33         ty::Adt(def, subs) => def.all_fields().any(|f| !is_copy(cx, f.ty(cx.tcx, subs))),
  34         _ => true,
  35     }
  36 }
  37
  38 /// Walks into `ty` and returns `true` if any inner type is the same as `other_ty`
  39 pub fn contains_ty(ty: Ty<'_>, other_ty: Ty<'_>) -> bool {
  40     ty.walk().any(|inner| match inner.unpack() {
  41         GenericArgKind::Type(inner_ty) => ty::TyS::same_type(other_ty, inner_ty),
  42         GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
  43     })
  44 }
  45
  46 /// Returns true if ty has `iter` or `iter_mut` methods
  47 pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<Symbol> {
  48     // FIXME: instead of this hard-coded list, we should check if `<adt>::iter`
  49     // exists and has the desired signature. Unfortunately FnCtxt is not exported
  50     // so we can't use its `lookup_method` method.
  51     let into_iter_collections: &[Symbol] = &[
  52         sym::vec_type,
  53         sym::option_type,
  54         sym::result_type,
  55         sym::BTreeMap,
  56         sym::BTreeSet,
  57         sym::vecdeque_type,
  58         sym::LinkedList,
  59         sym::BinaryHeap,
  60         sym::hashset_type,
  61         sym::hashmap_type,
  62         sym::PathBuf,
  63         sym::Path,
  64         sym::Receiver,
  65     ];
  66
  67     let ty_to_check = match probably_ref_ty.kind() {
  68         ty::Ref(_, ty_to_check, _) => ty_to_check,
  69         _ => probably_ref_ty,
  70     };
  71
  72     let def_id = match ty_to_check.kind() {
  73         ty::Array(..) => return Some(sym::array),
  74         ty::Slice(..) => return Some(sym::slice),
  75         ty::Adt(adt, _) => adt.did,
  76         _ => return None,
  77     };
  78
  79     for &name in into_iter_collections {
  80         if cx.tcx.is_diagnostic_item(name, def_id) {
  81             return Some(cx.tcx.item_name(def_id));
  82         }
  83     }
  84     None
  85 }
  86
  87 /// Checks whether a type implements a trait.
  88 /// See also `get_trait_def_id`.
  89 pub fn implements_trait<'tcx>(
  90     cx: &LateContext<'tcx>,
  91     ty: Ty<'tcx>,
  92     trait_id: DefId,
  93     ty_params: &[GenericArg<'tcx>],
  94 ) -> bool {
  95     // Do not check on infer_types to avoid panic in evaluate_obligation.
  96     if ty.has_infer_types() {
  97         return false;
  98     }
  99     let ty = cx.tcx.erase_regions(ty);
 100     if ty.has_escaping_bound_vars() {
 101         return false;
 102     }
 103     let ty_params = cx.tcx.mk_substs(ty_params.iter());
 104     cx.tcx.type_implements_trait((trait_id, ty, ty_params, cx.param_env))
 105 }
 106
 107 /// Checks whether this type implements `Drop`.
 108 pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
 109     match ty.ty_adt_def() {
 110         Some(def) => def.has_dtor(cx.tcx),
 111         None => false,
 112     }
 113 }
 114
 115 // Returns whether the type has #[must_use] attribute
 116 pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
 117     match ty.kind() {
 118         ty::Adt(ref adt, _) => must_use_attr(&cx.tcx.get_attrs(adt.did)).is_some(),
 119         ty::Foreign(ref did) => must_use_attr(&cx.tcx.get_attrs(*did)).is_some(),
 120         ty::Slice(ref ty)
 121         | ty::Array(ref ty, _)
 122         | ty::RawPtr(ty::TypeAndMut { ref ty, .. })
 123         | ty::Ref(_, ref ty, _) => {
 124             // for the Array case we don't need to care for the len == 0 case
 125             // because we don't want to lint functions returning empty arrays
 126             is_must_use_ty(cx, *ty)
 127         },
 128         ty::Tuple(ref substs) => substs.types().any(|ty| is_must_use_ty(cx, ty)),
 129         ty::Opaque(ref def_id, _) => {
 130             for (predicate, _) in cx.tcx.explicit_item_bounds(*def_id) {
 131                 if let ty::PredicateKind::Trait(trait_predicate, _) = predicate.kind().skip_binder() {
 132                     if must_use_attr(&cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
 133                         return true;
 134                     }
 135                 }
 136             }
 137             false
 138         },
 139         ty::Dynamic(binder, _) => {
 140             for predicate in binder.iter() {
 141                 if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder() {
 142                     if must_use_attr(&cx.tcx.get_attrs(trait_ref.def_id)).is_some() {
 143                         return true;
 144                     }
 145                 }
 146             }
 147             false
 148         },
 149         _ => false,
 150     }
 151 }
 152
 153 // FIXME: Per https://doc.rust-lang.org/nightly/nightly-rustc/rustc_trait_selection/infer/at/struct.At.html#method.normalize
 154 // this function can be removed once the `normalizie` method does not panic when normalization does
 155 // not succeed
 156 /// Checks if `Ty` is normalizable. This function is useful
 157 /// to avoid crashes on `layout_of`.
 158 pub fn is_normalizable<'tcx>(cx: &LateContext<'tcx>, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
 159     is_normalizable_helper(cx, param_env, ty, &mut HashMap::new())
 160 }
 161
 162 fn is_normalizable_helper<'tcx>(
 163     cx: &LateContext<'tcx>,
 164     param_env: ty::ParamEnv<'tcx>,
 165     ty: Ty<'tcx>,
 166     cache: &mut HashMap<Ty<'tcx>, bool>,
 167 ) -> bool {
 168     if let Some(&cached_result) = cache.get(ty) {
 169         return cached_result;
 170     }
 171     // prevent recursive loops, false-negative is better than endless loop leading to stack overflow
 172     cache.insert(ty, false);
 173     let result = cx.tcx.infer_ctxt().enter(|infcx| {
 174         let cause = rustc_middle::traits::ObligationCause::dummy();
 175         if infcx.at(&cause, param_env).normalize(ty).is_ok() {
 176             match ty.kind() {
 177                 ty::Adt(def, substs) => def.variants.iter().all(|variant| {
 178                     variant
 179                         .fields
 180                         .iter()
 181                         .all(|field| is_normalizable_helper(cx, param_env, field.ty(cx.tcx, substs), cache))
 182                 }),
 183                 _ => ty.walk().all(|generic_arg| match generic_arg.unpack() {
 184                     GenericArgKind::Type(inner_ty) if inner_ty != ty => {
 185                         is_normalizable_helper(cx, param_env, inner_ty, cache)
 186                     },
 187                     _ => true, // if inner_ty == ty, we've already checked it
 188                 }),
 189             }
 190         } else {
 191             false
 192         }
 193     });
 194     cache.insert(ty, result);
 195     result
 196 }
 197
 198 /// Returns true iff the given type is a primitive (a bool or char, any integer or floating-point
 199 /// number type, a str, or an array, slice, or tuple of those types).
 200 pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
 201     match ty.kind() {
 202         ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => true,
 203         ty::Ref(_, inner, _) if *inner.kind() == ty::Str => true,
 204         ty::Array(inner_type, _) | ty::Slice(inner_type) => is_recursively_primitive_type(inner_type),
 205         ty::Tuple(inner_types) => inner_types.types().all(is_recursively_primitive_type),
 206         _ => false,
 207     }
 208 }
 209
 210 /// Checks if the type is equal to a diagnostic item
 211 ///
 212 /// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
 213 pub fn is_type_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
 214     match ty.kind() {
 215         ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did),
 216         _ => false,
 217     }
 218 }
 219
 220 /// Checks if the type is equal to a lang item
 221 pub fn is_type_lang_item(cx: &LateContext<'_>, ty: Ty<'_>, lang_item: hir::LangItem) -> bool {
 222     match ty.kind() {
 223         ty::Adt(adt, _) => cx.tcx.lang_items().require(lang_item).unwrap() == adt.did,
 224         _ => false,
 225     }
 226 }
 227
 228 /// Return `true` if the passed `typ` is `isize` or `usize`.
 229 pub fn is_isize_or_usize(typ: Ty<'_>) -> bool {
 230     matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
 231 }
 232
 233 /// Checks if type is struct, enum or union type with the given def path.
 234 ///
 235 /// If the type is a diagnostic item, use `is_type_diagnostic_item` instead.
 236 /// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
 237 pub fn match_type(cx: &LateContext<'_>, ty: Ty<'_>, path: &[&str]) -> bool {
 238     match ty.kind() {
 239         ty::Adt(adt, _) => match_def_path(cx, adt.did, path),
 240         _ => false,
 241     }
 242 }
 243
 244 /// Peels off all references on the type. Returns the underlying type and the number of references
 245 /// removed.
 246 pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
 247     fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
 248         if let ty::Ref(_, ty, _) = ty.kind() {
 249             peel(ty, count + 1)
 250         } else {
 251             (ty, count)
 252         }
 253     }
 254     peel(ty, 0)
 255 }
 256
 257 /// Peels off all references on the type.Returns the underlying type, the number of references
 258 /// removed, and whether the pointer is ultimately mutable or not.
 259 pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
 260     fn f(ty: Ty<'_>, count: usize, mutability: Mutability) -> (Ty<'_>, usize, Mutability) {
 261         match ty.kind() {
 262             ty::Ref(_, ty, Mutability::Mut) => f(ty, count + 1, mutability),
 263             ty::Ref(_, ty, Mutability::Not) => f(ty, count + 1, Mutability::Not),
 264             _ => (ty, count, mutability),
 265         }
 266     }
 267     f(ty, 0, Mutability::Mut)
 268 }
 269
 270 /// Returns `true` if the given type is an `unsafe` function.
 271 pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
 272     match ty.kind() {
 273         ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).unsafety() == Unsafety::Unsafe,
 274         _ => false,
 275     }
 276 }
 277
 278 /// Returns the base type for HIR references and pointers.
 279 pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
 280     match ty.kind {
 281         TyKind::Ptr(ref mut_ty) | TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(&mut_ty.ty),
 282         _ => ty,
 283     }
 284 }
 285
 286 /// Returns the base type for references and raw pointers, and count reference
 287 /// depth.
 288 pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
 289     fn inner(ty: Ty<'_>, depth: usize) -> (Ty<'_>, usize) {
 290         match ty.kind() {
 291             ty::Ref(_, ty, _) => inner(ty, depth + 1),
 292             _ => (ty, depth),
 293         }
 294     }
 295     inner(ty, 0)
 296 }