clippy_lints/src/methods/mod.rs

   1 mod manual_saturating_arithmetic;
   2 mod option_map_unwrap_or;
   3 mod unnecessary_filter_map;
   4
   5 use std::borrow::Cow;
   6 use std::fmt;
   7 use std::iter;
   8
   9 use if_chain::if_chain;
  10 use matches::matches;
  11 use rustc::hir;
  12 use rustc::hir::intravisit::{self, Visitor};
  13 use rustc::lint::{in_external_macro, LateContext, LateLintPass, Lint, LintArray, LintContext, LintPass};
  14 use rustc::ty::{self, Predicate, Ty};
  15 use rustc::{declare_lint_pass, declare_tool_lint};
  16 use rustc_errors::Applicability;
  17 use syntax::ast;
  18 use syntax::source_map::Span;
  19 use syntax::symbol::{sym, LocalInternedString};
  20
  21 use crate::utils::sugg;
  22 use crate::utils::usage::mutated_variables;
  23 use crate::utils::{
  24     get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, implements_trait, in_macro, is_copy,
  25     is_ctor_function, is_expn_of, iter_input_pats, last_path_segment, match_def_path, match_qpath, match_trait_method,
  26     match_type, match_var, method_calls, method_chain_args, remove_blocks, return_ty, same_tys, single_segment_path,
  27     snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_sugg,
  28     span_lint_and_then, span_note_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth, SpanlessEq,
  29 };
  30 use crate::utils::{paths, span_help_and_lint};
  31
  32 declare_clippy_lint! {
  33     /// **What it does:** Checks for `.unwrap()` calls on `Option`s.
  34     ///
  35     /// **Why is this bad?** Usually it is better to handle the `None` case, or to
  36     /// at least call `.expect(_)` with a more helpful message. Still, for a lot of
  37     /// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
  38     /// `Allow` by default.
  39     ///
  40     /// **Known problems:** None.
  41     ///
  42     /// **Example:**
  43     ///
  44     /// Using unwrap on an `Option`:
  45     ///
  46     /// ```rust
  47     /// let opt = Some(1);
  48     /// opt.unwrap();
  49     /// ```
  50     ///
  51     /// Better:
  52     ///
  53     /// ```rust
  54     /// let opt = Some(1);
  55     /// opt.expect("more helpful message");
  56     /// ```
  57     pub OPTION_UNWRAP_USED,
  58     restriction,
  59     "using `Option.unwrap()`, which should at least get a better message using `expect()`"
  60 }
  61
  62 declare_clippy_lint! {
  63     /// **What it does:** Checks for `.unwrap()` calls on `Result`s.
  64     ///
  65     /// **Why is this bad?** `result.unwrap()` will let the thread panic on `Err`
  66     /// values. Normally, you want to implement more sophisticated error handling,
  67     /// and propagate errors upwards with `try!`.
  68     ///
  69     /// Even if you want to panic on errors, not all `Error`s implement good
  70     /// messages on display. Therefore, it may be beneficial to look at the places
  71     /// where they may get displayed. Activate this lint to do just that.
  72     ///
  73     /// **Known problems:** None.
  74     ///
  75     /// **Example:**
  76     /// Using unwrap on an `Option`:
  77     ///
  78     /// ```rust
  79     /// let res: Result<usize, ()> = Ok(1);
  80     /// res.unwrap();
  81     /// ```
  82     ///
  83     /// Better:
  84     ///
  85     /// ```rust
  86     /// let res: Result<usize, ()> = Ok(1);
  87     /// res.expect("more helpful message");
  88     /// ```
  89     pub RESULT_UNWRAP_USED,
  90     restriction,
  91     "using `Result.unwrap()`, which might be better handled"
  92 }
  93
  94 declare_clippy_lint! {
  95     /// **What it does:** Checks for methods that should live in a trait
  96     /// implementation of a `std` trait (see [llogiq's blog
  97     /// post](http://llogiq.github.io/2015/07/30/traits.html) for further
  98     /// information) instead of an inherent implementation.
  99     ///
 100     /// **Why is this bad?** Implementing the traits improve ergonomics for users of
 101     /// the code, often with very little cost. Also people seeing a `mul(...)`
 102     /// method
 103     /// may expect `*` to work equally, so you should have good reason to disappoint
 104     /// them.
 105     ///
 106     /// **Known problems:** None.
 107     ///
 108     /// **Example:**
 109     /// ```ignore
 110     /// struct X;
 111     /// impl X {
 112     ///     fn add(&self, other: &X) -> X {
 113     ///         ..
 114     ///     }
 115     /// }
 116     /// ```
 117     pub SHOULD_IMPLEMENT_TRAIT,
 118     style,
 119     "defining a method that should be implementing a std trait"
 120 }
 121
 122 declare_clippy_lint! {
 123     /// **What it does:** Checks for methods with certain name prefixes and which
 124     /// doesn't match how self is taken. The actual rules are:
 125     ///
 126     /// |Prefix |`self` taken          |
 127     /// |-------|----------------------|
 128     /// |`as_`  |`&self` or `&mut self`|
 129     /// |`from_`| none                 |
 130     /// |`into_`|`self`                |
 131     /// |`is_`  |`&self` or none       |
 132     /// |`to_`  |`&self`               |
 133     ///
 134     /// **Why is this bad?** Consistency breeds readability. If you follow the
 135     /// conventions, your users won't be surprised that they, e.g., need to supply a
 136     /// mutable reference to a `as_..` function.
 137     ///
 138     /// **Known problems:** None.
 139     ///
 140     /// **Example:**
 141     /// ```ignore
 142     /// impl X {
 143     ///     fn as_str(self) -> &str {
 144     ///         ..
 145     ///     }
 146     /// }
 147     /// ```
 148     pub WRONG_SELF_CONVENTION,
 149     style,
 150     "defining a method named with an established prefix (like \"into_\") that takes `self` with the wrong convention"
 151 }
 152
 153 declare_clippy_lint! {
 154     /// **What it does:** This is the same as
 155     /// [`wrong_self_convention`](#wrong_self_convention), but for public items.
 156     ///
 157     /// **Why is this bad?** See [`wrong_self_convention`](#wrong_self_convention).
 158     ///
 159     /// **Known problems:** Actually *renaming* the function may break clients if
 160     /// the function is part of the public interface. In that case, be mindful of
 161     /// the stability guarantees you've given your users.
 162     ///
 163     /// **Example:**
 164     /// ```rust
 165     /// # struct X;
 166     /// impl<'a> X {
 167     ///     pub fn as_str(self) -> &'a str {
 168     ///         "foo"
 169     ///     }
 170     /// }
 171     /// ```
 172     pub WRONG_PUB_SELF_CONVENTION,
 173     restriction,
 174     "defining a public method named with an established prefix (like \"into_\") that takes `self` with the wrong convention"
 175 }
 176
 177 declare_clippy_lint! {
 178     /// **What it does:** Checks for usage of `ok().expect(..)`.
 179     ///
 180     /// **Why is this bad?** Because you usually call `expect()` on the `Result`
 181     /// directly to get a better error message.
 182     ///
 183     /// **Known problems:** The error type needs to implement `Debug`
 184     ///
 185     /// **Example:**
 186     /// ```ignore
 187     /// x.ok().expect("why did I do this again?")
 188     /// ```
 189     pub OK_EXPECT,
 190     style,
 191     "using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result"
 192 }
 193
 194 declare_clippy_lint! {
 195     /// **What it does:** Checks for usage of `_.map(_).unwrap_or(_)`.
 196     ///
 197     /// **Why is this bad?** Readability, this can be written more concisely as
 198     /// `_.map_or(_, _)`.
 199     ///
 200     /// **Known problems:** The order of the arguments is not in execution order
 201     ///
 202     /// **Example:**
 203     /// ```rust
 204     /// # let x = Some(1);
 205     /// x.map(|a| a + 1).unwrap_or(0);
 206     /// ```
 207     pub OPTION_MAP_UNWRAP_OR,
 208     pedantic,
 209     "using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as `map_or(a, f)`"
 210 }
 211
 212 declare_clippy_lint! {
 213     /// **What it does:** Checks for usage of `_.map(_).unwrap_or_else(_)`.
 214     ///
 215     /// **Why is this bad?** Readability, this can be written more concisely as
 216     /// `_.map_or_else(_, _)`.
 217     ///
 218     /// **Known problems:** The order of the arguments is not in execution order.
 219     ///
 220     /// **Example:**
 221     /// ```rust
 222     /// # let x = Some(1);
 223     /// # fn some_function() -> usize { 1 }
 224     /// x.map(|a| a + 1).unwrap_or_else(some_function);
 225     /// ```
 226     pub OPTION_MAP_UNWRAP_OR_ELSE,
 227     pedantic,
 228     "using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `map_or_else(g, f)`"
 229 }
 230
 231 declare_clippy_lint! {
 232     /// **What it does:** Checks for usage of `result.map(_).unwrap_or_else(_)`.
 233     ///
 234     /// **Why is this bad?** Readability, this can be written more concisely as
 235     /// `result.ok().map_or_else(_, _)`.
 236     ///
 237     /// **Known problems:** None.
 238     ///
 239     /// **Example:**
 240     /// ```rust
 241     /// # let x: Result<usize, ()> = Ok(1);
 242     /// # fn some_function(foo: ()) -> usize { 1 }
 243     /// x.map(|a| a + 1).unwrap_or_else(some_function);
 244     /// ```
 245     pub RESULT_MAP_UNWRAP_OR_ELSE,
 246     pedantic,
 247     "using `Result.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `.ok().map_or_else(g, f)`"
 248 }
 249
 250 declare_clippy_lint! {
 251     /// **What it does:** Checks for usage of `_.map_or(None, _)`.
 252     ///
 253     /// **Why is this bad?** Readability, this can be written more concisely as
 254     /// `_.and_then(_)`.
 255     ///
 256     /// **Known problems:** The order of the arguments is not in execution order.
 257     ///
 258     /// **Example:**
 259     /// ```ignore
 260     /// opt.map_or(None, |a| a + 1)
 261     /// ```
 262     pub OPTION_MAP_OR_NONE,
 263     style,
 264     "using `Option.map_or(None, f)`, which is more succinctly expressed as `and_then(f)`"
 265 }
 266
 267 declare_clippy_lint! {
 268     /// **What it does:** Checks for usage of `_.and_then(|x| Some(y))`.
 269     ///
 270     /// **Why is this bad?** Readability, this can be written more concisely as
 271     /// `_.map(|x| y)`.
 272     ///
 273     /// **Known problems:** None
 274     ///
 275     /// **Example:**
 276     ///
 277     /// ```rust
 278     /// let x = Some("foo");
 279     /// let _ = x.and_then(|s| Some(s.len()));
 280     /// ```
 281     ///
 282     /// The correct use would be:
 283     ///
 284     /// ```rust
 285     /// let x = Some("foo");
 286     /// let _ = x.map(|s| s.len());
 287     /// ```
 288     pub OPTION_AND_THEN_SOME,
 289     complexity,
 290     "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`"
 291 }
 292
 293 declare_clippy_lint! {
 294     /// **What it does:** Checks for usage of `_.filter(_).next()`.
 295     ///
 296     /// **Why is this bad?** Readability, this can be written more concisely as
 297     /// `_.find(_)`.
 298     ///
 299     /// **Known problems:** None.
 300     ///
 301     /// **Example:**
 302     /// ```rust
 303     /// # let vec = vec![1];
 304     /// vec.iter().filter(|x| **x == 0).next();
 305     /// ```
 306     /// Could be written as
 307     /// ```rust
 308     /// # let vec = vec![1];
 309     /// vec.iter().find(|x| **x == 0);
 310     /// ```
 311     pub FILTER_NEXT,
 312     complexity,
 313     "using `filter(p).next()`, which is more succinctly expressed as `.find(p)`"
 314 }
 315
 316 declare_clippy_lint! {
 317     /// **What it does:** Checks for usage of `_.map(_).flatten(_)`,
 318     ///
 319     /// **Why is this bad?** Readability, this can be written more concisely as a
 320     /// single method call.
 321     ///
 322     /// **Known problems:**
 323     ///
 324     /// **Example:**
 325     /// ```rust
 326     /// let vec = vec![vec![1]];
 327     /// vec.iter().map(|x| x.iter()).flatten();
 328     /// ```
 329     pub MAP_FLATTEN,
 330     pedantic,
 331     "using combinations of `flatten` and `map` which can usually be written as a single method call"
 332 }
 333
 334 declare_clippy_lint! {
 335     /// **What it does:** Checks for usage of `_.filter(_).map(_)`,
 336     /// `_.filter(_).flat_map(_)`, `_.filter_map(_).flat_map(_)` and similar.
 337     ///
 338     /// **Why is this bad?** Readability, this can be written more concisely as a
 339     /// single method call.
 340     ///
 341     /// **Known problems:** Often requires a condition + Option/Iterator creation
 342     /// inside the closure.
 343     ///
 344     /// **Example:**
 345     /// ```rust
 346     /// let vec = vec![1];
 347     /// vec.iter().filter(|x| **x == 0).map(|x| *x * 2);
 348     /// ```
 349     pub FILTER_MAP,
 350     pedantic,
 351     "using combinations of `filter`, `map`, `filter_map` and `flat_map` which can usually be written as a single method call"
 352 }
 353
 354 declare_clippy_lint! {
 355     /// **What it does:** Checks for usage of `_.filter_map(_).next()`.
 356     ///
 357     /// **Why is this bad?** Readability, this can be written more concisely as a
 358     /// single method call.
 359     ///
 360     /// **Known problems:** None
 361     ///
 362     /// **Example:**
 363     /// ```rust
 364     ///  (0..3).filter_map(|x| if x == 2 { Some(x) } else { None }).next();
 365     /// ```
 366     /// Can be written as
 367     ///
 368     /// ```rust
 369     ///  (0..3).find_map(|x| if x == 2 { Some(x) } else { None });
 370     /// ```
 371     pub FILTER_MAP_NEXT,
 372     pedantic,
 373     "using combination of `filter_map` and `next` which can usually be written as a single method call"
 374 }
 375
 376 declare_clippy_lint! {
 377     /// **What it does:** Checks for usage of `flat_map(|x| x)`.
 378     ///
 379     /// **Why is this bad?** Readability, this can be written more concisely by using `flatten`.
 380     ///
 381     /// **Known problems:** None
 382     ///
 383     /// **Example:**
 384     /// ```rust
 385     /// # let iter = vec![vec![0]].into_iter();
 386     /// iter.flat_map(|x| x);
 387     /// ```
 388     /// Can be written as
 389     /// ```rust
 390     /// # let iter = vec![vec![0]].into_iter();
 391     /// iter.flatten();
 392     /// ```
 393     pub FLAT_MAP_IDENTITY,
 394     complexity,
 395     "call to `flat_map` where `flatten` is sufficient"
 396 }
 397
 398 declare_clippy_lint! {
 399     /// **What it does:** Checks for usage of `_.find(_).map(_)`.
 400     ///
 401     /// **Why is this bad?** Readability, this can be written more concisely as a
 402     /// single method call.
 403     ///
 404     /// **Known problems:** Often requires a condition + Option/Iterator creation
 405     /// inside the closure.
 406     ///
 407     /// **Example:**
 408     /// ```rust
 409     ///  (0..3).find(|x| *x == 2).map(|x| x * 2);
 410     /// ```
 411     /// Can be written as
 412     /// ```rust
 413     ///  (0..3).find_map(|x| if x == 2 { Some(x * 2) } else { None });
 414     /// ```
 415     pub FIND_MAP,
 416     pedantic,
 417     "using a combination of `find` and `map` can usually be written as a single method call"
 418 }
 419
 420 declare_clippy_lint! {
 421     /// **What it does:** Checks for an iterator search (such as `find()`,
 422     /// `position()`, or `rposition()`) followed by a call to `is_some()`.
 423     ///
 424     /// **Why is this bad?** Readability, this can be written more concisely as
 425     /// `_.any(_)`.
 426     ///
 427     /// **Known problems:** None.
 428     ///
 429     /// **Example:**
 430     /// ```rust
 431     /// # let vec = vec![1];
 432     /// vec.iter().find(|x| **x == 0).is_some();
 433     /// ```
 434     /// Could be written as
 435     /// ```rust
 436     /// # let vec = vec![1];
 437     /// vec.iter().any(|x| *x == 0);
 438     /// ```
 439     pub SEARCH_IS_SOME,
 440     complexity,
 441     "using an iterator search followed by `is_some()`, which is more succinctly expressed as a call to `any()`"
 442 }
 443
 444 declare_clippy_lint! {
 445     /// **What it does:** Checks for usage of `.chars().next()` on a `str` to check
 446     /// if it starts with a given char.
 447     ///
 448     /// **Why is this bad?** Readability, this can be written more concisely as
 449     /// `_.starts_with(_)`.
 450     ///
 451     /// **Known problems:** None.
 452     ///
 453     /// **Example:**
 454     /// ```rust
 455     /// let name = "foo";
 456     /// if name.chars().next() == Some('_') {};
 457     /// ```
 458     /// Could be written as
 459     /// ```rust
 460     /// let name = "foo";
 461     /// if name.starts_with('_') {};
 462     /// ```
 463     pub CHARS_NEXT_CMP,
 464     complexity,
 465     "using `.chars().next()` to check if a string starts with a char"
 466 }
 467
 468 declare_clippy_lint! {
 469     /// **What it does:** Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,
 470     /// etc., and suggests to use `or_else`, `unwrap_or_else`, etc., or
 471     /// `unwrap_or_default` instead.
 472     ///
 473     /// **Why is this bad?** The function will always be called and potentially
 474     /// allocate an object acting as the default.
 475     ///
 476     /// **Known problems:** If the function has side-effects, not calling it will
 477     /// change the semantic of the program, but you shouldn't rely on that anyway.
 478     ///
 479     /// **Example:**
 480     /// ```rust
 481     /// # let foo = Some(String::new());
 482     /// foo.unwrap_or(String::new());
 483     /// ```
 484     /// this can instead be written:
 485     /// ```rust
 486     /// # let foo = Some(String::new());
 487     /// foo.unwrap_or_else(String::new);
 488     /// ```
 489     /// or
 490     /// ```rust
 491     /// # let foo = Some(String::new());
 492     /// foo.unwrap_or_default();
 493     /// ```
 494     pub OR_FUN_CALL,
 495     perf,
 496     "using any `*or` method with a function call, which suggests `*or_else`"
 497 }
 498
 499 declare_clippy_lint! {
 500     /// **What it does:** Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`,
 501     /// etc., and suggests to use `unwrap_or_else` instead
 502     ///
 503     /// **Why is this bad?** The function will always be called.
 504     ///
 505     /// **Known problems:** If the function has side-effects, not calling it will
 506     /// change the semantics of the program, but you shouldn't rely on that anyway.
 507     ///
 508     /// **Example:**
 509     /// ```rust
 510     /// # let foo = Some(String::new());
 511     /// # let err_code = "418";
 512     /// # let err_msg = "I'm a teapot";
 513     /// foo.expect(&format!("Err {}: {}", err_code, err_msg));
 514     /// ```
 515     /// or
 516     /// ```rust
 517     /// # let foo = Some(String::new());
 518     /// # let err_code = "418";
 519     /// # let err_msg = "I'm a teapot";
 520     /// foo.expect(format!("Err {}: {}", err_code, err_msg).as_str());
 521     /// ```
 522     /// this can instead be written:
 523     /// ```rust
 524     /// # let foo = Some(String::new());
 525     /// # let err_code = "418";
 526     /// # let err_msg = "I'm a teapot";
 527     /// foo.unwrap_or_else(|| panic!("Err {}: {}", err_code, err_msg));
 528     /// ```
 529     pub EXPECT_FUN_CALL,
 530     perf,
 531     "using any `expect` method with a function call"
 532 }
 533
 534 declare_clippy_lint! {
 535     /// **What it does:** Checks for usage of `.clone()` on a `Copy` type.
 536     ///
 537     /// **Why is this bad?** The only reason `Copy` types implement `Clone` is for
 538     /// generics, not for using the `clone` method on a concrete type.
 539     ///
 540     /// **Known problems:** None.
 541     ///
 542     /// **Example:**
 543     /// ```rust
 544     /// 42u64.clone();
 545     /// ```
 546     pub CLONE_ON_COPY,
 547     complexity,
 548     "using `clone` on a `Copy` type"
 549 }
 550
 551 declare_clippy_lint! {
 552     /// **What it does:** Checks for usage of `.clone()` on a ref-counted pointer,
 553     /// (`Rc`, `Arc`, `rc::Weak`, or `sync::Weak`), and suggests calling Clone via unified
 554     /// function syntax instead (e.g., `Rc::clone(foo)`).
 555     ///
 556     /// **Why is this bad?** Calling '.clone()' on an Rc, Arc, or Weak
 557     /// can obscure the fact that only the pointer is being cloned, not the underlying
 558     /// data.
 559     ///
 560     /// **Example:**
 561     /// ```rust
 562     /// # use std::rc::Rc;
 563     /// let x = Rc::new(1);
 564     /// x.clone();
 565     /// ```
 566     pub CLONE_ON_REF_PTR,
 567     restriction,
 568     "using 'clone' on a ref-counted pointer"
 569 }
 570
 571 declare_clippy_lint! {
 572     /// **What it does:** Checks for usage of `.clone()` on an `&&T`.
 573     ///
 574     /// **Why is this bad?** Cloning an `&&T` copies the inner `&T`, instead of
 575     /// cloning the underlying `T`.
 576     ///
 577     /// **Known problems:** None.
 578     ///
 579     /// **Example:**
 580     /// ```rust
 581     /// fn main() {
 582     ///     let x = vec![1];
 583     ///     let y = &&x;
 584     ///     let z = y.clone();
 585     ///     println!("{:p} {:p}", *y, z); // prints out the same pointer
 586     /// }
 587     /// ```
 588     pub CLONE_DOUBLE_REF,
 589     correctness,
 590     "using `clone` on `&&T`"
 591 }
 592
 593 declare_clippy_lint! {
 594     /// **What it does:** Checks for `new` not returning `Self`.
 595     ///
 596     /// **Why is this bad?** As a convention, `new` methods are used to make a new
 597     /// instance of a type.
 598     ///
 599     /// **Known problems:** None.
 600     ///
 601     /// **Example:**
 602     /// ```ignore
 603     /// impl Foo {
 604     ///     fn new(..) -> NotAFoo {
 605     ///     }
 606     /// }
 607     /// ```
 608     pub NEW_RET_NO_SELF,
 609     style,
 610     "not returning `Self` in a `new` method"
 611 }
 612
 613 declare_clippy_lint! {
 614     /// **What it does:** Checks for string methods that receive a single-character
 615     /// `str` as an argument, e.g., `_.split("x")`.
 616     ///
 617     /// **Why is this bad?** Performing these methods using a `char` is faster than
 618     /// using a `str`.
 619     ///
 620     /// **Known problems:** Does not catch multi-byte unicode characters.
 621     ///
 622     /// **Example:**
 623     /// `_.split("x")` could be `_.split('x')`
 624     pub SINGLE_CHAR_PATTERN,
 625     perf,
 626     "using a single-character str where a char could be used, e.g., `_.split(\"x\")`"
 627 }
 628
 629 declare_clippy_lint! {
 630     /// **What it does:** Checks for getting the inner pointer of a temporary
 631     /// `CString`.
 632     ///
 633     /// **Why is this bad?** The inner pointer of a `CString` is only valid as long
 634     /// as the `CString` is alive.
 635     ///
 636     /// **Known problems:** None.
 637     ///
 638     /// **Example:**
 639     /// ```rust,ignore
 640     /// let c_str = CString::new("foo").unwrap().as_ptr();
 641     /// unsafe {
 642     ///     call_some_ffi_func(c_str);
 643     /// }
 644     /// ```
 645     /// Here `c_str` point to a freed address. The correct use would be:
 646     /// ```rust,ignore
 647     /// let c_str = CString::new("foo").unwrap();
 648     /// unsafe {
 649     ///     call_some_ffi_func(c_str.as_ptr());
 650     /// }
 651     /// ```
 652     pub TEMPORARY_CSTRING_AS_PTR,
 653     correctness,
 654     "getting the inner pointer of a temporary `CString`"
 655 }
 656
 657 declare_clippy_lint! {
 658     /// **What it does:** Checks for use of `.iter().nth()` (and the related
 659     /// `.iter_mut().nth()`) on standard library types with O(1) element access.
 660     ///
 661     /// **Why is this bad?** `.get()` and `.get_mut()` are more efficient and more
 662     /// readable.
 663     ///
 664     /// **Known problems:** None.
 665     ///
 666     /// **Example:**
 667     /// ```rust
 668     /// let some_vec = vec![0, 1, 2, 3];
 669     /// let bad_vec = some_vec.iter().nth(3);
 670     /// let bad_slice = &some_vec[..].iter().nth(3);
 671     /// ```
 672     /// The correct use would be:
 673     /// ```rust
 674     /// let some_vec = vec![0, 1, 2, 3];
 675     /// let bad_vec = some_vec.get(3);
 676     /// let bad_slice = &some_vec[..].get(3);
 677     /// ```
 678     pub ITER_NTH,
 679     perf,
 680     "using `.iter().nth()` on a standard library type with O(1) element access"
 681 }
 682
 683 declare_clippy_lint! {
 684     /// **What it does:** Checks for use of `.skip(x).next()` on iterators.
 685     ///
 686     /// **Why is this bad?** `.nth(x)` is cleaner
 687     ///
 688     /// **Known problems:** None.
 689     ///
 690     /// **Example:**
 691     /// ```rust
 692     /// let some_vec = vec![0, 1, 2, 3];
 693     /// let bad_vec = some_vec.iter().skip(3).next();
 694     /// let bad_slice = &some_vec[..].iter().skip(3).next();
 695     /// ```
 696     /// The correct use would be:
 697     /// ```rust
 698     /// let some_vec = vec![0, 1, 2, 3];
 699     /// let bad_vec = some_vec.iter().nth(3);
 700     /// let bad_slice = &some_vec[..].iter().nth(3);
 701     /// ```
 702     pub ITER_SKIP_NEXT,
 703     style,
 704     "using `.skip(x).next()` on an iterator"
 705 }
 706
 707 declare_clippy_lint! {
 708     /// **What it does:** Checks for use of `.get().unwrap()` (or
 709     /// `.get_mut().unwrap`) on a standard library type which implements `Index`
 710     ///
 711     /// **Why is this bad?** Using the Index trait (`[]`) is more clear and more
 712     /// concise.
 713     ///
 714     /// **Known problems:** Not a replacement for error handling: Using either
 715     /// `.unwrap()` or the Index trait (`[]`) carries the risk of causing a `panic`
 716     /// if the value being accessed is `None`. If the use of `.get().unwrap()` is a
 717     /// temporary placeholder for dealing with the `Option` type, then this does
 718     /// not mitigate the need for error handling. If there is a chance that `.get()`
 719     /// will be `None` in your program, then it is advisable that the `None` case
 720     /// is handled in a future refactor instead of using `.unwrap()` or the Index
 721     /// trait.
 722     ///
 723     /// **Example:**
 724     /// ```rust
 725     /// let mut some_vec = vec![0, 1, 2, 3];
 726     /// let last = some_vec.get(3).unwrap();
 727     /// *some_vec.get_mut(0).unwrap() = 1;
 728     /// ```
 729     /// The correct use would be:
 730     /// ```rust
 731     /// let mut some_vec = vec![0, 1, 2, 3];
 732     /// let last = some_vec[3];
 733     /// some_vec[0] = 1;
 734     /// ```
 735     pub GET_UNWRAP,
 736     restriction,
 737     "using `.get().unwrap()` or `.get_mut().unwrap()` when using `[]` would work instead"
 738 }
 739
 740 declare_clippy_lint! {
 741     /// **What it does:** Checks for the use of `.extend(s.chars())` where s is a
 742     /// `&str` or `String`.
 743     ///
 744     /// **Why is this bad?** `.push_str(s)` is clearer
 745     ///
 746     /// **Known problems:** None.
 747     ///
 748     /// **Example:**
 749     /// ```rust
 750     /// let abc = "abc";
 751     /// let def = String::from("def");
 752     /// let mut s = String::new();
 753     /// s.extend(abc.chars());
 754     /// s.extend(def.chars());
 755     /// ```
 756     /// The correct use would be:
 757     /// ```rust
 758     /// let abc = "abc";
 759     /// let def = String::from("def");
 760     /// let mut s = String::new();
 761     /// s.push_str(abc);
 762     /// s.push_str(&def);
 763     /// ```
 764     pub STRING_EXTEND_CHARS,
 765     style,
 766     "using `x.extend(s.chars())` where s is a `&str` or `String`"
 767 }
 768
 769 declare_clippy_lint! {
 770     /// **What it does:** Checks for the use of `.cloned().collect()` on slice to
 771     /// create a `Vec`.
 772     ///
 773     /// **Why is this bad?** `.to_vec()` is clearer
 774     ///
 775     /// **Known problems:** None.
 776     ///
 777     /// **Example:**
 778     /// ```rust
 779     /// let s = [1, 2, 3, 4, 5];
 780     /// let s2: Vec<isize> = s[..].iter().cloned().collect();
 781     /// ```
 782     /// The better use would be:
 783     /// ```rust
 784     /// let s = [1, 2, 3, 4, 5];
 785     /// let s2: Vec<isize> = s.to_vec();
 786     /// ```
 787     pub ITER_CLONED_COLLECT,
 788     style,
 789     "using `.cloned().collect()` on slice to create a `Vec`"
 790 }
 791
 792 declare_clippy_lint! {
 793     /// **What it does:** Checks for usage of `.chars().last()` or
 794     /// `.chars().next_back()` on a `str` to check if it ends with a given char.
 795     ///
 796     /// **Why is this bad?** Readability, this can be written more concisely as
 797     /// `_.ends_with(_)`.
 798     ///
 799     /// **Known problems:** None.
 800     ///
 801     /// **Example:**
 802     /// ```ignore
 803     /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-')
 804     /// ```
 805     pub CHARS_LAST_CMP,
 806     style,
 807     "using `.chars().last()` or `.chars().next_back()` to check if a string ends with a char"
 808 }
 809
 810 declare_clippy_lint! {
 811     /// **What it does:** Checks for usage of `.as_ref()` or `.as_mut()` where the
 812     /// types before and after the call are the same.
 813     ///
 814     /// **Why is this bad?** The call is unnecessary.
 815     ///
 816     /// **Known problems:** None.
 817     ///
 818     /// **Example:**
 819     /// ```rust
 820     /// # fn do_stuff(x: &[i32]) {}
 821     /// let x: &[i32] = &[1, 2, 3, 4, 5];
 822     /// do_stuff(x.as_ref());
 823     /// ```
 824     /// The correct use would be:
 825     /// ```rust
 826     /// # fn do_stuff(x: &[i32]) {}
 827     /// let x: &[i32] = &[1, 2, 3, 4, 5];
 828     /// do_stuff(x);
 829     /// ```
 830     pub USELESS_ASREF,
 831     complexity,
 832     "using `as_ref` where the types before and after the call are the same"
 833 }
 834
 835 declare_clippy_lint! {
 836     /// **What it does:** Checks for using `fold` when a more succinct alternative exists.
 837     /// Specifically, this checks for `fold`s which could be replaced by `any`, `all`,
 838     /// `sum` or `product`.
 839     ///
 840     /// **Why is this bad?** Readability.
 841     ///
 842     /// **Known problems:** False positive in pattern guards. Will be resolved once
 843     /// non-lexical lifetimes are stable.
 844     ///
 845     /// **Example:**
 846     /// ```rust
 847     /// let _ = (0..3).fold(false, |acc, x| acc || x > 2);
 848     /// ```
 849     /// This could be written as:
 850     /// ```rust
 851     /// let _ = (0..3).any(|x| x > 2);
 852     /// ```
 853     pub UNNECESSARY_FOLD,
 854     style,
 855     "using `fold` when a more succinct alternative exists"
 856 }
 857
 858 declare_clippy_lint! {
 859     /// **What it does:** Checks for `filter_map` calls which could be replaced by `filter` or `map`.
 860     /// More specifically it checks if the closure provided is only performing one of the
 861     /// filter or map operations and suggests the appropriate option.
 862     ///
 863     /// **Why is this bad?** Complexity. The intent is also clearer if only a single
 864     /// operation is being performed.
 865     ///
 866     /// **Known problems:** None
 867     ///
 868     /// **Example:**
 869     /// ```rust
 870     /// let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });
 871     /// ```
 872     /// As there is no transformation of the argument this could be written as:
 873     /// ```rust
 874     /// let _ = (0..3).filter(|&x| x > 2);
 875     /// ```
 876     ///
 877     /// ```rust
 878     /// let _ = (0..4).filter_map(i32::checked_abs);
 879     /// ```
 880     /// As there is no conditional check on the argument this could be written as:
 881     /// ```rust
 882     /// let _ = (0..4).map(i32::checked_abs);
 883     /// ```
 884     pub UNNECESSARY_FILTER_MAP,
 885     complexity,
 886     "using `filter_map` when a more succinct alternative exists"
 887 }
 888
 889 declare_clippy_lint! {
 890     /// **What it does:** Checks for `into_iter` calls on types which should be replaced by `iter` or
 891     /// `iter_mut`.
 892     ///
 893     /// **Why is this bad?** Arrays and `PathBuf` do not yet have an `into_iter` method which move out
 894     /// their content into an iterator. Auto-referencing resolves the `into_iter` call to its reference
 895     /// instead, like `<&[T; N] as IntoIterator>::into_iter`, which just iterates over item references
 896     /// like calling `iter` would. Furthermore, when the standard library actually
 897     /// [implements the `into_iter` method](https://github.com/rust-lang/rust/issues/25725) which moves
 898     /// the content out of the array, the original use of `into_iter` got inferred with the wrong type
 899     /// and the code will be broken.
 900     ///
 901     /// **Known problems:** None
 902     ///
 903     /// **Example:**
 904     ///
 905     /// ```rust
 906     /// let _ = [1, 2, 3].into_iter().map(|x| *x).collect::<Vec<u32>>();
 907     /// ```
 908     /// Could be written as:
 909     /// ```rust
 910     /// let _ = [1, 2, 3].iter().map(|x| *x).collect::<Vec<u32>>();
 911     /// ```
 912     pub INTO_ITER_ON_ARRAY,
 913     correctness,
 914     "using `.into_iter()` on an array"
 915 }
 916
 917 declare_clippy_lint! {
 918     /// **What it does:** Checks for `into_iter` calls on references which should be replaced by `iter`
 919     /// or `iter_mut`.
 920     ///
 921     /// **Why is this bad?** Readability. Calling `into_iter` on a reference will not move out its
 922     /// content into the resulting iterator, which is confusing. It is better just call `iter` or
 923     /// `iter_mut` directly.
 924     ///
 925     /// **Known problems:** None
 926     ///
 927     /// **Example:**
 928     ///
 929     /// ```rust
 930     /// let _ = (&vec![3, 4, 5]).into_iter();
 931     /// ```
 932     pub INTO_ITER_ON_REF,
 933     style,
 934     "using `.into_iter()` on a reference"
 935 }
 936
 937 declare_clippy_lint! {
 938     /// **What it does:** Checks for calls to `map` followed by a `count`.
 939     ///
 940     /// **Why is this bad?** It looks suspicious. Maybe `map` was confused with `filter`.
 941     /// If the `map` call is intentional, this should be rewritten.
 942     ///
 943     /// **Known problems:** None
 944     ///
 945     /// **Example:**
 946     ///
 947     /// ```rust
 948     /// let _ = (0..3).map(|x| x + 2).count();
 949     /// ```
 950     pub SUSPICIOUS_MAP,
 951     complexity,
 952     "suspicious usage of map"
 953 }
 954
 955 declare_clippy_lint! {
 956     /// **What it does:** Checks for `MaybeUninit::uninit().assume_init()`.
 957     ///
 958     /// **Why is this bad?** For most types, this is undefined behavior.
 959     ///
 960     /// **Known problems:** For now, we accept empty tuples and tuples / arrays
 961     /// of `MaybeUninit`. There may be other types that allow uninitialized
 962     /// data, but those are not yet rigorously defined.
 963     ///
 964     /// **Example:**
 965     ///
 966     /// ```rust
 967     /// // Beware the UB
 968     /// use std::mem::MaybeUninit;
 969     ///
 970     /// let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
 971     /// ```
 972     ///
 973     /// Note that the following is OK:
 974     ///
 975     /// ```rust
 976     /// use std::mem::MaybeUninit;
 977     ///
 978     /// let _: [MaybeUninit<bool>; 5] = unsafe {
 979     ///     MaybeUninit::uninit().assume_init()
 980     /// };
 981     /// ```
 982     pub UNINIT_ASSUMED_INIT,
 983     correctness,
 984     "`MaybeUninit::uninit().assume_init()`"
 985 }
 986
 987 declare_clippy_lint! {
 988     /// **What it does:** Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.
 989     ///
 990     /// **Why is this bad?** These can be written simply with `saturating_add/sub` methods.
 991     ///
 992     /// **Example:**
 993     ///
 994     /// ```rust
 995     /// # let y: u32 = 0;
 996     /// # let x: u32 = 100;
 997     /// let add = x.checked_add(y).unwrap_or(u32::max_value());
 998     /// let sub = x.checked_sub(y).unwrap_or(u32::min_value());
 999     /// ```
1000     ///
1001     /// can be written using dedicated methods for saturating addition/subtraction as:
1002     ///
1003     /// ```rust
1004     /// # let y: u32 = 0;
1005     /// # let x: u32 = 100;
1006     /// let add = x.saturating_add(y);
1007     /// let sub = x.saturating_sub(y);
1008     /// ```
1009     pub MANUAL_SATURATING_ARITHMETIC,
1010     style,
1011     "`.chcked_add/sub(x).unwrap_or(MAX/MIN)`"
1012 }
1013
1014 declare_lint_pass!(Methods => [
1015     OPTION_UNWRAP_USED,
1016     RESULT_UNWRAP_USED,
1017     SHOULD_IMPLEMENT_TRAIT,
1018     WRONG_SELF_CONVENTION,
1019     WRONG_PUB_SELF_CONVENTION,
1020     OK_EXPECT,
1021     OPTION_MAP_UNWRAP_OR,
1022     OPTION_MAP_UNWRAP_OR_ELSE,
1023     RESULT_MAP_UNWRAP_OR_ELSE,
1024     OPTION_MAP_OR_NONE,
1025     OPTION_AND_THEN_SOME,
1026     OR_FUN_CALL,
1027     EXPECT_FUN_CALL,
1028     CHARS_NEXT_CMP,
1029     CHARS_LAST_CMP,
1030     CLONE_ON_COPY,
1031     CLONE_ON_REF_PTR,
1032     CLONE_DOUBLE_REF,
1033     NEW_RET_NO_SELF,
1034     SINGLE_CHAR_PATTERN,
1035     SEARCH_IS_SOME,
1036     TEMPORARY_CSTRING_AS_PTR,
1037     FILTER_NEXT,
1038     FILTER_MAP,
1039     FILTER_MAP_NEXT,
1040     FLAT_MAP_IDENTITY,
1041     FIND_MAP,
1042     MAP_FLATTEN,
1043     ITER_NTH,
1044     ITER_SKIP_NEXT,
1045     GET_UNWRAP,
1046     STRING_EXTEND_CHARS,
1047     ITER_CLONED_COLLECT,
1048     USELESS_ASREF,
1049     UNNECESSARY_FOLD,
1050     UNNECESSARY_FILTER_MAP,
1051     INTO_ITER_ON_ARRAY,
1052     INTO_ITER_ON_REF,
1053     SUSPICIOUS_MAP,
1054     UNINIT_ASSUMED_INIT,
1055     MANUAL_SATURATING_ARITHMETIC,
1056 ]);
1057
1058 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
1059     #[allow(clippy::cognitive_complexity)]
1060     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
1061         if in_macro(expr.span) {
1062             return;
1063         }
1064
1065         let (method_names, arg_lists) = method_calls(expr, 2);
1066         let method_names: Vec<LocalInternedString> = method_names.iter().map(|s| s.as_str()).collect();
1067         let method_names: Vec<&str> = method_names.iter().map(std::convert::AsRef::as_ref).collect();
1068
1069         match method_names.as_slice() {
1070             ["unwrap", "get"] => lint_get_unwrap(cx, expr, arg_lists[1], false),
1071             ["unwrap", "get_mut"] => lint_get_unwrap(cx, expr, arg_lists[1], true),
1072             ["unwrap", ..] => lint_unwrap(cx, expr, arg_lists[0]),
1073             ["expect", "ok"] => lint_ok_expect(cx, expr, arg_lists[1]),
1074             ["unwrap_or", "map"] => option_map_unwrap_or::lint(cx, expr, arg_lists[1], arg_lists[0]),
1075             ["unwrap_or_else", "map"] => lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0]),
1076             ["map_or", ..] => lint_map_or_none(cx, expr, arg_lists[0]),
1077             ["and_then", ..] => lint_option_and_then_some(cx, expr, arg_lists[0]),
1078             ["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
1079             ["map", "filter"] => lint_filter_map(cx, expr, arg_lists[1], arg_lists[0]),
1080             ["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
1081             ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1]),
1082             ["map", "find"] => lint_find_map(cx, expr, arg_lists[1], arg_lists[0]),
1083             ["flat_map", "filter"] => lint_filter_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
1084             ["flat_map", "filter_map"] => lint_filter_map_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
1085             ["flat_map", ..] => lint_flat_map_identity(cx, expr, arg_lists[0]),
1086             ["flatten", "map"] => lint_map_flatten(cx, expr, arg_lists[1]),
1087             ["is_some", "find"] => lint_search_is_some(cx, expr, "find", arg_lists[1], arg_lists[0]),
1088             ["is_some", "position"] => lint_search_is_some(cx, expr, "position", arg_lists[1], arg_lists[0]),
1089             ["is_some", "rposition"] => lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0]),
1090             ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
1091             ["as_ptr", "unwrap"] | ["as_ptr", "expect"] => {
1092                 lint_cstring_as_ptr(cx, expr, &arg_lists[1][0], &arg_lists[0][0])
1093             },
1094             ["nth", "iter"] => lint_iter_nth(cx, expr, arg_lists[1], false),
1095             ["nth", "iter_mut"] => lint_iter_nth(cx, expr, arg_lists[1], true),
1096             ["next", "skip"] => lint_iter_skip_next(cx, expr),
1097             ["collect", "cloned"] => lint_iter_cloned_collect(cx, expr, arg_lists[1]),
1098             ["as_ref"] => lint_asref(cx, expr, "as_ref", arg_lists[0]),
1099             ["as_mut"] => lint_asref(cx, expr, "as_mut", arg_lists[0]),
1100             ["fold", ..] => lint_unnecessary_fold(cx, expr, arg_lists[0]),
1101             ["filter_map", ..] => unnecessary_filter_map::lint(cx, expr, arg_lists[0]),
1102             ["count", "map"] => lint_suspicious_map(cx, expr),
1103             ["assume_init"] => lint_maybe_uninit(cx, &arg_lists[0][0], expr),
1104             ["unwrap_or", arith @ "checked_add"]
1105             | ["unwrap_or", arith @ "checked_sub"]
1106             | ["unwrap_or", arith @ "checked_mul"] => {
1107                 manual_saturating_arithmetic::lint(cx, expr, &arg_lists, &arith["checked_".len()..])
1108             },
1109             _ => {},
1110         }
1111
1112         match expr.node {
1113             hir::ExprKind::MethodCall(ref method_call, ref method_span, ref args) => {
1114                 lint_or_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
1115                 lint_expect_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
1116
1117                 let self_ty = cx.tables.expr_ty_adjusted(&args[0]);
1118                 if args.len() == 1 && method_call.ident.name == sym!(clone) {
1119                     lint_clone_on_copy(cx, expr, &args[0], self_ty);
1120                     lint_clone_on_ref_ptr(cx, expr, &args[0]);
1121                 }
1122
1123                 match self_ty.sty {
1124                     ty::Ref(_, ty, _) if ty.sty == ty::Str => {
1125                         for &(method, pos) in &PATTERN_METHODS {
1126                             if method_call.ident.name.as_str() == method && args.len() > pos {
1127                                 lint_single_char_pattern(cx, expr, &args[pos]);
1128                             }
1129                         }
1130                     },
1131                     ty::Ref(..) if method_call.ident.name == sym!(into_iter) => {
1132                         lint_into_iter(cx, expr, self_ty, *method_span);
1133                     },
1134                     _ => (),
1135                 }
1136             },
1137             hir::ExprKind::Binary(op, ref lhs, ref rhs)
1138                 if op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne =>
1139             {
1140                 let mut info = BinaryExprInfo {
1141                     expr,
1142                     chain: lhs,
1143                     other: rhs,
1144                     eq: op.node == hir::BinOpKind::Eq,
1145                 };
1146                 lint_binary_expr_with_method_call(cx, &mut info);
1147             }
1148             _ => (),
1149         }
1150     }
1151
1152     fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, impl_item: &'tcx hir::ImplItem) {
1153         if in_external_macro(cx.sess(), impl_item.span) {
1154             return;
1155         }
1156         let name = impl_item.ident.name.as_str();
1157         let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id);
1158         let item = cx.tcx.hir().expect_item(parent);
1159         let def_id = cx.tcx.hir().local_def_id(item.hir_id);
1160         let ty = cx.tcx.type_of(def_id);
1161         if_chain! {
1162             if let hir::ImplItemKind::Method(ref sig, id) = impl_item.node;
1163             if let Some(first_arg) = iter_input_pats(&sig.decl, cx.tcx.hir().body(id)).next();
1164             if let hir::ItemKind::Impl(_, _, _, _, None, _, _) = item.node;
1165
1166             let method_def_id = cx.tcx.hir().local_def_id(impl_item.hir_id);
1167             let method_sig = cx.tcx.fn_sig(method_def_id);
1168             let method_sig = cx.tcx.erase_late_bound_regions(&method_sig);
1169
1170             let first_arg_ty = &method_sig.inputs().iter().next();
1171
1172             // check conventions w.r.t. conversion method names and predicates
1173             if let Some(first_arg_ty) = first_arg_ty;
1174
1175             then {
1176                 if cx.access_levels.is_exported(impl_item.hir_id) {
1177                 // check missing trait implementations
1178                     for &(method_name, n_args, self_kind, out_type, trait_name) in &TRAIT_METHODS {
1179                         if name == method_name &&
1180                         sig.decl.inputs.len() == n_args &&
1181                         out_type.matches(cx, &sig.decl.output) &&
1182                         self_kind.matches(cx, ty, first_arg_ty) {
1183                             span_lint(cx, SHOULD_IMPLEMENT_TRAIT, impl_item.span, &format!(
1184                                 "defining a method called `{}` on this type; consider implementing \
1185                                 the `{}` trait or choosing a less ambiguous name", name, trait_name));
1186                         }
1187                     }
1188                 }
1189
1190                 if let Some((ref conv, self_kinds)) = &CONVENTIONS
1191                     .iter()
1192                     .find(|(ref conv, _)| conv.check(&name))
1193                 {
1194                     if !self_kinds.iter().any(|k| k.matches(cx, ty, first_arg_ty)) {
1195                         let lint = if item.vis.node.is_pub() {
1196                             WRONG_PUB_SELF_CONVENTION
1197                         } else {
1198                             WRONG_SELF_CONVENTION
1199                         };
1200
1201                         span_lint(
1202                             cx,
1203                             lint,
1204                             first_arg.pat.span,
1205                             &format!(
1206                                "methods called `{}` usually take {}; consider choosing a less \
1207                                  ambiguous name",
1208                                 conv,
1209                                 &self_kinds
1210                                     .iter()
1211                                     .map(|k| k.description())
1212                                     .collect::<Vec<_>>()
1213                                     .join(" or ")
1214                             ),
1215                         );
1216                     }
1217                 }
1218             }
1219         }
1220
1221         if let hir::ImplItemKind::Method(_, _) = impl_item.node {
1222             let ret_ty = return_ty(cx, impl_item.hir_id);
1223
1224             // walk the return type and check for Self (this does not check associated types)
1225             if ret_ty.walk().any(|inner_type| same_tys(cx, ty, inner_type)) {
1226                 return;
1227             }
1228
1229             // if return type is impl trait, check the associated types
1230             if let ty::Opaque(def_id, _) = ret_ty.sty {
1231                 // one of the associated types must be Self
1232                 for predicate in &cx.tcx.predicates_of(def_id).predicates {
1233                     match predicate {
1234                         (Predicate::Projection(poly_projection_predicate), _) => {
1235                             let binder = poly_projection_predicate.ty();
1236                             let associated_type = binder.skip_binder();
1237
1238                             // walk the associated type and check for Self
1239                             for inner_type in associated_type.walk() {
1240                                 if same_tys(cx, ty, inner_type) {
1241                                     return;
1242                                 }
1243                             }
1244                         },
1245                         (_, _) => {},
1246                     }
1247                 }
1248             }
1249
1250             if name == "new" && !same_tys(cx, ret_ty, ty) {
1251                 span_lint(
1252                     cx,
1253                     NEW_RET_NO_SELF,
1254                     impl_item.span,
1255                     "methods called `new` usually return `Self`",
1256                 );
1257             }
1258         }
1259     }
1260 }
1261
1262 /// Checks for the `OR_FUN_CALL` lint.
1263 #[allow(clippy::too_many_lines)]
1264 fn lint_or_fun_call<'a, 'tcx>(
1265     cx: &LateContext<'a, 'tcx>,
1266     expr: &hir::Expr,
1267     method_span: Span,
1268     name: &str,
1269     args: &'tcx [hir::Expr],
1270 ) {
1271     // Searches an expression for method calls or function calls that aren't ctors
1272     struct FunCallFinder<'a, 'tcx> {
1273         cx: &'a LateContext<'a, 'tcx>,
1274         found: bool,
1275     }
1276
1277     impl<'a, 'tcx> intravisit::Visitor<'tcx> for FunCallFinder<'a, 'tcx> {
1278         fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
1279             let call_found = match &expr.node {
1280                 // ignore enum and struct constructors
1281                 hir::ExprKind::Call(..) => !is_ctor_function(self.cx, expr),
1282                 hir::ExprKind::MethodCall(..) => true,
1283                 _ => false,
1284             };
1285
1286             if call_found {
1287                 // don't lint for constant values
1288                 let owner_def = self.cx.tcx.hir().get_parent_did(expr.hir_id);
1289                 let promotable = self
1290                     .cx
1291                     .tcx
1292                     .rvalue_promotable_map(owner_def)
1293                     .contains(&expr.hir_id.local_id);
1294                 if !promotable {
1295                     self.found |= true;
1296                 }
1297             }
1298
1299             if !self.found {
1300                 intravisit::walk_expr(self, expr);
1301             }
1302         }
1303
1304         fn nested_visit_map<'this>(&'this mut self) -> intravisit::NestedVisitorMap<'this, 'tcx> {
1305             intravisit::NestedVisitorMap::None
1306         }
1307     }
1308
1309     /// Checks for `unwrap_or(T::new())` or `unwrap_or(T::default())`.
1310     fn check_unwrap_or_default(
1311         cx: &LateContext<'_, '_>,
1312         name: &str,
1313         fun: &hir::Expr,
1314         self_expr: &hir::Expr,
1315         arg: &hir::Expr,
1316         or_has_args: bool,
1317         span: Span,
1318     ) -> bool {
1319         if_chain! {
1320             if !or_has_args;
1321             if name == "unwrap_or";
1322             if let hir::ExprKind::Path(ref qpath) = fun.node;
1323             let path = &*last_path_segment(qpath).ident.as_str();
1324             if ["default", "new"].contains(&path);
1325             let arg_ty = cx.tables.expr_ty(arg);
1326             if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT);
1327             if implements_trait(cx, arg_ty, default_trait_id, &[]);
1328
1329             then {
1330                 let mut applicability = Applicability::MachineApplicable;
1331                 span_lint_and_sugg(
1332                     cx,
1333                     OR_FUN_CALL,
1334                     span,
1335                     &format!("use of `{}` followed by a call to `{}`", name, path),
1336                     "try this",
1337                     format!(
1338                         "{}.unwrap_or_default()",
1339                         snippet_with_applicability(cx, self_expr.span, "_", &mut applicability)
1340                     ),
1341                     applicability,
1342                 );
1343
1344                 true
1345             } else {
1346                 false
1347             }
1348         }
1349     }
1350
1351     /// Checks for `*or(foo())`.
1352     #[allow(clippy::too_many_arguments)]
1353     fn check_general_case<'a, 'tcx>(
1354         cx: &LateContext<'a, 'tcx>,
1355         name: &str,
1356         method_span: Span,
1357         fun_span: Span,
1358         self_expr: &hir::Expr,
1359         arg: &'tcx hir::Expr,
1360         or_has_args: bool,
1361         span: Span,
1362     ) {
1363         // (path, fn_has_argument, methods, suffix)
1364         let know_types: &[(&[_], _, &[_], _)] = &[
1365             (&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
1366             (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"),
1367             (&paths::OPTION, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
1368             (&paths::RESULT, true, &["or", "unwrap_or"], "else"),
1369         ];
1370
1371         if_chain! {
1372             if know_types.iter().any(|k| k.2.contains(&name));
1373
1374             let mut finder = FunCallFinder { cx: &cx, found: false };
1375             if { finder.visit_expr(&arg); finder.found };
1376
1377             let self_ty = cx.tables.expr_ty(self_expr);
1378
1379             if let Some(&(_, fn_has_arguments, poss, suffix)) =
1380                    know_types.iter().find(|&&i| match_type(cx, self_ty, i.0));
1381
1382             if poss.contains(&name);
1383
1384             then {
1385                 let sugg: Cow<'_, _> = match (fn_has_arguments, !or_has_args) {
1386                     (true, _) => format!("|_| {}", snippet_with_macro_callsite(cx, arg.span, "..")).into(),
1387                     (false, false) => format!("|| {}", snippet_with_macro_callsite(cx, arg.span, "..")).into(),
1388                     (false, true) => snippet_with_macro_callsite(cx, fun_span, ".."),
1389                 };
1390                 let span_replace_word = method_span.with_hi(span.hi());
1391                 span_lint_and_sugg(
1392                     cx,
1393                     OR_FUN_CALL,
1394                     span_replace_word,
1395                     &format!("use of `{}` followed by a function call", name),
1396                     "try this",
1397                     format!("{}_{}({})", name, suffix, sugg),
1398                     Applicability::HasPlaceholders,
1399                 );
1400             }
1401         }
1402     }
1403
1404     if args.len() == 2 {
1405         match args[1].node {
1406             hir::ExprKind::Call(ref fun, ref or_args) => {
1407                 let or_has_args = !or_args.is_empty();
1408                 if !check_unwrap_or_default(cx, name, fun, &args[0], &args[1], or_has_args, expr.span) {
1409                     check_general_case(
1410                         cx,
1411                         name,
1412                         method_span,
1413                         fun.span,
1414                         &args[0],
1415                         &args[1],
1416                         or_has_args,
1417                         expr.span,
1418                     );
1419                 }
1420             },
1421             hir::ExprKind::MethodCall(_, span, ref or_args) => check_general_case(
1422                 cx,
1423                 name,
1424                 method_span,
1425                 span,
1426                 &args[0],
1427                 &args[1],
1428                 !or_args.is_empty(),
1429                 expr.span,
1430             ),
1431             _ => {},
1432         }
1433     }
1434 }
1435
1436 /// Checks for the `EXPECT_FUN_CALL` lint.
1437 #[allow(clippy::too_many_lines)]
1438 fn lint_expect_fun_call(cx: &LateContext<'_, '_>, expr: &hir::Expr, method_span: Span, name: &str, args: &[hir::Expr]) {
1439     // Strip `&`, `as_ref()` and `as_str()` off `arg` until we're left with either a `String` or
1440     // `&str`
1441     fn get_arg_root<'a>(cx: &LateContext<'_, '_>, arg: &'a hir::Expr) -> &'a hir::Expr {
1442         let mut arg_root = arg;
1443         loop {
1444             arg_root = match &arg_root.node {
1445                 hir::ExprKind::AddrOf(_, expr) => expr,
1446                 hir::ExprKind::MethodCall(method_name, _, call_args) => {
1447                     if call_args.len() == 1
1448                         && (method_name.ident.name == sym!(as_str) || method_name.ident.name == sym!(as_ref))
1449                         && {
1450                             let arg_type = cx.tables.expr_ty(&call_args[0]);
1451                             let base_type = walk_ptrs_ty(arg_type);
1452                             base_type.sty == ty::Str || match_type(cx, base_type, &paths::STRING)
1453                         }
1454                     {
1455                         &call_args[0]
1456                     } else {
1457                         break;
1458                     }
1459                 },
1460                 _ => break,
1461             };
1462         }
1463         arg_root
1464     }
1465
1466     // Only `&'static str` or `String` can be used directly in the `panic!`. Other types should be
1467     // converted to string.
1468     fn requires_to_string(cx: &LateContext<'_, '_>, arg: &hir::Expr) -> bool {
1469         let arg_ty = cx.tables.expr_ty(arg);
1470         if match_type(cx, arg_ty, &paths::STRING) {
1471             return false;
1472         }
1473         if let ty::Ref(ty::ReStatic, ty, ..) = arg_ty.sty {
1474             if ty.sty == ty::Str {
1475                 return false;
1476             }
1477         };
1478         true
1479     }
1480
1481     fn generate_format_arg_snippet(
1482         cx: &LateContext<'_, '_>,
1483         a: &hir::Expr,
1484         applicability: &mut Applicability,
1485     ) -> Vec<String> {
1486         if_chain! {
1487             if let hir::ExprKind::AddrOf(_, ref format_arg) = a.node;
1488             if let hir::ExprKind::Match(ref format_arg_expr, _, _) = format_arg.node;
1489             if let hir::ExprKind::Tup(ref format_arg_expr_tup) = format_arg_expr.node;
1490
1491             then {
1492                 format_arg_expr_tup
1493                     .iter()
1494                     .map(|a| snippet_with_applicability(cx, a.span, "..", applicability).into_owned())
1495                     .collect()
1496             } else {
1497                 unreachable!()
1498             }
1499         }
1500     }
1501
1502     fn is_call(node: &hir::ExprKind) -> bool {
1503         match node {
1504             hir::ExprKind::AddrOf(_, expr) => {
1505                 is_call(&expr.node)
1506             },
1507             hir::ExprKind::Call(..)
1508             | hir::ExprKind::MethodCall(..)
1509             // These variants are debatable or require further examination
1510             | hir::ExprKind::Match(..)
1511             | hir::ExprKind::Block{ .. } => true,
1512             _ => false,
1513         }
1514     }
1515
1516     if args.len() != 2 || name != "expect" || !is_call(&args[1].node) {
1517         return;
1518     }
1519
1520     let receiver_type = cx.tables.expr_ty(&args[0]);
1521     let closure_args = if match_type(cx, receiver_type, &paths::OPTION) {
1522         "||"
1523     } else if match_type(cx, receiver_type, &paths::RESULT) {
1524         "|_|"
1525     } else {
1526         return;
1527     };
1528
1529     let arg_root = get_arg_root(cx, &args[1]);
1530
1531     let span_replace_word = method_span.with_hi(expr.span.hi());
1532
1533     let mut applicability = Applicability::MachineApplicable;
1534
1535     //Special handling for `format!` as arg_root
1536     if let hir::ExprKind::Call(ref inner_fun, ref inner_args) = arg_root.node {
1537         if is_expn_of(inner_fun.span, "format").is_some() && inner_args.len() == 1 {
1538             if let hir::ExprKind::Call(_, format_args) = &inner_args[0].node {
1539                 let fmt_spec = &format_args[0];
1540                 let fmt_args = &format_args[1];
1541
1542                 let mut args = vec![snippet(cx, fmt_spec.span, "..").into_owned()];
1543
1544                 args.extend(generate_format_arg_snippet(cx, fmt_args, &mut applicability));
1545
1546                 let sugg = args.join(", ");
1547
1548                 span_lint_and_sugg(
1549                     cx,
1550                     EXPECT_FUN_CALL,
1551                     span_replace_word,
1552                     &format!("use of `{}` followed by a function call", name),
1553                     "try this",
1554                     format!("unwrap_or_else({} panic!({}))", closure_args, sugg),
1555                     applicability,
1556                 );
1557
1558                 return;
1559             }
1560         }
1561     }
1562
1563     let mut arg_root_snippet: Cow<'_, _> = snippet_with_applicability(cx, arg_root.span, "..", &mut applicability);
1564     if requires_to_string(cx, arg_root) {
1565         arg_root_snippet.to_mut().push_str(".to_string()");
1566     }
1567
1568     span_lint_and_sugg(
1569         cx,
1570         EXPECT_FUN_CALL,
1571         span_replace_word,
1572         &format!("use of `{}` followed by a function call", name),
1573         "try this",
1574         format!("unwrap_or_else({} {{ panic!({}) }})", closure_args, arg_root_snippet),
1575         applicability,
1576     );
1577 }
1578
1579 /// Checks for the `CLONE_ON_COPY` lint.
1580 fn lint_clone_on_copy(cx: &LateContext<'_, '_>, expr: &hir::Expr, arg: &hir::Expr, arg_ty: Ty<'_>) {
1581     let ty = cx.tables.expr_ty(expr);
1582     if let ty::Ref(_, inner, _) = arg_ty.sty {
1583         if let ty::Ref(_, innermost, _) = inner.sty {
1584             span_lint_and_then(
1585                 cx,
1586                 CLONE_DOUBLE_REF,
1587                 expr.span,
1588                 "using `clone` on a double-reference; \
1589                  this will copy the reference instead of cloning the inner type",
1590                 |db| {
1591                     if let Some(snip) = sugg::Sugg::hir_opt(cx, arg) {
1592                         let mut ty = innermost;
1593                         let mut n = 0;
1594                         while let ty::Ref(_, inner, _) = ty.sty {
1595                             ty = inner;
1596                             n += 1;
1597                         }
1598                         let refs: String = iter::repeat('&').take(n + 1).collect();
1599                         let derefs: String = iter::repeat('*').take(n).collect();
1600                         let explicit = format!("{}{}::clone({})", refs, ty, snip);
1601                         db.span_suggestion(
1602                             expr.span,
1603                             "try dereferencing it",
1604                             format!("{}({}{}).clone()", refs, derefs, snip.deref()),
1605                             Applicability::MaybeIncorrect,
1606                         );
1607                         db.span_suggestion(
1608                             expr.span,
1609                             "or try being explicit about what type to clone",
1610                             explicit,
1611                             Applicability::MaybeIncorrect,
1612                         );
1613                     }
1614                 },
1615             );
1616             return; // don't report clone_on_copy
1617         }
1618     }
1619
1620     if is_copy(cx, ty) {
1621         let snip;
1622         if let Some(snippet) = sugg::Sugg::hir_opt(cx, arg) {
1623             let parent = cx.tcx.hir().get_parent_node(expr.hir_id);
1624             match &cx.tcx.hir().get(parent) {
1625                 hir::Node::Expr(parent) => match parent.node {
1626                     // &*x is a nop, &x.clone() is not
1627                     hir::ExprKind::AddrOf(..) |
1628                     // (*x).func() is useless, x.clone().func() can work in case func borrows mutably
1629                     hir::ExprKind::MethodCall(..) => return,
1630                     _ => {},
1631                 },
1632                 hir::Node::Stmt(stmt) => {
1633                     if let hir::StmtKind::Local(ref loc) = stmt.node {
1634                         if let hir::PatKind::Ref(..) = loc.pat.node {
1635                             // let ref y = *x borrows x, let ref y = x.clone() does not
1636                             return;
1637                         }
1638                     }
1639                 },
1640                 _ => {},
1641             }
1642
1643             // x.clone() might have dereferenced x, possibly through Deref impls
1644             if cx.tables.expr_ty(arg) == ty {
1645                 snip = Some(("try removing the `clone` call", format!("{}", snippet)));
1646             } else {
1647                 let deref_count = cx
1648                     .tables
1649                     .expr_adjustments(arg)
1650                     .iter()
1651                     .filter(|adj| {
1652                         if let ty::adjustment::Adjust::Deref(_) = adj.kind {
1653                             true
1654                         } else {
1655                             false
1656                         }
1657                     })
1658                     .count();
1659                 let derefs: String = iter::repeat('*').take(deref_count).collect();
1660                 snip = Some(("try dereferencing it", format!("{}{}", derefs, snippet)));
1661             }
1662         } else {
1663             snip = None;
1664         }
1665         span_lint_and_then(cx, CLONE_ON_COPY, expr.span, "using `clone` on a `Copy` type", |db| {
1666             if let Some((text, snip)) = snip {
1667                 db.span_suggestion(expr.span, text, snip, Applicability::Unspecified);
1668             }
1669         });
1670     }
1671 }
1672
1673 fn lint_clone_on_ref_ptr(cx: &LateContext<'_, '_>, expr: &hir::Expr, arg: &hir::Expr) {
1674     let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(arg));
1675
1676     if let ty::Adt(_, subst) = obj_ty.sty {
1677         let caller_type = if match_type(cx, obj_ty, &paths::RC) {
1678             "Rc"
1679         } else if match_type(cx, obj_ty, &paths::ARC) {
1680             "Arc"
1681         } else if match_type(cx, obj_ty, &paths::WEAK_RC) || match_type(cx, obj_ty, &paths::WEAK_ARC) {
1682             "Weak"
1683         } else {
1684             return;
1685         };
1686
1687         span_lint_and_sugg(
1688             cx,
1689             CLONE_ON_REF_PTR,
1690             expr.span,
1691             "using '.clone()' on a ref-counted pointer",
1692             "try this",
1693             format!(
1694                 "{}::<{}>::clone(&{})",
1695                 caller_type,
1696                 subst.type_at(0),
1697                 snippet(cx, arg.span, "_")
1698             ),
1699             Applicability::Unspecified, // Sometimes unnecessary ::<_> after Rc/Arc/Weak
1700         );
1701     }
1702 }
1703
1704 fn lint_string_extend(cx: &LateContext<'_, '_>, expr: &hir::Expr, args: &[hir::Expr]) {
1705     let arg = &args[1];
1706     if let Some(arglists) = method_chain_args(arg, &["chars"]) {
1707         let target = &arglists[0][0];
1708         let self_ty = walk_ptrs_ty(cx.tables.expr_ty(target));
1709         let ref_str = if self_ty.sty == ty::Str {
1710             ""
1711         } else if match_type(cx, self_ty, &paths::STRING) {
1712             "&"
1713         } else {
1714             return;
1715         };
1716
1717         let mut applicability = Applicability::MachineApplicable;
1718         span_lint_and_sugg(
1719             cx,
1720             STRING_EXTEND_CHARS,
1721             expr.span,
1722             "calling `.extend(_.chars())`",
1723             "try this",
1724             format!(
1725                 "{}.push_str({}{})",
1726                 snippet_with_applicability(cx, args[0].span, "_", &mut applicability),
1727                 ref_str,
1728                 snippet_with_applicability(cx, target.span, "_", &mut applicability)
1729             ),
1730             applicability,
1731         );
1732     }
1733 }
1734
1735 fn lint_extend(cx: &LateContext<'_, '_>, expr: &hir::Expr, args: &[hir::Expr]) {
1736     let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&args[0]));
1737     if match_type(cx, obj_ty, &paths::STRING) {
1738         lint_string_extend(cx, expr, args);
1739     }
1740 }
1741
1742 fn lint_cstring_as_ptr(cx: &LateContext<'_, '_>, expr: &hir::Expr, source: &hir::Expr, unwrap: &hir::Expr) {
1743     if_chain! {
1744         let source_type = cx.tables.expr_ty(source);
1745         if let ty::Adt(def, substs) = source_type.sty;
1746         if match_def_path(cx, def.did, &paths::RESULT);
1747         if match_type(cx, substs.type_at(0), &paths::CSTRING);
1748         then {
1749             span_lint_and_then(
1750                 cx,
1751                 TEMPORARY_CSTRING_AS_PTR,
1752                 expr.span,
1753                 "you are getting the inner pointer of a temporary `CString`",
1754                 |db| {
1755                     db.note("that pointer will be invalid outside this expression");
1756                     db.span_help(unwrap.span, "assign the `CString` to a variable to extend its lifetime");
1757                 });
1758         }
1759     }
1760 }
1761
1762 fn lint_iter_cloned_collect<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &hir::Expr, iter_args: &'tcx [hir::Expr]) {
1763     if_chain! {
1764         if match_type(cx, cx.tables.expr_ty(expr), &paths::VEC);
1765         if let Some(slice) = derefs_to_slice(cx, &iter_args[0], cx.tables.expr_ty(&iter_args[0]));
1766         if let Some(to_replace) = expr.span.trim_start(slice.span.source_callsite());
1767
1768         then {
1769             span_lint_and_sugg(
1770                 cx,
1771                 ITER_CLONED_COLLECT,
1772                 to_replace,
1773                 "called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
1774                  more readable",
1775                 "try",
1776                 ".to_vec()".to_string(),
1777                 Applicability::MachineApplicable,
1778             );
1779         }
1780     }
1781 }
1782
1783 fn lint_unnecessary_fold(cx: &LateContext<'_, '_>, expr: &hir::Expr, fold_args: &[hir::Expr]) {
1784     fn check_fold_with_op(
1785         cx: &LateContext<'_, '_>,
1786         expr: &hir::Expr,
1787         fold_args: &[hir::Expr],
1788         op: hir::BinOpKind,
1789         replacement_method_name: &str,
1790         replacement_has_args: bool,
1791     ) {
1792         if_chain! {
1793             // Extract the body of the closure passed to fold
1794             if let hir::ExprKind::Closure(_, _, body_id, _, _) = fold_args[2].node;
1795             let closure_body = cx.tcx.hir().body(body_id);
1796             let closure_expr = remove_blocks(&closure_body.value);
1797
1798             // Check if the closure body is of the form `acc <op> some_expr(x)`
1799             if let hir::ExprKind::Binary(ref bin_op, ref left_expr, ref right_expr) = closure_expr.node;
1800             if bin_op.node == op;
1801
1802             // Extract the names of the two arguments to the closure
1803             if let Some(first_arg_ident) = get_arg_name(&closure_body.params[0].pat);
1804             if let Some(second_arg_ident) = get_arg_name(&closure_body.params[1].pat);
1805
1806             if match_var(&*left_expr, first_arg_ident);
1807             if replacement_has_args || match_var(&*right_expr, second_arg_ident);
1808
1809             if let hir::ExprKind::MethodCall(_, span, _) = &expr.node;
1810
1811             then {
1812                 let mut applicability = Applicability::MachineApplicable;
1813                 let sugg = if replacement_has_args {
1814                     format!(
1815                         "{replacement}(|{s}| {r})",
1816                         replacement = replacement_method_name,
1817                         s = second_arg_ident,
1818                         r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
1819                     )
1820                 } else {
1821                     format!(
1822                         "{replacement}()",
1823                         replacement = replacement_method_name,
1824                     )
1825                 };
1826
1827                 span_lint_and_sugg(
1828                     cx,
1829                     UNNECESSARY_FOLD,
1830                     span.with_hi(expr.span.hi()),
1831                     // TODO #2371 don't suggest e.g., .any(|x| f(x)) if we can suggest .any(f)
1832                     "this `.fold` can be written more succinctly using another method",
1833                     "try",
1834                     sugg,
1835                     applicability,
1836                 );
1837             }
1838         }
1839     }
1840
1841     // Check that this is a call to Iterator::fold rather than just some function called fold
1842     if !match_trait_method(cx, expr, &paths::ITERATOR) {
1843         return;
1844     }
1845
1846     assert!(
1847         fold_args.len() == 3,
1848         "Expected fold_args to have three entries - the receiver, the initial value and the closure"
1849     );
1850
1851     // Check if the first argument to .fold is a suitable literal
1852     if let hir::ExprKind::Lit(ref lit) = fold_args[1].node {
1853         match lit.node {
1854             ast::LitKind::Bool(false) => check_fold_with_op(cx, expr, fold_args, hir::BinOpKind::Or, "any", true),
1855             ast::LitKind::Bool(true) => check_fold_with_op(cx, expr, fold_args, hir::BinOpKind::And, "all", true),
1856             ast::LitKind::Int(0, _) => check_fold_with_op(cx, expr, fold_args, hir::BinOpKind::Add, "sum", false),
1857             ast::LitKind::Int(1, _) => check_fold_with_op(cx, expr, fold_args, hir::BinOpKind::Mul, "product", false),
1858             _ => (),
1859         }
1860     }
1861 }
1862
1863 fn lint_iter_nth<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &hir::Expr, iter_args: &'tcx [hir::Expr], is_mut: bool) {
1864     let mut_str = if is_mut { "_mut" } else { "" };
1865     let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.tables.expr_ty(&iter_args[0])).is_some() {
1866         "slice"
1867     } else if match_type(cx, cx.tables.expr_ty(&iter_args[0]), &paths::VEC) {
1868         "Vec"
1869     } else if match_type(cx, cx.tables.expr_ty(&iter_args[0]), &paths::VEC_DEQUE) {
1870         "VecDeque"
1871     } else {
1872         return; // caller is not a type that we want to lint
1873     };
1874
1875     span_lint(
1876         cx,
1877         ITER_NTH,
1878         expr.span,
1879         &format!(
1880             "called `.iter{0}().nth()` on a {1}. Calling `.get{0}()` is both faster and more readable",
1881             mut_str, caller_type
1882         ),
1883     );
1884 }
1885
1886 fn lint_get_unwrap<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &hir::Expr, get_args: &'tcx [hir::Expr], is_mut: bool) {
1887     // Note: we don't want to lint `get_mut().unwrap` for HashMap or BTreeMap,
1888     // because they do not implement `IndexMut`
1889     let mut applicability = Applicability::MachineApplicable;
1890     let expr_ty = cx.tables.expr_ty(&get_args[0]);
1891     let get_args_str = if get_args.len() > 1 {
1892         snippet_with_applicability(cx, get_args[1].span, "_", &mut applicability)
1893     } else {
1894         return; // not linting on a .get().unwrap() chain or variant
1895     };
1896     let mut needs_ref;
1897     let caller_type = if derefs_to_slice(cx, &get_args[0], expr_ty).is_some() {
1898         needs_ref = get_args_str.parse::<usize>().is_ok();
1899         "slice"
1900     } else if match_type(cx, expr_ty, &paths::VEC) {
1901         needs_ref = get_args_str.parse::<usize>().is_ok();
1902         "Vec"
1903     } else if match_type(cx, expr_ty, &paths::VEC_DEQUE) {
1904         needs_ref = get_args_str.parse::<usize>().is_ok();
1905         "VecDeque"
1906     } else if !is_mut && match_type(cx, expr_ty, &paths::HASHMAP) {
1907         needs_ref = true;
1908         "HashMap"
1909     } else if !is_mut && match_type(cx, expr_ty, &paths::BTREEMAP) {
1910         needs_ref = true;
1911         "BTreeMap"
1912     } else {
1913         return; // caller is not a type that we want to lint
1914     };
1915
1916     let mut span = expr.span;
1917
1918     // Handle the case where the result is immediately dereferenced
1919     // by not requiring ref and pulling the dereference into the
1920     // suggestion.
1921     if_chain! {
1922         if needs_ref;
1923         if let Some(parent) = get_parent_expr(cx, expr);
1924         if let hir::ExprKind::Unary(hir::UnOp::UnDeref, _) = parent.node;
1925         then {
1926             needs_ref = false;
1927             span = parent.span;
1928         }
1929     }
1930
1931     let mut_str = if is_mut { "_mut" } else { "" };
1932     let borrow_str = if !needs_ref {
1933         ""
1934     } else if is_mut {
1935         "&mut "
1936     } else {
1937         "&"
1938     };
1939
1940     span_lint_and_sugg(
1941         cx,
1942         GET_UNWRAP,
1943         span,
1944         &format!(
1945             "called `.get{0}().unwrap()` on a {1}. Using `[]` is more clear and more concise",
1946             mut_str, caller_type
1947         ),
1948         "try this",
1949         format!(
1950             "{}{}[{}]",
1951             borrow_str,
1952             snippet_with_applicability(cx, get_args[0].span, "_", &mut applicability),
1953             get_args_str
1954         ),
1955         applicability,
1956     );
1957 }
1958
1959 fn lint_iter_skip_next(cx: &LateContext<'_, '_>, expr: &hir::Expr) {
1960     // lint if caller of skip is an Iterator
1961     if match_trait_method(cx, expr, &paths::ITERATOR) {
1962         span_lint(
1963             cx,
1964             ITER_SKIP_NEXT,
1965             expr.span,
1966             "called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)`",
1967         );
1968     }
1969 }
1970
1971 fn derefs_to_slice<'a, 'tcx>(
1972     cx: &LateContext<'a, 'tcx>,
1973     expr: &'tcx hir::Expr,
1974     ty: Ty<'tcx>,
1975 ) -> Option<&'tcx hir::Expr> {
1976     fn may_slice<'a>(cx: &LateContext<'_, 'a>, ty: Ty<'a>) -> bool {
1977         match ty.sty {
1978             ty::Slice(_) => true,
1979             ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
1980             ty::Adt(..) => match_type(cx, ty, &paths::VEC),
1981             ty::Array(_, size) => size.eval_usize(cx.tcx, cx.param_env) < 32,
1982             ty::Ref(_, inner, _) => may_slice(cx, inner),
1983             _ => false,
1984         }
1985     }
1986
1987     if let hir::ExprKind::MethodCall(ref path, _, ref args) = expr.node {
1988         if path.ident.name == sym!(iter) && may_slice(cx, cx.tables.expr_ty(&args[0])) {
1989             Some(&args[0])
1990         } else {
1991             None
1992         }
1993     } else {
1994         match ty.sty {
1995             ty::Slice(_) => Some(expr),
1996             ty::Adt(def, _) if def.is_box() && may_slice(cx, ty.boxed_ty()) => Some(expr),
1997             ty::Ref(_, inner, _) => {
1998                 if may_slice(cx, inner) {
1999                     Some(expr)
2000                 } else {
2001                     None
2002                 }
2003             },
2004             _ => None,
2005         }
2006     }
2007 }
2008
2009 /// lint use of `unwrap()` for `Option`s and `Result`s
2010 fn lint_unwrap(cx: &LateContext<'_, '_>, expr: &hir::Expr, unwrap_args: &[hir::Expr]) {
2011     let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&unwrap_args[0]));
2012
2013     let mess = if match_type(cx, obj_ty, &paths::OPTION) {
2014         Some((OPTION_UNWRAP_USED, "an Option", "None"))
2015     } else if match_type(cx, obj_ty, &paths::RESULT) {
2016         Some((RESULT_UNWRAP_USED, "a Result", "Err"))
2017     } else {
2018         None
2019     };
2020
2021     if let Some((lint, kind, none_value)) = mess {
2022         span_lint(
2023             cx,
2024             lint,
2025             expr.span,
2026             &format!(
2027                 "used unwrap() on {} value. If you don't want to handle the {} case gracefully, consider \
2028                  using expect() to provide a better panic \
2029                  message",
2030                 kind, none_value
2031             ),
2032         );
2033     }
2034 }
2035
2036 /// lint use of `ok().expect()` for `Result`s
2037 fn lint_ok_expect(cx: &LateContext<'_, '_>, expr: &hir::Expr, ok_args: &[hir::Expr]) {
2038     if_chain! {
2039         // lint if the caller of `ok()` is a `Result`
2040         if match_type(cx, cx.tables.expr_ty(&ok_args[0]), &paths::RESULT);
2041         let result_type = cx.tables.expr_ty(&ok_args[0]);
2042         if let Some(error_type) = get_error_type(cx, result_type);
2043         if has_debug_impl(error_type, cx);
2044
2045         then {
2046             span_lint(
2047                 cx,
2048                 OK_EXPECT,
2049                 expr.span,
2050                 "called `ok().expect()` on a Result value. You can call `expect` directly on the `Result`",
2051             );
2052         }
2053     }
2054 }
2055
2056 /// lint use of `map().flatten()` for `Iterators`
2057 fn lint_map_flatten<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, map_args: &'tcx [hir::Expr]) {
2058     // lint if caller of `.map().flatten()` is an Iterator
2059     if match_trait_method(cx, expr, &paths::ITERATOR) {
2060         let msg = "called `map(..).flatten()` on an `Iterator`. \
2061                    This is more succinctly expressed by calling `.flat_map(..)`";
2062         let self_snippet = snippet(cx, map_args[0].span, "..");
2063         let func_snippet = snippet(cx, map_args[1].span, "..");
2064         let hint = format!("{0}.flat_map({1})", self_snippet, func_snippet);
2065         span_lint_and_then(cx, MAP_FLATTEN, expr.span, msg, |db| {
2066             db.span_suggestion(
2067                 expr.span,
2068                 "try using flat_map instead",
2069                 hint,
2070                 Applicability::MachineApplicable,
2071             );
2072         });
2073     }
2074 }
2075
2076 /// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
2077 fn lint_map_unwrap_or_else<'a, 'tcx>(
2078     cx: &LateContext<'a, 'tcx>,
2079     expr: &'tcx hir::Expr,
2080     map_args: &'tcx [hir::Expr],
2081     unwrap_args: &'tcx [hir::Expr],
2082 ) {
2083     // lint if the caller of `map()` is an `Option`
2084     let is_option = match_type(cx, cx.tables.expr_ty(&map_args[0]), &paths::OPTION);
2085     let is_result = match_type(cx, cx.tables.expr_ty(&map_args[0]), &paths::RESULT);
2086
2087     if is_option || is_result {
2088         // Don't make a suggestion that may fail to compile due to mutably borrowing
2089         // the same variable twice.
2090         let map_mutated_vars = mutated_variables(&map_args[0], cx);
2091         let unwrap_mutated_vars = mutated_variables(&unwrap_args[1], cx);
2092         if let (Some(map_mutated_vars), Some(unwrap_mutated_vars)) = (map_mutated_vars, unwrap_mutated_vars) {
2093             if map_mutated_vars.intersection(&unwrap_mutated_vars).next().is_some() {
2094                 return;
2095             }
2096         } else {
2097             return;
2098         }
2099
2100         // lint message
2101         let msg = if is_option {
2102             "called `map(f).unwrap_or_else(g)` on an Option value. This can be done more directly by calling \
2103              `map_or_else(g, f)` instead"
2104         } else {
2105             "called `map(f).unwrap_or_else(g)` on a Result value. This can be done more directly by calling \
2106              `ok().map_or_else(g, f)` instead"
2107         };
2108         // get snippets for args to map() and unwrap_or_else()
2109         let map_snippet = snippet(cx, map_args[1].span, "..");
2110         let unwrap_snippet = snippet(cx, unwrap_args[1].span, "..");
2111         // lint, with note if neither arg is > 1 line and both map() and
2112         // unwrap_or_else() have the same span
2113         let multiline = map_snippet.lines().count() > 1 || unwrap_snippet.lines().count() > 1;
2114         let same_span = map_args[1].span.ctxt() == unwrap_args[1].span.ctxt();
2115         if same_span && !multiline {
2116             span_note_and_lint(
2117                 cx,
2118                 if is_option {
2119                     OPTION_MAP_UNWRAP_OR_ELSE
2120                 } else {
2121                     RESULT_MAP_UNWRAP_OR_ELSE
2122                 },
2123                 expr.span,
2124                 msg,
2125                 expr.span,
2126                 &format!(
2127                     "replace `map({0}).unwrap_or_else({1})` with `{2}map_or_else({1}, {0})`",
2128                     map_snippet,
2129                     unwrap_snippet,
2130                     if is_result { "ok()." } else { "" }
2131                 ),
2132             );
2133         } else if same_span && multiline {
2134             span_lint(
2135                 cx,
2136                 if is_option {
2137                     OPTION_MAP_UNWRAP_OR_ELSE
2138                 } else {
2139                     RESULT_MAP_UNWRAP_OR_ELSE
2140                 },
2141                 expr.span,
2142                 msg,
2143             );
2144         };
2145     }
2146 }
2147
2148 /// lint use of `_.map_or(None, _)` for `Option`s
2149 fn lint_map_or_none<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, map_or_args: &'tcx [hir::Expr]) {
2150     if match_type(cx, cx.tables.expr_ty(&map_or_args[0]), &paths::OPTION) {
2151         // check if the first non-self argument to map_or() is None
2152         let map_or_arg_is_none = if let hir::ExprKind::Path(ref qpath) = map_or_args[1].node {
2153             match_qpath(qpath, &paths::OPTION_NONE)
2154         } else {
2155             false
2156         };
2157
2158         if map_or_arg_is_none {
2159             // lint message
2160             let msg = "called `map_or(None, f)` on an Option value. This can be done more directly by calling \
2161                        `and_then(f)` instead";
2162             let map_or_self_snippet = snippet(cx, map_or_args[0].span, "..");
2163             let map_or_func_snippet = snippet(cx, map_or_args[2].span, "..");
2164             let hint = format!("{0}.and_then({1})", map_or_self_snippet, map_or_func_snippet);
2165             span_lint_and_then(cx, OPTION_MAP_OR_NONE, expr.span, msg, |db| {
2166                 db.span_suggestion(
2167                     expr.span,
2168                     "try using and_then instead",
2169                     hint,
2170                     Applicability::MachineApplicable, // snippet
2171                 );
2172             });
2173         }
2174     }
2175 }
2176
2177 /// Lint use of `_.and_then(|x| Some(y))` for `Option`s
2178 fn lint_option_and_then_some(cx: &LateContext<'_, '_>, expr: &hir::Expr, args: &[hir::Expr]) {
2179     const LINT_MSG: &str = "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`";
2180     const NO_OP_MSG: &str = "using `Option.and_then(Some)`, which is a no-op";
2181
2182     // Searches an return expressions in `y` in `_.and_then(|x| Some(y))`, which we don't lint
2183     struct RetCallFinder {
2184         found: bool,
2185     }
2186
2187     impl<'tcx> intravisit::Visitor<'tcx> for RetCallFinder {
2188         fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
2189             if self.found {
2190                 return;
2191             }
2192             if let hir::ExprKind::Ret(..) = &expr.node {
2193                 self.found = true;
2194             } else {
2195                 intravisit::walk_expr(self, expr);
2196             }
2197         }
2198
2199         fn nested_visit_map<'this>(&'this mut self) -> intravisit::NestedVisitorMap<'this, 'tcx> {
2200             intravisit::NestedVisitorMap::None
2201         }
2202     }
2203
2204     let ty = cx.tables.expr_ty(&args[0]);
2205     if !match_type(cx, ty, &paths::OPTION) {
2206         return;
2207     }
2208
2209     match args[1].node {
2210         hir::ExprKind::Closure(_, _, body_id, closure_args_span, _) => {
2211             let closure_body = cx.tcx.hir().body(body_id);
2212             let closure_expr = remove_blocks(&closure_body.value);
2213             if_chain! {
2214                 if let hir::ExprKind::Call(ref some_expr, ref some_args) = closure_expr.node;
2215                 if let hir::ExprKind::Path(ref qpath) = some_expr.node;
2216                 if match_qpath(qpath, &paths::OPTION_SOME);
2217                 if some_args.len() == 1;
2218                 then {
2219                     let inner_expr = &some_args[0];
2220
2221                     let mut finder = RetCallFinder { found: false };
2222                     finder.visit_expr(inner_expr);
2223                     if finder.found {
2224                         return;
2225                     }
2226
2227                     let some_inner_snip = if inner_expr.span.from_expansion() {
2228                         snippet_with_macro_callsite(cx, inner_expr.span, "_")
2229                     } else {
2230                         snippet(cx, inner_expr.span, "_")
2231                     };
2232
2233                     let closure_args_snip = snippet(cx, closure_args_span, "..");
2234                     let option_snip = snippet(cx, args[0].span, "..");
2235                     let note = format!("{}.map({} {})", option_snip, closure_args_snip, some_inner_snip);
2236                     span_lint_and_sugg(
2237                         cx,
2238                         OPTION_AND_THEN_SOME,
2239                         expr.span,
2240                         LINT_MSG,
2241                         "try this",
2242                         note,
2243                         Applicability::MachineApplicable,
2244                     );
2245                 }
2246             }
2247         },
2248         // `_.and_then(Some)` case, which is no-op.
2249         hir::ExprKind::Path(ref qpath) => {
2250             if match_qpath(qpath, &paths::OPTION_SOME) {
2251                 let option_snip = snippet(cx, args[0].span, "..");
2252                 let note = format!("{}", option_snip);
2253                 span_lint_and_sugg(
2254                     cx,
2255                     OPTION_AND_THEN_SOME,
2256                     expr.span,
2257                     NO_OP_MSG,
2258                     "use the expression directly",
2259                     note,
2260                     Applicability::MachineApplicable,
2261                 );
2262             }
2263         },
2264         _ => {},
2265     }
2266 }
2267
2268 /// lint use of `filter().next()` for `Iterators`
2269 fn lint_filter_next<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, filter_args: &'tcx [hir::Expr]) {
2270     // lint if caller of `.filter().next()` is an Iterator
2271     if match_trait_method(cx, expr, &paths::ITERATOR) {
2272         let msg = "called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling \
2273                    `.find(p)` instead.";
2274         let filter_snippet = snippet(cx, filter_args[1].span, "..");
2275         if filter_snippet.lines().count() <= 1 {
2276             // add note if not multi-line
2277             span_note_and_lint(
2278                 cx,
2279                 FILTER_NEXT,
2280                 expr.span,
2281                 msg,
2282                 expr.span,
2283                 &format!("replace `filter({0}).next()` with `find({0})`", filter_snippet),
2284             );
2285         } else {
2286             span_lint(cx, FILTER_NEXT, expr.span, msg);
2287         }
2288     }
2289 }
2290
2291 /// lint use of `filter().map()` for `Iterators`
2292 fn lint_filter_map<'a, 'tcx>(
2293     cx: &LateContext<'a, 'tcx>,
2294     expr: &'tcx hir::Expr,
2295     _filter_args: &'tcx [hir::Expr],
2296     _map_args: &'tcx [hir::Expr],
2297 ) {
2298     // lint if caller of `.filter().map()` is an Iterator
2299     if match_trait_method(cx, expr, &paths::ITERATOR) {
2300         let msg = "called `filter(p).map(q)` on an `Iterator`. \
2301                    This is more succinctly expressed by calling `.filter_map(..)` instead.";
2302         span_lint(cx, FILTER_MAP, expr.span, msg);
2303     }
2304 }
2305
2306 /// lint use of `filter_map().next()` for `Iterators`
2307 fn lint_filter_map_next<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, filter_args: &'tcx [hir::Expr]) {
2308     if match_trait_method(cx, expr, &paths::ITERATOR) {
2309         let msg = "called `filter_map(p).next()` on an `Iterator`. This is more succinctly expressed by calling \
2310                    `.find_map(p)` instead.";
2311         let filter_snippet = snippet(cx, filter_args[1].span, "..");
2312         if filter_snippet.lines().count() <= 1 {
2313             span_note_and_lint(
2314                 cx,
2315                 FILTER_MAP_NEXT,
2316                 expr.span,
2317                 msg,
2318                 expr.span,
2319                 &format!("replace `filter_map({0}).next()` with `find_map({0})`", filter_snippet),
2320             );
2321         } else {
2322             span_lint(cx, FILTER_MAP_NEXT, expr.span, msg);
2323         }
2324     }
2325 }
2326
2327 /// lint use of `find().map()` for `Iterators`
2328 fn lint_find_map<'a, 'tcx>(
2329     cx: &LateContext<'a, 'tcx>,
2330     expr: &'tcx hir::Expr,
2331     _find_args: &'tcx [hir::Expr],
2332     map_args: &'tcx [hir::Expr],
2333 ) {
2334     // lint if caller of `.filter().map()` is an Iterator
2335     if match_trait_method(cx, &map_args[0], &paths::ITERATOR) {
2336         let msg = "called `find(p).map(q)` on an `Iterator`. \
2337                    This is more succinctly expressed by calling `.find_map(..)` instead.";
2338         span_lint(cx, FIND_MAP, expr.span, msg);
2339     }
2340 }
2341
2342 /// lint use of `filter().map()` for `Iterators`
2343 fn lint_filter_map_map<'a, 'tcx>(
2344     cx: &LateContext<'a, 'tcx>,
2345     expr: &'tcx hir::Expr,
2346     _filter_args: &'tcx [hir::Expr],
2347     _map_args: &'tcx [hir::Expr],
2348 ) {
2349     // lint if caller of `.filter().map()` is an Iterator
2350     if match_trait_method(cx, expr, &paths::ITERATOR) {
2351         let msg = "called `filter_map(p).map(q)` on an `Iterator`. \
2352                    This is more succinctly expressed by only calling `.filter_map(..)` instead.";
2353         span_lint(cx, FILTER_MAP, expr.span, msg);
2354     }
2355 }
2356
2357 /// lint use of `filter().flat_map()` for `Iterators`
2358 fn lint_filter_flat_map<'a, 'tcx>(
2359     cx: &LateContext<'a, 'tcx>,
2360     expr: &'tcx hir::Expr,
2361     _filter_args: &'tcx [hir::Expr],
2362     _map_args: &'tcx [hir::Expr],
2363 ) {
2364     // lint if caller of `.filter().flat_map()` is an Iterator
2365     if match_trait_method(cx, expr, &paths::ITERATOR) {
2366         let msg = "called `filter(p).flat_map(q)` on an `Iterator`. \
2367                    This is more succinctly expressed by calling `.flat_map(..)` \
2368                    and filtering by returning an empty Iterator.";
2369         span_lint(cx, FILTER_MAP, expr.span, msg);
2370     }
2371 }
2372
2373 /// lint use of `filter_map().flat_map()` for `Iterators`
2374 fn lint_filter_map_flat_map<'a, 'tcx>(
2375     cx: &LateContext<'a, 'tcx>,
2376     expr: &'tcx hir::Expr,
2377     _filter_args: &'tcx [hir::Expr],
2378     _map_args: &'tcx [hir::Expr],
2379 ) {
2380     // lint if caller of `.filter_map().flat_map()` is an Iterator
2381     if match_trait_method(cx, expr, &paths::ITERATOR) {
2382         let msg = "called `filter_map(p).flat_map(q)` on an `Iterator`. \
2383                    This is more succinctly expressed by calling `.flat_map(..)` \
2384                    and filtering by returning an empty Iterator.";
2385         span_lint(cx, FILTER_MAP, expr.span, msg);
2386     }
2387 }
2388
2389 /// lint use of `flat_map` for `Iterators` where `flatten` would be sufficient
2390 fn lint_flat_map_identity<'a, 'tcx>(
2391     cx: &LateContext<'a, 'tcx>,
2392     expr: &'tcx hir::Expr,
2393     flat_map_args: &'tcx [hir::Expr],
2394 ) {
2395     if match_trait_method(cx, expr, &paths::ITERATOR) {
2396         let arg_node = &flat_map_args[1].node;
2397
2398         let apply_lint = |message: &str| {
2399             if let hir::ExprKind::MethodCall(_, span, _) = &expr.node {
2400                 span_lint_and_sugg(
2401                     cx,
2402                     FLAT_MAP_IDENTITY,
2403                     span.with_hi(expr.span.hi()),
2404                     message,
2405                     "try",
2406                     "flatten()".to_string(),
2407                     Applicability::MachineApplicable,
2408                 );
2409             }
2410         };
2411
2412         if_chain! {
2413             if let hir::ExprKind::Closure(_, _, body_id, _, _) = arg_node;
2414             let body = cx.tcx.hir().body(*body_id);
2415
2416             if let hir::PatKind::Binding(_, _, binding_ident, _) = body.params[0].pat.node;
2417             if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = body.value.node;
2418
2419             if path.segments.len() == 1;
2420             if path.segments[0].ident.as_str() == binding_ident.as_str();
2421
2422             then {
2423                 apply_lint("called `flat_map(|x| x)` on an `Iterator`");
2424             }
2425         }
2426
2427         if_chain! {
2428             if let hir::ExprKind::Path(ref qpath) = arg_node;
2429
2430             if match_qpath(qpath, &paths::STD_CONVERT_IDENTITY);
2431
2432             then {
2433                 apply_lint("called `flat_map(std::convert::identity)` on an `Iterator`");
2434             }
2435         }
2436     }
2437 }
2438
2439 /// lint searching an Iterator followed by `is_some()`
2440 fn lint_search_is_some<'a, 'tcx>(
2441     cx: &LateContext<'a, 'tcx>,
2442     expr: &'tcx hir::Expr,
2443     search_method: &str,
2444     search_args: &'tcx [hir::Expr],
2445     is_some_args: &'tcx [hir::Expr],
2446 ) {
2447     // lint if caller of search is an Iterator
2448     if match_trait_method(cx, &is_some_args[0], &paths::ITERATOR) {
2449         let msg = format!(
2450             "called `is_some()` after searching an `Iterator` with {}. This is more succinctly \
2451              expressed by calling `any()`.",
2452             search_method
2453         );
2454         let search_snippet = snippet(cx, search_args[1].span, "..");
2455         if search_snippet.lines().count() <= 1 {
2456             // suggest `any(|x| ..)` instead of `any(|&x| ..)` for `find(|&x| ..).is_some()`
2457             let any_search_snippet = if_chain! {
2458                 if search_method == "find";
2459                 if let hir::ExprKind::Closure(_, _, body_id, ..) = search_args[1].node;
2460                 let closure_body = cx.tcx.hir().body(body_id);
2461                 if let Some(closure_arg) = closure_body.params.get(0);
2462                 if let hir::PatKind::Ref(..) = closure_arg.pat.node;
2463                 then {
2464                     Some(search_snippet.replacen('&', "", 1))
2465                 } else {
2466                     None
2467                 }
2468             };
2469             // add note if not multi-line
2470             span_note_and_lint(
2471                 cx,
2472                 SEARCH_IS_SOME,
2473                 expr.span,
2474                 &msg,
2475                 expr.span,
2476                 &format!(
2477                     "replace `{0}({1}).is_some()` with `any({2})`",
2478                     search_method,
2479                     search_snippet,
2480                     any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
2481                 ),
2482             );
2483         } else {
2484             span_lint(cx, SEARCH_IS_SOME, expr.span, &msg);
2485         }
2486     }
2487 }
2488
2489 /// Used for `lint_binary_expr_with_method_call`.
2490 #[derive(Copy, Clone)]
2491 struct BinaryExprInfo<'a> {
2492     expr: &'a hir::Expr,
2493     chain: &'a hir::Expr,
2494     other: &'a hir::Expr,
2495     eq: bool,
2496 }
2497
2498 /// Checks for the `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
2499 fn lint_binary_expr_with_method_call(cx: &LateContext<'_, '_>, info: &mut BinaryExprInfo<'_>) {
2500     macro_rules! lint_with_both_lhs_and_rhs {
2501         ($func:ident, $cx:expr, $info:ident) => {
2502             if !$func($cx, $info) {
2503                 ::std::mem::swap(&mut $info.chain, &mut $info.other);
2504                 if $func($cx, $info) {
2505                     return;
2506                 }
2507             }
2508         };
2509     }
2510
2511     lint_with_both_lhs_and_rhs!(lint_chars_next_cmp, cx, info);
2512     lint_with_both_lhs_and_rhs!(lint_chars_last_cmp, cx, info);
2513     lint_with_both_lhs_and_rhs!(lint_chars_next_cmp_with_unwrap, cx, info);
2514     lint_with_both_lhs_and_rhs!(lint_chars_last_cmp_with_unwrap, cx, info);
2515 }
2516
2517 /// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
2518 fn lint_chars_cmp(
2519     cx: &LateContext<'_, '_>,
2520     info: &BinaryExprInfo<'_>,
2521     chain_methods: &[&str],
2522     lint: &'static Lint,
2523     suggest: &str,
2524 ) -> bool {
2525     if_chain! {
2526         if let Some(args) = method_chain_args(info.chain, chain_methods);
2527         if let hir::ExprKind::Call(ref fun, ref arg_char) = info.other.node;
2528         if arg_char.len() == 1;
2529         if let hir::ExprKind::Path(ref qpath) = fun.node;
2530         if let Some(segment) = single_segment_path(qpath);
2531         if segment.ident.name == sym!(Some);
2532         then {
2533             let mut applicability = Applicability::MachineApplicable;
2534             let self_ty = walk_ptrs_ty(cx.tables.expr_ty_adjusted(&args[0][0]));
2535
2536             if self_ty.sty != ty::Str {
2537                 return false;
2538             }
2539
2540             span_lint_and_sugg(
2541                 cx,
2542                 lint,
2543                 info.expr.span,
2544                 &format!("you should use the `{}` method", suggest),
2545                 "like this",
2546                 format!("{}{}.{}({})",
2547                         if info.eq { "" } else { "!" },
2548                         snippet_with_applicability(cx, args[0][0].span, "_", &mut applicability),
2549                         suggest,
2550                         snippet_with_applicability(cx, arg_char[0].span, "_", &mut applicability)),
2551                 applicability,
2552             );
2553
2554             return true;
2555         }
2556     }
2557
2558     false
2559 }
2560
2561 /// Checks for the `CHARS_NEXT_CMP` lint.
2562 fn lint_chars_next_cmp<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
2563     lint_chars_cmp(cx, info, &["chars", "next"], CHARS_NEXT_CMP, "starts_with")
2564 }
2565
2566 /// Checks for the `CHARS_LAST_CMP` lint.
2567 fn lint_chars_last_cmp<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
2568     if lint_chars_cmp(cx, info, &["chars", "last"], CHARS_LAST_CMP, "ends_with") {
2569         true
2570     } else {
2571         lint_chars_cmp(cx, info, &["chars", "next_back"], CHARS_LAST_CMP, "ends_with")
2572     }
2573 }
2574
2575 /// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints with `unwrap()`.
2576 fn lint_chars_cmp_with_unwrap<'a, 'tcx>(
2577     cx: &LateContext<'a, 'tcx>,
2578     info: &BinaryExprInfo<'_>,
2579     chain_methods: &[&str],
2580     lint: &'static Lint,
2581     suggest: &str,
2582 ) -> bool {
2583     if_chain! {
2584         if let Some(args) = method_chain_args(info.chain, chain_methods);
2585         if let hir::ExprKind::Lit(ref lit) = info.other.node;
2586         if let ast::LitKind::Char(c) = lit.node;
2587         then {
2588             let mut applicability = Applicability::MachineApplicable;
2589             span_lint_and_sugg(
2590                 cx,
2591                 lint,
2592                 info.expr.span,
2593                 &format!("you should use the `{}` method", suggest),
2594                 "like this",
2595                 format!("{}{}.{}('{}')",
2596                         if info.eq { "" } else { "!" },
2597                         snippet_with_applicability(cx, args[0][0].span, "_", &mut applicability),
2598                         suggest,
2599                         c),
2600                 applicability,
2601             );
2602
2603             true
2604         } else {
2605             false
2606         }
2607     }
2608 }
2609
2610 /// Checks for the `CHARS_NEXT_CMP` lint with `unwrap()`.
2611 fn lint_chars_next_cmp_with_unwrap<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
2612     lint_chars_cmp_with_unwrap(cx, info, &["chars", "next", "unwrap"], CHARS_NEXT_CMP, "starts_with")
2613 }
2614
2615 /// Checks for the `CHARS_LAST_CMP` lint with `unwrap()`.
2616 fn lint_chars_last_cmp_with_unwrap<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
2617     if lint_chars_cmp_with_unwrap(cx, info, &["chars", "last", "unwrap"], CHARS_LAST_CMP, "ends_with") {
2618         true
2619     } else {
2620         lint_chars_cmp_with_unwrap(cx, info, &["chars", "next_back", "unwrap"], CHARS_LAST_CMP, "ends_with")
2621     }
2622 }
2623
2624 /// lint for length-1 `str`s for methods in `PATTERN_METHODS`
2625 fn lint_single_char_pattern<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, _expr: &'tcx hir::Expr, arg: &'tcx hir::Expr) {
2626     if_chain! {
2627         if let hir::ExprKind::Lit(lit) = &arg.node;
2628         if let ast::LitKind::Str(r, style) = lit.node;
2629         if r.as_str().len() == 1;
2630         then {
2631             let mut applicability = Applicability::MachineApplicable;
2632             let snip = snippet_with_applicability(cx, arg.span, "..", &mut applicability);
2633             let ch = if let ast::StrStyle::Raw(nhash) = style {
2634                 let nhash = nhash as usize;
2635                 // for raw string: r##"a"##
2636                 &snip[(nhash + 2)..(snip.len() - 1 - nhash)]
2637             } else {
2638                 // for regular string: "a"
2639                 &snip[1..(snip.len() - 1)]
2640             };
2641             let hint = format!("'{}'", if ch == "'" { "\\'" } else { ch });
2642             span_lint_and_sugg(
2643                 cx,
2644                 SINGLE_CHAR_PATTERN,
2645                 arg.span,
2646                 "single-character string constant used as pattern",
2647                 "try using a char instead",
2648                 hint,
2649                 applicability,
2650             );
2651         }
2652     }
2653 }
2654
2655 /// Checks for the `USELESS_ASREF` lint.
2656 fn lint_asref(cx: &LateContext<'_, '_>, expr: &hir::Expr, call_name: &str, as_ref_args: &[hir::Expr]) {
2657     // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
2658     // check if the call is to the actual `AsRef` or `AsMut` trait
2659     if match_trait_method(cx, expr, &paths::ASREF_TRAIT) || match_trait_method(cx, expr, &paths::ASMUT_TRAIT) {
2660         // check if the type after `as_ref` or `as_mut` is the same as before
2661         let recvr = &as_ref_args[0];
2662         let rcv_ty = cx.tables.expr_ty(recvr);
2663         let res_ty = cx.tables.expr_ty(expr);
2664         let (base_res_ty, res_depth) = walk_ptrs_ty_depth(res_ty);
2665         let (base_rcv_ty, rcv_depth) = walk_ptrs_ty_depth(rcv_ty);
2666         if base_rcv_ty == base_res_ty && rcv_depth >= res_depth {
2667             // allow the `as_ref` or `as_mut` if it is followed by another method call
2668             if_chain! {
2669                 if let Some(parent) = get_parent_expr(cx, expr);
2670                 if let hir::ExprKind::MethodCall(_, ref span, _) = parent.node;
2671                 if span != &expr.span;
2672                 then {
2673                     return;
2674                 }
2675             }
2676
2677             let mut applicability = Applicability::MachineApplicable;
2678             span_lint_and_sugg(
2679                 cx,
2680                 USELESS_ASREF,
2681                 expr.span,
2682                 &format!("this call to `{}` does nothing", call_name),
2683                 "try this",
2684                 snippet_with_applicability(cx, recvr.span, "_", &mut applicability).to_string(),
2685                 applicability,
2686             );
2687         }
2688     }
2689 }
2690
2691 fn ty_has_iter_method(
2692     cx: &LateContext<'_, '_>,
2693     self_ref_ty: Ty<'_>,
2694 ) -> Option<(&'static Lint, &'static str, &'static str)> {
2695     has_iter_method(cx, self_ref_ty).map(|ty_name| {
2696         let lint = if ty_name == "array" || ty_name == "PathBuf" {
2697             INTO_ITER_ON_ARRAY
2698         } else {
2699             INTO_ITER_ON_REF
2700         };
2701         let mutbl = match self_ref_ty.sty {
2702             ty::Ref(_, _, mutbl) => mutbl,
2703             _ => unreachable!(),
2704         };
2705         let method_name = match mutbl {
2706             hir::MutImmutable => "iter",
2707             hir::MutMutable => "iter_mut",
2708         };
2709         (lint, ty_name, method_name)
2710     })
2711 }
2712
2713 fn lint_into_iter(cx: &LateContext<'_, '_>, expr: &hir::Expr, self_ref_ty: Ty<'_>, method_span: Span) {
2714     if !match_trait_method(cx, expr, &paths::INTO_ITERATOR) {
2715         return;
2716     }
2717     if let Some((lint, kind, method_name)) = ty_has_iter_method(cx, self_ref_ty) {
2718         span_lint_and_sugg(
2719             cx,
2720             lint,
2721             method_span,
2722             &format!(
2723                 "this .into_iter() call is equivalent to .{}() and will not move the {}",
2724                 method_name, kind,
2725             ),
2726             "call directly",
2727             method_name.to_string(),
2728             Applicability::MachineApplicable,
2729         );
2730     }
2731 }
2732
2733 /// lint for `MaybeUninit::uninit().assume_init()` (we already have the latter)
2734 fn lint_maybe_uninit(cx: &LateContext<'_, '_>, expr: &hir::Expr, outer: &hir::Expr) {
2735     if_chain! {
2736         if let hir::ExprKind::Call(ref callee, ref args) = expr.node;
2737         if args.is_empty();
2738         if let hir::ExprKind::Path(ref path) = callee.node;
2739         if match_qpath(path, &paths::MEM_MAYBEUNINIT_UNINIT);
2740         if !is_maybe_uninit_ty_valid(cx, cx.tables.expr_ty_adjusted(outer));
2741         then {
2742             span_lint(
2743                 cx,
2744                 UNINIT_ASSUMED_INIT,
2745                 outer.span,
2746                 "this call for this type may be undefined behavior"
2747             );
2748         }
2749     }
2750 }
2751
2752 fn is_maybe_uninit_ty_valid(cx: &LateContext<'_, '_>, ty: Ty<'_>) -> bool {
2753     match ty.sty {
2754         ty::Array(ref component, _) => is_maybe_uninit_ty_valid(cx, component),
2755         ty::Tuple(ref types) => types.types().all(|ty| is_maybe_uninit_ty_valid(cx, ty)),
2756         ty::Adt(ref adt, _) => {
2757             // needs to be a MaybeUninit
2758             match_def_path(cx, adt.did, &paths::MEM_MAYBEUNINIT)
2759         },
2760         _ => false,
2761     }
2762 }
2763
2764 fn lint_suspicious_map(cx: &LateContext<'_, '_>, expr: &hir::Expr) {
2765     span_help_and_lint(
2766         cx,
2767         SUSPICIOUS_MAP,
2768         expr.span,
2769         "this call to `map()` won't have an effect on the call to `count()`",
2770         "make sure you did not confuse `map` with `filter`",
2771     );
2772 }
2773
2774 /// Given a `Result<T, E>` type, return its error type (`E`).
2775 fn get_error_type<'a>(cx: &LateContext<'_, '_>, ty: Ty<'a>) -> Option<Ty<'a>> {
2776     match ty.sty {
2777         ty::Adt(_, substs) if match_type(cx, ty, &paths::RESULT) => substs.types().nth(1),
2778         _ => None,
2779     }
2780 }
2781
2782 /// This checks whether a given type is known to implement Debug.
2783 fn has_debug_impl<'a, 'b>(ty: Ty<'a>, cx: &LateContext<'b, 'a>) -> bool {
2784     match cx.tcx.get_diagnostic_item(sym::debug_trait) {
2785         Some(debug) => implements_trait(cx, ty, debug, &[]),
2786         None => false,
2787     }
2788 }
2789
2790 enum Convention {
2791     Eq(&'static str),
2792     StartsWith(&'static str),
2793 }
2794
2795 #[rustfmt::skip]
2796 const CONVENTIONS: [(Convention, &[SelfKind]); 7] = [
2797     (Convention::Eq("new"), &[SelfKind::No]),
2798     (Convention::StartsWith("as_"), &[SelfKind::Ref, SelfKind::RefMut]),
2799     (Convention::StartsWith("from_"), &[SelfKind::No]),
2800     (Convention::StartsWith("into_"), &[SelfKind::Value]),
2801     (Convention::StartsWith("is_"), &[SelfKind::Ref, SelfKind::No]),
2802     (Convention::Eq("to_mut"), &[SelfKind::RefMut]),
2803     (Convention::StartsWith("to_"), &[SelfKind::Ref]),
2804 ];
2805
2806 #[rustfmt::skip]
2807 const TRAIT_METHODS: [(&str, usize, SelfKind, OutType, &str); 30] = [
2808     ("add", 2, SelfKind::Value, OutType::Any, "std::ops::Add"),
2809     ("as_mut", 1, SelfKind::RefMut, OutType::Ref, "std::convert::AsMut"),
2810     ("as_ref", 1, SelfKind::Ref, OutType::Ref, "std::convert::AsRef"),
2811     ("bitand", 2, SelfKind::Value, OutType::Any, "std::ops::BitAnd"),
2812     ("bitor", 2, SelfKind::Value, OutType::Any, "std::ops::BitOr"),
2813     ("bitxor", 2, SelfKind::Value, OutType::Any, "std::ops::BitXor"),
2814     ("borrow", 1, SelfKind::Ref, OutType::Ref, "std::borrow::Borrow"),
2815     ("borrow_mut", 1, SelfKind::RefMut, OutType::Ref, "std::borrow::BorrowMut"),
2816     ("clone", 1, SelfKind::Ref, OutType::Any, "std::clone::Clone"),
2817     ("cmp", 2, SelfKind::Ref, OutType::Any, "std::cmp::Ord"),
2818     ("default", 0, SelfKind::No, OutType::Any, "std::default::Default"),
2819     ("deref", 1, SelfKind::Ref, OutType::Ref, "std::ops::Deref"),
2820     ("deref_mut", 1, SelfKind::RefMut, OutType::Ref, "std::ops::DerefMut"),
2821     ("div", 2, SelfKind::Value, OutType::Any, "std::ops::Div"),
2822     ("drop", 1, SelfKind::RefMut, OutType::Unit, "std::ops::Drop"),
2823     ("eq", 2, SelfKind::Ref, OutType::Bool, "std::cmp::PartialEq"),
2824     ("from_iter", 1, SelfKind::No, OutType::Any, "std::iter::FromIterator"),
2825     ("from_str", 1, SelfKind::No, OutType::Any, "std::str::FromStr"),
2826     ("hash", 2, SelfKind::Ref, OutType::Unit, "std::hash::Hash"),
2827     ("index", 2, SelfKind::Ref, OutType::Ref, "std::ops::Index"),
2828     ("index_mut", 2, SelfKind::RefMut, OutType::Ref, "std::ops::IndexMut"),
2829     ("into_iter", 1, SelfKind::Value, OutType::Any, "std::iter::IntoIterator"),
2830     ("mul", 2, SelfKind::Value, OutType::Any, "std::ops::Mul"),
2831     ("neg", 1, SelfKind::Value, OutType::Any, "std::ops::Neg"),
2832     ("next", 1, SelfKind::RefMut, OutType::Any, "std::iter::Iterator"),
2833     ("not", 1, SelfKind::Value, OutType::Any, "std::ops::Not"),
2834     ("rem", 2, SelfKind::Value, OutType::Any, "std::ops::Rem"),
2835     ("shl", 2, SelfKind::Value, OutType::Any, "std::ops::Shl"),
2836     ("shr", 2, SelfKind::Value, OutType::Any, "std::ops::Shr"),
2837     ("sub", 2, SelfKind::Value, OutType::Any, "std::ops::Sub"),
2838 ];
2839
2840 #[rustfmt::skip]
2841 const PATTERN_METHODS: [(&str, usize); 17] = [
2842     ("contains", 1),
2843     ("starts_with", 1),
2844     ("ends_with", 1),
2845     ("find", 1),
2846     ("rfind", 1),
2847     ("split", 1),
2848     ("rsplit", 1),
2849     ("split_terminator", 1),
2850     ("rsplit_terminator", 1),
2851     ("splitn", 2),
2852     ("rsplitn", 2),
2853     ("matches", 1),
2854     ("rmatches", 1),
2855     ("match_indices", 1),
2856     ("rmatch_indices", 1),
2857     ("trim_start_matches", 1),
2858     ("trim_end_matches", 1),
2859 ];
2860
2861 #[derive(Clone, Copy, PartialEq, Debug)]
2862 enum SelfKind {
2863     Value,
2864     Ref,
2865     RefMut,
2866     No,
2867 }
2868
2869 impl SelfKind {
2870     fn matches<'a>(self, cx: &LateContext<'_, 'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
2871         fn matches_value(parent_ty: Ty<'_>, ty: Ty<'_>) -> bool {
2872             if ty == parent_ty {
2873                 true
2874             } else if ty.is_box() {
2875                 ty.boxed_ty() == parent_ty
2876             } else if ty.is_rc() || ty.is_arc() {
2877                 if let ty::Adt(_, substs) = ty.sty {
2878                     substs.types().next().map_or(false, |t| t == parent_ty)
2879                 } else {
2880                     false
2881                 }
2882             } else {
2883                 false
2884             }
2885         }
2886
2887         fn matches_ref<'a>(
2888             cx: &LateContext<'_, 'a>,
2889             mutability: hir::Mutability,
2890             parent_ty: Ty<'a>,
2891             ty: Ty<'a>,
2892         ) -> bool {
2893             if let ty::Ref(_, t, m) = ty.sty {
2894                 return m == mutability && t == parent_ty;
2895             }
2896
2897             let trait_path = match mutability {
2898                 hir::Mutability::MutImmutable => &paths::ASREF_TRAIT,
2899                 hir::Mutability::MutMutable => &paths::ASMUT_TRAIT,
2900             };
2901
2902             let trait_def_id = match get_trait_def_id(cx, trait_path) {
2903                 Some(did) => did,
2904                 None => return false,
2905             };
2906             implements_trait(cx, ty, trait_def_id, &[parent_ty.into()])
2907         }
2908
2909         match self {
2910             Self::Value => matches_value(parent_ty, ty),
2911             Self::Ref => {
2912                 matches_ref(cx, hir::Mutability::MutImmutable, parent_ty, ty) || ty == parent_ty && is_copy(cx, ty)
2913             },
2914             Self::RefMut => matches_ref(cx, hir::Mutability::MutMutable, parent_ty, ty),
2915             Self::No => ty != parent_ty,
2916         }
2917     }
2918
2919     fn description(self) -> &'static str {
2920         match self {
2921             Self::Value => "self by value",
2922             Self::Ref => "self by reference",
2923             Self::RefMut => "self by mutable reference",
2924             Self::No => "no self",
2925         }
2926     }
2927 }
2928
2929 impl Convention {
2930     fn check(&self, other: &str) -> bool {
2931         match *self {
2932             Self::Eq(this) => this == other,
2933             Self::StartsWith(this) => other.starts_with(this) && this != other,
2934         }
2935     }
2936 }
2937
2938 impl fmt::Display for Convention {
2939     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
2940         match *self {
2941             Self::Eq(this) => this.fmt(f),
2942             Self::StartsWith(this) => this.fmt(f).and_then(|_| '*'.fmt(f)),
2943         }
2944     }
2945 }
2946
2947 #[derive(Clone, Copy)]
2948 enum OutType {
2949     Unit,
2950     Bool,
2951     Any,
2952     Ref,
2953 }
2954
2955 impl OutType {
2956     fn matches(self, cx: &LateContext<'_, '_>, ty: &hir::FunctionRetTy) -> bool {
2957         let is_unit = |ty: &hir::Ty| SpanlessEq::new(cx).eq_ty_kind(&ty.node, &hir::TyKind::Tup(vec![].into()));
2958         match (self, ty) {
2959             (Self::Unit, &hir::DefaultReturn(_)) => true,
2960             (Self::Unit, &hir::Return(ref ty)) if is_unit(ty) => true,
2961             (Self::Bool, &hir::Return(ref ty)) if is_bool(ty) => true,
2962             (Self::Any, &hir::Return(ref ty)) if !is_unit(ty) => true,
2963             (Self::Ref, &hir::Return(ref ty)) => matches!(ty.node, hir::TyKind::Rptr(_, _)),
2964             _ => false,
2965         }
2966     }
2967 }
2968
2969 fn is_bool(ty: &hir::Ty) -> bool {
2970     if let hir::TyKind::Path(ref p) = ty.node {
2971         match_qpath(p, &["bool"])
2972     } else {
2973         false
2974     }
2975 }