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