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

}

pub fn resolve_range_pat(&self, range_pat: &ast::RangePat) -> Option<Struct> {

self.imp.resolve_range_pat(range_pat).map(Struct::from)

}

}

pub fn is_derive_annotated(&self, adt: InFile<&ast::Adt>) -> bool {

}

pub fn derive_helpers_in_scope(&self, adt: &ast::Adt) -> Option<Vec<(Symbol, Symbol)>> {

/// Checks if renaming `renamed` to `new_name` may introduce conflicts with other locals,

/// and returns the conflicting locals.

let body = self.db.body(to_be_renamed.parent);

let resolver = to_be_renamed.parent.resolver(self.db);

let starting_expr =

body: &body,

conflicts: FxHashSet::default(),

db: self.db,

old_name: to_be_renamed.name(self.db).symbol().clone(),

owner: to_be_renamed.parent,

to_be_renamed: to_be_renamed.binding_id,

if first == last {

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

InFile::new(file.file_id, first),

&mut |InFile { value, .. }, _ctx| {

if let Some(node) = value

.parent_ancestors()

{

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![];

let mut scratch = scratch.into_iter();

InFile::new(file.file_id, last),

&mut |InFile { value: last, file_id: last_fid }, _ctx| {

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

if first_fid == last_fid {

}

}

}

},

);

}

res

}

if ast::MacroCall::can_cast(ancestor.kind()) {

return true;

}

ast::Item::Union(it) => it.into(),

_ => return false,

};

})

})

}

token: SyntaxToken,

mut cb: impl FnMut(InFile<SyntaxToken>, SyntaxContext),

) {

});

}

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

let mut res = smallvec![];

if res.is_empty() {

res.push(token);

}

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

let mut res = smallvec![];

let token = self.wrap_token_infile(token);

if !ctx.is_opaque(self.db) {

// Don't descend into opaque contexts

res.push(t);

}

});

if res.is_empty() {

res.push(token);

token: InFile<SyntaxToken>,

mut cb: impl FnMut(InFile<SyntaxToken>, SyntaxContext) -> ControlFlow<T>,

) -> Option<T> {

}

/// Descends the token into expansions, returning the tokens that matches the input

.unwrap_or(token)

}

fn descend_into_macros_impl<T>(

&self,

InFile { value: token, file_id }: InFile<SyntaxToken>,

f: &mut dyn FnMut(InFile<SyntaxToken>, SyntaxContext) -> ControlFlow<T>,

) -> Option<T> {

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

// Process the expansion of a call, pushing all tokens with our span in the expansion back onto our stack

// A stack of tokens to process, along with the file they came from

// These are tracked to know which macro calls we still have to look into

// the tokens themselves aren't that interesting as the span that is being used to map

// things down never changes.

let mut stack: Vec<(_, SmallVec<[_; 2]>)> = vec![];

match include {

Some(include) => {

// include! inputs are always from real files, so they only need to be handled once upfront

}

None => {

stack.push((file_id, smallvec![(token, span.ctx)]));

tokens.reverse();

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

let was_not_remapped = (|| {

})

}

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

// secondary attribute inputs

let tt = token

.parent_ancestors()

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

.last()?;

match tt {

// function-like macro call

Either::Left(tt) => {

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

return None;

}

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

return None;

}

let mcall = InFile::new(expansion, macro_call);

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

Some(&it) => it,

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

filter_duplicates(tokens, text_range);

}

// derive or derive helper

Either::Right(meta) => {

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

let adt = match attr.syntax().parent().and_then(ast::Adt::cast) {

Some(adt) => {

// this might be a derive on an ADT

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

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

});

}

}

None => {

// Otherwise this could be a derive helper on a variant or field

)

}

}?;

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 resolver = &token

.parent()

self.analyze_impl(InFile::new(expansion, &parent), None, false)

})?

.resolver;

let helpers = resolver

.def_map()

.derive_helpers_in_scope(InFile::new(expansion, id))?;

}

let mut res = None;

}

}

})()

.is_none();

if was_not_remapped {

if let ControlFlow::Break(b) = f(InFile::new(expansion, token), ctx) {

return Some(b);

}

/// Iterates the ancestors of the given node, climbing up macro expansions while doing so.

pub fn ancestors_with_macros(

&self,

node: SyntaxNode,

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

let node = self.find_file(&node);

}

})

}

pub fn ancestors_at_offset_with_macros(

ChildContainer::TraitId(it) => {

return Some(SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset));

}

ChildContainer::ImplId(it) => {

return Some(SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset));

}

ChildContainer::EnumId(it) => {

return Some(SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset));

}

ChildContainer::GenericDefId(it) => {

return Some(SourceAnalyzer::new_generic_def(self.db, it, node, offset));

}