-//! A higher level attributes based on TokenTree, with also some shortcuts.

-

-use std::{borrow::Cow, convert::identity, hash::Hash, ops};

-

-use base_db::Crate;

-use cfg::{CfgExpr, CfgOptions};

-use either::Either;

-use hir_expand::{

- HirFileId, InFile,

- attrs::{Attr, AttrId, RawAttrs, collect_attrs},

- span_map::SpanMapRef,

-};

-use intern::{Symbol, sym};

-use la_arena::{ArenaMap, Idx, RawIdx};

-use mbe::DelimiterKind;

-use rustc_abi::ReprOptions;

-use span::AstIdNode;

-use syntax::{

- AstPtr,

- ast::{self, HasAttrs},

-};

-use triomphe::Arc;

-use tt::iter::{TtElement, TtIter};

-

-use crate::{

- AdtId, AstIdLoc, AttrDefId, GenericParamId, HasModule, LocalFieldId, Lookup, MacroId,

- VariantId,

- db::DefDatabase,

- item_tree::block_item_tree_query,

- lang_item::LangItem,

- nameres::{ModuleOrigin, ModuleSource},

- src::{HasChildSource, HasSource},

-};

-

-/// Desugared attributes of an item post `cfg_attr` expansion.

-#[derive(Default, Debug, Clone, PartialEq, Eq)]

-pub struct Attrs(RawAttrs);

-

-#[derive(Debug, Clone, PartialEq, Eq)]

-pub struct AttrsWithOwner {

- attrs: Attrs,

- owner: AttrDefId,

-}

-

-impl Attrs {

- pub fn new(

- db: &dyn DefDatabase,

- owner: &dyn ast::HasAttrs,

- span_map: SpanMapRef<'_>,

- cfg_options: &CfgOptions,

- ) -> Self {

- Attrs(RawAttrs::new_expanded(db, owner, span_map, cfg_options))

- }

-

- pub fn get(&self, id: AttrId) -> Option<&Attr> {

- (**self).iter().find(|attr| attr.id == id)

- }

-

- pub(crate) fn expand_cfg_attr(

- db: &dyn DefDatabase,

- krate: Crate,

- raw_attrs: RawAttrs,

- ) -> Attrs {

- Attrs(raw_attrs.expand_cfg_attr(db, krate))

- }

-

- pub(crate) fn is_cfg_enabled_for(

- db: &dyn DefDatabase,

- owner: &dyn ast::HasAttrs,

- span_map: SpanMapRef<'_>,

- cfg_options: &CfgOptions,

- ) -> Result<(), CfgExpr> {

- RawAttrs::attrs_iter_expanded::<false>(db, owner, span_map, cfg_options)

- .filter_map(|attr| attr.cfg())

- .find_map(|cfg| match cfg_options.check(&cfg).is_none_or(identity) {

- true => None,

- false => Some(cfg),

- })

- .map_or(Ok(()), Err)

- }

-}

-

-impl ops::Deref for Attrs {

- type Target = [Attr];

-

- fn deref(&self) -> &[Attr] {

- &self.0

- }

-}

-

-impl ops::Deref for AttrsWithOwner {

- type Target = Attrs;

-

- fn deref(&self) -> &Attrs {

- &self.attrs

- }

-}

-

