clippy_lints/src/types.rs

   1 // Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution.
   3 //
   4 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   5 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   7 // option. This file may not be copied, modified, or distributed
   8 // except according to those terms.
   9
  10
  11 #![allow(clippy::default_hash_types)]
  12
  13 use crate::consts::{constant, Constant};
  14 use crate::reexport::*;
  15 use crate::rustc::hir;
  16 use crate::rustc::hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
  17 use crate::rustc::hir::*;
  18 use crate::rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass};
  19 use crate::rustc::ty::layout::LayoutOf;
  20 use crate::rustc::ty::{self, Ty, TyCtxt, TypeckTables};
  21 use crate::rustc::{declare_tool_lint, lint_array};
  22 use crate::rustc_errors::Applicability;
  23 use crate::rustc_target::spec::abi::Abi;
  24 use crate::rustc_typeck::hir_ty_to_ty;
  25 use crate::syntax::ast::{FloatTy, IntTy, UintTy};
  26 use crate::syntax::errors::DiagnosticBuilder;
  27 use crate::syntax::source_map::{DUMMY_SP, Span};
  28 use crate::utils::paths;
  29 use crate::utils::{
  30     clip, comparisons, differing_macro_contexts, higher, in_constant, in_macro, int_bits, last_path_segment,
  31     match_def_path, match_path, multispan_sugg, opt_def_id, same_tys, sext, snippet, snippet_opt,
  32     snippet_with_applicability, span_help_and_lint, span_lint, span_lint_and_sugg, span_lint_and_then, unsext,
  33     AbsolutePathBuffer,
  34 };
  35 use if_chain::if_chain;
  36 use std::borrow::Cow;
  37 use std::cmp::Ordering;
  38 use std::collections::BTreeMap;
  39
  40 /// Handles all the linting of funky types
  41 pub struct TypePass;
  42
  43 /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
  44 ///
  45 /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
  46 /// the heap. So if you `Box` it, you just add another level of indirection
  47 /// without any benefit whatsoever.
  48 ///
  49 /// **Known problems:** None.
  50 ///
  51 /// **Example:**
  52 /// ```rust
  53 /// struct X {
  54 ///     values: Box<Vec<Foo>>,
  55 /// }
  56 /// ```
  57 ///
  58 /// Better:
  59 ///
  60 /// ```rust
  61 /// struct X {
  62 ///     values: Vec<Foo>,
  63 /// }
  64 /// ```
  65 declare_clippy_lint! {
  66     pub BOX_VEC,
  67     perf,
  68     "usage of `Box<Vec<T>>`, vector elements are already on the heap"
  69 }
  70
  71 /// **What it does:** Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code.
  72 ///
  73 /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
  74 /// the heap. So if you `Box` its contents, you just add another level of indirection.
  75 ///
  76 /// **Known problems:** Vec<Box<T: Sized>> makes sense if T is a large type (see #3530, 1st comment).
  77 ///
  78 /// **Example:**
  79 /// ```rust
  80 /// struct X {
  81 ///     values: Vec<Box<i32>>,
  82 /// }
  83 /// ```
  84 ///
  85 /// Better:
  86 ///
  87 /// ```rust
  88 /// struct X {
  89 ///     values: Vec<i32>,
  90 /// }
  91 /// ```
  92 declare_clippy_lint! {
  93     pub VEC_BOX_SIZED,
  94     complexity,
  95     "usage of `Vec<Box<T>>` where T: Sized, vector elements are already on the heap"
  96 }
  97
  98 /// **What it does:** Checks for use of `Option<Option<_>>` in function signatures and type
  99 /// definitions
 100 ///
 101 /// **Why is this bad?** `Option<_>` represents an optional value. `Option<Option<_>>`
 102 /// represents an optional optional value which is logically the same thing as an optional
 103 /// value but has an unneeded extra level of wrapping.
 104 ///
 105 /// **Known problems:** None.
 106 ///
 107 /// **Example**
 108 /// ```rust
 109 /// fn x() -> Option<Option<u32>> {
 110 ///     None
 111 /// }
 112 declare_clippy_lint! {
 113     pub OPTION_OPTION,
 114     complexity,
 115     "usage of `Option<Option<T>>`"
 116 }
 117
 118 /// **What it does:** Checks for usage of any `LinkedList`, suggesting to use a
 119 /// `Vec` or a `VecDeque` (formerly called `RingBuf`).
 120 ///
 121 /// **Why is this bad?** Gankro says:
 122 ///
 123 /// > The TL;DR of `LinkedList` is that it's built on a massive amount of
 124 /// pointers and indirection.
 125 /// > It wastes memory, it has terrible cache locality, and is all-around slow.
 126 /// `RingBuf`, while
 127 /// > "only" amortized for push/pop, should be faster in the general case for
 128 /// almost every possible
 129 /// > workload, and isn't even amortized at all if you can predict the capacity
 130 /// you need.
 131 /// >
 132 /// > `LinkedList`s are only really good if you're doing a lot of merging or
 133 /// splitting of lists.
 134 /// > This is because they can just mangle some pointers instead of actually
 135 /// copying the data. Even
 136 /// > if you're doing a lot of insertion in the middle of the list, `RingBuf`
 137 /// can still be better
 138 /// > because of how expensive it is to seek to the middle of a `LinkedList`.
 139 ///
 140 /// **Known problems:** False positives – the instances where using a
 141 /// `LinkedList` makes sense are few and far between, but they can still happen.
 142 ///
 143 /// **Example:**
 144 /// ```rust
 145 /// let x = LinkedList::new();
 146 /// ```
 147 declare_clippy_lint! {
 148     pub LINKEDLIST,
 149     pedantic,
 150     "usage of LinkedList, usually a vector is faster, or a more specialized data structure like a VecDeque"
 151 }
 152
 153 /// **What it does:** Checks for use of `&Box<T>` anywhere in the code.
 154 ///
 155 /// **Why is this bad?** Any `&Box<T>` can also be a `&T`, which is more
 156 /// general.
 157 ///
 158 /// **Known problems:** None.
 159 ///
 160 /// **Example:**
 161 /// ```rust
 162 /// fn foo(bar: &Box<T>) { ... }
 163 /// ```
 164 ///
 165 /// Better:
 166 ///
 167 /// ```rust
 168 /// fn foo(bar: &T) { ... }
 169 /// ```
 170 declare_clippy_lint! {
 171     pub BORROWED_BOX,
 172     complexity,
 173     "a borrow of a boxed type"
 174 }
 175
 176 impl LintPass for TypePass {
 177     fn get_lints(&self) -> LintArray {
 178         lint_array!(BOX_VEC, VEC_BOX_SIZED, OPTION_OPTION, LINKEDLIST, BORROWED_BOX)
 179     }
 180 }
 181
 182 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypePass {
 183     fn check_fn(&mut self, cx: &LateContext<'_, '_>, _: FnKind<'_>, decl: &FnDecl, _: &Body, _: Span, id: NodeId) {
 184         // skip trait implementations, see #605
 185         if let Some(hir::Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent(id)) {
 186             if let ItemKind::Impl(_, _, _, _, Some(..), _, _) = item.node {
 187                 return;
 188             }
 189         }
 190
 191         check_fn_decl(cx, decl);
 192     }
 193
 194     fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, field: &StructField) {
 195         check_ty(cx, &field.ty, false);
 196     }
 197
 198     fn check_trait_item(&mut self, cx: &LateContext<'_, '_>, item: &TraitItem) {
 199         match item.node {
 200             TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => check_ty(cx, ty, false),
 201             TraitItemKind::Method(ref sig, _) => check_fn_decl(cx, &sig.decl),
 202             _ => (),
 203         }
 204     }
 205
 206     fn check_local(&mut self, cx: &LateContext<'_, '_>, local: &Local) {
 207         if let Some(ref ty) = local.ty {
 208             check_ty(cx, ty, true);
 209         }
 210     }
 211 }
 212
 213 fn check_fn_decl(cx: &LateContext<'_, '_>, decl: &FnDecl) {
 214     for input in &decl.inputs {
 215         check_ty(cx, input, false);
 216     }
 217
 218     if let FunctionRetTy::Return(ref ty) = decl.output {
 219         check_ty(cx, ty, false);
 220     }
 221 }
 222
 223 /// Check if `qpath` has last segment with type parameter matching `path`
 224 fn match_type_parameter(cx: &LateContext<'_, '_>, qpath: &QPath, path: &[&str]) -> bool {
 225     let last = last_path_segment(qpath);
 226     if_chain! {
 227         if let Some(ref params) = last.args;
 228         if !params.parenthesized;
 229         if let Some(ty) = params.args.iter().find_map(|arg| match arg {
 230             GenericArg::Type(ty) => Some(ty),
 231             GenericArg::Lifetime(_) => None,
 232         });
 233         if let TyKind::Path(ref qpath) = ty.node;
 234         if let Some(did) = opt_def_id(cx.tables.qpath_def(qpath, cx.tcx.hir().node_to_hir_id(ty.id)));
 235         if match_def_path(cx.tcx, did, path);
 236         then {
 237             return true;
 238         }
 239     }
 240     false
 241 }
 242
 243 /// Recursively check for `TypePass` lints in the given type. Stop at the first
 244 /// lint found.
 245 ///
 246 /// The parameter `is_local` distinguishes the context of the type; types from
 247 /// local bindings should only be checked for the `BORROWED_BOX` lint.
 248 fn check_ty(cx: &LateContext<'_, '_>, ast_ty: &hir::Ty, is_local: bool) {
 249     if in_macro(ast_ty.span) {
 250         return;
 251     }
 252     match ast_ty.node {
 253         TyKind::Path(ref qpath) if !is_local => {
 254             let hir_id = cx.tcx.hir().node_to_hir_id(ast_ty.id);
 255             let def = cx.tables.qpath_def(qpath, hir_id);
 256             if let Some(def_id) = opt_def_id(def) {
 257                 if Some(def_id) == cx.tcx.lang_items().owned_box() {
 258                     if match_type_parameter(cx, qpath, &paths::VEC) {
 259                         span_help_and_lint(
 260                             cx,
 261                             BOX_VEC,
 262                             ast_ty.span,
 263                             "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
 264                             "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation.",
 265                         );
 266                         return; // don't recurse into the type
 267                     }
 268                 } else if match_def_path(cx.tcx, def_id, &paths::VEC) {
 269                     if_chain! {
 270                         // Get the _ part of Vec<_>
 271                         if let Some(ref last) = last_path_segment(qpath).args;
 272                         if let Some(ty) = last.args.iter().find_map(|arg| match arg {
 273                             GenericArg::Type(ty) => Some(ty),
 274                             GenericArg::Lifetime(_) => None,
 275                         });
 276                         // ty is now _ at this point
 277                         if let TyKind::Path(ref ty_qpath) = ty.node;
 278                         let def = cx.tables.qpath_def(ty_qpath, ty.hir_id);
 279                         if let Some(def_id) = opt_def_id(def);
 280                         if Some(def_id) == cx.tcx.lang_items().owned_box();
 281                         // At this point, we know ty is Box<T>, now get T
 282                         if let Some(ref last) = last_path_segment(ty_qpath).args;
 283                         if let Some(ty) = last.args.iter().find_map(|arg| match arg {
 284                             GenericArg::Type(ty) => Some(ty),
 285                             GenericArg::Lifetime(_) => None,
 286                         });
 287                         if let TyKind::Path(ref ty_qpath) = ty.node;
 288                         let def = cx.tables.qpath_def(ty_qpath, ty.hir_id);
 289                         if let Some(def_id) = opt_def_id(def);
 290                         let boxed_type = cx.tcx.type_of(def_id);
 291                         if boxed_type.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env);
 292                         then {
 293                             span_lint_and_sugg(
 294                                 cx,
 295                                 VEC_BOX_SIZED,
 296                                 ast_ty.span,
 297                                 "you seem to be trying to use `Vec<Box<T>>`, but T is Sized. `Vec<T>` is already on the heap, `Vec<Box<T>>` makes an extra allocation.",
 298                                 "try",
 299                                 format!("Vec<{}>", boxed_type),
 300                                 Applicability::MachineApplicable
 301                             )
 302                         }
 303                     }
 304                 } else if match_def_path(cx.tcx, def_id, &paths::OPTION) {
 305                     if match_type_parameter(cx, qpath, &paths::OPTION) {
 306                         span_lint(
 307                             cx,
 308                             OPTION_OPTION,
 309                             ast_ty.span,
 310                             "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
 311                              enum if you need to distinguish all 3 cases",
 312                         );
 313                         return; // don't recurse into the type
 314                     }
 315                 } else if match_def_path(cx.tcx, def_id, &paths::LINKED_LIST) {
 316                     span_help_and_lint(
 317                         cx,
 318                         LINKEDLIST,
 319                         ast_ty.span,
 320                         "I see you're using a LinkedList! Perhaps you meant some other data structure?",
 321                         "a VecDeque might work",
 322                     );
 323                     return; // don't recurse into the type
 324                 }
 325             }
 326             match *qpath {
 327                 QPath::Resolved(Some(ref ty), ref p) => {
 328                     check_ty(cx, ty, is_local);
 329                     for ty in p.segments.iter().flat_map(|seg| {
 330                         seg.args
 331                             .as_ref()
 332                             .map_or_else(|| [].iter(), |params| params.args.iter())
 333                             .filter_map(|arg| match arg {
 334                                 GenericArg::Type(ty) => Some(ty),
 335                                 GenericArg::Lifetime(_) => None,
 336                             })
 337                     }) {
 338                         check_ty(cx, ty, is_local);
 339                     }
 340                 },
 341                 QPath::Resolved(None, ref p) => {
 342                     for ty in p.segments.iter().flat_map(|seg| {
 343                         seg.args
 344                             .as_ref()
 345                             .map_or_else(|| [].iter(), |params| params.args.iter())
 346                             .filter_map(|arg| match arg {
 347                                 GenericArg::Type(ty) => Some(ty),
 348                                 GenericArg::Lifetime(_) => None,
 349                             })
 350                     }) {
 351                         check_ty(cx, ty, is_local);
 352                     }
 353                 },
 354                 QPath::TypeRelative(ref ty, ref seg) => {
 355                     check_ty(cx, ty, is_local);
 356                     if let Some(ref params) = seg.args {
 357                         for ty in params.args.iter().filter_map(|arg| match arg {
 358                             GenericArg::Type(ty) => Some(ty),
 359                             GenericArg::Lifetime(_) => None,
 360                         }) {
 361                             check_ty(cx, ty, is_local);
 362                         }
 363                     }
 364                 },
 365             }
 366         },
 367         TyKind::Rptr(ref lt, ref mut_ty) => check_ty_rptr(cx, ast_ty, is_local, lt, mut_ty),
 368         // recurse
 369         TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
 370             check_ty(cx, ty, is_local)
 371         },
 372         TyKind::Tup(ref tys) => {
 373             for ty in tys {
 374                 check_ty(cx, ty, is_local);
 375             }
 376         },
 377         _ => {},
 378     }
 379 }
 380
 381 fn check_ty_rptr(cx: &LateContext<'_, '_>, ast_ty: &hir::Ty, is_local: bool, lt: &Lifetime, mut_ty: &MutTy) {
 382     match mut_ty.ty.node {
 383         TyKind::Path(ref qpath) => {
 384             let hir_id = cx.tcx.hir().node_to_hir_id(mut_ty.ty.id);
 385             let def = cx.tables.qpath_def(qpath, hir_id);
 386             if_chain! {
 387                 if let Some(def_id) = opt_def_id(def);
 388                 if Some(def_id) == cx.tcx.lang_items().owned_box();
 389                 if let QPath::Resolved(None, ref path) = *qpath;
 390                 if let [ref bx] = *path.segments;
 391                 if let Some(ref params) = bx.args;
 392                 if !params.parenthesized;
 393                 if let Some(inner) = params.args.iter().find_map(|arg| match arg {
 394                     GenericArg::Type(ty) => Some(ty),
 395                     GenericArg::Lifetime(_) => None,
 396                 });
 397                 then {
 398                     if is_any_trait(inner) {
 399                         // Ignore `Box<Any>` types, see #1884 for details.
 400                         return;
 401                     }
 402
 403                     let ltopt = if lt.is_elided() {
 404                         String::new()
 405                     } else {
 406                         format!("{} ", lt.name.ident().as_str())
 407                     };
 408                     let mutopt = if mut_ty.mutbl == Mutability::MutMutable {
 409                         "mut "
 410                     } else {
 411                         ""
 412                     };
 413                     let mut applicability = Applicability::MachineApplicable;
 414                     span_lint_and_sugg(
 415                         cx,
 416                         BORROWED_BOX,
 417                         ast_ty.span,
 418                         "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
 419                         "try",
 420                         format!(
 421                             "&{}{}{}",
 422                             ltopt,
 423                             mutopt,
 424                             &snippet_with_applicability(cx, inner.span, "..", &mut applicability)
 425                         ),
 426                         Applicability::Unspecified,
 427                     );
 428                     return; // don't recurse into the type
 429                 }
 430             };
 431             check_ty(cx, &mut_ty.ty, is_local);
 432         },
 433         _ => check_ty(cx, &mut_ty.ty, is_local),
 434     }
 435 }
 436
 437 // Returns true if given type is `Any` trait.
 438 fn is_any_trait(t: &hir::Ty) -> bool {
 439     if_chain! {
 440         if let TyKind::TraitObject(ref traits, _) = t.node;
 441         if traits.len() >= 1;
 442         // Only Send/Sync can be used as additional traits, so it is enough to
 443         // check only the first trait.
 444         if match_path(&traits[0].trait_ref.path, &paths::ANY_TRAIT);
 445         then {
 446             return true;
 447         }
 448     }
 449
 450     false
 451 }
 452
 453 pub struct LetPass;
 454
 455 /// **What it does:** Checks for binding a unit value.
 456 ///
 457 /// **Why is this bad?** A unit value cannot usefully be used anywhere. So
 458 /// binding one is kind of pointless.
 459 ///
 460 /// **Known problems:** None.
 461 ///
 462 /// **Example:**
 463 /// ```rust
 464 /// let x = {
 465 ///     1;
 466 /// };
 467 /// ```
 468 declare_clippy_lint! {
 469     pub LET_UNIT_VALUE,
 470     style,
 471     "creating a let binding to a value of unit type, which usually can't be used afterwards"
 472 }
 473
 474 fn check_let_unit(cx: &LateContext<'_, '_>, decl: &Decl) {
 475     if let DeclKind::Local(ref local) = decl.node {
 476         if is_unit(cx.tables.pat_ty(&local.pat)) {
 477             if in_external_macro(cx.sess(), decl.span) || in_macro(local.pat.span) {
 478                 return;
 479             }
 480             if higher::is_from_for_desugar(decl) {
 481                 return;
 482             }
 483             span_lint(
 484                 cx,
 485                 LET_UNIT_VALUE,
 486                 decl.span,
 487                 &format!(
 488                     "this let-binding has unit value. Consider omitting `let {} =`",
 489                     snippet(cx, local.pat.span, "..")
 490                 ),
 491             );
 492         }
 493     }
 494 }
 495
 496 impl LintPass for LetPass {
 497     fn get_lints(&self) -> LintArray {
 498         lint_array!(LET_UNIT_VALUE)
 499     }
 500 }
 501
 502 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetPass {
 503     fn check_decl(&mut self, cx: &LateContext<'a, 'tcx>, decl: &'tcx Decl) {
 504         check_let_unit(cx, decl)
 505     }
 506 }
 507
 508 /// **What it does:** Checks for comparisons to unit.
 509 ///
 510 /// **Why is this bad?** Unit is always equal to itself, and thus is just a
 511 /// clumsily written constant. Mostly this happens when someone accidentally
 512 /// adds semicolons at the end of the operands.
 513 ///
 514 /// **Known problems:** None.
 515 ///
 516 /// **Example:**
 517 /// ```rust
 518 /// if {
 519 ///     foo();
 520 /// } == {
 521 ///     bar();
 522 /// } {
 523 ///     baz();
 524 /// }
 525 /// ```
 526 /// is equal to
 527 /// ```rust
 528 /// {
 529 ///     foo();
 530 ///     bar();
 531 ///     baz();
 532 /// }
 533 /// ```
 534 declare_clippy_lint! {
 535     pub UNIT_CMP,
 536     correctness,
 537     "comparing unit values"
 538 }
 539
 540 pub struct UnitCmp;
 541
 542 impl LintPass for UnitCmp {
 543     fn get_lints(&self) -> LintArray {
 544         lint_array!(UNIT_CMP)
 545     }
 546 }
 547
 548 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitCmp {
 549     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
 550         if in_macro(expr.span) {
 551             return;
 552         }
 553         if let ExprKind::Binary(ref cmp, ref left, _) = expr.node {
 554             let op = cmp.node;
 555             if op.is_comparison() && is_unit(cx.tables.expr_ty(left)) {
 556                 let result = match op {
 557                     BinOpKind::Eq | BinOpKind::Le | BinOpKind::Ge => "true",
 558                     _ => "false",
 559                 };
 560                 span_lint(
 561                     cx,
 562                     UNIT_CMP,
 563                     expr.span,
 564                     &format!(
 565                         "{}-comparison of unit values detected. This will always be {}",
 566                         op.as_str(),
 567                         result
 568                     ),
 569                 );
 570             }
 571         }
 572     }
 573 }
 574
 575 /// **What it does:** Checks for passing a unit value as an argument to a function without using a
 576 /// unit literal (`()`).
 577 ///
 578 /// **Why is this bad?** This is likely the result of an accidental semicolon.
 579 ///
 580 /// **Known problems:** None.
 581 ///
 582 /// **Example:**
 583 /// ```rust
 584 /// foo({
 585 ///     let a = bar();
 586 ///     baz(a);
 587 /// })
 588 /// ```
 589 declare_clippy_lint! {
 590     pub UNIT_ARG,
 591     complexity,
 592     "passing unit to a function"
 593 }
 594
 595 pub struct UnitArg;
 596
 597 impl LintPass for UnitArg {
 598     fn get_lints(&self) -> LintArray {
 599         lint_array!(UNIT_ARG)
 600     }
 601 }
 602
 603 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg {
 604     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
 605         if in_macro(expr.span) {
 606             return;
 607         }
 608         match expr.node {
 609             ExprKind::Call(_, ref args) | ExprKind::MethodCall(_, _, ref args) => {
 610                 for arg in args {
 611                     if is_unit(cx.tables.expr_ty(arg)) && !is_unit_literal(arg) {
 612                         let map = &cx.tcx.hir();
 613                         // apparently stuff in the desugaring of `?` can trigger this
 614                         // so check for that here
 615                         // only the calls to `Try::from_error` is marked as desugared,
 616                         // so we need to check both the current Expr and its parent.
 617                         if !is_questionmark_desugar_marked_call(expr) {
 618                             if_chain! {
 619                                 let opt_parent_node = map.find(map.get_parent_node(expr.id));
 620                                 if let Some(hir::Node::Expr(parent_expr)) = opt_parent_node;
 621                                 if is_questionmark_desugar_marked_call(parent_expr);
 622                                 then {}
 623                                 else {
 624                                     // `expr` and `parent_expr` where _both_ not from
 625                                     // desugaring `?`, so lint
 626                                     span_lint_and_sugg(
 627                                         cx,
 628                                         UNIT_ARG,
 629                                         arg.span,
 630                                         "passing a unit value to a function",
 631                                         "if you intended to pass a unit value, use a unit literal instead",
 632                                         "()".to_string(),
 633                                         Applicability::MachineApplicable,
 634                                     );
 635                                 }
 636                             }
 637                         }
 638                     }
 639                 }
 640             },
 641             _ => (),
 642         }
 643     }
 644 }
 645
 646 fn is_questionmark_desugar_marked_call(expr: &Expr) -> bool {
 647     use crate::syntax_pos::hygiene::CompilerDesugaringKind;
 648     if let ExprKind::Call(ref callee, _) = expr.node {
 649         callee.span.is_compiler_desugaring(CompilerDesugaringKind::QuestionMark)
 650     } else {
 651         false
 652     }
 653 }
 654
 655 fn is_unit(ty: Ty<'_>) -> bool {
 656     match ty.sty {
 657         ty::Tuple(slice) if slice.is_empty() => true,
 658         _ => false,
 659     }
 660 }
 661
 662 fn is_unit_literal(expr: &Expr) -> bool {
 663     match expr.node {
 664         ExprKind::Tup(ref slice) if slice.is_empty() => true,
 665         _ => false,
 666     }
 667 }
 668
 669 pub struct CastPass;
 670
 671 /// **What it does:** Checks for casts from any numerical to a float type where
 672 /// the receiving type cannot store all values from the original type without
 673 /// rounding errors. This possible rounding is to be expected, so this lint is
 674 /// `Allow` by default.
 675 ///
 676 /// Basically, this warns on casting any integer with 32 or more bits to `f32`
 677 /// or any 64-bit integer to `f64`.
 678 ///
 679 /// **Why is this bad?** It's not bad at all. But in some applications it can be
 680 /// helpful to know where precision loss can take place. This lint can help find
 681 /// those places in the code.
 682 ///
 683 /// **Known problems:** None.
 684 ///
 685 /// **Example:**
 686 /// ```rust
 687 /// let x = u64::MAX;
 688 /// x as f64
 689 /// ```
 690 declare_clippy_lint! {
 691     pub CAST_PRECISION_LOSS,
 692     pedantic,
 693     "casts that cause loss of precision, e.g. `x as f32` where `x: u64`"
 694 }
 695
 696 /// **What it does:** Checks for casts from a signed to an unsigned numerical
 697 /// type. In this case, negative values wrap around to large positive values,
 698 /// which can be quite surprising in practice. However, as the cast works as
 699 /// defined, this lint is `Allow` by default.
 700 ///
 701 /// **Why is this bad?** Possibly surprising results. You can activate this lint
 702 /// as a one-time check to see where numerical wrapping can arise.
 703 ///
 704 /// **Known problems:** None.
 705 ///
 706 /// **Example:**
 707 /// ```rust
 708 /// let y: i8 = -1;
 709 /// y as u128 // will return 18446744073709551615
 710 /// ```
 711 declare_clippy_lint! {
 712     pub CAST_SIGN_LOSS,
 713     pedantic,
 714     "casts from signed types to unsigned types, e.g. `x as u32` where `x: i32`"
 715 }
 716
 717 /// **What it does:** Checks for on casts between numerical types that may
 718 /// truncate large values. This is expected behavior, so the cast is `Allow` by
 719 /// default.
 720 ///
 721 /// **Why is this bad?** In some problem domains, it is good practice to avoid
 722 /// truncation. This lint can be activated to help assess where additional
 723 /// checks could be beneficial.
 724 ///
 725 /// **Known problems:** None.
 726 ///
 727 /// **Example:**
 728 /// ```rust
 729 /// fn as_u8(x: u64) -> u8 {
 730 ///     x as u8
 731 /// }
 732 /// ```
 733 declare_clippy_lint! {
 734     pub CAST_POSSIBLE_TRUNCATION,
 735     pedantic,
 736     "casts that may cause truncation of the value, e.g. `x as u8` where `x: u32`, or `x as i32` where `x: f32`"
 737 }
 738
 739 /// **What it does:** Checks for casts from an unsigned type to a signed type of
 740 /// the same size. Performing such a cast is a 'no-op' for the compiler,
 741 /// i.e. nothing is changed at the bit level, and the binary representation of
 742 /// the value is reinterpreted. This can cause wrapping if the value is too big
 743 /// for the target signed type. However, the cast works as defined, so this lint
 744 /// is `Allow` by default.
 745 ///
 746 /// **Why is this bad?** While such a cast is not bad in itself, the results can
 747 /// be surprising when this is not the intended behavior, as demonstrated by the
 748 /// example below.
 749 ///
 750 /// **Known problems:** None.
 751 ///
 752 /// **Example:**
 753 /// ```rust
 754 /// u32::MAX as i32 // will yield a value of `-1`
 755 /// ```
 756 declare_clippy_lint! {
 757     pub CAST_POSSIBLE_WRAP,
 758     pedantic,
 759     "casts that may cause wrapping around the value, e.g. `x as i32` where `x: u32` and `x > i32::MAX`"
 760 }
 761
 762 /// **What it does:** Checks for on casts between numerical types that may
 763 /// be replaced by safe conversion functions.
 764 ///
 765 /// **Why is this bad?** Rust's `as` keyword will perform many kinds of
 766 /// conversions, including silently lossy conversions. Conversion functions such
 767 /// as `i32::from` will only perform lossless conversions. Using the conversion
 768 /// functions prevents conversions from turning into silent lossy conversions if
 769 /// the types of the input expressions ever change, and make it easier for
 770 /// people reading the code to know that the conversion is lossless.
 771 ///
 772 /// **Known problems:** None.
 773 ///
 774 /// **Example:**
 775 /// ```rust
 776 /// fn as_u64(x: u8) -> u64 {
 777 ///     x as u64
 778 /// }
 779 /// ```
 780 ///
 781 /// Using `::from` would look like this:
 782 ///
 783 /// ```rust
 784 /// fn as_u64(x: u8) -> u64 {
 785 ///     u64::from(x)
 786 /// }
 787 /// ```
 788 declare_clippy_lint! {
 789     pub CAST_LOSSLESS,
 790     complexity,
 791     "casts using `as` that are known to be lossless, e.g. `x as u64` where `x: u8`"
 792 }
 793
 794 /// **What it does:** Checks for casts to the same type.
 795 ///
 796 /// **Why is this bad?** It's just unnecessary.
 797 ///
 798 /// **Known problems:** None.
 799 ///
 800 /// **Example:**
 801 /// ```rust
 802 /// let _ = 2i32 as i32
 803 /// ```
 804 declare_clippy_lint! {
 805     pub UNNECESSARY_CAST,
 806     complexity,
 807     "cast to the same type, e.g. `x as i32` where `x: i32`"
 808 }
 809
 810 /// **What it does:** Checks for casts from a less-strictly-aligned pointer to a
 811 /// more-strictly-aligned pointer
 812 ///
 813 /// **Why is this bad?** Dereferencing the resulting pointer may be undefined
 814 /// behavior.
 815 ///
 816 /// **Known problems:** None.
 817 ///
 818 /// **Example:**
 819 /// ```rust
 820 /// let _ = (&1u8 as *const u8) as *const u16;
 821 /// let _ = (&mut 1u8 as *mut u8) as *mut u16;
 822 /// ```
 823 declare_clippy_lint! {
 824     pub CAST_PTR_ALIGNMENT,
 825     correctness,
 826     "cast from a pointer to a more-strictly-aligned pointer"
 827 }
 828
 829 /// **What it does:** Checks for casts of function pointers to something other than usize
 830 ///
 831 /// **Why is this bad?**
 832 /// Casting a function pointer to anything other than usize/isize is not portable across
 833 /// architectures, because you end up losing bits if the target type is too small or end up with a
 834 /// bunch of extra bits that waste space and add more instructions to the final binary than
 835 /// strictly necessary for the problem
 836 ///
 837 /// Casting to isize also doesn't make sense since there are no signed addresses.
 838 ///
 839 /// **Example**
 840 ///
 841 /// ```rust
 842 /// // Bad
 843 /// fn fun() -> i32 {}
 844 /// let a = fun as i64;
 845 ///
 846 /// // Good
 847 /// fn fun2() -> i32 {}
 848 /// let a = fun2 as usize;
 849 /// ```
 850 declare_clippy_lint! {
 851     pub FN_TO_NUMERIC_CAST,
 852     style,
 853     "casting a function pointer to a numeric type other than usize"
 854 }
 855
 856 /// **What it does:** Checks for casts of a function pointer to a numeric type not wide enough to
 857 /// store address.
 858 ///
 859 /// **Why is this bad?**
 860 /// Such a cast discards some bits of the function's address. If this is intended, it would be more
 861 /// clearly expressed by casting to usize first, then casting the usize to the intended type (with
 862 /// a comment) to perform the truncation.
 863 ///
 864 /// **Example**
 865 ///
 866 /// ```rust
 867 /// // Bad
 868 /// fn fn1() -> i16 {
 869 ///     1
 870 /// };
 871 /// let _ = fn1 as i32;
 872 ///
 873 /// // Better: Cast to usize first, then comment with the reason for the truncation
 874 /// fn fn2() -> i16 {
 875 ///     1
 876 /// };
 877 /// let fn_ptr = fn2 as usize;
 878 /// let fn_ptr_truncated = fn_ptr as i32;
 879 /// ```
 880 declare_clippy_lint! {
 881     pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
 882     style,
 883     "casting a function pointer to a numeric type not wide enough to store the address"
 884 }
 885
 886 /// Returns the size in bits of an integral type.
 887 /// Will return 0 if the type is not an int or uint variant
 888 fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_, '_, '_>) -> u64 {
 889     match typ.sty {
 890         ty::Int(i) => match i {
 891             IntTy::Isize => tcx.data_layout.pointer_size.bits(),
 892             IntTy::I8 => 8,
 893             IntTy::I16 => 16,
 894             IntTy::I32 => 32,
 895             IntTy::I64 => 64,
 896             IntTy::I128 => 128,
 897         },
 898         ty::Uint(i) => match i {
 899             UintTy::Usize => tcx.data_layout.pointer_size.bits(),
 900             UintTy::U8 => 8,
 901             UintTy::U16 => 16,
 902             UintTy::U32 => 32,
 903             UintTy::U64 => 64,
 904             UintTy::U128 => 128,
 905         },
 906         _ => 0,
 907     }
 908 }
 909
 910 fn is_isize_or_usize(typ: Ty<'_>) -> bool {
 911     match typ.sty {
 912         ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize) => true,
 913         _ => false,
 914     }
 915 }
 916
 917 fn span_precision_loss_lint(cx: &LateContext<'_, '_>, expr: &Expr, cast_from: Ty<'_>, cast_to_f64: bool) {
 918     let mantissa_nbits = if cast_to_f64 { 52 } else { 23 };
 919     let arch_dependent = is_isize_or_usize(cast_from) && cast_to_f64;
 920     let arch_dependent_str = "on targets with 64-bit wide pointers ";
 921     let from_nbits_str = if arch_dependent {
 922         "64".to_owned()
 923     } else if is_isize_or_usize(cast_from) {
 924         "32 or 64".to_owned()
 925     } else {
 926         int_ty_to_nbits(cast_from, cx.tcx).to_string()
 927     };
 928     span_lint(
 929         cx,
 930         CAST_PRECISION_LOSS,
 931         expr.span,
 932         &format!(
 933             "casting {0} to {1} causes a loss of precision {2}({0} is {3} bits wide, but {1}'s mantissa \
 934              is only {4} bits wide)",
 935             cast_from,
 936             if cast_to_f64 { "f64" } else { "f32" },
 937             if arch_dependent { arch_dependent_str } else { "" },
 938             from_nbits_str,
 939             mantissa_nbits
 940         ),
 941     );
 942 }
 943
 944 fn should_strip_parens(op: &Expr, snip: &str) -> bool {
 945     if let ExprKind::Binary(_, _, _) = op.node {
 946         if snip.starts_with('(') && snip.ends_with(')') {
 947             return true;
 948         }
 949     }
 950     false
 951 }
 952
 953 fn span_lossless_lint(cx: &LateContext<'_, '_>, expr: &Expr, op: &Expr, cast_from: Ty<'_>, cast_to: Ty<'_>) {
 954     // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
 955     if in_constant(cx, expr.id) {
 956         return;
 957     }
 958     // The suggestion is to use a function call, so if the original expression
 959     // has parens on the outside, they are no longer needed.
 960     let mut applicability = Applicability::MachineApplicable;
 961     let opt = snippet_opt(cx, op.span);
 962     let sugg = if let Some(ref snip) = opt {
 963         if should_strip_parens(op, snip) {
 964             &snip[1..snip.len() - 1]
 965         } else {
 966             snip.as_str()
 967         }
 968     } else {
 969         applicability = Applicability::HasPlaceholders;
 970         ".."
 971     };
 972
 973     span_lint_and_sugg(
 974         cx,
 975         CAST_LOSSLESS,
 976         expr.span,
 977         &format!(
 978             "casting {} to {} may become silently lossy if types change",
 979             cast_from, cast_to
 980         ),
 981         "try",
 982         format!("{}::from({})", cast_to, sugg),
 983         applicability,
 984     );
 985 }
 986
 987 enum ArchSuffix {
 988     _32,
 989     _64,
 990     None,
 991 }
 992
 993 fn check_truncation_and_wrapping(cx: &LateContext<'_, '_>, expr: &Expr, cast_from: Ty<'_>, cast_to: Ty<'_>) {
 994     let arch_64_suffix = " on targets with 64-bit wide pointers";
 995     let arch_32_suffix = " on targets with 32-bit wide pointers";
 996     let cast_unsigned_to_signed = !cast_from.is_signed() && cast_to.is_signed();
 997     let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
 998     let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
 999     let (span_truncation, suffix_truncation, span_wrap, suffix_wrap) =
1000         match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
1001             (true, true) | (false, false) => (
1002                 to_nbits < from_nbits,
1003                 ArchSuffix::None,
1004                 to_nbits == from_nbits && cast_unsigned_to_signed,
1005                 ArchSuffix::None,
1006             ),
1007             (true, false) => (
1008                 to_nbits <= 32,
1009                 if to_nbits == 32 {
1010                     ArchSuffix::_64
1011                 } else {
1012                     ArchSuffix::None
1013                 },
1014                 to_nbits <= 32 && cast_unsigned_to_signed,
1015                 ArchSuffix::_32,
1016             ),
1017             (false, true) => (
1018                 from_nbits == 64,
1019                 ArchSuffix::_32,
1020                 cast_unsigned_to_signed,
1021                 if from_nbits == 64 {
1022                     ArchSuffix::_64
1023                 } else {
1024                     ArchSuffix::_32
1025                 },
1026             ),
1027         };
1028     if span_truncation {
1029         span_lint(
1030             cx,
1031             CAST_POSSIBLE_TRUNCATION,
1032             expr.span,
1033             &format!(
1034                 "casting {} to {} may truncate the value{}",
1035                 cast_from,
1036                 cast_to,
1037                 match suffix_truncation {
1038                     ArchSuffix::_32 => arch_32_suffix,
1039                     ArchSuffix::_64 => arch_64_suffix,
1040                     ArchSuffix::None => "",
1041                 }
1042             ),
1043         );
1044     }
1045     if span_wrap {
1046         span_lint(
1047             cx,
1048             CAST_POSSIBLE_WRAP,
1049             expr.span,
1050             &format!(
1051                 "casting {} to {} may wrap around the value{}",
1052                 cast_from,
1053                 cast_to,
1054                 match suffix_wrap {
1055                     ArchSuffix::_32 => arch_32_suffix,
1056                     ArchSuffix::_64 => arch_64_suffix,
1057                     ArchSuffix::None => "",
1058                 }
1059             ),
1060         );
1061     }
1062 }
1063
1064 fn check_lossless(cx: &LateContext<'_, '_>, expr: &Expr, op: &Expr, cast_from: Ty<'_>, cast_to: Ty<'_>) {
1065     let cast_signed_to_unsigned = cast_from.is_signed() && !cast_to.is_signed();
1066     let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
1067     let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
1068     if !is_isize_or_usize(cast_from) && !is_isize_or_usize(cast_to) && from_nbits < to_nbits && !cast_signed_to_unsigned
1069     {
1070         span_lossless_lint(cx, expr, op, cast_from, cast_to);
1071     }
1072 }
1073
1074 impl LintPass for CastPass {
1075     fn get_lints(&self) -> LintArray {
1076         lint_array!(
1077             CAST_PRECISION_LOSS,
1078             CAST_SIGN_LOSS,
1079             CAST_POSSIBLE_TRUNCATION,
1080             CAST_POSSIBLE_WRAP,
1081             CAST_LOSSLESS,
1082             UNNECESSARY_CAST,
1083             CAST_PTR_ALIGNMENT,
1084             FN_TO_NUMERIC_CAST,
1085             FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
1086         )
1087     }
1088 }
1089
1090 // Check if the given type is either `core::ffi::c_void` or
1091 // one of the platform specific `libc::<platform>::c_void` of libc.
1092 fn is_c_void(tcx: TyCtxt<'_, '_, '_>, ty: Ty<'_>) -> bool {
1093     if let ty::Adt(adt, _) = ty.sty {
1094         let mut apb = AbsolutePathBuffer { names: vec![] };
1095         tcx.push_item_path(&mut apb, adt.did, false);
1096
1097         if apb.names.is_empty() {
1098             return false;
1099         }
1100         if apb.names[0] == "libc" || apb.names[0] == "core" && *apb.names.last().unwrap() == "c_void" {
1101             return true;
1102         }
1103     }
1104     false
1105 }
1106
1107 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass {
1108     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
1109         if let ExprKind::Cast(ref ex, _) = expr.node {
1110             let (cast_from, cast_to) = (cx.tables.expr_ty(ex), cx.tables.expr_ty(expr));
1111             lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
1112             if let ExprKind::Lit(ref lit) = ex.node {
1113                 use crate::syntax::ast::{LitIntType, LitKind};
1114                 match lit.node {
1115                     LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::FloatUnsuffixed(_) => {},
1116                     _ => {
1117                         if cast_from.sty == cast_to.sty && !in_external_macro(cx.sess(), expr.span) {
1118                             span_lint(
1119                                 cx,
1120                                 UNNECESSARY_CAST,
1121                                 expr.span,
1122                                 &format!(
1123                                     "casting to the same type is unnecessary (`{}` -> `{}`)",
1124                                     cast_from, cast_to
1125                                 ),
1126                             );
1127                         }
1128                     },
1129                 }
1130             }
1131             if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
1132                 match (cast_from.is_integral(), cast_to.is_integral()) {
1133                     (true, false) => {
1134                         let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
1135                         let to_nbits = if let ty::Float(FloatTy::F32) = cast_to.sty {
1136                             32
1137                         } else {
1138                             64
1139                         };
1140                         if is_isize_or_usize(cast_from) || from_nbits >= to_nbits {
1141                             span_precision_loss_lint(cx, expr, cast_from, to_nbits == 64);
1142                         }
1143                         if from_nbits < to_nbits {
1144                             span_lossless_lint(cx, expr, ex, cast_from, cast_to);
1145                         }
1146                     },
1147                     (false, true) => {
1148                         span_lint(
1149                             cx,
1150                             CAST_POSSIBLE_TRUNCATION,
1151                             expr.span,
1152                             &format!("casting {} to {} may truncate the value", cast_from, cast_to),
1153                         );
1154                         if !cast_to.is_signed() {
1155                             span_lint(
1156                                 cx,
1157                                 CAST_SIGN_LOSS,
1158                                 expr.span,
1159                                 &format!("casting {} to {} may lose the sign of the value", cast_from, cast_to),
1160                             );
1161                         }
1162                     },
1163                     (true, true) => {
1164                         if cast_from.is_signed() && !cast_to.is_signed() {
1165                             span_lint(
1166                                 cx,
1167                                 CAST_SIGN_LOSS,
1168                                 expr.span,
1169                                 &format!("casting {} to {} may lose the sign of the value", cast_from, cast_to),
1170                             );
1171                         }
1172                         check_truncation_and_wrapping(cx, expr, cast_from, cast_to);
1173                         check_lossless(cx, expr, ex, cast_from, cast_to);
1174                     },
1175                     (false, false) => {
1176                         if let (&ty::Float(FloatTy::F64), &ty::Float(FloatTy::F32)) = (&cast_from.sty, &cast_to.sty) {
1177                             span_lint(
1178                                 cx,
1179                                 CAST_POSSIBLE_TRUNCATION,
1180                                 expr.span,
1181                                 "casting f64 to f32 may truncate the value",
1182                             );
1183                         }
1184                         if let (&ty::Float(FloatTy::F32), &ty::Float(FloatTy::F64)) = (&cast_from.sty, &cast_to.sty) {
1185                             span_lossless_lint(cx, expr, ex, cast_from, cast_to);
1186                         }
1187                     },
1188                 }
1189             }
1190
1191             if_chain! {
1192                 if let ty::RawPtr(from_ptr_ty) = &cast_from.sty;
1193                 if let ty::RawPtr(to_ptr_ty) = &cast_to.sty;
1194                 if let Some(from_align) = cx.layout_of(from_ptr_ty.ty).ok().map(|a| a.align.abi);
1195                 if let Some(to_align) = cx.layout_of(to_ptr_ty.ty).ok().map(|a| a.align.abi);
1196                 if from_align < to_align;
1197                 // with c_void, we inherently need to trust the user
1198                 if !is_c_void(cx.tcx, from_ptr_ty.ty);
1199                 then {
1200                     span_lint(
1201                         cx,
1202                         CAST_PTR_ALIGNMENT,
1203                         expr.span,
1204                         &format!("casting from `{}` to a more-strictly-aligned pointer (`{}`)", cast_from, cast_to)
1205                     );
1206                 }
1207             }
1208         }
1209     }
1210 }
1211
1212 fn lint_fn_to_numeric_cast(
1213     cx: &LateContext<'_, '_>,
1214     expr: &Expr,
1215     cast_expr: &Expr,
1216     cast_from: Ty<'_>,
1217     cast_to: Ty<'_>,
1218 ) {
1219     // We only want to check casts to `ty::Uint` or `ty::Int`
1220     match cast_to.sty {
1221         ty::Uint(_) | ty::Int(..) => { /* continue on */ },
1222         _ => return,
1223     }
1224     match cast_from.sty {
1225         ty::FnDef(..) | ty::FnPtr(_) => {
1226             let mut applicability = Applicability::MachineApplicable;
1227             let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
1228
1229             let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
1230             if to_nbits < cx.tcx.data_layout.pointer_size.bits() {
1231                 span_lint_and_sugg(
1232                     cx,
1233                     FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
1234                     expr.span,
1235                     &format!(
1236                         "casting function pointer `{}` to `{}`, which truncates the value",
1237                         from_snippet, cast_to
1238                     ),
1239                     "try",
1240                     format!("{} as usize", from_snippet),
1241                     applicability,
1242                 );
1243             } else if cast_to.sty != ty::Uint(UintTy::Usize) {
1244                 span_lint_and_sugg(
1245                     cx,
1246                     FN_TO_NUMERIC_CAST,
1247                     expr.span,
1248                     &format!("casting function pointer `{}` to `{}`", from_snippet, cast_to),
1249                     "try",
1250                     format!("{} as usize", from_snippet),
1251                     applicability,
1252                 );
1253             }
1254         },
1255         _ => {},
1256     }
1257 }
1258
1259 /// **What it does:** Checks for types used in structs, parameters and `let`
1260 /// declarations above a certain complexity threshold.
1261 ///
1262 /// **Why is this bad?** Too complex types make the code less readable. Consider
1263 /// using a `type` definition to simplify them.
1264 ///
1265 /// **Known problems:** None.
1266 ///
1267 /// **Example:**
1268 /// ```rust
1269 /// struct Foo {
1270 ///     inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>>,
1271 /// }
1272 /// ```
1273 declare_clippy_lint! {
1274     pub TYPE_COMPLEXITY,
1275     complexity,
1276     "usage of very complex types that might be better factored into `type` definitions"
1277 }
1278
1279 pub struct TypeComplexityPass {
1280     threshold: u64,
1281 }
1282
1283 impl TypeComplexityPass {
1284     pub fn new(threshold: u64) -> Self {
1285         Self { threshold }
1286     }
1287 }
1288
1289 impl LintPass for TypeComplexityPass {
1290     fn get_lints(&self) -> LintArray {
1291         lint_array!(TYPE_COMPLEXITY)
1292     }
1293 }
1294
1295 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeComplexityPass {
1296     fn check_fn(
1297         &mut self,
1298         cx: &LateContext<'a, 'tcx>,
1299         _: FnKind<'tcx>,
1300         decl: &'tcx FnDecl,
1301         _: &'tcx Body,
1302         _: Span,
1303         _: NodeId,
1304     ) {
1305         self.check_fndecl(cx, decl);
1306     }
1307
1308     fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx StructField) {
1309         // enum variants are also struct fields now
1310         self.check_type(cx, &field.ty);
1311     }
1312
1313     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
1314         match item.node {
1315             ItemKind::Static(ref ty, _, _) | ItemKind::Const(ref ty, _) => self.check_type(cx, ty),
1316             // functions, enums, structs, impls and traits are covered
1317             _ => (),
1318         }
1319     }
1320
1321     fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) {
1322         match item.node {
1323             TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => self.check_type(cx, ty),
1324             TraitItemKind::Method(MethodSig { ref decl, .. }, TraitMethod::Required(_)) => self.check_fndecl(cx, decl),
1325             // methods with default impl are covered by check_fn
1326             _ => (),
1327         }
1328     }
1329
1330     fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) {
1331         match item.node {
1332             ImplItemKind::Const(ref ty, _) | ImplItemKind::Type(ref ty) => self.check_type(cx, ty),
1333             // methods are covered by check_fn
1334             _ => (),
1335         }
1336     }
1337
1338     fn check_local(&mut self, cx: &LateContext<'a, 'tcx>, local: &'tcx Local) {
1339         if let Some(ref ty) = local.ty {
1340             self.check_type(cx, ty);
1341         }
1342     }
1343 }
1344
1345 impl<'a, 'tcx> TypeComplexityPass {
1346     fn check_fndecl(&self, cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl) {
1347         for arg in &decl.inputs {
1348             self.check_type(cx, arg);
1349         }
1350         if let Return(ref ty) = decl.output {
1351             self.check_type(cx, ty);
1352         }
1353     }
1354
1355     fn check_type(&self, cx: &LateContext<'_, '_>, ty: &hir::Ty) {
1356         if in_macro(ty.span) {
1357             return;
1358         }
1359         let score = {
1360             let mut visitor = TypeComplexityVisitor { score: 0, nest: 1 };
1361             visitor.visit_ty(ty);
1362             visitor.score
1363         };
1364
1365         if score > self.threshold {
1366             span_lint(
1367                 cx,
1368                 TYPE_COMPLEXITY,
1369                 ty.span,
1370                 "very complex type used. Consider factoring parts into `type` definitions",
1371             );
1372         }
1373     }
1374 }
1375
1376 /// Walks a type and assigns a complexity score to it.
1377 struct TypeComplexityVisitor {
1378     /// total complexity score of the type
1379     score: u64,
1380     /// current nesting level
1381     nest: u64,
1382 }
1383
1384 impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
1385     fn visit_ty(&mut self, ty: &'tcx hir::Ty) {
1386         let (add_score, sub_nest) = match ty.node {
1387             // _, &x and *x have only small overhead; don't mess with nesting level
1388             TyKind::Infer | TyKind::Ptr(..) | TyKind::Rptr(..) => (1, 0),
1389
1390             // the "normal" components of a type: named types, arrays/tuples
1391             TyKind::Path(..) | TyKind::Slice(..) | TyKind::Tup(..) | TyKind::Array(..) => (10 * self.nest, 1),
1392
1393             // function types bring a lot of overhead
1394             TyKind::BareFn(ref bare) if bare.abi == Abi::Rust => (50 * self.nest, 1),
1395
1396             TyKind::TraitObject(ref param_bounds, _) => {
1397                 let has_lifetime_parameters = param_bounds.iter().any(|bound| {
1398                     bound.bound_generic_params.iter().any(|gen| match gen.kind {
1399                         GenericParamKind::Lifetime { .. } => true,
1400                         _ => false,
1401                     })
1402                 });
1403                 if has_lifetime_parameters {
1404                     // complex trait bounds like A<'a, 'b>
1405                     (50 * self.nest, 1)
1406                 } else {
1407                     // simple trait bounds like A + B
1408                     (20 * self.nest, 0)
1409                 }
1410             },
1411
1412             _ => (0, 0),
1413         };
1414         self.score += add_score;
1415         self.nest += sub_nest;
1416         walk_ty(self, ty);
1417         self.nest -= sub_nest;
1418     }
1419     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
1420         NestedVisitorMap::None
1421     }
1422 }
1423
1424 /// **What it does:** Checks for expressions where a character literal is cast
1425 /// to `u8` and suggests using a byte literal instead.
1426 ///
1427 /// **Why is this bad?** In general, casting values to smaller types is
1428 /// error-prone and should be avoided where possible. In the particular case of
1429 /// converting a character literal to u8, it is easy to avoid by just using a
1430 /// byte literal instead. As an added bonus, `b'a'` is even slightly shorter
1431 /// than `'a' as u8`.
1432 ///
1433 /// **Known problems:** None.
1434 ///
1435 /// **Example:**
1436 /// ```rust
1437 /// 'x' as u8
1438 /// ```
1439 ///
1440 /// A better version, using the byte literal:
1441 ///
1442 /// ```rust
1443 /// b'x'
1444 /// ```
1445 declare_clippy_lint! {
1446     pub CHAR_LIT_AS_U8,
1447     complexity,
1448     "casting a character literal to u8"
1449 }
1450
1451 pub struct CharLitAsU8;
1452
1453 impl LintPass for CharLitAsU8 {
1454     fn get_lints(&self) -> LintArray {
1455         lint_array!(CHAR_LIT_AS_U8)
1456     }
1457 }
1458
1459 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CharLitAsU8 {
1460     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
1461         use crate::syntax::ast::{LitKind, UintTy};
1462
1463         if let ExprKind::Cast(ref e, _) = expr.node {
1464             if let ExprKind::Lit(ref l) = e.node {
1465                 if let LitKind::Char(_) = l.node {
1466                     if ty::Uint(UintTy::U8) == cx.tables.expr_ty(expr).sty && !in_macro(expr.span) {
1467                         let msg = "casting character literal to u8. `char`s \
1468                                    are 4 bytes wide in rust, so casting to u8 \
1469                                    truncates them";
1470                         let help = format!(
1471                             "Consider using a byte literal instead:\nb{}",
1472                             snippet(cx, e.span, "'x'")
1473                         );
1474                         span_help_and_lint(cx, CHAR_LIT_AS_U8, expr.span, msg, &help);
1475                     }
1476                 }
1477             }
1478         }
1479     }
1480 }
1481
1482 /// **What it does:** Checks for comparisons where one side of the relation is
1483 /// either the minimum or maximum value for its type and warns if it involves a
1484 /// case that is always true or always false. Only integer and boolean types are
1485 /// checked.
1486 ///
1487 /// **Why is this bad?** An expression like `min <= x` may misleadingly imply
1488 /// that is is possible for `x` to be less than the minimum. Expressions like
1489 /// `max < x` are probably mistakes.
1490 ///
1491 /// **Known problems:** For `usize` the size of the current compile target will
1492 /// be assumed (e.g. 64 bits on 64 bit systems). This means code that uses such
1493 /// a comparison to detect target pointer width will trigger this lint. One can
1494 /// use `mem::sizeof` and compare its value or conditional compilation
1495 /// attributes
1496 /// like `#[cfg(target_pointer_width = "64")] ..` instead.
1497 ///
1498 /// **Example:**
1499 /// ```rust
1500 /// vec.len() <= 0
1501 /// 100 > std::i32::MAX
1502 /// ```
1503 declare_clippy_lint! {
1504     pub ABSURD_EXTREME_COMPARISONS,
1505     correctness,
1506     "a comparison with a maximum or minimum value that is always true or false"
1507 }
1508
1509 pub struct AbsurdExtremeComparisons;
1510
1511 impl LintPass for AbsurdExtremeComparisons {
1512     fn get_lints(&self) -> LintArray {
1513         lint_array!(ABSURD_EXTREME_COMPARISONS)
1514     }
1515 }
1516
1517 enum ExtremeType {
1518     Minimum,
1519     Maximum,
1520 }
1521
1522 struct ExtremeExpr<'a> {
1523     which: ExtremeType,
1524     expr: &'a Expr,
1525 }
1526
1527 enum AbsurdComparisonResult {
1528     AlwaysFalse,
1529     AlwaysTrue,
1530     InequalityImpossible,
1531 }
1532
1533 fn is_cast_between_fixed_and_target<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) -> bool {
1534     if let ExprKind::Cast(ref cast_exp, _) = expr.node {
1535         let precast_ty = cx.tables.expr_ty(cast_exp);
1536         let cast_ty = cx.tables.expr_ty(expr);
1537
1538         return is_isize_or_usize(precast_ty) != is_isize_or_usize(cast_ty);
1539     }
1540
1541     false
1542 }
1543
1544 fn detect_absurd_comparison<'a, 'tcx>(
1545     cx: &LateContext<'a, 'tcx>,
1546     op: BinOpKind,
1547     lhs: &'tcx Expr,
1548     rhs: &'tcx Expr,
1549 ) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> {
1550     use crate::types::AbsurdComparisonResult::*;
1551     use crate::types::ExtremeType::*;
1552     use crate::utils::comparisons::*;
1553
1554     // absurd comparison only makes sense on primitive types
1555     // primitive types don't implement comparison operators with each other
1556     if cx.tables.expr_ty(lhs) != cx.tables.expr_ty(rhs) {
1557         return None;
1558     }
1559
1560     // comparisons between fix sized types and target sized types are considered unanalyzable
1561     if is_cast_between_fixed_and_target(cx, lhs) || is_cast_between_fixed_and_target(cx, rhs) {
1562         return None;
1563     }
1564
1565     let normalized = normalize_comparison(op, lhs, rhs);
1566     let (rel, normalized_lhs, normalized_rhs) = if let Some(val) = normalized {
1567         val
1568     } else {
1569         return None;
1570     };
1571
1572     let lx = detect_extreme_expr(cx, normalized_lhs);
1573     let rx = detect_extreme_expr(cx, normalized_rhs);
1574
1575     Some(match rel {
1576         Rel::Lt => {
1577             match (lx, rx) {
1578                 (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, AlwaysFalse), // max < x
1579                 (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, AlwaysFalse), // x < min
1580                 _ => return None,
1581             }
1582         },
1583         Rel::Le => {
1584             match (lx, rx) {
1585                 (Some(l @ ExtremeExpr { which: Minimum, .. }), _) => (l, AlwaysTrue), // min <= x
1586                 (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, InequalityImpossible), // max <= x
1587                 (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, InequalityImpossible), // x <= min
1588                 (_, Some(r @ ExtremeExpr { which: Maximum, .. })) => (r, AlwaysTrue), // x <= max
1589                 _ => return None,
1590             }
1591         },
1592         Rel::Ne | Rel::Eq => return None,
1593     })
1594 }
1595
1596 fn detect_extreme_expr<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) -> Option<ExtremeExpr<'tcx>> {
1597     use crate::types::ExtremeType::*;
1598
1599     let ty = cx.tables.expr_ty(expr);
1600
1601     let cv = constant(cx, cx.tables, expr)?.0;
1602
1603     let which = match (&ty.sty, cv) {
1604         (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => Minimum,
1605         (&ty::Int(ity), Constant::Int(i))
1606             if i == unsext(cx.tcx, i128::min_value() >> (128 - int_bits(cx.tcx, ity)), ity) =>
1607         {
1608             Minimum
1609         },
1610
1611         (&ty::Bool, Constant::Bool(true)) => Maximum,
1612         (&ty::Int(ity), Constant::Int(i))
1613             if i == unsext(cx.tcx, i128::max_value() >> (128 - int_bits(cx.tcx, ity)), ity) =>
1614         {
1615             Maximum
1616         },
1617         (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::max_value(), uty) == i => Maximum,
1618
1619         _ => return None,
1620     };
1621     Some(ExtremeExpr { which, expr })
1622 }
1623
1624 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AbsurdExtremeComparisons {
1625     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
1626         use crate::types::AbsurdComparisonResult::*;
1627         use crate::types::ExtremeType::*;
1628
1629         if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.node {
1630             if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) {
1631                 if !in_macro(expr.span) {
1632                     let msg = "this comparison involving the minimum or maximum element for this \
1633                                type contains a case that is always true or always false";
1634
1635                     let conclusion = match result {
1636                         AlwaysFalse => "this comparison is always false".to_owned(),
1637                         AlwaysTrue => "this comparison is always true".to_owned(),
1638                         InequalityImpossible => format!(
1639                             "the case where the two sides are not equal never occurs, consider using {} == {} \
1640                              instead",
1641                             snippet(cx, lhs.span, "lhs"),
1642                             snippet(cx, rhs.span, "rhs")
1643                         ),
1644                     };
1645
1646                     let help = format!(
1647                         "because {} is the {} value for this type, {}",
1648                         snippet(cx, culprit.expr.span, "x"),
1649                         match culprit.which {
1650                             Minimum => "minimum",
1651                             Maximum => "maximum",
1652                         },
1653                         conclusion
1654                     );
1655
1656                     span_help_and_lint(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, &help);
1657                 }
1658             }
1659         }
1660     }
1661 }
1662
1663 /// **What it does:** Checks for comparisons where the relation is always either
1664 /// true or false, but where one side has been upcast so that the comparison is
1665 /// necessary. Only integer types are checked.
1666 ///
1667 /// **Why is this bad?** An expression like `let x : u8 = ...; (x as u32) > 300`
1668 /// will mistakenly imply that it is possible for `x` to be outside the range of
1669 /// `u8`.
1670 ///
1671 /// **Known problems:**
1672 /// https://github.com/rust-lang/rust-clippy/issues/886
1673 ///
1674 /// **Example:**
1675 /// ```rust
1676 /// let x : u8 = ...; (x as u32) > 300
1677 /// ```
1678 declare_clippy_lint! {
1679     pub INVALID_UPCAST_COMPARISONS,
1680     pedantic,
1681     "a comparison involving an upcast which is always true or false"
1682 }
1683
1684 pub struct InvalidUpcastComparisons;
1685
1686 impl LintPass for InvalidUpcastComparisons {
1687     fn get_lints(&self) -> LintArray {
1688         lint_array!(INVALID_UPCAST_COMPARISONS)
1689     }
1690 }
1691
1692 #[derive(Copy, Clone, Debug, Eq)]
1693 enum FullInt {
1694     S(i128),
1695     U(u128),
1696 }
1697
1698 impl FullInt {
1699     #[allow(clippy::cast_sign_loss)]
1700     fn cmp_s_u(s: i128, u: u128) -> Ordering {
1701         if s < 0 {
1702             Ordering::Less
1703         } else if u > (i128::max_value() as u128) {
1704             Ordering::Greater
1705         } else {
1706             (s as u128).cmp(&u)
1707         }
1708     }
1709 }
1710
1711 impl PartialEq for FullInt {
1712     fn eq(&self, other: &Self) -> bool {
1713         self.partial_cmp(other).expect("partial_cmp only returns Some(_)") == Ordering::Equal
1714     }
1715 }
1716
1717 impl PartialOrd for FullInt {
1718     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
1719         Some(match (self, other) {
1720             (&FullInt::S(s), &FullInt::S(o)) => s.cmp(&o),
1721             (&FullInt::U(s), &FullInt::U(o)) => s.cmp(&o),
1722             (&FullInt::S(s), &FullInt::U(o)) => Self::cmp_s_u(s, o),
1723             (&FullInt::U(s), &FullInt::S(o)) => Self::cmp_s_u(o, s).reverse(),
1724         })
1725     }
1726 }
1727 impl Ord for FullInt {
1728     fn cmp(&self, other: &Self) -> Ordering {
1729         self.partial_cmp(other)
1730             .expect("partial_cmp for FullInt can never return None")
1731     }
1732 }
1733
1734 fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr) -> Option<(FullInt, FullInt)> {
1735     use crate::syntax::ast::{IntTy, UintTy};
1736     use std::*;
1737
1738     if let ExprKind::Cast(ref cast_exp, _) = expr.node {
1739         let pre_cast_ty = cx.tables.expr_ty(cast_exp);
1740         let cast_ty = cx.tables.expr_ty(expr);
1741         // if it's a cast from i32 to u32 wrapping will invalidate all these checks
1742         if cx.layout_of(pre_cast_ty).ok().map(|l| l.size) == cx.layout_of(cast_ty).ok().map(|l| l.size) {
1743             return None;
1744         }
1745         match pre_cast_ty.sty {
1746             ty::Int(int_ty) => Some(match int_ty {
1747                 IntTy::I8 => (
1748                     FullInt::S(i128::from(i8::min_value())),
1749                     FullInt::S(i128::from(i8::max_value())),
1750                 ),
1751                 IntTy::I16 => (
1752                     FullInt::S(i128::from(i16::min_value())),
1753                     FullInt::S(i128::from(i16::max_value())),
1754                 ),
1755                 IntTy::I32 => (
1756                     FullInt::S(i128::from(i32::min_value())),
1757                     FullInt::S(i128::from(i32::max_value())),
1758                 ),
1759                 IntTy::I64 => (
1760                     FullInt::S(i128::from(i64::min_value())),
1761                     FullInt::S(i128::from(i64::max_value())),
1762                 ),
1763                 IntTy::I128 => (FullInt::S(i128::min_value()), FullInt::S(i128::max_value())),
1764                 IntTy::Isize => (
1765                     FullInt::S(isize::min_value() as i128),
1766                     FullInt::S(isize::max_value() as i128),
1767                 ),
1768             }),
1769             ty::Uint(uint_ty) => Some(match uint_ty {
1770                 UintTy::U8 => (
1771                     FullInt::U(u128::from(u8::min_value())),
1772                     FullInt::U(u128::from(u8::max_value())),
1773                 ),
1774                 UintTy::U16 => (
1775                     FullInt::U(u128::from(u16::min_value())),
1776                     FullInt::U(u128::from(u16::max_value())),
1777                 ),
1778                 UintTy::U32 => (
1779                     FullInt::U(u128::from(u32::min_value())),
1780                     FullInt::U(u128::from(u32::max_value())),
1781                 ),
1782                 UintTy::U64 => (
1783                     FullInt::U(u128::from(u64::min_value())),
1784                     FullInt::U(u128::from(u64::max_value())),
1785                 ),
1786                 UintTy::U128 => (FullInt::U(u128::min_value()), FullInt::U(u128::max_value())),
1787                 UintTy::Usize => (
1788                     FullInt::U(usize::min_value() as u128),
1789                     FullInt::U(usize::max_value() as u128),
1790                 ),
1791             }),
1792             _ => None,
1793         }
1794     } else {
1795         None
1796     }
1797 }
1798
1799 fn node_as_const_fullint<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) -> Option<FullInt> {
1800     let val = constant(cx, cx.tables, expr)?.0;
1801     if let Constant::Int(const_int) = val {
1802         match cx.tables.expr_ty(expr).sty {
1803             ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
1804             ty::Uint(_) => Some(FullInt::U(const_int)),
1805             _ => None,
1806         }
1807     } else {
1808         None
1809     }
1810 }
1811
1812 fn err_upcast_comparison(cx: &LateContext<'_, '_>, span: Span, expr: &Expr, always: bool) {
1813     if let ExprKind::Cast(ref cast_val, _) = expr.node {
1814         span_lint(
1815             cx,
1816             INVALID_UPCAST_COMPARISONS,
1817             span,
1818             &format!(
1819                 "because of the numeric bounds on `{}` prior to casting, this expression is always {}",
1820                 snippet(cx, cast_val.span, "the expression"),
1821                 if always { "true" } else { "false" },
1822             ),
1823         );
1824     }
1825 }
1826
1827 fn upcast_comparison_bounds_err<'a, 'tcx>(
1828     cx: &LateContext<'a, 'tcx>,
1829     span: Span,
1830     rel: comparisons::Rel,
1831     lhs_bounds: Option<(FullInt, FullInt)>,
1832     lhs: &'tcx Expr,
1833     rhs: &'tcx Expr,
1834     invert: bool,
1835 ) {
1836     use crate::utils::comparisons::*;
1837
1838     if let Some((lb, ub)) = lhs_bounds {
1839         if let Some(norm_rhs_val) = node_as_const_fullint(cx, rhs) {
1840             if rel == Rel::Eq || rel == Rel::Ne {
1841                 if norm_rhs_val < lb || norm_rhs_val > ub {
1842                     err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);
1843                 }
1844             } else if match rel {
1845                 Rel::Lt => {
1846                     if invert {
1847                         norm_rhs_val < lb
1848                     } else {
1849                         ub < norm_rhs_val
1850                     }
1851                 },
1852                 Rel::Le => {
1853                     if invert {
1854                         norm_rhs_val <= lb
1855                     } else {
1856                         ub <= norm_rhs_val
1857                     }
1858                 },
1859                 Rel::Eq | Rel::Ne => unreachable!(),
1860             } {
1861                 err_upcast_comparison(cx, span, lhs, true)
1862             } else if match rel {
1863                 Rel::Lt => {
1864                     if invert {
1865                         norm_rhs_val >= ub
1866                     } else {
1867                         lb >= norm_rhs_val
1868                     }
1869                 },
1870                 Rel::Le => {
1871                     if invert {
1872                         norm_rhs_val > ub
1873                     } else {
1874                         lb > norm_rhs_val
1875                     }
1876                 },
1877                 Rel::Eq | Rel::Ne => unreachable!(),
1878             } {
1879                 err_upcast_comparison(cx, span, lhs, false)
1880             }
1881         }
1882     }
1883 }
1884
1885 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidUpcastComparisons {
1886     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
1887         if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.node {
1888             let normalized = comparisons::normalize_comparison(cmp.node, lhs, rhs);
1889             let (rel, normalized_lhs, normalized_rhs) = if let Some(val) = normalized {
1890                 val
1891             } else {
1892                 return;
1893             };
1894
1895             let lhs_bounds = numeric_cast_precast_bounds(cx, normalized_lhs);
1896             let rhs_bounds = numeric_cast_precast_bounds(cx, normalized_rhs);
1897
1898             upcast_comparison_bounds_err(cx, expr.span, rel, lhs_bounds, normalized_lhs, normalized_rhs, false);
1899             upcast_comparison_bounds_err(cx, expr.span, rel, rhs_bounds, normalized_rhs, normalized_lhs, true);
1900         }
1901     }
1902 }
1903
1904 /// **What it does:** Checks for public `impl` or `fn` missing generalization
1905 /// over different hashers and implicitly defaulting to the default hashing
1906 /// algorithm (SipHash).
1907 ///
1908 /// **Why is this bad?** `HashMap` or `HashSet` with custom hashers cannot be
1909 /// used with them.
1910 ///
1911 /// **Known problems:** Suggestions for replacing constructors can contain
1912 /// false-positives. Also applying suggestions can require modification of other
1913 /// pieces of code, possibly including external crates.
1914 ///
1915 /// **Example:**
1916 /// ```rust
1917 /// impl<K: Hash + Eq, V> Serialize for HashMap<K, V> { ... }
1918 ///
1919 /// pub foo(map: &mut HashMap<i32, i32>) { .. }
1920 /// ```
1921 declare_clippy_lint! {
1922     pub IMPLICIT_HASHER,
1923     style,
1924     "missing generalization over different hashers"
1925 }
1926
1927 pub struct ImplicitHasher;
1928
1929 impl LintPass for ImplicitHasher {
1930     fn get_lints(&self) -> LintArray {
1931         lint_array!(IMPLICIT_HASHER)
1932     }
1933 }
1934
1935 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImplicitHasher {
1936     #[allow(clippy::cast_possible_truncation)]
1937     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
1938         use crate::syntax_pos::BytePos;
1939
1940         fn suggestion<'a, 'tcx>(
1941             cx: &LateContext<'a, 'tcx>,
1942             db: &mut DiagnosticBuilder<'_>,
1943             generics_span: Span,
1944             generics_suggestion_span: Span,
1945             target: &ImplicitHasherType<'_>,
1946             vis: ImplicitHasherConstructorVisitor<'_, '_, '_>,
1947         ) {
1948             let generics_snip = snippet(cx, generics_span, "");
1949             // trim `<` `>`
1950             let generics_snip = if generics_snip.is_empty() {
1951                 ""
1952             } else {
1953                 &generics_snip[1..generics_snip.len() - 1]
1954             };
1955
1956             multispan_sugg(
1957                 db,
1958                 "consider adding a type parameter".to_string(),
1959                 vec![
1960                     (
1961                         generics_suggestion_span,
1962                         format!(
1963                             "<{}{}S: ::std::hash::BuildHasher{}>",
1964                             generics_snip,
1965                             if generics_snip.is_empty() { "" } else { ", " },
1966                             if vis.suggestions.is_empty() {
1967                                 ""
1968                             } else {
1969                                 // request users to add `Default` bound so that generic constructors can be used
1970                                 " + Default"
1971                             },
1972                         ),
1973                     ),
1974                     (
1975                         target.span(),
1976                         format!("{}<{}, S>", target.type_name(), target.type_arguments(),),
1977                     ),
1978                 ],
1979             );
1980
1981             if !vis.suggestions.is_empty() {
1982                 multispan_sugg(db, "...and use generic constructor".into(), vis.suggestions);
1983             }
1984         }
1985
1986         if !cx.access_levels.is_exported(item.id) {
1987             return;
1988         }
1989
1990         match item.node {
1991             ItemKind::Impl(_, _, _, ref generics, _, ref ty, ref items) => {
1992                 let mut vis = ImplicitHasherTypeVisitor::new(cx);
1993                 vis.visit_ty(ty);
1994
1995                 for target in &vis.found {
1996                     if differing_macro_contexts(item.span, target.span()) {
1997                         return;
1998                     }
1999
2000                     let generics_suggestion_span = generics.span.substitute_dummy({
2001                         let pos = snippet_opt(cx, item.span.until(target.span()))
2002                             .and_then(|snip| Some(item.span.lo() + BytePos(snip.find("impl")? as u32 + 4)));
2003                         if let Some(pos) = pos {
2004                             Span::new(pos, pos, item.span.data().ctxt)
2005                         } else {
2006                             return;
2007                         }
2008                     });
2009
2010                     let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
2011                     for item in items.iter().map(|item| cx.tcx.hir().impl_item(item.id)) {
2012                         ctr_vis.visit_impl_item(item);
2013                     }
2014
2015                     span_lint_and_then(
2016                         cx,
2017                         IMPLICIT_HASHER,
2018                         target.span(),
2019                         &format!(
2020                             "impl for `{}` should be generalized over different hashers",
2021                             target.type_name()
2022                         ),
2023                         move |db| {
2024                             suggestion(cx, db, generics.span, generics_suggestion_span, target, ctr_vis);
2025                         },
2026                     );
2027                 }
2028             },
2029             ItemKind::Fn(ref decl, .., ref generics, body_id) => {
2030                 let body = cx.tcx.hir().body(body_id);
2031
2032                 for ty in &decl.inputs {
2033                     let mut vis = ImplicitHasherTypeVisitor::new(cx);
2034                     vis.visit_ty(ty);
2035
2036                     for target in &vis.found {
2037                         let generics_suggestion_span = generics.span.substitute_dummy({
2038                             let pos = snippet_opt(cx, item.span.until(body.arguments[0].pat.span))
2039                                 .and_then(|snip| {
2040                                     let i = snip.find("fn")?;
2041                                     Some(item.span.lo() + BytePos((i + (&snip[i..]).find('(')?) as u32))
2042                                 })
2043                                 .expect("failed to create span for type parameters");
2044                             Span::new(pos, pos, item.span.data().ctxt)
2045                         });
2046
2047                         let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
2048                         ctr_vis.visit_body(body);
2049
2050                         span_lint_and_then(
2051                             cx,
2052                             IMPLICIT_HASHER,
2053                             target.span(),
2054                             &format!(
2055                                 "parameter of type `{}` should be generalized over different hashers",
2056                                 target.type_name()
2057                             ),
2058                             move |db| {
2059                                 suggestion(cx, db, generics.span, generics_suggestion_span, target, ctr_vis);
2060                             },
2061                         );
2062                     }
2063                 }
2064             },
2065             _ => {},
2066         }
2067     }
2068 }
2069
2070 enum ImplicitHasherType<'tcx> {
2071     HashMap(Span, Ty<'tcx>, Cow<'static, str>, Cow<'static, str>),
2072     HashSet(Span, Ty<'tcx>, Cow<'static, str>),
2073 }
2074
2075 impl<'tcx> ImplicitHasherType<'tcx> {
2076     /// Checks that `ty` is a target type without a BuildHasher.
2077     fn new<'a>(cx: &LateContext<'a, 'tcx>, hir_ty: &hir::Ty) -> Option<Self> {
2078         if let TyKind::Path(QPath::Resolved(None, ref path)) = hir_ty.node {
2079             let params: Vec<_> = path
2080                 .segments
2081                 .last()
2082                 .as_ref()?
2083                 .args
2084                 .as_ref()?
2085                 .args
2086                 .iter()
2087                 .filter_map(|arg| match arg {
2088                     GenericArg::Type(ty) => Some(ty),
2089                     GenericArg::Lifetime(_) => None,
2090                 })
2091                 .collect();
2092             let params_len = params.len();
2093
2094             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
2095
2096             if match_path(path, &paths::HASHMAP) && params_len == 2 {
2097                 Some(ImplicitHasherType::HashMap(
2098                     hir_ty.span,
2099                     ty,
2100                     snippet(cx, params[0].span, "K"),
2101                     snippet(cx, params[1].span, "V"),
2102                 ))
2103             } else if match_path(path, &paths::HASHSET) && params_len == 1 {
2104                 Some(ImplicitHasherType::HashSet(
2105                     hir_ty.span,
2106                     ty,
2107                     snippet(cx, params[0].span, "T"),
2108                 ))
2109             } else {
2110                 None
2111             }
2112         } else {
2113             None
2114         }
2115     }
2116
2117     fn type_name(&self) -> &'static str {
2118         match *self {
2119             ImplicitHasherType::HashMap(..) => "HashMap",
2120             ImplicitHasherType::HashSet(..) => "HashSet",
2121         }
2122     }
2123
2124     fn type_arguments(&self) -> String {
2125         match *self {
2126             ImplicitHasherType::HashMap(.., ref k, ref v) => format!("{}, {}", k, v),
2127             ImplicitHasherType::HashSet(.., ref t) => format!("{}", t),
2128         }
2129     }
2130
2131     fn ty(&self) -> Ty<'tcx> {
2132         match *self {
2133             ImplicitHasherType::HashMap(_, ty, ..) | ImplicitHasherType::HashSet(_, ty, ..) => ty,
2134         }
2135     }
2136
2137     fn span(&self) -> Span {
2138         match *self {
2139             ImplicitHasherType::HashMap(span, ..) | ImplicitHasherType::HashSet(span, ..) => span,
2140         }
2141     }
2142 }
2143
2144 struct ImplicitHasherTypeVisitor<'a, 'tcx: 'a> {
2145     cx: &'a LateContext<'a, 'tcx>,
2146     found: Vec<ImplicitHasherType<'tcx>>,
2147 }
2148
2149 impl<'a, 'tcx: 'a> ImplicitHasherTypeVisitor<'a, 'tcx> {
2150     fn new(cx: &'a LateContext<'a, 'tcx>) -> Self {
2151         Self { cx, found: vec![] }
2152     }
2153 }
2154
2155 impl<'a, 'tcx: 'a> Visitor<'tcx> for ImplicitHasherTypeVisitor<'a, 'tcx> {
2156     fn visit_ty(&mut self, t: &'tcx hir::Ty) {
2157         if let Some(target) = ImplicitHasherType::new(self.cx, t) {
2158             self.found.push(target);
2159         }
2160
2161         walk_ty(self, t);
2162     }
2163
2164     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
2165         NestedVisitorMap::None
2166     }
2167 }
2168
2169 /// Looks for default-hasher-dependent constructors like `HashMap::new`.
2170 struct ImplicitHasherConstructorVisitor<'a, 'b, 'tcx: 'a + 'b> {
2171     cx: &'a LateContext<'a, 'tcx>,
2172     body: &'a TypeckTables<'tcx>,
2173     target: &'b ImplicitHasherType<'tcx>,
2174     suggestions: BTreeMap<Span, String>,
2175 }
2176
2177 impl<'a, 'b, 'tcx: 'a + 'b> ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
2178     fn new(cx: &'a LateContext<'a, 'tcx>, target: &'b ImplicitHasherType<'tcx>) -> Self {
2179         Self {
2180             cx,
2181             body: cx.tables,
2182             target,
2183             suggestions: BTreeMap::new(),
2184         }
2185     }
2186 }
2187
2188 impl<'a, 'b, 'tcx: 'a + 'b> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
2189     fn visit_body(&mut self, body: &'tcx Body) {
2190         self.body = self.cx.tcx.body_tables(body.id());
2191         walk_body(self, body);
2192     }
2193
2194     fn visit_expr(&mut self, e: &'tcx Expr) {
2195         if_chain! {
2196             if let ExprKind::Call(ref fun, ref args) = e.node;
2197             if let ExprKind::Path(QPath::TypeRelative(ref ty, ref method)) = fun.node;
2198             if let TyKind::Path(QPath::Resolved(None, ref ty_path)) = ty.node;
2199             then {
2200                 if !same_tys(self.cx, self.target.ty(), self.body.expr_ty(e)) {
2201                     return;
2202                 }
2203
2204                 if match_path(ty_path, &paths::HASHMAP) {
2205                     if method.ident.name == "new" {
2206                         self.suggestions
2207                             .insert(e.span, "HashMap::default()".to_string());
2208                     } else if method.ident.name == "with_capacity" {
2209                         self.suggestions.insert(
2210                             e.span,
2211                             format!(
2212                                 "HashMap::with_capacity_and_hasher({}, Default::default())",
2213                                 snippet(self.cx, args[0].span, "capacity"),
2214                             ),
2215                         );
2216                     }
2217                 } else if match_path(ty_path, &paths::HASHSET) {
2218                     if method.ident.name == "new" {
2219                         self.suggestions
2220                             .insert(e.span, "HashSet::default()".to_string());
2221                     } else if method.ident.name == "with_capacity" {
2222                         self.suggestions.insert(
2223                             e.span,
2224                             format!(
2225                                 "HashSet::with_capacity_and_hasher({}, Default::default())",
2226                                 snippet(self.cx, args[0].span, "capacity"),
2227                             ),
2228                         );
2229                     }
2230                 }
2231             }
2232         }
2233
2234         walk_expr(self, e);
2235     }
2236
2237     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
2238         NestedVisitorMap::OnlyBodies(&self.cx.tcx.hir())
2239     }
2240 }