clippy_lints/src/methods/mod.rs

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