type_ref::Mutability,

};

use hir_expand::{

attrs::collect_attrs,

builtin::{BuiltinFnLikeExpander, EagerExpander},

db::ExpandDatabase,

hygiene::SyntaxContextExt as _,

inert_attr_macro::find_builtin_attr_idx,

mod_path::{ModPath, PathKind},

use itertools::Itertools;

use rustc_hash::{FxHashMap, FxHashSet};

use smallvec::{SmallVec, smallvec};

use stdx::TupleExt;

use syntax::{

AstNode, AstToken, Direction, SyntaxKind, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange,

use crate::{

Adjust, Adjustment, Adt, AutoBorrow, BindingMode, BuiltinAttr, Callable, Const, ConstParam,

db::HirDatabase,

semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},

source_analyzer::{SourceAnalyzer, name_hygiene, resolve_hir_path},

pub struct SemanticsImpl<'db> {

pub db: &'db dyn HirDatabase,

s2d_cache: RefCell<SourceToDefCache>,

}

impl<DB> fmt::Debug for Semantics<'_, DB> {

SemanticsImpl { db, s2d_cache: Default::default(), macro_call_cache: Default::default() }

}

let tree = self.db.parse(file_id).tree();

self.cache(tree.syntax().clone(), hir_file_id);

tree

pub fn attach_first_edition(&self, file: FileId) -> Option<EditionedFileId> {

Some(EditionedFileId::new(

file,

self.file_to_module_defs(file).next()?.krate().edition(self.db),

))

}

pub fn parse_guess_edition(&self, file_id: FileId) -> ast::SourceFile {

.attach_first_edition(file_id)

let tree = self.db.parse(file_id).tree();

tree

}

pub fn find_parent_file(&self, file_id: HirFileId) -> Option<InFile<SyntaxNode>> {

let def_map = self.db.crate_def_map(module.krate().id);

match def_map[module.id.local_id].origin {

ModuleOrigin::CrateRoot { .. } => None,

_ => unreachable!("FileId can only belong to a file module"),

}

}

let root = find_root(&node.value);

self.cache(root, node.file_id);

Some(node)

node

}

let res = self.db.parse_macro_expansion(file_id).map(|it| it.0.syntax_node());

self.cache(res.value.clone(), file_id.into());

res

pub fn check_cfg_attr(&self, attr: &ast::TokenTree) -> Option<bool> {

let file_id = self.find_file(attr.syntax()).file_id;

}

};

hir_expand::check_cfg_attr_value(self.db, attr, krate)

}

let macro_call = InFile::new(sa.file_id, macro_call);

let file_id = sa.expand(self.db, macro_call)?;

let skip = matches!(

macro_call.def.kind,

pub fn expand_attr_macro(&self, item: &ast::Item) -> Option<ExpandResult<SyntaxNode>> {

let src = self.wrap_node_infile(item.clone());

let macro_call_id = self.with_ctx(|ctx| ctx.item_to_macro_call(src.as_ref()))?;

}

pub fn expand_derive_as_pseudo_attr_macro(&self, attr: &ast::Attr) -> Option<SyntaxNode> {

let call_id = self.with_ctx(|ctx| {

ctx.attr_to_derive_macro_call(src.with_value(&adt), src).map(|(_, it, _)| it)

})?;

}

pub fn resolve_derive_macro(&self, attr: &ast::Attr) -> Option<Vec<Option<Macro>>> {

.derive_macro_calls(attr)?

.into_iter()

.flat_map(|call| {

let ExpandResult { value, err } = self.db.parse_macro_expansion(file_id);

let root_node = value.0.syntax_node();

self.cache(root_node.clone(), file_id.into());

Some(result)

}

let adt = attr.syntax().ancestors().find_map(ast::Item::cast).and_then(|it| match it {

ast::Item::Struct(it) => Some(ast::Adt::Struct(it)),

ast::Item::Enum(it) => Some(ast::Adt::Enum(it)),

.derive_helpers_in_scope(InFile::new(sa.file_id, id))?

.iter()

.filter(|&(name, _, _)| *name == attr_name)

.collect();

res.is_empty().not().then_some(res)

}

let macro_file = analyzer.expansion(macro_call)?;

hir_expand::db::expand_speculative(

self.db,

speculative_args.syntax(),

token_to_map,

)

pub fn speculative_expand_raw(

&self,

speculative_args: &SyntaxNode,

token_to_map: SyntaxToken,

) -> Option<(SyntaxNode, Vec<(SyntaxToken, u8)>)> {

}

/// Expand the macro call with a different item as the input, mapping the `token_to_map` down into the

None => {

stack.push((

file_id.into(),

));

}

}

})

});

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

let attr_id = match self.db.lookup_intern_macro_call(call_id).kind {

hir_expand::MacroCallKind::Attr { invoc_attr_index, .. } => {

invoc_attr_index.ast_index()

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

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

filter_duplicates(tokens, text_range);

}

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

.eager_arg(self.db)

.and_then(|arg| {

// also descend into eager expansions

}))

}

// derive or derive helper

match derive_call {

Some(call_id) => {

// resolved to a derive

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(

);

}

None => Some(adt),

// as there may be multiple derives registering the same helper

// name, we gotta make sure to call this for all of them!

// FIXME: We need to call `f` for all of them as well though!

}

res

}

)

}

let root = self.parse_or_expand(src.file_id);

let node = src.map(|it| it.to_node(&root));

}

fn token_ancestors_with_macros(

ctx: &mut SourceToDefCtx<'_, '_>,

macro_call_id: MacroCallId,

) -> Option<MacroId> {

let db: &dyn ExpandDatabase = ctx.db;

let loc = db.lookup_intern_macro_call(macro_call_id);

match loc.def.ast_id() {

Either::Left(it) => {

it.to_ptr(db).to_node(&db.parse(file_id).syntax_node())

}

let expansion_info = ctx.cache.get_or_insert_expansion(ctx.db, macro_file);

it.to_ptr(db).to_node(&expansion_info.expanded().value)

}

ctx.macro_to_def(InFile::new(it.file_id, &node))

}

Either::Right(it) => {

it.to_ptr(db).to_node(&db.parse(file_id).syntax_node())

}

let expansion_info = ctx.cache.get_or_insert_expansion(ctx.db, macro_file);

it.to_ptr(db).to_node(&expansion_info.expanded().value)

}