-impl Attrs {

- pub const EMPTY: Self = Self(RawAttrs::EMPTY);

-

- pub(crate) fn fields_attrs_query(

- db: &dyn DefDatabase,

- v: VariantId,

- ) -> Arc<ArenaMap<LocalFieldId, Attrs>> {

- let _p = tracing::info_span!("fields_attrs_query").entered();

- let mut res = ArenaMap::default();

- let (fields, file_id, krate) = match v {

- VariantId::EnumVariantId(it) => {

- let loc = it.lookup(db);

- let krate = loc.parent.lookup(db).container.krate;

- let source = loc.source(db);

- (source.value.field_list(), source.file_id, krate)

- }

- VariantId::StructId(it) => {

- let loc = it.lookup(db);

- let krate = loc.container.krate;

- let source = loc.source(db);

- (source.value.field_list(), source.file_id, krate)

- }

- VariantId::UnionId(it) => {

- let loc = it.lookup(db);

- let krate = loc.container.krate;

- let source = loc.source(db);

- (

- source.value.record_field_list().map(ast::FieldList::RecordFieldList),

- source.file_id,

- krate,

- )

- }

- };

- let Some(fields) = fields else {

- return Arc::new(res);

- };

-

- let cfg_options = krate.cfg_options(db);

- let span_map = db.span_map(file_id);

-

- match fields {

- ast::FieldList::RecordFieldList(fields) => {

- let mut idx = 0;

- for field in fields.fields() {

- let attrs =

- Attrs(RawAttrs::new_expanded(db, &field, span_map.as_ref(), cfg_options));

- if attrs.is_cfg_enabled(cfg_options).is_ok() {

- res.insert(Idx::from_raw(RawIdx::from(idx)), attrs);

- idx += 1;

- }

- }

- }

- ast::FieldList::TupleFieldList(fields) => {

- let mut idx = 0;

- for field in fields.fields() {

- let attrs =

- Attrs(RawAttrs::new_expanded(db, &field, span_map.as_ref(), cfg_options));

- if attrs.is_cfg_enabled(cfg_options).is_ok() {

- res.insert(Idx::from_raw(RawIdx::from(idx)), attrs);

- idx += 1;

- }

- }

- }

- }

-

- res.shrink_to_fit();

- Arc::new(res)

- }

-}

-

-impl Attrs {

- #[inline]

- pub fn by_key(&self, key: Symbol) -> AttrQuery<'_> {

- AttrQuery { attrs: self, key }

- }

-

- #[inline]

- pub fn rust_analyzer_tool(&self) -> impl Iterator<Item = &Attr> {

- self.iter()

- .filter(|&attr| attr.path.segments().first().is_some_and(|s| *s == sym::rust_analyzer))

- }

-

- #[inline]

- pub fn cfg(&self) -> Option<CfgExpr> {

- let mut cfgs = self.by_key(sym::cfg).tt_values().map(CfgExpr::parse);

- let first = cfgs.next()?;

- match cfgs.next() {

- Some(second) => {

- let cfgs = [first, second].into_iter().chain(cfgs);

- Some(CfgExpr::All(cfgs.collect()))

- }

- None => Some(first),

- }

- }

-

- #[inline]

- pub fn cfgs(&self) -> impl Iterator<Item = CfgExpr> + '_ {

- self.by_key(sym::cfg).tt_values().map(CfgExpr::parse)

- }

-

- #[inline]

- pub(crate) fn is_cfg_enabled(&self, cfg_options: &CfgOptions) -> Result<(), CfgExpr> {

- self.cfgs().try_for_each(|cfg| {

- if cfg_options.check(&cfg) != Some(false) { Ok(()) } else { Err(cfg) }

- })

- }

-

- #[inline]

- pub fn lang(&self) -> Option<&Symbol> {

- self.by_key(sym::lang).string_value()

- }

-

- #[inline]

- pub fn lang_item(&self) -> Option<LangItem> {

- self.by_key(sym::lang).string_value().and_then(LangItem::from_symbol)

- }

-

- #[inline]

- pub fn has_doc_hidden(&self) -> bool {

- self.by_key(sym::doc).tt_values().any(|tt| {

- tt.top_subtree().delimiter.kind == DelimiterKind::Parenthesis &&

- matches!(tt.token_trees().flat_tokens(), [tt::TokenTree::Leaf(tt::Leaf::Ident(ident))] if ident.sym == sym::hidden)

- })

- }

-

- #[inline]

- pub fn has_doc_notable_trait(&self) -> bool {

- self.by_key(sym::doc).tt_values().any(|tt| {

- tt.top_subtree().delimiter.kind == DelimiterKind::Parenthesis &&

- matches!(tt.token_trees().flat_tokens(), [tt::TokenTree::Leaf(tt::Leaf::Ident(ident))] if ident.sym == sym::notable_trait)

- })

- }

-

- #[inline]

- pub fn doc_exprs(&self) -> impl Iterator<Item = DocExpr> + '_ {

- self.by_key(sym::doc).tt_values().map(DocExpr::parse)

- }

-

- #[inline]

- pub fn doc_aliases(&self) -> impl Iterator<Item = Symbol> + '_ {

- self.doc_exprs().flat_map(|doc_expr| doc_expr.aliases().to_vec())

- }

-

- #[inline]

- pub fn export_name(&self) -> Option<&Symbol> {

- self.by_key(sym::export_name).string_value()

- }

-

- #[inline]

