- "arrayvec",

- "thin-vec",

-version = "0.15.17"

-checksum = "d4f1e4a001f863f41ea8d0e6a0c34b356d5b733db50dadab3efef640bafb779b"

-cfg = { path = "./crates/cfg", version = "0.0.0", features = ["tt", "syntax"] }

-rowan = "=0.15.17"

-thin-vec = "0.2.14"

-//! Defines [`EditionedFileId`], an interned wrapper around [`span::EditionedFileId`] that

-//! is interned (so queries can take it) and remembers its crate.

-

-use core::fmt;

-use std::hash::{Hash, Hasher};

-

-use span::Edition;

-use vfs::FileId;

-

-use crate::{Crate, RootQueryDb};

-

-#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

-pub struct EditionedFileId(

- salsa::Id,

- std::marker::PhantomData<&'static salsa::plumbing::interned::Value<EditionedFileId>>,

-);

-

-const _: () = {

- use salsa::plumbing as zalsa_;

- use zalsa_::interned as zalsa_struct_;

- type Configuration_ = EditionedFileId;

-

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

- pub struct EditionedFileIdData {

- editioned_file_id: span::EditionedFileId,

- krate: Crate,

- }

-

- /// We like to include the origin crate in an `EditionedFileId` (for use in the item tree),

- /// but this poses us a problem.

- ///

- /// Spans contain `EditionedFileId`s, and we don't want to make them store the crate too

- /// because that will increase their size, which will increase memory usage significantly.

- /// Furthermore, things using spans do not generally need the crate: they are using the

- /// file id for queries like `ast_id_map` or `parse`, which do not care about the crate.

- ///

- /// To solve this, we hash **only the `span::EditionedFileId`**, but on still compare

- /// the crate in equality check. This preserves the invariant of `Hash` and `Eq` -

- /// although same hashes can be used for different items, same file ids used for multiple

- /// crates is a rare thing, and different items always have different hashes. Then,

- /// when we only have a `span::EditionedFileId`, we use the `intern()` method to

- /// reuse existing file ids, and create new one only if needed. See [`from_span_guess_origin`].

- ///

- /// See this for more info: https://rust-lang.zulipchat.com/#narrow/channel/185405-t-compiler.2Frust-analyzer/topic/Letting.20EditionedFileId.20know.20its.20crate/near/530189401

- ///

- /// [`from_span_guess_origin`]: EditionedFileId::from_span_guess_origin

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

- struct WithoutCrate {

- editioned_file_id: span::EditionedFileId,

- }

-

- impl Hash for EditionedFileIdData {

- #[inline]

- fn hash<H: Hasher>(&self, state: &mut H) {

- let EditionedFileIdData { editioned_file_id, krate: _ } = *self;

- editioned_file_id.hash(state);

- }

- }

-

- impl zalsa_struct_::HashEqLike<WithoutCrate> for EditionedFileIdData {

- #[inline]

- fn hash<H: Hasher>(&self, state: &mut H) {

- Hash::hash(self, state);

- }

-

- #[inline]

- fn eq(&self, data: &WithoutCrate) -> bool {

- let EditionedFileIdData { editioned_file_id, krate: _ } = *self;

- editioned_file_id == data.editioned_file_id

- }

- }

-

- impl zalsa_::HasJar for EditionedFileId {

- type Jar = zalsa_struct_::JarImpl<EditionedFileId>;

- const KIND: zalsa_::JarKind = zalsa_::JarKind::Struct;

- }

-

- zalsa_::register_jar! {

- zalsa_::ErasedJar::erase::<EditionedFileId>()

- }

-

- impl zalsa_struct_::Configuration for EditionedFileId {

- const LOCATION: salsa::plumbing::Location =

- salsa::plumbing::Location { file: file!(), line: line!() };

- const DEBUG_NAME: &'static str = "EditionedFileId";

- const REVISIONS: std::num::NonZeroUsize = std::num::NonZeroUsize::MAX;

- const PERSIST: bool = false;

-

- type Fields<'a> = EditionedFileIdData;

- type Struct<'db> = EditionedFileId;

-

- fn serialize<S>(_: &Self::Fields<'_>, _: S) -> Result<S::Ok, S::Error>

- where

- S: zalsa_::serde::Serializer,

- {

- unimplemented!("attempted to serialize value that set `PERSIST` to false")

- }

-

- fn deserialize<'de, D>(_: D) -> Result<Self::Fields<'static>, D::Error>

- where

- D: zalsa_::serde::Deserializer<'de>,

- {

- unimplemented!("attempted to deserialize value that cannot set `PERSIST` to false");

- }

- }

-

- impl Configuration_ {

- pub fn ingredient(zalsa: &zalsa_::Zalsa) -> &zalsa_struct_::IngredientImpl<Self> {

- static CACHE: zalsa_::IngredientCache<zalsa_struct_::IngredientImpl<EditionedFileId>> =

- zalsa_::IngredientCache::new();

-

- // SAFETY: `lookup_jar_by_type` returns a valid ingredient index, and the only

- // ingredient created by our jar is the struct ingredient.

- unsafe {

- CACHE.get_or_create(zalsa, || {

- zalsa.lookup_jar_by_type::<zalsa_struct_::JarImpl<EditionedFileId>>()

- })

- }

- }

- }

-

- impl zalsa_::AsId for EditionedFileId {

- fn as_id(&self) -> salsa::Id {

- self.0.as_id()

- }

- }

- impl zalsa_::FromId for EditionedFileId {

- fn from_id(id: salsa::Id) -> Self {

- Self(<salsa::Id>::from_id(id), std::marker::PhantomData)

- }

- }

-

- unsafe impl Send for EditionedFileId {}

- unsafe impl Sync for EditionedFileId {}

-

- impl std::fmt::Debug for EditionedFileId {

- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

- Self::default_debug_fmt(*self, f)

- }

- }

-

- impl zalsa_::SalsaStructInDb for EditionedFileId {

- type MemoIngredientMap = salsa::plumbing::MemoIngredientSingletonIndex;

-

- fn lookup_ingredient_index(aux: &zalsa_::Zalsa) -> salsa::plumbing::IngredientIndices {

- aux.lookup_jar_by_type::<zalsa_struct_::JarImpl<EditionedFileId>>().into()

- }

-

- fn entries(zalsa: &zalsa_::Zalsa) -> impl Iterator<Item = zalsa_::DatabaseKeyIndex> + '_ {

- let _ingredient_index =

- zalsa.lookup_jar_by_type::<zalsa_struct_::JarImpl<EditionedFileId>>();

- <EditionedFileId>::ingredient(zalsa).entries(zalsa).map(|entry| entry.key())

- }

-

- #[inline]

- fn cast(id: salsa::Id, type_id: std::any::TypeId) -> Option<Self> {

- if type_id == std::any::TypeId::of::<EditionedFileId>() {

- Some(<Self as salsa::plumbing::FromId>::from_id(id))

- } else {

- None

- }

- }

-

- #[inline]

- unsafe fn memo_table(

- zalsa: &zalsa_::Zalsa,

- id: zalsa_::Id,

- current_revision: zalsa_::Revision,

- ) -> zalsa_::MemoTableWithTypes<'_> {

- // SAFETY: Guaranteed by caller.

- unsafe {

- zalsa.table().memos::<zalsa_struct_::Value<EditionedFileId>>(id, current_revision)

- }

- }

- }

-

- unsafe impl zalsa_::Update for EditionedFileId {

- unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool {

- if unsafe { *old_pointer } != new_value {

- unsafe { *old_pointer = new_value };

- true

- } else {

- false

- }

- }

- }

-

- impl EditionedFileId {

- pub fn from_span(

- db: &(impl salsa::Database + ?Sized),

- editioned_file_id: span::EditionedFileId,

- krate: Crate,

- ) -> Self {

- let (zalsa, zalsa_local) = db.zalsas();

- Configuration_::ingredient(zalsa).intern(

- zalsa,

- zalsa_local,

- EditionedFileIdData { editioned_file_id, krate },

- |_, data| data,

- )

- }

-

- /// Guesses the crate for the file.

- ///

- /// Only use this if you cannot precisely determine the origin. This can happen in one of two cases:

- ///

- /// 1. The file is not in the module tree.

- /// 2. You are latency sensitive and cannot afford calling the def map to precisely compute the origin

- /// (e.g. on enter feature, folding, etc.).

- pub fn from_span_guess_origin(

- db: &dyn RootQueryDb,

- editioned_file_id: span::EditionedFileId,

- ) -> Self {

- let (zalsa, zalsa_local) = db.zalsas();

- Configuration_::ingredient(zalsa).intern(

- zalsa,

- zalsa_local,

- WithoutCrate { editioned_file_id },

- |_, _| {

- // FileId not in the database.

- let krate = db

- .relevant_crates(editioned_file_id.file_id())

- .first()

- .copied()

- .unwrap_or_else(|| db.all_crates()[0]);

- EditionedFileIdData { editioned_file_id, krate }

- },

- )

- }

-

- pub fn editioned_file_id(self, db: &dyn salsa::Database) -> span::EditionedFileId {

- let zalsa = db.zalsa();

- let fields = Configuration_::ingredient(zalsa).fields(zalsa, self);

- fields.editioned_file_id

- }

-

- pub fn krate(self, db: &dyn salsa::Database) -> Crate {

- let zalsa = db.zalsa();

- let fields = Configuration_::ingredient(zalsa).fields(zalsa, self);

- fields.krate

- }

-

- /// Default debug formatting for this struct (may be useful if you define your own `Debug` impl)

- pub fn default_debug_fmt(this: Self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

- zalsa_::with_attached_database(|db| {

- let zalsa = db.zalsa();

- let fields = Configuration_::ingredient(zalsa).fields(zalsa, this);

- fmt::Debug::fmt(fields, f)

- })

- .unwrap_or_else(|| {

- f.debug_tuple("EditionedFileId").field(&zalsa_::AsId::as_id(&this)).finish()

- })

- }

- }

-};

-

-impl EditionedFileId {

- #[inline]

- pub fn new(db: &dyn salsa::Database, file_id: FileId, edition: Edition, krate: Crate) -> Self {

- EditionedFileId::from_span(db, span::EditionedFileId::new(file_id, edition), krate)

- }

-

- /// Attaches the current edition and guesses the crate for the file.

- ///

- /// Only use this if you cannot precisely determine the origin. This can happen in one of two cases:

- ///

- /// 1. The file is not in the module tree.

- /// 2. You are latency sensitive and cannot afford calling the def map to precisely compute the origin

- /// (e.g. on enter feature, folding, etc.).

- #[inline]

- pub fn current_edition_guess_origin(db: &dyn RootQueryDb, file_id: FileId) -> Self {

- Self::from_span_guess_origin(db, span::EditionedFileId::current_edition(file_id))

- }

-

- #[inline]

- pub fn file_id(self, db: &dyn salsa::Database) -> vfs::FileId {

- let id = self.editioned_file_id(db);

- id.file_id()

- }

-

- #[inline]

- pub fn unpack(self, db: &dyn salsa::Database) -> (vfs::FileId, span::Edition) {

- let id = self.editioned_file_id(db);

- (id.file_id(), id.edition())

- }

-

- #[inline]

- pub fn edition(self, db: &dyn salsa::Database) -> Edition {

- self.editioned_file_id(db).edition()

- }

-}

