clippy_lints/src/utils/mod.rs

   1 use crate::reexport::*;
   2 use if_chain::if_chain;
   3 use matches::matches;
   4 use rustc::hir;
   5 use rustc::hir::def::Def;
   6 use rustc::hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
   7 use rustc::hir::intravisit::{NestedVisitorMap, Visitor};
   8 use rustc::hir::Node;
   9 use rustc::hir::*;
  10 use rustc::lint::{LateContext, Level, Lint, LintContext};
  11 use rustc::session::Session;
  12 use rustc::traits;
  13 use rustc::ty::{
  14     self,
  15     layout::{self, IntegerExt},
  16     subst::Kind,
  17     Binder, Ty, TyCtxt,
  18 };
  19 use rustc_data_structures::sync::Lrc;
  20 use rustc_errors::Applicability;
  21 use std::borrow::Cow;
  22 use std::mem;
  23 use std::str::FromStr;
  24 use syntax::ast::{self, LitKind};
  25 use syntax::attr;
  26 use syntax::source_map::{Span, DUMMY_SP};
  27 use syntax::symbol;
  28 use syntax::symbol::{keywords, Symbol};
  29
  30 pub mod camel_case;
  31
  32 pub mod author;
  33 pub mod comparisons;
  34 pub mod conf;
  35 pub mod constants;
  36 mod diagnostics;
  37 mod hir_utils;
  38 pub mod inspector;
  39 pub mod internal_lints;
  40 pub mod paths;
  41 pub mod ptr;
  42 pub mod sugg;
  43 pub mod usage;
  44 pub use self::diagnostics::*;
  45 pub use self::hir_utils::{SpanlessEq, SpanlessHash};
  46
  47 pub mod higher;
  48
  49 /// Returns true if the two spans come from differing expansions (i.e. one is
  50 /// from a macro and one
  51 /// isn't).
  52 pub fn differing_macro_contexts(lhs: Span, rhs: Span) -> bool {
  53     rhs.ctxt() != lhs.ctxt()
  54 }
  55
  56 /// Returns `true` if the given `NodeId` is inside a constant context
  57 ///
  58 /// # Example
  59 ///
  60 /// ```rust,ignore
  61 /// if in_constant(cx, expr.id) {
  62 ///     // Do something
  63 /// }
  64 /// ```
  65 pub fn in_constant(cx: &LateContext<'_, '_>, id: NodeId) -> bool {
  66     let parent_id = cx.tcx.hir().get_parent(id);
  67     match cx.tcx.hir().get(parent_id) {
  68         Node::Item(&Item {
  69             node: ItemKind::Const(..),
  70             ..
  71         })
  72         | Node::TraitItem(&TraitItem {
  73             node: TraitItemKind::Const(..),
  74             ..
  75         })
  76         | Node::ImplItem(&ImplItem {
  77             node: ImplItemKind::Const(..),
  78             ..
  79         })
  80         | Node::AnonConst(_)
  81         | Node::Item(&Item {
  82             node: ItemKind::Static(..),
  83             ..
  84         }) => true,
  85         Node::Item(&Item {
  86             node: ItemKind::Fn(_, header, ..),
  87             ..
  88         }) => header.constness == Constness::Const,
  89         _ => false,
  90     }
  91 }
  92
  93 /// Returns true if this `expn_info` was expanded by any macro.
  94 pub fn in_macro(span: Span) -> bool {
  95     span.ctxt().outer().expn_info().is_some()
  96 }
  97
  98 /// Used to store the absolute path to a type.
  99 ///
 100 /// See `match_def_path` for usage.
 101 #[derive(Debug)]
 102 pub struct AbsolutePathBuffer {
 103     pub names: Vec<symbol::LocalInternedString>,
 104 }
 105
 106 impl ty::item_path::ItemPathBuffer for AbsolutePathBuffer {
 107     fn root_mode(&self) -> &ty::item_path::RootMode {
 108         const ABSOLUTE: &ty::item_path::RootMode = &ty::item_path::RootMode::Absolute;
 109         ABSOLUTE
 110     }
 111
 112     fn push(&mut self, text: &str) {
 113         self.names.push(symbol::Symbol::intern(text).as_str());
 114     }
 115 }
 116
 117 /// Check if a `DefId`'s path matches the given absolute type path usage.
 118 ///
 119 /// # Examples
 120 /// ```rust,ignore
 121 /// match_def_path(cx.tcx, id, &["core", "option", "Option"])
 122 /// ```
 123 ///
 124 /// See also the `paths` module.
 125 pub fn match_def_path(tcx: TyCtxt<'_, '_, '_>, def_id: DefId, path: &[&str]) -> bool {
 126     let mut apb = AbsolutePathBuffer { names: vec![] };
 127
 128     tcx.push_item_path(&mut apb, def_id, false);
 129
 130     apb.names.len() == path.len() && apb.names.into_iter().zip(path.iter()).all(|(a, &b)| *a == *b)
 131 }
 132
 133 /// Get the absolute path of `def_id` as a vector of `&str`.
 134 ///
 135 /// # Examples
 136 /// ```rust,ignore
 137 /// let def_path = get_def_path(tcx, def_id);
 138 /// if let &["core", "option", "Option"] = &def_path[..] {
 139 ///     // The given `def_id` is that of an `Option` type
 140 /// };
 141 /// ```
 142 pub fn get_def_path(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Vec<&'static str> {
 143     let mut apb = AbsolutePathBuffer { names: vec![] };
 144     tcx.push_item_path(&mut apb, def_id, false);
 145     apb.names
 146         .iter()
 147         .map(syntax_pos::symbol::LocalInternedString::get)
 148         .collect()
 149 }
 150
 151 /// Check if type is struct, enum or union type with given def path.
 152 pub fn match_type(cx: &LateContext<'_, '_>, ty: Ty<'_>, path: &[&str]) -> bool {
 153     match ty.sty {
 154         ty::Adt(adt, _) => match_def_path(cx.tcx, adt.did, path),
 155         _ => false,
 156     }
 157 }
 158
 159 /// Check if the method call given in `expr` belongs to given trait.
 160 pub fn match_trait_method(cx: &LateContext<'_, '_>, expr: &Expr, path: &[&str]) -> bool {
 161     let method_call = cx.tables.type_dependent_defs()[expr.hir_id];
 162     let trt_id = cx.tcx.trait_of_item(method_call.def_id());
 163     if let Some(trt_id) = trt_id {
 164         match_def_path(cx.tcx, trt_id, path)
 165     } else {
 166         false
 167     }
 168 }
 169
 170 /// Check if an expression references a variable of the given name.
 171 pub fn match_var(expr: &Expr, var: Name) -> bool {
 172     if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.node {
 173         if path.segments.len() == 1 && path.segments[0].ident.name == var {
 174             return true;
 175         }
 176     }
 177     false
 178 }
 179
 180 pub fn last_path_segment(path: &QPath) -> &PathSegment {
 181     match *path {
 182         QPath::Resolved(_, ref path) => path.segments.last().expect("A path must have at least one segment"),
 183         QPath::TypeRelative(_, ref seg) => seg,
 184     }
 185 }
 186
 187 pub fn single_segment_path(path: &QPath) -> Option<&PathSegment> {
 188     match *path {
 189         QPath::Resolved(_, ref path) if path.segments.len() == 1 => Some(&path.segments[0]),
 190         QPath::Resolved(..) => None,
 191         QPath::TypeRelative(_, ref seg) => Some(seg),
 192     }
 193 }
 194
 195 /// Match a `Path` against a slice of segment string literals.
 196 ///
 197 /// # Examples
 198 /// ```rust,ignore
 199 /// match_qpath(path, &["std", "rt", "begin_unwind"])
 200 /// ```
 201 pub fn match_qpath(path: &QPath, segments: &[&str]) -> bool {
 202     match *path {
 203         QPath::Resolved(_, ref path) => match_path(path, segments),
 204         QPath::TypeRelative(ref ty, ref segment) => match ty.node {
 205             TyKind::Path(ref inner_path) => {
 206                 !segments.is_empty()
 207                     && match_qpath(inner_path, &segments[..(segments.len() - 1)])
 208                     && segment.ident.name == segments[segments.len() - 1]
 209             },
 210             _ => false,
 211         },
 212     }
 213 }
 214
 215 pub fn match_path(path: &Path, segments: &[&str]) -> bool {
 216     path.segments
 217         .iter()
 218         .rev()
 219         .zip(segments.iter().rev())
 220         .all(|(a, b)| a.ident.name == *b)
 221 }
 222
 223 /// Match a `Path` against a slice of segment string literals, e.g.
 224 ///
 225 /// # Examples
 226 /// ```rust,ignore
 227 /// match_qpath(path, &["std", "rt", "begin_unwind"])
 228 /// ```
 229 pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool {
 230     path.segments
 231         .iter()
 232         .rev()
 233         .zip(segments.iter().rev())
 234         .all(|(a, b)| a.ident.name == *b)
 235 }
 236
 237 /// Get the definition associated to a path.
 238 pub fn path_to_def(cx: &LateContext<'_, '_>, path: &[&str]) -> Option<def::Def> {
 239     let crates = cx.tcx.crates();
 240     let krate = crates.iter().find(|&&krate| cx.tcx.crate_name(krate) == path[0]);
 241     if let Some(krate) = krate {
 242         let krate = DefId {
 243             krate: *krate,
 244             index: CRATE_DEF_INDEX,
 245         };
 246         let mut items = cx.tcx.item_children(krate);
 247         let mut path_it = path.iter().skip(1).peekable();
 248
 249         loop {
 250             let segment = match path_it.next() {
 251                 Some(segment) => segment,
 252                 None => return None,
 253             };
 254
 255             for item in mem::replace(&mut items, Lrc::new(vec![])).iter() {
 256                 if item.ident.name == *segment {
 257                     if path_it.peek().is_none() {
 258                         return Some(item.def);
 259                     }
 260
 261                     items = cx.tcx.item_children(item.def.def_id());
 262                     break;
 263                 }
 264             }
 265         }
 266     } else {
 267         None
 268     }
 269 }
 270
 271 /// Convenience function to get the `DefId` of a trait by path.
 272 pub fn get_trait_def_id(cx: &LateContext<'_, '_>, path: &[&str]) -> Option<DefId> {
 273     let def = match path_to_def(cx, path) {
 274         Some(def) => def,
 275         None => return None,
 276     };
 277
 278     match def {
 279         def::Def::Trait(trait_id) => Some(trait_id),
 280         _ => None,
 281     }
 282 }
 283
 284 /// Check whether a type implements a trait.
 285 /// See also `get_trait_def_id`.
 286 pub fn implements_trait<'a, 'tcx>(
 287     cx: &LateContext<'a, 'tcx>,
 288     ty: Ty<'tcx>,
 289     trait_id: DefId,
 290     ty_params: &[Kind<'tcx>],
 291 ) -> bool {
 292     let ty = cx.tcx.erase_regions(&ty);
 293     let obligation = cx.tcx.predicate_for_trait_def(
 294         cx.param_env,
 295         traits::ObligationCause::dummy(),
 296         trait_id,
 297         0,
 298         ty,
 299         ty_params,
 300     );
 301     cx.tcx
 302         .infer_ctxt()
 303         .enter(|infcx| infcx.predicate_must_hold_modulo_regions(&obligation))
 304 }
 305
 306 /// Check whether this type implements Drop.
 307 pub fn has_drop<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
 308     match ty.ty_adt_def() {
 309         Some(def) => def.has_dtor(cx.tcx),
 310         _ => false,
 311     }
 312 }
 313
 314 /// Resolve the definition of a node from its `HirId`.
 315 pub fn resolve_node(cx: &LateContext<'_, '_>, qpath: &QPath, id: HirId) -> def::Def {
 316     cx.tables.qpath_def(qpath, id)
 317 }
 318
 319 /// Return the method names and argument list of nested method call expressions that make up
 320 /// `expr`.
 321 pub fn method_calls<'a>(expr: &'a Expr, max_depth: usize) -> (Vec<Symbol>, Vec<&'a [Expr]>) {
 322     let mut method_names = Vec::with_capacity(max_depth);
 323     let mut arg_lists = Vec::with_capacity(max_depth);
 324
 325     let mut current = expr;
 326     for _ in 0..max_depth {
 327         if let ExprKind::MethodCall(path, _, args) = &current.node {
 328             if args.iter().any(|e| in_macro(e.span)) {
 329                 break;
 330             }
 331             method_names.push(path.ident.name);
 332             arg_lists.push(&**args);
 333             current = &args[0];
 334         } else {
 335             break;
 336         }
 337     }
 338
 339     (method_names, arg_lists)
 340 }
 341
 342 /// Match an `Expr` against a chain of methods, and return the matched `Expr`s.
 343 ///
 344 /// For example, if `expr` represents the `.baz()` in `foo.bar().baz()`,
 345 /// `matched_method_chain(expr, &["bar", "baz"])` will return a `Vec`
 346 /// containing the `Expr`s for
 347 /// `.bar()` and `.baz()`
 348 pub fn method_chain_args<'a>(expr: &'a Expr, methods: &[&str]) -> Option<Vec<&'a [Expr]>> {
 349     let mut current = expr;
 350     let mut matched = Vec::with_capacity(methods.len());
 351     for method_name in methods.iter().rev() {
 352         // method chains are stored last -> first
 353         if let ExprKind::MethodCall(ref path, _, ref args) = current.node {
 354             if path.ident.name == *method_name {
 355                 if args.iter().any(|e| in_macro(e.span)) {
 356                     return None;
 357                 }
 358                 matched.push(&**args); // build up `matched` backwards
 359                 current = &args[0] // go to parent expression
 360             } else {
 361                 return None;
 362             }
 363         } else {
 364             return None;
 365         }
 366     }
 367     matched.reverse(); // reverse `matched`, so that it is in the same order as `methods`
 368     Some(matched)
 369 }
 370
 371 /// Returns true if the provided `def_id` is an entrypoint to a program
 372 pub fn is_entrypoint_fn(cx: &LateContext<'_, '_>, def_id: DefId) -> bool {
 373     if let Some((entry_fn_def_id, _)) = cx.tcx.entry_fn(LOCAL_CRATE) {
 374         return def_id == entry_fn_def_id;
 375     }
 376     false
 377 }
 378
 379 /// Get the name of the item the expression is in, if available.
 380 pub fn get_item_name(cx: &LateContext<'_, '_>, expr: &Expr) -> Option<Name> {
 381     let parent_id = cx.tcx.hir().get_parent(expr.id);
 382     match cx.tcx.hir().find(parent_id) {
 383         Some(Node::Item(&Item { ref ident, .. })) => Some(ident.name),
 384         Some(Node::TraitItem(&TraitItem { ident, .. })) | Some(Node::ImplItem(&ImplItem { ident, .. })) => {
 385             Some(ident.name)
 386         },
 387         _ => None,
 388     }
 389 }
 390
 391 /// Get the name of a `Pat`, if any
 392 pub fn get_pat_name(pat: &Pat) -> Option<Name> {
 393     match pat.node {
 394         PatKind::Binding(.., ref spname, _) => Some(spname.name),
 395         PatKind::Path(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name),
 396         PatKind::Box(ref p) | PatKind::Ref(ref p, _) => get_pat_name(&*p),
 397         _ => None,
 398     }
 399 }
 400
 401 struct ContainsName {
 402     name: Name,
 403     result: bool,
 404 }
 405
 406 impl<'tcx> Visitor<'tcx> for ContainsName {
 407     fn visit_name(&mut self, _: Span, name: Name) {
 408         if self.name == name {
 409             self.result = true;
 410         }
 411     }
 412     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
 413         NestedVisitorMap::None
 414     }
 415 }
 416
 417 /// check if an `Expr` contains a certain name
 418 pub fn contains_name(name: Name, expr: &Expr) -> bool {
 419     let mut cn = ContainsName { name, result: false };
 420     cn.visit_expr(expr);
 421     cn.result
 422 }
 423
 424 /// Convert a span to a code snippet if available, otherwise use default.
 425 ///
 426 /// This is useful if you want to provide suggestions for your lint or more generally, if you want
 427 /// to convert a given `Span` to a `str`.
 428 ///
 429 /// # Example
 430 /// ```rust,ignore
 431 /// snippet(cx, expr.span, "..")
 432 /// ```
 433 pub fn snippet<'a, 'b, T: LintContext<'b>>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
 434     snippet_opt(cx, span).map_or_else(|| Cow::Borrowed(default), From::from)
 435 }
 436
 437 /// Same as `snippet`, but it adapts the applicability level by following rules:
 438 ///
 439 /// - Applicability level `Unspecified` will never be changed.
 440 /// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
 441 /// - If the default value is used and the applicability level is `MachineApplicable`, change it to
 442 /// `HasPlaceholders`
 443 pub fn snippet_with_applicability<'a, 'b, T: LintContext<'b>>(
 444     cx: &T,
 445     span: Span,
 446     default: &'a str,
 447     applicability: &mut Applicability,
 448 ) -> Cow<'a, str> {
 449     if *applicability != Applicability::Unspecified && in_macro(span) {
 450         *applicability = Applicability::MaybeIncorrect;
 451     }
 452     snippet_opt(cx, span).map_or_else(
 453         || {
 454             if *applicability == Applicability::MachineApplicable {
 455                 *applicability = Applicability::HasPlaceholders;
 456             }
 457             Cow::Borrowed(default)
 458         },
 459         From::from,
 460     )
 461 }
 462
 463 /// Same as `snippet`, but should only be used when it's clear that the input span is
 464 /// not a macro argument.
 465 pub fn snippet_with_macro_callsite<'a, 'b, T: LintContext<'b>>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
 466     snippet(cx, span.source_callsite(), default)
 467 }
 468
 469 /// Convert a span to a code snippet. Returns `None` if not available.
 470 pub fn snippet_opt<'a, T: LintContext<'a>>(cx: &T, span: Span) -> Option<String> {
 471     cx.sess().source_map().span_to_snippet(span).ok()
 472 }
 473
 474 /// Convert a span (from a block) to a code snippet if available, otherwise use
 475 /// default.
 476 /// This trims the code of indentation, except for the first line. Use it for
 477 /// blocks or block-like
 478 /// things which need to be printed as such.
 479 ///
 480 /// # Example
 481 /// ```rust,ignore
 482 /// snippet_block(cx, expr.span, "..")
 483 /// ```
 484 pub fn snippet_block<'a, 'b, T: LintContext<'b>>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
 485     let snip = snippet(cx, span, default);
 486     trim_multiline(snip, true)
 487 }
 488
 489 /// Same as `snippet_block`, but adapts the applicability level by the rules of
 490 /// `snippet_with_applicabiliy`.
 491 pub fn snippet_block_with_applicability<'a, 'b, T: LintContext<'b>>(
 492     cx: &T,
 493     span: Span,
 494     default: &'a str,
 495     applicability: &mut Applicability,
 496 ) -> Cow<'a, str> {
 497     let snip = snippet_with_applicability(cx, span, default, applicability);
 498     trim_multiline(snip, true)
 499 }
 500
 501 /// Returns a new Span that covers the full last line of the given Span
 502 pub fn last_line_of_span<'a, T: LintContext<'a>>(cx: &T, span: Span) -> Span {
 503     let source_map_and_line = cx.sess().source_map().lookup_line(span.lo()).unwrap();
 504     let line_no = source_map_and_line.line;
 505     let line_start = &source_map_and_line.sf.lines[line_no];
 506     Span::new(*line_start, span.hi(), span.ctxt())
 507 }
 508
 509 /// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
 510 /// Also takes an `Option<String>` which can be put inside the braces.
 511 pub fn expr_block<'a, 'b, T: LintContext<'b>>(
 512     cx: &T,
 513     expr: &Expr,
 514     option: Option<String>,
 515     default: &'a str,
 516 ) -> Cow<'a, str> {
 517     let code = snippet_block(cx, expr.span, default);
 518     let string = option.unwrap_or_default();
 519     if in_macro(expr.span) {
 520         Cow::Owned(format!("{{ {} }}", snippet_with_macro_callsite(cx, expr.span, default)))
 521     } else if let ExprKind::Block(_, _) = expr.node {
 522         Cow::Owned(format!("{}{}", code, string))
 523     } else if string.is_empty() {
 524         Cow::Owned(format!("{{ {} }}", code))
 525     } else {
 526         Cow::Owned(format!("{{\n{};\n{}\n}}", code, string))
 527     }
 528 }
 529
 530 /// Trim indentation from a multiline string with possibility of ignoring the
 531 /// first line.
 532 pub fn trim_multiline(s: Cow<'_, str>, ignore_first: bool) -> Cow<'_, str> {
 533     let s_space = trim_multiline_inner(s, ignore_first, ' ');
 534     let s_tab = trim_multiline_inner(s_space, ignore_first, '\t');
 535     trim_multiline_inner(s_tab, ignore_first, ' ')
 536 }
 537
 538 fn trim_multiline_inner(s: Cow<'_, str>, ignore_first: bool, ch: char) -> Cow<'_, str> {
 539     let x = s
 540         .lines()
 541         .skip(ignore_first as usize)
 542         .filter_map(|l| {
 543             if l.is_empty() {
 544                 None
 545             } else {
 546                 // ignore empty lines
 547                 Some(l.char_indices().find(|&(_, x)| x != ch).unwrap_or((l.len(), ch)).0)
 548             }
 549         })
 550         .min()
 551         .unwrap_or(0);
 552     if x > 0 {
 553         Cow::Owned(
 554             s.lines()
 555                 .enumerate()
 556                 .map(|(i, l)| {
 557                     if (ignore_first && i == 0) || l.is_empty() {
 558                         l
 559                     } else {
 560                         l.split_at(x).1
 561                     }
 562                 })
 563                 .collect::<Vec<_>>()
 564                 .join("\n"),
 565         )
 566     } else {
 567         s
 568     }
 569 }
 570
 571 /// Get a parent expressions if any – this is useful to constrain a lint.
 572 pub fn get_parent_expr<'c>(cx: &'c LateContext<'_, '_>, e: &Expr) -> Option<&'c Expr> {
 573     let map = &cx.tcx.hir();
 574     let node_id: NodeId = e.id;
 575     let parent_id: NodeId = map.get_parent_node(node_id);
 576     if node_id == parent_id {
 577         return None;
 578     }
 579     map.find(parent_id).and_then(|node| {
 580         if let Node::Expr(parent) = node {
 581             Some(parent)
 582         } else {
 583             None
 584         }
 585     })
 586 }
 587
 588 pub fn get_enclosing_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, node: NodeId) -> Option<&'tcx Block> {
 589     let map = &cx.tcx.hir();
 590     let enclosing_node = map
 591         .get_enclosing_scope(node)
 592         .and_then(|enclosing_id| map.find(enclosing_id));
 593     if let Some(node) = enclosing_node {
 594         match node {
 595             Node::Block(block) => Some(block),
 596             Node::Item(&Item {
 597                 node: ItemKind::Fn(_, _, _, eid),
 598                 ..
 599             })
 600             | Node::ImplItem(&ImplItem {
 601                 node: ImplItemKind::Method(_, eid),
 602                 ..
 603             }) => match cx.tcx.hir().body(eid).value.node {
 604                 ExprKind::Block(ref block, _) => Some(block),
 605                 _ => None,
 606             },
 607             _ => None,
 608         }
 609     } else {
 610         None
 611     }
 612 }
 613
 614 /// Return the base type for HIR references and pointers.
 615 pub fn walk_ptrs_hir_ty(ty: &hir::Ty) -> &hir::Ty {
 616     match ty.node {
 617         TyKind::Ptr(ref mut_ty) | TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(&mut_ty.ty),
 618         _ => ty,
 619     }
 620 }
 621
 622 /// Return the base type for references and raw pointers.
 623 pub fn walk_ptrs_ty(ty: Ty<'_>) -> Ty<'_> {
 624     match ty.sty {
 625         ty::Ref(_, ty, _) => walk_ptrs_ty(ty),
 626         _ => ty,
 627     }
 628 }
 629
 630 /// Return the base type for references and raw pointers, and count reference
 631 /// depth.
 632 pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
 633     fn inner(ty: Ty<'_>, depth: usize) -> (Ty<'_>, usize) {
 634         match ty.sty {
 635             ty::Ref(_, ty, _) => inner(ty, depth + 1),
 636             _ => (ty, depth),
 637         }
 638     }
 639     inner(ty, 0)
 640 }
 641
 642 /// Check whether the given expression is a constant literal of the given value.
 643 pub fn is_integer_literal(expr: &Expr, value: u128) -> bool {
 644     // FIXME: use constant folding
 645     if let ExprKind::Lit(ref spanned) = expr.node {
 646         if let LitKind::Int(v, _) = spanned.node {
 647             return v == value;
 648         }
 649     }
 650     false
 651 }
 652
 653 /// Returns `true` if the given `Expr` has been coerced before.
 654 ///
 655 /// Examples of coercions can be found in the Nomicon at
 656 /// <https://doc.rust-lang.org/nomicon/coercions.html>.
 657 ///
 658 /// See `rustc::ty::adjustment::Adjustment` and `rustc_typeck::check::coercion` for more
 659 /// information on adjustments and coercions.
 660 pub fn is_adjusted(cx: &LateContext<'_, '_>, e: &Expr) -> bool {
 661     cx.tables.adjustments().get(e.hir_id).is_some()
 662 }
 663
 664 pub struct LimitStack {
 665     stack: Vec<u64>,
 666 }
 667
 668 impl Drop for LimitStack {
 669     fn drop(&mut self) {
 670         assert_eq!(self.stack.len(), 1);
 671     }
 672 }
 673
 674 impl LimitStack {
 675     pub fn new(limit: u64) -> Self {
 676         Self { stack: vec![limit] }
 677     }
 678     pub fn limit(&self) -> u64 {
 679         *self.stack.last().expect("there should always be a value in the stack")
 680     }
 681     pub fn push_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
 682         let stack = &mut self.stack;
 683         parse_attrs(sess, attrs, name, |val| stack.push(val));
 684     }
 685     pub fn pop_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
 686         let stack = &mut self.stack;
 687         parse_attrs(sess, attrs, name, |val| assert_eq!(stack.pop(), Some(val)));
 688     }
 689 }
 690
 691 pub fn get_attr<'a>(attrs: &'a [ast::Attribute], name: &'static str) -> impl Iterator<Item = &'a ast::Attribute> {
 692     attrs.iter().filter(move |attr| {
 693         attr.path.segments.len() == 2
 694             && attr.path.segments[0].ident.to_string() == "clippy"
 695             && attr.path.segments[1].ident.to_string() == name
 696     })
 697 }
 698
 699 fn parse_attrs<F: FnMut(u64)>(sess: &Session, attrs: &[ast::Attribute], name: &'static str, mut f: F) {
 700     for attr in get_attr(attrs, name) {
 701         if let Some(ref value) = attr.value_str() {
 702             if let Ok(value) = FromStr::from_str(&value.as_str()) {
 703                 f(value)
 704             } else {
 705                 sess.span_err(attr.span, "not a number");
 706             }
 707         } else {
 708             sess.span_err(attr.span, "bad clippy attribute");
 709         }
 710     }
 711 }
 712
 713 /// Return the pre-expansion span if is this comes from an expansion of the
 714 /// macro `name`.
 715 /// See also `is_direct_expn_of`.
 716 pub fn is_expn_of(mut span: Span, name: &str) -> Option<Span> {
 717     loop {
 718         let span_name_span = span
 719             .ctxt()
 720             .outer()
 721             .expn_info()
 722             .map(|ei| (ei.format.name(), ei.call_site));
 723
 724         match span_name_span {
 725             Some((mac_name, new_span)) if mac_name == name => return Some(new_span),
 726             None => return None,
 727             Some((_, new_span)) => span = new_span,
 728         }
 729     }
 730 }
 731
 732 /// Return the pre-expansion span if is this directly comes from an expansion
 733 /// of the macro `name`.
 734 /// The difference with `is_expn_of` is that in
 735 /// ```rust,ignore
 736 /// foo!(bar!(42));
 737 /// ```
 738 /// `42` is considered expanded from `foo!` and `bar!` by `is_expn_of` but only
 739 /// `bar!` by
 740 /// `is_direct_expn_of`.
 741 pub fn is_direct_expn_of(span: Span, name: &str) -> Option<Span> {
 742     let span_name_span = span
 743         .ctxt()
 744         .outer()
 745         .expn_info()
 746         .map(|ei| (ei.format.name(), ei.call_site));
 747
 748     match span_name_span {
 749         Some((mac_name, new_span)) if mac_name == name => Some(new_span),
 750         _ => None,
 751     }
 752 }
 753
 754 /// Convenience function to get the return type of a function
 755 pub fn return_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, fn_item: NodeId) -> Ty<'tcx> {
 756     let fn_def_id = cx.tcx.hir().local_def_id(fn_item);
 757     let ret_ty = cx.tcx.fn_sig(fn_def_id).output();
 758     cx.tcx.erase_late_bound_regions(&ret_ty)
 759 }
 760
 761 /// Check if two types are the same.
 762 ///
 763 /// This discards any lifetime annotations, too.
 764 // FIXME: this works correctly for lifetimes bounds (`for <'a> Foo<'a>` == `for
 765 // <'b> Foo<'b>` but
 766 // not for type parameters.
 767 pub fn same_tys<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
 768     let a = cx.tcx.erase_late_bound_regions(&Binder::bind(a));
 769     let b = cx.tcx.erase_late_bound_regions(&Binder::bind(b));
 770     cx.tcx
 771         .infer_ctxt()
 772         .enter(|infcx| infcx.can_eq(cx.param_env, a, b).is_ok())
 773 }
 774
 775 /// Return whether the given type is an `unsafe` function.
 776 pub fn type_is_unsafe_function<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
 777     match ty.sty {
 778         ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).unsafety() == Unsafety::Unsafe,
 779         _ => false,
 780     }
 781 }
 782
 783 pub fn is_copy<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
 784     ty.is_copy_modulo_regions(cx.tcx.global_tcx(), cx.param_env, DUMMY_SP)
 785 }
 786
 787 /// Return whether a pattern is refutable.
 788 pub fn is_refutable(cx: &LateContext<'_, '_>, pat: &Pat) -> bool {
 789     fn is_enum_variant(cx: &LateContext<'_, '_>, qpath: &QPath, id: HirId) -> bool {
 790         matches!(
 791             cx.tables.qpath_def(qpath, id),
 792             def::Def::Variant(..) | def::Def::VariantCtor(..)
 793         )
 794     }
 795
 796     fn are_refutable<'a, I: Iterator<Item = &'a Pat>>(cx: &LateContext<'_, '_>, mut i: I) -> bool {
 797         i.any(|pat| is_refutable(cx, pat))
 798     }
 799
 800     match pat.node {
 801         PatKind::Binding(..) | PatKind::Wild => false,
 802         PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => is_refutable(cx, pat),
 803         PatKind::Lit(..) | PatKind::Range(..) => true,
 804         PatKind::Path(ref qpath) => is_enum_variant(cx, qpath, pat.hir_id),
 805         PatKind::Tuple(ref pats, _) => are_refutable(cx, pats.iter().map(|pat| &**pat)),
 806         PatKind::Struct(ref qpath, ref fields, _) => {
 807             if is_enum_variant(cx, qpath, pat.hir_id) {
 808                 true
 809             } else {
 810                 are_refutable(cx, fields.iter().map(|field| &*field.node.pat))
 811             }
 812         },
 813         PatKind::TupleStruct(ref qpath, ref pats, _) => {
 814             if is_enum_variant(cx, qpath, pat.hir_id) {
 815                 true
 816             } else {
 817                 are_refutable(cx, pats.iter().map(|pat| &**pat))
 818             }
 819         },
 820         PatKind::Slice(ref head, ref middle, ref tail) => {
 821             are_refutable(cx, head.iter().chain(middle).chain(tail.iter()).map(|pat| &**pat))
 822         },
 823     }
 824 }
 825
 826 /// Checks for the `#[automatically_derived]` attribute all `#[derive]`d
 827 /// implementations have.
 828 pub fn is_automatically_derived(attrs: &[ast::Attribute]) -> bool {
 829     attr::contains_name(attrs, "automatically_derived")
 830 }
 831
 832 /// Remove blocks around an expression.
 833 ///
 834 /// Ie. `x`, `{ x }` and `{{{{ x }}}}` all give `x`. `{ x; y }` and `{}` return
 835 /// themselves.
 836 pub fn remove_blocks(expr: &Expr) -> &Expr {
 837     if let ExprKind::Block(ref block, _) = expr.node {
 838         if block.stmts.is_empty() {
 839             if let Some(ref expr) = block.expr {
 840                 remove_blocks(expr)
 841             } else {
 842                 expr
 843             }
 844         } else {
 845             expr
 846         }
 847     } else {
 848         expr
 849     }
 850 }
 851
 852 pub fn opt_def_id(def: Def) -> Option<DefId> {
 853     def.opt_def_id()
 854 }
 855
 856 pub fn is_self(slf: &Arg) -> bool {
 857     if let PatKind::Binding(.., name, _) = slf.pat.node {
 858         name.name == keywords::SelfLower.name()
 859     } else {
 860         false
 861     }
 862 }
 863
 864 pub fn is_self_ty(slf: &hir::Ty) -> bool {
 865     if_chain! {
 866         if let TyKind::Path(ref qp) = slf.node;
 867         if let QPath::Resolved(None, ref path) = *qp;
 868         if let Def::SelfTy(..) = path.def;
 869         then {
 870             return true
 871         }
 872     }
 873     false
 874 }
 875
 876 pub fn iter_input_pats<'tcx>(decl: &FnDecl, body: &'tcx Body) -> impl Iterator<Item = &'tcx Arg> {
 877     (0..decl.inputs.len()).map(move |i| &body.arguments[i])
 878 }
 879
 880 /// Check if a given expression is a match expression
 881 /// expanded from `?` operator or `try` macro.
 882 pub fn is_try(expr: &Expr) -> Option<&Expr> {
 883     fn is_ok(arm: &Arm) -> bool {
 884         if_chain! {
 885             if let PatKind::TupleStruct(ref path, ref pat, None) = arm.pats[0].node;
 886             if match_qpath(path, &paths::RESULT_OK[1..]);
 887             if let PatKind::Binding(_, defid, _, _, None) = pat[0].node;
 888             if let ExprKind::Path(QPath::Resolved(None, ref path)) = arm.body.node;
 889             if let Def::Local(lid) = path.def;
 890             if lid == defid;
 891             then {
 892                 return true;
 893             }
 894         }
 895         false
 896     }
 897
 898     fn is_err(arm: &Arm) -> bool {
 899         if let PatKind::TupleStruct(ref path, _, _) = arm.pats[0].node {
 900             match_qpath(path, &paths::RESULT_ERR[1..])
 901         } else {
 902             false
 903         }
 904     }
 905
 906     if let ExprKind::Match(_, ref arms, ref source) = expr.node {
 907         // desugared from a `?` operator
 908         if let MatchSource::TryDesugar = *source {
 909             return Some(expr);
 910         }
 911
 912         if_chain! {
 913             if arms.len() == 2;
 914             if arms[0].pats.len() == 1 && arms[0].guard.is_none();
 915             if arms[1].pats.len() == 1 && arms[1].guard.is_none();
 916             if (is_ok(&arms[0]) && is_err(&arms[1])) ||
 917                 (is_ok(&arms[1]) && is_err(&arms[0]));
 918             then {
 919                 return Some(expr);
 920             }
 921         }
 922     }
 923
 924     None
 925 }
 926
 927 /// Returns true if the lint is allowed in the current context
 928 ///
 929 /// Useful for skipping long running code when it's unnecessary
 930 pub fn is_allowed(cx: &LateContext<'_, '_>, lint: &'static Lint, id: NodeId) -> bool {
 931     cx.tcx.lint_level_at_node(lint, id).0 == Level::Allow
 932 }
 933
 934 pub fn get_arg_name(pat: &Pat) -> Option<ast::Name> {
 935     match pat.node {
 936         PatKind::Binding(.., ident, None) => Some(ident.name),
 937         PatKind::Ref(ref subpat, _) => get_arg_name(subpat),
 938         _ => None,
 939     }
 940 }
 941
 942 pub fn int_bits(tcx: TyCtxt<'_, '_, '_>, ity: ast::IntTy) -> u64 {
 943     layout::Integer::from_attr(&tcx, attr::IntType::SignedInt(ity))
 944         .size()
 945         .bits()
 946 }
 947
 948 #[allow(clippy::cast_possible_wrap)]
 949 /// Turn a constant int byte representation into an i128
 950 pub fn sext(tcx: TyCtxt<'_, '_, '_>, u: u128, ity: ast::IntTy) -> i128 {
 951     let amt = 128 - int_bits(tcx, ity);
 952     ((u as i128) << amt) >> amt
 953 }
 954
 955 #[allow(clippy::cast_sign_loss)]
 956 /// clip unused bytes
 957 pub fn unsext(tcx: TyCtxt<'_, '_, '_>, u: i128, ity: ast::IntTy) -> u128 {
 958     let amt = 128 - int_bits(tcx, ity);
 959     ((u as u128) << amt) >> amt
 960 }
 961
 962 /// clip unused bytes
 963 pub fn clip(tcx: TyCtxt<'_, '_, '_>, u: u128, ity: ast::UintTy) -> u128 {
 964     let bits = layout::Integer::from_attr(&tcx, attr::IntType::UnsignedInt(ity))
 965         .size()
 966         .bits();
 967     let amt = 128 - bits;
 968     (u << amt) >> amt
 969 }
 970
 971 /// Remove block comments from the given Vec of lines
 972 ///
 973 /// # Examples
 974 ///
 975 /// ```rust,ignore
 976 /// without_block_comments(vec!["/*", "foo", "*/"]);
 977 /// // => vec![]
 978 ///
 979 /// without_block_comments(vec!["bar", "/*", "foo", "*/"]);
 980 /// // => vec!["bar"]
 981 /// ```
 982 pub fn without_block_comments(lines: Vec<&str>) -> Vec<&str> {
 983     let mut without = vec![];
 984
 985     let mut nest_level = 0;
 986
 987     for line in lines {
 988         if line.contains("/*") {
 989             nest_level += 1;
 990             continue;
 991         } else if line.contains("*/") {
 992             nest_level -= 1;
 993             continue;
 994         }
 995
 996         if nest_level == 0 {
 997             without.push(line);
 998         }
 999     }
1000
1001     without
1002 }
1003
1004 pub fn any_parent_is_automatically_derived(tcx: TyCtxt<'_, '_, '_>, node: NodeId) -> bool {
1005     let map = &tcx.hir();
1006     let mut prev_enclosing_node = None;
1007     let mut enclosing_node = node;
1008     while Some(enclosing_node) != prev_enclosing_node {
1009         if is_automatically_derived(map.attrs(enclosing_node)) {
1010             return true;
1011         }
1012         prev_enclosing_node = Some(enclosing_node);
1013         enclosing_node = map.get_parent(enclosing_node);
1014     }
1015     false
1016 }
1017
1018 /// Returns true if ty has `iter` or `iter_mut` methods
1019 pub fn has_iter_method(cx: &LateContext<'_, '_>, probably_ref_ty: ty::Ty<'_>) -> Option<&'static str> {
1020     // FIXME: instead of this hard-coded list, we should check if `<adt>::iter`
1021     // exists and has the desired signature. Unfortunately FnCtxt is not exported
1022     // so we can't use its `lookup_method` method.
1023     static INTO_ITER_COLLECTIONS: [&[&str]; 13] = [
1024         &paths::VEC,
1025         &paths::OPTION,
1026         &paths::RESULT,
1027         &paths::BTREESET,
1028         &paths::BTREEMAP,
1029         &paths::VEC_DEQUE,
1030         &paths::LINKED_LIST,
1031         &paths::BINARY_HEAP,
1032         &paths::HASHSET,
1033         &paths::HASHMAP,
1034         &paths::PATH_BUF,
1035         &paths::PATH,
1036         &paths::RECEIVER,
1037     ];
1038
1039     let ty_to_check = match probably_ref_ty.sty {
1040         ty::Ref(_, ty_to_check, _) => ty_to_check,
1041         _ => probably_ref_ty,
1042     };
1043
1044     let def_id = match ty_to_check.sty {
1045         ty::Array(..) => return Some("array"),
1046         ty::Slice(..) => return Some("slice"),
1047         ty::Adt(adt, _) => adt.did,
1048         _ => return None,
1049     };
1050
1051     for path in &INTO_ITER_COLLECTIONS {
1052         if match_def_path(cx.tcx, def_id, path) {
1053             return Some(path.last().unwrap());
1054         }
1055     }
1056     None
1057 }
1058
1059 #[cfg(test)]
1060 mod test {
1061     use super::{trim_multiline, without_block_comments};
1062
1063     #[test]
1064     fn test_trim_multiline_single_line() {
1065         assert_eq!("", trim_multiline("".into(), false));
1066         assert_eq!("...", trim_multiline("...".into(), false));
1067         assert_eq!("...", trim_multiline("    ...".into(), false));
1068         assert_eq!("...", trim_multiline("\t...".into(), false));
1069         assert_eq!("...", trim_multiline("\t\t...".into(), false));
1070     }
1071
1072     #[test]
1073     #[rustfmt::skip]
1074     fn test_trim_multiline_block() {
1075         assert_eq!("\
1076     if x {
1077         y
1078     } else {
1079         z
1080     }", trim_multiline("    if x {
1081             y
1082         } else {
1083             z
1084         }".into(), false));
1085         assert_eq!("\
1086     if x {
1087     \ty
1088     } else {
1089     \tz
1090     }", trim_multiline("    if x {
1091         \ty
1092         } else {
1093         \tz
1094         }".into(), false));
1095     }
1096
1097     #[test]
1098     #[rustfmt::skip]
1099     fn test_trim_multiline_empty_line() {
1100         assert_eq!("\
1101     if x {
1102         y
1103
1104     } else {
1105         z
1106     }", trim_multiline("    if x {
1107             y
1108
1109         } else {
1110             z
1111         }".into(), false));
1112     }
1113
1114     #[test]
1115     fn test_without_block_comments_lines_without_block_comments() {
1116         let result = without_block_comments(vec!["/*", "", "*/"]);
1117         println!("result: {:?}", result);
1118         assert!(result.is_empty());
1119
1120         let result = without_block_comments(vec!["", "/*", "", "*/", "#[crate_type = \"lib\"]", "/*", "", "*/", ""]);
1121         assert_eq!(result, vec!["", "#[crate_type = \"lib\"]", ""]);
1122
1123         let result = without_block_comments(vec!["/* rust", "", "*/"]);
1124         assert!(result.is_empty());
1125
1126         let result = without_block_comments(vec!["/* one-line comment */"]);
1127         assert!(result.is_empty());
1128
1129         let result = without_block_comments(vec!["/* nested", "/* multi-line", "comment", "*/", "test", "*/"]);
1130         assert!(result.is_empty());
1131
1132         let result = without_block_comments(vec!["/* nested /* inline /* comment */ test */ */"]);
1133         assert!(result.is_empty());
1134
1135         let result = without_block_comments(vec!["foo", "bar", "baz"]);
1136         assert_eq!(result, vec!["foo", "bar", "baz"]);
1137     }
1138 }