- pub fn is_proc_macro(&self) -> bool {

- self.by_key(sym::proc_macro).exists()

- }

-

- #[inline]

- pub fn is_proc_macro_attribute(&self) -> bool {

- self.by_key(sym::proc_macro_attribute).exists()

- }

-

- #[inline]

- pub fn is_proc_macro_derive(&self) -> bool {

- self.by_key(sym::proc_macro_derive).exists()

- }

-

- #[inline]

- pub fn is_test(&self) -> bool {

- self.iter().any(|it| {

- it.path()

- .segments()

- .iter()

- .rev()

- .zip([sym::core, sym::prelude, sym::v1, sym::test].iter().rev())

- .all(|it| it.0 == it.1)

- })

- }

-

- #[inline]

- pub fn is_ignore(&self) -> bool {

- self.by_key(sym::ignore).exists()

- }

-

- #[inline]

- pub fn is_bench(&self) -> bool {

- self.by_key(sym::bench).exists()

- }

-

- #[inline]

- pub fn is_unstable(&self) -> bool {

- self.by_key(sym::unstable).exists()

- }

-

- #[inline]

- pub fn rustc_legacy_const_generics(&self) -> Option<Box<Box<[u32]>>> {

- self.by_key(sym::rustc_legacy_const_generics)

- .tt_values()

- .next()

- .map(parse_rustc_legacy_const_generics)

- .filter(|it| !it.is_empty())

- .map(Box::new)

- }

-

- #[inline]

- pub fn repr(&self) -> Option<ReprOptions> {

- self.by_key(sym::repr).tt_values().filter_map(parse_repr_tt).fold(None, |acc, repr| {

- acc.map_or(Some(repr), |mut acc| {

- merge_repr(&mut acc, repr);

- Some(acc)

- })

- })

- }

-}

-

-fn parse_rustc_legacy_const_generics(tt: &crate::tt::TopSubtree) -> Box<[u32]> {

- let mut indices = Vec::new();

- let mut iter = tt.iter();

- while let (Some(first), second) = (iter.next(), iter.next()) {

- match first {

- TtElement::Leaf(tt::Leaf::Literal(lit)) => match lit.symbol.as_str().parse() {

- Ok(index) => indices.push(index),

- Err(_) => break,

- },

- _ => break,

- }

-

- if let Some(comma) = second {

- match comma {

- TtElement::Leaf(tt::Leaf::Punct(punct)) if punct.char == ',' => {}

- _ => break,

- }

- }

- }

-

- indices.into_boxed_slice()

-}

-

-fn merge_repr(this: &mut ReprOptions, other: ReprOptions) {

- let ReprOptions { int, align, pack, flags, field_shuffle_seed: _ } = this;

- flags.insert(other.flags);

- *align = (*align).max(other.align);

- *pack = match (*pack, other.pack) {

- (Some(pack), None) | (None, Some(pack)) => Some(pack),

- _ => (*pack).min(other.pack),

- };

- if other.int.is_some() {

- *int = other.int;

- }

-}

-

