+use std::{cell::RefCell, fmt};

+use smallvec::{smallvec, SmallVec};

+ // FIXME: Rename to descend_into_macros_single

+ self.imp.descend_into_macros(token).pop().unwrap()

+ }

+

+ // FIXME: Rename to descend_into_macros

+ pub fn descend_into_macros_many(&self, token: SyntaxToken) -> SmallVec<[SyntaxToken; 1]> {

+ self.imp.descend_node_at_offset(node, offset).flatten().find_map(N::cast)

+ self.imp.descend_node_at_offset(node, offset).flatten().find_map(N::cast)

+ }

+

+ /// Find an AstNode by offset inside SyntaxNode, if it is inside *MacroCall*,

+ /// descend it and find again

+ pub fn find_nodes_at_offset_with_descend<'slf, N: AstNode + 'slf>(

+ &'slf self,

+ node: &SyntaxNode,

+ offset: TextSize,

+ ) -> impl Iterator<Item = N> + 'slf {

+ self.imp.descend_node_at_offset(node, offset).filter_map(|mut it| it.find_map(N::cast))

+ fn descend_into_macros(&self, token: SyntaxToken) -> SmallVec<[SyntaxToken; 1]> {

+ None => return smallvec![token],

+ let mut queue = vec![InFile::new(sa.file_id, token)];

+ let mut cache = self.expansion_info_cache.borrow_mut();

+ let mut res = smallvec![];

+ while let Some(token) = queue.pop() {

+ let was_not_remapped = (|| {

+ for node in token.value.ancestors() {

+ match_ast! {

+ match node {

+ ast::MacroCall(macro_call) => {

+ let tt = macro_call.token_tree()?;

+ let l_delim = match tt.left_delimiter_token() {

+ Some(it) => it.text_range().end(),

+ None => tt.syntax().text_range().start()

+ };

+ let r_delim = match tt.right_delimiter_token() {

+ Some(it) => it.text_range().start(),

+ None => tt.syntax().text_range().end()

+ };

+ if !TextRange::new(l_delim, r_delim).contains_range(token.value.text_range()) {

+ return None;

+ }

+ let file_id = sa.expand(self.db, token.with_value(&macro_call))?;

+ let tokens = cache

+ .map_token_down(self.db.upcast(), None, token.as_ref())?;

+

+ let len = queue.len();

+ queue.extend(tokens.inspect(|token| {

+ if let Some(parent) = token.value.parent() {

+ self.cache(find_root(&parent), token.file_id);

+ }

+ }));

+ return (queue.len() != len).then(|| ());

+ },

+ ast::Item(item) => {

+ if let Some(call_id) = self.with_ctx(|ctx| ctx.item_to_macro_call(token.with_value(item.clone()))) {

+ let file_id = call_id.as_file();

+ let tokens = cache

+ .entry(file_id)

+ .or_insert_with(|| file_id.expansion_info(self.db.upcast()))

+ .as_ref()?

+ .map_token_down(self.db.upcast(), Some(item), token.as_ref())?;

+

+ let len = queue.len();

+ queue.extend(tokens.inspect(|token| {

+ if let Some(parent) = token.value.parent() {

+ self.cache(find_root(&parent), token.file_id);

+ }

+ }));

+ return (queue.len() != len).then(|| ());

+ },

+ _ => {}

+ }

+ None

+ })().is_none();

+ if was_not_remapped {

+ res.push(token.value)

+ }

+ res

+ // Note this return type is deliberate as [`find_nodes_at_offset_with_descend`] wants to stop

+ // traversing the inner iterator when it finds a node.

+ ) -> impl Iterator<Item = impl Iterator<Item = SyntaxNode> + '_> + '_ {

+ .map(move |token| self.descend_into_macros(token))

+ .map(|it| it.into_iter().map(move |it| self.token_ancestors_with_macros(it)))

+ let range = tmap_2.first_range_by_token(token_id, token_to_map.kind())?;

+ let range = token_map.first_range_by_token(token_id, SyntaxKind::IDENT)?;

+ ) -> Option<impl Iterator<Item = InFile<SyntaxToken>> + '_> {

+ let tokens = self

+ .exp_map

+ .ranges_by_token(token_id, token.value.kind())

+ .flat_map(move |range| self.expanded.value.covering_element(range).into_token());

+ Some(tokens.map(move |token| self.expanded.with_value(token)))

+ let range = token_map.first_range_by_token(token_id, token.value.kind())?;

+use rustc_hash::FxHashSet;

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

+ let defs = find_defs(sema, syntax, offset);

+ let res: FxHashSet<_> = declarations.chain(usages).collect();

+ if res.is_empty() {

+ None

+ } else {

+ Some(res.into_iter().collect())

+ }

+) -> FxHashSet<Definition> {

+ sema.find_nodes_at_offset_with_descend(syntax, offset)

+ .flat_map(|name_like| {

+ Some(match name_like {

+ ast::NameLike::NameRef(name_ref) => {

+ match NameRefClass::classify(sema, &name_ref)? {

+ NameRefClass::Definition(def) => vec![def],

+ NameRefClass::FieldShorthand { local_ref, field_ref } => {

+ vec![Definition::Local(local_ref), Definition::Field(field_ref)]

+ }

+ }

+ }

+ ast::NameLike::Name(name) => match NameClass::classify(sema, &name)? {

+ NameClass::Definition(it) | NameClass::ConstReference(it) => vec![it],

+ NameClass::PatFieldShorthand { local_def, field_ref } => {

+ vec![Definition::Local(local_def), Definition::Field(field_ref)]

+ }

+ },

+ ast::NameLike::Lifetime(lifetime) => {

+ NameRefClass::classify_lifetime(sema, &lifetime)

+ .and_then(|class| match class {

+ NameRefClass::Definition(it) => Some(it),

+ _ => None,

+ })

+ .or_else(|| {

+ NameClass::classify_lifetime(sema, &lifetime)

+ .and_then(NameClass::defined)

+ })

+ .map(|it| vec![it])?

+ }

+ })

+ .flatten()

+ .collect()

+ fn test_multi_macro_usage() {

+ check(

+ r#"

+macro_rules! foo {

+ ($ident:ident) => {

+ fn $ident() -> $ident { loop {} }

+ struct $ident;

+ }

+}

+

+foo!(bar$0);

+ // ^^^

+fn foo() {

+ let bar: bar = bar();

+ // ^^^

+ // ^^^

+}

+"#,

+ );

+ check(

+ r#"

+macro_rules! foo {

+ ($ident:ident) => {

+ fn $ident() -> $ident { loop {} }

+ struct $ident;

+ }

+}

+

+foo!(bar);

+ // ^^^

+fn foo() {

+ let bar: bar$0 = bar();

+ // ^^^

+}

+"#,

+ );

+ }

+

+ #[test]

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

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

+ for name in sema.find_nodes_at_offset_with_descend(&tree, offset) {

+ for name_ref in sema.find_nodes_at_offset_with_descend(&tree, offset) {

+ let get_text = |id, kind| -> String {

+ content[token_map.first_range_by_token(id, kind).unwrap()].to_string()

+ };

+ pub fn ranges_by_token(

+ &self,

+ token_id: tt::TokenId,

+ kind: SyntaxKind,

+ ) -> impl Iterator<Item = TextRange> + '_ {

+ self.entries

+ .iter()

+ .filter(move |&&(tid, _)| tid == token_id)

+ .filter_map(move |(_, range)| range.by_kind(kind))

+ }

+

+ pub fn first_range_by_token(

+ &self,

+ token_id: tt::TokenId,

+ kind: SyntaxKind,

+ ) -> Option<TextRange> {

+ self.ranges_by_token(token_id, kind).next()