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