-fn parse_repr_tt(tt: &crate::tt::TopSubtree) -> Option<ReprOptions> {

- use crate::builtin_type::{BuiltinInt, BuiltinUint};

- use rustc_abi::{Align, Integer, IntegerType, ReprFlags, ReprOptions};

-

- match tt.top_subtree().delimiter {

- tt::Delimiter { kind: DelimiterKind::Parenthesis, .. } => {}

- _ => return None,

- }

-

- let mut acc = ReprOptions::default();

- let mut tts = tt.iter();

- while let Some(tt) = tts.next() {

- let TtElement::Leaf(tt::Leaf::Ident(ident)) = tt else {

- continue;

- };

- let repr = match &ident.sym {

- s if *s == sym::packed => {

- let pack = if let Some(TtElement::Subtree(_, mut tt_iter)) = tts.peek() {

- tts.next();

- if let Some(TtElement::Leaf(tt::Leaf::Literal(lit))) = tt_iter.next() {

- lit.symbol.as_str().parse().unwrap_or_default()

- } else {

- 0

- }

- } else {

- 0

- };

- let pack = Some(Align::from_bytes(pack).unwrap_or(Align::ONE));

- ReprOptions { pack, ..Default::default() }

- }

- s if *s == sym::align => {

- let mut align = None;

- if let Some(TtElement::Subtree(_, mut tt_iter)) = tts.peek() {

- tts.next();

- if let Some(TtElement::Leaf(tt::Leaf::Literal(lit))) = tt_iter.next()

- && let Ok(a) = lit.symbol.as_str().parse()

- {

- align = Align::from_bytes(a).ok();

- }

- }

- ReprOptions { align, ..Default::default() }

- }

- s if *s == sym::C => ReprOptions { flags: ReprFlags::IS_C, ..Default::default() },

- s if *s == sym::transparent => {

- ReprOptions { flags: ReprFlags::IS_TRANSPARENT, ..Default::default() }

- }

- s if *s == sym::simd => ReprOptions { flags: ReprFlags::IS_SIMD, ..Default::default() },

- repr => {

- let mut int = None;

- if let Some(builtin) = BuiltinInt::from_suffix_sym(repr)

- .map(Either::Left)

- .or_else(|| BuiltinUint::from_suffix_sym(repr).map(Either::Right))

- {

- int = Some(match builtin {

- Either::Left(bi) => match bi {

- BuiltinInt::Isize => IntegerType::Pointer(true),

- BuiltinInt::I8 => IntegerType::Fixed(Integer::I8, true),

- BuiltinInt::I16 => IntegerType::Fixed(Integer::I16, true),

- BuiltinInt::I32 => IntegerType::Fixed(Integer::I32, true),

- BuiltinInt::I64 => IntegerType::Fixed(Integer::I64, true),

- BuiltinInt::I128 => IntegerType::Fixed(Integer::I128, true),

- },

- Either::Right(bu) => match bu {

- BuiltinUint::Usize => IntegerType::Pointer(false),

- BuiltinUint::U8 => IntegerType::Fixed(Integer::I8, false),

- BuiltinUint::U16 => IntegerType::Fixed(Integer::I16, false),

- BuiltinUint::U32 => IntegerType::Fixed(Integer::I32, false),

- BuiltinUint::U64 => IntegerType::Fixed(Integer::I64, false),

- BuiltinUint::U128 => IntegerType::Fixed(Integer::I128, false),

- },

- });

- }

- ReprOptions { int, ..Default::default() }

- }

- };

- merge_repr(&mut acc, repr);

- }

-

- Some(acc)

-}

-

-#[derive(Debug, Clone, PartialEq, Eq, Hash)]

-pub enum DocAtom {

- /// eg. `#[doc(hidden)]`

- Flag(Symbol),

- /// eg. `#[doc(alias = "it")]`

- ///

- /// Note that a key can have multiple values that are all considered "active" at the same time.

- /// For example, `#[doc(alias = "x")]` and `#[doc(alias = "y")]`.

- KeyValue { key: Symbol, value: Symbol },

-}

-

-#[derive(Debug, Clone, PartialEq, Eq, Hash)]

-pub enum DocExpr {

- Invalid,

- /// eg. `#[doc(hidden)]`, `#[doc(alias = "x")]`

- Atom(DocAtom),

- /// eg. `#[doc(alias("x", "y"))]`

- Alias(Vec<Symbol>),

-}

-

-impl From<DocAtom> for DocExpr {

- fn from(atom: DocAtom) -> Self {

- DocExpr::Atom(atom)

- }

-}

-

-impl DocExpr {

- fn parse<S: Copy>(tt: &tt::TopSubtree<S>) -> DocExpr {

- next_doc_expr(tt.iter()).unwrap_or(DocExpr::Invalid)

- }

-

- pub fn aliases(&self) -> &[Symbol] {

- match self {

- DocExpr::Atom(DocAtom::KeyValue { key, value }) if *key == sym::alias => {

- std::slice::from_ref(value)

- }

- DocExpr::Alias(aliases) => aliases,

- _ => &[],

- }

- }

-}

-

-fn next_doc_expr<S: Copy>(mut it: TtIter<'_, S>) -> Option<DocExpr> {

- let name = match it.next() {

- None => return None,

- Some(TtElement::Leaf(tt::Leaf::Ident(ident))) => ident.sym.clone(),

- Some(_) => return Some(DocExpr::Invalid),

- };

-

- // Peek

- let ret = match it.peek() {

- Some(TtElement::Leaf(tt::Leaf::Punct(punct))) if punct.char == '=' => {

- it.next();

- match it.next() {

- Some(TtElement::Leaf(tt::Leaf::Literal(tt::Literal {

- symbol: text,

- kind: tt::LitKind::Str,

- ..

- }))) => DocAtom::KeyValue { key: name, value: text.clone() }.into(),

- _ => return Some(DocExpr::Invalid),

- }

- }

- Some(TtElement::Subtree(_, subtree_iter)) => {

- it.next();

- let subs = parse_comma_sep(subtree_iter);

- match &name {

- s if *s == sym::alias => DocExpr::Alias(subs),

- _ => DocExpr::Invalid,

- }

- }

- _ => DocAtom::Flag(name).into(),

- };

- Some(ret)

-}

