- - run: rm dist/rust-analyzer-no-server.vsix

-

- "span",

- "arrayvec",

-version = "0.4.7"

-checksum = "5396562cd2eaa828445d6d34258ae21ee1eb9d40fe626ca7f51c8dccb4af9d66"

-version = "1.0.1"

-checksum = "ce9bedf5da2c234fdf2391ede2b90fabf585355f33100689bc364a3ea558561a"

-version = "0.15.17"

-checksum = "d4f1e4a001f863f41ea8d0e6a0c34b356d5b733db50dadab3efef640bafb779b"

-rowan = "=0.15.17"

- CrateGraphBuilder, CratesIdMap, LibraryRoots, LocalRoots, RootQueryDb, SourceRoot, SourceRootId,

- pub fn apply(self, db: &mut dyn RootQueryDb) -> Option<CratesIdMap> {

-use crate::{CrateWorkspaceData, EditionedFileId, FxIndexSet, RootQueryDb};

- pub fn transitive_rev_deps(self, db: &dyn RootQueryDb) -> Box<[Crate]> {

- db.all_crates().iter().for_each(|&krate| {

- pub fn set_in_db(self, db: &mut dyn RootQueryDb) -> CratesIdMap {

- let old_all_crates = db.all_crates();

-

- db.set_all_crates_with_durability(

- Arc::new(Vec::from_iter(all_crates).into_boxed_slice()),

- Durability::MEDIUM,

- );

- db: &mut dyn RootQueryDb,

-use syntax::{Parse, SyntaxError, ast};

-/// Database which stores all significant input facts: source code and project

-/// model. Everything else in rust-analyzer is derived from these queries.

-#[query_group::query_group]

-pub trait RootQueryDb: SourceDatabase + salsa::Database {

- /// Parses the file into the syntax tree.

- #[salsa::invoke(parse)]

- #[salsa::lru(128)]

- fn parse(&self, file_id: EditionedFileId) -> Parse<ast::SourceFile>;

-

- /// Returns the set of errors obtained from parsing the file including validation errors.

- #[salsa::transparent]

- fn parse_errors(&self, file_id: EditionedFileId) -> Option<&[SyntaxError]>;

-

- #[salsa::transparent]

- fn toolchain_channel(&self, krate: Crate) -> Option<ReleaseChannel>;

-

- /// Crates whose root file is in `id`.

- #[salsa::invoke_interned(source_root_crates)]

- fn source_root_crates(&self, id: SourceRootId) -> Arc<[Crate]>;

-

- #[salsa::transparent]

- fn relevant_crates(&self, file_id: FileId) -> Arc<[Crate]>;

-

- /// Returns the crates in topological order.

- ///

- /// **Warning**: do not use this query in `hir-*` crates! It kills incrementality across crate metadata modifications.

- #[salsa::input]

- fn all_crates(&self) -> Arc<Box<[Crate]>>;

-}

-

-fn toolchain_channel(db: &dyn RootQueryDb, krate: Crate) -> Option<ReleaseChannel> {

-fn parse(db: &dyn RootQueryDb, file_id: EditionedFileId) -> Parse<ast::SourceFile> {

- let _p = tracing::info_span!("parse", ?file_id).entered();

- let (file_id, edition) = file_id.unpack(db.as_dyn_database());

- let text = db.file_text(file_id).text(db);

- ast::SourceFile::parse(text, edition)

-fn parse_errors(db: &dyn RootQueryDb, file_id: EditionedFileId) -> Option<&[SyntaxError]> {

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

- fn parse_errors(db: &dyn RootQueryDb, file_id: EditionedFileId) -> Option<Box<[SyntaxError]>> {

- let errors = db.parse(file_id).errors();

- match &*errors {

- [] => None,

- [..] => Some(errors.into()),

- }

- }

- parse_errors(db, file_id).as_ref().map(|it| &**it)

-fn source_root_crates(db: &dyn RootQueryDb, id: SourceRootId) -> Arc<[Crate]> {

- let crates = db.all_crates();

- crates

- .iter()

- .copied()

- .filter(|&krate| {

- let root_file = krate.data(db).root_file_id;

- db.file_source_root(root_file).source_root_id(db) == id

- })

- .collect()

-fn relevant_crates(db: &dyn RootQueryDb, file_id: FileId) -> Arc<[Crate]> {

- db.source_root_crates(source_root.source_root_id(db))

-span = { path = "../span", version = "0.0", optional = true }

-syntax = ["dep:syntax", "dep:span"]

- 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 dummy_span = span::Span {

- range: span::TextRange::empty(span::TextSize::new(0)),

- anchor: span::SpanAnchor {

- file_id: span::EditionedFileId::from_raw(0),

- ast_id: span::FIXUP_ERASED_FILE_AST_ID_MARKER,

- },

- ctx: span::SyntaxContext::root(span::Edition::Edition2015),

- };

- let literal =

- Symbol::intern(tt::token_to_literal(literal.text(), dummy_span).text());

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

-};

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

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

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

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

- tt_ast.syntax(),

- let cfg = parse_ast_cfg(&tt_ast);

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

- tt_ast.syntax(),

- let cfg = parse_ast_cfg(&tt_ast);

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

- tt_ast.syntax(),

- let cfg = parse_ast_cfg(&tt_ast);

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

- tt_ast.syntax(),

- let cfg = parse_ast_cfg(&tt_ast);

-

- assert_parse_result(

- r#"#![cfg(any(not(), all(), , bar = "baz",))]"#,

- CfgExpr::Any(

- vec![

- CfgExpr::Not(Box::new(CfgExpr::Invalid)),

- CfgExpr::All(Box::new([])),

- CfgExpr::Invalid,

- CfgAtom::KeyValue { key: Symbol::intern("bar"), value: Symbol::intern("baz") }

- .into(),

- ]

- .into_boxed_slice(),

- ),

- );

-//! 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},

-};

- HirFileId, InFile, Lookup,

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

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

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

-use tt::{TextRange, TextSize};

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

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

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

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

- "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() {

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

- }

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

- }

- "rustc_deprecated_safe_2024" => {

- attr_flags.insert(AttrFlags::RUSTC_DEPRECATED_SAFE_2024)

- },

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

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

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

- "macro_style" => extract_ra_macro_style(attr_flags, tt),

- _ => {}

- },

- _ => {}

- },

- Meta::Path { path } => {

- match path.segments.len() {

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

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

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

- _ => {}

- }

-

- if path.is_test {

- attr_flags.insert(AttrFlags::IS_TEST);

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

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

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

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

-#[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();

- }

-}

-

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

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

- && path.is1("doc")

-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()));

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

-}

-

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

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

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

- |attr, _, _, _| {

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

- && path.is1("cfg")

- && let cfg =

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

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

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

- && path.is1("repr")

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

- && path.is1("rustc_legacy_const_generics")

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

- |attr, _, _, _| {

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

- && path.is1("doc")

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

- && path.is1("target_feature")

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

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

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

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

- && path.is1("doc")

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

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

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

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

- && matches!(

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

- "proc_macro_derive" | "rustc_builtin_macro"

- )

- use expect_test::expect;

- use hir_expand::InFile;

- use tt::{TextRange, TextSize};

- use crate::attrs::{AttrFlags, Docs, IsInnerDoc};

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

- );

- }

-

- #[test]

-use base_db::{Crate, RootQueryDb, SourceDatabase};

-pub trait InternDatabase: RootQueryDb {

- ast::Attr,

- /// Like [`Self::signature_const_expr_roots`], but also returns the origin

- let elements = e.map(|expr| self.collect_expr(expr)).collect();

- use base_db::RootQueryDb;

- let file_syntax = db.parse(editioned_file_id).syntax_node();

- let file = db.parse(editioned_file_id).ok().unwrap();

- [salsa id]: Id(3803),

- Id(2400),

- 4801,

- use base_db::RootQueryDb;

- let all_crates = db.all_crates();

- let all_crates = db.all_crates();

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

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

- 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(path_range);

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

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

- value.text(),

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

- )))

