src/librustc_passes/stability.rs

   1 //! A pass that annotates every item and method with its stability level,
   2 //! propagating default levels lexically from parent to children ast nodes.
   3
   4 use rustc::hir::map::Map;
   5 use rustc::lint;
   6 use rustc::middle::privacy::AccessLevels;
   7 use rustc::middle::stability::{DeprecationEntry, Index};
   8 use rustc::session::parse::feature_err;
   9 use rustc::session::Session;
  10 use rustc::ty::query::Providers;
  11 use rustc::ty::TyCtxt;
  12 use rustc_ast::ast::Attribute;
  13 use rustc_attr::{self as attr, ConstStability, Stability};
  14 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
  15 use rustc_errors::struct_span_err;
  16 use rustc_hir as hir;
  17 use rustc_hir::def::{DefKind, Res};
  18 use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
  19 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
  20 use rustc_hir::{Generics, HirId, Item, StructField, Variant};
  21 use rustc_infer::traits::misc::can_type_implement_copy;
  22 use rustc_span::symbol::{sym, Symbol};
  23 use rustc_span::Span;
  24
  25 use std::cmp::Ordering;
  26 use std::mem::replace;
  27 use std::num::NonZeroU32;
  28
  29 #[derive(PartialEq)]
  30 enum AnnotationKind {
  31     // Annotation is required if not inherited from unstable parents
  32     Required,
  33     // Annotation is useless, reject it
  34     Prohibited,
  35     // Annotation itself is useless, but it can be propagated to children
  36     Container,
  37 }
  38
  39 // A private tree-walker for producing an Index.
  40 struct Annotator<'a, 'tcx> {
  41     tcx: TyCtxt<'tcx>,
  42     index: &'a mut Index<'tcx>,
  43     parent_stab: Option<&'tcx Stability>,
  44     parent_const_stab: Option<&'tcx ConstStability>,
  45     parent_depr: Option<DeprecationEntry>,
  46     in_trait_impl: bool,
  47 }
  48
  49 impl<'a, 'tcx> Annotator<'a, 'tcx> {
  50     // Determine the stability for a node based on its attributes and inherited
  51     // stability. The stability is recorded in the index and used as the parent.
  52     fn annotate<F>(
  53         &mut self,
  54         hir_id: HirId,
  55         attrs: &[Attribute],
  56         item_sp: Span,
  57         kind: AnnotationKind,
  58         visit_children: F,
  59     ) where
  60         F: FnOnce(&mut Self),
  61     {
  62         if !self.tcx.features().staged_api {
  63             self.forbid_staged_api_attrs(hir_id, attrs, item_sp, kind, visit_children);
  64             return;
  65         }
  66
  67         // This crate explicitly wants staged API.
  68
  69         debug!("annotate(id = {:?}, attrs = {:?})", hir_id, attrs);
  70         if let Some(..) = attr::find_deprecation(&self.tcx.sess.parse_sess, attrs, item_sp) {
  71             self.tcx.sess.span_err(
  72                 item_sp,
  73                 "`#[deprecated]` cannot be used in staged API; \
  74                                              use `#[rustc_deprecated]` instead",
  75             );
  76         }
  77
  78         let (stab, const_stab) = attr::find_stability(&self.tcx.sess.parse_sess, attrs, item_sp);
  79
  80         let const_stab = const_stab.map(|const_stab| {
  81             let const_stab = self.tcx.intern_const_stability(const_stab);
  82             self.index.const_stab_map.insert(hir_id, const_stab);
  83             const_stab
  84         });
  85
  86         if const_stab.is_none() {
  87             debug!("annotate: const_stab not found, parent = {:?}", self.parent_const_stab);
  88             if let Some(parent) = self.parent_const_stab {
  89                 if parent.level.is_unstable() {
  90                     self.index.const_stab_map.insert(hir_id, parent);
  91                 }
  92             }
  93         }
  94
  95         let stab = stab.map(|mut stab| {
  96             // Error if prohibited, or can't inherit anything from a container.
  97             if kind == AnnotationKind::Prohibited
  98                 || (kind == AnnotationKind::Container
  99                     && stab.level.is_stable()
 100                     && stab.rustc_depr.is_none())
 101             {
 102                 self.tcx.sess.span_err(item_sp, "This stability annotation is useless");
 103             }
 104
 105             debug!("annotate: found {:?}", stab);
 106             // If parent is deprecated and we're not, inherit this by merging
 107             // deprecated_since and its reason.
 108             if let Some(parent_stab) = self.parent_stab {
 109                 if parent_stab.rustc_depr.is_some() && stab.rustc_depr.is_none() {
 110                     stab.rustc_depr = parent_stab.rustc_depr
 111                 }
 112             }
 113
 114             let stab = self.tcx.intern_stability(stab);
 115
 116             // Check if deprecated_since < stable_since. If it is,
 117             // this is *almost surely* an accident.
 118             if let (
 119                 &Some(attr::RustcDeprecation { since: dep_since, .. }),
 120                 &attr::Stable { since: stab_since },
 121             ) = (&stab.rustc_depr, &stab.level)
 122             {
 123                 // Explicit version of iter::order::lt to handle parse errors properly
 124                 for (dep_v, stab_v) in
 125                     dep_since.as_str().split('.').zip(stab_since.as_str().split('.'))
 126                 {
 127                     if let (Ok(dep_v), Ok(stab_v)) = (dep_v.parse::<u64>(), stab_v.parse()) {
 128                         match dep_v.cmp(&stab_v) {
 129                             Ordering::Less => {
 130                                 self.tcx.sess.span_err(
 131                                     item_sp,
 132                                     "An API can't be stabilized \
 133                                                                  after it is deprecated",
 134                                 );
 135                                 break;
 136                             }
 137                             Ordering::Equal => continue,
 138                             Ordering::Greater => break,
 139                         }
 140                     } else {
 141                         // Act like it isn't less because the question is now nonsensical,
 142                         // and this makes us not do anything else interesting.
 143                         self.tcx.sess.span_err(
 144                             item_sp,
 145                             "Invalid stability or deprecation \
 146                                                          version found",
 147                         );
 148                         break;
 149                     }
 150                 }
 151             }
 152
 153             self.index.stab_map.insert(hir_id, stab);
 154             stab
 155         });
 156
 157         if stab.is_none() {
 158             debug!("annotate: stab not found, parent = {:?}", self.parent_stab);
 159             if let Some(stab) = self.parent_stab {
 160                 if stab.level.is_unstable() {
 161                     self.index.stab_map.insert(hir_id, stab);
 162                 }
 163             }
 164         }
 165
 166         self.recurse_with_stability_attrs(stab, const_stab, visit_children);
 167     }
 168
 169     fn recurse_with_stability_attrs(
 170         &mut self,
 171         stab: Option<&'tcx Stability>,
 172         const_stab: Option<&'tcx ConstStability>,
 173         f: impl FnOnce(&mut Self),
 174     ) {
 175         // These will be `Some` if this item changes the corresponding stability attribute.
 176         let mut replaced_parent_stab = None;
 177         let mut replaced_parent_const_stab = None;
 178
 179         if let Some(stab) = stab {
 180             replaced_parent_stab = Some(replace(&mut self.parent_stab, Some(stab)));
 181         }
 182         if let Some(const_stab) = const_stab {
 183             replaced_parent_const_stab =
 184                 Some(replace(&mut self.parent_const_stab, Some(const_stab)));
 185         }
 186
 187         f(self);
 188
 189         if let Some(orig_parent_stab) = replaced_parent_stab {
 190             self.parent_stab = orig_parent_stab;
 191         }
 192         if let Some(orig_parent_const_stab) = replaced_parent_const_stab {
 193             self.parent_const_stab = orig_parent_const_stab;
 194         }
 195     }
 196
 197     fn forbid_staged_api_attrs(
 198         &mut self,
 199         hir_id: HirId,
 200         attrs: &[Attribute],
 201         item_sp: Span,
 202         kind: AnnotationKind,
 203         visit_children: impl FnOnce(&mut Self),
 204     ) {
 205         // Emit errors for non-staged-api crates.
 206         let unstable_attrs = [
 207             sym::unstable,
 208             sym::stable,
 209             sym::rustc_deprecated,
 210             sym::rustc_const_unstable,
 211             sym::rustc_const_stable,
 212         ];
 213         for attr in attrs {
 214             let name = attr.name_or_empty();
 215             if unstable_attrs.contains(&name) {
 216                 attr::mark_used(attr);
 217                 struct_span_err!(
 218                     self.tcx.sess,
 219                     attr.span,
 220                     E0734,
 221                     "stability attributes may not be used outside of the standard library",
 222                 )
 223                 .emit();
 224             }
 225         }
 226
 227         // Propagate unstability.  This can happen even for non-staged-api crates in case
 228         // -Zforce-unstable-if-unmarked is set.
 229         if let Some(stab) = self.parent_stab {
 230             if stab.level.is_unstable() {
 231                 self.index.stab_map.insert(hir_id, stab);
 232             }
 233         }
 234
 235         if let Some(depr) = attr::find_deprecation(&self.tcx.sess.parse_sess, attrs, item_sp) {
 236             if kind == AnnotationKind::Prohibited {
 237                 self.tcx.sess.span_err(item_sp, "This deprecation annotation is useless");
 238             }
 239
 240             // `Deprecation` is just two pointers, no need to intern it
 241             let depr_entry = DeprecationEntry::local(depr, hir_id);
 242             self.index.depr_map.insert(hir_id, depr_entry.clone());
 243
 244             let orig_parent_depr = replace(&mut self.parent_depr, Some(depr_entry));
 245             visit_children(self);
 246             self.parent_depr = orig_parent_depr;
 247         } else if let Some(parent_depr) = self.parent_depr.clone() {
 248             self.index.depr_map.insert(hir_id, parent_depr);
 249             visit_children(self);
 250         } else {
 251             visit_children(self);
 252         }
 253     }
 254 }
 255
 256 impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
 257     /// Because stability levels are scoped lexically, we want to walk
 258     /// nested items in the context of the outer item, so enable
 259     /// deep-walking.
 260     type Map = Map<'tcx>;
 261
 262     fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
 263         NestedVisitorMap::All(&self.tcx.hir())
 264     }
 265
 266     fn visit_item(&mut self, i: &'tcx Item<'tcx>) {
 267         let orig_in_trait_impl = self.in_trait_impl;
 268         let mut kind = AnnotationKind::Required;
 269         match i.kind {
 270             // Inherent impls and foreign modules serve only as containers for other items,
 271             // they don't have their own stability. They still can be annotated as unstable
 272             // and propagate this unstability to children, but this annotation is completely
 273             // optional. They inherit stability from their parents when unannotated.
 274             hir::ItemKind::Impl { of_trait: None, .. } | hir::ItemKind::ForeignMod(..) => {
 275                 self.in_trait_impl = false;
 276                 kind = AnnotationKind::Container;
 277             }
 278             hir::ItemKind::Impl { of_trait: Some(_), .. } => {
 279                 self.in_trait_impl = true;
 280             }
 281             hir::ItemKind::Struct(ref sd, _) => {
 282                 if let Some(ctor_hir_id) = sd.ctor_hir_id() {
 283                     self.annotate(ctor_hir_id, &i.attrs, i.span, AnnotationKind::Required, |_| {})
 284                 }
 285             }
 286             _ => {}
 287         }
 288
 289         self.annotate(i.hir_id, &i.attrs, i.span, kind, |v| intravisit::walk_item(v, i));
 290         self.in_trait_impl = orig_in_trait_impl;
 291     }
 292
 293     fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem<'tcx>) {
 294         self.annotate(ti.hir_id, &ti.attrs, ti.span, AnnotationKind::Required, |v| {
 295             intravisit::walk_trait_item(v, ti);
 296         });
 297     }
 298
 299     fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem<'tcx>) {
 300         let kind =
 301             if self.in_trait_impl { AnnotationKind::Prohibited } else { AnnotationKind::Required };
 302         self.annotate(ii.hir_id, &ii.attrs, ii.span, kind, |v| {
 303             intravisit::walk_impl_item(v, ii);
 304         });
 305     }
 306
 307     fn visit_variant(&mut self, var: &'tcx Variant<'tcx>, g: &'tcx Generics<'tcx>, item_id: HirId) {
 308         self.annotate(var.id, &var.attrs, var.span, AnnotationKind::Required, |v| {
 309             if let Some(ctor_hir_id) = var.data.ctor_hir_id() {
 310                 v.annotate(ctor_hir_id, &var.attrs, var.span, AnnotationKind::Required, |_| {});
 311             }
 312
 313             intravisit::walk_variant(v, var, g, item_id)
 314         })
 315     }
 316
 317     fn visit_struct_field(&mut self, s: &'tcx StructField<'tcx>) {
 318         self.annotate(s.hir_id, &s.attrs, s.span, AnnotationKind::Required, |v| {
 319             intravisit::walk_struct_field(v, s);
 320         });
 321     }
 322
 323     fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem<'tcx>) {
 324         self.annotate(i.hir_id, &i.attrs, i.span, AnnotationKind::Required, |v| {
 325             intravisit::walk_foreign_item(v, i);
 326         });
 327     }
 328
 329     fn visit_macro_def(&mut self, md: &'tcx hir::MacroDef<'tcx>) {
 330         self.annotate(md.hir_id, &md.attrs, md.span, AnnotationKind::Required, |_| {});
 331     }
 332 }
 333
 334 struct MissingStabilityAnnotations<'a, 'tcx> {
 335     tcx: TyCtxt<'tcx>,
 336     access_levels: &'a AccessLevels,
 337 }
 338
 339 impl<'a, 'tcx> MissingStabilityAnnotations<'a, 'tcx> {
 340     fn check_missing_stability(&self, hir_id: HirId, span: Span, name: &str) {
 341         let stab = self.tcx.stability().local_stability(hir_id);
 342         let is_error =
 343             !self.tcx.sess.opts.test && stab.is_none() && self.access_levels.is_reachable(hir_id);
 344         if is_error {
 345             self.tcx.sess.span_err(span, &format!("{} has missing stability attribute", name));
 346         }
 347     }
 348 }
 349
 350 impl<'a, 'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'a, 'tcx> {
 351     type Map = Map<'tcx>;
 352
 353     fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
 354         NestedVisitorMap::OnlyBodies(&self.tcx.hir())
 355     }
 356
 357     fn visit_item(&mut self, i: &'tcx Item<'tcx>) {
 358         match i.kind {
 359             // Inherent impls and foreign modules serve only as containers for other items,
 360             // they don't have their own stability. They still can be annotated as unstable
 361             // and propagate this unstability to children, but this annotation is completely
 362             // optional. They inherit stability from their parents when unannotated.
 363             hir::ItemKind::Impl { of_trait: None, .. } | hir::ItemKind::ForeignMod(..) => {}
 364
 365             _ => self.check_missing_stability(i.hir_id, i.span, i.kind.descr()),
 366         }
 367
 368         intravisit::walk_item(self, i)
 369     }
 370
 371     fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem<'tcx>) {
 372         self.check_missing_stability(ti.hir_id, ti.span, "item");
 373         intravisit::walk_trait_item(self, ti);
 374     }
 375
 376     fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem<'tcx>) {
 377         let impl_def_id = self.tcx.hir().local_def_id(self.tcx.hir().get_parent_item(ii.hir_id));
 378         if self.tcx.impl_trait_ref(impl_def_id).is_none() {
 379             self.check_missing_stability(ii.hir_id, ii.span, "item");
 380         }
 381         intravisit::walk_impl_item(self, ii);
 382     }
 383
 384     fn visit_variant(&mut self, var: &'tcx Variant<'tcx>, g: &'tcx Generics<'tcx>, item_id: HirId) {
 385         self.check_missing_stability(var.id, var.span, "variant");
 386         intravisit::walk_variant(self, var, g, item_id);
 387     }
 388
 389     fn visit_struct_field(&mut self, s: &'tcx StructField<'tcx>) {
 390         self.check_missing_stability(s.hir_id, s.span, "field");
 391         intravisit::walk_struct_field(self, s);
 392     }
 393
 394     fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem<'tcx>) {
 395         self.check_missing_stability(i.hir_id, i.span, i.kind.descriptive_variant());
 396         intravisit::walk_foreign_item(self, i);
 397     }
 398
 399     fn visit_macro_def(&mut self, md: &'tcx hir::MacroDef<'tcx>) {
 400         self.check_missing_stability(md.hir_id, md.span, "macro");
 401     }
 402 }
 403
 404 fn new_index(tcx: TyCtxt<'tcx>) -> Index<'tcx> {
 405     let is_staged_api =
 406         tcx.sess.opts.debugging_opts.force_unstable_if_unmarked || tcx.features().staged_api;
 407     let mut staged_api = FxHashMap::default();
 408     staged_api.insert(LOCAL_CRATE, is_staged_api);
 409     let mut index = Index {
 410         staged_api,
 411         stab_map: Default::default(),
 412         const_stab_map: Default::default(),
 413         depr_map: Default::default(),
 414         active_features: Default::default(),
 415     };
 416
 417     let active_lib_features = &tcx.features().declared_lib_features;
 418     let active_lang_features = &tcx.features().declared_lang_features;
 419
 420     // Put the active features into a map for quick lookup.
 421     index.active_features = active_lib_features
 422         .iter()
 423         .map(|&(s, ..)| s)
 424         .chain(active_lang_features.iter().map(|&(s, ..)| s))
 425         .collect();
 426
 427     {
 428         let krate = tcx.hir().krate();
 429         let mut annotator = Annotator {
 430             tcx,
 431             index: &mut index,
 432             parent_stab: None,
 433             parent_const_stab: None,
 434             parent_depr: None,
 435             in_trait_impl: false,
 436         };
 437
 438         // If the `-Z force-unstable-if-unmarked` flag is passed then we provide
 439         // a parent stability annotation which indicates that this is private
 440         // with the `rustc_private` feature. This is intended for use when
 441         // compiling librustc crates themselves so we can leverage crates.io
 442         // while maintaining the invariant that all sysroot crates are unstable
 443         // by default and are unable to be used.
 444         if tcx.sess.opts.debugging_opts.force_unstable_if_unmarked {
 445             let reason = "this crate is being loaded from the sysroot, an \
 446                           unstable location; did you mean to load this crate \
 447                           from crates.io via `Cargo.toml` instead?";
 448             let stability = tcx.intern_stability(Stability {
 449                 level: attr::StabilityLevel::Unstable {
 450                     reason: Some(Symbol::intern(reason)),
 451                     issue: NonZeroU32::new(27812),
 452                     is_soft: false,
 453                 },
 454                 feature: sym::rustc_private,
 455                 rustc_depr: None,
 456             });
 457             annotator.parent_stab = Some(stability);
 458         }
 459
 460         annotator.annotate(
 461             hir::CRATE_HIR_ID,
 462             &krate.attrs,
 463             krate.span,
 464             AnnotationKind::Required,
 465             |v| intravisit::walk_crate(v, krate),
 466         );
 467     }
 468     return index;
 469 }
 470
 471 /// Cross-references the feature names of unstable APIs with enabled
 472 /// features and possibly prints errors.
 473 fn check_mod_unstable_api_usage(tcx: TyCtxt<'_>, module_def_id: DefId) {
 474     tcx.hir().visit_item_likes_in_module(module_def_id, &mut Checker { tcx }.as_deep_visitor());
 475 }
 476
 477 pub(crate) fn provide(providers: &mut Providers<'_>) {
 478     *providers = Providers { check_mod_unstable_api_usage, ..*providers };
 479     providers.stability_index = |tcx, cnum| {
 480         assert_eq!(cnum, LOCAL_CRATE);
 481         tcx.arena.alloc(new_index(tcx))
 482     };
 483 }
 484
 485 struct Checker<'tcx> {
 486     tcx: TyCtxt<'tcx>,
 487 }
 488
 489 impl Visitor<'tcx> for Checker<'tcx> {
 490     type Map = Map<'tcx>;
 491
 492     /// Because stability levels are scoped lexically, we want to walk
 493     /// nested items in the context of the outer item, so enable
 494     /// deep-walking.
 495     fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
 496         NestedVisitorMap::OnlyBodies(&self.tcx.hir())
 497     }
 498
 499     fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
 500         match item.kind {
 501             hir::ItemKind::ExternCrate(_) => {
 502                 // compiler-generated `extern crate` items have a dummy span.
 503                 if item.span.is_dummy() {
 504                     return;
 505                 }
 506
 507                 let def_id = self.tcx.hir().local_def_id(item.hir_id);
 508                 let cnum = match self.tcx.extern_mod_stmt_cnum(def_id) {
 509                     Some(cnum) => cnum,
 510                     None => return,
 511                 };
 512                 let def_id = DefId { krate: cnum, index: CRATE_DEF_INDEX };
 513                 self.tcx.check_stability(def_id, Some(item.hir_id), item.span);
 514             }
 515
 516             // For implementations of traits, check the stability of each item
 517             // individually as it's possible to have a stable trait with unstable
 518             // items.
 519             hir::ItemKind::Impl { of_trait: Some(ref t), items, .. } => {
 520                 if let Res::Def(DefKind::Trait, trait_did) = t.path.res {
 521                     for impl_item_ref in items {
 522                         let impl_item = self.tcx.hir().impl_item(impl_item_ref.id);
 523                         let trait_item_def_id = self
 524                             .tcx
 525                             .associated_items(trait_did)
 526                             .filter_by_name_unhygienic(impl_item.ident.name)
 527                             .next()
 528                             .map(|item| item.def_id);
 529                         if let Some(def_id) = trait_item_def_id {
 530                             // Pass `None` to skip deprecation warnings.
 531                             self.tcx.check_stability(def_id, None, impl_item.span);
 532                         }
 533                     }
 534                 }
 535             }
 536
 537             // There's no good place to insert stability check for non-Copy unions,
 538             // so semi-randomly perform it here in stability.rs
 539             hir::ItemKind::Union(..) if !self.tcx.features().untagged_unions => {
 540                 let def_id = self.tcx.hir().local_def_id(item.hir_id);
 541                 let adt_def = self.tcx.adt_def(def_id);
 542                 let ty = self.tcx.type_of(def_id);
 543
 544                 if adt_def.has_dtor(self.tcx) {
 545                     feature_err(
 546                         &self.tcx.sess.parse_sess,
 547                         sym::untagged_unions,
 548                         item.span,
 549                         "unions with `Drop` implementations are unstable",
 550                     )
 551                     .emit();
 552                 } else {
 553                     let param_env = self.tcx.param_env(def_id);
 554                     if can_type_implement_copy(self.tcx, param_env, ty).is_err() {
 555                         feature_err(
 556                             &self.tcx.sess.parse_sess,
 557                             sym::untagged_unions,
 558                             item.span,
 559                             "unions with non-`Copy` fields are unstable",
 560                         )
 561                         .emit();
 562                     }
 563                 }
 564             }
 565
 566             _ => (/* pass */),
 567         }
 568         intravisit::walk_item(self, item);
 569     }
 570
 571     fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, id: hir::HirId) {
 572         if let Some(def_id) = path.res.opt_def_id() {
 573             self.tcx.check_stability(def_id, Some(id), path.span)
 574         }
 575         intravisit::walk_path(self, path)
 576     }
 577 }
 578
 579 /// Given the list of enabled features that were not language features (i.e., that
 580 /// were expected to be library features), and the list of features used from
 581 /// libraries, identify activated features that don't exist and error about them.
 582 pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) {
 583     let access_levels = &tcx.privacy_access_levels(LOCAL_CRATE);
 584
 585     if tcx.stability().staged_api[&LOCAL_CRATE] {
 586         let krate = tcx.hir().krate();
 587         let mut missing = MissingStabilityAnnotations { tcx, access_levels };
 588         missing.check_missing_stability(hir::CRATE_HIR_ID, krate.span, "crate");
 589         intravisit::walk_crate(&mut missing, krate);
 590         krate.visit_all_item_likes(&mut missing.as_deep_visitor());
 591     }
 592
 593     let declared_lang_features = &tcx.features().declared_lang_features;
 594     let mut lang_features = FxHashSet::default();
 595     for &(feature, span, since) in declared_lang_features {
 596         if let Some(since) = since {
 597             // Warn if the user has enabled an already-stable lang feature.
 598             unnecessary_stable_feature_lint(tcx, span, feature, since);
 599         }
 600         if !lang_features.insert(feature) {
 601             // Warn if the user enables a lang feature multiple times.
 602             duplicate_feature_err(tcx.sess, span, feature);
 603         }
 604     }
 605
 606     let declared_lib_features = &tcx.features().declared_lib_features;
 607     let mut remaining_lib_features = FxHashMap::default();
 608     for (feature, span) in declared_lib_features {
 609         if remaining_lib_features.contains_key(&feature) {
 610             // Warn if the user enables a lib feature multiple times.
 611             duplicate_feature_err(tcx.sess, *span, *feature);
 612         }
 613         remaining_lib_features.insert(feature, span.clone());
 614     }
 615     // `stdbuild` has special handling for `libc`, so we need to
 616     // recognise the feature when building std.
 617     // Likewise, libtest is handled specially, so `test` isn't
 618     // available as we'd like it to be.
 619     // FIXME: only remove `libc` when `stdbuild` is active.
 620     // FIXME: remove special casing for `test`.
 621     remaining_lib_features.remove(&Symbol::intern("libc"));
 622     remaining_lib_features.remove(&sym::test);
 623
 624     let check_features = |remaining_lib_features: &mut FxHashMap<_, _>, defined_features: &[_]| {
 625         for &(feature, since) in defined_features {
 626             if let Some(since) = since {
 627                 if let Some(span) = remaining_lib_features.get(&feature) {
 628                     // Warn if the user has enabled an already-stable lib feature.
 629                     unnecessary_stable_feature_lint(tcx, *span, feature, since);
 630                 }
 631             }
 632             remaining_lib_features.remove(&feature);
 633             if remaining_lib_features.is_empty() {
 634                 break;
 635             }
 636         }
 637     };
 638
 639     // We always collect the lib features declared in the current crate, even if there are
 640     // no unknown features, because the collection also does feature attribute validation.
 641     let local_defined_features = tcx.lib_features().to_vec();
 642     if !remaining_lib_features.is_empty() {
 643         check_features(&mut remaining_lib_features, &local_defined_features);
 644
 645         for &cnum in &*tcx.crates() {
 646             if remaining_lib_features.is_empty() {
 647                 break;
 648             }
 649             check_features(&mut remaining_lib_features, tcx.defined_lib_features(cnum));
 650         }
 651     }
 652
 653     for (feature, span) in remaining_lib_features {
 654         struct_span_err!(tcx.sess, span, E0635, "unknown feature `{}`", feature).emit();
 655     }
 656
 657     // FIXME(#44232): the `used_features` table no longer exists, so we
 658     // don't lint about unused features. We should re-enable this one day!
 659 }
 660
 661 fn unnecessary_stable_feature_lint(tcx: TyCtxt<'_>, span: Span, feature: Symbol, since: Symbol) {
 662     tcx.struct_span_lint_hir(lint::builtin::STABLE_FEATURES, hir::CRATE_HIR_ID, span, |lint| {
 663         lint.build(&format!(
 664             "the feature `{}` has been stable since {} and no longer requires \
 665                       an attribute to enable",
 666             feature, since
 667         ))
 668         .emit();
 669     });
 670 }
 671
 672 fn duplicate_feature_err(sess: &Session, span: Span, feature: Symbol) {
 673     struct_span_err!(sess, span, E0636, "the feature `{}` has already been declared", feature)
 674         .emit();
 675 }