-

-fn parse_comma_sep<S>(iter: TtIter<'_, S>) -> Vec<Symbol> {

- iter.filter_map(|tt| match tt {

- TtElement::Leaf(tt::Leaf::Literal(tt::Literal {

- kind: tt::LitKind::Str, symbol, ..

- })) => Some(symbol.clone()),

- _ => None,

- })

- .collect()

-}

-

-impl AttrsWithOwner {

- pub fn new(db: &dyn DefDatabase, owner: AttrDefId) -> Self {

- Self { attrs: db.attrs(owner), owner }

- }

-

- pub(crate) fn attrs_query(db: &dyn DefDatabase, def: AttrDefId) -> Attrs {

- let _p = tracing::info_span!("attrs_query").entered();

- // FIXME: this should use `Trace` to avoid duplication in `source_map` below

- match def {

- AttrDefId::ModuleId(module) => {

- let def_map = module.def_map(db);

- let mod_data = &def_map[module.local_id];

-

- let raw_attrs = match mod_data.origin {

- ModuleOrigin::File { definition, declaration_tree_id, declaration, .. } => {

- let decl_attrs = declaration_tree_id

- .item_tree(db)

- .raw_attrs(declaration.upcast())

- .clone();

- let tree = db.file_item_tree(definition.into());

- let def_attrs = tree.top_level_raw_attrs().clone();

- decl_attrs.merge(def_attrs)

- }

- ModuleOrigin::CrateRoot { definition } => {

- let tree = db.file_item_tree(definition.into());

- tree.top_level_raw_attrs().clone()

- }

- ModuleOrigin::Inline { definition_tree_id, definition } => {

- definition_tree_id.item_tree(db).raw_attrs(definition.upcast()).clone()

- }

- ModuleOrigin::BlockExpr { id, .. } => {

- let tree = block_item_tree_query(db, id);

- tree.top_level_raw_attrs().clone()

- }

- };

- Attrs::expand_cfg_attr(db, module.krate, raw_attrs)

- }

- AttrDefId::FieldId(it) => db.fields_attrs(it.parent)[it.local_id].clone(),

- AttrDefId::EnumVariantId(it) => attrs_from_ast_id_loc(db, it),

- AttrDefId::AdtId(it) => match it {

- AdtId::StructId(it) => attrs_from_ast_id_loc(db, it),

- AdtId::EnumId(it) => attrs_from_ast_id_loc(db, it),

- AdtId::UnionId(it) => attrs_from_ast_id_loc(db, it),

- },

- AttrDefId::TraitId(it) => attrs_from_ast_id_loc(db, it),

- AttrDefId::MacroId(it) => match it {

- MacroId::Macro2Id(it) => attrs_from_ast_id_loc(db, it),

- MacroId::MacroRulesId(it) => attrs_from_ast_id_loc(db, it),

- MacroId::ProcMacroId(it) => attrs_from_ast_id_loc(db, it),

- },

- AttrDefId::ImplId(it) => attrs_from_ast_id_loc(db, it),

- AttrDefId::ConstId(it) => attrs_from_ast_id_loc(db, it),

- AttrDefId::StaticId(it) => attrs_from_ast_id_loc(db, it),

- AttrDefId::FunctionId(it) => attrs_from_ast_id_loc(db, it),

- AttrDefId::TypeAliasId(it) => attrs_from_ast_id_loc(db, it),

- AttrDefId::GenericParamId(it) => match it {

- GenericParamId::ConstParamId(it) => {

- let src = it.parent().child_source(db);

- // FIXME: We should be never getting `None` here.

- Attrs(match src.value.get(it.local_id()) {

- Some(val) => RawAttrs::new_expanded(

- db,

- val,

- db.span_map(src.file_id).as_ref(),

- def.krate(db).cfg_options(db),

- ),

- None => RawAttrs::EMPTY,

- })

- }

- GenericParamId::TypeParamId(it) => {

- let src = it.parent().child_source(db);

- // FIXME: We should be never getting `None` here.

- Attrs(match src.value.get(it.local_id()) {

- Some(val) => RawAttrs::new_expanded(

- db,

- val,

- db.span_map(src.file_id).as_ref(),

- def.krate(db).cfg_options(db),

- ),

- None => RawAttrs::EMPTY,

- })

- }

- GenericParamId::LifetimeParamId(it) => {

- let src = it.parent.child_source(db);

- // FIXME: We should be never getting `None` here.

- Attrs(match src.value.get(it.local_id) {

- Some(val) => RawAttrs::new_expanded(

- db,

- val,

- db.span_map(src.file_id).as_ref(),

- def.krate(db).cfg_options(db),

- ),

- None => RawAttrs::EMPTY,

- })

- }

- },

- AttrDefId::ExternBlockId(it) => attrs_from_ast_id_loc(db, it),

- AttrDefId::ExternCrateId(it) => attrs_from_ast_id_loc(db, it),

- AttrDefId::UseId(it) => attrs_from_ast_id_loc(db, it),

- }

- }

-

- pub fn source_map(&self, db: &dyn DefDatabase) -> AttrSourceMap {

- let owner = match self.owner {

- AttrDefId::ModuleId(module) => {

- // Modules can have 2 attribute owners (the `mod x;` item, and the module file itself).

-

- let def_map = module.def_map(db);

- let mod_data = &def_map[module.local_id];

- match mod_data.declaration_source(db) {

- Some(it) => {

- let mut map = AttrSourceMap::new(InFile::new(it.file_id, &it.value));

- if let InFile { file_id, value: ModuleSource::SourceFile(file) } =

- mod_data.definition_source(db)

- {

- map.append_module_inline_attrs(AttrSourceMap::new(InFile::new(

- file_id, &file,

- )));

- }

- return map;

- }

- None => {

- let InFile { file_id, value } = mod_data.definition_source(db);

- let attrs_owner = match &value {

- ModuleSource::SourceFile(file) => file as &dyn ast::HasAttrs,

- ModuleSource::Module(module) => module as &dyn ast::HasAttrs,

- ModuleSource::BlockExpr(block) => block as &dyn ast::HasAttrs,

- };

- return AttrSourceMap::new(InFile::new(file_id, attrs_owner));

- }

- }

- }

- AttrDefId::FieldId(id) => {

- let map = db.fields_attrs_source_map(id.parent);

- let file_id = id.parent.file_id(db);

- let root = db.parse_or_expand(file_id);

- let owner = ast::AnyHasAttrs::new(map[id.local_id].to_node(&root));

- InFile::new(file_id, owner)

- }

- AttrDefId::AdtId(adt) => match adt {

- AdtId::StructId(id) => any_has_attrs(db, id),

- AdtId::UnionId(id) => any_has_attrs(db, id),

- AdtId::EnumId(id) => any_has_attrs(db, id),

- },

- AttrDefId::FunctionId(id) => any_has_attrs(db, id),

- AttrDefId::EnumVariantId(id) => any_has_attrs(db, id),

- AttrDefId::StaticId(id) => any_has_attrs(db, id),

- AttrDefId::ConstId(id) => any_has_attrs(db, id),

- AttrDefId::TraitId(id) => any_has_attrs(db, id),

- AttrDefId::TypeAliasId(id) => any_has_attrs(db, id),

- AttrDefId::MacroId(id) => match id {

- MacroId::Macro2Id(id) => any_has_attrs(db, id),

- MacroId::MacroRulesId(id) => any_has_attrs(db, id),

- MacroId::ProcMacroId(id) => any_has_attrs(db, id),

- },

- AttrDefId::ImplId(id) => any_has_attrs(db, id),

- AttrDefId::GenericParamId(id) => match id {

- GenericParamId::ConstParamId(id) => id

- .parent()

- .child_source(db)

- .map(|source| ast::AnyHasAttrs::new(source[id.local_id()].clone())),

- GenericParamId::TypeParamId(id) => id

- .parent()

- .child_source(db)

- .map(|source| ast::AnyHasAttrs::new(source[id.local_id()].clone())),

- GenericParamId::LifetimeParamId(id) => id

- .parent

- .child_source(db)

- .map(|source| ast::AnyHasAttrs::new(source[id.local_id].clone())),

- },

- AttrDefId::ExternBlockId(id) => any_has_attrs(db, id),

- AttrDefId::ExternCrateId(id) => any_has_attrs(db, id),

- AttrDefId::UseId(id) => any_has_attrs(db, id),

- };

-

- AttrSourceMap::new(owner.as_ref().map(|node| node as &dyn HasAttrs))

- }

-}

