compiler/rustc_lint/src/unused.rs

   1 use crate::Lint;
   2 use crate::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
   3 use rustc_ast as ast;
   4 use rustc_ast::util::parser;
   5 use rustc_ast::{ExprKind, StmtKind};
   6 use rustc_ast_pretty::pprust;
   7 use rustc_data_structures::fx::FxHashMap;
   8 use rustc_errors::{pluralize, Applicability};
   9 use rustc_feature::{AttributeType, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP};
  10 use rustc_hir as hir;
  11 use rustc_hir::def::{DefKind, Res};
  12 use rustc_hir::def_id::DefId;
  13 use rustc_middle::ty::adjustment;
  14 use rustc_middle::ty::{self, Ty};
  15 use rustc_session::lint::builtin::UNUSED_ATTRIBUTES;
  16 use rustc_span::symbol::Symbol;
  17 use rustc_span::symbol::{kw, sym};
  18 use rustc_span::{BytePos, Span, DUMMY_SP};
  19
  20 use tracing::debug;
  21
  22 declare_lint! {
  23     /// The `unused_must_use` lint detects unused result of a type flagged as
  24     /// `#[must_use]`.
  25     ///
  26     /// ### Example
  27     ///
  28     /// ```rust
  29     /// fn returns_result() -> Result<(), ()> {
  30     ///     Ok(())
  31     /// }
  32     ///
  33     /// fn main() {
  34     ///     returns_result();
  35     /// }
  36     /// ```
  37     ///
  38     /// {{produces}}
  39     ///
  40     /// ### Explanation
  41     ///
  42     /// The `#[must_use]` attribute is an indicator that it is a mistake to
  43     /// ignore the value. See [the reference] for more details.
  44     ///
  45     /// [the reference]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
  46     pub UNUSED_MUST_USE,
  47     Warn,
  48     "unused result of a type flagged as `#[must_use]`",
  49     report_in_external_macro
  50 }
  51
  52 declare_lint! {
  53     /// The `unused_results` lint checks for the unused result of an
  54     /// expression in a statement.
  55     ///
  56     /// ### Example
  57     ///
  58     /// ```rust,compile_fail
  59     /// #![deny(unused_results)]
  60     /// fn foo<T>() -> T { panic!() }
  61     ///
  62     /// fn main() {
  63     ///     foo::<usize>();
  64     /// }
  65     /// ```
  66     ///
  67     /// {{produces}}
  68     ///
  69     /// ### Explanation
  70     ///
  71     /// Ignoring the return value of a function may indicate a mistake. In
  72     /// cases were it is almost certain that the result should be used, it is
  73     /// recommended to annotate the function with the [`must_use` attribute].
  74     /// Failure to use such a return value will trigger the [`unused_must_use`
  75     /// lint] which is warn-by-default. The `unused_results` lint is
  76     /// essentially the same, but triggers for *all* return values.
  77     ///
  78     /// This lint is "allow" by default because it can be noisy, and may not be
  79     /// an actual problem. For example, calling the `remove` method of a `Vec`
  80     /// or `HashMap` returns the previous value, which you may not care about.
  81     /// Using this lint would require explicitly ignoring or discarding such
  82     /// values.
  83     ///
  84     /// [`must_use` attribute]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
  85     /// [`unused_must_use` lint]: warn-by-default.html#unused-must-use
  86     pub UNUSED_RESULTS,
  87     Allow,
  88     "unused result of an expression in a statement"
  89 }
  90
  91 declare_lint_pass!(UnusedResults => [UNUSED_MUST_USE, UNUSED_RESULTS]);
  92
  93 impl<'tcx> LateLintPass<'tcx> for UnusedResults {
  94     fn check_stmt(&mut self, cx: &LateContext<'_>, s: &hir::Stmt<'_>) {
  95         let expr = match s.kind {
  96             hir::StmtKind::Semi(ref expr) => &**expr,
  97             _ => return,
  98         };
  99
 100         if let hir::ExprKind::Ret(..) = expr.kind {
 101             return;
 102         }
 103
 104         let ty = cx.typeck_results().expr_ty(&expr);
 105         let type_permits_lack_of_use = check_must_use_ty(cx, ty, &expr, s.span, "", "", 1);
 106
 107         let mut fn_warned = false;
 108         let mut op_warned = false;
 109         let maybe_def_id = match expr.kind {
 110             hir::ExprKind::Call(ref callee, _) => {
 111                 match callee.kind {
 112                     hir::ExprKind::Path(ref qpath) => {
 113                         match cx.qpath_res(qpath, callee.hir_id) {
 114                             Res::Def(DefKind::Fn | DefKind::AssocFn, def_id) => Some(def_id),
 115                             // `Res::Local` if it was a closure, for which we
 116                             // do not currently support must-use linting
 117                             _ => None,
 118                         }
 119                     }
 120                     _ => None,
 121                 }
 122             }
 123             hir::ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
 124             _ => None,
 125         };
 126         if let Some(def_id) = maybe_def_id {
 127             fn_warned = check_must_use_def(cx, def_id, s.span, "return value of ", "");
 128         } else if type_permits_lack_of_use {
 129             // We don't warn about unused unit or uninhabited types.
 130             // (See https://github.com/rust-lang/rust/issues/43806 for details.)
 131             return;
 132         }
 133
 134         let must_use_op = match expr.kind {
 135             // Hardcoding operators here seemed more expedient than the
 136             // refactoring that would be needed to look up the `#[must_use]`
 137             // attribute which does exist on the comparison trait methods
 138             hir::ExprKind::Binary(bin_op, ..) => match bin_op.node {
 139                 hir::BinOpKind::Eq
 140                 | hir::BinOpKind::Lt
 141                 | hir::BinOpKind::Le
 142                 | hir::BinOpKind::Ne
 143                 | hir::BinOpKind::Ge
 144                 | hir::BinOpKind::Gt => Some("comparison"),
 145                 hir::BinOpKind::Add
 146                 | hir::BinOpKind::Sub
 147                 | hir::BinOpKind::Div
 148                 | hir::BinOpKind::Mul
 149                 | hir::BinOpKind::Rem => Some("arithmetic operation"),
 150                 hir::BinOpKind::And | hir::BinOpKind::Or => Some("logical operation"),
 151                 hir::BinOpKind::BitXor
 152                 | hir::BinOpKind::BitAnd
 153                 | hir::BinOpKind::BitOr
 154                 | hir::BinOpKind::Shl
 155                 | hir::BinOpKind::Shr => Some("bitwise operation"),
 156             },
 157             hir::ExprKind::Unary(..) => Some("unary operation"),
 158             _ => None,
 159         };
 160
 161         if let Some(must_use_op) = must_use_op {
 162             cx.struct_span_lint(UNUSED_MUST_USE, expr.span, |lint| {
 163                 lint.build(&format!("unused {} that must be used", must_use_op)).emit()
 164             });
 165             op_warned = true;
 166         }
 167
 168         if !(type_permits_lack_of_use || fn_warned || op_warned) {
 169             cx.struct_span_lint(UNUSED_RESULTS, s.span, |lint| lint.build("unused result").emit());
 170         }
 171
 172         // Returns whether an error has been emitted (and thus another does not need to be later).
 173         fn check_must_use_ty<'tcx>(
 174             cx: &LateContext<'tcx>,
 175             ty: Ty<'tcx>,
 176             expr: &hir::Expr<'_>,
 177             span: Span,
 178             descr_pre: &str,
 179             descr_post: &str,
 180             plural_len: usize,
 181         ) -> bool {
 182             if ty.is_unit()
 183                 || cx.tcx.is_ty_uninhabited_from(
 184                     cx.tcx.parent_module(expr.hir_id).to_def_id(),
 185                     ty,
 186                     cx.param_env,
 187                 )
 188             {
 189                 return true;
 190             }
 191
 192             let plural_suffix = pluralize!(plural_len);
 193
 194             match *ty.kind() {
 195                 ty::Adt(..) if ty.is_box() => {
 196                     let boxed_ty = ty.boxed_ty();
 197                     let descr_pre = &format!("{}boxed ", descr_pre);
 198                     check_must_use_ty(cx, boxed_ty, expr, span, descr_pre, descr_post, plural_len)
 199                 }
 200                 ty::Adt(def, _) => check_must_use_def(cx, def.did, span, descr_pre, descr_post),
 201                 ty::Opaque(def, _) => {
 202                     let mut has_emitted = false;
 203                     for &(predicate, _) in cx.tcx.explicit_item_bounds(def) {
 204                         // We only look at the `DefId`, so it is safe to skip the binder here.
 205                         if let ty::PredicateKind::Trait(ref poly_trait_predicate, _) =
 206                             predicate.kind().skip_binder()
 207                         {
 208                             let def_id = poly_trait_predicate.trait_ref.def_id;
 209                             let descr_pre =
 210                                 &format!("{}implementer{} of ", descr_pre, plural_suffix,);
 211                             if check_must_use_def(cx, def_id, span, descr_pre, descr_post) {
 212                                 has_emitted = true;
 213                                 break;
 214                             }
 215                         }
 216                     }
 217                     has_emitted
 218                 }
 219                 ty::Dynamic(binder, _) => {
 220                     let mut has_emitted = false;
 221                     for predicate in binder.iter() {
 222                         if let ty::ExistentialPredicate::Trait(ref trait_ref) =
 223                             predicate.skip_binder()
 224                         {
 225                             let def_id = trait_ref.def_id;
 226                             let descr_post =
 227                                 &format!(" trait object{}{}", plural_suffix, descr_post,);
 228                             if check_must_use_def(cx, def_id, span, descr_pre, descr_post) {
 229                                 has_emitted = true;
 230                                 break;
 231                             }
 232                         }
 233                     }
 234                     has_emitted
 235                 }
 236                 ty::Tuple(ref tys) => {
 237                     let mut has_emitted = false;
 238                     let spans = if let hir::ExprKind::Tup(comps) = &expr.kind {
 239                         debug_assert_eq!(comps.len(), tys.len());
 240                         comps.iter().map(|e| e.span).collect()
 241                     } else {
 242                         vec![]
 243                     };
 244                     for (i, ty) in tys.iter().map(|k| k.expect_ty()).enumerate() {
 245                         let descr_post = &format!(" in tuple element {}", i);
 246                         let span = *spans.get(i).unwrap_or(&span);
 247                         if check_must_use_ty(cx, ty, expr, span, descr_pre, descr_post, plural_len)
 248                         {
 249                             has_emitted = true;
 250                         }
 251                     }
 252                     has_emitted
 253                 }
 254                 ty::Array(ty, len) => match len.try_eval_usize(cx.tcx, cx.param_env) {
 255                     // If the array is empty we don't lint, to avoid false positives
 256                     Some(0) | None => false,
 257                     // If the array is definitely non-empty, we can do `#[must_use]` checking.
 258                     Some(n) => {
 259                         let descr_pre = &format!("{}array{} of ", descr_pre, plural_suffix,);
 260                         check_must_use_ty(cx, ty, expr, span, descr_pre, descr_post, n as usize + 1)
 261                     }
 262                 },
 263                 ty::Closure(..) => {
 264                     cx.struct_span_lint(UNUSED_MUST_USE, span, |lint| {
 265                         let mut err = lint.build(&format!(
 266                             "unused {}closure{}{} that must be used",
 267                             descr_pre, plural_suffix, descr_post,
 268                         ));
 269                         err.note("closures are lazy and do nothing unless called");
 270                         err.emit();
 271                     });
 272                     true
 273                 }
 274                 ty::Generator(..) => {
 275                     cx.struct_span_lint(UNUSED_MUST_USE, span, |lint| {
 276                         let mut err = lint.build(&format!(
 277                             "unused {}generator{}{} that must be used",
 278                             descr_pre, plural_suffix, descr_post,
 279                         ));
 280                         err.note("generators are lazy and do nothing unless resumed");
 281                         err.emit();
 282                     });
 283                     true
 284                 }
 285                 _ => false,
 286             }
 287         }
 288
 289         // Returns whether an error has been emitted (and thus another does not need to be later).
 290         // FIXME: Args desc_{pre,post}_path could be made lazy by taking Fn() -> &str, but this
 291         // would make calling it a big awkward. Could also take String (so args are moved), but
 292         // this would still require a copy into the format string, which would only be executed
 293         // when needed.
 294         fn check_must_use_def(
 295             cx: &LateContext<'_>,
 296             def_id: DefId,
 297             span: Span,
 298             descr_pre_path: &str,
 299             descr_post_path: &str,
 300         ) -> bool {
 301             for attr in cx.tcx.get_attrs(def_id).iter() {
 302                 if cx.sess().check_name(attr, sym::must_use) {
 303                     cx.struct_span_lint(UNUSED_MUST_USE, span, |lint| {
 304                         let msg = format!(
 305                             "unused {}`{}`{} that must be used",
 306                             descr_pre_path,
 307                             cx.tcx.def_path_str(def_id),
 308                             descr_post_path
 309                         );
 310                         let mut err = lint.build(&msg);
 311                         // check for #[must_use = "..."]
 312                         if let Some(note) = attr.value_str() {
 313                             err.note(&note.as_str());
 314                         }
 315                         err.emit();
 316                     });
 317                     return true;
 318                 }
 319             }
 320             false
 321         }
 322     }
 323 }
 324
 325 declare_lint! {
 326     /// The `path_statements` lint detects path statements with no effect.
 327     ///
 328     /// ### Example
 329     ///
 330     /// ```rust
 331     /// let x = 42;
 332     ///
 333     /// x;
 334     /// ```
 335     ///
 336     /// {{produces}}
 337     ///
 338     /// ### Explanation
 339     ///
 340     /// It is usually a mistake to have a statement that has no effect.
 341     pub PATH_STATEMENTS,
 342     Warn,
 343     "path statements with no effect"
 344 }
 345
 346 declare_lint_pass!(PathStatements => [PATH_STATEMENTS]);
 347
 348 impl<'tcx> LateLintPass<'tcx> for PathStatements {
 349     fn check_stmt(&mut self, cx: &LateContext<'_>, s: &hir::Stmt<'_>) {
 350         if let hir::StmtKind::Semi(expr) = s.kind {
 351             if let hir::ExprKind::Path(_) = expr.kind {
 352                 cx.struct_span_lint(PATH_STATEMENTS, s.span, |lint| {
 353                     let ty = cx.typeck_results().expr_ty(expr);
 354                     if ty.needs_drop(cx.tcx, cx.param_env) {
 355                         let mut lint = lint.build("path statement drops value");
 356                         if let Ok(snippet) = cx.sess().source_map().span_to_snippet(expr.span) {
 357                             lint.span_suggestion(
 358                                 s.span,
 359                                 "use `drop` to clarify the intent",
 360                                 format!("drop({});", snippet),
 361                                 Applicability::MachineApplicable,
 362                             );
 363                         } else {
 364                             lint.span_help(s.span, "use `drop` to clarify the intent");
 365                         }
 366                         lint.emit()
 367                     } else {
 368                         lint.build("path statement with no effect").emit()
 369                     }
 370                 });
 371             }
 372         }
 373     }
 374 }
 375
 376 #[derive(Copy, Clone)]
 377 pub struct UnusedAttributes {
 378     builtin_attributes: &'static FxHashMap<Symbol, &'static BuiltinAttribute>,
 379 }
 380
 381 impl UnusedAttributes {
 382     pub fn new() -> Self {
 383         UnusedAttributes { builtin_attributes: &*BUILTIN_ATTRIBUTE_MAP }
 384     }
 385 }
 386
 387 impl_lint_pass!(UnusedAttributes => [UNUSED_ATTRIBUTES]);
 388
 389 impl<'tcx> LateLintPass<'tcx> for UnusedAttributes {
 390     fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &ast::Attribute) {
 391         debug!("checking attribute: {:?}", attr);
 392
 393         if attr.is_doc_comment() {
 394             return;
 395         }
 396
 397         let attr_info = attr.ident().and_then(|ident| self.builtin_attributes.get(&ident.name));
 398
 399         if let Some(&&(name, ty, ..)) = attr_info {
 400             if let AttributeType::AssumedUsed = ty {
 401                 debug!("{:?} is AssumedUsed", name);
 402                 return;
 403             }
 404         }
 405
 406         if !cx.sess().is_attr_used(attr) {
 407             debug!("emitting warning for: {:?}", attr);
 408             cx.struct_span_lint(UNUSED_ATTRIBUTES, attr.span, |lint| {
 409                 lint.build("unused attribute").emit()
 410             });
 411             // Is it a builtin attribute that must be used at the crate level?
 412             if attr_info.map_or(false, |(_, ty, ..)| ty == &AttributeType::CrateLevel) {
 413                 cx.struct_span_lint(UNUSED_ATTRIBUTES, attr.span, |lint| {
 414                     let msg = match attr.style {
 415                         ast::AttrStyle::Outer => {
 416                             "crate-level attribute should be an inner attribute: add an exclamation \
 417                              mark: `#![foo]`"
 418                         }
 419                         ast::AttrStyle::Inner => "crate-level attribute should be in the root module",
 420                     };
 421                     lint.build(msg).emit()
 422                 });
 423             }
 424         } else {
 425             debug!("Attr was used: {:?}", attr);
 426         }
 427     }
 428 }
 429
 430 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 431 enum UnusedDelimsCtx {
 432     FunctionArg,
 433     MethodArg,
 434     AssignedValue,
 435     IfCond,
 436     WhileCond,
 437     ForIterExpr,
 438     MatchScrutineeExpr,
 439     ReturnValue,
 440     BlockRetValue,
 441     LetScrutineeExpr,
 442     ArrayLenExpr,
 443     AnonConst,
 444 }
 445
 446 impl From<UnusedDelimsCtx> for &'static str {
 447     fn from(ctx: UnusedDelimsCtx) -> &'static str {
 448         match ctx {
 449             UnusedDelimsCtx::FunctionArg => "function argument",
 450             UnusedDelimsCtx::MethodArg => "method argument",
 451             UnusedDelimsCtx::AssignedValue => "assigned value",
 452             UnusedDelimsCtx::IfCond => "`if` condition",
 453             UnusedDelimsCtx::WhileCond => "`while` condition",
 454             UnusedDelimsCtx::ForIterExpr => "`for` iterator expression",
 455             UnusedDelimsCtx::MatchScrutineeExpr => "`match` scrutinee expression",
 456             UnusedDelimsCtx::ReturnValue => "`return` value",
 457             UnusedDelimsCtx::BlockRetValue => "block return value",
 458             UnusedDelimsCtx::LetScrutineeExpr => "`let` scrutinee expression",
 459             UnusedDelimsCtx::ArrayLenExpr | UnusedDelimsCtx::AnonConst => "const expression",
 460         }
 461     }
 462 }
 463
 464 /// Used by both `UnusedParens` and `UnusedBraces` to prevent code duplication.
 465 trait UnusedDelimLint {
 466     const DELIM_STR: &'static str;
 467
 468     /// Due to `ref` pattern, there can be a difference between using
 469     /// `{ expr }` and `expr` in pattern-matching contexts. This means
 470     /// that we should only lint `unused_parens` and not `unused_braces`
 471     /// in this case.
 472     ///
 473     /// ```rust
 474     /// let mut a = 7;
 475     /// let ref b = { a }; // We actually borrow a copy of `a` here.
 476     /// a += 1; // By mutating `a` we invalidate any borrows of `a`.
 477     /// assert_eq!(b + 1, a); // `b` does not borrow `a`, so we can still use it here.
 478     /// ```
 479     const LINT_EXPR_IN_PATTERN_MATCHING_CTX: bool;
 480
 481     // this cannot be a constant is it refers to a static.
 482     fn lint(&self) -> &'static Lint;
 483
 484     fn check_unused_delims_expr(
 485         &self,
 486         cx: &EarlyContext<'_>,
 487         value: &ast::Expr,
 488         ctx: UnusedDelimsCtx,
 489         followed_by_block: bool,
 490         left_pos: Option<BytePos>,
 491         right_pos: Option<BytePos>,
 492     );
 493
 494     fn is_expr_delims_necessary(inner: &ast::Expr, followed_by_block: bool) -> bool {
 495         // Prevent false-positives in cases like `fn x() -> u8 { ({ 0 } + 1) }`
 496         let lhs_needs_parens = {
 497             let mut innermost = inner;
 498             loop {
 499                 if let ExprKind::Binary(_, lhs, _rhs) = &innermost.kind {
 500                     innermost = lhs;
 501                     if !rustc_ast::util::classify::expr_requires_semi_to_be_stmt(innermost) {
 502                         break true;
 503                     }
 504                 } else {
 505                     break false;
 506                 }
 507             }
 508         };
 509
 510         lhs_needs_parens
 511             || (followed_by_block
 512                 && match inner.kind {
 513                     ExprKind::Ret(_) | ExprKind::Break(..) | ExprKind::Yield(..) => true,
 514                     _ => parser::contains_exterior_struct_lit(&inner),
 515                 })
 516     }
 517
 518     fn emit_unused_delims_expr(
 519         &self,
 520         cx: &EarlyContext<'_>,
 521         value: &ast::Expr,
 522         ctx: UnusedDelimsCtx,
 523         left_pos: Option<BytePos>,
 524         right_pos: Option<BytePos>,
 525     ) {
 526         let expr_text = if let Ok(snippet) = cx.sess().source_map().span_to_snippet(value.span) {
 527             snippet
 528         } else {
 529             pprust::expr_to_string(value)
 530         };
 531         let keep_space = (
 532             left_pos.map_or(false, |s| s >= value.span.lo()),
 533             right_pos.map_or(false, |s| s <= value.span.hi()),
 534         );
 535         self.emit_unused_delims(cx, value.span, &expr_text, ctx.into(), keep_space);
 536     }
 537
 538     fn emit_unused_delims(
 539         &self,
 540         cx: &EarlyContext<'_>,
 541         span: Span,
 542         pattern: &str,
 543         msg: &str,
 544         keep_space: (bool, bool),
 545     ) {
 546         // FIXME(flip1995): Quick and dirty fix for #70814. This should be fixed in rustdoc
 547         // properly.
 548         if span == DUMMY_SP {
 549             return;
 550         }
 551
 552         cx.struct_span_lint(self.lint(), span, |lint| {
 553             let span_msg = format!("unnecessary {} around {}", Self::DELIM_STR, msg);
 554             let mut err = lint.build(&span_msg);
 555             let mut ate_left_paren = false;
 556             let mut ate_right_paren = false;
 557             let parens_removed = pattern
 558                 .trim_matches(|c| match c {
 559                     '(' | '{' => {
 560                         if ate_left_paren {
 561                             false
 562                         } else {
 563                             ate_left_paren = true;
 564                             true
 565                         }
 566                     }
 567                     ')' | '}' => {
 568                         if ate_right_paren {
 569                             false
 570                         } else {
 571                             ate_right_paren = true;
 572                             true
 573                         }
 574                     }
 575                     _ => false,
 576                 })
 577                 .trim();
 578
 579             let replace = {
 580                 let mut replace = if keep_space.0 {
 581                     let mut s = String::from(" ");
 582                     s.push_str(parens_removed);
 583                     s
 584                 } else {
 585                     String::from(parens_removed)
 586                 };
 587
 588                 if keep_space.1 {
 589                     replace.push(' ');
 590                 }
 591                 replace
 592             };
 593
 594             let suggestion = format!("remove these {}", Self::DELIM_STR);
 595
 596             err.span_suggestion_short(span, &suggestion, replace, Applicability::MachineApplicable);
 597             err.emit();
 598         });
 599     }
 600
 601     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
 602         use rustc_ast::ExprKind::*;
 603         let (value, ctx, followed_by_block, left_pos, right_pos) = match e.kind {
 604             // Do not lint `unused_braces` in `if let` expressions.
 605             If(ref cond, ref block, ..)
 606                 if !matches!(cond.kind, Let(_, _)) || Self::LINT_EXPR_IN_PATTERN_MATCHING_CTX =>
 607             {
 608                 let left = e.span.lo() + rustc_span::BytePos(2);
 609                 let right = block.span.lo();
 610                 (cond, UnusedDelimsCtx::IfCond, true, Some(left), Some(right))
 611             }
 612
 613             // Do not lint `unused_braces` in `while let` expressions.
 614             While(ref cond, ref block, ..)
 615                 if !matches!(cond.kind, Let(_, _)) || Self::LINT_EXPR_IN_PATTERN_MATCHING_CTX =>
 616             {
 617                 let left = e.span.lo() + rustc_span::BytePos(5);
 618                 let right = block.span.lo();
 619                 (cond, UnusedDelimsCtx::WhileCond, true, Some(left), Some(right))
 620             }
 621
 622             ForLoop(_, ref cond, ref block, ..) => {
 623                 (cond, UnusedDelimsCtx::ForIterExpr, true, None, Some(block.span.lo()))
 624             }
 625
 626             Match(ref head, _) if Self::LINT_EXPR_IN_PATTERN_MATCHING_CTX => {
 627                 let left = e.span.lo() + rustc_span::BytePos(5);
 628                 (head, UnusedDelimsCtx::MatchScrutineeExpr, true, Some(left), None)
 629             }
 630
 631             Ret(Some(ref value)) => {
 632                 let left = e.span.lo() + rustc_span::BytePos(3);
 633                 (value, UnusedDelimsCtx::ReturnValue, false, Some(left), None)
 634             }
 635
 636             Assign(_, ref value, _) | AssignOp(.., ref value) => {
 637                 (value, UnusedDelimsCtx::AssignedValue, false, None, None)
 638             }
 639             // either function/method call, or something this lint doesn't care about
 640             ref call_or_other => {
 641                 let (args_to_check, ctx) = match *call_or_other {
 642                     Call(_, ref args) => (&args[..], UnusedDelimsCtx::FunctionArg),
 643                     // first "argument" is self (which sometimes needs delims)
 644                     MethodCall(_, ref args, _) => (&args[1..], UnusedDelimsCtx::MethodArg),
 645                     // actual catch-all arm
 646                     _ => {
 647                         return;
 648                     }
 649                 };
 650                 // Don't lint if this is a nested macro expansion: otherwise, the lint could
 651                 // trigger in situations that macro authors shouldn't have to care about, e.g.,
 652                 // when a parenthesized token tree matched in one macro expansion is matched as
 653                 // an expression in another and used as a fn/method argument (Issue #47775)
 654                 if e.span.ctxt().outer_expn_data().call_site.from_expansion() {
 655                     return;
 656                 }
 657                 for arg in args_to_check {
 658                     self.check_unused_delims_expr(cx, arg, ctx, false, None, None);
 659                 }
 660                 return;
 661             }
 662         };
 663         self.check_unused_delims_expr(cx, &value, ctx, followed_by_block, left_pos, right_pos);
 664     }
 665
 666     fn check_stmt(&mut self, cx: &EarlyContext<'_>, s: &ast::Stmt) {
 667         match s.kind {
 668             StmtKind::Local(ref local) if Self::LINT_EXPR_IN_PATTERN_MATCHING_CTX => {
 669                 if let Some(ref value) = local.init {
 670                     self.check_unused_delims_expr(
 671                         cx,
 672                         &value,
 673                         UnusedDelimsCtx::AssignedValue,
 674                         false,
 675                         None,
 676                         None,
 677                     );
 678                 }
 679             }
 680             StmtKind::Expr(ref expr) => {
 681                 self.check_unused_delims_expr(
 682                     cx,
 683                     &expr,
 684                     UnusedDelimsCtx::BlockRetValue,
 685                     false,
 686                     None,
 687                     None,
 688                 );
 689             }
 690             _ => {}
 691         }
 692     }
 693
 694     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
 695         use ast::ItemKind::*;
 696
 697         if let Const(.., Some(expr)) | Static(.., Some(expr)) = &item.kind {
 698             self.check_unused_delims_expr(
 699                 cx,
 700                 expr,
 701                 UnusedDelimsCtx::AssignedValue,
 702                 false,
 703                 None,
 704                 None,
 705             );
 706         }
 707     }
 708 }
 709
 710 declare_lint! {
 711     /// The `unused_parens` lint detects `if`, `match`, `while` and `return`
 712     /// with parentheses; they do not need them.
 713     ///
 714     /// ### Examples
 715     ///
 716     /// ```rust
 717     /// if(true) {}
 718     /// ```
 719     ///
 720     /// {{produces}}
 721     ///
 722     /// ### Explanation
 723     ///
 724     /// The parenthesis are not needed, and should be removed. This is the
 725     /// preferred style for writing these expressions.
 726     pub(super) UNUSED_PARENS,
 727     Warn,
 728     "`if`, `match`, `while` and `return` do not need parentheses"
 729 }
 730
 731 declare_lint_pass!(UnusedParens => [UNUSED_PARENS]);
 732
 733 impl UnusedDelimLint for UnusedParens {
 734     const DELIM_STR: &'static str = "parentheses";
 735
 736     const LINT_EXPR_IN_PATTERN_MATCHING_CTX: bool = true;
 737
 738     fn lint(&self) -> &'static Lint {
 739         UNUSED_PARENS
 740     }
 741
 742     fn check_unused_delims_expr(
 743         &self,
 744         cx: &EarlyContext<'_>,
 745         value: &ast::Expr,
 746         ctx: UnusedDelimsCtx,
 747         followed_by_block: bool,
 748         left_pos: Option<BytePos>,
 749         right_pos: Option<BytePos>,
 750     ) {
 751         match value.kind {
 752             ast::ExprKind::Paren(ref inner) => {
 753                 if !Self::is_expr_delims_necessary(inner, followed_by_block)
 754                     && value.attrs.is_empty()
 755                     && !value.span.from_expansion()
 756                     && (ctx != UnusedDelimsCtx::LetScrutineeExpr
 757                         || !matches!(inner.kind, ast::ExprKind::Binary(
 758                                 rustc_span::source_map::Spanned { node, .. },
 759                                 _,
 760                                 _,
 761                             ) if node.lazy()))
 762                 {
 763                     self.emit_unused_delims_expr(cx, value, ctx, left_pos, right_pos)
 764                 }
 765             }
 766             ast::ExprKind::Let(_, ref expr) => {
 767                 self.check_unused_delims_expr(
 768                     cx,
 769                     expr,
 770                     UnusedDelimsCtx::LetScrutineeExpr,
 771                     followed_by_block,
 772                     None,
 773                     None,
 774                 );
 775             }
 776             _ => {}
 777         }
 778     }
 779 }
 780
 781 impl UnusedParens {
 782     fn check_unused_parens_pat(
 783         &self,
 784         cx: &EarlyContext<'_>,
 785         value: &ast::Pat,
 786         avoid_or: bool,
 787         avoid_mut: bool,
 788     ) {
 789         use ast::{BindingMode, Mutability, PatKind};
 790
 791         if let PatKind::Paren(inner) = &value.kind {
 792             match inner.kind {
 793                 // The lint visitor will visit each subpattern of `p`. We do not want to lint
 794                 // any range pattern no matter where it occurs in the pattern. For something like
 795                 // `&(a..=b)`, there is a recursive `check_pat` on `a` and `b`, but we will assume
 796                 // that if there are unnecessary parens they serve a purpose of readability.
 797                 PatKind::Range(..) => return,
 798                 // Avoid `p0 | .. | pn` if we should.
 799                 PatKind::Or(..) if avoid_or => return,
 800                 // Avoid `mut x` and `mut x @ p` if we should:
 801                 PatKind::Ident(BindingMode::ByValue(Mutability::Mut), ..) if avoid_mut => return,
 802                 // Otherwise proceed with linting.
 803                 _ => {}
 804             }
 805
 806             let pattern_text =
 807                 if let Ok(snippet) = cx.sess().source_map().span_to_snippet(value.span) {
 808                     snippet
 809                 } else {
 810                     pprust::pat_to_string(value)
 811                 };
 812             self.emit_unused_delims(cx, value.span, &pattern_text, "pattern", (false, false));
 813         }
 814     }
 815 }
 816
 817 impl EarlyLintPass for UnusedParens {
 818     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
 819         if let ExprKind::Let(ref pat, ..) | ExprKind::ForLoop(ref pat, ..) = e.kind {
 820             self.check_unused_parens_pat(cx, pat, false, false);
 821         }
 822
 823         <Self as UnusedDelimLint>::check_expr(self, cx, e)
 824     }
 825
 826     fn check_pat(&mut self, cx: &EarlyContext<'_>, p: &ast::Pat) {
 827         use ast::{Mutability, PatKind::*};
 828         match &p.kind {
 829             // Do not lint on `(..)` as that will result in the other arms being useless.
 830             Paren(_)
 831             // The other cases do not contain sub-patterns.
 832             | Wild | Rest | Lit(..) | MacCall(..) | Range(..) | Ident(.., None) | Path(..) => {},
 833             // These are list-like patterns; parens can always be removed.
 834             TupleStruct(_, ps) | Tuple(ps) | Slice(ps) | Or(ps) => for p in ps {
 835                 self.check_unused_parens_pat(cx, p, false, false);
 836             },
 837             Struct(_, fps, _) => for f in fps {
 838                 self.check_unused_parens_pat(cx, &f.pat, false, false);
 839             },
 840             // Avoid linting on `i @ (p0 | .. | pn)` and `box (p0 | .. | pn)`, #64106.
 841             Ident(.., Some(p)) | Box(p) => self.check_unused_parens_pat(cx, p, true, false),
 842             // Avoid linting on `&(mut x)` as `&mut x` has a different meaning, #55342.
 843             // Also avoid linting on `& mut? (p0 | .. | pn)`, #64106.
 844             Ref(p, m) => self.check_unused_parens_pat(cx, p, true, *m == Mutability::Not),
 845         }
 846     }
 847
 848     fn check_stmt(&mut self, cx: &EarlyContext<'_>, s: &ast::Stmt) {
 849         if let StmtKind::Local(ref local) = s.kind {
 850             self.check_unused_parens_pat(cx, &local.pat, false, false);
 851         }
 852
 853         <Self as UnusedDelimLint>::check_stmt(self, cx, s)
 854     }
 855
 856     fn check_param(&mut self, cx: &EarlyContext<'_>, param: &ast::Param) {
 857         self.check_unused_parens_pat(cx, &param.pat, true, false);
 858     }
 859
 860     fn check_arm(&mut self, cx: &EarlyContext<'_>, arm: &ast::Arm) {
 861         self.check_unused_parens_pat(cx, &arm.pat, false, false);
 862     }
 863
 864     fn check_ty(&mut self, cx: &EarlyContext<'_>, ty: &ast::Ty) {
 865         if let ast::TyKind::Paren(r) = &ty.kind {
 866             match &r.kind {
 867                 ast::TyKind::TraitObject(..) => {}
 868                 ast::TyKind::ImplTrait(_, bounds) if bounds.len() > 1 => {}
 869                 ast::TyKind::Array(_, len) => {
 870                     self.check_unused_delims_expr(
 871                         cx,
 872                         &len.value,
 873                         UnusedDelimsCtx::ArrayLenExpr,
 874                         false,
 875                         None,
 876                         None,
 877                     );
 878                 }
 879                 _ => {
 880                     let pattern_text =
 881                         if let Ok(snippet) = cx.sess().source_map().span_to_snippet(ty.span) {
 882                             snippet
 883                         } else {
 884                             pprust::ty_to_string(ty)
 885                         };
 886
 887                     self.emit_unused_delims(cx, ty.span, &pattern_text, "type", (false, false));
 888                 }
 889             }
 890         }
 891     }
 892
 893     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
 894         <Self as UnusedDelimLint>::check_item(self, cx, item)
 895     }
 896 }
 897
 898 declare_lint! {
 899     /// The `unused_braces` lint detects unnecessary braces around an
 900     /// expression.
 901     ///
 902     /// ### Example
 903     ///
 904     /// ```rust
 905     /// if { true } {
 906     ///     // ...
 907     /// }
 908     /// ```
 909     ///
 910     /// {{produces}}
 911     ///
 912     /// ### Explanation
 913     ///
 914     /// The braces are not needed, and should be removed. This is the
 915     /// preferred style for writing these expressions.
 916     pub(super) UNUSED_BRACES,
 917     Warn,
 918     "unnecessary braces around an expression"
 919 }
 920
 921 declare_lint_pass!(UnusedBraces => [UNUSED_BRACES]);
 922
 923 impl UnusedDelimLint for UnusedBraces {
 924     const DELIM_STR: &'static str = "braces";
 925
 926     const LINT_EXPR_IN_PATTERN_MATCHING_CTX: bool = false;
 927
 928     fn lint(&self) -> &'static Lint {
 929         UNUSED_BRACES
 930     }
 931
 932     fn check_unused_delims_expr(
 933         &self,
 934         cx: &EarlyContext<'_>,
 935         value: &ast::Expr,
 936         ctx: UnusedDelimsCtx,
 937         followed_by_block: bool,
 938         left_pos: Option<BytePos>,
 939         right_pos: Option<BytePos>,
 940     ) {
 941         match value.kind {
 942             ast::ExprKind::Block(ref inner, None)
 943                 if inner.rules == ast::BlockCheckMode::Default =>
 944             {
 945                 // emit a warning under the following conditions:
 946                 //
 947                 // - the block does not have a label
 948                 // - the block is not `unsafe`
 949                 // - the block contains exactly one expression (do not lint `{ expr; }`)
 950                 // - `followed_by_block` is true and the internal expr may contain a `{`
 951                 // - the block is not multiline (do not lint multiline match arms)
 952                 //      ```
 953                 //      match expr {
 954                 //          Pattern => {
 955                 //              somewhat_long_expression
 956                 //          }
 957                 //          // ...
 958                 //      }
 959                 //      ```
 960                 // - the block has no attribute and was not created inside a macro
 961                 // - if the block is an `anon_const`, the inner expr must be a literal
 962                 //      (do not lint `struct A<const N: usize>; let _: A<{ 2 + 3 }>;`)
 963                 //
 964                 // FIXME(const_generics): handle paths when #67075 is fixed.
 965                 if let [stmt] = inner.stmts.as_slice() {
 966                     if let ast::StmtKind::Expr(ref expr) = stmt.kind {
 967                         if !Self::is_expr_delims_necessary(expr, followed_by_block)
 968                             && (ctx != UnusedDelimsCtx::AnonConst
 969                                 || matches!(expr.kind, ast::ExprKind::Lit(_)))
 970                             && !cx.sess().source_map().is_multiline(value.span)
 971                             && value.attrs.is_empty()
 972                             && !value.span.from_expansion()
 973                         {
 974                             self.emit_unused_delims_expr(cx, value, ctx, left_pos, right_pos)
 975                         }
 976                     }
 977                 }
 978             }
 979             ast::ExprKind::Let(_, ref expr) => {
 980                 self.check_unused_delims_expr(
 981                     cx,
 982                     expr,
 983                     UnusedDelimsCtx::LetScrutineeExpr,
 984                     followed_by_block,
 985                     None,
 986                     None,
 987                 );
 988             }
 989             _ => {}
 990         }
 991     }
 992 }
 993
 994 impl EarlyLintPass for UnusedBraces {
 995     fn check_stmt(&mut self, cx: &EarlyContext<'_>, s: &ast::Stmt) {
 996         <Self as UnusedDelimLint>::check_stmt(self, cx, s)
 997     }
 998
 999     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
1000         <Self as UnusedDelimLint>::check_expr(self, cx, e);
1001
1002         if let ExprKind::Repeat(_, ref anon_const) = e.kind {
1003             self.check_unused_delims_expr(
1004                 cx,
1005                 &anon_const.value,
1006                 UnusedDelimsCtx::AnonConst,
1007                 false,
1008                 None,
1009                 None,
1010             );
1011         }
1012     }
1013
1014     fn check_generic_arg(&mut self, cx: &EarlyContext<'_>, arg: &ast::GenericArg) {
1015         if let ast::GenericArg::Const(ct) = arg {
1016             self.check_unused_delims_expr(
1017                 cx,
1018                 &ct.value,
1019                 UnusedDelimsCtx::AnonConst,
1020                 false,
1021                 None,
1022                 None,
1023             );
1024         }
1025     }
1026
1027     fn check_variant(&mut self, cx: &EarlyContext<'_>, v: &ast::Variant) {
1028         if let Some(anon_const) = &v.disr_expr {
1029             self.check_unused_delims_expr(
1030                 cx,
1031                 &anon_const.value,
1032                 UnusedDelimsCtx::AnonConst,
1033                 false,
1034                 None,
1035                 None,
1036             );
1037         }
1038     }
1039
1040     fn check_ty(&mut self, cx: &EarlyContext<'_>, ty: &ast::Ty) {
1041         match ty.kind {
1042             ast::TyKind::Array(_, ref len) => {
1043                 self.check_unused_delims_expr(
1044                     cx,
1045                     &len.value,
1046                     UnusedDelimsCtx::ArrayLenExpr,
1047                     false,
1048                     None,
1049                     None,
1050                 );
1051             }
1052
1053             ast::TyKind::Typeof(ref anon_const) => {
1054                 self.check_unused_delims_expr(
1055                     cx,
1056                     &anon_const.value,
1057                     UnusedDelimsCtx::AnonConst,
1058                     false,
1059                     None,
1060                     None,
1061                 );
1062             }
1063
1064             _ => {}
1065         }
1066     }
1067
1068     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
1069         <Self as UnusedDelimLint>::check_item(self, cx, item)
1070     }
1071 }
1072
1073 declare_lint! {
1074     /// The `unused_import_braces` lint catches unnecessary braces around an
1075     /// imported item.
1076     ///
1077     /// ### Example
1078     ///
1079     /// ```rust,compile_fail
1080     /// #![deny(unused_import_braces)]
1081     /// use test::{A};
1082     ///
1083     /// pub mod test {
1084     ///     pub struct A;
1085     /// }
1086     /// # fn main() {}
1087     /// ```
1088     ///
1089     /// {{produces}}
1090     ///
1091     /// ### Explanation
1092     ///
1093     /// If there is only a single item, then remove the braces (`use test::A;`
1094     /// for example).
1095     ///
1096     /// This lint is "allow" by default because it is only enforcing a
1097     /// stylistic choice.
1098     UNUSED_IMPORT_BRACES,
1099     Allow,
1100     "unnecessary braces around an imported item"
1101 }
1102
1103 declare_lint_pass!(UnusedImportBraces => [UNUSED_IMPORT_BRACES]);
1104
1105 impl UnusedImportBraces {
1106     fn check_use_tree(&self, cx: &EarlyContext<'_>, use_tree: &ast::UseTree, item: &ast::Item) {
1107         if let ast::UseTreeKind::Nested(ref items) = use_tree.kind {
1108             // Recursively check nested UseTrees
1109             for &(ref tree, _) in items {
1110                 self.check_use_tree(cx, tree, item);
1111             }
1112
1113             // Trigger the lint only if there is one nested item
1114             if items.len() != 1 {
1115                 return;
1116             }
1117
1118             // Trigger the lint if the nested item is a non-self single item
1119             let node_name = match items[0].0.kind {
1120                 ast::UseTreeKind::Simple(rename, ..) => {
1121                     let orig_ident = items[0].0.prefix.segments.last().unwrap().ident;
1122                     if orig_ident.name == kw::SelfLower {
1123                         return;
1124                     }
1125                     rename.unwrap_or(orig_ident).name
1126                 }
1127                 ast::UseTreeKind::Glob => Symbol::intern("*"),
1128                 ast::UseTreeKind::Nested(_) => return,
1129             };
1130
1131             cx.struct_span_lint(UNUSED_IMPORT_BRACES, item.span, |lint| {
1132                 lint.build(&format!("braces around {} is unnecessary", node_name)).emit()
1133             });
1134         }
1135     }
1136 }
1137
1138 impl EarlyLintPass for UnusedImportBraces {
1139     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
1140         if let ast::ItemKind::Use(ref use_tree) = item.kind {
1141             self.check_use_tree(cx, use_tree, item);
1142         }
1143     }
1144 }
1145
1146 declare_lint! {
1147     /// The `unused_allocation` lint detects unnecessary allocations that can
1148     /// be eliminated.
1149     ///
1150     /// ### Example
1151     ///
1152     /// ```rust
1153     /// #![feature(box_syntax)]
1154     /// fn main() {
1155     ///     let a = (box [1, 2, 3]).len();
1156     /// }
1157     /// ```
1158     ///
1159     /// {{produces}}
1160     ///
1161     /// ### Explanation
1162     ///
1163     /// When a `box` expression is immediately coerced to a reference, then
1164     /// the allocation is unnecessary, and a reference (using `&` or `&mut`)
1165     /// should be used instead to avoid the allocation.
1166     pub(super) UNUSED_ALLOCATION,
1167     Warn,
1168     "detects unnecessary allocations that can be eliminated"
1169 }
1170
1171 declare_lint_pass!(UnusedAllocation => [UNUSED_ALLOCATION]);
1172
1173 impl<'tcx> LateLintPass<'tcx> for UnusedAllocation {
1174     fn check_expr(&mut self, cx: &LateContext<'_>, e: &hir::Expr<'_>) {
1175         match e.kind {
1176             hir::ExprKind::Box(_) => {}
1177             _ => return,
1178         }
1179
1180         for adj in cx.typeck_results().expr_adjustments(e) {
1181             if let adjustment::Adjust::Borrow(adjustment::AutoBorrow::Ref(_, m)) = adj.kind {
1182                 cx.struct_span_lint(UNUSED_ALLOCATION, e.span, |lint| {
1183                     let msg = match m {
1184                         adjustment::AutoBorrowMutability::Not => {
1185                             "unnecessary allocation, use `&` instead"
1186                         }
1187                         adjustment::AutoBorrowMutability::Mut { .. } => {
1188                             "unnecessary allocation, use `&mut` instead"
1189                         }
1190                     };
1191                     lint.build(msg).emit()
1192                 });
1193             }
1194         }
1195     }
1196 }