use either::Either;

use hir_def::{

hir::{BindingId, Expr, ExprId, ExprOrPatId, Pat},

resolver::{self, HasResolver, Resolver, TypeNs},

};

use hir_expand::{

attrs::collect_attrs,

builtin::{BuiltinFnLikeExpander, EagerExpander},

db::ExpandDatabase,

hygiene::SyntaxContextExt as _,

inert_attr_macro::find_builtin_attr_idx,

name::AsName,

};

use hir_ty::diagnostics::unsafe_operations_for_body;

use itertools::Itertools;

use rustc_hash::{FxHashMap, FxHashSet};

use stdx::TupleExt;

use syntax::{

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

TextSize,

};

use crate::{

db::HirDatabase,

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

};

const CONTINUE_NO_BREAKS: ControlFlow<Infallible, ()> = ControlFlow::Continue(());

pub struct SemanticsImpl<'db> {

pub db: &'db dyn HirDatabase,

s2d_cache: RefCell<SourceToDefCache>,

}

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

}

pub fn parse(&self, file_id: EditionedFileId) -> ast::SourceFile {

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

tree

}

match self.file_to_module_defs(file).next() {

}

}

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 {

let file_id = self

.attach_first_edition(file_id)

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

self.cache(tree.syntax().clone(), file_id.into());

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,

ModuleOrigin::File { declaration, declaration_tree_id, .. } => {

let file_id = declaration_tree_id.file_id();

let in_file = InFile::new(file_id, declaration);

let root = find_root(node.syntax());

self.cache(root, file_id);

Some(in_file.with_value(node.syntax().clone()))

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

}

}

let root = find_root(&node.value);

self.cache(root, node.file_id);

Some(node)

/// Returns the `SyntaxNode` of the module. If this is a file module, returns

/// the `SyntaxNode` of the *definition* file, not of the *declaration*.

pub fn module_definition_node(&self, module: Module) -> InFile<SyntaxNode> {

let definition = definition.map(|it| it.node());

let root_node = find_root(&definition.value);

self.cache(root_node, definition.file_id);

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

let sa = self.analyze_no_infer(macro_call.syntax())?;

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

let node = self.parse_or_expand(file_id.into());

Some(node)

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

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

}

};

}

/// Expands the macro if it isn't one of the built-in ones that expand to custom syntax or dummy

let sa = self.analyze_no_infer(macro_call.syntax())?;

let macro_call = InFile::new(sa.file_id, 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)

}

speculative_args: &ast::TokenTree,

token_to_map: SyntaxToken,

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

hir_expand::db::expand_speculative(

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

let macro_call = self.wrap_node_infile(actual_macro_call.clone());

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

hir_expand::db::expand_speculative(

macro_call_id,

speculative_args.syntax(),

token_to_map,

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

})?;

hir_expand::db::expand_speculative(

macro_call_id,

speculative_args.syntax(),

token_to_map,

/// and returns the conflicting locals.

pub fn rename_conflicts(&self, to_be_renamed: &Local, new_name: &str) -> Vec<Local> {

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

let starting_expr =

body.binding_owners.get(&to_be_renamed.binding_id).copied().unwrap_or(body.body_expr);

let mut visitor = RenameConflictsVisitor {

}

}

/// Maps a node down by mapping its first and last token down.

pub fn descend_node_into_attributes<N: AstNode>(&self, node: N) -> SmallVec<[N; 1]> {

// This might not be the correct way to do this, but it works for now

pub fn descend_into_macros_cb(

&self,

token: SyntaxToken,

) {

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

self.descend_into_macros_impl(token, &mut |t, ctx| {

res

}

let mut res = smallvec![];

self.descend_into_macros_impl(token, &mut |t, ctx| {

// Don't descend into opaque contexts

}

CONTINUE_NO_BREAKS

});

pub fn descend_into_macros_breakable<T>(

&self,

token: InRealFile<SyntaxToken>,

) -> Option<T> {

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

}

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

let matches = (kind == mapped_kind || any_ident_match())

&& text == value.text()

if matches {

r.push(value);

}

|| kind.is_any_identifier() && value.kind().is_any_identifier();

let matches =

(kind == mapped_kind || any_ident_match()) && text == value.text();

},

)

} else {

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

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

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

Some(&it) => it,

None => {

m_cache.insert(mcall, it);

it

}

filter_duplicates(tokens, text_range);

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

.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

}

/// macro file the node resides in.

