use std::{

cell::RefCell,

fmt, iter, mem,

ops::{self, ControlFlow, Not},

};

builtin::{BuiltinFnLikeExpander, EagerExpander},

db::ExpandDatabase,

files::InRealFile,

name::AsName,

FileRange, InMacroFile, MacroCallId, MacroFileId, MacroFileIdExt,

};

use itertools::Itertools;

use rustc_hash::{FxHashMap, FxHashSet};

use smallvec::{smallvec, SmallVec};

Variant, VariantDef,

};

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

pub enum PathResolution {

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

/// descend it and find again

pub fn find_node_at_offset_with_descend<N: AstNode>(

&self,

node: &SyntaxNode,

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

}

/// descend it and find again

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

&'slf self,

node: &SyntaxNode,

)

}

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(

Some(it) => it,

None => return res,

};

if first == last {

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

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

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

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

if first_fid == last_fid {

}

}

}

},

);

}

res

}

&self,

token: SyntaxToken,

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

}

let mut res = smallvec![];

if res.is_empty() {

res.push(token);

}

res

}

&self,

}

});

}

&self,

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

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

let def_map = sa.resolver.def_map();

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

let process_expansion_for_token = |stack: &mut Vec<_>, macro_file| {

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

Some(

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

return process_expansion_for_token(&mut stack, file_id);

}

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

process_expansion_for_token(&mut stack, file_id).or(file_id

.eager_arg(self.db.upcast())

process_expansion_for_token(&mut stack, arg.as_macro_file())

}))

}

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)

});

)

}

}?;

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

})()

.is_none();

}

}

}

}

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

offset: TextSize,

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

node.token_at_offset(offset)

.map(|descendants| {

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

})

hir_ty::Adjust::Borrow(hir_ty::AutoBorrow::RawPtr(m)) => {

Adjust::Borrow(AutoBorrow::RawPtr(mutability(m)))

}

Adjust::Borrow(AutoBorrow::Ref(mutability(m)))

}

hir_ty::Adjust::Pointer(pc) => Adjust::Pointer(pc),

/// Returns none if the file of the node is not part of a crate.

fn analyze(&self, node: &SyntaxNode) -> Option<SourceAnalyzer> {

self.analyze_impl(node, None, true)

}

/// Returns none if the file of the node is not part of a crate.

fn analyze_no_infer(&self, node: &SyntaxNode) -> Option<SourceAnalyzer> {

self.analyze_impl(node, None, false)

}

node: &SyntaxNode,

offset: TextSize,

) -> Option<SourceAnalyzer> {

self.analyze_impl(node, Some(offset), false)

}

fn analyze_impl(

&self,

offset: Option<TextSize>,

infer_body: bool,

) -> Option<SourceAnalyzer> {

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

let container = self.with_ctx(|ctx| ctx.find_container(node))?;

InFile::new(file_id, node)

}

/// Wraps the node in a [`InFile`] with the file id it belongs to.

fn find_file<'node>(&self, node: &'node SyntaxNode) -> InFile<&'node SyntaxNode> {

let root_node = find_root(node);