- });

- (span, path_range, input)

- }

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

- let span = span_map.span_for(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(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).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(())

-struct#0:MacroRules[BE8F, 0]@58..64#18432# MyTraitMap2#0:MacroCall[BE8F, 0]@31..42#ROOT2024# {#0:MacroRules[BE8F, 0]@72..73#18432#

- map#0:MacroRules[BE8F, 0]@86..89#18432#:#0:MacroRules[BE8F, 0]@89..90#18432# #0:MacroRules[BE8F, 0]@89..90#18432#::#0:MacroRules[BE8F, 0]@91..93#18432#std#0:MacroRules[BE8F, 0]@93..96#18432#::#0:MacroRules[BE8F, 0]@96..98#18432#collections#0:MacroRules[BE8F, 0]@98..109#18432#::#0:MacroRules[BE8F, 0]@109..111#18432#HashSet#0:MacroRules[BE8F, 0]@111..118#18432#<#0:MacroRules[BE8F, 0]@118..119#18432#(#0:MacroRules[BE8F, 0]@119..120#18432#)#0:MacroRules[BE8F, 0]@120..121#18432#>#0:MacroRules[BE8F, 0]@121..122#18432#,#0:MacroRules[BE8F, 0]@122..123#18432#

-}#0:MacroRules[BE8F, 0]@132..133#18432#