-

-#[derive(Debug)]

-pub struct AttrSourceMap {

- source: Vec<Either<ast::Attr, ast::Comment>>,

- file_id: HirFileId,

- /// If this map is for a module, this will be the [`HirFileId`] of the module's definition site,

- /// while `file_id` will be the one of the module declaration site.

- /// The usize is the index into `source` from which point on the entries reside in the def site

- /// file.

- mod_def_site_file_id: Option<(HirFileId, usize)>,

-}

-

-impl AttrSourceMap {

- fn new(owner: InFile<&dyn ast::HasAttrs>) -> Self {

- Self {

- source: collect_attrs(owner.value).map(|(_, it)| it).collect(),

- file_id: owner.file_id,

- mod_def_site_file_id: None,

- }

- }

-

- /// Append a second source map to this one, this is required for modules, whose outline and inline

- /// attributes can reside in different files

- fn append_module_inline_attrs(&mut self, other: Self) {

- assert!(self.mod_def_site_file_id.is_none() && other.mod_def_site_file_id.is_none());

- let len = self.source.len();

- self.source.extend(other.source);

- if other.file_id != self.file_id {

- self.mod_def_site_file_id = Some((other.file_id, len));

- }

- }

-

- /// Maps the lowered `Attr` back to its original syntax node.

- ///

- /// `attr` must come from the `owner` used for AttrSourceMap

- ///

- /// Note that the returned syntax node might be a `#[cfg_attr]`, or a doc comment, instead of

- /// the attribute represented by `Attr`.

- pub fn source_of(&self, attr: &Attr) -> InFile<&Either<ast::Attr, ast::Comment>> {

- self.source_of_id(attr.id)

- }

-

- pub fn source_of_id(&self, id: AttrId) -> InFile<&Either<ast::Attr, ast::Comment>> {

- let ast_idx = id.ast_index();

- let file_id = match self.mod_def_site_file_id {

- Some((file_id, def_site_cut)) if def_site_cut <= ast_idx => file_id,

- _ => self.file_id,

- };

-

- self.source

- .get(ast_idx)

- .map(|it| InFile::new(file_id, it))

- .unwrap_or_else(|| panic!("cannot find attr at index {id:?}"))

- }

-}