-impl Crate {

- pub fn root_file_id(self, db: &dyn salsa::Database) -> EditionedFileId {

- let data = self.data(db);

- EditionedFileId::new(db, data.root_file_id, data.edition, self)

-mod editioned_file_id;

- editioned_file_id::EditionedFileId,

-syntax = { workspace = true, optional = true }

- // FIXME: Parsing from `tt` is only used in a handful of places, reconsider

- // if we should switch them to AST.

- #[cfg(feature = "syntax")]

- pub fn parse_from_ast(

- ast: &mut std::iter::Peekable<syntax::ast::TokenTreeChildren>,

- ) -> CfgExpr {

- next_cfg_expr_from_ast(ast).unwrap_or(CfgExpr::Invalid)

- }

-

-#[cfg(feature = "syntax")]

-fn next_cfg_expr_from_ast(

- it: &mut std::iter::Peekable<syntax::ast::TokenTreeChildren>,

-) -> Option<CfgExpr> {

- use intern::sym;

- use syntax::{NodeOrToken, SyntaxKind, T, ast};

-

- let name = match it.next() {

- None => return None,

- Some(NodeOrToken::Token(ident)) if ident.kind().is_any_identifier() => {

- Symbol::intern(ident.text())

- }

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

- };

-

- let ret = match it.peek() {

- Some(NodeOrToken::Token(eq)) if eq.kind() == T![=] => {

- it.next();

- if let Some(NodeOrToken::Token(literal)) = it.peek()

- && matches!(literal.kind(), SyntaxKind::STRING)

- {

- let literal = tt::token_to_literal(literal.text(), ()).symbol;

- it.next();

- CfgAtom::KeyValue { key: name, value: literal.clone() }.into()

- } else {

- return Some(CfgExpr::Invalid);

- }

- }

- Some(NodeOrToken::Node(subtree)) => {

- let mut subtree_iter = ast::TokenTreeChildren::new(subtree).peekable();

- it.next();

- let mut subs = std::iter::from_fn(|| next_cfg_expr_from_ast(&mut subtree_iter));

- match name {

- s if s == sym::all => CfgExpr::All(subs.collect()),

- s if s == sym::any => CfgExpr::Any(subs.collect()),

- s if s == sym::not => {

- CfgExpr::Not(Box::new(subs.next().unwrap_or(CfgExpr::Invalid)))

- }

- _ => CfgExpr::Invalid,

- }

- }

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

- };

-

- // Eat comma separator

- while it.next().is_some_and(|it| it.as_token().is_none_or(|it| it.kind() != T![,])) {}

-

- Some(ret)

-}

-

-use syntax::{

- AstNode, Edition,

- ast::{self, TokenTreeChildren},

-};

-#[track_caller]

-fn parse_ast_cfg(tt: &ast::TokenTree) -> CfgExpr {

- CfgExpr::parse_from_ast(&mut TokenTreeChildren::new(tt).peekable())

-}

-

-#[track_caller]

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

- tt_ast.syntax(),

- let cfg = parse_ast_cfg(&tt_ast);

- assert_eq!(cfg, expected);

-#[track_caller]

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

- tt_ast.syntax(),

- let cfg = parse_ast_cfg(&tt_ast);

- let actual = format!("#![cfg({})]", DnfExpr::new(&cfg));

- expect.assert_eq(&actual);

-#[track_caller]

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

- tt_ast.syntax(),

- let cfg = parse_ast_cfg(&tt_ast);

- let dnf = DnfExpr::new(&cfg);

- let why_inactive = dnf.why_inactive(opts).unwrap().to_string();

- expect.assert_eq(&why_inactive);

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

- tt_ast.syntax(),

- let cfg = parse_ast_cfg(&tt_ast);

- let dnf = DnfExpr::new(&cfg);

- let hints = dnf.compute_enable_hints(opts).map(|diff| diff.to_string()).collect::<Vec<_>>();

- assert_eq!(hints, expected_hints);

-thin-vec.workspace = true

-syntax-bridge.workspace = true

-//! Attributes for anything that is not name resolution.

-//!

-//! The fundamental idea of this module stems from the observation that most "interesting"

-//! attributes have a more memory-compact form than storing their full syntax, and

-//! that most of the attributes are flags, and those that are not are rare. Therefore,

-//! this module defines [`AttrFlags`], which is a bitflag enum that contains only a yes/no

-//! answer to whether an attribute is present on an item. For most attributes, that's all

-//! that is interesting us; for the rest of them, we define another query that extracts

-//! their data. A key part is that every one of those queries will have a wrapper method

-//! that queries (or is given) the `AttrFlags` and checks for the presence of the attribute;

-//! if it is not present, we do not call the query, to prevent Salsa from needing to record

-//! its value. This way, queries are only called on items that have the attribute, which is

-//! usually only a few.

-//!

-//! An exception to this model that is also defined in this module is documentation (doc

-//! comments and `#[doc = "..."]` attributes). But it also has a more compact form than

-//! the attribute: a concatenated string of the full docs as well as a source map

-//! to map it back to AST (which is needed for things like resolving links in doc comments

-//! and highlight injection). The lowering and upmapping of doc comments is a bit complicated,

-//! but it is encapsulated in the [`Docs`] struct.

-

-use std::{

- convert::Infallible,

- iter::Peekable,

- ops::{ControlFlow, Range},

-};

-

-use base_db::Crate;

-use cfg::{CfgExpr, CfgOptions};

-use either::Either;

-use hir_expand::{

- HirFileId, InFile, Lookup,

- attrs::{Meta, expand_cfg_attr, expand_cfg_attr_with_doc_comments},

-};

-use intern::Symbol;

-use itertools::Itertools;

-use la_arena::ArenaMap;

-use rustc_abi::ReprOptions;

-use rustc_hash::FxHashSet;

-use smallvec::SmallVec;

-use syntax::{

- AstNode, AstToken, NodeOrToken, SmolStr, SyntaxNode, SyntaxToken, T,

- ast::{self, AttrDocCommentIter, HasAttrs, IsString, TokenTreeChildren},

-};

-use tt::{TextRange, TextSize};

-

-use crate::{

- AdtId, AstIdLoc, AttrDefId, FieldId, FunctionId, GenericDefId, HasModule, InternedModuleId,

- LifetimeParamId, LocalFieldId, MacroId, TypeOrConstParamId, VariantId,

- db::DefDatabase,

- hir::generics::{GenericParams, LocalLifetimeParamId, LocalTypeOrConstParamId},

- lang_item::LangItem,

- nameres::ModuleOrigin,

- src::{HasChildSource, HasSource},

-};

-

-#[inline]

-fn attrs_from_ast_id_loc<N: AstNode + Into<ast::AnyHasAttrs>>(

- db: &dyn DefDatabase,

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

-) -> (InFile<ast::AnyHasAttrs>, Crate) {

- let loc = lookup.lookup(db);

- let source = loc.source(db);

- let krate = loc.krate(db);

- (source.map(|it| it.into()), krate)

-}

-

-#[inline]

-fn extract_doc_tt_attr(attr_flags: &mut AttrFlags, tt: ast::TokenTree) {

- for atom in DocAtom::parse(tt) {

- match atom {

- DocAtom::Flag(flag) => match &*flag {

- "notable_trait" => attr_flags.insert(AttrFlags::IS_DOC_NOTABLE_TRAIT),

- "hidden" => attr_flags.insert(AttrFlags::IS_DOC_HIDDEN),

- _ => {}

- },

- DocAtom::KeyValue { key, value: _ } => match &*key {

- "alias" => attr_flags.insert(AttrFlags::HAS_DOC_ALIASES),

- "keyword" => attr_flags.insert(AttrFlags::HAS_DOC_KEYWORD),

- _ => {}

- },

- DocAtom::Alias(_) => attr_flags.insert(AttrFlags::HAS_DOC_ALIASES),

- }

- }

-}

-

-fn extract_ra_completions(attr_flags: &mut AttrFlags, tt: ast::TokenTree) {

- let tt = TokenTreeChildren::new(&tt);

- if let Ok(NodeOrToken::Token(option)) = tt.exactly_one()

- && option.kind().is_any_identifier()

- {

- match option.text() {

- "ignore_flyimport" => attr_flags.insert(AttrFlags::COMPLETE_IGNORE_FLYIMPORT),

- "ignore_methods" => attr_flags.insert(AttrFlags::COMPLETE_IGNORE_METHODS),

- "ignore_flyimport_methods" => {

- attr_flags.insert(AttrFlags::COMPLETE_IGNORE_FLYIMPORT_METHODS)

- }

- _ => {}

- }

- }

-}

-

-fn extract_rustc_skip_during_method_dispatch(attr_flags: &mut AttrFlags, tt: ast::TokenTree) {

- let iter = TokenTreeChildren::new(&tt);

- for kind in iter {

- if let NodeOrToken::Token(kind) = kind

- && kind.kind().is_any_identifier()

- {

- match kind.text() {

- "array" => attr_flags.insert(AttrFlags::RUSTC_SKIP_ARRAY_DURING_METHOD_DISPATCH),

- "boxed_slice" => {

- attr_flags.insert(AttrFlags::RUSTC_SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH)

- }

- _ => {}

- }

- }

- }

-}

-

-#[inline]

-fn match_attr_flags(attr_flags: &mut AttrFlags, attr: Meta) -> ControlFlow<Infallible> {

- match attr {

- Meta::NamedKeyValue { name: Some(name), value, .. } => match name.text() {

- "deprecated" => attr_flags.insert(AttrFlags::IS_DEPRECATED),

- "lang" => attr_flags.insert(AttrFlags::LANG_ITEM),

- "path" => attr_flags.insert(AttrFlags::HAS_PATH),

- "unstable" => attr_flags.insert(AttrFlags::IS_UNSTABLE),

- "export_name" => {

- if let Some(value) = value

- && let Some(value) = ast::String::cast(value)

- && let Ok(value) = value.value()

- && *value == *"main"

- {

- attr_flags.insert(AttrFlags::IS_EXPORT_NAME_MAIN);

- }

- }

- _ => {}

- },

- Meta::TokenTree { path, tt } => match path.segments.len() {

- 1 => match path.segments[0].text() {

- "deprecated" => attr_flags.insert(AttrFlags::IS_DEPRECATED),

- "cfg" => attr_flags.insert(AttrFlags::HAS_CFG),

- "doc" => extract_doc_tt_attr(attr_flags, tt),

- "repr" => attr_flags.insert(AttrFlags::HAS_REPR),

- "target_feature" => attr_flags.insert(AttrFlags::HAS_TARGET_FEATURE),

- "proc_macro_derive" | "rustc_builtin_macro" => {

- attr_flags.insert(AttrFlags::IS_DERIVE_OR_BUILTIN_MACRO)

- }

- "unstable" => attr_flags.insert(AttrFlags::IS_UNSTABLE),

- "rustc_layout_scalar_valid_range_start" | "rustc_layout_scalar_valid_range_end" => {

- attr_flags.insert(AttrFlags::RUSTC_LAYOUT_SCALAR_VALID_RANGE)

- }

- "rustc_legacy_const_generics" => {

- attr_flags.insert(AttrFlags::HAS_LEGACY_CONST_GENERICS)

- }

- "rustc_skip_during_method_dispatch" => {

- extract_rustc_skip_during_method_dispatch(attr_flags, tt)

- }

- _ => {}

- },

- 2 => match path.segments[0].text() {

- "rust_analyzer" => match path.segments[1].text() {

- "completions" => extract_ra_completions(attr_flags, tt),

- _ => {}

- },

- _ => {}

- },

- _ => {}

- },

- Meta::Path { path } => {

- match path.segments.len() {

- 1 => match path.segments[0].text() {

- "rustc_has_incoherent_inherent_impls" => {

- attr_flags.insert(AttrFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS)

- }

- "rustc_allow_incoherent_impl" => {

- attr_flags.insert(AttrFlags::RUSTC_ALLOW_INCOHERENT_IMPL)

- }

- "fundamental" => attr_flags.insert(AttrFlags::FUNDAMENTAL),

- "no_std" => attr_flags.insert(AttrFlags::IS_NO_STD),

- "may_dangle" => attr_flags.insert(AttrFlags::MAY_DANGLE),

- "rustc_paren_sugar" => attr_flags.insert(AttrFlags::RUSTC_PAREN_SUGAR),

- "rustc_coinductive" => attr_flags.insert(AttrFlags::RUSTC_COINDUCTIVE),

- "rustc_force_inline" => attr_flags.insert(AttrFlags::RUSTC_FORCE_INLINE),

- "unstable" => attr_flags.insert(AttrFlags::IS_UNSTABLE),

- "deprecated" => attr_flags.insert(AttrFlags::IS_DEPRECATED),

- "macro_export" => attr_flags.insert(AttrFlags::IS_MACRO_EXPORT),

- "no_mangle" => attr_flags.insert(AttrFlags::NO_MANGLE),

- "non_exhaustive" => attr_flags.insert(AttrFlags::NON_EXHAUSTIVE),

- "ignore" => attr_flags.insert(AttrFlags::IS_IGNORE),

- "bench" => attr_flags.insert(AttrFlags::IS_BENCH),

- "rustc_const_panic_str" => attr_flags.insert(AttrFlags::RUSTC_CONST_PANIC_STR),

- "rustc_intrinsic" => attr_flags.insert(AttrFlags::RUSTC_INTRINSIC),

- "rustc_safe_intrinsic" => attr_flags.insert(AttrFlags::RUSTC_SAFE_INTRINSIC),

- "rustc_intrinsic_must_be_overridden" => {

- attr_flags.insert(AttrFlags::RUSTC_INTRINSIC_MUST_BE_OVERRIDDEN)

- }

- "rustc_allocator" => attr_flags.insert(AttrFlags::RUSTC_ALLOCATOR),

- "rustc_deallocator" => attr_flags.insert(AttrFlags::RUSTC_DEALLOCATOR),

- "rustc_reallocator" => attr_flags.insert(AttrFlags::RUSTC_REALLOCATOR),

- "rustc_allocator_zeroed" => {

- attr_flags.insert(AttrFlags::RUSTC_ALLOCATOR_ZEROED)

- }

- "rustc_reservation_impl" => {

- attr_flags.insert(AttrFlags::RUSTC_RESERVATION_IMPL)

- }

- "rustc_deprecated_safe_2024" => {

- attr_flags.insert(AttrFlags::RUSTC_DEPRECATED_SAFE_2024)

- }

- "rustc_skip_array_during_method_dispatch" => {

- attr_flags.insert(AttrFlags::RUSTC_SKIP_ARRAY_DURING_METHOD_DISPATCH)

- }

- _ => {}

- },

- 2 => match path.segments[0].text() {

- "rust_analyzer" => match path.segments[1].text() {

- "skip" => attr_flags.insert(AttrFlags::RUST_ANALYZER_SKIP),

- _ => {}

- },

- _ => {}

- },

- _ => {}

- }

-

- if path.is_test {

- attr_flags.insert(AttrFlags::IS_TEST);

- }

- }

- _ => {}

- };

- ControlFlow::Continue(())

-}

-

-bitflags::bitflags! {

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

- pub struct AttrFlags: u64 {

- const RUST_ANALYZER_SKIP = 1 << 0;

-

- const LANG_ITEM = 1 << 1;

-

- const HAS_DOC_ALIASES = 1 << 2;

- const HAS_DOC_KEYWORD = 1 << 3;

- const IS_DOC_NOTABLE_TRAIT = 1 << 4;

- const IS_DOC_HIDDEN = 1 << 5;

-

- const RUSTC_HAS_INCOHERENT_INHERENT_IMPLS = 1 << 6;

- const RUSTC_ALLOW_INCOHERENT_IMPL = 1 << 7;

- const FUNDAMENTAL = 1 << 8;

- const RUSTC_SKIP_ARRAY_DURING_METHOD_DISPATCH = 1 << 9;

- const RUSTC_SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH = 1 << 10;

- const HAS_REPR = 1 << 11;

- const HAS_TARGET_FEATURE = 1 << 12;

- const RUSTC_DEPRECATED_SAFE_2024 = 1 << 13;

- const HAS_LEGACY_CONST_GENERICS = 1 << 14;

- const NO_MANGLE = 1 << 15;

- const NON_EXHAUSTIVE = 1 << 16;

- const RUSTC_RESERVATION_IMPL = 1 << 17;

- const RUSTC_CONST_PANIC_STR = 1 << 18;

- const MAY_DANGLE = 1 << 19;

-

- const RUSTC_INTRINSIC = 1 << 20;

- const RUSTC_SAFE_INTRINSIC = 1 << 21;

- const RUSTC_INTRINSIC_MUST_BE_OVERRIDDEN = 1 << 22;

- const RUSTC_ALLOCATOR = 1 << 23;

- const RUSTC_DEALLOCATOR = 1 << 24;

- const RUSTC_REALLOCATOR = 1 << 25;

- const RUSTC_ALLOCATOR_ZEROED = 1 << 26;

-

- const IS_UNSTABLE = 1 << 27;

- const IS_IGNORE = 1 << 28;

- // FIXME: `IS_TEST` and `IS_BENCH` should be based on semantic information, not textual match.

- const IS_BENCH = 1 << 29;

- const IS_TEST = 1 << 30;

- const IS_EXPORT_NAME_MAIN = 1 << 31;

- const IS_MACRO_EXPORT = 1 << 32;

- const IS_NO_STD = 1 << 33;

- const IS_DERIVE_OR_BUILTIN_MACRO = 1 << 34;

- const IS_DEPRECATED = 1 << 35;

- const HAS_PATH = 1 << 36;

- const HAS_CFG = 1 << 37;

-

- const COMPLETE_IGNORE_FLYIMPORT = 1 << 38;

- const COMPLETE_IGNORE_FLYIMPORT_METHODS = 1 << 39;

- const COMPLETE_IGNORE_METHODS = 1 << 40;

-

- const RUSTC_LAYOUT_SCALAR_VALID_RANGE = 1 << 41;

- const RUSTC_PAREN_SUGAR = 1 << 42;

- const RUSTC_COINDUCTIVE = 1 << 43;

- const RUSTC_FORCE_INLINE = 1 << 44;

- }

-}

-

-fn attrs_source(

- db: &dyn DefDatabase,

- owner: AttrDefId,

-) -> (InFile<ast::AnyHasAttrs>, Option<InFile<ast::Module>>, Crate) {

- let (owner, krate) = match owner {

- AttrDefId::ModuleId(id) => {

- let id = id.loc(db);

- let def_map = id.def_map(db);

- let (definition, declaration) = match def_map[id.local_id].origin {

- ModuleOrigin::CrateRoot { definition } => {

- let file = db.parse(definition).tree();

- (InFile::new(definition.into(), ast::AnyHasAttrs::from(file)), None)

- }

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

- let declaration = InFile::new(declaration_tree_id.file_id(), declaration);

- let declaration = declaration.with_value(declaration.to_node(db));

- let definition_source = db.parse(definition).tree();

- (InFile::new(definition.into(), definition_source.into()), Some(declaration))

- }

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

- let definition = InFile::new(definition_tree_id.file_id(), definition);

- let definition = definition.with_value(definition.to_node(db).into());

- (definition, None)

- }

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

- let definition = block.to_node(db);

- (block.with_value(definition.into()), None)

- }

- };

- return (definition, declaration, id.krate);

- }

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

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

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

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

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

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

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

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

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

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

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

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

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

- 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),

