clippy_lints/src/types.rs

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