-

-#[derive(Debug, Clone)]

-pub struct AttrQuery<'attr> {

- attrs: &'attr Attrs,

- key: Symbol,

-}

-

-impl<'attr> AttrQuery<'attr> {

- #[inline]

- pub fn tt_values(self) -> impl Iterator<Item = &'attr crate::tt::TopSubtree> {

- self.attrs().filter_map(|attr| attr.token_tree_value())

- }

-

- #[inline]

- pub fn string_value(self) -> Option<&'attr Symbol> {

- self.attrs().find_map(|attr| attr.string_value())

- }

-

- #[inline]

- pub fn string_value_with_span(self) -> Option<(&'attr Symbol, span::Span)> {

- self.attrs().find_map(|attr| attr.string_value_with_span())

- }

-

- #[inline]

- pub fn string_value_unescape(self) -> Option<Cow<'attr, str>> {

- self.attrs().find_map(|attr| attr.string_value_unescape())

- }

-

- #[inline]

- pub fn exists(self) -> bool {

- self.attrs().next().is_some()

- }

-

- #[inline]

- pub fn attrs(self) -> impl Iterator<Item = &'attr Attr> + Clone {

- let key = self.key;

- self.attrs.iter().filter(move |attr| attr.path.as_ident().is_some_and(|s| *s == key))

- }

-

- /// Find string value for a specific key inside token tree

- ///

- /// ```ignore

- /// #[doc(html_root_url = "url")]

- /// ^^^^^^^^^^^^^ key

- /// ```

- #[inline]

- pub fn find_string_value_in_tt(self, key: Symbol) -> Option<&'attr str> {