- };

- (owner, None, krate)

-}

-

-fn collect_attrs<BreakValue>(

- db: &dyn DefDatabase,

- owner: AttrDefId,

- mut callback: impl FnMut(Meta) -> ControlFlow<BreakValue>,

-) -> Option<BreakValue> {

- let (source, outer_mod_decl, krate) = attrs_source(db, owner);

-

- let mut cfg_options = None;

- expand_cfg_attr(

- outer_mod_decl

- .into_iter()

- .flat_map(|it| it.value.attrs())

- .chain(ast::attrs_including_inner(&source.value)),

- || cfg_options.get_or_insert_with(|| krate.cfg_options(db)),

- move |meta, _, _, _| callback(meta),

- )

-}

-

-fn collect_field_attrs<T>(

- db: &dyn DefDatabase,

- variant: VariantId,

- mut field_attrs: impl FnMut(&CfgOptions, InFile<ast::AnyHasAttrs>) -> T,

-) -> ArenaMap<LocalFieldId, T> {

- let (variant_syntax, krate) = match variant {

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

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

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

- };

- let cfg_options = krate.cfg_options(db);

- let variant_syntax = variant_syntax

- .with_value(ast::VariantDef::cast(variant_syntax.value.syntax().clone()).unwrap());

- let fields = match &variant_syntax.value {

- ast::VariantDef::Struct(it) => it.field_list(),

- ast::VariantDef::Union(it) => it.record_field_list().map(ast::FieldList::RecordFieldList),

- ast::VariantDef::Variant(it) => it.field_list(),

- };

- let Some(fields) = fields else {

- return ArenaMap::new();

- };

-

- let mut result = ArenaMap::new();

- let mut idx = 0;

- match fields {

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

- for field in fields.fields() {

- if AttrFlags::is_cfg_enabled_for(&field, cfg_options).is_ok() {

- result.insert(

- la_arena::Idx::from_raw(la_arena::RawIdx::from_u32(idx)),

- field_attrs(cfg_options, variant_syntax.with_value(field.into())),

- );

- idx += 1;

- }

- }

- }

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

- for field in fields.fields() {

- if AttrFlags::is_cfg_enabled_for(&field, cfg_options).is_ok() {

- result.insert(

- la_arena::Idx::from_raw(la_arena::RawIdx::from_u32(idx)),

- field_attrs(cfg_options, variant_syntax.with_value(field.into())),

- );

- idx += 1;

- }

- }

- }

- }

- result.shrink_to_fit();

- result

-}

-

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

-pub struct RustcLayoutScalarValidRange {

- pub start: Option<u128>,

- pub end: Option<u128>,

-}

-

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

-struct DocsSourceMapLine {

- /// The offset in [`Docs::docs`].

- string_offset: TextSize,

- /// The offset in the AST of the text.

- ast_offset: TextSize,

-}

-

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

-pub struct Docs {

- /// The concatenated string of all `#[doc = "..."]` attributes and documentation comments.

- docs: String,

- /// A sorted map from an offset in `docs` to an offset in the source code.

- docs_source_map: Vec<DocsSourceMapLine>,

- /// If the item is an outlined module (`mod foo;`), `docs_source_map` store the concatenated

- /// list of the outline and inline docs (outline first). Then, this field contains the [`HirFileId`]

- /// of the outline declaration, and the index in `docs` from which the inline docs

- /// begin.

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

- inline_file: HirFileId,

- /// The size the prepended prefix, which does not map to real doc comments.

- prefix_len: TextSize,

- /// The offset in `docs` from which the docs are inner attributes/comments.

- inline_inner_docs_start: Option<TextSize>,

- /// Like `inline_inner_docs_start`, but for `outline_mod`. This can happen only when merging `Docs`

- /// (as outline modules don't have inner attributes).

- outline_inner_docs_start: Option<TextSize>,

-}

-

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

-pub enum IsInnerDoc {

- No,

- Yes,

-}

-

-impl IsInnerDoc {

- #[inline]

- pub fn yes(self) -> bool {

- self == IsInnerDoc::Yes

- }

-}

-

-impl Docs {

- #[inline]

- pub fn docs(&self) -> &str {

- &self.docs

- }

-

- #[inline]

- pub fn into_docs(self) -> String {

- self.docs

- }

-

- pub fn find_ast_range(

- &self,

- mut string_range: TextRange,

- ) -> Option<(InFile<TextRange>, IsInnerDoc)> {

- if string_range.start() < self.prefix_len {

- return None;

- }

- string_range -= self.prefix_len;

-

- let mut file = self.inline_file;

- let mut inner_docs_start = self.inline_inner_docs_start;

- // Check whether the range is from the outline, the inline, or both.

- let source_map = if let Some((outline_mod_file, outline_mod_end)) = self.outline_mod {

- if let Some(first_inline) = self.docs_source_map.get(outline_mod_end) {

- if string_range.end() <= first_inline.string_offset {

- // The range is completely in the outline.

- file = outline_mod_file;

- inner_docs_start = self.outline_inner_docs_start;

- &self.docs_source_map[..outline_mod_end]

- } else if string_range.start() >= first_inline.string_offset {

- // The range is completely in the inline.

- &self.docs_source_map[outline_mod_end..]

- } else {

- // The range is combined from the outline and the inline - cannot map it back.

- return None;

- }

- } else {

- // There is no inline.

- file = outline_mod_file;

- inner_docs_start = self.outline_inner_docs_start;

- &self.docs_source_map

- }

- } else {

- // There is no outline.

- &self.docs_source_map

- };

-

- let after_range =

- source_map.partition_point(|line| line.string_offset <= string_range.start()) - 1;

- let after_range = &source_map[after_range..];

- let line = after_range.first()?;

- if after_range.get(1).is_some_and(|next_line| next_line.string_offset < string_range.end())

- {

- // The range is combined from two lines - cannot map it back.

- return None;

- }

- let ast_range = string_range - line.string_offset + line.ast_offset;

- let is_inner = if inner_docs_start

- .is_some_and(|inner_docs_start| string_range.start() >= inner_docs_start)

- {

- IsInnerDoc::Yes

- } else {

- IsInnerDoc::No

- };

- Some((InFile::new(file, ast_range), is_inner))

- }

-

- #[inline]

- pub fn shift_by(&mut self, offset: TextSize) {

- self.prefix_len += offset;

- }

-

- pub fn prepend_str(&mut self, s: &str) {

- self.prefix_len += TextSize::of(s);

- self.docs.insert_str(0, s);

- }

-

- pub fn append_str(&mut self, s: &str) {

- self.docs.push_str(s);

- }

-

- pub fn append(&mut self, other: &Docs) {

- let other_offset = TextSize::of(&self.docs);

-

- assert!(

- self.outline_mod.is_none() && other.outline_mod.is_none(),

- "cannot merge `Docs` that have `outline_mod` set"

- );

- self.outline_mod = Some((self.inline_file, self.docs_source_map.len()));

- self.inline_file = other.inline_file;

- self.outline_inner_docs_start = self.inline_inner_docs_start;

- self.inline_inner_docs_start = other.inline_inner_docs_start.map(|it| it + other_offset);

-

- self.docs.push_str(&other.docs);

- self.docs_source_map.extend(other.docs_source_map.iter().map(

- |&DocsSourceMapLine { string_offset, ast_offset }| DocsSourceMapLine {

- ast_offset,

- string_offset: string_offset + other_offset,

- },

- ));

- }

-

- fn extend_with_doc_comment(&mut self, comment: ast::Comment, indent: &mut usize) {

- let Some((doc, offset)) = comment.doc_comment() else { return };

- self.extend_with_doc_str(doc, comment.syntax().text_range().start() + offset, indent);

- }

-

- fn extend_with_doc_attr(&mut self, value: SyntaxToken, indent: &mut usize) {

- let Some(value) = ast::String::cast(value) else { return };

- let Some(value_offset) = value.text_range_between_quotes() else { return };

- let value_offset = value_offset.start();

- let Ok(value) = value.value() else { return };

- // FIXME: Handle source maps for escaped text.

- self.extend_with_doc_str(&value, value_offset, indent);

- }

-

- fn extend_with_doc_str(&mut self, doc: &str, mut offset_in_ast: TextSize, indent: &mut usize) {

- for line in doc.split('\n') {

- self.docs_source_map.push(DocsSourceMapLine {

- string_offset: TextSize::of(&self.docs),

- ast_offset: offset_in_ast,

- });

- offset_in_ast += TextSize::of(line) + TextSize::of("\n");

-

- let line = line.trim_end();

- if let Some(line_indent) = line.chars().position(|ch| !ch.is_whitespace()) {

- // Empty lines are handled because `position()` returns `None` for them.

- *indent = std::cmp::min(*indent, line_indent);

- }

- self.docs.push_str(line);

- self.docs.push('\n');

- }

- }

-

- fn remove_indent(&mut self, indent: usize, start_source_map_index: usize) {

- /// In case of panics, we want to avoid corrupted UTF-8 in `self.docs`, so we clear it.

- struct Guard<'a>(&'a mut Docs);

- impl Drop for Guard<'_> {

- fn drop(&mut self) {

- let Docs {

- docs,

- docs_source_map,

- outline_mod,

- inline_file: _,

- prefix_len: _,

- inline_inner_docs_start: _,

- outline_inner_docs_start: _,

- } = self.0;

- // Don't use `String::clear()` here because it's not guaranteed to not do UTF-8-dependent things,

- // and we may have temporarily broken the string's encoding.

- unsafe { docs.as_mut_vec() }.clear();

- // This is just to avoid panics down the road.

- docs_source_map.clear();

- *outline_mod = None;

- }

- }

-

- if self.docs.is_empty() {

- return;

- }

-

- let guard = Guard(self);

- let source_map = &mut guard.0.docs_source_map[start_source_map_index..];

- let Some(&DocsSourceMapLine { string_offset: mut copy_into, .. }) = source_map.first()

- else {

- return;

- };

- // We basically want to remove multiple ranges from a string. Doing this efficiently (without O(N^2)

- // or allocations) requires unsafe. Basically, for each line, we copy the line minus the indent into

- // consecutive to the previous line (which may have moved). Then at the end we truncate.

- let mut accumulated_offset = TextSize::new(0);

- for idx in 0..source_map.len() {

- let string_end_offset = source_map

- .get(idx + 1)

- .map_or_else(|| TextSize::of(&guard.0.docs), |next_attr| next_attr.string_offset);

- let line_source = &mut source_map[idx];

- let line_docs =

- &guard.0.docs[TextRange::new(line_source.string_offset, string_end_offset)];

- let line_docs_len = TextSize::of(line_docs);

- let indent_size = line_docs.char_indices().nth(indent).map_or_else(

- || TextSize::of(line_docs) - TextSize::of("\n"),

- |(offset, _)| TextSize::new(offset as u32),

- );

- unsafe { guard.0.docs.as_bytes_mut() }.copy_within(

- Range::<usize>::from(TextRange::new(

- line_source.string_offset + indent_size,

- string_end_offset,

- )),

- copy_into.into(),

- );

- copy_into += line_docs_len - indent_size;

-

- if let Some(inner_attrs_start) = &mut guard.0.inline_inner_docs_start

- && *inner_attrs_start == line_source.string_offset

- {

- *inner_attrs_start -= accumulated_offset;

- }

- // The removals in the string accumulate, but in the AST not, because it already points

- // to the beginning of each attribute.

- // Also, we need to shift the AST offset of every line, but the string offset of the first

- // line should not get shifted (in general, the shift for the string offset is by the

- // number of lines until the current one, excluding the current one).

- line_source.string_offset -= accumulated_offset;

- line_source.ast_offset += indent_size;

-

- accumulated_offset += indent_size;

- }

- // Don't use `String::truncate()` here because it's not guaranteed to not do UTF-8-dependent things,

- // and we may have temporarily broken the string's encoding.

- unsafe { guard.0.docs.as_mut_vec() }.truncate(copy_into.into());

