clippy_lints/src/methods/mod.rs

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