compiler/rustc_lint/src/builtin.rs

   1 //! Lints in the Rust compiler.
   2 //!
   3 //! This contains lints which can feasibly be implemented as their own
   4 //! AST visitor. Also see `rustc_session::lint::builtin`, which contains the
   5 //! definitions of lints that are emitted directly inside the main compiler.
   6 //!
   7 //! To add a new lint to rustc, declare it here using `declare_lint!()`.
   8 //! Then add code to emit the new lint in the appropriate circumstances.
   9 //! You can do that in an existing `LintPass` if it makes sense, or in a
  10 //! new `LintPass`, or using `Session::add_lint` elsewhere in the
  11 //! compiler. Only do the latter if the check can't be written cleanly as a
  12 //! `LintPass` (also, note that such lints will need to be defined in
  13 //! `rustc_session::lint::builtin`, not here).
  14 //!
  15 //! If you define a new `EarlyLintPass`, you will also need to add it to the
  16 //! `add_early_builtin!` or `add_early_builtin_with_new!` invocation in
  17 //! `lib.rs`. Use the former for unit-like structs and the latter for structs
  18 //! with a `pub fn new()`.
  19 //!
  20 //! If you define a new `LateLintPass`, you will also need to add it to the
  21 //! `late_lint_methods!` invocation in `lib.rs`.
  22
  23 use crate::{
  24     types::{transparent_newtype_field, CItemKind},
  25     EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext,
  26 };
  27 use rustc_ast::attr;
  28 use rustc_ast::tokenstream::{TokenStream, TokenTree};
  29 use rustc_ast::visit::{FnCtxt, FnKind};
  30 use rustc_ast::{self as ast, *};
  31 use rustc_ast_pretty::pprust::{self, expr_to_string};
  32 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
  33 use rustc_data_structures::stack::ensure_sufficient_stack;
  34 use rustc_errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString};
  35 use rustc_feature::{deprecated_attributes, AttributeGate, AttributeTemplate, AttributeType};
  36 use rustc_feature::{GateIssue, Stability};
  37 use rustc_hir as hir;
  38 use rustc_hir::def::{DefKind, Res};
  39 use rustc_hir::def_id::{DefId, LocalDefId, LocalDefIdSet, CRATE_DEF_ID};
  40 use rustc_hir::{ForeignItemKind, GenericParamKind, PatKind};
  41 use rustc_hir::{HirId, Node};
  42 use rustc_index::vec::Idx;
  43 use rustc_middle::lint::LintDiagnosticBuilder;
  44 use rustc_middle::ty::print::with_no_trimmed_paths;
  45 use rustc_middle::ty::subst::{GenericArgKind, Subst};
  46 use rustc_middle::ty::Instance;
  47 use rustc_middle::ty::{self, layout::LayoutError, Ty, TyCtxt};
  48 use rustc_session::lint::FutureIncompatibilityReason;
  49 use rustc_session::Session;
  50 use rustc_span::edition::Edition;
  51 use rustc_span::source_map::Spanned;
  52 use rustc_span::symbol::{kw, sym, Ident, Symbol};
  53 use rustc_span::{BytePos, Span};
  54 use rustc_target::abi::{LayoutOf, VariantIdx};
  55 use rustc_trait_selection::traits::misc::can_type_implement_copy;
  56
  57 use crate::nonstandard_style::{method_context, MethodLateContext};
  58
  59 use std::fmt::Write;
  60 use tracing::{debug, trace};
  61
  62 // hardwired lints from librustc_middle
  63 pub use rustc_session::lint::builtin::*;
  64
  65 declare_lint! {
  66     /// The `while_true` lint detects `while true { }`.
  67     ///
  68     /// ### Example
  69     ///
  70     /// ```rust,no_run
  71     /// while true {
  72     ///
  73     /// }
  74     /// ```
  75     ///
  76     /// {{produces}}
  77     ///
  78     /// ### Explanation
  79     ///
  80     /// `while true` should be replaced with `loop`. A `loop` expression is
  81     /// the preferred way to write an infinite loop because it more directly
  82     /// expresses the intent of the loop.
  83     WHILE_TRUE,
  84     Warn,
  85     "suggest using `loop { }` instead of `while true { }`"
  86 }
  87
  88 declare_lint_pass!(WhileTrue => [WHILE_TRUE]);
  89
  90 /// Traverse through any amount of parenthesis and return the first non-parens expression.
  91 fn pierce_parens(mut expr: &ast::Expr) -> &ast::Expr {
  92     while let ast::ExprKind::Paren(sub) = &expr.kind {
  93         expr = sub;
  94     }
  95     expr
  96 }
  97
  98 impl EarlyLintPass for WhileTrue {
  99     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
 100         if let ast::ExprKind::While(cond, _, label) = &e.kind {
 101             if let ast::ExprKind::Lit(ref lit) = pierce_parens(cond).kind {
 102                 if let ast::LitKind::Bool(true) = lit.kind {
 103                     if !lit.span.from_expansion() {
 104                         let msg = "denote infinite loops with `loop { ... }`";
 105                         let condition_span = e.span.with_hi(cond.span.hi());
 106                         cx.struct_span_lint(WHILE_TRUE, condition_span, |lint| {
 107                             lint.build(msg)
 108                                 .span_suggestion_short(
 109                                     condition_span,
 110                                     "use `loop`",
 111                                     format!(
 112                                         "{}loop",
 113                                         label.map_or_else(String::new, |label| format!(
 114                                             "{}: ",
 115                                             label.ident,
 116                                         ))
 117                                     ),
 118                                     Applicability::MachineApplicable,
 119                                 )
 120                                 .emit();
 121                         })
 122                     }
 123                 }
 124             }
 125         }
 126     }
 127 }
 128
 129 declare_lint! {
 130     /// The `box_pointers` lints use of the Box type.
 131     ///
 132     /// ### Example
 133     ///
 134     /// ```rust,compile_fail
 135     /// #![deny(box_pointers)]
 136     /// struct Foo {
 137     ///     x: Box<isize>,
 138     /// }
 139     /// ```
 140     ///
 141     /// {{produces}}
 142     ///
 143     /// ### Explanation
 144     ///
 145     /// This lint is mostly historical, and not particularly useful. `Box<T>`
 146     /// used to be built into the language, and the only way to do heap
 147     /// allocation. Today's Rust can call into other allocators, etc.
 148     BOX_POINTERS,
 149     Allow,
 150     "use of owned (Box type) heap memory"
 151 }
 152
 153 declare_lint_pass!(BoxPointers => [BOX_POINTERS]);
 154
 155 impl BoxPointers {
 156     fn check_heap_type(&self, cx: &LateContext<'_>, span: Span, ty: Ty<'_>) {
 157         for leaf in ty.walk() {
 158             if let GenericArgKind::Type(leaf_ty) = leaf.unpack() {
 159                 if leaf_ty.is_box() {
 160                     cx.struct_span_lint(BOX_POINTERS, span, |lint| {
 161                         lint.build(&format!("type uses owned (Box type) pointers: {}", ty)).emit()
 162                     });
 163                 }
 164             }
 165         }
 166     }
 167 }
 168
 169 impl<'tcx> LateLintPass<'tcx> for BoxPointers {
 170     fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {
 171         match it.kind {
 172             hir::ItemKind::Fn(..)
 173             | hir::ItemKind::TyAlias(..)
 174             | hir::ItemKind::Enum(..)
 175             | hir::ItemKind::Struct(..)
 176             | hir::ItemKind::Union(..) => {
 177                 self.check_heap_type(cx, it.span, cx.tcx.type_of(it.def_id))
 178             }
 179             _ => (),
 180         }
 181
 182         // If it's a struct, we also have to check the fields' types
 183         match it.kind {
 184             hir::ItemKind::Struct(ref struct_def, _) | hir::ItemKind::Union(ref struct_def, _) => {
 185                 for struct_field in struct_def.fields() {
 186                     let def_id = cx.tcx.hir().local_def_id(struct_field.hir_id);
 187                     self.check_heap_type(cx, struct_field.span, cx.tcx.type_of(def_id));
 188                 }
 189             }
 190             _ => (),
 191         }
 192     }
 193
 194     fn check_expr(&mut self, cx: &LateContext<'_>, e: &hir::Expr<'_>) {
 195         let ty = cx.typeck_results().node_type(e.hir_id);
 196         self.check_heap_type(cx, e.span, ty);
 197     }
 198 }
 199
 200 declare_lint! {
 201     /// The `non_shorthand_field_patterns` lint detects using `Struct { x: x }`
 202     /// instead of `Struct { x }` in a pattern.
 203     ///
 204     /// ### Example
 205     ///
 206     /// ```rust
 207     /// struct Point {
 208     ///     x: i32,
 209     ///     y: i32,
 210     /// }
 211     ///
 212     ///
 213     /// fn main() {
 214     ///     let p = Point {
 215     ///         x: 5,
 216     ///         y: 5,
 217     ///     };
 218     ///
 219     ///     match p {
 220     ///         Point { x: x, y: y } => (),
 221     ///     }
 222     /// }
 223     /// ```
 224     ///
 225     /// {{produces}}
 226     ///
 227     /// ### Explanation
 228     ///
 229     /// The preferred style is to avoid the repetition of specifying both the
 230     /// field name and the binding name if both identifiers are the same.
 231     NON_SHORTHAND_FIELD_PATTERNS,
 232     Warn,
 233     "using `Struct { x: x }` instead of `Struct { x }` in a pattern"
 234 }
 235
 236 declare_lint_pass!(NonShorthandFieldPatterns => [NON_SHORTHAND_FIELD_PATTERNS]);
 237
 238 impl<'tcx> LateLintPass<'tcx> for NonShorthandFieldPatterns {
 239     fn check_pat(&mut self, cx: &LateContext<'_>, pat: &hir::Pat<'_>) {
 240         if let PatKind::Struct(ref qpath, field_pats, _) = pat.kind {
 241             let variant = cx
 242                 .typeck_results()
 243                 .pat_ty(pat)
 244                 .ty_adt_def()
 245                 .expect("struct pattern type is not an ADT")
 246                 .variant_of_res(cx.qpath_res(qpath, pat.hir_id));
 247             for fieldpat in field_pats {
 248                 if fieldpat.is_shorthand {
 249                     continue;
 250                 }
 251                 if fieldpat.span.from_expansion() {
 252                     // Don't lint if this is a macro expansion: macro authors
 253                     // shouldn't have to worry about this kind of style issue
 254                     // (Issue #49588)
 255                     continue;
 256                 }
 257                 if let PatKind::Binding(binding_annot, _, ident, None) = fieldpat.pat.kind {
 258                     if cx.tcx.find_field_index(ident, &variant)
 259                         == Some(cx.tcx.field_index(fieldpat.hir_id, cx.typeck_results()))
 260                     {
 261                         cx.struct_span_lint(NON_SHORTHAND_FIELD_PATTERNS, fieldpat.span, |lint| {
 262                             let mut err = lint
 263                                 .build(&format!("the `{}:` in this pattern is redundant", ident));
 264                             let binding = match binding_annot {
 265                                 hir::BindingAnnotation::Unannotated => None,
 266                                 hir::BindingAnnotation::Mutable => Some("mut"),
 267                                 hir::BindingAnnotation::Ref => Some("ref"),
 268                                 hir::BindingAnnotation::RefMut => Some("ref mut"),
 269                             };
 270                             let ident = if let Some(binding) = binding {
 271                                 format!("{} {}", binding, ident)
 272                             } else {
 273                                 ident.to_string()
 274                             };
 275                             err.span_suggestion(
 276                                 fieldpat.span,
 277                                 "use shorthand field pattern",
 278                                 ident,
 279                                 Applicability::MachineApplicable,
 280                             );
 281                             err.emit();
 282                         });
 283                     }
 284                 }
 285             }
 286         }
 287     }
 288 }
 289
 290 declare_lint! {
 291     /// The `unsafe_code` lint catches usage of `unsafe` code.
 292     ///
 293     /// ### Example
 294     ///
 295     /// ```rust,compile_fail
 296     /// #![deny(unsafe_code)]
 297     /// fn main() {
 298     ///     unsafe {
 299     ///
 300     ///     }
 301     /// }
 302     /// ```
 303     ///
 304     /// {{produces}}
 305     ///
 306     /// ### Explanation
 307     ///
 308     /// This lint is intended to restrict the usage of `unsafe`, which can be
 309     /// difficult to use correctly.
 310     UNSAFE_CODE,
 311     Allow,
 312     "usage of `unsafe` code"
 313 }
 314
 315 declare_lint_pass!(UnsafeCode => [UNSAFE_CODE]);
 316
 317 impl UnsafeCode {
 318     fn report_unsafe(
 319         &self,
 320         cx: &EarlyContext<'_>,
 321         span: Span,
 322         decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a>),
 323     ) {
 324         // This comes from a macro that has `#[allow_internal_unsafe]`.
 325         if span.allows_unsafe() {
 326             return;
 327         }
 328
 329         cx.struct_span_lint(UNSAFE_CODE, span, decorate);
 330     }
 331
 332     fn report_overriden_symbol_name(&self, cx: &EarlyContext<'_>, span: Span, msg: &str) {
 333         self.report_unsafe(cx, span, |lint| {
 334             lint.build(msg)
 335                 .note(
 336                     "the linker's behavior with multiple libraries exporting duplicate symbol \
 337                     names is undefined and Rust cannot provide guarantees when you manually \
 338                     override them",
 339                 )
 340                 .emit();
 341         })
 342     }
 343 }
 344
 345 impl EarlyLintPass for UnsafeCode {
 346     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &ast::Attribute) {
 347         if cx.sess().check_name(attr, sym::allow_internal_unsafe) {
 348             self.report_unsafe(cx, attr.span, |lint| {
 349                 lint.build(
 350                     "`allow_internal_unsafe` allows defining \
 351                                                macros using unsafe without triggering \
 352                                                the `unsafe_code` lint at their call site",
 353                 )
 354                 .emit()
 355             });
 356         }
 357     }
 358
 359     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
 360         if let ast::ExprKind::Block(ref blk, _) = e.kind {
 361             // Don't warn about generated blocks; that'll just pollute the output.
 362             if blk.rules == ast::BlockCheckMode::Unsafe(ast::UserProvided) {
 363                 self.report_unsafe(cx, blk.span, |lint| {
 364                     lint.build("usage of an `unsafe` block").emit()
 365                 });
 366             }
 367         }
 368     }
 369
 370     fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) {
 371         match it.kind {
 372             ast::ItemKind::Trait(box ast::TraitKind(_, ast::Unsafe::Yes(_), ..)) => self
 373                 .report_unsafe(cx, it.span, |lint| {
 374                     lint.build("declaration of an `unsafe` trait").emit()
 375                 }),
 376
 377             ast::ItemKind::Impl(box ast::ImplKind { unsafety: ast::Unsafe::Yes(_), .. }) => self
 378                 .report_unsafe(cx, it.span, |lint| {
 379                     lint.build("implementation of an `unsafe` trait").emit()
 380                 }),
 381
 382             ast::ItemKind::Fn(..) => {
 383                 if let Some(attr) = cx.sess().find_by_name(&it.attrs, sym::no_mangle) {
 384                     self.report_overriden_symbol_name(
 385                         cx,
 386                         attr.span,
 387                         "declaration of a `no_mangle` function",
 388                     );
 389                 }
 390                 if let Some(attr) = cx.sess().find_by_name(&it.attrs, sym::export_name) {
 391                     self.report_overriden_symbol_name(
 392                         cx,
 393                         attr.span,
 394                         "declaration of a function with `export_name`",
 395                     );
 396                 }
 397             }
 398
 399             ast::ItemKind::Static(..) => {
 400                 if let Some(attr) = cx.sess().find_by_name(&it.attrs, sym::no_mangle) {
 401                     self.report_overriden_symbol_name(
 402                         cx,
 403                         attr.span,
 404                         "declaration of a `no_mangle` static",
 405                     );
 406                 }
 407                 if let Some(attr) = cx.sess().find_by_name(&it.attrs, sym::export_name) {
 408                     self.report_overriden_symbol_name(
 409                         cx,
 410                         attr.span,
 411                         "declaration of a static with `export_name`",
 412                     );
 413                 }
 414             }
 415
 416             _ => {}
 417         }
 418     }
 419
 420     fn check_fn(&mut self, cx: &EarlyContext<'_>, fk: FnKind<'_>, span: Span, _: ast::NodeId) {
 421         if let FnKind::Fn(
 422             ctxt,
 423             _,
 424             ast::FnSig { header: ast::FnHeader { unsafety: ast::Unsafe::Yes(_), .. }, .. },
 425             _,
 426             body,
 427         ) = fk
 428         {
 429             let msg = match ctxt {
 430                 FnCtxt::Foreign => return,
 431                 FnCtxt::Free => "declaration of an `unsafe` function",
 432                 FnCtxt::Assoc(_) if body.is_none() => "declaration of an `unsafe` method",
 433                 FnCtxt::Assoc(_) => "implementation of an `unsafe` method",
 434             };
 435             self.report_unsafe(cx, span, |lint| lint.build(msg).emit());
 436         }
 437     }
 438 }
 439
 440 declare_lint! {
 441     /// The `missing_docs` lint detects missing documentation for public items.
 442     ///
 443     /// ### Example
 444     ///
 445     /// ```rust,compile_fail
 446     /// #![deny(missing_docs)]
 447     /// pub fn foo() {}
 448     /// ```
 449     ///
 450     /// {{produces}}
 451     ///
 452     /// ### Explanation
 453     ///
 454     /// This lint is intended to ensure that a library is well-documented.
 455     /// Items without documentation can be difficult for users to understand
 456     /// how to use properly.
 457     ///
 458     /// This lint is "allow" by default because it can be noisy, and not all
 459     /// projects may want to enforce everything to be documented.
 460     pub MISSING_DOCS,
 461     Allow,
 462     "detects missing documentation for public members",
 463     report_in_external_macro
 464 }
 465
 466 pub struct MissingDoc {
 467     /// Stack of whether `#[doc(hidden)]` is set at each level which has lint attributes.
 468     doc_hidden_stack: Vec<bool>,
 469
 470     /// Private traits or trait items that leaked through. Don't check their methods.
 471     private_traits: FxHashSet<hir::HirId>,
 472 }
 473
 474 impl_lint_pass!(MissingDoc => [MISSING_DOCS]);
 475
 476 fn has_doc(sess: &Session, attr: &ast::Attribute) -> bool {
 477     if attr.is_doc_comment() {
 478         return true;
 479     }
 480
 481     if !sess.check_name(attr, sym::doc) {
 482         return false;
 483     }
 484
 485     if attr.value_str().is_some() {
 486         return true;
 487     }
 488
 489     if let Some(list) = attr.meta_item_list() {
 490         for meta in list {
 491             if meta.has_name(sym::hidden) {
 492                 return true;
 493             }
 494         }
 495     }
 496
 497     false
 498 }
 499
 500 impl MissingDoc {
 501     pub fn new() -> MissingDoc {
 502         MissingDoc { doc_hidden_stack: vec![false], private_traits: FxHashSet::default() }
 503     }
 504
 505     fn doc_hidden(&self) -> bool {
 506         *self.doc_hidden_stack.last().expect("empty doc_hidden_stack")
 507     }
 508
 509     fn check_missing_docs_attrs(
 510         &self,
 511         cx: &LateContext<'_>,
 512         def_id: LocalDefId,
 513         sp: Span,
 514         article: &'static str,
 515         desc: &'static str,
 516     ) {
 517         // If we're building a test harness, then warning about
 518         // documentation is probably not really relevant right now.
 519         if cx.sess().opts.test {
 520             return;
 521         }
 522
 523         // `#[doc(hidden)]` disables missing_docs check.
 524         if self.doc_hidden() {
 525             return;
 526         }
 527
 528         // Only check publicly-visible items, using the result from the privacy pass.
 529         // It's an option so the crate root can also use this function (it doesn't
 530         // have a `NodeId`).
 531         if def_id != CRATE_DEF_ID {
 532             if !cx.access_levels.is_exported(def_id) {
 533                 return;
 534             }
 535         }
 536
 537         let attrs = cx.tcx.get_attrs(def_id.to_def_id());
 538         let has_doc = attrs.iter().any(|a| has_doc(cx.sess(), a));
 539         if !has_doc {
 540             cx.struct_span_lint(
 541                 MISSING_DOCS,
 542                 cx.tcx.sess.source_map().guess_head_span(sp),
 543                 |lint| {
 544                     lint.build(&format!("missing documentation for {} {}", article, desc)).emit()
 545                 },
 546             );
 547         }
 548     }
 549 }
 550
 551 impl<'tcx> LateLintPass<'tcx> for MissingDoc {
 552     fn enter_lint_attrs(&mut self, cx: &LateContext<'_>, attrs: &[ast::Attribute]) {
 553         let doc_hidden = self.doc_hidden()
 554             || attrs.iter().any(|attr| {
 555                 cx.sess().check_name(attr, sym::doc)
 556                     && match attr.meta_item_list() {
 557                         None => false,
 558                         Some(l) => attr::list_contains_name(&l, sym::hidden),
 559                     }
 560             });
 561         self.doc_hidden_stack.push(doc_hidden);
 562     }
 563
 564     fn exit_lint_attrs(&mut self, _: &LateContext<'_>, _attrs: &[ast::Attribute]) {
 565         self.doc_hidden_stack.pop().expect("empty doc_hidden_stack");
 566     }
 567
 568     fn check_crate(&mut self, cx: &LateContext<'_>, krate: &hir::Crate<'_>) {
 569         self.check_missing_docs_attrs(cx, CRATE_DEF_ID, krate.module().inner, "the", "crate");
 570
 571         for macro_def in krate.exported_macros() {
 572             // Non exported macros should be skipped, since `missing_docs` only
 573             // applies to externally visible items.
 574             if !cx.access_levels.is_exported(macro_def.def_id) {
 575                 continue;
 576             }
 577
 578             let attrs = cx.tcx.hir().attrs(macro_def.hir_id());
 579             let has_doc = attrs.iter().any(|a| has_doc(cx.sess(), a));
 580             if !has_doc {
 581                 cx.struct_span_lint(
 582                     MISSING_DOCS,
 583                     cx.tcx.sess.source_map().guess_head_span(macro_def.span),
 584                     |lint| lint.build("missing documentation for macro").emit(),
 585                 );
 586             }
 587         }
 588     }
 589
 590     fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {
 591         match it.kind {
 592             hir::ItemKind::Trait(.., trait_item_refs) => {
 593                 // Issue #11592: traits are always considered exported, even when private.
 594                 if let hir::VisibilityKind::Inherited = it.vis.node {
 595                     self.private_traits.insert(it.hir_id());
 596                     for trait_item_ref in trait_item_refs {
 597                         self.private_traits.insert(trait_item_ref.id.hir_id());
 598                     }
 599                     return;
 600                 }
 601             }
 602             hir::ItemKind::Impl(hir::Impl { of_trait: Some(ref trait_ref), items, .. }) => {
 603                 // If the trait is private, add the impl items to `private_traits` so they don't get
 604                 // reported for missing docs.
 605                 let real_trait = trait_ref.path.res.def_id();
 606                 if let Some(def_id) = real_trait.as_local() {
 607                     let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id);
 608                     if let Some(Node::Item(item)) = cx.tcx.hir().find(hir_id) {
 609                         if let hir::VisibilityKind::Inherited = item.vis.node {
 610                             for impl_item_ref in items {
 611                                 self.private_traits.insert(impl_item_ref.id.hir_id());
 612                             }
 613                         }
 614                     }
 615                 }
 616                 return;
 617             }
 618
 619             hir::ItemKind::TyAlias(..)
 620             | hir::ItemKind::Fn(..)
 621             | hir::ItemKind::Mod(..)
 622             | hir::ItemKind::Enum(..)
 623             | hir::ItemKind::Struct(..)
 624             | hir::ItemKind::Union(..)
 625             | hir::ItemKind::Const(..)
 626             | hir::ItemKind::Static(..) => {}
 627
 628             _ => return,
 629         };
 630
 631         let (article, desc) = cx.tcx.article_and_description(it.def_id.to_def_id());
 632
 633         self.check_missing_docs_attrs(cx, it.def_id, it.span, article, desc);
 634     }
 635
 636     fn check_trait_item(&mut self, cx: &LateContext<'_>, trait_item: &hir::TraitItem<'_>) {
 637         if self.private_traits.contains(&trait_item.hir_id()) {
 638             return;
 639         }
 640
 641         let (article, desc) = cx.tcx.article_and_description(trait_item.def_id.to_def_id());
 642
 643         self.check_missing_docs_attrs(cx, trait_item.def_id, trait_item.span, article, desc);
 644     }
 645
 646     fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
 647         // If the method is an impl for a trait, don't doc.
 648         if method_context(cx, impl_item.hir_id()) == MethodLateContext::TraitImpl {
 649             return;
 650         }
 651
 652         let (article, desc) = cx.tcx.article_and_description(impl_item.def_id.to_def_id());
 653         self.check_missing_docs_attrs(cx, impl_item.def_id, impl_item.span, article, desc);
 654     }
 655
 656     fn check_foreign_item(&mut self, cx: &LateContext<'_>, foreign_item: &hir::ForeignItem<'_>) {
 657         let (article, desc) = cx.tcx.article_and_description(foreign_item.def_id.to_def_id());
 658         self.check_missing_docs_attrs(cx, foreign_item.def_id, foreign_item.span, article, desc);
 659     }
 660
 661     fn check_field_def(&mut self, cx: &LateContext<'_>, sf: &hir::FieldDef<'_>) {
 662         if !sf.is_positional() {
 663             let def_id = cx.tcx.hir().local_def_id(sf.hir_id);
 664             self.check_missing_docs_attrs(cx, def_id, sf.span, "a", "struct field")
 665         }
 666     }
 667
 668     fn check_variant(&mut self, cx: &LateContext<'_>, v: &hir::Variant<'_>) {
 669         self.check_missing_docs_attrs(cx, cx.tcx.hir().local_def_id(v.id), v.span, "a", "variant");
 670     }
 671 }
 672
 673 declare_lint! {
 674     /// The `missing_copy_implementations` lint detects potentially-forgotten
 675     /// implementations of [`Copy`].
 676     ///
 677     /// [`Copy`]: https://doc.rust-lang.org/std/marker/trait.Copy.html
 678     ///
 679     /// ### Example
 680     ///
 681     /// ```rust,compile_fail
 682     /// #![deny(missing_copy_implementations)]
 683     /// pub struct Foo {
 684     ///     pub field: i32
 685     /// }
 686     /// # fn main() {}
 687     /// ```
 688     ///
 689     /// {{produces}}
 690     ///
 691     /// ### Explanation
 692     ///
 693     /// Historically (before 1.0), types were automatically marked as `Copy`
 694     /// if possible. This was changed so that it required an explicit opt-in
 695     /// by implementing the `Copy` trait. As part of this change, a lint was
 696     /// added to alert if a copyable type was not marked `Copy`.
 697     ///
 698     /// This lint is "allow" by default because this code isn't bad; it is
 699     /// common to write newtypes like this specifically so that a `Copy` type
 700     /// is no longer `Copy`. `Copy` types can result in unintended copies of
 701     /// large data which can impact performance.
 702     pub MISSING_COPY_IMPLEMENTATIONS,
 703     Allow,
 704     "detects potentially-forgotten implementations of `Copy`"
 705 }
 706
 707 declare_lint_pass!(MissingCopyImplementations => [MISSING_COPY_IMPLEMENTATIONS]);
 708
 709 impl<'tcx> LateLintPass<'tcx> for MissingCopyImplementations {
 710     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
 711         if !cx.access_levels.is_reachable(item.def_id) {
 712             return;
 713         }
 714         let (def, ty) = match item.kind {
 715             hir::ItemKind::Struct(_, ref ast_generics) => {
 716                 if !ast_generics.params.is_empty() {
 717                     return;
 718                 }
 719                 let def = cx.tcx.adt_def(item.def_id);
 720                 (def, cx.tcx.mk_adt(def, cx.tcx.intern_substs(&[])))
 721             }
 722             hir::ItemKind::Union(_, ref ast_generics) => {
 723                 if !ast_generics.params.is_empty() {
 724                     return;
 725                 }
 726                 let def = cx.tcx.adt_def(item.def_id);
 727                 (def, cx.tcx.mk_adt(def, cx.tcx.intern_substs(&[])))
 728             }
 729             hir::ItemKind::Enum(_, ref ast_generics) => {
 730                 if !ast_generics.params.is_empty() {
 731                     return;
 732                 }
 733                 let def = cx.tcx.adt_def(item.def_id);
 734                 (def, cx.tcx.mk_adt(def, cx.tcx.intern_substs(&[])))
 735             }
 736             _ => return,
 737         };
 738         if def.has_dtor(cx.tcx) {
 739             return;
 740         }
 741         let param_env = ty::ParamEnv::empty();
 742         if ty.is_copy_modulo_regions(cx.tcx.at(item.span), param_env) {
 743             return;
 744         }
 745         if can_type_implement_copy(cx.tcx, param_env, ty).is_ok() {
 746             cx.struct_span_lint(MISSING_COPY_IMPLEMENTATIONS, item.span, |lint| {
 747                 lint.build(
 748                     "type could implement `Copy`; consider adding `impl \
 749                           Copy`",
 750                 )
 751                 .emit()
 752             })
 753         }
 754     }
 755 }
 756
 757 declare_lint! {
 758     /// The `missing_debug_implementations` lint detects missing
 759     /// implementations of [`fmt::Debug`].
 760     ///
 761     /// [`fmt::Debug`]: https://doc.rust-lang.org/std/fmt/trait.Debug.html
 762     ///
 763     /// ### Example
 764     ///
 765     /// ```rust,compile_fail
 766     /// #![deny(missing_debug_implementations)]
 767     /// pub struct Foo;
 768     /// # fn main() {}
 769     /// ```
 770     ///
 771     /// {{produces}}
 772     ///
 773     /// ### Explanation
 774     ///
 775     /// Having a `Debug` implementation on all types can assist with
 776     /// debugging, as it provides a convenient way to format and display a
 777     /// value. Using the `#[derive(Debug)]` attribute will automatically
 778     /// generate a typical implementation, or a custom implementation can be
 779     /// added by manually implementing the `Debug` trait.
 780     ///
 781     /// This lint is "allow" by default because adding `Debug` to all types can
 782     /// have a negative impact on compile time and code size. It also requires
 783     /// boilerplate to be added to every type, which can be an impediment.
 784     MISSING_DEBUG_IMPLEMENTATIONS,
 785     Allow,
 786     "detects missing implementations of Debug"
 787 }
 788
 789 #[derive(Default)]
 790 pub struct MissingDebugImplementations {
 791     impling_types: Option<LocalDefIdSet>,
 792 }
 793
 794 impl_lint_pass!(MissingDebugImplementations => [MISSING_DEBUG_IMPLEMENTATIONS]);
 795
 796 impl<'tcx> LateLintPass<'tcx> for MissingDebugImplementations {
 797     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
 798         if !cx.access_levels.is_reachable(item.def_id) {
 799             return;
 800         }
 801
 802         match item.kind {
 803             hir::ItemKind::Struct(..) | hir::ItemKind::Union(..) | hir::ItemKind::Enum(..) => {}
 804             _ => return,
 805         }
 806
 807         let debug = match cx.tcx.get_diagnostic_item(sym::debug_trait) {
 808             Some(debug) => debug,
 809             None => return,
 810         };
 811
 812         if self.impling_types.is_none() {
 813             let mut impls = LocalDefIdSet::default();
 814             cx.tcx.for_each_impl(debug, |d| {
 815                 if let Some(ty_def) = cx.tcx.type_of(d).ty_adt_def() {
 816                     if let Some(def_id) = ty_def.did.as_local() {
 817                         impls.insert(def_id);
 818                     }
 819                 }
 820             });
 821
 822             self.impling_types = Some(impls);
 823             debug!("{:?}", self.impling_types);
 824         }
 825
 826         if !self.impling_types.as_ref().unwrap().contains(&item.def_id) {
 827             cx.struct_span_lint(MISSING_DEBUG_IMPLEMENTATIONS, item.span, |lint| {
 828                 lint.build(&format!(
 829                     "type does not implement `{}`; consider adding `#[derive(Debug)]` \
 830                      or a manual implementation",
 831                     cx.tcx.def_path_str(debug)
 832                 ))
 833                 .emit()
 834             });
 835         }
 836     }
 837 }
 838
 839 declare_lint! {
 840     /// The `anonymous_parameters` lint detects anonymous parameters in trait
 841     /// definitions.
 842     ///
 843     /// ### Example
 844     ///
 845     /// ```rust,edition2015,compile_fail
 846     /// #![deny(anonymous_parameters)]
 847     /// // edition 2015
 848     /// pub trait Foo {
 849     ///     fn foo(usize);
 850     /// }
 851     /// fn main() {}
 852     /// ```
 853     ///
 854     /// {{produces}}
 855     ///
 856     /// ### Explanation
 857     ///
 858     /// This syntax is mostly a historical accident, and can be worked around
 859     /// quite easily by adding an `_` pattern or a descriptive identifier:
 860     ///
 861     /// ```rust
 862     /// trait Foo {
 863     ///     fn foo(_: usize);
 864     /// }
 865     /// ```
 866     ///
 867     /// This syntax is now a hard error in the 2018 edition. In the 2015
 868     /// edition, this lint is "warn" by default. This lint
 869     /// enables the [`cargo fix`] tool with the `--edition` flag to
 870     /// automatically transition old code from the 2015 edition to 2018. The
 871     /// tool will run this lint and automatically apply the
 872     /// suggested fix from the compiler (which is to add `_` to each
 873     /// parameter). This provides a completely automated way to update old
 874     /// code for a new edition. See [issue #41686] for more details.
 875     ///
 876     /// [issue #41686]: https://github.com/rust-lang/rust/issues/41686
 877     /// [`cargo fix`]: https://doc.rust-lang.org/cargo/commands/cargo-fix.html
 878     pub ANONYMOUS_PARAMETERS,
 879     Warn,
 880     "detects anonymous parameters",
 881     @future_incompatible = FutureIncompatibleInfo {
 882         reference: "issue #41686 <https://github.com/rust-lang/rust/issues/41686>",
 883         reason: FutureIncompatibilityReason::EditionError(Edition::Edition2018),
 884     };
 885 }
 886
 887 declare_lint_pass!(
 888     /// Checks for use of anonymous parameters (RFC 1685).
 889     AnonymousParameters => [ANONYMOUS_PARAMETERS]
 890 );
 891
 892 impl EarlyLintPass for AnonymousParameters {
 893     fn check_trait_item(&mut self, cx: &EarlyContext<'_>, it: &ast::AssocItem) {
 894         if cx.sess.edition() != Edition::Edition2015 {
 895             // This is a hard error in future editions; avoid linting and erroring
 896             return;
 897         }
 898         if let ast::AssocItemKind::Fn(box FnKind(_, ref sig, _, _)) = it.kind {
 899             for arg in sig.decl.inputs.iter() {
 900                 if let ast::PatKind::Ident(_, ident, None) = arg.pat.kind {
 901                     if ident.name == kw::Empty {
 902                         cx.struct_span_lint(ANONYMOUS_PARAMETERS, arg.pat.span, |lint| {
 903                             let ty_snip = cx.sess.source_map().span_to_snippet(arg.ty.span);
 904
 905                             let (ty_snip, appl) = if let Ok(ref snip) = ty_snip {
 906                                 (snip.as_str(), Applicability::MachineApplicable)
 907                             } else {
 908                                 ("<type>", Applicability::HasPlaceholders)
 909                             };
 910
 911                             lint.build(
 912                                 "anonymous parameters are deprecated and will be \
 913                                      removed in the next edition.",
 914                             )
 915                             .span_suggestion(
 916                                 arg.pat.span,
 917                                 "try naming the parameter or explicitly \
 918                                             ignoring it",
 919                                 format!("_: {}", ty_snip),
 920                                 appl,
 921                             )
 922                             .emit();
 923                         })
 924                     }
 925                 }
 926             }
 927         }
 928     }
 929 }
 930
 931 /// Check for use of attributes which have been deprecated.
 932 #[derive(Clone)]
 933 pub struct DeprecatedAttr {
 934     // This is not free to compute, so we want to keep it around, rather than
 935     // compute it for every attribute.
 936     depr_attrs: Vec<&'static (Symbol, AttributeType, AttributeTemplate, AttributeGate)>,
 937 }
 938
 939 impl_lint_pass!(DeprecatedAttr => []);
 940
 941 impl DeprecatedAttr {
 942     pub fn new() -> DeprecatedAttr {
 943         DeprecatedAttr { depr_attrs: deprecated_attributes() }
 944     }
 945 }
 946
 947 fn lint_deprecated_attr(
 948     cx: &EarlyContext<'_>,
 949     attr: &ast::Attribute,
 950     msg: &str,
 951     suggestion: Option<&str>,
 952 ) {
 953     cx.struct_span_lint(DEPRECATED, attr.span, |lint| {
 954         lint.build(msg)
 955             .span_suggestion_short(
 956                 attr.span,
 957                 suggestion.unwrap_or("remove this attribute"),
 958                 String::new(),
 959                 Applicability::MachineApplicable,
 960             )
 961             .emit();
 962     })
 963 }
 964
 965 impl EarlyLintPass for DeprecatedAttr {
 966     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &ast::Attribute) {
 967         for &&(n, _, _, ref g) in &self.depr_attrs {
 968             if attr.ident().map(|ident| ident.name) == Some(n) {
 969                 if let &AttributeGate::Gated(
 970                     Stability::Deprecated(link, suggestion),
 971                     name,
 972                     reason,
 973                     _,
 974                 ) = g
 975                 {
 976                     let msg =
 977                         format!("use of deprecated attribute `{}`: {}. See {}", name, reason, link);
 978                     lint_deprecated_attr(cx, attr, &msg, suggestion);
 979                 }
 980                 return;
 981             }
 982         }
 983         if cx.sess().check_name(attr, sym::no_start) || cx.sess().check_name(attr, sym::crate_id) {
 984             let path_str = pprust::path_to_string(&attr.get_normal_item().path);
 985             let msg = format!("use of deprecated attribute `{}`: no longer used.", path_str);
 986             lint_deprecated_attr(cx, attr, &msg, None);
 987         }
 988     }
 989 }
 990
 991 fn warn_if_doc(cx: &EarlyContext<'_>, node_span: Span, node_kind: &str, attrs: &[ast::Attribute]) {
 992     use rustc_ast::token::CommentKind;
 993
 994     let mut attrs = attrs.iter().peekable();
 995
 996     // Accumulate a single span for sugared doc comments.
 997     let mut sugared_span: Option<Span> = None;
 998
 999     while let Some(attr) = attrs.next() {
1000         let is_doc_comment = attr.is_doc_comment();
1001         if is_doc_comment {
1002             sugared_span =
1003                 Some(sugared_span.map_or(attr.span, |span| span.with_hi(attr.span.hi())));
1004         }
1005
1006         if attrs.peek().map_or(false, |next_attr| next_attr.is_doc_comment()) {
1007             continue;
1008         }
1009
1010         let span = sugared_span.take().unwrap_or(attr.span);
1011
1012         if is_doc_comment || cx.sess().check_name(attr, sym::doc) {
1013             cx.struct_span_lint(UNUSED_DOC_COMMENTS, span, |lint| {
1014                 let mut err = lint.build("unused doc comment");
1015                 err.span_label(
1016                     node_span,
1017                     format!("rustdoc does not generate documentation for {}", node_kind),
1018                 );
1019                 match attr.kind {
1020                     AttrKind::DocComment(CommentKind::Line, _) | AttrKind::Normal(..) => {
1021                         err.help("use `//` for a plain comment");
1022                     }
1023                     AttrKind::DocComment(CommentKind::Block, _) => {
1024                         err.help("use `/* */` for a plain comment");
1025                     }
1026                 }
1027                 err.emit();
1028             });
1029         }
1030     }
1031 }
1032
1033 impl EarlyLintPass for UnusedDocComment {
1034     fn check_stmt(&mut self, cx: &EarlyContext<'_>, stmt: &ast::Stmt) {
1035         let kind = match stmt.kind {
1036             ast::StmtKind::Local(..) => "statements",
1037             // Disabled pending discussion in #78306
1038             ast::StmtKind::Item(..) => return,
1039             // expressions will be reported by `check_expr`.
1040             ast::StmtKind::Empty
1041             | ast::StmtKind::Semi(_)
1042             | ast::StmtKind::Expr(_)
1043             | ast::StmtKind::MacCall(_) => return,
1044         };
1045
1046         warn_if_doc(cx, stmt.span, kind, stmt.kind.attrs());
1047     }
1048
1049     fn check_arm(&mut self, cx: &EarlyContext<'_>, arm: &ast::Arm) {
1050         let arm_span = arm.pat.span.with_hi(arm.body.span.hi());
1051         warn_if_doc(cx, arm_span, "match arms", &arm.attrs);
1052     }
1053
1054     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
1055         warn_if_doc(cx, expr.span, "expressions", &expr.attrs);
1056     }
1057 }
1058
1059 declare_lint! {
1060     /// The `no_mangle_const_items` lint detects any `const` items with the
1061     /// [`no_mangle` attribute].
1062     ///
1063     /// [`no_mangle` attribute]: https://doc.rust-lang.org/reference/abi.html#the-no_mangle-attribute
1064     ///
1065     /// ### Example
1066     ///
1067     /// ```rust,compile_fail
1068     /// #[no_mangle]
1069     /// const FOO: i32 = 5;
1070     /// ```
1071     ///
1072     /// {{produces}}
1073     ///
1074     /// ### Explanation
1075     ///
1076     /// Constants do not have their symbols exported, and therefore, this
1077     /// probably means you meant to use a [`static`], not a [`const`].
1078     ///
1079     /// [`static`]: https://doc.rust-lang.org/reference/items/static-items.html
1080     /// [`const`]: https://doc.rust-lang.org/reference/items/constant-items.html
1081     NO_MANGLE_CONST_ITEMS,
1082     Deny,
1083     "const items will not have their symbols exported"
1084 }
1085
1086 declare_lint! {
1087     /// The `no_mangle_generic_items` lint detects generic items that must be
1088     /// mangled.
1089     ///
1090     /// ### Example
1091     ///
1092     /// ```rust
1093     /// #[no_mangle]
1094     /// fn foo<T>(t: T) {
1095     ///
1096     /// }
1097     /// ```
1098     ///
1099     /// {{produces}}
1100     ///
1101     /// ### Explanation
1102     ///
1103     /// A function with generics must have its symbol mangled to accommodate
1104     /// the generic parameter. The [`no_mangle` attribute] has no effect in
1105     /// this situation, and should be removed.
1106     ///
1107     /// [`no_mangle` attribute]: https://doc.rust-lang.org/reference/abi.html#the-no_mangle-attribute
1108     NO_MANGLE_GENERIC_ITEMS,
1109     Warn,
1110     "generic items must be mangled"
1111 }
1112
1113 declare_lint_pass!(InvalidNoMangleItems => [NO_MANGLE_CONST_ITEMS, NO_MANGLE_GENERIC_ITEMS]);
1114
1115 impl<'tcx> LateLintPass<'tcx> for InvalidNoMangleItems {
1116     fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {
1117         let attrs = cx.tcx.hir().attrs(it.hir_id());
1118         match it.kind {
1119             hir::ItemKind::Fn(.., ref generics, _) => {
1120                 if let Some(no_mangle_attr) = cx.sess().find_by_name(attrs, sym::no_mangle) {
1121                     for param in generics.params {
1122                         match param.kind {
1123                             GenericParamKind::Lifetime { .. } => {}
1124                             GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => {
1125                                 cx.struct_span_lint(NO_MANGLE_GENERIC_ITEMS, it.span, |lint| {
1126                                     lint.build(
1127                                         "functions generic over types or consts must be mangled",
1128                                     )
1129                                     .span_suggestion_short(
1130                                         no_mangle_attr.span,
1131                                         "remove this attribute",
1132                                         String::new(),
1133                                         // Use of `#[no_mangle]` suggests FFI intent; correct
1134                                         // fix may be to monomorphize source by hand
1135                                         Applicability::MaybeIncorrect,
1136                                     )
1137                                     .emit();
1138                                 });
1139                                 break;
1140                             }
1141                         }
1142                     }
1143                 }
1144             }
1145             hir::ItemKind::Const(..) => {
1146                 if cx.sess().contains_name(attrs, sym::no_mangle) {
1147                     // Const items do not refer to a particular location in memory, and therefore
1148                     // don't have anything to attach a symbol to
1149                     cx.struct_span_lint(NO_MANGLE_CONST_ITEMS, it.span, |lint| {
1150                         let msg = "const items should never be `#[no_mangle]`";
1151                         let mut err = lint.build(msg);
1152
1153                         // account for "pub const" (#45562)
1154                         let start = cx
1155                             .tcx
1156                             .sess
1157                             .source_map()
1158                             .span_to_snippet(it.span)
1159                             .map(|snippet| snippet.find("const").unwrap_or(0))
1160                             .unwrap_or(0) as u32;
1161                         // `const` is 5 chars
1162                         let const_span = it.span.with_hi(BytePos(it.span.lo().0 + start + 5));
1163                         err.span_suggestion(
1164                             const_span,
1165                             "try a static value",
1166                             "pub static".to_owned(),
1167                             Applicability::MachineApplicable,
1168                         );
1169                         err.emit();
1170                     });
1171                 }
1172             }
1173             _ => {}
1174         }
1175     }
1176 }
1177
1178 declare_lint! {
1179     /// The `mutable_transmutes` lint catches transmuting from `&T` to `&mut
1180     /// T` because it is [undefined behavior].
1181     ///
1182     /// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
1183     ///
1184     /// ### Example
1185     ///
1186     /// ```rust,compile_fail
1187     /// unsafe {
1188     ///     let y = std::mem::transmute::<&i32, &mut i32>(&5);
1189     /// }
1190     /// ```
1191     ///
1192     /// {{produces}}
1193     ///
1194     /// ### Explanation
1195     ///
1196     /// Certain assumptions are made about aliasing of data, and this transmute
1197     /// violates those assumptions. Consider using [`UnsafeCell`] instead.
1198     ///
1199     /// [`UnsafeCell`]: https://doc.rust-lang.org/std/cell/struct.UnsafeCell.html
1200     MUTABLE_TRANSMUTES,
1201     Deny,
1202     "mutating transmuted &mut T from &T may cause undefined behavior"
1203 }
1204
1205 declare_lint_pass!(MutableTransmutes => [MUTABLE_TRANSMUTES]);
1206
1207 impl<'tcx> LateLintPass<'tcx> for MutableTransmutes {
1208     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
1209         use rustc_target::spec::abi::Abi::RustIntrinsic;
1210         if let Some((&ty::Ref(_, _, from_mt), &ty::Ref(_, _, to_mt))) =
1211             get_transmute_from_to(cx, expr).map(|(ty1, ty2)| (ty1.kind(), ty2.kind()))
1212         {
1213             if to_mt == hir::Mutability::Mut && from_mt == hir::Mutability::Not {
1214                 let msg = "mutating transmuted &mut T from &T may cause undefined behavior, \
1215                                consider instead using an UnsafeCell";
1216                 cx.struct_span_lint(MUTABLE_TRANSMUTES, expr.span, |lint| lint.build(msg).emit());
1217             }
1218         }
1219
1220         fn get_transmute_from_to<'tcx>(
1221             cx: &LateContext<'tcx>,
1222             expr: &hir::Expr<'_>,
1223         ) -> Option<(Ty<'tcx>, Ty<'tcx>)> {
1224             let def = if let hir::ExprKind::Path(ref qpath) = expr.kind {
1225                 cx.qpath_res(qpath, expr.hir_id)
1226             } else {
1227                 return None;
1228             };
1229             if let Res::Def(DefKind::Fn, did) = def {
1230                 if !def_id_is_transmute(cx, did) {
1231                     return None;
1232                 }
1233                 let sig = cx.typeck_results().node_type(expr.hir_id).fn_sig(cx.tcx);
1234                 let from = sig.inputs().skip_binder()[0];
1235                 let to = sig.output().skip_binder();
1236                 return Some((from, to));
1237             }
1238             None
1239         }
1240
1241         fn def_id_is_transmute(cx: &LateContext<'_>, def_id: DefId) -> bool {
1242             cx.tcx.fn_sig(def_id).abi() == RustIntrinsic
1243                 && cx.tcx.item_name(def_id) == sym::transmute
1244         }
1245     }
1246 }
1247
1248 declare_lint! {
1249     /// The `unstable_features` is deprecated and should no longer be used.
1250     UNSTABLE_FEATURES,
1251     Allow,
1252     "enabling unstable features (deprecated. do not use)"
1253 }
1254
1255 declare_lint_pass!(
1256     /// Forbids using the `#[feature(...)]` attribute
1257     UnstableFeatures => [UNSTABLE_FEATURES]
1258 );
1259
1260 impl<'tcx> LateLintPass<'tcx> for UnstableFeatures {
1261     fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &ast::Attribute) {
1262         if cx.sess().check_name(attr, sym::feature) {
1263             if let Some(items) = attr.meta_item_list() {
1264                 for item in items {
1265                     cx.struct_span_lint(UNSTABLE_FEATURES, item.span(), |lint| {
1266                         lint.build("unstable feature").emit()
1267                     });
1268                 }
1269             }
1270         }
1271     }
1272 }
1273
1274 declare_lint! {
1275     /// The `unreachable_pub` lint triggers for `pub` items not reachable from
1276     /// the crate root.
1277     ///
1278     /// ### Example
1279     ///
1280     /// ```rust,compile_fail
1281     /// #![deny(unreachable_pub)]
1282     /// mod foo {
1283     ///     pub mod bar {
1284     ///
1285     ///     }
1286     /// }
1287     /// ```
1288     ///
1289     /// {{produces}}
1290     ///
1291     /// ### Explanation
1292     ///
1293     /// A bare `pub` visibility may be misleading if the item is not actually
1294     /// publicly exported from the crate. The `pub(crate)` visibility is
1295     /// recommended to be used instead, which more clearly expresses the intent
1296     /// that the item is only visible within its own crate.
1297     ///
1298     /// This lint is "allow" by default because it will trigger for a large
1299     /// amount existing Rust code, and has some false-positives. Eventually it
1300     /// is desired for this to become warn-by-default.
1301     pub UNREACHABLE_PUB,
1302     Allow,
1303     "`pub` items not reachable from crate root"
1304 }
1305
1306 declare_lint_pass!(
1307     /// Lint for items marked `pub` that aren't reachable from other crates.
1308     UnreachablePub => [UNREACHABLE_PUB]
1309 );
1310
1311 impl UnreachablePub {
1312     fn perform_lint(
1313         &self,
1314         cx: &LateContext<'_>,
1315         what: &str,
1316         def_id: LocalDefId,
1317         vis: &hir::Visibility<'_>,
1318         span: Span,
1319         exportable: bool,
1320     ) {
1321         let mut applicability = Applicability::MachineApplicable;
1322         match vis.node {
1323             hir::VisibilityKind::Public if !cx.access_levels.is_reachable(def_id) => {
1324                 if span.from_expansion() {
1325                     applicability = Applicability::MaybeIncorrect;
1326                 }
1327                 let def_span = cx.tcx.sess.source_map().guess_head_span(span);
1328                 cx.struct_span_lint(UNREACHABLE_PUB, def_span, |lint| {
1329                     let mut err = lint.build(&format!("unreachable `pub` {}", what));
1330                     let replacement = if cx.tcx.features().crate_visibility_modifier {
1331                         "crate"
1332                     } else {
1333                         "pub(crate)"
1334                     }
1335                     .to_owned();
1336
1337                     err.span_suggestion(
1338                         vis.span,
1339                         "consider restricting its visibility",
1340                         replacement,
1341                         applicability,
1342                     );
1343                     if exportable {
1344                         err.help("or consider exporting it for use by other crates");
1345                     }
1346                     err.emit();
1347                 });
1348             }
1349             _ => {}
1350         }
1351     }
1352 }
1353
1354 impl<'tcx> LateLintPass<'tcx> for UnreachablePub {
1355     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
1356         self.perform_lint(cx, "item", item.def_id, &item.vis, item.span, true);
1357     }
1358
1359     fn check_foreign_item(&mut self, cx: &LateContext<'_>, foreign_item: &hir::ForeignItem<'tcx>) {
1360         self.perform_lint(
1361             cx,
1362             "item",
1363             foreign_item.def_id,
1364             &foreign_item.vis,
1365             foreign_item.span,
1366             true,
1367         );
1368     }
1369
1370     fn check_field_def(&mut self, cx: &LateContext<'_>, field: &hir::FieldDef<'_>) {
1371         let def_id = cx.tcx.hir().local_def_id(field.hir_id);
1372         self.perform_lint(cx, "field", def_id, &field.vis, field.span, false);
1373     }
1374
1375     fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
1376         self.perform_lint(cx, "item", impl_item.def_id, &impl_item.vis, impl_item.span, false);
1377     }
1378 }
1379
1380 declare_lint! {
1381     /// The `type_alias_bounds` lint detects bounds in type aliases.
1382     ///
1383     /// ### Example
1384     ///
1385     /// ```rust
1386     /// type SendVec<T: Send> = Vec<T>;
1387     /// ```
1388     ///
1389     /// {{produces}}
1390     ///
1391     /// ### Explanation
1392     ///
1393     /// The trait bounds in a type alias are currently ignored, and should not
1394     /// be included to avoid confusion. This was previously allowed
1395     /// unintentionally; this may become a hard error in the future.
1396     TYPE_ALIAS_BOUNDS,
1397     Warn,
1398     "bounds in type aliases are not enforced"
1399 }
1400
1401 declare_lint_pass!(
1402     /// Lint for trait and lifetime bounds in type aliases being mostly ignored.
1403     /// They are relevant when using associated types, but otherwise neither checked
1404     /// at definition site nor enforced at use site.
1405     TypeAliasBounds => [TYPE_ALIAS_BOUNDS]
1406 );
1407
1408 impl TypeAliasBounds {
1409     fn is_type_variable_assoc(qpath: &hir::QPath<'_>) -> bool {
1410         match *qpath {
1411             hir::QPath::TypeRelative(ref ty, _) => {
1412                 // If this is a type variable, we found a `T::Assoc`.
1413                 match ty.kind {
1414                     hir::TyKind::Path(hir::QPath::Resolved(None, ref path)) => {
1415                         matches!(path.res, Res::Def(DefKind::TyParam, _))
1416                     }
1417                     _ => false,
1418                 }
1419             }
1420             hir::QPath::Resolved(..) | hir::QPath::LangItem(..) => false,
1421         }
1422     }
1423
1424     fn suggest_changing_assoc_types(ty: &hir::Ty<'_>, err: &mut DiagnosticBuilder<'_>) {
1425         // Access to associates types should use `<T as Bound>::Assoc`, which does not need a
1426         // bound.  Let's see if this type does that.
1427
1428         // We use a HIR visitor to walk the type.
1429         use rustc_hir::intravisit::{self, Visitor};
1430         struct WalkAssocTypes<'a, 'db> {
1431             err: &'a mut DiagnosticBuilder<'db>,
1432         }
1433         impl<'a, 'db, 'v> Visitor<'v> for WalkAssocTypes<'a, 'db> {
1434             type Map = intravisit::ErasedMap<'v>;
1435
1436             fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
1437                 intravisit::NestedVisitorMap::None
1438             }
1439
1440             fn visit_qpath(&mut self, qpath: &'v hir::QPath<'v>, id: hir::HirId, span: Span) {
1441                 if TypeAliasBounds::is_type_variable_assoc(qpath) {
1442                     self.err.span_help(
1443                         span,
1444                         "use fully disambiguated paths (i.e., `<T as Trait>::Assoc`) to refer to \
1445                          associated types in type aliases",
1446                     );
1447                 }
1448                 intravisit::walk_qpath(self, qpath, id, span)
1449             }
1450         }
1451
1452         // Let's go for a walk!
1453         let mut visitor = WalkAssocTypes { err };
1454         visitor.visit_ty(ty);
1455     }
1456 }
1457
1458 impl<'tcx> LateLintPass<'tcx> for TypeAliasBounds {
1459     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
1460         let (ty, type_alias_generics) = match item.kind {
1461             hir::ItemKind::TyAlias(ref ty, ref generics) => (&*ty, generics),
1462             _ => return,
1463         };
1464         if let hir::TyKind::OpaqueDef(..) = ty.kind {
1465             // Bounds are respected for `type X = impl Trait`
1466             return;
1467         }
1468         let mut suggested_changing_assoc_types = false;
1469         // There must not be a where clause
1470         if !type_alias_generics.where_clause.predicates.is_empty() {
1471             cx.lint(
1472                 TYPE_ALIAS_BOUNDS,
1473                 |lint| {
1474                     let mut err = lint.build("where clauses are not enforced in type aliases");
1475                     let spans: Vec<_> = type_alias_generics
1476                         .where_clause
1477                         .predicates
1478                         .iter()
1479                         .map(|pred| pred.span())
1480                         .collect();
1481                     err.set_span(spans);
1482                     err.span_suggestion(
1483                         type_alias_generics.where_clause.span_for_predicates_or_empty_place(),
1484                         "the clause will not be checked when the type alias is used, and should be removed",
1485                         String::new(),
1486                         Applicability::MachineApplicable,
1487                     );
1488                     if !suggested_changing_assoc_types {
1489                         TypeAliasBounds::suggest_changing_assoc_types(ty, &mut err);
1490                         suggested_changing_assoc_types = true;
1491                     }
1492                     err.emit();
1493                 },
1494             );
1495         }
1496         // The parameters must not have bounds
1497         for param in type_alias_generics.params.iter() {
1498             let spans: Vec<_> = param.bounds.iter().map(|b| b.span()).collect();
1499             let suggestion = spans
1500                 .iter()
1501                 .map(|sp| {
1502                     let start = param.span.between(*sp); // Include the `:` in `T: Bound`.
1503                     (start.to(*sp), String::new())
1504                 })
1505                 .collect();
1506             if !spans.is_empty() {
1507                 cx.struct_span_lint(TYPE_ALIAS_BOUNDS, spans, |lint| {
1508                     let mut err =
1509                         lint.build("bounds on generic parameters are not enforced in type aliases");
1510                     let msg = "the bound will not be checked when the type alias is used, \
1511                                    and should be removed";
1512                     err.multipart_suggestion(&msg, suggestion, Applicability::MachineApplicable);
1513                     if !suggested_changing_assoc_types {
1514                         TypeAliasBounds::suggest_changing_assoc_types(ty, &mut err);
1515                         suggested_changing_assoc_types = true;
1516                     }
1517                     err.emit();
1518                 });
1519             }
1520         }
1521     }
1522 }
1523
1524 declare_lint_pass!(
1525     /// Lint constants that are erroneous.
1526     /// Without this lint, we might not get any diagnostic if the constant is
1527     /// unused within this crate, even though downstream crates can't use it
1528     /// without producing an error.
1529     UnusedBrokenConst => []
1530 );
1531
1532 impl<'tcx> LateLintPass<'tcx> for UnusedBrokenConst {
1533     fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {
1534         match it.kind {
1535             hir::ItemKind::Const(_, body_id) => {
1536                 let def_id = cx.tcx.hir().body_owner_def_id(body_id).to_def_id();
1537                 // trigger the query once for all constants since that will already report the errors
1538                 // FIXME: Use ensure here
1539                 let _ = cx.tcx.const_eval_poly(def_id);
1540             }
1541             hir::ItemKind::Static(_, _, body_id) => {
1542                 let def_id = cx.tcx.hir().body_owner_def_id(body_id).to_def_id();
1543                 // FIXME: Use ensure here
1544                 let _ = cx.tcx.eval_static_initializer(def_id);
1545             }
1546             _ => {}
1547         }
1548     }
1549 }
1550
1551 declare_lint! {
1552     /// The `trivial_bounds` lint detects trait bounds that don't depend on
1553     /// any type parameters.
1554     ///
1555     /// ### Example
1556     ///
1557     /// ```rust
1558     /// #![feature(trivial_bounds)]
1559     /// pub struct A where i32: Copy;
1560     /// ```
1561     ///
1562     /// {{produces}}
1563     ///
1564     /// ### Explanation
1565     ///
1566     /// Usually you would not write a trait bound that you know is always
1567     /// true, or never true. However, when using macros, the macro may not
1568     /// know whether or not the constraint would hold or not at the time when
1569     /// generating the code. Currently, the compiler does not alert you if the
1570     /// constraint is always true, and generates an error if it is never true.
1571     /// The `trivial_bounds` feature changes this to be a warning in both
1572     /// cases, giving macros more freedom and flexibility to generate code,
1573     /// while still providing a signal when writing non-macro code that
1574     /// something is amiss.
1575     ///
1576     /// See [RFC 2056] for more details. This feature is currently only
1577     /// available on the nightly channel, see [tracking issue #48214].
1578     ///
1579     /// [RFC 2056]: https://github.com/rust-lang/rfcs/blob/master/text/2056-allow-trivial-where-clause-constraints.md
1580     /// [tracking issue #48214]: https://github.com/rust-lang/rust/issues/48214
1581     TRIVIAL_BOUNDS,
1582     Warn,
1583     "these bounds don't depend on an type parameters"
1584 }
1585
1586 declare_lint_pass!(
1587     /// Lint for trait and lifetime bounds that don't depend on type parameters
1588     /// which either do nothing, or stop the item from being used.
1589     TrivialConstraints => [TRIVIAL_BOUNDS]
1590 );
1591
1592 impl<'tcx> LateLintPass<'tcx> for TrivialConstraints {
1593     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
1594         use rustc_middle::ty::fold::TypeFoldable;
1595         use rustc_middle::ty::PredicateKind::*;
1596
1597         if cx.tcx.features().trivial_bounds {
1598             let predicates = cx.tcx.predicates_of(item.def_id);
1599             for &(predicate, span) in predicates.predicates {
1600                 let predicate_kind_name = match predicate.kind().skip_binder() {
1601                     Trait(..) => "Trait",
1602                     TypeOutlives(..) |
1603                     RegionOutlives(..) => "Lifetime",
1604
1605                     // Ignore projections, as they can only be global
1606                     // if the trait bound is global
1607                     Projection(..) |
1608                     // Ignore bounds that a user can't type
1609                     WellFormed(..) |
1610                     ObjectSafe(..) |
1611                     ClosureKind(..) |
1612                     Subtype(..) |
1613                     ConstEvaluatable(..) |
1614                     ConstEquate(..) |
1615                     TypeWellFormedFromEnv(..) => continue,
1616                 };
1617                 if predicate.is_global() {
1618                     cx.struct_span_lint(TRIVIAL_BOUNDS, span, |lint| {
1619                         lint.build(&format!(
1620                             "{} bound {} does not depend on any type \
1621                                 or lifetime parameters",
1622                             predicate_kind_name, predicate
1623                         ))
1624                         .emit()
1625                     });
1626                 }
1627             }
1628         }
1629     }
1630 }
1631
1632 declare_lint_pass!(
1633     /// Does nothing as a lint pass, but registers some `Lint`s
1634     /// which are used by other parts of the compiler.
1635     SoftLints => [
1636         WHILE_TRUE,
1637         BOX_POINTERS,
1638         NON_SHORTHAND_FIELD_PATTERNS,
1639         UNSAFE_CODE,
1640         MISSING_DOCS,
1641         MISSING_COPY_IMPLEMENTATIONS,
1642         MISSING_DEBUG_IMPLEMENTATIONS,
1643         ANONYMOUS_PARAMETERS,
1644         UNUSED_DOC_COMMENTS,
1645         NO_MANGLE_CONST_ITEMS,
1646         NO_MANGLE_GENERIC_ITEMS,
1647         MUTABLE_TRANSMUTES,
1648         UNSTABLE_FEATURES,
1649         UNREACHABLE_PUB,
1650         TYPE_ALIAS_BOUNDS,
1651         TRIVIAL_BOUNDS
1652     ]
1653 );
1654
1655 declare_lint! {
1656     /// The `ellipsis_inclusive_range_patterns` lint detects the [`...` range
1657     /// pattern], which is deprecated.
1658     ///
1659     /// [`...` range pattern]: https://doc.rust-lang.org/reference/patterns.html#range-patterns
1660     ///
1661     /// ### Example
1662     ///
1663     /// ```rust
1664     /// let x = 123;
1665     /// match x {
1666     ///     0...100 => {}
1667     ///     _ => {}
1668     /// }
1669     /// ```
1670     ///
1671     /// {{produces}}
1672     ///
1673     /// ### Explanation
1674     ///
1675     /// The `...` range pattern syntax was changed to `..=` to avoid potential
1676     /// confusion with the [`..` range expression]. Use the new form instead.
1677     ///
1678     /// [`..` range expression]: https://doc.rust-lang.org/reference/expressions/range-expr.html
1679     pub ELLIPSIS_INCLUSIVE_RANGE_PATTERNS,
1680     Warn,
1681     "`...` range patterns are deprecated",
1682     @future_incompatible = FutureIncompatibleInfo {
1683         reference: "issue #80165 <https://github.com/rust-lang/rust/issues/80165>",
1684         reason: FutureIncompatibilityReason::EditionError(Edition::Edition2021),
1685     };
1686 }
1687
1688 #[derive(Default)]
1689 pub struct EllipsisInclusiveRangePatterns {
1690     /// If `Some(_)`, suppress all subsequent pattern
1691     /// warnings for better diagnostics.
1692     node_id: Option<ast::NodeId>,
1693 }
1694
1695 impl_lint_pass!(EllipsisInclusiveRangePatterns => [ELLIPSIS_INCLUSIVE_RANGE_PATTERNS]);
1696
1697 impl EarlyLintPass for EllipsisInclusiveRangePatterns {
1698     fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &ast::Pat) {
1699         if self.node_id.is_some() {
1700             // Don't recursively warn about patterns inside range endpoints.
1701             return;
1702         }
1703
1704         use self::ast::{PatKind, RangeSyntax::DotDotDot};
1705
1706         /// If `pat` is a `...` pattern, return the start and end of the range, as well as the span
1707         /// corresponding to the ellipsis.
1708         fn matches_ellipsis_pat(pat: &ast::Pat) -> Option<(Option<&Expr>, &Expr, Span)> {
1709             match &pat.kind {
1710                 PatKind::Range(
1711                     a,
1712                     Some(b),
1713                     Spanned { span, node: RangeEnd::Included(DotDotDot) },
1714                 ) => Some((a.as_deref(), b, *span)),
1715                 _ => None,
1716             }
1717         }
1718
1719         let (parenthesise, endpoints) = match &pat.kind {
1720             PatKind::Ref(subpat, _) => (true, matches_ellipsis_pat(&subpat)),
1721             _ => (false, matches_ellipsis_pat(pat)),
1722         };
1723
1724         if let Some((start, end, join)) = endpoints {
1725             let msg = "`...` range patterns are deprecated";
1726             let suggestion = "use `..=` for an inclusive range";
1727             if parenthesise {
1728                 self.node_id = Some(pat.id);
1729                 let end = expr_to_string(&end);
1730                 let replace = match start {
1731                     Some(start) => format!("&({}..={})", expr_to_string(&start), end),
1732                     None => format!("&(..={})", end),
1733                 };
1734                 if join.edition() >= Edition::Edition2021 {
1735                     let mut err =
1736                         rustc_errors::struct_span_err!(cx.sess, pat.span, E0783, "{}", msg,);
1737                     err.span_suggestion(
1738                         pat.span,
1739                         suggestion,
1740                         replace,
1741                         Applicability::MachineApplicable,
1742                     )
1743                     .emit();
1744                 } else {
1745                     cx.struct_span_lint(ELLIPSIS_INCLUSIVE_RANGE_PATTERNS, pat.span, |lint| {
1746                         lint.build(msg)
1747                             .span_suggestion(
1748                                 pat.span,
1749                                 suggestion,
1750                                 replace,
1751                                 Applicability::MachineApplicable,
1752                             )
1753                             .emit();
1754                     });
1755                 }
1756             } else {
1757                 let replace = "..=".to_owned();
1758                 if join.edition() >= Edition::Edition2021 {
1759                     let mut err =
1760                         rustc_errors::struct_span_err!(cx.sess, pat.span, E0783, "{}", msg,);
1761                     err.span_suggestion_short(
1762                         join,
1763                         suggestion,
1764                         replace,
1765                         Applicability::MachineApplicable,
1766                     )
1767                     .emit();
1768                 } else {
1769                     cx.struct_span_lint(ELLIPSIS_INCLUSIVE_RANGE_PATTERNS, join, |lint| {
1770                         lint.build(msg)
1771                             .span_suggestion_short(
1772                                 join,
1773                                 suggestion,
1774                                 replace,
1775                                 Applicability::MachineApplicable,
1776                             )
1777                             .emit();
1778                     });
1779                 }
1780             };
1781         }
1782     }
1783
1784     fn check_pat_post(&mut self, _cx: &EarlyContext<'_>, pat: &ast::Pat) {
1785         if let Some(node_id) = self.node_id {
1786             if pat.id == node_id {
1787                 self.node_id = None
1788             }
1789         }
1790     }
1791 }
1792
1793 declare_lint! {
1794     /// The `unnameable_test_items` lint detects [`#[test]`][test] functions
1795     /// that are not able to be run by the test harness because they are in a
1796     /// position where they are not nameable.
1797     ///
1798     /// [test]: https://doc.rust-lang.org/reference/attributes/testing.html#the-test-attribute
1799     ///
1800     /// ### Example
1801     ///
1802     /// ```rust,test
1803     /// fn main() {
1804     ///     #[test]
1805     ///     fn foo() {
1806     ///         // This test will not fail because it does not run.
1807     ///         assert_eq!(1, 2);
1808     ///     }
1809     /// }
1810     /// ```
1811     ///
1812     /// {{produces}}
1813     ///
1814     /// ### Explanation
1815     ///
1816     /// In order for the test harness to run a test, the test function must be
1817     /// located in a position where it can be accessed from the crate root.
1818     /// This generally means it must be defined in a module, and not anywhere
1819     /// else such as inside another function. The compiler previously allowed
1820     /// this without an error, so a lint was added as an alert that a test is
1821     /// not being used. Whether or not this should be allowed has not yet been
1822     /// decided, see [RFC 2471] and [issue #36629].
1823     ///
1824     /// [RFC 2471]: https://github.com/rust-lang/rfcs/pull/2471#issuecomment-397414443
1825     /// [issue #36629]: https://github.com/rust-lang/rust/issues/36629
1826     UNNAMEABLE_TEST_ITEMS,
1827     Warn,
1828     "detects an item that cannot be named being marked as `#[test_case]`",
1829     report_in_external_macro
1830 }
1831
1832 pub struct UnnameableTestItems {
1833     boundary: Option<LocalDefId>, // Id of the item under which things are not nameable
1834     items_nameable: bool,
1835 }
1836
1837 impl_lint_pass!(UnnameableTestItems => [UNNAMEABLE_TEST_ITEMS]);
1838
1839 impl UnnameableTestItems {
1840     pub fn new() -> Self {
1841         Self { boundary: None, items_nameable: true }
1842     }
1843 }
1844
1845 impl<'tcx> LateLintPass<'tcx> for UnnameableTestItems {
1846     fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {
1847         if self.items_nameable {
1848             if let hir::ItemKind::Mod(..) = it.kind {
1849             } else {
1850                 self.items_nameable = false;
1851                 self.boundary = Some(it.def_id);
1852             }
1853             return;
1854         }
1855
1856         let attrs = cx.tcx.hir().attrs(it.hir_id());
1857         if let Some(attr) = cx.sess().find_by_name(attrs, sym::rustc_test_marker) {
1858             cx.struct_span_lint(UNNAMEABLE_TEST_ITEMS, attr.span, |lint| {
1859                 lint.build("cannot test inner items").emit()
1860             });
1861         }
1862     }
1863
1864     fn check_item_post(&mut self, _cx: &LateContext<'_>, it: &hir::Item<'_>) {
1865         if !self.items_nameable && self.boundary == Some(it.def_id) {
1866             self.items_nameable = true;
1867         }
1868     }
1869 }
1870
1871 declare_lint! {
1872     /// The `keyword_idents` lint detects edition keywords being used as an
1873     /// identifier.
1874     ///
1875     /// ### Example
1876     ///
1877     /// ```rust,edition2015,compile_fail
1878     /// #![deny(keyword_idents)]
1879     /// // edition 2015
1880     /// fn dyn() {}
1881     /// ```
1882     ///
1883     /// {{produces}}
1884     ///
1885     /// ### Explanation
1886     ///
1887     /// Rust [editions] allow the language to evolve without breaking
1888     /// backwards compatibility. This lint catches code that uses new keywords
1889     /// that are added to the language that are used as identifiers (such as a
1890     /// variable name, function name, etc.). If you switch the compiler to a
1891     /// new edition without updating the code, then it will fail to compile if
1892     /// you are using a new keyword as an identifier.
1893     ///
1894     /// You can manually change the identifiers to a non-keyword, or use a
1895     /// [raw identifier], for example `r#dyn`, to transition to a new edition.
1896     ///
1897     /// This lint solves the problem automatically. It is "allow" by default
1898     /// because the code is perfectly valid in older editions. The [`cargo
1899     /// fix`] tool with the `--edition` flag will switch this lint to "warn"
1900     /// and automatically apply the suggested fix from the compiler (which is
1901     /// to use a raw identifier). This provides a completely automated way to
1902     /// update old code for a new edition.
1903     ///
1904     /// [editions]: https://doc.rust-lang.org/edition-guide/
1905     /// [raw identifier]: https://doc.rust-lang.org/reference/identifiers.html
1906     /// [`cargo fix`]: https://doc.rust-lang.org/cargo/commands/cargo-fix.html
1907     pub KEYWORD_IDENTS,
1908     Allow,
1909     "detects edition keywords being used as an identifier",
1910     @future_incompatible = FutureIncompatibleInfo {
1911         reference: "issue #49716 <https://github.com/rust-lang/rust/issues/49716>",
1912         reason: FutureIncompatibilityReason::EditionError(Edition::Edition2018),
1913     };
1914 }
1915
1916 declare_lint_pass!(
1917     /// Check for uses of edition keywords used as an identifier.
1918     KeywordIdents => [KEYWORD_IDENTS]
1919 );
1920
1921 struct UnderMacro(bool);
1922
1923 impl KeywordIdents {
1924     fn check_tokens(&mut self, cx: &EarlyContext<'_>, tokens: TokenStream) {
1925         for tt in tokens.into_trees() {
1926             match tt {
1927                 // Only report non-raw idents.
1928                 TokenTree::Token(token) => {
1929                     if let Some((ident, false)) = token.ident() {
1930                         self.check_ident_token(cx, UnderMacro(true), ident);
1931                     }
1932                 }
1933                 TokenTree::Delimited(_, _, tts) => self.check_tokens(cx, tts),
1934             }
1935         }
1936     }
1937
1938     fn check_ident_token(
1939         &mut self,
1940         cx: &EarlyContext<'_>,
1941         UnderMacro(under_macro): UnderMacro,
1942         ident: Ident,
1943     ) {
1944         let next_edition = match cx.sess.edition() {
1945             Edition::Edition2015 => {
1946                 match ident.name {
1947                     kw::Async | kw::Await | kw::Try => Edition::Edition2018,
1948
1949                     // rust-lang/rust#56327: Conservatively do not
1950                     // attempt to report occurrences of `dyn` within
1951                     // macro definitions or invocations, because `dyn`
1952                     // can legitimately occur as a contextual keyword
1953                     // in 2015 code denoting its 2018 meaning, and we
1954                     // do not want rustfix to inject bugs into working
1955                     // code by rewriting such occurrences.
1956                     //
1957                     // But if we see `dyn` outside of a macro, we know
1958                     // its precise role in the parsed AST and thus are
1959                     // assured this is truly an attempt to use it as
1960                     // an identifier.
1961                     kw::Dyn if !under_macro => Edition::Edition2018,
1962
1963                     _ => return,
1964                 }
1965             }
1966
1967             // There are no new keywords yet for the 2018 edition and beyond.
1968             _ => return,
1969         };
1970
1971         // Don't lint `r#foo`.
1972         if cx.sess.parse_sess.raw_identifier_spans.borrow().contains(&ident.span) {
1973             return;
1974         }
1975
1976         cx.struct_span_lint(KEYWORD_IDENTS, ident.span, |lint| {
1977             lint.build(&format!("`{}` is a keyword in the {} edition", ident, next_edition))
1978                 .span_suggestion(
1979                     ident.span,
1980                     "you can use a raw identifier to stay compatible",
1981                     format!("r#{}", ident),
1982                     Applicability::MachineApplicable,
1983                 )
1984                 .emit()
1985         });
1986     }
1987 }
1988
1989 impl EarlyLintPass for KeywordIdents {
1990     fn check_mac_def(&mut self, cx: &EarlyContext<'_>, mac_def: &ast::MacroDef, _id: ast::NodeId) {
1991         self.check_tokens(cx, mac_def.body.inner_tokens());
1992     }
1993     fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &ast::MacCall) {
1994         self.check_tokens(cx, mac.args.inner_tokens());
1995     }
1996     fn check_ident(&mut self, cx: &EarlyContext<'_>, ident: Ident) {
1997         self.check_ident_token(cx, UnderMacro(false), ident);
1998     }
1999 }
2000
2001 declare_lint_pass!(ExplicitOutlivesRequirements => [EXPLICIT_OUTLIVES_REQUIREMENTS]);
2002
2003 impl ExplicitOutlivesRequirements {
2004     fn lifetimes_outliving_lifetime<'tcx>(
2005         inferred_outlives: &'tcx [(ty::Predicate<'tcx>, Span)],
2006         index: u32,
2007     ) -> Vec<ty::Region<'tcx>> {
2008         inferred_outlives
2009             .iter()
2010             .filter_map(|(pred, _)| match pred.kind().skip_binder() {
2011                 ty::PredicateKind::RegionOutlives(ty::OutlivesPredicate(a, b)) => match a {
2012                     ty::ReEarlyBound(ebr) if ebr.index == index => Some(b),
2013                     _ => None,
2014                 },
2015                 _ => None,
2016             })
2017             .collect()
2018     }
2019
2020     fn lifetimes_outliving_type<'tcx>(
2021         inferred_outlives: &'tcx [(ty::Predicate<'tcx>, Span)],
2022         index: u32,
2023     ) -> Vec<ty::Region<'tcx>> {
2024         inferred_outlives
2025             .iter()
2026             .filter_map(|(pred, _)| match pred.kind().skip_binder() {
2027                 ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(a, b)) => {
2028                     a.is_param(index).then_some(b)
2029                 }
2030                 _ => None,
2031             })
2032             .collect()
2033     }
2034
2035     fn collect_outlived_lifetimes<'tcx>(
2036         &self,
2037         param: &'tcx hir::GenericParam<'tcx>,
2038         tcx: TyCtxt<'tcx>,
2039         inferred_outlives: &'tcx [(ty::Predicate<'tcx>, Span)],
2040         ty_generics: &'tcx ty::Generics,
2041     ) -> Vec<ty::Region<'tcx>> {
2042         let index =
2043             ty_generics.param_def_id_to_index[&tcx.hir().local_def_id(param.hir_id).to_def_id()];
2044
2045         match param.kind {
2046             hir::GenericParamKind::Lifetime { .. } => {
2047                 Self::lifetimes_outliving_lifetime(inferred_outlives, index)
2048             }
2049             hir::GenericParamKind::Type { .. } => {
2050                 Self::lifetimes_outliving_type(inferred_outlives, index)
2051             }
2052             hir::GenericParamKind::Const { .. } => Vec::new(),
2053         }
2054     }
2055
2056     fn collect_outlives_bound_spans<'tcx>(
2057         &self,
2058         tcx: TyCtxt<'tcx>,
2059         bounds: &hir::GenericBounds<'_>,
2060         inferred_outlives: &[ty::Region<'tcx>],
2061         infer_static: bool,
2062     ) -> Vec<(usize, Span)> {
2063         use rustc_middle::middle::resolve_lifetime::Region;
2064
2065         bounds
2066             .iter()
2067             .enumerate()
2068             .filter_map(|(i, bound)| {
2069                 if let hir::GenericBound::Outlives(lifetime) = bound {
2070                     let is_inferred = match tcx.named_region(lifetime.hir_id) {
2071                         Some(Region::Static) if infer_static => {
2072                             inferred_outlives.iter().any(|r| matches!(r, ty::ReStatic))
2073                         }
2074                         Some(Region::EarlyBound(index, ..)) => inferred_outlives.iter().any(|r| {
2075                             if let ty::ReEarlyBound(ebr) = r { ebr.index == index } else { false }
2076                         }),
2077                         _ => false,
2078                     };
2079                     is_inferred.then_some((i, bound.span()))
2080                 } else {
2081                     None
2082                 }
2083             })
2084             .collect()
2085     }
2086
2087     fn consolidate_outlives_bound_spans(
2088         &self,
2089         lo: Span,
2090         bounds: &hir::GenericBounds<'_>,
2091         bound_spans: Vec<(usize, Span)>,
2092     ) -> Vec<Span> {
2093         if bounds.is_empty() {
2094             return Vec::new();
2095         }
2096         if bound_spans.len() == bounds.len() {
2097             let (_, last_bound_span) = bound_spans[bound_spans.len() - 1];
2098             // If all bounds are inferable, we want to delete the colon, so
2099             // start from just after the parameter (span passed as argument)
2100             vec![lo.to(last_bound_span)]
2101         } else {
2102             let mut merged = Vec::new();
2103             let mut last_merged_i = None;
2104
2105             let mut from_start = true;
2106             for (i, bound_span) in bound_spans {
2107                 match last_merged_i {
2108                     // If the first bound is inferable, our span should also eat the leading `+`.
2109                     None if i == 0 => {
2110                         merged.push(bound_span.to(bounds[1].span().shrink_to_lo()));
2111                         last_merged_i = Some(0);
2112                     }
2113                     // If consecutive bounds are inferable, merge their spans
2114                     Some(h) if i == h + 1 => {
2115                         if let Some(tail) = merged.last_mut() {
2116                             // Also eat the trailing `+` if the first
2117                             // more-than-one bound is inferable
2118                             let to_span = if from_start && i < bounds.len() {
2119                                 bounds[i + 1].span().shrink_to_lo()
2120                             } else {
2121                                 bound_span
2122                             };
2123                             *tail = tail.to(to_span);
2124                             last_merged_i = Some(i);
2125                         } else {
2126                             bug!("another bound-span visited earlier");
2127                         }
2128                     }
2129                     _ => {
2130                         // When we find a non-inferable bound, subsequent inferable bounds
2131                         // won't be consecutive from the start (and we'll eat the leading
2132                         // `+` rather than the trailing one)
2133                         from_start = false;
2134                         merged.push(bounds[i - 1].span().shrink_to_hi().to(bound_span));
2135                         last_merged_i = Some(i);
2136                     }
2137                 }
2138             }
2139             merged
2140         }
2141     }
2142 }
2143
2144 impl<'tcx> LateLintPass<'tcx> for ExplicitOutlivesRequirements {
2145     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
2146         use rustc_middle::middle::resolve_lifetime::Region;
2147
2148         let infer_static = cx.tcx.features().infer_static_outlives_requirements;
2149         let def_id = item.def_id;
2150         if let hir::ItemKind::Struct(_, ref hir_generics)
2151         | hir::ItemKind::Enum(_, ref hir_generics)
2152         | hir::ItemKind::Union(_, ref hir_generics) = item.kind
2153         {
2154             let inferred_outlives = cx.tcx.inferred_outlives_of(def_id);
2155             if inferred_outlives.is_empty() {
2156                 return;
2157             }
2158
2159             let ty_generics = cx.tcx.generics_of(def_id);
2160
2161             let mut bound_count = 0;
2162             let mut lint_spans = Vec::new();
2163
2164             for param in hir_generics.params {
2165                 let has_lifetime_bounds = param
2166                     .bounds
2167                     .iter()
2168                     .any(|bound| matches!(bound, hir::GenericBound::Outlives(_)));
2169                 if !has_lifetime_bounds {
2170                     continue;
2171                 }
2172
2173                 let relevant_lifetimes =
2174                     self.collect_outlived_lifetimes(param, cx.tcx, inferred_outlives, ty_generics);
2175                 if relevant_lifetimes.is_empty() {
2176                     continue;
2177                 }
2178
2179                 let bound_spans = self.collect_outlives_bound_spans(
2180                     cx.tcx,
2181                     &param.bounds,
2182                     &relevant_lifetimes,
2183                     infer_static,
2184                 );
2185                 bound_count += bound_spans.len();
2186                 lint_spans.extend(self.consolidate_outlives_bound_spans(
2187                     param.span.shrink_to_hi(),
2188                     &param.bounds,
2189                     bound_spans,
2190                 ));
2191             }
2192
2193             let mut where_lint_spans = Vec::new();
2194             let mut dropped_predicate_count = 0;
2195             let num_predicates = hir_generics.where_clause.predicates.len();
2196             for (i, where_predicate) in hir_generics.where_clause.predicates.iter().enumerate() {
2197                 let (relevant_lifetimes, bounds, span) = match where_predicate {
2198                     hir::WherePredicate::RegionPredicate(predicate) => {
2199                         if let Some(Region::EarlyBound(index, ..)) =
2200                             cx.tcx.named_region(predicate.lifetime.hir_id)
2201                         {
2202                             (
2203                                 Self::lifetimes_outliving_lifetime(inferred_outlives, index),
2204                                 &predicate.bounds,
2205                                 predicate.span,
2206                             )
2207                         } else {
2208                             continue;
2209                         }
2210                     }
2211                     hir::WherePredicate::BoundPredicate(predicate) => {
2212                         // FIXME we can also infer bounds on associated types,
2213                         // and should check for them here.
2214                         match predicate.bounded_ty.kind {
2215                             hir::TyKind::Path(hir::QPath::Resolved(None, ref path)) => {
2216                                 if let Res::Def(DefKind::TyParam, def_id) = path.res {
2217                                     let index = ty_generics.param_def_id_to_index[&def_id];
2218                                     (
2219                                         Self::lifetimes_outliving_type(inferred_outlives, index),
2220                                         &predicate.bounds,
2221                                         predicate.span,
2222                                     )
2223                                 } else {
2224                                     continue;
2225                                 }
2226                             }
2227                             _ => {
2228                                 continue;
2229                             }
2230                         }
2231                     }
2232                     _ => continue,
2233                 };
2234                 if relevant_lifetimes.is_empty() {
2235                     continue;
2236                 }
2237
2238                 let bound_spans = self.collect_outlives_bound_spans(
2239                     cx.tcx,
2240                     bounds,
2241                     &relevant_lifetimes,
2242                     infer_static,
2243                 );
2244                 bound_count += bound_spans.len();
2245
2246                 let drop_predicate = bound_spans.len() == bounds.len();
2247                 if drop_predicate {
2248                     dropped_predicate_count += 1;
2249                 }
2250
2251                 // If all the bounds on a predicate were inferable and there are
2252                 // further predicates, we want to eat the trailing comma.
2253                 if drop_predicate && i + 1 < num_predicates {
2254                     let next_predicate_span = hir_generics.where_clause.predicates[i + 1].span();
2255                     where_lint_spans.push(span.to(next_predicate_span.shrink_to_lo()));
2256                 } else {
2257                     where_lint_spans.extend(self.consolidate_outlives_bound_spans(
2258                         span.shrink_to_lo(),
2259                         bounds,
2260                         bound_spans,
2261                     ));
2262                 }
2263             }
2264
2265             // If all predicates are inferable, drop the entire clause
2266             // (including the `where`)
2267             if num_predicates > 0 && dropped_predicate_count == num_predicates {
2268                 let where_span = hir_generics
2269                     .where_clause
2270                     .span()
2271                     .expect("span of (nonempty) where clause should exist");
2272                 // Extend the where clause back to the closing `>` of the
2273                 // generics, except for tuple struct, which have the `where`
2274                 // after the fields of the struct.
2275                 let full_where_span =
2276                     if let hir::ItemKind::Struct(hir::VariantData::Tuple(..), _) = item.kind {
2277                         where_span
2278                     } else {
2279                         hir_generics.span.shrink_to_hi().to(where_span)
2280                     };
2281                 lint_spans.push(full_where_span);
2282             } else {
2283                 lint_spans.extend(where_lint_spans);
2284             }
2285
2286             if !lint_spans.is_empty() {
2287                 cx.struct_span_lint(EXPLICIT_OUTLIVES_REQUIREMENTS, lint_spans.clone(), |lint| {
2288                     lint.build("outlives requirements can be inferred")
2289                         .multipart_suggestion(
2290                             if bound_count == 1 {
2291                                 "remove this bound"
2292                             } else {
2293                                 "remove these bounds"
2294                             },
2295                             lint_spans
2296                                 .into_iter()
2297                                 .map(|span| (span, "".to_owned()))
2298                                 .collect::<Vec<_>>(),
2299                             Applicability::MachineApplicable,
2300                         )
2301                         .emit();
2302                 });
2303             }
2304         }
2305     }
2306 }
2307
2308 declare_lint! {
2309     /// The `incomplete_features` lint detects unstable features enabled with
2310     /// the [`feature` attribute] that may function improperly in some or all
2311     /// cases.
2312     ///
2313     /// [`feature` attribute]: https://doc.rust-lang.org/nightly/unstable-book/
2314     ///
2315     /// ### Example
2316     ///
2317     /// ```rust
2318     /// #![feature(const_generics)]
2319     /// ```
2320     ///
2321     /// {{produces}}
2322     ///
2323     /// ### Explanation
2324     ///
2325     /// Although it is encouraged for people to experiment with unstable
2326     /// features, some of them are known to be incomplete or faulty. This lint
2327     /// is a signal that the feature has not yet been finished, and you may
2328     /// experience problems with it.
2329     pub INCOMPLETE_FEATURES,
2330     Warn,
2331     "incomplete features that may function improperly in some or all cases"
2332 }
2333
2334 declare_lint_pass!(
2335     /// Check for used feature gates in `INCOMPLETE_FEATURES` in `rustc_feature/src/active.rs`.
2336     IncompleteFeatures => [INCOMPLETE_FEATURES]
2337 );
2338
2339 impl EarlyLintPass for IncompleteFeatures {
2340     fn check_crate(&mut self, cx: &EarlyContext<'_>, _: &ast::Crate) {
2341         let features = cx.sess.features_untracked();
2342         features
2343             .declared_lang_features
2344             .iter()
2345             .map(|(name, span, _)| (name, span))
2346             .chain(features.declared_lib_features.iter().map(|(name, span)| (name, span)))
2347             .filter(|(&name, _)| features.incomplete(name))
2348             .for_each(|(&name, &span)| {
2349                 cx.struct_span_lint(INCOMPLETE_FEATURES, span, |lint| {
2350                     let mut builder = lint.build(&format!(
2351                         "the feature `{}` is incomplete and may not be safe to use \
2352                          and/or cause compiler crashes",
2353                         name,
2354                     ));
2355                     if let Some(n) = rustc_feature::find_feature_issue(name, GateIssue::Language) {
2356                         builder.note(&format!(
2357                             "see issue #{} <https://github.com/rust-lang/rust/issues/{}> \
2358                              for more information",
2359                             n, n,
2360                         ));
2361                     }
2362                     if HAS_MIN_FEATURES.contains(&name) {
2363                         builder.help(&format!(
2364                             "consider using `min_{}` instead, which is more stable and complete",
2365                             name,
2366                         ));
2367                     }
2368                     builder.emit();
2369                 })
2370             });
2371     }
2372 }
2373
2374 const HAS_MIN_FEATURES: &[Symbol] = &[sym::specialization];
2375
2376 declare_lint! {
2377     /// The `invalid_value` lint detects creating a value that is not valid,
2378     /// such as a null reference.
2379     ///
2380     /// ### Example
2381     ///
2382     /// ```rust,no_run
2383     /// # #![allow(unused)]
2384     /// unsafe {
2385     ///     let x: &'static i32 = std::mem::zeroed();
2386     /// }
2387     /// ```
2388     ///
2389     /// {{produces}}
2390     ///
2391     /// ### Explanation
2392     ///
2393     /// In some situations the compiler can detect that the code is creating
2394     /// an invalid value, which should be avoided.
2395     ///
2396     /// In particular, this lint will check for improper use of
2397     /// [`mem::zeroed`], [`mem::uninitialized`], [`mem::transmute`], and
2398     /// [`MaybeUninit::assume_init`] that can cause [undefined behavior]. The
2399     /// lint should provide extra information to indicate what the problem is
2400     /// and a possible solution.
2401     ///
2402     /// [`mem::zeroed`]: https://doc.rust-lang.org/std/mem/fn.zeroed.html
2403     /// [`mem::uninitialized`]: https://doc.rust-lang.org/std/mem/fn.uninitialized.html
2404     /// [`mem::transmute`]: https://doc.rust-lang.org/std/mem/fn.transmute.html
2405     /// [`MaybeUninit::assume_init`]: https://doc.rust-lang.org/std/mem/union.MaybeUninit.html#method.assume_init
2406     /// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
2407     pub INVALID_VALUE,
2408     Warn,
2409     "an invalid value is being created (such as a null reference)"
2410 }
2411
2412 declare_lint_pass!(InvalidValue => [INVALID_VALUE]);
2413
2414 impl<'tcx> LateLintPass<'tcx> for InvalidValue {
2415     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) {
2416         #[derive(Debug, Copy, Clone, PartialEq)]
2417         enum InitKind {
2418             Zeroed,
2419             Uninit,
2420         }
2421
2422         /// Information about why a type cannot be initialized this way.
2423         /// Contains an error message and optionally a span to point at.
2424         type InitError = (String, Option<Span>);
2425
2426         /// Test if this constant is all-0.
2427         fn is_zero(expr: &hir::Expr<'_>) -> bool {
2428             use hir::ExprKind::*;
2429             use rustc_ast::LitKind::*;
2430             match &expr.kind {
2431                 Lit(lit) => {
2432                     if let Int(i, _) = lit.node {
2433                         i == 0
2434                     } else {
2435                         false
2436                     }
2437                 }
2438                 Tup(tup) => tup.iter().all(is_zero),
2439                 _ => false,
2440             }
2441         }
2442
2443         /// Determine if this expression is a "dangerous initialization".
2444         fn is_dangerous_init(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<InitKind> {
2445             if let hir::ExprKind::Call(ref path_expr, ref args) = expr.kind {
2446                 // Find calls to `mem::{uninitialized,zeroed}` methods.
2447                 if let hir::ExprKind::Path(ref qpath) = path_expr.kind {
2448                     let def_id = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id()?;
2449
2450                     if cx.tcx.is_diagnostic_item(sym::mem_zeroed, def_id) {
2451                         return Some(InitKind::Zeroed);
2452                     } else if cx.tcx.is_diagnostic_item(sym::mem_uninitialized, def_id) {
2453                         return Some(InitKind::Uninit);
2454                     } else if cx.tcx.is_diagnostic_item(sym::transmute, def_id) && is_zero(&args[0])
2455                     {
2456                         return Some(InitKind::Zeroed);
2457                     }
2458                 }
2459             } else if let hir::ExprKind::MethodCall(_, _, ref args, _) = expr.kind {
2460                 // Find problematic calls to `MaybeUninit::assume_init`.
2461                 let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
2462                 if cx.tcx.is_diagnostic_item(sym::assume_init, def_id) {
2463                     // This is a call to *some* method named `assume_init`.
2464                     // See if the `self` parameter is one of the dangerous constructors.
2465                     if let hir::ExprKind::Call(ref path_expr, _) = args[0].kind {
2466                         if let hir::ExprKind::Path(ref qpath) = path_expr.kind {
2467                             let def_id = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id()?;
2468
2469                             if cx.tcx.is_diagnostic_item(sym::maybe_uninit_zeroed, def_id) {
2470                                 return Some(InitKind::Zeroed);
2471                             } else if cx.tcx.is_diagnostic_item(sym::maybe_uninit_uninit, def_id) {
2472                                 return Some(InitKind::Uninit);
2473                             }
2474                         }
2475                     }
2476                 }
2477             }
2478
2479             None
2480         }
2481
2482         /// Test if this enum has several actually "existing" variants.
2483         /// Zero-sized uninhabited variants do not always have a tag assigned and thus do not "exist".
2484         fn is_multi_variant(adt: &ty::AdtDef) -> bool {
2485             // As an approximation, we only count dataless variants. Those are definitely inhabited.
2486             let existing_variants = adt.variants.iter().filter(|v| v.fields.is_empty()).count();
2487             existing_variants > 1
2488         }
2489
2490         /// Return `Some` only if we are sure this type does *not*
2491         /// allow zero initialization.
2492         fn ty_find_init_error<'tcx>(
2493             tcx: TyCtxt<'tcx>,
2494             ty: Ty<'tcx>,
2495             init: InitKind,
2496         ) -> Option<InitError> {
2497             use rustc_middle::ty::TyKind::*;
2498             match ty.kind() {
2499                 // Primitive types that don't like 0 as a value.
2500                 Ref(..) => Some(("references must be non-null".to_string(), None)),
2501                 Adt(..) if ty.is_box() => Some(("`Box` must be non-null".to_string(), None)),
2502                 FnPtr(..) => Some(("function pointers must be non-null".to_string(), None)),
2503                 Never => Some(("the `!` type has no valid value".to_string(), None)),
2504                 RawPtr(tm) if matches!(tm.ty.kind(), Dynamic(..)) =>
2505                 // raw ptr to dyn Trait
2506                 {
2507                     Some(("the vtable of a wide raw pointer must be non-null".to_string(), None))
2508                 }
2509                 // Primitive types with other constraints.
2510                 Bool if init == InitKind::Uninit => {
2511                     Some(("booleans must be either `true` or `false`".to_string(), None))
2512                 }
2513                 Char if init == InitKind::Uninit => {
2514                     Some(("characters must be a valid Unicode codepoint".to_string(), None))
2515                 }
2516                 // Recurse and checks for some compound types.
2517                 Adt(adt_def, substs) if !adt_def.is_union() => {
2518                     // First check if this ADT has a layout attribute (like `NonNull` and friends).
2519                     use std::ops::Bound;
2520                     match tcx.layout_scalar_valid_range(adt_def.did) {
2521                         // We exploit here that `layout_scalar_valid_range` will never
2522                         // return `Bound::Excluded`.  (And we have tests checking that we
2523                         // handle the attribute correctly.)
2524                         (Bound::Included(lo), _) if lo > 0 => {
2525                             return Some((format!("`{}` must be non-null", ty), None));
2526                         }
2527                         (Bound::Included(_), _) | (_, Bound::Included(_))
2528                             if init == InitKind::Uninit =>
2529                         {
2530                             return Some((
2531                                 format!(
2532                                     "`{}` must be initialized inside its custom valid range",
2533                                     ty,
2534                                 ),
2535                                 None,
2536                             ));
2537                         }
2538                         _ => {}
2539                     }
2540                     // Now, recurse.
2541                     match adt_def.variants.len() {
2542                         0 => Some(("enums with no variants have no valid value".to_string(), None)),
2543                         1 => {
2544                             // Struct, or enum with exactly one variant.
2545                             // Proceed recursively, check all fields.
2546                             let variant = &adt_def.variants[VariantIdx::from_u32(0)];
2547                             variant.fields.iter().find_map(|field| {
2548                                 ty_find_init_error(tcx, field.ty(tcx, substs), init).map(
2549                                     |(mut msg, span)| {
2550                                         if span.is_none() {
2551                                             // Point to this field, should be helpful for figuring
2552                                             // out where the source of the error is.
2553                                             let span = tcx.def_span(field.did);
2554                                             write!(
2555                                                 &mut msg,
2556                                                 " (in this {} field)",
2557                                                 adt_def.descr()
2558                                             )
2559                                             .unwrap();
2560                                             (msg, Some(span))
2561                                         } else {
2562                                             // Just forward.
2563                                             (msg, span)
2564                                         }
2565                                     },
2566                                 )
2567                             })
2568                         }
2569                         // Multi-variant enum.
2570                         _ => {
2571                             if init == InitKind::Uninit && is_multi_variant(adt_def) {
2572                                 let span = tcx.def_span(adt_def.did);
2573                                 Some((
2574                                     "enums have to be initialized to a variant".to_string(),
2575                                     Some(span),
2576                                 ))
2577                             } else {
2578                                 // In principle, for zero-initialization we could figure out which variant corresponds
2579                                 // to tag 0, and check that... but for now we just accept all zero-initializations.
2580                                 None
2581                             }
2582                         }
2583                     }
2584                 }
2585                 Tuple(..) => {
2586                     // Proceed recursively, check all fields.
2587                     ty.tuple_fields().find_map(|field| ty_find_init_error(tcx, field, init))
2588                 }
2589                 // Conservative fallback.
2590                 _ => None,
2591             }
2592         }
2593
2594         if let Some(init) = is_dangerous_init(cx, expr) {
2595             // This conjures an instance of a type out of nothing,
2596             // using zeroed or uninitialized memory.
2597             // We are extremely conservative with what we warn about.
2598             let conjured_ty = cx.typeck_results().expr_ty(expr);
2599             if let Some((msg, span)) =
2600                 with_no_trimmed_paths(|| ty_find_init_error(cx.tcx, conjured_ty, init))
2601             {
2602                 cx.struct_span_lint(INVALID_VALUE, expr.span, |lint| {
2603                     let mut err = lint.build(&format!(
2604                         "the type `{}` does not permit {}",
2605                         conjured_ty,
2606                         match init {
2607                             InitKind::Zeroed => "zero-initialization",
2608                             InitKind::Uninit => "being left uninitialized",
2609                         },
2610                     ));
2611                     err.span_label(expr.span, "this code causes undefined behavior when executed");
2612                     err.span_label(
2613                         expr.span,
2614                         "help: use `MaybeUninit<T>` instead, \
2615                             and only call `assume_init` after initialization is done",
2616                     );
2617                     if let Some(span) = span {
2618                         err.span_note(span, &msg);
2619                     } else {
2620                         err.note(&msg);
2621                     }
2622                     err.emit();
2623                 });
2624             }
2625         }
2626     }
2627 }
2628
2629 declare_lint! {
2630     /// The `clashing_extern_declarations` lint detects when an `extern fn`
2631     /// has been declared with the same name but different types.
2632     ///
2633     /// ### Example
2634     ///
2635     /// ```rust
2636     /// mod m {
2637     ///     extern "C" {
2638     ///         fn foo();
2639     ///     }
2640     /// }
2641     ///
2642     /// extern "C" {
2643     ///     fn foo(_: u32);
2644     /// }
2645     /// ```
2646     ///
2647     /// {{produces}}
2648     ///
2649     /// ### Explanation
2650     ///
2651     /// Because two symbols of the same name cannot be resolved to two
2652     /// different functions at link time, and one function cannot possibly
2653     /// have two types, a clashing extern declaration is almost certainly a
2654     /// mistake. Check to make sure that the `extern` definitions are correct
2655     /// and equivalent, and possibly consider unifying them in one location.
2656     ///
2657     /// This lint does not run between crates because a project may have
2658     /// dependencies which both rely on the same extern function, but declare
2659     /// it in a different (but valid) way. For example, they may both declare
2660     /// an opaque type for one or more of the arguments (which would end up
2661     /// distinct types), or use types that are valid conversions in the
2662     /// language the `extern fn` is defined in. In these cases, the compiler
2663     /// can't say that the clashing declaration is incorrect.
2664     pub CLASHING_EXTERN_DECLARATIONS,
2665     Warn,
2666     "detects when an extern fn has been declared with the same name but different types"
2667 }
2668
2669 pub struct ClashingExternDeclarations {
2670     /// Map of function symbol name to the first-seen hir id for that symbol name.. If seen_decls
2671     /// contains an entry for key K, it means a symbol with name K has been seen by this lint and
2672     /// the symbol should be reported as a clashing declaration.
2673     // FIXME: Technically, we could just store a &'tcx str here without issue; however, the
2674     // `impl_lint_pass` macro doesn't currently support lints parametric over a lifetime.
2675     seen_decls: FxHashMap<Symbol, HirId>,
2676 }
2677
2678 /// Differentiate between whether the name for an extern decl came from the link_name attribute or
2679 /// just from declaration itself. This is important because we don't want to report clashes on
2680 /// symbol name if they don't actually clash because one or the other links against a symbol with a
2681 /// different name.
2682 enum SymbolName {
2683     /// The name of the symbol + the span of the annotation which introduced the link name.
2684     Link(Symbol, Span),
2685     /// No link name, so just the name of the symbol.
2686     Normal(Symbol),
2687 }
2688
2689 impl SymbolName {
2690     fn get_name(&self) -> Symbol {
2691         match self {
2692             SymbolName::Link(s, _) | SymbolName::Normal(s) => *s,
2693         }
2694     }
2695 }
2696
2697 impl ClashingExternDeclarations {
2698     crate fn new() -> Self {
2699         ClashingExternDeclarations { seen_decls: FxHashMap::default() }
2700     }
2701     /// Insert a new foreign item into the seen set. If a symbol with the same name already exists
2702     /// for the item, return its HirId without updating the set.
2703     fn insert(&mut self, tcx: TyCtxt<'_>, fi: &hir::ForeignItem<'_>) -> Option<HirId> {
2704         let did = fi.def_id.to_def_id();
2705         let instance = Instance::new(did, ty::List::identity_for_item(tcx, did));
2706         let name = Symbol::intern(tcx.symbol_name(instance).name);
2707         if let Some(&hir_id) = self.seen_decls.get(&name) {
2708             // Avoid updating the map with the new entry when we do find a collision. We want to
2709             // make sure we're always pointing to the first definition as the previous declaration.
2710             // This lets us avoid emitting "knock-on" diagnostics.
2711             Some(hir_id)
2712         } else {
2713             self.seen_decls.insert(name, fi.hir_id())
2714         }
2715     }
2716
2717     /// Get the name of the symbol that's linked against for a given extern declaration. That is,
2718     /// the name specified in a #[link_name = ...] attribute if one was specified, else, just the
2719     /// symbol's name.
2720     fn name_of_extern_decl(tcx: TyCtxt<'_>, fi: &hir::ForeignItem<'_>) -> SymbolName {
2721         if let Some((overridden_link_name, overridden_link_name_span)) =
2722             tcx.codegen_fn_attrs(fi.def_id).link_name.map(|overridden_link_name| {
2723                 // FIXME: Instead of searching through the attributes again to get span
2724                 // information, we could have codegen_fn_attrs also give span information back for
2725                 // where the attribute was defined. However, until this is found to be a
2726                 // bottleneck, this does just fine.
2727                 (
2728                     overridden_link_name,
2729                     tcx.get_attrs(fi.def_id.to_def_id())
2730                         .iter()
2731                         .find(|at| tcx.sess.check_name(at, sym::link_name))
2732                         .unwrap()
2733                         .span,
2734                 )
2735             })
2736         {
2737             SymbolName::Link(overridden_link_name, overridden_link_name_span)
2738         } else {
2739             SymbolName::Normal(fi.ident.name)
2740         }
2741     }
2742
2743     /// Checks whether two types are structurally the same enough that the declarations shouldn't
2744     /// clash. We need this so we don't emit a lint when two modules both declare an extern struct,
2745     /// with the same members (as the declarations shouldn't clash).
2746     fn structurally_same_type<'tcx>(
2747         cx: &LateContext<'tcx>,
2748         a: Ty<'tcx>,
2749         b: Ty<'tcx>,
2750         ckind: CItemKind,
2751     ) -> bool {
2752         fn structurally_same_type_impl<'tcx>(
2753             seen_types: &mut FxHashSet<(Ty<'tcx>, Ty<'tcx>)>,
2754             cx: &LateContext<'tcx>,
2755             a: Ty<'tcx>,
2756             b: Ty<'tcx>,
2757             ckind: CItemKind,
2758         ) -> bool {
2759             debug!("structurally_same_type_impl(cx, a = {:?}, b = {:?})", a, b);
2760             let tcx = cx.tcx;
2761
2762             // Given a transparent newtype, reach through and grab the inner
2763             // type unless the newtype makes the type non-null.
2764             let non_transparent_ty = |ty: Ty<'tcx>| -> Ty<'tcx> {
2765                 let mut ty = ty;
2766                 loop {
2767                     if let ty::Adt(def, substs) = *ty.kind() {
2768                         let is_transparent = def.subst(tcx, substs).repr.transparent();
2769                         let is_non_null = crate::types::nonnull_optimization_guaranteed(tcx, &def);
2770                         debug!(
2771                             "non_transparent_ty({:?}) -- type is transparent? {}, type is non-null? {}",
2772                             ty, is_transparent, is_non_null
2773                         );
2774                         if is_transparent && !is_non_null {
2775                             debug_assert!(def.variants.len() == 1);
2776                             let v = &def.variants[VariantIdx::new(0)];
2777                             ty = transparent_newtype_field(tcx, v)
2778                                 .expect(
2779                                     "single-variant transparent structure with zero-sized field",
2780                                 )
2781                                 .ty(tcx, substs);
2782                             continue;
2783                         }
2784                     }
2785                     debug!("non_transparent_ty -> {:?}", ty);
2786                     return ty;
2787                 }
2788             };
2789
2790             let a = non_transparent_ty(a);
2791             let b = non_transparent_ty(b);
2792
2793             if !seen_types.insert((a, b)) {
2794                 // We've encountered a cycle. There's no point going any further -- the types are
2795                 // structurally the same.
2796                 return true;
2797             }
2798             let tcx = cx.tcx;
2799             if a == b || rustc_middle::ty::TyS::same_type(a, b) {
2800                 // All nominally-same types are structurally same, too.
2801                 true
2802             } else {
2803                 // Do a full, depth-first comparison between the two.
2804                 use rustc_middle::ty::TyKind::*;
2805                 let a_kind = a.kind();
2806                 let b_kind = b.kind();
2807
2808                 let compare_layouts = |a, b| -> Result<bool, LayoutError<'tcx>> {
2809                     debug!("compare_layouts({:?}, {:?})", a, b);
2810                     let a_layout = &cx.layout_of(a)?.layout.abi;
2811                     let b_layout = &cx.layout_of(b)?.layout.abi;
2812                     debug!(
2813                         "comparing layouts: {:?} == {:?} = {}",
2814                         a_layout,
2815                         b_layout,
2816                         a_layout == b_layout
2817                     );
2818                     Ok(a_layout == b_layout)
2819                 };
2820
2821                 #[allow(rustc::usage_of_ty_tykind)]
2822                 let is_primitive_or_pointer = |kind: &ty::TyKind<'_>| {
2823                     kind.is_primitive() || matches!(kind, RawPtr(..) | Ref(..))
2824                 };
2825
2826                 ensure_sufficient_stack(|| {
2827                     match (a_kind, b_kind) {
2828                         (Adt(a_def, a_substs), Adt(b_def, b_substs)) => {
2829                             let a = a.subst(cx.tcx, a_substs);
2830                             let b = b.subst(cx.tcx, b_substs);
2831                             debug!("Comparing {:?} and {:?}", a, b);
2832
2833                             // We can immediately rule out these types as structurally same if
2834                             // their layouts differ.
2835                             match compare_layouts(a, b) {
2836                                 Ok(false) => return false,
2837                                 _ => (), // otherwise, continue onto the full, fields comparison
2838                             }
2839
2840                             // Grab a flattened representation of all fields.
2841                             let a_fields = a_def.variants.iter().flat_map(|v| v.fields.iter());
2842                             let b_fields = b_def.variants.iter().flat_map(|v| v.fields.iter());
2843
2844                             // Perform a structural comparison for each field.
2845                             a_fields.eq_by(
2846                                 b_fields,
2847                                 |&ty::FieldDef { did: a_did, .. },
2848                                  &ty::FieldDef { did: b_did, .. }| {
2849                                     structurally_same_type_impl(
2850                                         seen_types,
2851                                         cx,
2852                                         tcx.type_of(a_did),
2853                                         tcx.type_of(b_did),
2854                                         ckind,
2855                                     )
2856                                 },
2857                             )
2858                         }
2859                         (Array(a_ty, a_const), Array(b_ty, b_const)) => {
2860                             // For arrays, we also check the constness of the type.
2861                             a_const.val == b_const.val
2862                                 && structurally_same_type_impl(seen_types, cx, a_ty, b_ty, ckind)
2863                         }
2864                         (Slice(a_ty), Slice(b_ty)) => {
2865                             structurally_same_type_impl(seen_types, cx, a_ty, b_ty, ckind)
2866                         }
2867                         (RawPtr(a_tymut), RawPtr(b_tymut)) => {
2868                             a_tymut.mutbl == b_tymut.mutbl
2869                                 && structurally_same_type_impl(
2870                                     seen_types,
2871                                     cx,
2872                                     &a_tymut.ty,
2873                                     &b_tymut.ty,
2874                                     ckind,
2875                                 )
2876                         }
2877                         (Ref(_a_region, a_ty, a_mut), Ref(_b_region, b_ty, b_mut)) => {
2878                             // For structural sameness, we don't need the region to be same.
2879                             a_mut == b_mut
2880                                 && structurally_same_type_impl(seen_types, cx, a_ty, b_ty, ckind)
2881                         }
2882                         (FnDef(..), FnDef(..)) => {
2883                             let a_poly_sig = a.fn_sig(tcx);
2884                             let b_poly_sig = b.fn_sig(tcx);
2885
2886                             // As we don't compare regions, skip_binder is fine.
2887                             let a_sig = a_poly_sig.skip_binder();
2888                             let b_sig = b_poly_sig.skip_binder();
2889
2890                             (a_sig.abi, a_sig.unsafety, a_sig.c_variadic)
2891                                 == (b_sig.abi, b_sig.unsafety, b_sig.c_variadic)
2892                                 && a_sig.inputs().iter().eq_by(b_sig.inputs().iter(), |a, b| {
2893                                     structurally_same_type_impl(seen_types, cx, a, b, ckind)
2894                                 })
2895                                 && structurally_same_type_impl(
2896                                     seen_types,
2897                                     cx,
2898                                     a_sig.output(),
2899                                     b_sig.output(),
2900                                     ckind,
2901                                 )
2902                         }
2903                         (Tuple(a_substs), Tuple(b_substs)) => {
2904                             a_substs.types().eq_by(b_substs.types(), |a_ty, b_ty| {
2905                                 structurally_same_type_impl(seen_types, cx, a_ty, b_ty, ckind)
2906                             })
2907                         }
2908                         // For these, it's not quite as easy to define structural-sameness quite so easily.
2909                         // For the purposes of this lint, take the conservative approach and mark them as
2910                         // not structurally same.
2911                         (Dynamic(..), Dynamic(..))
2912                         | (Error(..), Error(..))
2913                         | (Closure(..), Closure(..))
2914                         | (Generator(..), Generator(..))
2915                         | (GeneratorWitness(..), GeneratorWitness(..))
2916                         | (Projection(..), Projection(..))
2917                         | (Opaque(..), Opaque(..)) => false,
2918
2919                         // These definitely should have been caught above.
2920                         (Bool, Bool) | (Char, Char) | (Never, Never) | (Str, Str) => unreachable!(),
2921
2922                         // An Adt and a primitive or pointer type. This can be FFI-safe if non-null
2923                         // enum layout optimisation is being applied.
2924                         (Adt(..), other_kind) | (other_kind, Adt(..))
2925                             if is_primitive_or_pointer(other_kind) =>
2926                         {
2927                             let (primitive, adt) =
2928                                 if is_primitive_or_pointer(a.kind()) { (a, b) } else { (b, a) };
2929                             if let Some(ty) = crate::types::repr_nullable_ptr(cx, adt, ckind) {
2930                                 ty == primitive
2931                             } else {
2932                                 compare_layouts(a, b).unwrap_or(false)
2933                             }
2934                         }
2935                         // Otherwise, just compare the layouts. This may fail to lint for some
2936                         // incompatible types, but at the very least, will stop reads into
2937                         // uninitialised memory.
2938                         _ => compare_layouts(a, b).unwrap_or(false),
2939                     }
2940                 })
2941             }
2942         }
2943         let mut seen_types = FxHashSet::default();
2944         structurally_same_type_impl(&mut seen_types, cx, a, b, ckind)
2945     }
2946 }
2947
2948 impl_lint_pass!(ClashingExternDeclarations => [CLASHING_EXTERN_DECLARATIONS]);
2949
2950 impl<'tcx> LateLintPass<'tcx> for ClashingExternDeclarations {
2951     fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, this_fi: &hir::ForeignItem<'_>) {
2952         trace!("ClashingExternDeclarations: check_foreign_item: {:?}", this_fi);
2953         if let ForeignItemKind::Fn(..) = this_fi.kind {
2954             let tcx = cx.tcx;
2955             if let Some(existing_hid) = self.insert(tcx, this_fi) {
2956                 let existing_decl_ty = tcx.type_of(tcx.hir().local_def_id(existing_hid));
2957                 let this_decl_ty = tcx.type_of(this_fi.def_id);
2958                 debug!(
2959                     "ClashingExternDeclarations: Comparing existing {:?}: {:?} to this {:?}: {:?}",
2960                     existing_hid, existing_decl_ty, this_fi.def_id, this_decl_ty
2961                 );
2962                 // Check that the declarations match.
2963                 if !Self::structurally_same_type(
2964                     cx,
2965                     existing_decl_ty,
2966                     this_decl_ty,
2967                     CItemKind::Declaration,
2968                 ) {
2969                     let orig_fi = tcx.hir().expect_foreign_item(existing_hid);
2970                     let orig = Self::name_of_extern_decl(tcx, orig_fi);
2971
2972                     // We want to ensure that we use spans for both decls that include where the
2973                     // name was defined, whether that was from the link_name attribute or not.
2974                     let get_relevant_span =
2975                         |fi: &hir::ForeignItem<'_>| match Self::name_of_extern_decl(tcx, fi) {
2976                             SymbolName::Normal(_) => fi.span,
2977                             SymbolName::Link(_, annot_span) => fi.span.to(annot_span),
2978                         };
2979                     // Finally, emit the diagnostic.
2980                     tcx.struct_span_lint_hir(
2981                         CLASHING_EXTERN_DECLARATIONS,
2982                         this_fi.hir_id(),
2983                         get_relevant_span(this_fi),
2984                         |lint| {
2985                             let mut expected_str = DiagnosticStyledString::new();
2986                             expected_str.push(existing_decl_ty.fn_sig(tcx).to_string(), false);
2987                             let mut found_str = DiagnosticStyledString::new();
2988                             found_str.push(this_decl_ty.fn_sig(tcx).to_string(), true);
2989
2990                             lint.build(&format!(
2991                                 "`{}` redeclare{} with a different signature",
2992                                 this_fi.ident.name,
2993                                 if orig.get_name() == this_fi.ident.name {
2994                                     "d".to_string()
2995                                 } else {
2996                                     format!("s `{}`", orig.get_name())
2997                                 }
2998                             ))
2999                             .span_label(
3000                                 get_relevant_span(orig_fi),
3001                                 &format!("`{}` previously declared here", orig.get_name()),
3002                             )
3003                             .span_label(
3004                                 get_relevant_span(this_fi),
3005                                 "this signature doesn't match the previous declaration",
3006                             )
3007                             .note_expected_found(&"", expected_str, &"", found_str)
3008                             .emit()
3009                         },
3010                     );
3011                 }
3012             }
3013         }
3014     }
3015 }
3016
3017 declare_lint! {
3018     /// The `deref_nullptr` lint detects when an null pointer is dereferenced,
3019     /// which causes [undefined behavior].
3020     ///
3021     /// ### Example
3022     ///
3023     /// ```rust,no_run
3024     /// # #![allow(unused)]
3025     /// use std::ptr;
3026     /// unsafe {
3027     ///     let x = &*ptr::null::<i32>();
3028     ///     let x = ptr::addr_of!(*ptr::null::<i32>());
3029     ///     let x = *(0 as *const i32);
3030     /// }
3031     /// ```
3032     ///
3033     /// {{produces}}
3034     ///
3035     /// ### Explanation
3036     ///
3037     /// Dereferencing a null pointer causes [undefined behavior] even as a place expression,
3038     /// like `&*(0 as *const i32)` or `addr_of!(*(0 as *const i32))`.
3039     ///
3040     /// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
3041     pub DEREF_NULLPTR,
3042     Warn,
3043     "detects when an null pointer is dereferenced"
3044 }
3045
3046 declare_lint_pass!(DerefNullPtr => [DEREF_NULLPTR]);
3047
3048 impl<'tcx> LateLintPass<'tcx> for DerefNullPtr {
3049     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) {
3050         /// test if expression is a null ptr
3051         fn is_null_ptr(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
3052             match &expr.kind {
3053                 rustc_hir::ExprKind::Cast(ref expr, ref ty) => {
3054                     if let rustc_hir::TyKind::Ptr(_) = ty.kind {
3055                         return is_zero(expr) || is_null_ptr(cx, expr);
3056                     }
3057                 }
3058                 // check for call to `core::ptr::null` or `core::ptr::null_mut`
3059                 rustc_hir::ExprKind::Call(ref path, _) => {
3060                     if let rustc_hir::ExprKind::Path(ref qpath) = path.kind {
3061                         if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id() {
3062                             return cx.tcx.is_diagnostic_item(sym::ptr_null, def_id)
3063                                 || cx.tcx.is_diagnostic_item(sym::ptr_null_mut, def_id);
3064                         }
3065                     }
3066                 }
3067                 _ => {}
3068             }
3069             false
3070         }
3071
3072         /// test if expression is the literal `0`
3073         fn is_zero(expr: &hir::Expr<'_>) -> bool {
3074             match &expr.kind {
3075                 rustc_hir::ExprKind::Lit(ref lit) => {
3076                     if let LitKind::Int(a, _) = lit.node {
3077                         return a == 0;
3078                     }
3079                 }
3080                 _ => {}
3081             }
3082             false
3083         }
3084
3085         if let rustc_hir::ExprKind::Unary(ref un_op, ref expr_deref) = expr.kind {
3086             if let rustc_hir::UnOp::Deref = un_op {
3087                 if is_null_ptr(cx, expr_deref) {
3088                     cx.struct_span_lint(DEREF_NULLPTR, expr.span, |lint| {
3089                         let mut err = lint.build("dereferencing a null pointer");
3090                         err.span_label(
3091                             expr.span,
3092                             "this code causes undefined behavior when executed",
3093                         );
3094                         err.emit();
3095                     });
3096                 }
3097             }
3098         }
3099     }
3100 }