-

- std::mem::forget(guard);

- }

-

- fn remove_last_newline(&mut self) {

- self.docs.truncate(self.docs.len().saturating_sub(1));

- }

-

- fn shrink_to_fit(&mut self) {

- let Docs {

- docs,

- docs_source_map,

- outline_mod: _,

- inline_file: _,

- prefix_len: _,

- inline_inner_docs_start: _,

- outline_inner_docs_start: _,

- } = self;

- docs.shrink_to_fit();

- docs_source_map.shrink_to_fit();

- }

-}

-

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

-pub struct DeriveInfo {

- pub trait_name: Symbol,

- pub helpers: Box<[Symbol]>,

-}

-

-fn extract_doc_aliases(result: &mut Vec<Symbol>, attr: Meta) -> ControlFlow<Infallible> {

- if let Meta::TokenTree { path, tt } = attr

- && path.is1("doc")

- {

- for atom in DocAtom::parse(tt) {

- match atom {

- DocAtom::Alias(aliases) => {

- result.extend(aliases.into_iter().map(|alias| Symbol::intern(&alias)))

- }

- DocAtom::KeyValue { key, value } if key == "alias" => {

- result.push(Symbol::intern(&value))

- }

- _ => {}

- }

- }

- }

- ControlFlow::Continue(())

-}

-

-fn extract_cfgs(result: &mut Vec<CfgExpr>, attr: Meta) -> ControlFlow<Infallible> {

- if let Meta::TokenTree { path, tt } = attr

- && path.is1("cfg")

- {

- result.push(CfgExpr::parse_from_ast(&mut TokenTreeChildren::new(&tt).peekable()));

- }

- ControlFlow::Continue(())

-}

-

-fn extract_docs<'a>(

- get_cfg_options: &dyn Fn() -> &'a CfgOptions,

- source: InFile<ast::AnyHasAttrs>,

- outer_mod_decl: Option<InFile<ast::Module>>,

- inner_attrs_node: Option<SyntaxNode>,

-) -> Option<Box<Docs>> {

- let mut result = Docs {

- docs: String::new(),

- docs_source_map: Vec::new(),

- outline_mod: None,

- inline_file: source.file_id,

- prefix_len: TextSize::new(0),

- inline_inner_docs_start: None,

- outline_inner_docs_start: None,

- };

-

- let mut cfg_options = None;

- let mut extend_with_attrs =

- |result: &mut Docs, node: &SyntaxNode, expect_inner_attrs, indent: &mut usize| {

- expand_cfg_attr_with_doc_comments::<_, Infallible>(

- AttrDocCommentIter::from_syntax_node(node).filter(|attr| match attr {

- Either::Left(attr) => attr.kind().is_inner() == expect_inner_attrs,

- Either::Right(comment) => comment.kind().doc.is_some_and(|kind| {

- (kind == ast::CommentPlacement::Inner) == expect_inner_attrs

- }),

- }),

- || cfg_options.get_or_insert_with(get_cfg_options),

- |attr| {

- match attr {

- Either::Right(doc_comment) => {

- result.extend_with_doc_comment(doc_comment, indent)

- }

- Either::Left((attr, _, _, _)) => match attr {

- // FIXME: Handle macros: `#[doc = concat!("foo", "bar")]`.

- Meta::NamedKeyValue {

- name: Some(name), value: Some(value), ..

- } if name.text() == "doc" => {

- result.extend_with_doc_attr(value, indent);

- }

- _ => {}

- },

- }

- ControlFlow::Continue(())

- },

- );

- };

-

- if let Some(outer_mod_decl) = outer_mod_decl {

- let mut indent = usize::MAX;

- extend_with_attrs(&mut result, outer_mod_decl.value.syntax(), false, &mut indent);

- result.remove_indent(indent, 0);

- result.outline_mod = Some((outer_mod_decl.file_id, result.docs_source_map.len()));

- }

-

- let inline_source_map_start = result.docs_source_map.len();

- let mut indent = usize::MAX;

- extend_with_attrs(&mut result, source.value.syntax(), false, &mut indent);

- if let Some(inner_attrs_node) = &inner_attrs_node {

- result.inline_inner_docs_start = Some(TextSize::of(&result.docs));

- extend_with_attrs(&mut result, inner_attrs_node, true, &mut indent);

- }

- result.remove_indent(indent, inline_source_map_start);

-

- result.remove_last_newline();

-

- result.shrink_to_fit();

-

- if result.docs.is_empty() { None } else { Some(Box::new(result)) }

-}

-

-#[salsa::tracked]

-impl AttrFlags {

- #[salsa::tracked]

- pub fn query(db: &dyn DefDatabase, owner: AttrDefId) -> AttrFlags {

- let mut attr_flags = AttrFlags::empty();

- collect_attrs(db, owner, |attr| match_attr_flags(&mut attr_flags, attr));

- attr_flags

- }

-

- #[inline]

- pub fn query_field(db: &dyn DefDatabase, field: FieldId) -> AttrFlags {

- return field_attr_flags(db, field.parent)

- .get(field.local_id)

- .copied()

- .unwrap_or_else(AttrFlags::empty);

-

- #[salsa::tracked(returns(ref))]

- fn field_attr_flags(

- db: &dyn DefDatabase,

- variant: VariantId,

- ) -> ArenaMap<LocalFieldId, AttrFlags> {

- collect_field_attrs(db, variant, |cfg_options, field| {

- let mut attr_flags = AttrFlags::empty();

- expand_cfg_attr(

- field.value.attrs(),

- || cfg_options,

- |attr, _, _, _| match_attr_flags(&mut attr_flags, attr),

- );

- attr_flags

- })

- }

- }

-

- #[inline]

- pub fn query_generic_params(

- db: &dyn DefDatabase,

- def: GenericDefId,

- ) -> &(ArenaMap<LocalLifetimeParamId, AttrFlags>, ArenaMap<LocalTypeOrConstParamId, AttrFlags>)

- {

- let generic_params = GenericParams::new(db, def);

- let params_count_excluding_self =

- generic_params.len() - usize::from(generic_params.trait_self_param().is_some());

- if params_count_excluding_self == 0 {

- return const { &(ArenaMap::new(), ArenaMap::new()) };

- }

- return generic_params_attr_flags(db, def);

-

- #[salsa::tracked(returns(ref))]

- fn generic_params_attr_flags(

- db: &dyn DefDatabase,

- def: GenericDefId,

- ) -> (ArenaMap<LocalLifetimeParamId, AttrFlags>, ArenaMap<LocalTypeOrConstParamId, AttrFlags>)

- {

- let mut lifetimes = ArenaMap::new();

- let mut type_and_consts = ArenaMap::new();

-

- let mut cfg_options = None;

- let mut cfg_options =

- || *cfg_options.get_or_insert_with(|| def.krate(db).cfg_options(db));

-

- let lifetimes_source = HasChildSource::<LocalLifetimeParamId>::child_source(&def, db);

- for (lifetime_id, lifetime) in lifetimes_source.value.iter() {

- let mut attr_flags = AttrFlags::empty();

- expand_cfg_attr(lifetime.attrs(), &mut cfg_options, |attr, _, _, _| {

- match_attr_flags(&mut attr_flags, attr)

- });

- if !attr_flags.is_empty() {

- lifetimes.insert(lifetime_id, attr_flags);

- }

- }

-

- let type_and_consts_source =

- HasChildSource::<LocalTypeOrConstParamId>::child_source(&def, db);

- for (type_or_const_id, type_or_const) in type_and_consts_source.value.iter() {

- let mut attr_flags = AttrFlags::empty();

- expand_cfg_attr(type_or_const.attrs(), &mut cfg_options, |attr, _, _, _| {

- match_attr_flags(&mut attr_flags, attr)

- });

- if !attr_flags.is_empty() {

- type_and_consts.insert(type_or_const_id, attr_flags);

- }

- }

-

- lifetimes.shrink_to_fit();

- type_and_consts.shrink_to_fit();

- (lifetimes, type_and_consts)

- }

- }

-

- #[inline]

- pub fn query_lifetime_param(db: &dyn DefDatabase, owner: LifetimeParamId) -> AttrFlags {

- AttrFlags::query_generic_params(db, owner.parent)

- .0

- .get(owner.local_id)

- .copied()

- .unwrap_or_else(AttrFlags::empty)

- }

- #[inline]

- pub fn query_type_or_const_param(db: &dyn DefDatabase, owner: TypeOrConstParamId) -> AttrFlags {

- AttrFlags::query_generic_params(db, owner.parent)

- .1

- .get(owner.local_id)

- .copied()

- .unwrap_or_else(AttrFlags::empty)

- }

-

- pub(crate) fn is_cfg_enabled_for(

- owner: &dyn HasAttrs,

- cfg_options: &CfgOptions,

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

- let attrs = ast::attrs_including_inner(owner);

- let result = expand_cfg_attr(

- attrs,

- || cfg_options,

- |attr, _, _, _| {

- if let Meta::TokenTree { path, tt } = attr

- && path.is1("cfg")

- && let cfg =

- CfgExpr::parse_from_ast(&mut TokenTreeChildren::new(&tt).peekable())

- && cfg_options.check(&cfg) == Some(false)

- {

- ControlFlow::Break(cfg)

- } else {

- ControlFlow::Continue(())

- }

- },

- );

- match result {

- Some(cfg) => Err(cfg),

- None => Ok(()),

- }

- }

-

- #[inline]

- pub fn lang_item(db: &dyn DefDatabase, owner: AttrDefId) -> Option<LangItem> {

- AttrFlags::query(db, owner).lang_item_with_attrs(db, owner)

- }

-

- #[inline]

- pub fn lang_item_with_attrs(self, db: &dyn DefDatabase, owner: AttrDefId) -> Option<LangItem> {

- if !self.contains(AttrFlags::LANG_ITEM) {

- // Don't create the query in case this is not a lang item, this wastes memory.

- return None;

- }

-

- return lang_item(db, owner);

-

- #[salsa::tracked]

- fn lang_item(db: &dyn DefDatabase, owner: AttrDefId) -> Option<LangItem> {

- collect_attrs(db, owner, |attr| {

- if let Meta::NamedKeyValue { name: Some(name), value: Some(value), .. } = attr

- && name.text() == "lang"

- && let Some(value) = ast::String::cast(value)

- && let Ok(value) = value.value()

- && let symbol = Symbol::intern(&value)

- && let Some(lang_item) = LangItem::from_symbol(&symbol)

- {

- ControlFlow::Break(lang_item)

- } else {

- ControlFlow::Continue(())

- }

- })

- }

- }

-

- #[inline]

- pub fn repr(db: &dyn DefDatabase, owner: AdtId) -> Option<ReprOptions> {

- if !AttrFlags::query(db, owner.into()).contains(AttrFlags::HAS_REPR) {

- // Don't create the query in case this has no repr, this wastes memory.

- return None;

- }

-

- return repr(db, owner);

-

- #[salsa::tracked]

- fn repr(db: &dyn DefDatabase, owner: AdtId) -> Option<ReprOptions> {

- let mut result = None;

- collect_attrs::<Infallible>(db, owner.into(), |attr| {

- if let Meta::TokenTree { path, tt } = attr

- && path.is1("repr")

- && let Some(repr) = parse_repr_tt(&tt)

- {

- match &mut result {

- Some(existing) => merge_repr(existing, repr),

- None => result = Some(repr),

- }

- }

- ControlFlow::Continue(())

- });

- result

- }

- }

-

- /// Call this only if there are legacy const generics, to save memory.

- #[salsa::tracked(returns(ref))]

- pub(crate) fn legacy_const_generic_indices(

- db: &dyn DefDatabase,

- owner: FunctionId,

- ) -> Option<Box<[u32]>> {

- let result = collect_attrs(db, owner.into(), |attr| {

- if let Meta::TokenTree { path, tt } = attr

- && path.is1("rustc_legacy_const_generics")

- {

- let result = parse_rustc_legacy_const_generics(tt);

- ControlFlow::Break(result)

- } else {

- ControlFlow::Continue(())

- }

- });

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

- }

-

- // There aren't typically many crates, so it's okay to always make this a query without a flag.

- #[salsa::tracked(returns(ref))]

- pub fn doc_html_root_url(db: &dyn DefDatabase, krate: Crate) -> Option<SmolStr> {

- let root_file_id = krate.root_file_id(db);

- let syntax = db.parse(root_file_id).tree();

-

- let mut cfg_options = None;

- expand_cfg_attr(

- syntax.attrs(),

- || cfg_options.get_or_insert(krate.cfg_options(db)),

- |attr, _, _, _| {

- if let Meta::TokenTree { path, tt } = attr

- && path.is1("doc")

- && let Some(result) = DocAtom::parse(tt).into_iter().find_map(|atom| {

- if let DocAtom::KeyValue { key, value } = atom

- && key == "html_root_url"

- {

- Some(value)

- } else {

- None

- }

- })

- {

- ControlFlow::Break(result)

- } else {

- ControlFlow::Continue(())

- }

- },

- )

- }

-

- #[inline]

- pub fn target_features(db: &dyn DefDatabase, owner: FunctionId) -> &FxHashSet<Symbol> {

- if !AttrFlags::query(db, owner.into()).contains(AttrFlags::HAS_TARGET_FEATURE) {

- return const { &FxHashSet::with_hasher(rustc_hash::FxBuildHasher) };

- }

-

- return target_features(db, owner);

-

- #[salsa::tracked(returns(ref))]

- fn target_features(db: &dyn DefDatabase, owner: FunctionId) -> FxHashSet<Symbol> {

- let mut result = FxHashSet::default();

- collect_attrs::<Infallible>(db, owner.into(), |attr| {

- if let Meta::TokenTree { path, tt } = attr

- && path.is1("target_feature")

- && let mut tt = TokenTreeChildren::new(&tt)

- && let Some(NodeOrToken::Token(enable_ident)) = tt.next()

- && enable_ident.text() == "enable"

- && let Some(NodeOrToken::Token(eq_token)) = tt.next()

- && eq_token.kind() == T![=]

- && let Some(NodeOrToken::Token(features)) = tt.next()

- && let Some(features) = ast::String::cast(features)

- && let Ok(features) = features.value()

- && tt.next().is_none()

- {

- result.extend(features.split(',').map(Symbol::intern));

- }

- ControlFlow::Continue(())

- });

- result.shrink_to_fit();

- result

- }

- }

-

- #[inline]

- pub fn rustc_layout_scalar_valid_range(

- db: &dyn DefDatabase,

- owner: AdtId,

- ) -> RustcLayoutScalarValidRange {

- if !AttrFlags::query(db, owner.into()).contains(AttrFlags::RUSTC_LAYOUT_SCALAR_VALID_RANGE)

- {

- return RustcLayoutScalarValidRange::default();

- }

-

- return rustc_layout_scalar_valid_range(db, owner);

-

- #[salsa::tracked]

- fn rustc_layout_scalar_valid_range(

- db: &dyn DefDatabase,

- owner: AdtId,

- ) -> RustcLayoutScalarValidRange {

- let mut result = RustcLayoutScalarValidRange::default();

- collect_attrs::<Infallible>(db, owner.into(), |attr| {

- if let Meta::TokenTree { path, tt } = attr

- && (path.is1("rustc_layout_scalar_valid_range_start")

- || path.is1("rustc_layout_scalar_valid_range_end"))

- && let tt = TokenTreeChildren::new(&tt)

- && let Ok(NodeOrToken::Token(value)) = tt.exactly_one()

- && let Some(value) = ast::IntNumber::cast(value)

- && let Ok(value) = value.value()

- {

- if path.is1("rustc_layout_scalar_valid_range_start") {

- result.start = Some(value)

- } else {

- result.end = Some(value);

- }

- }

- ControlFlow::Continue(())

- });

- result

- }

- }

-

- #[inline]

- pub fn doc_aliases(self, db: &dyn DefDatabase, owner: Either<AttrDefId, FieldId>) -> &[Symbol] {

- if !self.contains(AttrFlags::HAS_DOC_ALIASES) {

- return &[];

- }

- return match owner {

- Either::Left(it) => doc_aliases(db, it),

- Either::Right(field) => fields_doc_aliases(db, field.parent)

- .get(field.local_id)

- .map(|it| &**it)

- .unwrap_or_default(),

- };

-

- #[salsa::tracked(returns(ref))]

- fn doc_aliases(db: &dyn DefDatabase, owner: AttrDefId) -> Box<[Symbol]> {

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

- collect_attrs::<Infallible>(db, owner, |attr| extract_doc_aliases(&mut result, attr));

- result.into_boxed_slice()

- }

-

- #[salsa::tracked(returns(ref))]

- fn fields_doc_aliases(

- db: &dyn DefDatabase,

- variant: VariantId,

- ) -> ArenaMap<LocalFieldId, Box<[Symbol]>> {

- collect_field_attrs(db, variant, |cfg_options, field| {

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

- expand_cfg_attr(

- field.value.attrs(),

- || cfg_options,

- |attr, _, _, _| extract_doc_aliases(&mut result, attr),

- );

- result.into_boxed_slice()

- })

- }

- }

-

- #[inline]

- pub fn cfgs(self, db: &dyn DefDatabase, owner: Either<AttrDefId, FieldId>) -> Option<&CfgExpr> {

- if !self.contains(AttrFlags::HAS_CFG) {

- return None;

- }

- return match owner {

- Either::Left(it) => cfgs(db, it).as_ref(),

- Either::Right(field) => {

- fields_cfgs(db, field.parent).get(field.local_id).and_then(|it| it.as_ref())

- }

- };

-

- // We LRU this query because it is only used by IDE.

- #[salsa::tracked(returns(ref), lru = 250)]

- fn cfgs(db: &dyn DefDatabase, owner: AttrDefId) -> Option<CfgExpr> {

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

- collect_attrs::<Infallible>(db, owner, |attr| extract_cfgs(&mut result, attr));

- match result.len() {

- 0 => None,

- 1 => result.into_iter().next(),

- _ => Some(CfgExpr::All(result.into_boxed_slice())),

- }

- }

-

- // We LRU this query because it is only used by IDE.

- #[salsa::tracked(returns(ref), lru = 50)]

- fn fields_cfgs(

- db: &dyn DefDatabase,

- variant: VariantId,

- ) -> ArenaMap<LocalFieldId, Option<CfgExpr>> {

- collect_field_attrs(db, variant, |cfg_options, field| {

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

- expand_cfg_attr(

- field.value.attrs(),

- || cfg_options,

- |attr, _, _, _| extract_cfgs(&mut result, attr),

- );

- match result.len() {

- 0 => None,

- 1 => result.into_iter().next(),

- _ => Some(CfgExpr::All(result.into_boxed_slice())),

- }

- })

- }

- }

-

- #[inline]

- pub fn doc_keyword(db: &dyn DefDatabase, owner: InternedModuleId) -> Option<Symbol> {

- if !AttrFlags::query(db, AttrDefId::ModuleId(owner)).contains(AttrFlags::HAS_DOC_KEYWORD) {

- return None;

- }

- return doc_keyword(db, owner);

-

- #[salsa::tracked]

- fn doc_keyword(db: &dyn DefDatabase, owner: InternedModuleId) -> Option<Symbol> {

- collect_attrs(db, AttrDefId::ModuleId(owner), |attr| {

- if let Meta::TokenTree { path, tt } = attr

- && path.is1("doc")

- {

- for atom in DocAtom::parse(tt) {

- if let DocAtom::KeyValue { key, value } = atom

- && key == "keyword"

- {

- return ControlFlow::Break(Symbol::intern(&value));

- }

- }

- }

- ControlFlow::Continue(())

- })

- }

- }

-

- // We LRU this query because it is only used by IDE.

- #[salsa::tracked(returns(ref), lru = 250)]

- pub fn docs(db: &dyn DefDatabase, owner: AttrDefId) -> Option<Box<Docs>> {

- let (source, outer_mod_decl, krate) = attrs_source(db, owner);

- let inner_attrs_node = source.value.inner_attributes_node();

- extract_docs(&|| krate.cfg_options(db), source, outer_mod_decl, inner_attrs_node)

- }

-

- #[inline]

- pub fn field_docs(db: &dyn DefDatabase, field: FieldId) -> Option<&Docs> {

- return fields_docs(db, field.parent).get(field.local_id).and_then(|it| it.as_deref());

-

- // We LRU this query because it is only used by IDE.

- #[salsa::tracked(returns(ref), lru = 50)]

- pub fn fields_docs(

- db: &dyn DefDatabase,

- variant: VariantId,

- ) -> ArenaMap<LocalFieldId, Option<Box<Docs>>> {

- collect_field_attrs(db, variant, |cfg_options, field| {

- extract_docs(&|| cfg_options, field, None, None)

- })

- }

- }

-

- #[inline]

- pub fn derive_info(db: &dyn DefDatabase, owner: MacroId) -> Option<&DeriveInfo> {

- if !AttrFlags::query(db, owner.into()).contains(AttrFlags::IS_DERIVE_OR_BUILTIN_MACRO) {

- return None;

- }

-

- return derive_info(db, owner).as_ref();

-

- #[salsa::tracked(returns(ref))]

- fn derive_info(db: &dyn DefDatabase, owner: MacroId) -> Option<DeriveInfo> {

- collect_attrs(db, owner.into(), |attr| {

- if let Meta::TokenTree { path, tt } = attr

- && path.segments.len() == 1

- && matches!(

- path.segments[0].text(),

- "proc_macro_derive" | "rustc_builtin_macro"

- )

- && let mut tt = TokenTreeChildren::new(&tt)

- && let Some(NodeOrToken::Token(trait_name)) = tt.next()

- && trait_name.kind().is_any_identifier()

- {

- let trait_name = Symbol::intern(trait_name.text());

-

- let helpers = if let Some(NodeOrToken::Token(comma)) = tt.next()

- && comma.kind() == T![,]

- && let Some(NodeOrToken::Token(attributes)) = tt.next()

- && attributes.text() == "attributes"

- && let Some(NodeOrToken::Node(attributes)) = tt.next()

- {

- attributes

- .syntax()

- .children_with_tokens()

- .filter_map(NodeOrToken::into_token)

- .filter(|it| it.kind().is_any_identifier())

- .map(|it| Symbol::intern(it.text()))

- .collect::<Box<[_]>>()

- } else {

- Box::new([])

- };

-

- ControlFlow::Break(DeriveInfo { trait_name, helpers })

- } else {

- ControlFlow::Continue(())

- }

- })

- }

- }

-}

