use std::{

cell::RefCell,

fmt, iter, mem,

ops::{self, ControlFlow, Not},

};

Variant, VariantDef,

};

pub enum DescendPreference {

SameKind,

None,

}

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

pub enum PathResolution {

/// An item

)

}

pub fn as_format_args_parts(

&self,

string: &ast::String,

) -> Option<Vec<(TextRange, Option<PathResolution>)>> {

}

pub fn check_for_format_args_template(

&self,

original_token: SyntaxToken,

offset: TextSize,

) -> Option<(TextRange, Option<PathResolution>)> {

}

fn resolve_offset_in_format_args(

if first == last {

// node is just the token, so descend the token

if let Some(node) = value

.parent_ancestors()

.take_while(|it| it.text_range() == value.text_range())

{

res.push(node)

}

});

} else {

// Descend first and last token, then zip them to look for the node they belong to

let mut scratch: SmallVec<[_; 1]> = smallvec![];

scratch.push(token);

});

let mut scratch = scratch.into_iter();

self.descend_into_macros_impl(

last,

if let Some(InFile { value: first, file_id: first_fid }) = scratch.next() {

if first_fid == last_fid {

if let Some(p) = first.parent() {

}

}

}

},

);

}

mode: DescendPreference,

token: SyntaxToken,

) -> SmallVec<[SyntaxToken; 1]> {

SameKind(SyntaxKind),

None,

}

None => token.kind(),

};

let mode = match mode {

DescendPreference::SameKind => Dp::SameKind(fetch_kind(&token)),

DescendPreference::None => Dp::None,

};

let mut res = smallvec![];

// special case for derive macros

|| (preferred_kind == SyntaxKind::IDENT && kind == SyntaxKind::NAME_REF)

}

if res.is_empty() {

res.push(token);

}

res

}

&self,

token: SyntaxToken,

}

} else {

ControlFlow::Continue(())

}

}

&self,

token: SyntaxToken,

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

let (sa, span, file_id) =

let mut m_cache = self.macro_call_cache.borrow_mut();

let def_map = sa.resolver.def_map();

let InMacroFile { file_id, value: mapped_tokens } = self.with_ctx(|ctx| {

Some(

ctx.cache

// we have found a mapping for the token if the vec is non-empty

let res = mapped_tokens.is_empty().not().then_some(());

// requeue the tokens we got from mapping our current token down

res

};

while let Some(token) = tokens.pop() {

let was_not_remapped = (|| {

// First expand into attribute invocations

token.parent_ancestors().filter_map(ast::Item::cast).find_map(|item| {

// Don't force populate the dyn cache for items that don't have an attribute anyways

item.attrs().next()?;

})

});

if let Some((call_id, item)) = containing_attribute_macro_call {

})

.unwrap_or_else(|| text_range.start());

let text_range = TextRange::new(start, text_range.end());

}

// Then check for token trees, that means we are either in a function-like macro or

.map_while(Either::<ast::TokenTree, ast::Meta>::cast)

.last()?;

match tt {

Either::Left(tt) => {

if tt.left_delimiter_token().map_or(false, |it| it == token) {

return None;

return None;

}

let macro_call = tt.syntax().parent().and_then(ast::MacroCall::cast)?;

let file_id = match m_cache.get(&mcall) {

Some(&it) => it,

None => {

}

};

let text_range = tt.syntax().text_range();

.eager_arg(self.db.upcast())

.and_then(|arg| {

// also descend into eager expansions

}))

}

Either::Right(meta) => {

// attribute we failed expansion for earlier, this might be a derive invocation

// or derive helper attribute

// so try downmapping the token into the pseudo derive expansion

// see [hir_expand::builtin_attr_macro] for how the pseudo derive expansion works

ctx.attr_to_derive_macro_call(

)

.map(|(_, call_id, _)| call_id)

});

!text_range.contains_range(t.text_range())

});

return process_expansion_for_token(

);

}

None => Some(adt),

)

}

}?;

return None;

}

let attr_name =

attr.path().and_then(|it| it.as_single_name_ref())?.as_name();

// Try to resolve to a derive helper and downmap

let helpers =

if !helpers.is_empty() {

let text_range = attr.syntax().text_range();

}

let mut res = None;

for (.., derive) in

helpers.iter().filter(|(helper, ..)| *helper == attr_name)

{

res = res.or(process_expansion_for_token(

&mut stack,

derive.as_macro_file(),

));

}

res

})()

.is_none();

}

}

}

}

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