//! A pass that annotates every item and method with its stability level, //! propagating default levels lexically from parent to children ast nodes. use attr::StabilityLevel; use rustc_attr::{self as attr, ConstStability, Stability, Unstable, UnstableReason}; use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap}; use rustc_errors::{struct_span_err, Applicability}; use rustc_hir as hir; use rustc_hir::def::{DefKind, Res}; use rustc_hir::def_id::{LocalDefId, CRATE_DEF_ID}; use rustc_hir::hir_id::CRATE_HIR_ID; use rustc_hir::intravisit::{self, Visitor}; use rustc_hir::{FieldDef, Generics, HirId, Item, ItemKind, TraitRef, Ty, TyKind, Variant}; use rustc_middle::hir::nested_filter; use rustc_middle::middle::privacy::AccessLevels; use rustc_middle::middle::stability::{AllowUnstable, DeprecationEntry, Index}; use rustc_middle::ty::{query::Providers, TyCtxt}; use rustc_session::lint; use rustc_session::lint::builtin::{INEFFECTIVE_UNSTABLE_TRAIT_IMPL, USELESS_DEPRECATED}; use rustc_session::Session; use rustc_span::symbol::{sym, Symbol}; use rustc_span::Span; use rustc_target::spec::abi::Abi; use std::cmp::Ordering; use std::iter; use std::mem::replace; use std::num::NonZeroU32; #[derive(PartialEq)] enum AnnotationKind { /// Annotation is required if not inherited from unstable parents. Required, /// Annotation is useless, reject it. Prohibited, /// Deprecation annotation is useless, reject it. (Stability attribute is still required.) DeprecationProhibited, /// Annotation itself is useless, but it can be propagated to children. Container, } /// Whether to inherit deprecation flags for nested items. In most cases, we do want to inherit /// deprecation, because nested items rarely have individual deprecation attributes, and so /// should be treated as deprecated if their parent is. However, default generic parameters /// have separate deprecation attributes from their parents, so we do not wish to inherit /// deprecation in this case. For example, inheriting deprecation for `T` in `Foo` /// would cause a duplicate warning arising from both `Foo` and `T` being deprecated. #[derive(Clone)] enum InheritDeprecation { Yes, No, } impl InheritDeprecation { fn yes(&self) -> bool { matches!(self, InheritDeprecation::Yes) } } /// Whether to inherit const stability flags for nested items. In most cases, we do not want to /// inherit const stability: just because an enclosing `fn` is const-stable does not mean /// all `extern` imports declared in it should be const-stable! However, trait methods /// inherit const stability attributes from their parent and do not have their own. enum InheritConstStability { Yes, No, } impl InheritConstStability { fn yes(&self) -> bool { matches!(self, InheritConstStability::Yes) } } enum InheritStability { Yes, No, } impl InheritStability { fn yes(&self) -> bool { matches!(self, InheritStability::Yes) } } /// A private tree-walker for producing an `Index`. struct Annotator<'a, 'tcx> { tcx: TyCtxt<'tcx>, index: &'a mut Index, parent_stab: Option, parent_const_stab: Option, parent_depr: Option, in_trait_impl: bool, } impl<'a, 'tcx> Annotator<'a, 'tcx> { /// Determine the stability for a node based on its attributes and inherited stability. The /// stability is recorded in the index and used as the parent. If the node is a function, /// `fn_sig` is its signature. fn annotate( &mut self, def_id: LocalDefId, item_sp: Span, fn_sig: Option<&'tcx hir::FnSig<'tcx>>, kind: AnnotationKind, inherit_deprecation: InheritDeprecation, inherit_const_stability: InheritConstStability, inherit_from_parent: InheritStability, visit_children: F, ) where F: FnOnce(&mut Self), { let attrs = self.tcx.hir().attrs(self.tcx.hir().local_def_id_to_hir_id(def_id)); debug!("annotate(id = {:?}, attrs = {:?})", def_id, attrs); let depr = attr::find_deprecation(&self.tcx.sess, attrs); let mut is_deprecated = false; if let Some((depr, span)) = &depr { is_deprecated = true; if kind == AnnotationKind::Prohibited || kind == AnnotationKind::DeprecationProhibited { let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); self.tcx.struct_span_lint_hir(USELESS_DEPRECATED, hir_id, *span, |lint| { lint.build("this `#[deprecated]` annotation has no effect") .span_suggestion_short( *span, "remove the unnecessary deprecation attribute", "", rustc_errors::Applicability::MachineApplicable, ) .emit(); }); } // `Deprecation` is just two pointers, no need to intern it let depr_entry = DeprecationEntry::local(*depr, def_id); self.index.depr_map.insert(def_id, depr_entry); } else if let Some(parent_depr) = self.parent_depr { if inherit_deprecation.yes() { is_deprecated = true; info!("tagging child {:?} as deprecated from parent", def_id); self.index.depr_map.insert(def_id, parent_depr); } } if !self.tcx.features().staged_api { // Propagate unstability. This can happen even for non-staged-api crates in case // -Zforce-unstable-if-unmarked is set. if let Some(stab) = self.parent_stab { if inherit_deprecation.yes() && stab.is_unstable() { self.index.stab_map.insert(def_id, stab); } } self.recurse_with_stability_attrs( depr.map(|(d, _)| DeprecationEntry::local(d, def_id)), None, None, visit_children, ); return; } let (stab, const_stab) = attr::find_stability(&self.tcx.sess, attrs, item_sp); let mut const_span = None; let const_stab = const_stab.map(|(const_stab, const_span_node)| { self.index.const_stab_map.insert(def_id, const_stab); const_span = Some(const_span_node); const_stab }); // If the current node is a function, has const stability attributes and if it doesn not have an intrinsic ABI, // check if the function/method is const or the parent impl block is const if let (Some(const_span), Some(fn_sig)) = (const_span, fn_sig) { if fn_sig.header.abi != Abi::RustIntrinsic && fn_sig.header.abi != Abi::PlatformIntrinsic && !fn_sig.header.is_const() { if !self.in_trait_impl || (self.in_trait_impl && !self.tcx.is_const_fn_raw(def_id.to_def_id())) { missing_const_err(&self.tcx.sess, fn_sig.span, const_span); } } } // `impl const Trait for Type` items forward their const stability to their // immediate children. if const_stab.is_none() { debug!("annotate: const_stab not found, parent = {:?}", self.parent_const_stab); if let Some(parent) = self.parent_const_stab { if parent.is_const_unstable() { self.index.const_stab_map.insert(def_id, parent); } } } if let Some((rustc_attr::Deprecation { is_since_rustc_version: true, .. }, span)) = &depr { if stab.is_none() { struct_span_err!( self.tcx.sess, *span, E0549, "deprecated attribute must be paired with \ either stable or unstable attribute" ) .emit(); } } let stab = stab.map(|(stab, span)| { // Error if prohibited, or can't inherit anything from a container. if kind == AnnotationKind::Prohibited || (kind == AnnotationKind::Container && stab.level.is_stable() && is_deprecated) { self.tcx.sess.struct_span_err(span,"this stability annotation is useless") .span_label(span, "useless stability annotation") .span_label(item_sp, "the stability attribute annotates this item") .emit(); } debug!("annotate: found {:?}", stab); // Check if deprecated_since < stable_since. If it is, // this is *almost surely* an accident. if let (&Some(dep_since), &attr::Stable { since: stab_since, .. }) = (&depr.as_ref().and_then(|(d, _)| d.since), &stab.level) { // Explicit version of iter::order::lt to handle parse errors properly for (dep_v, stab_v) in iter::zip(dep_since.as_str().split('.'), stab_since.as_str().split('.')) { match stab_v.parse::() { Err(_) => { self.tcx.sess.struct_span_err(span, "invalid stability version found") .span_label(span, "invalid stability version") .span_label(item_sp, "the stability attribute annotates this item") .emit(); break; } Ok(stab_vp) => match dep_v.parse::() { Ok(dep_vp) => match dep_vp.cmp(&stab_vp) { Ordering::Less => { self.tcx.sess.struct_span_err(span, "an API can't be stabilized after it is deprecated") .span_label(span, "invalid version") .span_label(item_sp, "the stability attribute annotates this item") .emit(); break; } Ordering::Equal => continue, Ordering::Greater => break, }, Err(_) => { if dep_v != "TBD" { self.tcx.sess.struct_span_err(span, "invalid deprecation version found") .span_label(span, "invalid deprecation version") .span_label(item_sp, "the stability attribute annotates this item") .emit(); } break; } }, } } } if let Stability { level: Unstable { implied_by: Some(implied_by), .. }, feature } = stab { self.index.implications.insert(implied_by, feature); } self.index.stab_map.insert(def_id, stab); stab }); if stab.is_none() { debug!("annotate: stab not found, parent = {:?}", self.parent_stab); if let Some(stab) = self.parent_stab { if inherit_deprecation.yes() && stab.is_unstable() || inherit_from_parent.yes() { self.index.stab_map.insert(def_id, stab); } } } self.recurse_with_stability_attrs( depr.map(|(d, _)| DeprecationEntry::local(d, def_id)), stab, if inherit_const_stability.yes() { const_stab } else { None }, visit_children, ); } fn recurse_with_stability_attrs( &mut self, depr: Option, stab: Option, const_stab: Option, f: impl FnOnce(&mut Self), ) { // These will be `Some` if this item changes the corresponding stability attribute. let mut replaced_parent_depr = None; let mut replaced_parent_stab = None; let mut replaced_parent_const_stab = None; if let Some(depr) = depr { replaced_parent_depr = Some(replace(&mut self.parent_depr, Some(depr))); } if let Some(stab) = stab { replaced_parent_stab = Some(replace(&mut self.parent_stab, Some(stab))); } if let Some(const_stab) = const_stab { replaced_parent_const_stab = Some(replace(&mut self.parent_const_stab, Some(const_stab))); } f(self); if let Some(orig_parent_depr) = replaced_parent_depr { self.parent_depr = orig_parent_depr; } if let Some(orig_parent_stab) = replaced_parent_stab { self.parent_stab = orig_parent_stab; } if let Some(orig_parent_const_stab) = replaced_parent_const_stab { self.parent_const_stab = orig_parent_const_stab; } } } impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> { /// Because stability levels are scoped lexically, we want to walk /// nested items in the context of the outer item, so enable /// deep-walking. type NestedFilter = nested_filter::All; fn nested_visit_map(&mut self) -> Self::Map { self.tcx.hir() } fn visit_item(&mut self, i: &'tcx Item<'tcx>) { let orig_in_trait_impl = self.in_trait_impl; let mut kind = AnnotationKind::Required; let mut const_stab_inherit = InheritConstStability::No; let mut fn_sig = None; match i.kind { // Inherent impls and foreign modules serve only as containers for other items, // they don't have their own stability. They still can be annotated as unstable // and propagate this instability to children, but this annotation is completely // optional. They inherit stability from their parents when unannotated. hir::ItemKind::Impl(hir::Impl { of_trait: None, .. }) | hir::ItemKind::ForeignMod { .. } => { self.in_trait_impl = false; kind = AnnotationKind::Container; } hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) => { self.in_trait_impl = true; kind = AnnotationKind::DeprecationProhibited; const_stab_inherit = InheritConstStability::Yes; } hir::ItemKind::Struct(ref sd, _) => { if let Some(ctor_hir_id) = sd.ctor_hir_id() { self.annotate( self.tcx.hir().local_def_id(ctor_hir_id), i.span, None, AnnotationKind::Required, InheritDeprecation::Yes, InheritConstStability::No, InheritStability::Yes, |_| {}, ) } } hir::ItemKind::Fn(ref item_fn_sig, _, _) => { fn_sig = Some(item_fn_sig); } _ => {} } self.annotate( i.def_id, i.span, fn_sig, kind, InheritDeprecation::Yes, const_stab_inherit, InheritStability::No, |v| intravisit::walk_item(v, i), ); self.in_trait_impl = orig_in_trait_impl; } fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem<'tcx>) { let fn_sig = match ti.kind { hir::TraitItemKind::Fn(ref fn_sig, _) => Some(fn_sig), _ => None, }; self.annotate( ti.def_id, ti.span, fn_sig, AnnotationKind::Required, InheritDeprecation::Yes, InheritConstStability::No, InheritStability::No, |v| { intravisit::walk_trait_item(v, ti); }, ); } fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem<'tcx>) { let kind = if self.in_trait_impl { AnnotationKind::Prohibited } else { AnnotationKind::Required }; let fn_sig = match ii.kind { hir::ImplItemKind::Fn(ref fn_sig, _) => Some(fn_sig), _ => None, }; self.annotate( ii.def_id, ii.span, fn_sig, kind, InheritDeprecation::Yes, InheritConstStability::No, InheritStability::No, |v| { intravisit::walk_impl_item(v, ii); }, ); } fn visit_variant(&mut self, var: &'tcx Variant<'tcx>, g: &'tcx Generics<'tcx>, item_id: HirId) { self.annotate( self.tcx.hir().local_def_id(var.id), var.span, None, AnnotationKind::Required, InheritDeprecation::Yes, InheritConstStability::No, InheritStability::Yes, |v| { if let Some(ctor_hir_id) = var.data.ctor_hir_id() { v.annotate( v.tcx.hir().local_def_id(ctor_hir_id), var.span, None, AnnotationKind::Required, InheritDeprecation::Yes, InheritConstStability::No, InheritStability::No, |_| {}, ); } intravisit::walk_variant(v, var, g, item_id) }, ) } fn visit_field_def(&mut self, s: &'tcx FieldDef<'tcx>) { self.annotate( self.tcx.hir().local_def_id(s.hir_id), s.span, None, AnnotationKind::Required, InheritDeprecation::Yes, InheritConstStability::No, InheritStability::Yes, |v| { intravisit::walk_field_def(v, s); }, ); } fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem<'tcx>) { self.annotate( i.def_id, i.span, None, AnnotationKind::Required, InheritDeprecation::Yes, InheritConstStability::No, InheritStability::No, |v| { intravisit::walk_foreign_item(v, i); }, ); } fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam<'tcx>) { let kind = match &p.kind { // Allow stability attributes on default generic arguments. hir::GenericParamKind::Type { default: Some(_), .. } | hir::GenericParamKind::Const { default: Some(_), .. } => AnnotationKind::Container, _ => AnnotationKind::Prohibited, }; self.annotate( self.tcx.hir().local_def_id(p.hir_id), p.span, None, kind, InheritDeprecation::No, InheritConstStability::No, InheritStability::No, |v| { intravisit::walk_generic_param(v, p); }, ); } } struct MissingStabilityAnnotations<'tcx> { tcx: TyCtxt<'tcx>, access_levels: &'tcx AccessLevels, } impl<'tcx> MissingStabilityAnnotations<'tcx> { fn check_missing_stability(&self, def_id: LocalDefId, span: Span) { let stab = self.tcx.stability().local_stability(def_id); if !self.tcx.sess.opts.test && stab.is_none() && self.access_levels.is_reachable(def_id) { let descr = self.tcx.def_kind(def_id).descr(def_id.to_def_id()); self.tcx.sess.span_err(span, &format!("{} has missing stability attribute", descr)); } } fn check_missing_const_stability(&self, def_id: LocalDefId, span: Span) { if !self.tcx.features().staged_api { return; } let is_const = self.tcx.is_const_fn(def_id.to_def_id()) || self.tcx.is_const_trait_impl_raw(def_id.to_def_id()); let is_stable = self .tcx .lookup_stability(def_id) .map_or(false, |stability| stability.level.is_stable()); let missing_const_stability_attribute = self.tcx.lookup_const_stability(def_id).is_none(); let is_reachable = self.access_levels.is_reachable(def_id); if is_const && is_stable && missing_const_stability_attribute && is_reachable { let descr = self.tcx.def_kind(def_id).descr(def_id.to_def_id()); self.tcx.sess.span_err(span, &format!("{descr} has missing const stability attribute")); } } } impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> { type NestedFilter = nested_filter::OnlyBodies; fn nested_visit_map(&mut self) -> Self::Map { self.tcx.hir() } fn visit_item(&mut self, i: &'tcx Item<'tcx>) { // Inherent impls and foreign modules serve only as containers for other items, // they don't have their own stability. They still can be annotated as unstable // and propagate this instability to children, but this annotation is completely // optional. They inherit stability from their parents when unannotated. if !matches!( i.kind, hir::ItemKind::Impl(hir::Impl { of_trait: None, .. }) | hir::ItemKind::ForeignMod { .. } ) { self.check_missing_stability(i.def_id, i.span); } // Ensure stable `const fn` have a const stability attribute. self.check_missing_const_stability(i.def_id, i.span); intravisit::walk_item(self, i) } fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem<'tcx>) { self.check_missing_stability(ti.def_id, ti.span); intravisit::walk_trait_item(self, ti); } fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem<'tcx>) { let impl_def_id = self.tcx.hir().get_parent_item(ii.hir_id()); if self.tcx.impl_trait_ref(impl_def_id).is_none() { self.check_missing_stability(ii.def_id, ii.span); self.check_missing_const_stability(ii.def_id, ii.span); } intravisit::walk_impl_item(self, ii); } fn visit_variant(&mut self, var: &'tcx Variant<'tcx>, g: &'tcx Generics<'tcx>, item_id: HirId) { self.check_missing_stability(self.tcx.hir().local_def_id(var.id), var.span); intravisit::walk_variant(self, var, g, item_id); } fn visit_field_def(&mut self, s: &'tcx FieldDef<'tcx>) { self.check_missing_stability(self.tcx.hir().local_def_id(s.hir_id), s.span); intravisit::walk_field_def(self, s); } fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem<'tcx>) { self.check_missing_stability(i.def_id, i.span); intravisit::walk_foreign_item(self, i); } // Note that we don't need to `check_missing_stability` for default generic parameters, // as we assume that any default generic parameters without attributes are automatically // stable (assuming they have not inherited instability from their parent). } fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index { let mut index = Index { stab_map: Default::default(), const_stab_map: Default::default(), depr_map: Default::default(), implications: Default::default(), }; { let mut annotator = Annotator { tcx, index: &mut index, parent_stab: None, parent_const_stab: None, parent_depr: None, in_trait_impl: false, }; // If the `-Z force-unstable-if-unmarked` flag is passed then we provide // a parent stability annotation which indicates that this is private // with the `rustc_private` feature. This is intended for use when // compiling `librustc_*` crates themselves so we can leverage crates.io // while maintaining the invariant that all sysroot crates are unstable // by default and are unable to be used. if tcx.sess.opts.unstable_opts.force_unstable_if_unmarked { let stability = Stability { level: attr::StabilityLevel::Unstable { reason: UnstableReason::Default, issue: NonZeroU32::new(27812), is_soft: false, implied_by: None, }, feature: sym::rustc_private, }; annotator.parent_stab = Some(stability); } annotator.annotate( CRATE_DEF_ID, tcx.hir().span(CRATE_HIR_ID), None, AnnotationKind::Required, InheritDeprecation::Yes, InheritConstStability::No, InheritStability::No, |v| tcx.hir().walk_toplevel_module(v), ); } index } /// Cross-references the feature names of unstable APIs with enabled /// features and possibly prints errors. fn check_mod_unstable_api_usage(tcx: TyCtxt<'_>, module_def_id: LocalDefId) { tcx.hir().visit_item_likes_in_module(module_def_id, &mut Checker { tcx }); } pub(crate) fn provide(providers: &mut Providers) { *providers = Providers { check_mod_unstable_api_usage, stability_index, stability_implications: |tcx, _| tcx.stability().implications.clone(), lookup_stability: |tcx, id| tcx.stability().local_stability(id.expect_local()), lookup_const_stability: |tcx, id| tcx.stability().local_const_stability(id.expect_local()), lookup_deprecation_entry: |tcx, id| { tcx.stability().local_deprecation_entry(id.expect_local()) }, ..*providers }; } struct Checker<'tcx> { tcx: TyCtxt<'tcx>, } impl<'tcx> Visitor<'tcx> for Checker<'tcx> { type NestedFilter = nested_filter::OnlyBodies; /// Because stability levels are scoped lexically, we want to walk /// nested items in the context of the outer item, so enable /// deep-walking. fn nested_visit_map(&mut self) -> Self::Map { self.tcx.hir() } fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { match item.kind { hir::ItemKind::ExternCrate(_) => { // compiler-generated `extern crate` items have a dummy span. // `std` is still checked for the `restricted-std` feature. if item.span.is_dummy() && item.ident.name != sym::std { return; } let Some(cnum) = self.tcx.extern_mod_stmt_cnum(item.def_id) else { return; }; let def_id = cnum.as_def_id(); self.tcx.check_stability(def_id, Some(item.hir_id()), item.span, None); } // For implementations of traits, check the stability of each item // individually as it's possible to have a stable trait with unstable // items. hir::ItemKind::Impl(hir::Impl { of_trait: Some(ref t), self_ty, items, constness, .. }) => { let features = self.tcx.features(); if features.staged_api { let attrs = self.tcx.hir().attrs(item.hir_id()); let (stab, const_stab) = attr::find_stability(&self.tcx.sess, attrs, item.span); // If this impl block has an #[unstable] attribute, give an // error if all involved types and traits are stable, because // it will have no effect. // See: https://github.com/rust-lang/rust/issues/55436 if let Some((Stability { level: attr::Unstable { .. }, .. }, span)) = stab { let mut c = CheckTraitImplStable { tcx: self.tcx, fully_stable: true }; c.visit_ty(self_ty); c.visit_trait_ref(t); if c.fully_stable { self.tcx.struct_span_lint_hir( INEFFECTIVE_UNSTABLE_TRAIT_IMPL, item.hir_id(), span, |lint| {lint .build("an `#[unstable]` annotation here has no effect") .note("see issue #55436 for more information") .emit();} ); } } // `#![feature(const_trait_impl)]` is unstable, so any impl declared stable // needs to have an error emitted. if features.const_trait_impl && *constness == hir::Constness::Const && const_stab.map_or(false, |(stab, _)| stab.is_const_stable()) { self.tcx .sess .struct_span_err(item.span, "trait implementations cannot be const stable yet") .note("see issue #67792 for more information") .emit(); } } for impl_item_ref in *items { let impl_item = self.tcx.associated_item(impl_item_ref.id.def_id); if let Some(def_id) = impl_item.trait_item_def_id { // Pass `None` to skip deprecation warnings. self.tcx.check_stability(def_id, None, impl_item_ref.span, None); } } } _ => (/* pass */), } intravisit::walk_item(self, item); } fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, id: hir::HirId) { if let Some(def_id) = path.res.opt_def_id() { let method_span = path.segments.last().map(|s| s.ident.span); let item_is_allowed = self.tcx.check_stability_allow_unstable( def_id, Some(id), path.span, method_span, if is_unstable_reexport(self.tcx, id) { AllowUnstable::Yes } else { AllowUnstable::No }, ); let is_allowed_through_unstable_modules = |def_id| { self.tcx .lookup_stability(def_id) .map(|stab| match stab.level { StabilityLevel::Stable { allowed_through_unstable_modules, .. } => { allowed_through_unstable_modules } _ => false, }) .unwrap_or(false) }; if item_is_allowed && !is_allowed_through_unstable_modules(def_id) { // Check parent modules stability as well if the item the path refers to is itself // stable. We only emit warnings for unstable path segments if the item is stable // or allowed because stability is often inherited, so the most common case is that // both the segments and the item are unstable behind the same feature flag. // // We check here rather than in `visit_path_segment` to prevent visiting the last // path segment twice // // We include special cases via #[rustc_allowed_through_unstable_modules] for items // that were accidentally stabilized through unstable paths before this check was // added, such as `core::intrinsics::transmute` let parents = path.segments.iter().rev().skip(1); for path_segment in parents { if let Some(def_id) = path_segment.res.as_ref().and_then(Res::opt_def_id) { // use `None` for id to prevent deprecation check self.tcx.check_stability_allow_unstable( def_id, None, path.span, None, if is_unstable_reexport(self.tcx, id) { AllowUnstable::Yes } else { AllowUnstable::No }, ); } } } } intravisit::walk_path(self, path) } } /// Check whether a path is a `use` item that has been marked as unstable. /// /// See issue #94972 for details on why this is a special case fn is_unstable_reexport<'tcx>(tcx: TyCtxt<'tcx>, id: hir::HirId) -> bool { // Get the LocalDefId so we can lookup the item to check the kind. let Some(def_id) = tcx.hir().opt_local_def_id(id) else { return false; }; let Some(stab) = tcx.stability().local_stability(def_id) else { return false; }; if stab.level.is_stable() { // The re-export is not marked as unstable, don't override return false; } // If this is a path that isn't a use, we don't need to do anything special if !matches!(tcx.hir().item(hir::ItemId { def_id }).kind, ItemKind::Use(..)) { return false; } true } struct CheckTraitImplStable<'tcx> { tcx: TyCtxt<'tcx>, fully_stable: bool, } impl<'tcx> Visitor<'tcx> for CheckTraitImplStable<'tcx> { fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, _id: hir::HirId) { if let Some(def_id) = path.res.opt_def_id() { if let Some(stab) = self.tcx.lookup_stability(def_id) { self.fully_stable &= stab.level.is_stable(); } } intravisit::walk_path(self, path) } fn visit_trait_ref(&mut self, t: &'tcx TraitRef<'tcx>) { if let Res::Def(DefKind::Trait, trait_did) = t.path.res { if let Some(stab) = self.tcx.lookup_stability(trait_did) { self.fully_stable &= stab.level.is_stable(); } } intravisit::walk_trait_ref(self, t) } fn visit_ty(&mut self, t: &'tcx Ty<'tcx>) { if let TyKind::Never = t.kind { self.fully_stable = false; } intravisit::walk_ty(self, t) } } /// Given the list of enabled features that were not language features (i.e., that /// were expected to be library features), and the list of features used from /// libraries, identify activated features that don't exist and error about them. pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) { let is_staged_api = tcx.sess.opts.unstable_opts.force_unstable_if_unmarked || tcx.features().staged_api; if is_staged_api { let access_levels = &tcx.privacy_access_levels(()); let mut missing = MissingStabilityAnnotations { tcx, access_levels }; missing.check_missing_stability(CRATE_DEF_ID, tcx.hir().span(CRATE_HIR_ID)); tcx.hir().walk_toplevel_module(&mut missing); tcx.hir().visit_all_item_likes_in_crate(&mut missing); } let declared_lang_features = &tcx.features().declared_lang_features; let mut lang_features = FxHashSet::default(); for &(feature, span, since) in declared_lang_features { if let Some(since) = since { // Warn if the user has enabled an already-stable lang feature. unnecessary_stable_feature_lint(tcx, span, feature, since); } if !lang_features.insert(feature) { // Warn if the user enables a lang feature multiple times. duplicate_feature_err(tcx.sess, span, feature); } } let declared_lib_features = &tcx.features().declared_lib_features; let mut remaining_lib_features = FxIndexMap::default(); for (feature, span) in declared_lib_features { if !tcx.sess.opts.unstable_features.is_nightly_build() { struct_span_err!( tcx.sess, *span, E0554, "`#![feature]` may not be used on the {} release channel", env!("CFG_RELEASE_CHANNEL") ) .emit(); } if remaining_lib_features.contains_key(&feature) { // Warn if the user enables a lib feature multiple times. duplicate_feature_err(tcx.sess, *span, *feature); } remaining_lib_features.insert(feature, *span); } // `stdbuild` has special handling for `libc`, so we need to // recognise the feature when building std. // Likewise, libtest is handled specially, so `test` isn't // available as we'd like it to be. // FIXME: only remove `libc` when `stdbuild` is active. // FIXME: remove special casing for `test`. remaining_lib_features.remove(&sym::libc); remaining_lib_features.remove(&sym::test); // We always collect the lib features declared in the current crate, even if there are // no unknown features, because the collection also does feature attribute validation. let local_defined_features = tcx.lib_features(()); let mut all_lib_features: FxHashMap<_, _> = local_defined_features.to_vec().iter().map(|el| *el).collect(); let mut implications = tcx.stability_implications(rustc_hir::def_id::LOCAL_CRATE).clone(); for &cnum in tcx.crates(()) { implications.extend(tcx.stability_implications(cnum)); all_lib_features.extend(tcx.defined_lib_features(cnum).iter().map(|el| *el)); } // Check that every feature referenced by an `implied_by` exists (for features defined in the // local crate). for (implied_by, feature) in tcx.stability_implications(rustc_hir::def_id::LOCAL_CRATE) { // Only `implied_by` needs to be checked, `feature` is guaranteed to exist. if !all_lib_features.contains_key(implied_by) { let span = local_defined_features .stable .get(feature) .map(|(_, span)| span) .or_else(|| local_defined_features.unstable.get(feature)) .expect("feature that implied another does not exist"); tcx.sess .struct_span_err( *span, format!("feature `{implied_by}` implying `{feature}` does not exist"), ) .emit(); } } if !remaining_lib_features.is_empty() { for (feature, since) in all_lib_features.iter() { if let Some(since) = since && let Some(span) = remaining_lib_features.get(&feature) { // Warn if the user has enabled an already-stable lib feature. if let Some(implies) = implications.get(&feature) { unnecessary_partially_stable_feature_lint(tcx, *span, *feature, *implies, *since); } else { unnecessary_stable_feature_lint(tcx, *span, *feature, *since); } } remaining_lib_features.remove(&feature); if remaining_lib_features.is_empty() { break; } } } for (feature, span) in remaining_lib_features { struct_span_err!(tcx.sess, span, E0635, "unknown feature `{}`", feature).emit(); } // FIXME(#44232): the `used_features` table no longer exists, so we // don't lint about unused features. We should re-enable this one day! } fn unnecessary_partially_stable_feature_lint( tcx: TyCtxt<'_>, span: Span, feature: Symbol, implies: Symbol, since: Symbol, ) { tcx.struct_span_lint_hir(lint::builtin::STABLE_FEATURES, hir::CRATE_HIR_ID, span, |lint| { lint.build(&format!( "the feature `{feature}` has been partially stabilized since {since} and is succeeded \ by the feature `{implies}`" )) .span_suggestion( span, &format!( "if you are using features which are still unstable, change to using `{implies}`" ), implies, Applicability::MaybeIncorrect, ) .span_suggestion( tcx.sess.source_map().span_extend_to_line(span), "if you are using features which are now stable, remove this line", "", Applicability::MaybeIncorrect, ) .emit(); }); } fn unnecessary_stable_feature_lint(tcx: TyCtxt<'_>, span: Span, feature: Symbol, since: Symbol) { tcx.struct_span_lint_hir(lint::builtin::STABLE_FEATURES, hir::CRATE_HIR_ID, span, |lint| { lint.build(&format!( "the feature `{feature}` has been stable since {since} and no longer requires an \ attribute to enable", )) .emit(); }); } fn duplicate_feature_err(sess: &Session, span: Span, feature: Symbol) { struct_span_err!(sess, span, E0636, "the feature `{}` has already been declared", feature) .emit(); } fn missing_const_err(session: &Session, fn_sig_span: Span, const_span: Span) { const ERROR_MSG: &'static str = "attributes `#[rustc_const_unstable]` \ and `#[rustc_const_stable]` require \ the function or method to be `const`"; session .struct_span_err(fn_sig_span, ERROR_MSG) .span_help(fn_sig_span, "make the function or method const") .span_label(const_span, "attribute specified here") .emit(); }