-

-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: &ast::TokenTree) -> Option<ReprOptions> {

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

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

-

- let mut tts = TokenTreeChildren::new(tt).peekable();

-

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

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

- let NodeOrToken::Token(ident) = tt else {

- continue;

- };

- if !ident.kind().is_any_identifier() {

- continue;

- }

- let repr = match ident.text() {

- "packed" => {

- let pack = if let Some(NodeOrToken::Node(tt)) = tts.peek() {

- let tt = tt.clone();

- tts.next();

- let mut tt_iter = TokenTreeChildren::new(&tt);

- if let Some(NodeOrToken::Token(lit)) = tt_iter.next()

- && let Some(lit) = ast::IntNumber::cast(lit)

- && let Ok(lit) = lit.value()

- && let Ok(lit) = lit.try_into()

- {

- lit

- } else {

- 0

- }

- } else {

- 0

- };

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

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

- }

- "align" => {

- let mut align = None;

- if let Some(NodeOrToken::Node(tt)) = tts.peek() {

- let tt = tt.clone();

- tts.next();

- let mut tt_iter = TokenTreeChildren::new(&tt);

- if let Some(NodeOrToken::Token(lit)) = tt_iter.next()

- && let Some(lit) = ast::IntNumber::cast(lit)

- && let Ok(lit) = lit.value()

- && let Ok(lit) = lit.try_into()

- {

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

- }

- }

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

- }

- "C" => ReprOptions { flags: ReprFlags::IS_C, ..Default::default() },

- "transparent" => ReprOptions { flags: ReprFlags::IS_TRANSPARENT, ..Default::default() },

- "simd" => ReprOptions { flags: ReprFlags::IS_SIMD, ..Default::default() },

- repr => {

- let mut int = None;

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

- .map(Either::Left)

- .or_else(|| BuiltinUint::from_suffix(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)

-}

-

-fn parse_rustc_legacy_const_generics(tt: ast::TokenTree) -> Box<[u32]> {

- TokenTreeChildren::new(&tt)

- .filter_map(|param| {

- ast::IntNumber::cast(param.into_token()?)?.value().ok()?.try_into().ok()

- })

- .collect()

-}

-

-#[derive(Debug)]

-enum DocAtom {

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

- Flag(SmolStr),

- /// 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: SmolStr, value: SmolStr },

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

- Alias(Vec<SmolStr>),

-}

-

-impl DocAtom {

- fn parse(tt: ast::TokenTree) -> SmallVec<[DocAtom; 1]> {

- let mut iter = TokenTreeChildren::new(&tt).peekable();

- let mut result = SmallVec::new();

- while iter.peek().is_some() {

- if let Some(expr) = next_doc_expr(&mut iter) {

- result.push(expr);

- }

- }

- result

- }

-}

-

-fn next_doc_expr(it: &mut Peekable<TokenTreeChildren>) -> Option<DocAtom> {

- let name = match it.next() {

- Some(NodeOrToken::Token(token)) if token.kind().is_any_identifier() => {

- SmolStr::new(token.text())

- }

- _ => return None,

- };

-

- let ret = match it.peek() {

- Some(NodeOrToken::Token(eq)) if eq.kind() == T![=] => {

- it.next();

- if let Some(NodeOrToken::Token(value)) = it.next()

- && let Some(value) = ast::String::cast(value)

- && let Ok(value) = value.value()

- {

- DocAtom::KeyValue { key: name, value: SmolStr::new(&*value) }

- } else {

- return None;

- }

- }

- Some(NodeOrToken::Node(subtree)) => {

- if name != "alias" {

- return None;

- }

- let aliases = TokenTreeChildren::new(subtree)

- .filter_map(|alias| {

- Some(SmolStr::new(&*ast::String::cast(alias.into_token()?)?.value().ok()?))

- })

- .collect();

- it.next();

- DocAtom::Alias(aliases)

- }

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

- };

- Some(ret)

-}

-

-#[cfg(test)]

-mod tests {

- use expect_test::expect;

- use hir_expand::InFile;

- use test_fixture::WithFixture;

- use tt::{TextRange, TextSize};

-

- use crate::attrs::IsInnerDoc;

- use crate::{attrs::Docs, test_db::TestDB};

-

- #[test]

- fn docs() {

- let (_db, file_id) = TestDB::with_single_file("");

- let mut docs = Docs {

- docs: String::new(),

- docs_source_map: Vec::new(),

- outline_mod: None,

- inline_file: file_id.into(),

- prefix_len: TextSize::new(0),

- inline_inner_docs_start: None,

- outline_inner_docs_start: None,

- };

- let mut indent = usize::MAX;

-

- let outer = " foo\n\tbar baz";

- let mut ast_offset = TextSize::new(123);

- for line in outer.split('\n') {

- docs.extend_with_doc_str(line, ast_offset, &mut indent);

- ast_offset += TextSize::of(line) + TextSize::of("\n");

- }

-

- docs.inline_inner_docs_start = Some(TextSize::of(&docs.docs));

- ast_offset += TextSize::new(123);

- let inner = " bar \n baz";

- for line in inner.split('\n') {

- docs.extend_with_doc_str(line, ast_offset, &mut indent);

- ast_offset += TextSize::of(line) + TextSize::of("\n");

- }

-

- assert_eq!(indent, 1);

- expect![[r#"

- [

- DocsSourceMapLine {

- string_offset: 0,

- ast_offset: 123,

- },

- DocsSourceMapLine {

- string_offset: 5,

- ast_offset: 128,

- },

- DocsSourceMapLine {

- string_offset: 15,

- ast_offset: 261,

- },

- DocsSourceMapLine {

- string_offset: 20,

- ast_offset: 267,

- },

- ]

- "#]]

- .assert_debug_eq(&docs.docs_source_map);

-

- docs.remove_indent(indent, 0);

-

- assert_eq!(docs.inline_inner_docs_start, Some(TextSize::new(13)));

-

- assert_eq!(docs.docs, "foo\nbar baz\nbar\nbaz\n");

- expect![[r#"

- [

- DocsSourceMapLine {

- string_offset: 0,

- ast_offset: 124,

- },

- DocsSourceMapLine {

- string_offset: 4,

- ast_offset: 129,

- },

- DocsSourceMapLine {

- string_offset: 13,

- ast_offset: 262,

- },

- DocsSourceMapLine {

- string_offset: 17,

- ast_offset: 268,

- },

- ]

- "#]]

- .assert_debug_eq(&docs.docs_source_map);

-

- docs.append(&docs.clone());

- docs.prepend_str("prefix---");

- assert_eq!(docs.docs, "prefix---foo\nbar baz\nbar\nbaz\nfoo\nbar baz\nbar\nbaz\n");

- expect![[r#"

- [

- DocsSourceMapLine {

- string_offset: 0,

- ast_offset: 124,

- },

- DocsSourceMapLine {

- string_offset: 4,

- ast_offset: 129,

- },

- DocsSourceMapLine {

- string_offset: 13,

- ast_offset: 262,

- },

- DocsSourceMapLine {

- string_offset: 17,

- ast_offset: 268,

- },

- DocsSourceMapLine {

- string_offset: 21,

- ast_offset: 124,

- },

- DocsSourceMapLine {

- string_offset: 25,

- ast_offset: 129,

- },

- DocsSourceMapLine {

- string_offset: 34,

- ast_offset: 262,

- },

- DocsSourceMapLine {

- string_offset: 38,

- ast_offset: 268,

- },

- ]

- "#]]

- .assert_debug_eq(&docs.docs_source_map);

-

- let range = |start, end| TextRange::new(TextSize::new(start), TextSize::new(end));

- let in_file = |range| InFile::new(file_id.into(), range);

- assert_eq!(docs.find_ast_range(range(0, 2)), None);

- assert_eq!(docs.find_ast_range(range(8, 10)), None);

- assert_eq!(

- docs.find_ast_range(range(9, 10)),

- Some((in_file(range(124, 125)), IsInnerDoc::No))

- );

- assert_eq!(docs.find_ast_range(range(20, 23)), None);

- assert_eq!(

- docs.find_ast_range(range(23, 25)),

- Some((in_file(range(263, 265)), IsInnerDoc::Yes))

- );

- }

-}

- AssocItemId, AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc, CrateRootModuleId, DefWithBodyId,

- EnumId, EnumLoc, EnumVariantId, EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId,

- ExternCrateLoc, FunctionId, FunctionLoc, GenericDefId, HasModule, ImplId, ImplLoc,

- InternedModuleId, LocalFieldId, Macro2Id, Macro2Loc, MacroExpander, MacroId, MacroRulesId,

- MacroRulesLoc, MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId, StaticLoc, StructId,

- StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc,

- VariantId,

- attrs::AttrFlags,

- // FIXME: Get rid of this, call `AttrFlags::lang_item()` directly.

- let root_module = CrateRootModuleId::from(crate_id).module(db);

- let attrs = AttrFlags::query(db, AttrDefId::ModuleId(InternedModuleId::new(db, root_module)));

- attrs.contains(AttrFlags::IS_NO_STD)

-use crate::{

- MacroId, UnresolvedMacro, attrs::AttrFlags, db::DefDatabase, expr_store::HygieneId,

- macro_call_as_call_id, nameres::DefMap,

-};

- owner: &dyn HasAttrs,

- AttrFlags::is_cfg_enabled_for(owner, cfg_options)

- attrs::AttrFlags,

- let skip_body = AttrFlags::query(

- db,

- match owner {

- DefWithBodyId::FunctionId(it) => it.into(),

- DefWithBodyId::StaticId(it) => it.into(),

- DefWithBodyId::ConstId(it) => it.into(),

- DefWithBodyId::VariantId(it) => it.into(),

- },

- )

- .contains(AttrFlags::RUST_ANALYZER_SKIP);

- let enabled = self.expander.is_cfg_enabled(owner, self.cfg_options);

- AdtId, DefWithBodyId, FunctionId, GenericDefId, StructId, TypeParamId, VariantId,

- attrs::AttrFlags,

- print_struct(db, id, &signature, edition)

- print_function(db, id, &signature, edition)

- id: StructId,

- StructSignature { name, generic_params, store, flags, shape }: &StructSignature,

- if let Some(repr) = AttrFlags::repr(db, id.into()) {

- id: FunctionId,

- signature @ FunctionSignature {

- let legacy_const_generics_indices = signature.legacy_const_generics_indices(db, id);

- if legacy_const_generics_indices.is_some_and(|idx| idx.contains(&(i as u32))) {

- BlockId(3801) in BlockRelativeModuleId { block: Some(BlockId(3800)), local_id: Idx::<ModuleData>(1) }

- BlockId(3800) in BlockRelativeModuleId { block: None, local_id: Idx::<ModuleData>(0) }

- out += &print_struct(

- &db,

- struct_id,

- &db.struct_signature(struct_id),

- Edition::CURRENT,

- );

- out += &print_function(

- &db,

- function_id,

- &db.function_signature(function_id),

- Edition::CURRENT,

- )

- AssocItemId, AttrDefId, Complete, FxIndexMap, InternedModuleId, ModuleDefId, ModuleId, TraitId,

- attrs::AttrFlags,

- ItemInNs::Types(id) | ItemInNs::Values(id) => match id {

- ModuleDefId::ModuleId(it) => {

- Some(AttrDefId::ModuleId(InternedModuleId::new(db, it)))

- }

- ModuleDefId::FunctionId(it) => Some(it.into()),

- ModuleDefId::AdtId(it) => Some(it.into()),

- ModuleDefId::EnumVariantId(it) => Some(it.into()),

- ModuleDefId::ConstId(it) => Some(it.into()),

- ModuleDefId::StaticId(it) => Some(it.into()),

- ModuleDefId::TraitId(it) => Some(it.into()),

- ModuleDefId::TypeAliasId(it) => Some(it.into()),

- ModuleDefId::MacroId(it) => Some(it.into()),

- ModuleDefId::BuiltinType(_) => None,

- },

- let attrs = AttrFlags::query(db, attr_id);

- Complete::extract(matches!(attr_id, AttrDefId::TraitId(_)), attrs);

- (

- attrs.contains(AttrFlags::IS_DOC_HIDDEN),

- attrs.contains(AttrFlags::IS_UNSTABLE),

- do_not_complete,

- )

- let attrs = AttrFlags::query(db, attr_id);

- is_doc_hidden: attrs.contains(AttrFlags::IS_DOC_HIDDEN),

- is_unstable: attrs.contains(AttrFlags::IS_UNSTABLE),

-mod attrs;

-use crate::{BlockId, Lookup, db::DefDatabase};

-pub(crate) use crate::item_tree::{

- attrs::*,

- lower::{lower_use_tree, visibility_from_ast},

-};

- let top_attrs = ctx.lower_attrs(&file);

- top_attrs: AttrsOrCfg::empty(),

- top_attrs: AttrsOrCfg::empty(),

- top_attrs: AttrsOrCfg,

- attrs: FxHashMap<FileAstId<ast::Item>, AttrsOrCfg>,

- pub(crate) fn top_level_attrs(&self) -> &AttrsOrCfg {

- pub(crate) fn attrs(&self, of: FileAstId<ast::Item>) -> Option<&AttrsOrCfg> {

- self.attrs.get(&of)

-//! Defines attribute helpers for name resolution.

-//!

-//! Notice we don't preserve all attributes for name resolution, to save space:

-//! for example, we skip doc comments (desugared to `#[doc = "..."]` attributes)

-//! and `#[inline]`. The filtered attributes are listed in [`hir_expand::attrs`].

-

-use std::{

- borrow::Cow,

- convert::Infallible,

- ops::{self, ControlFlow},

-};

-

-use cfg::{CfgExpr, CfgOptions};

-use either::Either;

-use hir_expand::{

- attrs::{Attr, AttrId, AttrInput, Meta, collect_item_tree_attrs},

- mod_path::ModPath,

- name::Name,

- span_map::SpanMapRef,

-};

-use intern::{Interned, Symbol, sym};

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

-use syntax_bridge::DocCommentDesugarMode;

-use tt::token_to_literal;

-

-use crate::{db::DefDatabase, item_tree::lower::Ctx};

-

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

-pub(crate) enum AttrsOrCfg {

- Enabled {

- attrs: AttrsOwned,

- },

- /// This only collects the attributes up to the disabled `cfg` (this is what needed for crate-level attributes.)

- CfgDisabled(Box<(CfgExpr, AttrsOwned)>),

-}

-

-impl Default for AttrsOrCfg {

- #[inline]

- fn default() -> Self {

- AttrsOrCfg::Enabled { attrs: AttrsOwned(Box::new([])) }

- }

-}

-

-impl AttrsOrCfg {

- pub(crate) fn lower<'a>(

- db: &dyn DefDatabase,

- owner: &dyn ast::HasAttrs,

- cfg_options: &dyn Fn() -> &'a CfgOptions,

- span_map: SpanMapRef<'_>,

- ) -> AttrsOrCfg {

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

- let result =

- collect_item_tree_attrs::<Infallible>(owner, cfg_options, |meta, container, _, _| {

- // NOTE: We cannot early return from this function, *every* attribute must be pushed, otherwise we'll mess the `AttrId`

- // tracking.

- let (span, path_range, input) = match meta {

- Meta::NamedKeyValue { path_range, name: _, value } => {

- let span = span_map.span_for_range(path_range);

- let input = value.map(|value| {

- Box::new(AttrInput::Literal(token_to_literal(

- value.text(),

- span_map.span_for_range(value.text_range()),

- )))

- });

- (span, path_range, input)

- }

- Meta::TokenTree { path, tt } => {

- let span = span_map.span_for_range(path.range);

- let tt = syntax_bridge::syntax_node_to_token_tree(

- tt.syntax(),

- span_map,

- span,

- DocCommentDesugarMode::ProcMacro,

- );

- let input = Some(Box::new(AttrInput::TokenTree(tt)));

- (span, path.range, input)

- }

- Meta::Path { path } => {

- let span = span_map.span_for_range(path.range);

- (span, path.range, None)

- }

- };

-

- let path = container.token_at_offset(path_range.start()).right_biased().and_then(

- |first_path_token| {

- let is_abs = matches!(first_path_token.kind(), T![:] | T![::]);

- let segments =

- std::iter::successors(Some(first_path_token), |it| it.next_token())

- .take_while(|it| it.text_range().end() <= path_range.end())

- .filter(|it| it.kind().is_any_identifier());

- ModPath::from_tokens(

- db,

- &mut |range| span_map.span_for_range(range).ctx,

- is_abs,

- segments,

- )

- },

- );

- let path = path.unwrap_or_else(|| Name::missing().into());

-

- attrs.push(Attr { path: Interned::new(path), input, ctxt: span.ctx });

- ControlFlow::Continue(())

- });

- let attrs = AttrsOwned(attrs.into_boxed_slice());

- match result {

- Some(Either::Right(cfg)) => AttrsOrCfg::CfgDisabled(Box::new((cfg, attrs))),

- None => AttrsOrCfg::Enabled { attrs },

- }

- }

-}

-

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

-pub(crate) struct AttrsOwned(Box<[Attr]>);

-

-#[derive(Debug, Clone, Copy)]

-pub(crate) struct Attrs<'a>(&'a [Attr]);

-

-impl ops::Deref for Attrs<'_> {

- type Target = [Attr];

-

- #[inline]

- fn deref(&self) -> &Self::Target {

- self.0

- }

-}

-

-impl Ctx<'_> {

- #[inline]

- pub(super) fn lower_attrs(&self, owner: &dyn ast::HasAttrs) -> AttrsOrCfg {

- AttrsOrCfg::lower(self.db, owner, &|| self.cfg_options(), self.span_map())

- }

-}

-

-impl AttrsOwned {

- #[inline]

- pub(crate) fn as_ref(&self) -> Attrs<'_> {

- Attrs(&self.0)

- }

-}

-

-impl<'a> Attrs<'a> {

- pub(crate) const EMPTY: Self = Attrs(&[]);

-

- #[inline]

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

- AttrQuery { attrs: self, key }

- }

-

- #[inline]

- pub(crate) fn iter(self) -> impl Iterator<Item = (AttrId, &'a Attr)> {

- self.0.iter().enumerate().map(|(id, attr)| (AttrId::from_item_tree_index(id as u32), attr))

- }

-

- #[inline]

- pub(crate) fn iter_after(

- self,

- after: Option<AttrId>,

- ) -> impl Iterator<Item = (AttrId, &'a Attr)> {

- let skip = after.map_or(0, |after| after.item_tree_index() + 1);

- self.0[skip as usize..]

- .iter()

- .enumerate()

- .map(move |(id, attr)| (AttrId::from_item_tree_index(id as u32 + skip), attr))

- }

-

- #[inline]

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

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

- }

-

- #[inline]

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

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

- }

-}

-#[derive(Debug, Clone)]

-pub(crate) struct AttrQuery<'attr> {

- attrs: Attrs<'attr>,

- key: Symbol,

-}

-

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

- #[inline]

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

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

- }

-

- #[inline]

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

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

- }

-

- #[inline]

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

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

- }

-

- #[inline]

- pub(crate) fn exists(self) -> bool {

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

- }

-

- #[inline]

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

- let key = self.key;

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

- }

-}

