clippy_lints/src/methods/mod.rs

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