-struct#1:MacroRules[DB0C, 0]@59..65#18432# Foo#0:MacroCall[DB0C, 0]@32..35#ROOT2024#(#1:MacroRules[DB0C, 0]@70..71#18432#u32#0:MacroCall[DB0C, 0]@41..44#ROOT2024#)#1:MacroRules[DB0C, 0]@74..75#18432#;#1:MacroRules[DB0C, 0]@75..76#18432#

-impl#\18432# Bar#\18432# {#\18432#

- fn#\18432# foo#\ROOT2024#(#\18432#)#\18432# {#\18432#}#\18432#

- fn#\18432# bar#\ROOT2024#(#\18432#)#\18432# {#\18432#}#\18432#

-}#\18432#

-#[cfg(target_os = "windows")] fn bar() {}

-#[cfg(feature = "impl-default")] impl Default for D3DVSHADERCAPS2_0 {

-#[cfg_attr(target_arch = "x86", repr(packed))] pub struct D3DCONTENTPROTECTIONCAPS {

-#[cfg(feature = "impl-default")] impl Default for D3DCONTENTPROTECTIONCAPS {

-#[cfg(feature = "std")] mod m;

-#[cfg(feature = "std")] mod f;

-use base_db::RootQueryDb;

- let ast = db.parse(editioned_file_id).syntax_node();

- #[cfg_attr(true , cfg(false ))] fn foo() {}

- #[cfg(true )] fn bar() {}

- let sf = db.parse(editioned_file_id).tree();

-use span::{Edition, FileAstId, SyntaxContext};