-

-impl AttrsOrCfg {

- #[inline]

- pub(super) fn empty() -> Self {

- AttrsOrCfg::Enabled { attrs: AttrsOwned(Box::new([])) }

- }

-

- #[inline]

- pub(super) fn is_empty(&self) -> bool {

- matches!(self, AttrsOrCfg::Enabled { attrs } if attrs.as_ref().is_empty())

- }

-}

-use std::cell::OnceCell;

-use cfg::CfgOptions;

- ModItemId, ModKind, ModPath, RawVisibility, RawVisibilityId, SmallModItem, Static, Struct,

- StructKind, Trait, TypeAlias, Union, Use, UseTree, UseTreeKind, VisibilityExplicitness,

- attrs::AttrsOrCfg,

- pub(super) db: &'a dyn DefDatabase,

- cfg_options: OnceCell<&'a CfgOptions>,

- cfg_options: OnceCell::new(),

- #[inline]

- pub(super) fn cfg_options(&self) -> &'a CfgOptions {

- self.cfg_options.get_or_init(|| self.file.krate(self.db).cfg_options(self.db))

- }

-

- self.tree.top_attrs = self.lower_attrs(block);

- let attrs = self.lower_attrs(item);

- fn add_attrs(&mut self, item: FileAstId<ast::Item>, attrs: AttrsOrCfg) {

- self.tree.attrs.insert(item, attrs);

- let attrs = self.lower_attrs(&item);

- Macro2, MacroCall, MacroRules, Mod, ModItemId, ModKind, RawVisibilityId, Static, Struct,

- Trait, TypeAlias, Union, Use, UseTree, UseTreeKind, attrs::AttrsOrCfg,

- fn print_attrs(&mut self, attrs: &AttrsOrCfg, inner: bool, separated_by: &str) {

- let AttrsOrCfg::Enabled { attrs } = attrs else {

- w!(self, "#[cfg(false)]{separated_by}");

- return;

- };

- for attr in &*attrs.as_ref() {

- expect![[r#"

- "#]],

- attrs::AttrFlags,

- if let Some(lang_item) = AttrFlags::lang_item(db, item.into()) {

- AttrFlags::lang_item(db, item)

- && AttrFlags::query(db, trait_.into()).contains(AttrFlags::IS_DOC_NOTABLE_TRAIT)

-pub mod attrs;

-use intern::{Interned, Symbol};

- attrs::AttrFlags,

-// FIXME: We probably should use this in more places.

-/// This is used to avoid interning the whole `AttrDefId`, so we intern just modules and not everything.

-#[salsa_macros::interned(debug, no_lifetime)]

-pub struct InternedModuleId {

- pub loc: ModuleId,

-}

-

-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, salsa_macros::Supertype)]

- ModuleId(InternedModuleId),

- AttrDefId::ModuleId(it) => it.loc(db),

- #[inline]

- pub fn extract(is_trait: bool, attrs: AttrFlags) -> Complete {

- if attrs.contains(AttrFlags::COMPLETE_IGNORE_FLYIMPORT) {

- return Complete::IgnoreFlyimport;

- } else if is_trait {

- if attrs.contains(AttrFlags::COMPLETE_IGNORE_METHODS) {

- return Complete::IgnoreMethods;

- } else if attrs.contains(AttrFlags::COMPLETE_IGNORE_FLYIMPORT_METHODS) {

- return Complete::IgnoreFlyimportMethods;

- Complete::Yes

- ($i:ident) => ( enum $i {} );

-m! { Foo }

- ($i:ident) => ( enum $i {} );

-enum Foo {}

- ($i:ident) => ( enum $i {} );

-m! { Foo }

- ($i:ident) => ( enum $i {} );

-enum Foo {}

- ($i:ident) => ( enum $i {} );

-m! { Foo }

- ($i:ident) => ( enum $i {} );

-enum Foo {}

- ($($i:ident),*) => ($(enum $i {} )*);

-m! { Baz, Qux }

- ($($i:ident),*) => ($(enum $i {} )*);

-enum Baz {}

-enum Qux {}

-m! { struct C {} }

-struct C {}

- // The modules are counted twice, once because of the module and once because of the macro call.

-

-mod b;

-mod c {}"#]],

- for (_, module) in def_map.modules() {

- let Some(src) = module.declaration_source(&db) else {

- continue;

- };

- if let Some(macro_file) = src.file_id.macro_file() {

- let pp = pretty_print_macro_expansion(

- src.value.syntax().clone(),

- db.span_map(macro_file.into()).as_ref(),

- false,

- false,

- );

- format_to!(expanded_text, "\n{}", pp)

- }

- }

-

-//- minicore: derive

-#[attr1] #[derive()] #[proc_macros::identity] #[attr2]

-

-/// Foo

-#[cfg_attr(false, doc = "abc...", attr1)]

-mod foo {

- #![cfg_attr(true, cfg_attr(true, foo, cfg_attr(false, bar), proc_macros::identity))]

- #![cfg_attr(true, doc = "123...", attr2)]

- #![attr3]

-

- #[cfg_attr(true, cfg(false))]

- fn foo() {}

-

- #[cfg(true)]

- fn bar() {}

-}

- expect![[r##"

-#[attr1] #[derive()] #[proc_macros::identity] #[attr2]

-/// Foo

-#[cfg_attr(false, doc = "abc...", attr1)]

-mod foo {

- #![cfg_attr(true, cfg_attr(true, foo, cfg_attr(false, bar), proc_macros::identity))]

- #![cfg_attr(true, doc = "123...", attr2)]

- #![attr3]

-

- #[cfg_attr(true, cfg(false))]

- fn foo() {}

-

- #[cfg(true)]

- fn bar() {}

-}

-

-#[attr2] struct S;

-#[doc = " Foo"] mod foo {

- # ![foo]

- # ![doc = "123..."]

- # ![attr2]

- # ![attr3]

- #[cfg_attr(true , cfg(false ))] fn foo() {}

- #[cfg(true )] fn bar() {}

-}"##]],

-use derive as my_cool_derive;

-

-#[my_cool_derive()]

-#[cfg_attr(true, derive(), attr1, derive(proc_macros::DeriveIdentity))]

-#[my_cool_derive()]

-struct Foo {

- #[cfg_attr(false, cfg(false), attr2)]

- v1: i32,

- #[cfg_attr(true, cfg(false), attr2)]

- v1: i32,

- #[cfg_attr(true, attr3)]

- v2: fn(#[cfg(false)] param: i32, #[cfg_attr(true, attr4)] param2: u32),

- v3: Foo<{

- #[cfg(false)]

- let foo = 123;

- 456

- }>,

- #[cfg(false)]

- v4: bool // No comma here

-}

-use derive as my_cool_derive;

-#[my_cool_derive()]

-#[cfg_attr(true, derive(), attr1, derive(proc_macros::DeriveIdentity))]

-#[my_cool_derive()]

-struct Foo {

- #[cfg_attr(false, cfg(false), attr2)]

- v1: i32,

- #[cfg_attr(true, cfg(false), attr2)]

- v1: i32,

- #[cfg_attr(true, attr3)]

- v2: fn(#[cfg(false)] param: i32, #[cfg_attr(true, attr4)] param2: u32),

- v3: Foo<{

- #[cfg(false)]

- let foo = 123;

- 456

- }>,

- #[cfg(false)]

- v4: bool // No comma here

-}

-

-#[attr1]

-#[my_cool_derive()] struct Foo {

- v1: i32, #[attr3]v2: fn(#[attr4]param2: u32), v3: Foo< {

- 456

- }

- >,

-}

- bar.;

- let root_file_id = crate_id.root_file_id(db);

- let module_data =

- ModuleData::new(ModuleOrigin::CrateRoot { definition: root_file_id }, Visibility::Public);

- let (def_map, local_def_map) =

- collector::collect_defs(db, def_map, TreeId::new(root_file_id.into(), None), None);

- AstId, AttrMacroAttrIds, ExpandTo, HirFileId, InFile, Intern, Lookup, MacroCallKind,

- MacroDefKind,

- item_tree::AttrsOrCfg,

- let attrs =

- match AttrsOrCfg::lower(self.db, &item, &|| self.cfg_options, self.span_map.as_ref()) {

- AttrsOrCfg::Enabled { attrs } => attrs,

- AttrsOrCfg::CfgDisabled(cfg) => {

- self.diagnostics.push(DefDiagnostic::unconfigured_code(

- self.module_id.local_id,

- InFile::new(self.file_id, ast_id.erase()),

- cfg.0,

- self.cfg_options.clone(),

- ));

- return;

- }

- };

- 'attrs: for (attr_id, attr) in attrs.as_ref().iter() {

- attr_id,

- MacroCallKind::Attr {

- ast_id,

- attr_args: None,

- censored_attr_ids: AttrMacroAttrIds::from_one(attr_id),

- },

- (*attr.path).clone(),

- AttrMacroAttrIds, MacroCallId, MacroCallKind, MacroDefId,

- /// This cannot be used to resolve items that allow derives.

- attr_id: AttrId,

- // There aren't any active attributes before this one, because attribute macros

- // replace their input, and derive macros are not allowed in this function.

- AttrMacroAttrIds::from_one(attr_id),

- censored_attr_ids: AttrMacroAttrIds,

- censored_attr_ids,

-use std::{cmp::Ordering, iter, mem};

- AttrMacroAttrIds, EditionedFileId, ErasedAstId, ExpandTo, HirFileId, InFile, MacroCallId,

- MacroCallKind, MacroDefId, MacroDefKind,

-use itertools::izip;

-use smallvec::SmallVec;

- self, Attrs, AttrsOrCfg, FieldsShape, ImportAlias, ImportKind, ItemTree, ItemTreeAstId,

- Macro2, MacroCall, MacroRules, Mod, ModItemId, ModKind, TreeId,

- prev_active_attrs: Default::default(),

- attr_id: AttrId,

- skip_attrs: FxHashMap<AstId<ast::Item>, AttrId>,

- /// When we expand attributes, we need to censor all previous active attributes

- /// on the same item. Therefore, this holds all active attributes that we already

- /// expanded.

- prev_active_attrs: FxHashMap<AstId<ast::Item>, SmallVec<[AttrId; 1]>>,

- let file_id = self.def_map.krate.root_file_id(self.db);

- let attrs = match item_tree.top_level_attrs() {

- AttrsOrCfg::Enabled { attrs } => attrs.as_ref(),

- AttrsOrCfg::CfgDisabled(it) => it.1.as_ref(),

- };

- |(feat, _, _)| match feat.segments() {

- if matches!(item_tree.top_level_attrs(), AttrsOrCfg::CfgDisabled(_)) {

- let is_cfg_enabled = matches!(item_tree.top_level_attrs(), AttrsOrCfg::Enabled { .. });

- MacroDirectiveKind::Attr { ast_id, mod_item, attr_id, attr, tree, item_tree } => {

- censored_attr_ids: AttrMacroAttrIds::from_one(*attr_id),

- (*attr.path).clone(),

- self.skip_attrs.insert(ast_id.ast_id.with_value(mod_item.ast_id()), *attr_id);

- attr_id,

- .insert(InFile::new(file_id, mod_item.ast_id()), *attr_id);

- let mut call_id = || {

- let active_attrs = self.prev_active_attrs.entry(ast_id).or_default();

- active_attrs.push(*attr_id);

-

- attr_macro_as_call_id(

- self.db,

- file_ast_id,

- attr,

- AttrMacroAttrIds::from_many(active_attrs),

- self.def_map.krate,

- def,

- )

- *attr_id,

- for (idx, (path, call_site, _)) in derive_macros.enumerate() {

- derive_attr: *attr_id,

- .init_derive_attribute(ast_id, *attr_id, call_id, len + 1);

- *attr_id,

- let attrs = match self.item_tree.attrs(item.ast_id()) {

- Some(AttrsOrCfg::Enabled { attrs }) => attrs.as_ref(),

- None => Attrs::EMPTY,

- Some(AttrsOrCfg::CfgDisabled(cfg)) => {

- let ast_id = item.ast_id().erase();

- self.emit_unconfigured_diagnostic(InFile::new(self.file_id(), ast_id), &cfg.0);

- return;

- }

- };

- if let Err(()) = self.resolve_attributes(attrs, item, container) {

- ModItemId::Mod(m) => self.collect_module(m, attrs),

- for (path, _, _) in paths {

- fn collect_module(&mut self, module_ast_id: ItemTreeAstId<Mod>, attrs: Attrs<'_>) {

- self.def_collector.def_map.krate,

- match item_tree.top_level_attrs() {

- AttrsOrCfg::CfgDisabled(cfg) => {

- &cfg.0,

- AttrsOrCfg::Enabled { attrs } => {

- let is_macro_use =

- is_macro_use || attrs.as_ref().by_key(sym::macro_use).exists();

- attrs: Attrs<'_>,

- let ignore_up_to = self

- for (attr_id, attr) in attrs.iter_after(ignore_up_to) {

- attr_id,

- let attrs = match self.item_tree.attrs(ast_id.upcast()) {

- Some(AttrsOrCfg::Enabled { attrs }) => attrs.as_ref(),

- None => Attrs::EMPTY,

- Some(AttrsOrCfg::CfgDisabled(_)) => {

- unreachable!("we only get here if the macro is not cfg'ed out")

- }

- };

- let attrs = match self.item_tree.attrs(ast_id.upcast()) {

- Some(AttrsOrCfg::Enabled { attrs }) => attrs.as_ref(),

- None => Attrs::EMPTY,

- Some(AttrsOrCfg::CfgDisabled(_)) => {

- unreachable!("we only get here if the macro is not cfg'ed out")

- }

- };

- prev_active_attrs: Default::default(),

- InvalidDeriveTarget { ast: AstId<ast::Item>, id: AttrId },

- MalformedDerive { ast: AstId<ast::Adt>, id: AttrId },

- Self { in_module: container, kind: DefDiagnosticKind::InvalidDeriveTarget { ast, id } }

- Self { in_module: container, kind: DefDiagnosticKind::MalformedDerive { ast, id } }

-use base_db::{AnchoredPath, Crate};

- krate: Crate,

- EditionedFileId::new(db, file_id, orig_file_id.edition(db), krate),

-use crate::{

- item_tree::Attrs,

- tt::{Leaf, TokenTree, TopSubtree, TtElement},

-};

-impl Attrs<'_> {

- pub(crate) fn parse_proc_macro_decl(&self, func_name: &Name) -> Option<ProcMacroDef> {

- pub(crate) fn parse_proc_macro_derive(&self) -> Option<(Name, Box<[Name]>)> {

- .filter_map(|tt| match tt {

- .collect::<Box<[_]>>();

- attrs::AttrFlags,

- /// Indicates whether this struct has `#[repr]`.

- const HAS_REPR = 1 << 0;

- let attrs = AttrFlags::query(db, id.into());

- if attrs.contains(AttrFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS) {

- if attrs.contains(AttrFlags::FUNDAMENTAL) {

- if attrs.contains(AttrFlags::HAS_REPR) {

- flags |= StructFlags::HAS_REPR;

- }

- if let Some(lang) = attrs.lang_item_with_attrs(db, id.into()) {

-

- #[inline]

- pub fn repr(&self, db: &dyn DefDatabase, id: StructId) -> Option<ReprOptions> {

- if self.flags.contains(StructFlags::HAS_REPR) {

- AttrFlags::repr(db, id.into())

- } else {

- None

- }

- }

- let attrs = AttrFlags::query(db, id.into());

- if attrs.contains(AttrFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS) {

- if attrs.contains(AttrFlags::FUNDAMENTAL) {

- if attrs.contains(AttrFlags::HAS_REPR) {

- flags |= StructFlags::HAS_REPR;

- }

- let attrs = AttrFlags::query(db, id.into());

- if attrs.contains(AttrFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS) {

- pub fn variant_body_type(db: &dyn DefDatabase, id: EnumId) -> IntegerType {

- match AttrFlags::repr(db, id.into()) {

- let attrs = AttrFlags::query(db, id.into());

- if attrs.contains(AttrFlags::RUSTC_ALLOW_INCOHERENT_IMPL) {

- let attrs = AttrFlags::query(db, id.into());

- if attrs.contains(AttrFlags::RUSTC_ALLOW_INCOHERENT_IMPL) {

- let attrs = AttrFlags::query(db, id.into());

- if attrs.contains(AttrFlags::FUNDAMENTAL) {

- if attrs.contains(AttrFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS) {

- if attrs.contains(AttrFlags::RUSTC_PAREN_SUGAR) {

- if attrs.contains(AttrFlags::RUSTC_COINDUCTIVE) {

- if attrs.contains(AttrFlags::RUSTC_SKIP_ARRAY_DURING_METHOD_DISPATCH) {

- if attrs.contains(AttrFlags::RUSTC_SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH) {

- const HAS_LEGACY_CONST_GENERICS = 1 << 12;

- const RUSTC_INTRINSIC = 1 << 13;

- let attrs = AttrFlags::query(db, id.into());

- if attrs.contains(AttrFlags::RUSTC_ALLOW_INCOHERENT_IMPL) {

- if attrs.contains(AttrFlags::HAS_TARGET_FEATURE) {

-

- if attrs.contains(AttrFlags::RUSTC_INTRINSIC) {

- if attrs.contains(AttrFlags::HAS_LEGACY_CONST_GENERICS) {

- flags.insert(FnFlags::HAS_LEGACY_CONST_GENERICS);

- }

- if attrs.contains(AttrFlags::RUSTC_DEPRECATED_SAFE_2024) {

- #[inline]

- pub fn legacy_const_generics_indices<'db>(

- &self,

- db: &'db dyn DefDatabase,

- id: FunctionId,

- ) -> Option<&'db [u32]> {

- if !self.flags.contains(FnFlags::HAS_LEGACY_CONST_GENERICS) {

- return None;

- }

-

- AttrFlags::legacy_const_generic_indices(db, id).as_deref()

- }

-

- let attrs = AttrFlags::query(db, id.into());

- if attrs.contains(AttrFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS) {

- if attrs.contains(AttrFlags::RUSTC_ALLOW_INCOHERENT_IMPL) {

- match AttrFlags::is_cfg_enabled_for(&field, cfg_options) {

- match AttrFlags::is_cfg_enabled_for(&variant, cfg_options) {

- UseId, VariantId, attrs::AttrFlags, db::DefDatabase,

- let enabled = AttrFlags::is_cfg_enabled_for(&fd, cfg_options).is_ok();

- let enabled = AttrFlags::is_cfg_enabled_for(&fd, cfg_options).is_ok();

- // We're not comparing the `base_db::EditionedFileId`, but rather the VFS `FileId`, because

- // `position.file_id` is created before the def map, causing it to have to wrong crate

- // attached often, which means it won't compare equal. This should not be a problem in real

- // r-a session, only in tests, because in real r-a we only guess the crate on syntactic-only

- // (e.g. on-enter) handlers. The rest pick the `EditionedFileId` from the def map.

- let Some(file_id) = src.file_id.file_id() else {

- continue;

- };

- if file_id.file_id(self) != position.file_id.file_id(self) {

- // We're not comparing the `base_db::EditionedFileId`, but rather the VFS `FileId`, because

- // `position.file_id` is created before the def map, causing it to have to wrong crate

- // attached often, which means it won't compare equal. This should not be a problem in real

- // r-a session, only in tests, because in real r-a we only guess the crate on syntactic-only

- // (e.g. on-enter) handlers. The rest pick the `EditionedFileId` from the def map.

- let Some(file_id) = file_id.file_id() else {

- continue;

- };

- if file_id.file_id(self) != position.file_id.file_id(self) {

- fn_def = Some((it, file_id));

- let (def_with_body, file_id) = fn_def?;

- let def_with_body = def_with_body.into();

- let root_syntax_node = self.parse(file_id).syntax_node();

- let expr_id =

- source_map.node_expr(InFile::new(file_id.into(), &expr))?.as_expr().unwrap();

-arrayvec.workspace = true

-thin-vec.workspace = true

-//! Defines the basics of attributes lowering.

-//!

-//! The heart and soul of this module is [`expand_cfg_attr()`], alongside its sibling

-//! [`expand_cfg_attr_with_doc_comments()`]. It is used to implement all attribute lowering

-//! in r-a. Its basic job is to list attributes; however, attributes do not necessarily map

-//! into [`ast::Attr`], because `cfg_attr` can map to zero, one, or more attributes

-//! (`#[cfg_attr(predicate, attr1, attr2, ...)]`). To bridge this gap, this module defines

-//! [`Meta`], which represents a desugared attribute. Various bits of r-a need different

-//! things from [`Meta`], therefore it contains many parts. The basic idea is:

-//!

-//! - There are three kinds of attributes, `path = value`, `path`, and `path(token_tree)`.

-//! - Most bits of rust-analyzer only need to deal with some paths. Therefore, we keep

-//! the path only if it has up to 2 segments, or one segment for `path = value`.

-//! We also only keep the value in `path = value` if it is a literal. However, we always

-//! save the all relevant ranges of attributes (the path range, and the full attribute range)

-//! for parts of r-a (e.g. name resolution) that need a faithful representation of the

-//! attribute.

-//!

-//! [`expand_cfg_attr()`] expands `cfg_attr`s as it goes (as its name implies), to list

-//! all attributes.

-//!

-//! Another thing to note is that we need to be able to map an attribute back to a range

-//! (for diagnostic purposes etc.). This is only ever needed for attributes that participate

-//! in name resolution. An attribute is mapped back by its [`AttrId`], which is just an

-//! index into the item tree attributes list. To minimize the risk of bugs, we have one

-//! place (here) and one function ([`is_item_tree_filtered_attr()`]) that decides whether

-//! an attribute participate in name resolution.

-

-use std::{

- borrow::Cow, cell::OnceCell, convert::Infallible, fmt, iter::Peekable, ops::ControlFlow,

-};

-use ::tt::{TextRange, TextSize};

-use arrayvec::ArrayVec;

-use intern::{Interned, Symbol};

-use parser::T;

-use smallvec::SmallVec;

-use span::{RealSpanMap, Span, SyntaxContext};

-use syntax::{

- AstNode, NodeOrToken, SyntaxNode, SyntaxToken,

- ast::{self, TokenTreeChildren},

- unescape,

-};

-use syntax_bridge::DocCommentDesugarMode;

- AstId,

- tt::{self, TopSubtree},

-#[derive(Debug)]

-pub struct AttrPath {

- /// This can be empty if the path is not of 1 or 2 segments exactly.

- pub segments: ArrayVec<SyntaxToken, 2>,

- pub range: TextRange,

- // FIXME: This shouldn't be textual, `#[test]` needs name resolution.

- // And if textual, it shouldn't be here, it should be in hir-def/src/attrs.rs. But some macros

- // fully qualify `test` as `core::prelude::vX::test`, and this is more than 2 segments, so hir-def

- // attrs can't find it. But this will mean we have to push every up-to-4-segments path, which

- // may impact perf. So it was easier to just hack it here.

- pub is_test: bool,

-impl AttrPath {

- #[inline]

- fn extract(path: &ast::Path) -> Self {

- let mut is_test = false;

- let segments = (|| {

- let mut segments = ArrayVec::new();

- let segment2 = path.segment()?.name_ref()?.syntax().first_token()?;

- if segment2.text() == "test" {

- // `#[test]` or `#[core::prelude::vX::test]`.

- is_test = true;

- }

- let segment1 = path.qualifier();

- if let Some(segment1) = segment1 {

- if segment1.qualifier().is_some() {

- None

- } else {

- let segment1 = segment1.segment()?.name_ref()?.syntax().first_token()?;

- segments.push(segment1);

- segments.push(segment2);

- Some(segments)

- }

- } else {

- segments.push(segment2);

- Some(segments)

- }

- })();

- AttrPath {

- segments: segments.unwrap_or(ArrayVec::new()),

- range: path.syntax().text_range(),

- is_test,

- #[inline]

- pub fn is1(&self, segment: &str) -> bool {

- self.segments.len() == 1 && self.segments[0].text() == segment

-}

-#[derive(Debug)]

-pub enum Meta {

- /// `name` is `None` if not a single token. `value` is a literal or `None`.

- NamedKeyValue {

- path_range: TextRange,

- name: Option<SyntaxToken>,

- value: Option<SyntaxToken>,

- },

- TokenTree {

- path: AttrPath,

- tt: ast::TokenTree,

- },

- Path {

- path: AttrPath,

- },

-}

-impl Meta {

- #[inline]

- pub fn path_range(&self) -> TextRange {

- match self {

- Meta::NamedKeyValue { path_range, .. } => *path_range,

- Meta::TokenTree { path, .. } | Meta::Path { path } => path.range,

- }

- fn extract(iter: &mut Peekable<TokenTreeChildren>) -> Option<(Self, TextSize)> {

- let mut start_offset = None;

- if let Some(NodeOrToken::Token(colon1)) = iter.peek()

- && colon1.kind() == T![:]

- {

- start_offset = Some(colon1.text_range().start());

- iter.next();

- iter.next_if(|it| it.as_token().is_some_and(|it| it.kind() == T![:]));

- let first_segment = iter

- .next_if(|it| it.as_token().is_some_and(|it| it.kind().is_any_identifier()))?

- .into_token()?;

- let mut is_test = first_segment.text() == "test";

- let start_offset = start_offset.unwrap_or_else(|| first_segment.text_range().start());

-

- let mut segments_len = 1;

- let mut second_segment = None;

- let mut path_range = first_segment.text_range();

- while iter.peek().and_then(NodeOrToken::as_token).is_some_and(|it| it.kind() == T![:])

- && let _ = iter.next()

- && iter.peek().and_then(NodeOrToken::as_token).is_some_and(|it| it.kind() == T![:])

- && let _ = iter.next()

- && let Some(NodeOrToken::Token(segment)) = iter.peek()

- && segment.kind().is_any_identifier()

- {

- segments_len += 1;

- is_test = segment.text() == "test";

- second_segment = Some(segment.clone());

- path_range = TextRange::new(path_range.start(), segment.text_range().end());

- iter.next();

- let segments = |first, second| {

- let mut segments = ArrayVec::new();

- if segments_len <= 2 {

- segments.push(first);

- if let Some(second) = second {

- segments.push(second);

- }

- }

- segments

- };

- let meta = match iter.peek() {

- Some(NodeOrToken::Token(eq)) if eq.kind() == T![=] => {

- iter.next();

- let value = match iter.peek() {

- Some(NodeOrToken::Token(token)) if token.kind().is_literal() => {

- // No need to consume it, it will be consumed by `extract_and_eat_comma()`.

- Some(token.clone())

- }

- _ => None,

- };

- let name = if second_segment.is_none() { Some(first_segment) } else { None };

- Meta::NamedKeyValue { path_range, name, value }

- }

- Some(NodeOrToken::Node(tt)) => Meta::TokenTree {

- path: AttrPath {

- segments: segments(first_segment, second_segment),

- range: path_range,

- is_test,

- },

- tt: tt.clone(),

- },

- _ => Meta::Path {

- path: AttrPath {

- segments: segments(first_segment, second_segment),

- range: path_range,

- is_test,

- },

- },

- Some((meta, start_offset))

- fn extract_possibly_unsafe(

- iter: &mut Peekable<TokenTreeChildren>,

- container: &ast::TokenTree,

- ) -> Option<(Self, TextRange)> {

- if iter.peek().is_some_and(|it| it.as_token().is_some_and(|it| it.kind() == T![unsafe])) {

- iter.next();

- let tt = iter.next()?.into_node()?;

- let result = Self::extract(&mut TokenTreeChildren::new(&tt).peekable()).map(

- |(meta, start_offset)| (meta, TextRange::new(start_offset, tt_end_offset(&tt))),

- );

- while iter.next().is_some_and(|it| it.as_token().is_none_or(|it| it.kind() != T![,])) {}

- result

- } else {

- Self::extract(iter).map(|(meta, start_offset)| {

- let end_offset = 'find_end_offset: {

- for it in iter {

- if let NodeOrToken::Token(it) = it

- && it.kind() == T![,]

- {

- break 'find_end_offset it.text_range().start();

- }

- }

- tt_end_offset(container)

- };

- (meta, TextRange::new(start_offset, end_offset))

- })

- }

-fn tt_end_offset(tt: &ast::TokenTree) -> TextSize {

- tt.syntax().last_token().unwrap().text_range().start()

-/// The callback is passed a desugared form of the attribute ([`Meta`]), a [`SyntaxNode`] fully containing it

-/// (note: it may not be the direct parent), the range within the [`SyntaxNode`] bounding the attribute,

-/// and the outermost `ast::Attr`. Note that one node may map to multiple [`Meta`]s due to `cfg_attr`.

-#[inline]

-pub fn expand_cfg_attr<'a, BreakValue>(

- attrs: impl Iterator<Item = ast::Attr>,

- cfg_options: impl FnMut() -> &'a CfgOptions,

- mut callback: impl FnMut(Meta, &SyntaxNode, TextRange, &ast::Attr) -> ControlFlow<BreakValue>,