From 7cf35367aa356f6d08479210134a0ec54795c69b Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Tue, 18 Jan 2022 21:01:07 +0100 Subject: [PATCH 1/3] Querify lookup_deprecation_entry. --- compiler/rustc_attr/src/builtin.rs | 6 +- compiler/rustc_expand/src/base.rs | 2 +- compiler/rustc_middle/src/middle/stability.rs | 5 - compiler/rustc_passes/src/stability.rs | 139 +++++++++++------- 4 files changed, 86 insertions(+), 66 deletions(-) diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs index 40531c1c164f2..cfb0fe0ae8e8f 100644 --- a/compiler/rustc_attr/src/builtin.rs +++ b/compiler/rustc_attr/src/builtin.rs @@ -797,11 +797,7 @@ pub struct Deprecation { } /// Finds the deprecation attribute. `None` if none exists. -pub fn find_deprecation(sess: &Session, attrs: &[Attribute]) -> Option<(Deprecation, Span)> { - find_deprecation_generic(sess, attrs.iter()) -} - -fn find_deprecation_generic<'a, I>(sess: &Session, attrs_iter: I) -> Option<(Deprecation, Span)> +pub fn find_deprecation<'a, I>(sess: &Session, attrs_iter: I) -> Option<(Deprecation, Span)> where I: Iterator, { diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs index 5a48473d5b07c..25d242d26db1a 100644 --- a/compiler/rustc_expand/src/base.rs +++ b/compiler/rustc_expand/src/base.rs @@ -814,7 +814,7 @@ impl SyntaxExtension { allow_internal_unstable: (!allow_internal_unstable.is_empty()) .then(|| allow_internal_unstable.into()), stability: stability.map(|(s, _)| s), - deprecation: attr::find_deprecation(&sess, attrs).map(|(d, _)| d), + deprecation: attr::find_deprecation(&sess, attrs.iter()).map(|(d, _)| d), helper_attrs, edition, builtin_name, diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs index 0836f236e248f..a92c0f4ffed76 100644 --- a/compiler/rustc_middle/src/middle/stability.rs +++ b/compiler/rustc_middle/src/middle/stability.rs @@ -62,7 +62,6 @@ pub struct Index { pub stab_map: FxHashMap, pub const_stab_map: FxHashMap, pub default_body_stab_map: FxHashMap, - pub depr_map: FxHashMap, /// Mapping from feature name to feature name based on the `implied_by` field of `#[unstable]` /// attributes. If a `#[unstable(feature = "implier", implied_by = "impliee")]` attribute /// exists, then this map will have a `impliee -> implier` entry. @@ -90,10 +89,6 @@ impl Index { pub fn local_default_body_stability(&self, def_id: LocalDefId) -> Option { self.default_body_stab_map.get(&def_id).copied() } - - pub fn local_deprecation_entry(&self, def_id: LocalDefId) -> Option { - self.depr_map.get(&def_id).cloned() - } } pub fn report_unstable( diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs index 47911aef25d4f..1e1c96db317ec 100644 --- a/compiler/rustc_passes/src/stability.rs +++ b/compiler/rustc_passes/src/stability.rs @@ -15,14 +15,14 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap}; use rustc_errors::Applicability; use rustc_hir as hir; use rustc_hir::def::{DefKind, Res}; -use rustc_hir::def_id::{LocalDefId, CRATE_DEF_ID}; +use rustc_hir::def_id::{DefId, LocalDefId, CRATE_DEF_ID}; use rustc_hir::hir_id::CRATE_HIR_ID; use rustc_hir::intravisit::{self, Visitor}; use rustc_hir::{FieldDef, Item, ItemKind, TraitRef, Ty, TyKind, Variant}; use rustc_middle::hir::nested_filter; use rustc_middle::middle::privacy::EffectiveVisibilities; use rustc_middle::middle::stability::{AllowUnstable, DeprecationEntry, Index}; -use rustc_middle::ty::{query::Providers, TyCtxt}; +use rustc_middle::ty::{query::Providers, DefIdTree, TyCtxt}; use rustc_session::lint; use rustc_session::lint::builtin::{INEFFECTIVE_UNSTABLE_TRAIT_IMPL, USELESS_DEPRECATED}; use rustc_span::symbol::{sym, Symbol}; @@ -90,13 +90,84 @@ impl InheritStability { } } +fn inherit_deprecation(def_kind: DefKind) -> InheritDeprecation { + match def_kind { + DefKind::LifetimeParam | DefKind::TyParam | DefKind::ConstParam => InheritDeprecation::No, + _ => InheritDeprecation::Yes, + } +} + +fn annotation_kind(tcx: TyCtxt<'_>, def_id: LocalDefId) -> AnnotationKind { + match tcx.hir().get_by_def_id(def_id) { + hir::Node::Item(i) => 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 unstability 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 { .. } => AnnotationKind::Container, + hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) => { + AnnotationKind::DeprecationProhibited + } + _ => AnnotationKind::Required, + }, + hir::Node::ImplItem(ii) => { + let item = tcx.hir().expect_item(tcx.hir().get_parent_item(ii.hir_id()).def_id); + match item.kind { + hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) => { + AnnotationKind::Prohibited + } + _ => AnnotationKind::Required, + } + } + hir::Node::GenericParam(p) => match &p.kind { + // Allow stability attributes on default generic arguments. + hir::GenericParamKind::Type { default: Some(_), .. } + | hir::GenericParamKind::Const { default: Some(_), .. } => AnnotationKind::Container, + _ => AnnotationKind::Prohibited, + }, + + _ => AnnotationKind::Required, + } +} + +fn lookup_deprecation_entry(tcx: TyCtxt<'_>, def_id: DefId) -> Option { + let def_id = def_id.expect_local(); + let attrs = tcx.get_attrs(def_id.to_def_id(), sym::deprecated); + + let depr = attr::find_deprecation(&tcx.sess, attrs); + let Some((depr, span)) = &depr else { + if inherit_deprecation(tcx.def_kind(def_id)).yes() { + let parent_id = tcx.opt_local_parent(def_id)?; + let parent_depr = tcx.lookup_deprecation_entry(parent_id)?; + info!("tagging child {:?} as deprecated from parent", def_id); + return Some(parent_depr); + } + + return None; + }; + + let kind = annotation_kind(tcx, def_id); + if matches!(kind, AnnotationKind::Prohibited | AnnotationKind::DeprecationProhibited) { + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); + tcx.emit_spanned_lint( + USELESS_DEPRECATED, + hir_id, + *span, + errors::DeprecatedAnnotationHasNoEffect { span: *span }, + ); + } + + // `Deprecation` is just two pointers, no need to intern it + Some(DeprecationEntry::local(*depr, def_id)) +} + /// 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, } @@ -117,34 +188,8 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> { ) 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 matches!(kind, AnnotationKind::Prohibited | AnnotationKind::DeprecationProhibited) { - let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); - self.tcx.emit_spanned_lint( - USELESS_DEPRECATED, - hir_id, - *span, - errors::DeprecatedAnnotationHasNoEffect { span: *span }, - ); - } - - // `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); - } - } + let depr = self.tcx.lookup_deprecation_entry(def_id); + let is_deprecated = depr.is_some(); if !self.tcx.features().staged_api { // Propagate unstability. This can happen even for non-staged-api crates in case @@ -155,15 +200,12 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> { } } - self.recurse_with_stability_attrs( - depr.map(|(d, _)| DeprecationEntry::local(d, def_id)), - None, - None, - visit_children, - ); + self.recurse_with_stability_attrs(None, None, visit_children); return; } + 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 (stab, const_stab, body_stab) = attr::find_stability(&self.tcx.sess, attrs, item_sp); let mut const_span = None; @@ -201,9 +243,9 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> { } } - if let Some((rustc_attr::Deprecation { is_since_rustc_version: true, .. }, span)) = &depr { - if stab.is_none() { - self.tcx.sess.emit_err(DeprecatedAttribute { span: *span }); + if stab.is_none() && depr.map_or(false, |d| d.attr.is_since_rustc_version) { + if let Some(attr) = attrs.iter().find(|attr| attr.has_name(sym::deprecated)) { + self.tcx.sess.emit_err(DeprecatedAttribute { span: attr.span }); } } @@ -227,7 +269,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> { // 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) + (&depr.as_ref().and_then(|d| d.attr.since), &stab.level) { // Explicit version of iter::order::lt to handle parse errors properly for (dep_v, stab_v) in @@ -282,7 +324,6 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> { } 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, @@ -291,19 +332,14 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> { 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))); } @@ -314,9 +350,6 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> { 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; } @@ -627,7 +660,6 @@ fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index { stab_map: Default::default(), const_stab_map: Default::default(), default_body_stab_map: Default::default(), - depr_map: Default::default(), implications: Default::default(), }; @@ -637,7 +669,6 @@ fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index { index: &mut index, parent_stab: None, parent_const_stab: None, - parent_depr: None, in_trait_impl: false, }; @@ -690,9 +721,7 @@ pub(crate) fn provide(providers: &mut Providers) { lookup_default_body_stability: |tcx, id| { tcx.stability().local_default_body_stability(id.expect_local()) }, - lookup_deprecation_entry: |tcx, id| { - tcx.stability().local_deprecation_entry(id.expect_local()) - }, + lookup_deprecation_entry, ..*providers }; } From 61c35e6de1e58352179b8c5bd6a6dbd0845fe82d Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sun, 29 Jan 2023 15:16:18 +0000 Subject: [PATCH 2/3] Extract parse_stability and parse_unstability. --- compiler/rustc_attr/src/builtin.rs | 429 +++++++++++++++-------------- 1 file changed, 224 insertions(+), 205 deletions(-) diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs index cfb0fe0ae8e8f..21d6df3775c3c 100644 --- a/compiler/rustc_attr/src/builtin.rs +++ b/compiler/rustc_attr/src/builtin.rs @@ -245,15 +245,13 @@ fn find_stability_generic<'a, I>( where I: Iterator, { - use StabilityLevel::*; - let mut stab: Option<(Stability, Span)> = None; let mut const_stab: Option<(ConstStability, Span)> = None; let mut body_stab: Option<(DefaultBodyStability, Span)> = None; let mut promotable = false; let mut allowed_through_unstable_modules = false; - 'outer: for attr in attrs_iter { + for attr in attrs_iter { if ![ sym::rustc_const_unstable, sym::rustc_const_stable, @@ -275,27 +273,7 @@ where promotable = true; } else if attr.has_name(sym::rustc_allowed_through_unstable_modules) { allowed_through_unstable_modules = true; - } - // attributes with data - else if let Some(meta @ MetaItem { kind: MetaItemKind::List(metas), .. }) = &meta { - let get = |meta: &MetaItem, item: &mut Option| { - if item.is_some() { - handle_errors( - &sess.parse_sess, - meta.span, - AttrError::MultipleItem(pprust::path_to_string(&meta.path)), - ); - return false; - } - if let Some(v) = meta.value_str() { - *item = Some(v); - true - } else { - sess.emit_err(session_diagnostics::IncorrectMetaItem { span: meta.span }); - false - } - }; - + } else if let Some(meta) = &meta { let meta_name = meta.name_or_empty(); match meta_name { sym::rustc_const_unstable | sym::rustc_default_body_unstable | sym::unstable => { @@ -322,122 +300,18 @@ where break; } - let mut feature = None; - let mut reason = None; - let mut issue = None; - let mut issue_num = None; - let mut is_soft = false; - let mut implied_by = None; - for meta in metas { - let Some(mi) = meta.meta_item() else { - handle_errors( - &sess.parse_sess, - meta.span(), - AttrError::UnsupportedLiteral(UnsupportedLiteralReason::Generic, false), - ); - continue 'outer; - }; - match mi.name_or_empty() { - sym::feature => { - if !get(mi, &mut feature) { - continue 'outer; - } - } - sym::reason => { - if !get(mi, &mut reason) { - continue 'outer; - } - } - sym::issue => { - if !get(mi, &mut issue) { - continue 'outer; - } - - // These unwraps are safe because `get` ensures the meta item - // is a name/value pair string literal. - issue_num = match issue.unwrap().as_str() { - "none" => None, - issue => match issue.parse::() { - Ok(num) => Some(num), - Err(err) => { - sess.emit_err( - session_diagnostics::InvalidIssueString { - span: mi.span, - cause: session_diagnostics::InvalidIssueStringCause::from_int_error_kind( - mi.name_value_literal_span().unwrap(), - err.kind(), - ), - }, - ); - continue 'outer; - } - }, - }; - } - sym::soft => { - if !mi.is_word() { - sess.emit_err(session_diagnostics::SoftNoArgs { - span: mi.span, - }); - } - is_soft = true; - } - sym::implied_by => { - if !get(mi, &mut implied_by) { - continue 'outer; - } - } - _ => { - handle_errors( - &sess.parse_sess, - meta.span(), - AttrError::UnknownMetaItem( - pprust::path_to_string(&mi.path), - &["feature", "reason", "issue", "soft"], - ), - ); - continue 'outer; - } - } - } - - match (feature, reason, issue) { - (Some(feature), reason, Some(_)) => { - if !rustc_lexer::is_ident(feature.as_str()) { - handle_errors( - &sess.parse_sess, - attr.span, - AttrError::NonIdentFeature, - ); - continue; - } - let level = Unstable { - reason: UnstableReason::from_opt_reason(reason), - issue: issue_num, - is_soft, - implied_by, - }; - if sym::unstable == meta_name { - stab = Some((Stability { level, feature }, attr.span)); - } else if sym::rustc_const_unstable == meta_name { - const_stab = Some(( - ConstStability { level, feature, promotable: false }, - attr.span, - )); - } else if sym::rustc_default_body_unstable == meta_name { - body_stab = - Some((DefaultBodyStability { level, feature }, attr.span)); - } else { - unreachable!("Unknown stability attribute {meta_name}"); - } - } - (None, _, _) => { - handle_errors(&sess.parse_sess, attr.span, AttrError::MissingFeature); - continue; - } - _ => { - sess.emit_err(session_diagnostics::MissingIssue { span: attr.span }); - continue; + if let Some((feature, level)) = parse_unstability(sess, attr) { + if sym::unstable == meta_name { + stab = Some((Stability { level, feature }, attr.span)); + } else if sym::rustc_const_unstable == meta_name { + const_stab = Some(( + ConstStability { level, feature, promotable: false }, + attr.span, + )); + } else if sym::rustc_default_body_unstable == meta_name { + body_stab = Some((DefaultBodyStability { level, feature }, attr.span)); + } else { + unreachable!("Unknown stability attribute {meta_name}"); } } } @@ -457,71 +331,14 @@ where ); break; } - - let mut feature = None; - let mut since = None; - for meta in metas { - match meta { - NestedMetaItem::MetaItem(mi) => match mi.name_or_empty() { - sym::feature => { - if !get(mi, &mut feature) { - continue 'outer; - } - } - sym::since => { - if !get(mi, &mut since) { - continue 'outer; - } - } - _ => { - handle_errors( - &sess.parse_sess, - meta.span(), - AttrError::UnknownMetaItem( - pprust::path_to_string(&mi.path), - &["feature", "since"], - ), - ); - continue 'outer; - } - }, - NestedMetaItem::Lit(lit) => { - handle_errors( - &sess.parse_sess, - lit.span, - AttrError::UnsupportedLiteral( - UnsupportedLiteralReason::Generic, - false, - ), - ); - continue 'outer; - } - } - } - - if let Some(s) = since && s.as_str() == VERSION_PLACEHOLDER { - since = Some(rust_version_symbol()); - } - - match (feature, since) { - (Some(feature), Some(since)) => { - let level = Stable { since, allowed_through_unstable_modules: false }; - if sym::stable == meta_name { - stab = Some((Stability { level, feature }, attr.span)); - } else { - const_stab = Some(( - ConstStability { level, feature, promotable: false }, - attr.span, - )); - } - } - (None, _) => { - handle_errors(&sess.parse_sess, attr.span, AttrError::MissingFeature); - continue; - } - _ => { - handle_errors(&sess.parse_sess, attr.span, AttrError::MissingSince); - continue; + if let Some((feature, level)) = parse_stability(sess, attr) { + if sym::stable == meta_name { + stab = Some((Stability { level, feature }, attr.span)); + } else { + const_stab = Some(( + ConstStability { level, feature, promotable: false }, + attr.span, + )); } } } @@ -556,6 +373,208 @@ where (stab, const_stab, body_stab) } +fn parse_stability(sess: &Session, attr: &Attribute) -> Option<(Symbol, StabilityLevel)> { + let meta = attr.meta()?; + let MetaItem { kind: MetaItemKind::List(ref metas), .. } = meta else { return None }; + let insert = |meta: &MetaItem, item: &mut Option| { + if item.is_some() { + handle_errors( + &sess.parse_sess, + meta.span, + AttrError::MultipleItem(pprust::path_to_string(&meta.path)), + ); + return false; + } + if let Some(v) = meta.value_str() { + *item = Some(v); + true + } else { + sess.emit_err(session_diagnostics::IncorrectMetaItem { span: meta.span }); + false + } + }; + + let mut feature = None; + let mut since = None; + for meta in metas { + let Some(mi) = meta.meta_item() else { + handle_errors( + &sess.parse_sess, + meta.span(), + AttrError::UnsupportedLiteral(UnsupportedLiteralReason::Generic, false), + ); + return None; + }; + + match mi.name_or_empty() { + sym::feature => { + if !insert(mi, &mut feature) { + return None; + } + } + sym::since => { + if !insert(mi, &mut since) { + return None; + } + } + _ => { + handle_errors( + &sess.parse_sess, + meta.span(), + AttrError::UnknownMetaItem( + pprust::path_to_string(&mi.path), + &["feature", "since"], + ), + ); + return None; + } + } + } + + if let Some(s) = since && s.as_str() == VERSION_PLACEHOLDER { + since = Some(rust_version_symbol()); + } + + match (feature, since) { + (Some(feature), Some(since)) => { + let level = StabilityLevel::Stable { since, allowed_through_unstable_modules: false }; + Some((feature, level)) + } + (None, _) => { + handle_errors(&sess.parse_sess, attr.span, AttrError::MissingFeature); + None + } + _ => { + handle_errors(&sess.parse_sess, attr.span, AttrError::MissingSince); + None + } + } +} + +fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, StabilityLevel)> { + let meta = attr.meta()?; + let MetaItem { kind: MetaItemKind::List(ref metas), .. } = meta else { return None }; + let insert = |meta: &MetaItem, item: &mut Option| { + if item.is_some() { + handle_errors( + &sess.parse_sess, + meta.span, + AttrError::MultipleItem(pprust::path_to_string(&meta.path)), + ); + return false; + } + if let Some(v) = meta.value_str() { + *item = Some(v); + true + } else { + sess.emit_err(session_diagnostics::IncorrectMetaItem { span: meta.span }); + false + } + }; + + let mut feature = None; + let mut reason = None; + let mut issue = None; + let mut issue_num = None; + let mut is_soft = false; + let mut implied_by = None; + for meta in metas { + let Some(mi) = meta.meta_item() else { + handle_errors( + &sess.parse_sess, + meta.span(), + AttrError::UnsupportedLiteral(UnsupportedLiteralReason::Generic, false), + ); + return None; + }; + + match mi.name_or_empty() { + sym::feature => { + if !insert(mi, &mut feature) { + return None; + } + } + sym::reason => { + if !insert(mi, &mut reason) { + return None; + } + } + sym::issue => { + if !insert(mi, &mut issue) { + return None; + } + + // These unwraps are safe because `insert` ensures the meta item + // is a name/value pair string literal. + issue_num = match issue.unwrap().as_str() { + "none" => None, + issue => match issue.parse::() { + Ok(num) => Some(num), + Err(err) => { + sess.emit_err( + session_diagnostics::InvalidIssueString { + span: mi.span, + cause: session_diagnostics::InvalidIssueStringCause::from_int_error_kind( + mi.name_value_literal_span().unwrap(), + err.kind(), + ), + }, + ); + return None; + } + }, + }; + } + sym::soft => { + if !mi.is_word() { + sess.emit_err(session_diagnostics::SoftNoArgs { span: mi.span }); + } + is_soft = true; + } + sym::implied_by => { + if !insert(mi, &mut implied_by) { + return None; + } + } + _ => { + handle_errors( + &sess.parse_sess, + meta.span(), + AttrError::UnknownMetaItem( + pprust::path_to_string(&mi.path), + &["feature", "reason", "issue", "soft", "implied_by"], + ), + ); + return None; + } + } + } + + match (feature, reason, issue) { + (Some(feature), reason, Some(_)) => { + if !rustc_lexer::is_ident(feature.as_str()) { + handle_errors(&sess.parse_sess, attr.span, AttrError::NonIdentFeature); + return None; + } + let level = StabilityLevel::Unstable { + reason: UnstableReason::from_opt_reason(reason), + issue: issue_num, + is_soft, + implied_by, + }; + Some((feature, level)) + } + (None, _, _) => { + handle_errors(&sess.parse_sess, attr.span, AttrError::MissingFeature); + return None; + } + _ => { + sess.emit_err(session_diagnostics::MissingIssue { span: attr.span }); + return None; + } + } +} + pub fn find_crate_name(sess: &Session, attrs: &[Attribute]) -> Option { sess.first_attr_value_str_by_name(attrs, sym::crate_name) } From 87f62c37412dae039d43af549513d7e847ea2ade Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sun, 29 Jan 2023 15:56:47 +0000 Subject: [PATCH 3/3] Separate find_*_stability. --- compiler/rustc_attr/src/builtin.rs | 206 +++++++++++-------------- compiler/rustc_expand/src/base.rs | 4 +- compiler/rustc_passes/src/stability.rs | 8 +- 3 files changed, 101 insertions(+), 117 deletions(-) diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs index 21d6df3775c3c..9967329142836 100644 --- a/compiler/rustc_attr/src/builtin.rs +++ b/compiler/rustc_attr/src/builtin.rs @@ -232,118 +232,89 @@ pub fn find_stability( sess: &Session, attrs: &[Attribute], item_sp: Span, -) -> (Option<(Stability, Span)>, Option<(ConstStability, Span)>, Option<(DefaultBodyStability, Span)>) -{ - find_stability_generic(sess, attrs.iter(), item_sp) +) -> Option<(Stability, Span)> { + let mut stab: Option<(Stability, Span)> = None; + let mut allowed_through_unstable_modules = false; + + for attr in attrs { + match attr.name_or_empty() { + sym::rustc_allowed_through_unstable_modules => allowed_through_unstable_modules = true, + sym::unstable => { + if stab.is_some() { + handle_errors(&sess.parse_sess, attr.span, AttrError::MultipleStabilityLevels); + break; + } + + if let Some((feature, level)) = parse_unstability(sess, attr) { + stab = Some((Stability { level, feature }, attr.span)); + } + } + sym::stable => { + if stab.is_some() { + handle_errors(&sess.parse_sess, attr.span, AttrError::MultipleStabilityLevels); + break; + } + if let Some((feature, level)) = parse_stability(sess, attr) { + stab = Some((Stability { level, feature }, attr.span)); + } + } + _ => {} + } + } + + if allowed_through_unstable_modules { + match &mut stab { + Some(( + Stability { + level: StabilityLevel::Stable { allowed_through_unstable_modules, .. }, + .. + }, + _, + )) => *allowed_through_unstable_modules = true, + _ => { + sess.emit_err(session_diagnostics::RustcAllowedUnstablePairing { span: item_sp }); + } + } + } + + stab } -fn find_stability_generic<'a, I>( +/// Collects stability info from all stability attributes in `attrs`. +/// Returns `None` if no stability attributes are found. +pub fn find_const_stability( sess: &Session, - attrs_iter: I, + attrs: &[Attribute], item_sp: Span, -) -> (Option<(Stability, Span)>, Option<(ConstStability, Span)>, Option<(DefaultBodyStability, Span)>) -where - I: Iterator, -{ - let mut stab: Option<(Stability, Span)> = None; +) -> Option<(ConstStability, Span)> { let mut const_stab: Option<(ConstStability, Span)> = None; - let mut body_stab: Option<(DefaultBodyStability, Span)> = None; let mut promotable = false; - let mut allowed_through_unstable_modules = false; - - for attr in attrs_iter { - if ![ - sym::rustc_const_unstable, - sym::rustc_const_stable, - sym::unstable, - sym::stable, - sym::rustc_promotable, - sym::rustc_allowed_through_unstable_modules, - sym::rustc_default_body_unstable, - ] - .iter() - .any(|&s| attr.has_name(s)) - { - continue; // not a stability level - } - let meta = attr.meta(); - - if attr.has_name(sym::rustc_promotable) { - promotable = true; - } else if attr.has_name(sym::rustc_allowed_through_unstable_modules) { - allowed_through_unstable_modules = true; - } else if let Some(meta) = &meta { - let meta_name = meta.name_or_empty(); - match meta_name { - sym::rustc_const_unstable | sym::rustc_default_body_unstable | sym::unstable => { - if meta_name == sym::unstable && stab.is_some() { - handle_errors( - &sess.parse_sess, - attr.span, - AttrError::MultipleStabilityLevels, - ); - break; - } else if meta_name == sym::rustc_const_unstable && const_stab.is_some() { - handle_errors( - &sess.parse_sess, - attr.span, - AttrError::MultipleStabilityLevels, - ); - break; - } else if meta_name == sym::rustc_default_body_unstable && body_stab.is_some() { - handle_errors( - &sess.parse_sess, - attr.span, - AttrError::MultipleStabilityLevels, - ); - break; - } + for attr in attrs { + match attr.name_or_empty() { + sym::rustc_promotable => promotable = true, + sym::rustc_const_unstable => { + if const_stab.is_some() { + handle_errors(&sess.parse_sess, attr.span, AttrError::MultipleStabilityLevels); + break; + } - if let Some((feature, level)) = parse_unstability(sess, attr) { - if sym::unstable == meta_name { - stab = Some((Stability { level, feature }, attr.span)); - } else if sym::rustc_const_unstable == meta_name { - const_stab = Some(( - ConstStability { level, feature, promotable: false }, - attr.span, - )); - } else if sym::rustc_default_body_unstable == meta_name { - body_stab = Some((DefaultBodyStability { level, feature }, attr.span)); - } else { - unreachable!("Unknown stability attribute {meta_name}"); - } - } + if let Some((feature, level)) = parse_unstability(sess, attr) { + const_stab = + Some((ConstStability { level, feature, promotable: false }, attr.span)); } - sym::rustc_const_stable | sym::stable => { - if meta_name == sym::stable && stab.is_some() { - handle_errors( - &sess.parse_sess, - attr.span, - AttrError::MultipleStabilityLevels, - ); - break; - } else if meta_name == sym::rustc_const_stable && const_stab.is_some() { - handle_errors( - &sess.parse_sess, - attr.span, - AttrError::MultipleStabilityLevels, - ); - break; - } - if let Some((feature, level)) = parse_stability(sess, attr) { - if sym::stable == meta_name { - stab = Some((Stability { level, feature }, attr.span)); - } else { - const_stab = Some(( - ConstStability { level, feature, promotable: false }, - attr.span, - )); - } - } + } + sym::rustc_const_stable => { + if const_stab.is_some() { + handle_errors(&sess.parse_sess, attr.span, AttrError::MultipleStabilityLevels); + break; + } + if let Some((feature, level)) = parse_stability(sess, attr) { + const_stab = + Some((ConstStability { level, feature, promotable: false }, attr.span)); } - _ => unreachable!(), } + _ => {} } } @@ -355,22 +326,31 @@ where } } - if allowed_through_unstable_modules { - match &mut stab { - Some(( - Stability { - level: StabilityLevel::Stable { allowed_through_unstable_modules, .. }, - .. - }, - _, - )) => *allowed_through_unstable_modules = true, - _ => { - sess.emit_err(session_diagnostics::RustcAllowedUnstablePairing { span: item_sp }); + const_stab +} + +/// Collects stability info from all stability attributes in `attrs`. +/// Returns `None` if no stability attributes are found. +pub fn find_body_stability( + sess: &Session, + attrs: &[Attribute], +) -> Option<(DefaultBodyStability, Span)> { + let mut body_stab: Option<(DefaultBodyStability, Span)> = None; + + for attr in attrs { + if attr.has_name(sym::rustc_default_body_unstable) { + if body_stab.is_some() { + handle_errors(&sess.parse_sess, attr.span, AttrError::MultipleStabilityLevels); + break; + } + + if let Some((feature, level)) = parse_unstability(sess, attr) { + body_stab = Some((DefaultBodyStability { level, feature }, attr.span)); } } } - (stab, const_stab, body_stab) + body_stab } fn parse_stability(sess: &Session, attr: &Attribute) -> Option<(Symbol, StabilityLevel)> { diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs index 25d242d26db1a..a1d1580420325 100644 --- a/compiler/rustc_expand/src/base.rs +++ b/compiler/rustc_expand/src/base.rs @@ -794,7 +794,9 @@ impl SyntaxExtension { ) }) .unwrap_or_else(|| (None, helper_attrs)); - let (stability, const_stability, body_stability) = attr::find_stability(&sess, attrs, span); + let stability = attr::find_stability(&sess, attrs, span); + let const_stability = attr::find_const_stability(&sess, attrs, span); + let body_stability = attr::find_body_stability(&sess, attrs); if let Some((_, sp)) = const_stability { sess.emit_err(MacroConstStability { span: sp, diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs index 1e1c96db317ec..3e2b6c3504618 100644 --- a/compiler/rustc_passes/src/stability.rs +++ b/compiler/rustc_passes/src/stability.rs @@ -206,7 +206,9 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> { 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 (stab, const_stab, body_stab) = attr::find_stability(&self.tcx.sess, attrs, item_sp); + let stab = attr::find_stability(&self.tcx.sess, attrs, item_sp); + let const_stab = attr::find_const_stability(&self.tcx.sess, attrs, item_sp); + let body_stab = attr::find_body_stability(&self.tcx.sess, attrs); let mut const_span = None; let const_stab = const_stab.map(|(const_stab, const_span_node)| { @@ -769,8 +771,8 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> { 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); + let stab = attr::find_stability(&self.tcx.sess, attrs, item.span); + let const_stab = attr::find_const_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