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