- if matches!(item_tree.top_level_attrs(), AttrsOrCfg::CfgDisabled(_)) {

-use base_db::RootQueryDb;

- DependencyBuilder, Env, RootQueryDb, SourceDatabase,

- for &krate in db.all_crates().iter() {

- let all_crates_before = db.all_crates();

- let all_crates_after = db.all_crates();

- Arc::ptr_eq(&all_crates_before, &all_crates_after),

- for &krate in db.all_crates().iter() {

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- "parse_shim",

- let krate = *db.all_crates().last().expect("no crate graph present");

- let krate = *db.all_crates().last().expect("no crate graph present");

- Crate, CrateGraphBuilder, CratesMap, FileSourceRootInput, FileText, Nonce, RootQueryDb,

- SourceDatabase, SourceRoot, SourceRootId, SourceRootInput,

- this.set_all_crates(Arc::new(Box::new([])));

- let all_crates = self.all_crates();

- for &krate in self.relevant_crates(file_id).iter() {

- let root_syntax_node = self.parse(file_id).syntax_node();

-arrayvec.workspace = true

-//! (`#[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.

-use std::{

- borrow::Cow, cell::OnceCell, convert::Infallible, fmt, iter::Peekable, ops::ControlFlow,

-};

-use ::tt::{TextRange, TextSize};

-use arrayvec::ArrayVec;

-use parser::T;

-use syntax::{

- AstNode, NodeOrToken, SyntaxNode, SyntaxToken,

- ast::{self, TokenTreeChildren},

- unescape,

-};

-#[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

- 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`.

- mut callback: impl FnMut(Meta, &SyntaxNode, TextRange, &ast::Attr) -> ControlFlow<BreakValue>,

- move |Either::Left((meta, container, range, top_attr))| {

- callback(meta, container, range, top_attr)

- },

- mut callback: impl FnMut(

- Either<(Meta, &SyntaxNode, TextRange, &ast::Attr), DocComment>,

- ) -> ControlFlow<BreakValue>,

- let result = attrs.try_for_each(|top_attr| {

- let top_attr = match top_attr {

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

- Either::Right(comment) => return callback(Either::Right(comment)),

- };

- if let Some((attr_name, tt)) = top_attr.as_simple_call()

- && attr_name == "cfg_attr"

- {

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

- let cfg = cfg::CfgExpr::parse_from_ast(&mut tt_iter);

- if cfg_options().check(&cfg) != Some(false) {

- stack.push((tt_iter, tt));

- while let Some((tt_iter, tt)) = stack.last_mut() {

- let Some((attr, range)) = Meta::extract_possibly_unsafe(tt_iter, tt) else {

- stack.pop();

- continue;

- };

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

- && path.is1("cfg_attr")

- {

- let mut nested_tt_iter = TokenTreeChildren::new(nested_tt).peekable();

- let cfg = cfg::CfgExpr::parse_from_ast(&mut nested_tt_iter);

- if cfg_options().check(&cfg) != Some(false) {

- stack.push((nested_tt_iter, nested_tt.clone()));

- }

- } else {

- callback(Either::Left((attr, tt.syntax(), range, &top_attr)))?;

- } else if let Some(ast_meta) = top_attr.meta()

- && let Some(path) = ast_meta.path()

- {

- let path = AttrPath::extract(&path);

- let meta = if let Some(tt) = ast_meta.token_tree() {

- Meta::TokenTree { path, tt }

- } else if let Some(value) = ast_meta.expr() {

- let value =

- if let ast::Expr::Literal(value) = value { Some(value.token()) } else { None };

- let name =

- if path.segments.len() == 1 { Some(path.segments[0].clone()) } else { None };

- Meta::NamedKeyValue { name, value, path_range: path.range }

- } else {

- Meta::Path { path }

- };

- callback(Either::Left((

- meta,

- ast_meta.syntax(),

- ast_meta.syntax().text_range(),

- &top_attr,

- )))?;

- ControlFlow::Continue(())

- });

- result.break_value()

- mut on_attr: impl FnMut(Meta, &SyntaxNode, &ast::Attr, TextRange) -> ControlFlow<BreakValue>,

- |attr, container, range, top_attr| {

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

- is_item_tree_filtered_attr(name.text())

- }

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

- let name = path.segments[0].text();

- if name == "cfg" {

- let cfg =

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

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

- return ControlFlow::Break(Either::Right(cfg));

- }

- true

- } else {

- is_item_tree_filtered_attr(name)

- Meta::Path { path } => {

- path.segments.len() == 1 && is_item_tree_filtered_attr(path.segments[0].text())

- }

- _ => false,

- if !filter && let ControlFlow::Break(v) = on_attr(attr, container, top_attr, range) {

- /// to `cfg_attr`), a `SyntaxNode` guaranteed to contain the attribute, the full range of the

- /// attribute, and its desugared [`Meta`].

- ) -> (ast::Attr, SyntaxNode, TextRange, Meta) {

- /// to `cfg_attr`), a `SyntaxNode` guaranteed to contain the attribute, the full range of the

- /// attribute, and its desugared [`Meta`].

- ) -> (ast::Attr, SyntaxNode, TextRange, Meta) {

- |meta, container, top_attr, range| {

- return ControlFlow::Break((top_attr.clone(), container.clone(), range, meta));

- let (_, _, derive_attr_range, derive_attr) = self.find_attr_range(db, krate, owner);

- let Meta::TokenTree { tt, .. } = derive_attr else {

- return derive_attr_range;

- return derive_attr_range;

- return derive_attr_range;

- &db.parse(editioned_file_id).syntax_node(),

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

- attrs::{AttrId, Meta, expand_cfg_attr, is_item_tree_filtered_attr},

- range: TextRange,

- let strip_current_item = expand_cfg_attr(

- node_attrs,

- &cfg_options,

- |attr, _container, range, top_attr| {

- match attr {

- Meta::NamedKeyValue { name, .. } => {

- if name

- .is_none_or(|name| !is_item_tree_filtered_attr(name.text()))

- {

- strip_current_attr = should_strip_attr();

- }

- }

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

- if path.is1("cfg") {

- let cfg_expr = CfgExpr::parse_from_ast(

- &mut TokenTreeChildren::new(&tt).peekable(),

- );

- } else if path.segments.len() != 1

- || !is_item_tree_filtered_attr(path.segments[0].text())

- {

- strip_current_attr = should_strip_attr();

- Meta::Path { path } => {

- if path.segments.len() != 1

- || !is_item_tree_filtered_attr(path.segments[0].text())

- .push(ExpandedAttrToProcess { range });

- },

- );

- if token_range.start() >= expanded_attr.range.start() {

- if token_range.start() >= expanded_attr.range.end() {

-

-pub fn check_cfg_attr_value(

- db: &dyn ExpandDatabase,

- attr: &ast::TokenTree,

- krate: Crate,

-) -> Option<bool> {

- let cfg_expr = CfgExpr::parse_from_ast(&mut TokenTreeChildren::new(attr).peekable());

- krate.cfg_options(db).check(&cfg_expr)

-}

-use base_db::{Crate, RootQueryDb};

- attrs::Meta,

-pub trait ExpandDatabase: RootQueryDb {

- ast::Attr::cast(speculative_args.clone()).and_then(|attr| attr.token_tree()).map(

- |token_tree| {

- },

- )

- let (_, _, _, meta) =

- match meta {

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

- let mut attr_arg = syntax_bridge::syntax_node_to_token_tree(

- tt.syntax(),

- span_map,

- span,

- DocCommentDesugarMode::ProcMacro,

- );

- attr_arg.set_top_subtree_delimiter_kind(tt::DelimiterKind::Invisible);

- Some(attr_arg)

- }

- _ => None,

- HirFileId::FileId(file_id) => db.parse(file_id).syntax_node(),

- (db.parse(file_id).to_syntax(), SpanMap::RealSpanMap(db.real_span_map(file_id)))

- let range = attr_ids

- .invoc_attr()

- .find_attr_range_with_source(db, loc.krate, &node)

- .3

- .path_range();

- AstNode, AstToken,

- attrs::{Meta, expand_cfg_attr},

- |attr, _, _, _| {

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

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

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

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

- db.parse(self).syntax_node()

- let value = db

- .parse(editioned_file_id)

- let anc = db.parse(editioned_file_id).syntax_node().covering_element(range);

- cfg_process::check_cfg_attr_value,

- // FIXME: handle `cfg_attr`

- let (attr, _, _, _) = derive_attr_index.find_attr_range(db, self.krate, *ast_id);

- let (attr, _, _, _) =

- attr_ids.invoc_attr().find_attr_range(db, self.krate, *ast_id);

- derive_attr_index.find_attr_range(db, krate, ast_id).2

- attr_ids.invoc_attr().find_attr_range(db, krate, ast_id).2

- let tree = db.parse(editioned_file_id).tree();

- Clauses::new_from_slice(adt_predicates.explicit_predicates().skip_binder())

- .store(),

- adt_predicates.explicit_predicates().iter_identity_copied().filter_map(|pred| {

- .iter_identity_copied()

- .iter_identity_copied()

- preds.iter().format_with("\n", |pred, formatter| formatter(&format_args!(

-use base_db::RootQueryDb;

- DisplayTarget::from_crate(db, *db.all_crates().last().expect("no crate graph present"));