builtin::{BuiltinFnLikeExpander, EagerExpander},

db::ExpandDatabase,

files::InRealFile,

inert_attr_macro::find_builtin_attr_idx,

name::AsName,

FileRange, InMacroFile, MacroCallId, MacroFileId, MacroFileIdExt,

use itertools::Itertools;

use rustc_hash::{FxHashMap, FxHashSet};

use smallvec::{smallvec, SmallVec};

use stdx::TupleExt;

use syntax::{

algo::skip_trivia_token,

let quote = string.open_quote_text_range()?;

let token = self.wrap_token_infile(string.syntax().clone()).into_real_file().ok()?;

(|| {

let token = token.value;

let string = ast::String::cast(token)?;

let original_string = ast::String::cast(original_token.clone())?;

let original_token = self.wrap_token_infile(original_token).into_real_file().ok()?;

let quote = original_string.open_quote_text_range()?;

(|| {

let token = token.value;

self.resolve_offset_in_format_args(

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

self.descend_into_macros_impl(

InRealFile::new(file_id, first),

if let Some(node) = value

.parent_ancestors()

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

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

CONTINUE_NO_BREAKS

});

let mut scratch = scratch.into_iter();

self.descend_into_macros_impl(

InRealFile::new(file_id, last),

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

if first_fid == last_fid {

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

res

}

token.parent_ancestors().any(|ancestor| {

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

return true;

})

}

pub fn descend_into_macros_cb(

&self,

token: SyntaxToken,

) {

if let Ok(token) = self.wrap_token_infile(token).into_real_file() {

CONTINUE_NO_BREAKS

});

}

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

let mut res = smallvec![];

if let Ok(token) = self.wrap_token_infile(token.clone()).into_real_file() {

res.push(t.value);

CONTINUE_NO_BREAKS

});

res

}

pub fn descend_into_macros_breakable<T>(

&self,

token: InRealFile<SyntaxToken>,

) -> Option<T> {

self.descend_into_macros_impl(token.clone(), &mut cb)

}

let text = token.text();

let kind = token.kind();

let mapped_kind = value.kind();

let any_ident_match = || kind.is_any_identifier() && value.kind().is_any_identifier();

if matches {

r.push(value);

}

let text = token.text();

let kind = token.kind();

if let Ok(token) = self.wrap_token_infile(token.clone()).into_real_file() {

} else {

None

}

fn descend_into_macros_impl<T>(

&self,

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

) -> Option<T> {

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

let (sa, span, file_id) = token

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

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

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

// Filters out all tokens that contain the given range (usually the macro call), any such

// token is redundant as the corresponding macro call has already been processed

let filter_duplicates = |tokens: &mut SmallVec<_>, range: TextRange| {

};

while let Some((expansion, ref mut tokens)) = stack.pop() {

let was_not_remapped = (|| {

// First expand into attribute invocations

let containing_attribute_macro_call = self.with_ctx(|ctx| {

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

// remove any other token in this macro input, all their mappings are the

// same as this

!text_range.contains_range(t.text_range())

});

return process_expansion_for_token(

.is_none();

if was_not_remapped {

return Some(b);

}

}