pub fn original_range(&self, node: &SyntaxNode) -> FileRange {

let node = self.find_file(node);

}

/// Attempts to map the node out of macro expanded files returning the original file range.

pub fn original_range_opt(&self, node: &SyntaxNode) -> Option<FileRange> {

let node = self.find_file(node);

}

/// Attempts to map the node out of macro expanded files.

/// This only work for attribute expansions, as other ones do not have nodes as input.

pub fn original_ast_node<N: AstNode>(&self, node: N) -> Option<N> {

|InRealFile { file_id, value }| {

self.cache(find_root(value.syntax()), file_id.into());

value

/// This only work for attribute expansions, as other ones do not have nodes as input.

pub fn original_syntax_node_rooted(&self, node: &SyntaxNode) -> Option<SyntaxNode> {

let InFile { file_id, .. } = self.find_file(node);

|InRealFile { file_id, value }| {

self.cache(find_root(&value), file_id.into());

value

)

}

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

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

}

fn token_ancestors_with_macros(

pub fn resolve_type(&self, ty: &ast::Type) -> Option<Type> {

let analyze = self.analyze(ty.syntax())?;

}

pub fn resolve_trait(&self, path: &ast::Path) -> Option<Trait> {

let analyze = self.analyze(path.syntax())?;

_ => None,

}

}

let (mut source_ty, _) = analyzer.type_of_expr(self.db, expr)?;

it.iter()

.map(|adjust| {

let target =

}

pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<Either<Field, TupleField>> {

}

pub fn resolve_field_fallback(

self.analyze(name.syntax())?.resolve_use_type_arg(name)

}

pub fn resolve_mod_path(

&self,

scope: &SyntaxNode,

path: &ModPath,

) -> Option<impl Iterator<Item = ItemInNs>> {

let analyze = self.analyze(scope)?;

Some(items.iter_items().map(|(item, _)| item.into()))

}

fn resolve_variant(&self, record_lit: ast::RecordExpr) -> Option<VariantId> {

}

pub fn resolve_bind_pat_to_const(&self, pat: &ast::IdentPat) -> Option<ModuleDef> {

&self,

node: InFile<&SyntaxNode>,

offset: Option<TextSize>,

infer_body: bool,

) -> Option<SourceAnalyzer> {

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

SourceAnalyzer::new_for_body(self.db, def, node, offset)

} else {

SourceAnalyzer::new_for_body_no_infer(self.db, def, node, offset)

}

};

Some(SourceAnalyzer::new_for_resolver(resolver, node))

}

}

}

fn macro_call_to_macro_id(

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

macro_call_id: MacroCallId,

) -> Option<MacroId> {

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)

}

/// Note: `VisibleTraits` should be treated as an opaque type, passed into `Type

pub fn visible_traits(&self) -> VisibleTraits {

let resolver = &self.resolver;

}

/// Calls the passed closure `f` on all names in scope.

pub fn process_all_names(&self, f: &mut dyn FnMut(Name, ScopeDef)) {

for (name, entries) in scope {

for entry in entries {

let def = match entry {

/// Resolve a path as-if it was written at the given scope. This is

/// necessary a heuristic, as it doesn't take hygiene into account.

pub fn speculative_resolve(&self, ast_path: &ast::Path) -> Option<PathResolution> {

resolve_hir_path(

self.db,

&self.resolver,

name_hygiene(self.db, InFile::new(self.file_id, ast_path.syntax())),

)

}

items.iter_items().map(|(item, _)| item.into())

}

}

pub fn extern_crate_decls(&self) -> impl Iterator<Item = Name> + '_ {

}

pub fn has_same_self_type(&self, other: &SemanticsScope<'_>) -> bool {

if let Some(name) = path.as_ident() {

if *name.symbol() == self.new_name {

if let Some(conflicting) = self.resolver.rename_will_conflict_with_renamed(

name,

path,

self.body.expr_or_pat_path_hygiene(node),

} else if *name.symbol() == self.old_name {

if let Some(conflicting) =

self.resolver.rename_will_conflict_with_another_variable(

name,

path,

self.body.expr_or_pat_path_hygiene(node),

fn rename_conflicts(&mut self, expr: ExprId) {

match &self.body[expr] {

Expr::Path(path) => {

self.resolve_path(expr.into(), path);

self.resolver.reset_to_guard(guard);

}

&Expr::Assignment { target, .. } => {

self.body.walk_pats(target, &mut |pat| {

if let Pat::Path(path) = &self.body[pat] {

self.resolve_path(pat.into(), path);