- self.tt_values().find_map(|tt| {

- let name = tt.iter()

- .skip_while(|tt| !matches!(tt, TtElement::Leaf(tt::Leaf::Ident(tt::Ident { sym, ..} )) if *sym == key))

- .nth(2);

-

- match name {

- Some(TtElement::Leaf(tt::Leaf::Literal(tt::Literal{ symbol: text, kind: tt::LitKind::Str | tt::LitKind::StrRaw(_) , ..}))) => Some(text.as_str()),

- _ => None

- }

- })

- }

-}

-

-fn any_has_attrs<'db>(

- db: &(dyn DefDatabase + 'db),

- id: impl Lookup<Database = dyn DefDatabase, Data = impl HasSource<Value = impl ast::HasAttrs>>,

-) -> InFile<ast::AnyHasAttrs> {

- id.lookup(db).source(db).map(ast::AnyHasAttrs::new)

-}

-

-fn attrs_from_ast_id_loc<'db, N: AstIdNode + HasAttrs>(

- db: &(dyn DefDatabase + 'db),

- lookup: impl Lookup<Database = dyn DefDatabase, Data = impl AstIdLoc<Ast = N> + HasModule>,

-) -> Attrs {

- let loc = lookup.lookup(db);

- let source = loc.source(db);

- let span_map = db.span_map(source.file_id);

- let cfg_options = loc.krate(db).cfg_options(db);

- Attrs(RawAttrs::new_expanded(db, &source.value, span_map.as_ref(), cfg_options))

-}

-

-pub(crate) fn fields_attrs_source_map(

- db: &dyn DefDatabase,

- def: VariantId,

-) -> Arc<ArenaMap<LocalFieldId, AstPtr<Either<ast::TupleField, ast::RecordField>>>> {

- let mut res = ArenaMap::default();

- let child_source = def.child_source(db);

-

- for (idx, variant) in child_source.value.iter() {

- res.insert(

- idx,

- variant

- .as_ref()

- .either(|l| AstPtr::new(l).wrap_left(), |r| AstPtr::new(r).wrap_right()),

- );

- }

-

- Arc::new(res)

-}

-

-#[cfg(test)]

-mod tests {

- //! This module contains tests for doc-expression parsing.

- //! Currently, it tests `#[doc(hidden)]` and `#[doc(alias)]`.

-

- use intern::Symbol;

- use span::EditionedFileId;

- use triomphe::Arc;

-

- use hir_expand::span_map::{RealSpanMap, SpanMap};

- use span::FileId;

- use syntax::{AstNode, TextRange, ast};

- use syntax_bridge::{DocCommentDesugarMode, syntax_node_to_token_tree};

-

- use crate::attr::{DocAtom, DocExpr};

-

- fn assert_parse_result(input: &str, expected: DocExpr) {

- let source_file = ast::SourceFile::parse(input, span::Edition::CURRENT).ok().unwrap();

- let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();

- let map = SpanMap::RealSpanMap(Arc::new(RealSpanMap::absolute(

- EditionedFileId::current_edition(FileId::from_raw(0)),

- )));

- let tt = syntax_node_to_token_tree(

- tt.syntax(),

- map.as_ref(),

- map.span_for_range(TextRange::empty(0.into())),

- DocCommentDesugarMode::ProcMacro,

- );

- let cfg = DocExpr::parse(&tt);

- assert_eq!(cfg, expected);

- }

-

- #[test]

- fn test_doc_expr_parser() {

- assert_parse_result("#![doc(hidden)]", DocAtom::Flag(Symbol::intern("hidden")).into());

-

- assert_parse_result(

- r#"#![doc(alias = "foo")]"#,

- DocAtom::KeyValue { key: Symbol::intern("alias"), value: Symbol::intern("foo") }.into(),

- );

-

- assert_parse_result(

- r#"#![doc(alias("foo"))]"#,

- DocExpr::Alias([Symbol::intern("foo")].into()),

- );

- assert_parse_result(

- r#"#![doc(alias("foo", "bar", "baz"))]"#,

- DocExpr::Alias(

- [Symbol::intern("foo"), Symbol::intern("bar"), Symbol::intern("baz")].into(),

- ),

- );

-

- assert_parse_result(

- r#"

- #[doc(alias("Bar", "Qux"))]

- struct Foo;"#,

- DocExpr::Alias([Symbol::intern("Bar"), Symbol::intern("Qux")].into()),

- );

- }

-}