use base_db::{CrateDisplayName, CrateOrigin, LangCrateOrigin};

use either::Either;

use hir_def::{

attrs::AttrFlags,

expr_store::{ExpressionStoreDiagnostics, ExpressionStoreSourceMap},

hir::{

AstId, MacroCallKind, RenderedExpandError, ValueResult, proc_macro::ProcMacroKind,

};

use hir_ty::{

ValueTyDefId, all_super_traits, autoderef, check_orphan_rules,

consteval::try_const_usize,

db::{InternedClosureId, InternedCoroutineId},

mir::{MutBorrowKind, interpret_mir},

next_solver::{

AliasTy, ClauseKind, ConstKind, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs,

infer::{DbInternerInferExt, InferCtxt},

},

traits::{self, is_inherent_impl_coherent, structurally_normalize_ty},

diagnostics::*,

has_source::HasSource,

semantics::{

},

};

.flatten()

}

}

pub fn modules(self, db: &dyn HirDatabase) -> Vec<Module> {

let def_map = crate_def_map(db, self.id);

}

pub fn root_file(self, db: &dyn HirDatabase) -> FileId {

impl HasCrate for ModuleDef {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

match self.module(db) {

None => Crate::core(db).unwrap_or_else(|| db.all_crates()[0].into()),

}

}

}

/// Returns the crate this module is part of.

}

/// Topmost parent of this module. Every module has a `crate_root`, but some

/// might be missing `krate`. This can happen if a module's file is not included

/// in the module tree of any target in `Cargo.toml`.

pub fn crate_root(self, db: &dyn HirDatabase) -> Module {

}

}

/// Iterates over all child modules.

pub fn children(self, db: &dyn HirDatabase) -> impl Iterator<Item = Module> {

let def_map = self.id.def_map(db);

.children

.values()

.collect::<Vec<_>>();

children.into_iter()

}

/// Finds a parent module.

pub fn parent(self, db: &dyn HirDatabase) -> Option<Module> {

let def_map = self.id.def_map(db);

Some(Module { id: parent_id })

}

/// Finds nearest non-block ancestor `Module` (`self` included).

pub fn nearest_non_block_module(self, db: &dyn HirDatabase) -> Module {

let mut id = self.id;

id = id.containing_module(db).expect("block without parent module");

}

Module { id }

db: &dyn HirDatabase,

visible_from: Option<Module>,

) -> Vec<(Name, ScopeDef)> {

.scope

.entries()

.filter_map(|(name, def)| {

style_lints: bool,

) {

let _p = tracing::info_span!("diagnostics", name = ?self.name(db)).entered();

let def_map = self.id.def_map(db);

for diag in def_map.diagnostics() {

// FIXME: This is accidentally quadratic.

continue;

}

emit_def_diagnostic(db, acc, diag, edition, def_map.krate());

}

// These are reported by the body of block modules

scope.all_macro_calls().for_each(|it| macro_call_diagnostics(db, it, acc));

}

match def {

ModuleDef::Module(m) => {

// Only add diagnostics from inline modules

m.diagnostics(db, acc, style_lints)

}

acc.extend(def.diagnostics(db, style_lints))

}

self.legacy_macros(db).into_iter().for_each(|m| emit_macro_def_diagnostics(db, acc, m));

let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());

let mut impl_assoc_items_scratch = vec![];

let ast_id_map = db.ast_id_map(file_id);

for diag in impl_def.id.impl_items_with_diagnostics(db).1.iter() {

}

if impl_signature.target_trait.is_none()

pub fn declarations(self, db: &dyn HirDatabase) -> Vec<ModuleDef> {

let def_map = self.id.def_map(db);

scope

.declarations()

.map(ModuleDef::from)

pub fn legacy_macros(self, db: &dyn HirDatabase) -> Vec<Macro> {

let def_map = self.id.def_map(db);

scope.legacy_macros().flat_map(|(_, it)| it).map(|&it| it.into()).collect()

}

pub fn impl_defs(self, db: &dyn HirDatabase) -> Vec<Impl> {

let def_map = self.id.def_map(db);

}

/// Finds a path that can be used to refer to the given item from within

#[inline]

pub fn doc_keyword(self, db: &dyn HirDatabase) -> Option<Symbol> {

}

/// Whether it has `#[path = "..."]` attribute.

impl HasVisibility for Module {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

let def_map = self.id.def_map(db);

module_data.visibility

}

}

.get(self.index as usize)

.copied()

.unwrap_or_else(|| Ty::new_error(interner, ErrorGuaranteed));

}

}

pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {

db.layout_of_ty(

self.ty(db).ty,

)

.map(|layout| Layout(layout, db.target_data_layout(self.krate(db).into()).unwrap()))

}

pub fn variant_body_ty<'db>(self, db: &'db dyn HirDatabase) -> Type<'db> {

let interner = DbInterner::new_no_crate(db);

Type::new_for_crate(

match EnumSignature::variant_body_type(db, self.id) {

layout::IntegerType::Pointer(sign) => match sign {

true => Ty::new_int(interner, rustc_type_ir::IntTy::Isize),

}

pub fn layout(self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {

let interner = DbInterner::new_no_crate(db);

let adt_id = AdtId::from(self);

let args = GenericArgs::for_item_with_defaults(interner, adt_id.into(), |_, id, _| {

GenericArg::error_from_id(interner, id)

});

.map(|layout| Layout(layout, db.target_data_layout(self.krate(db).id).unwrap()))

}

pub fn debug_mir(self, db: &dyn HirDatabase) -> String {

let body = db.mir_body(self.id());

match body {

Err(e) => format!("error:\n{e:?}"),

}

}

acc: &mut Vec<AnyDiagnostic<'db>>,

style_lints: bool,

) {

let (body, source_map) = db.body_with_source_map(self.into());

let sig_source_map = match self {

};

for (_, def_map) in body.blocks(db) {

}

expr_store_diagnostics(db, acc, &source_map);

}

pub fn assoc_fn_params(self, db: &dyn HirDatabase) -> Vec<Param<'_>> {

// FIXME: This shouldn't be `instantiate_identity()`, we shouldn't leak `TyKind::Param`s.

let callable_sig =

db.callable_item_signature(self.id.into()).instantiate_identity().skip_binder();

.iter()

.enumerate()

.map(|(idx, ty)| {

Param { func: Callee::Def(CallableDefId::FunctionId(self.id)), ty, idx }

})

.collect()

}

pub fn params_without_self(self, db: &dyn HirDatabase) -> Vec<Param<'_>> {

// FIXME: This shouldn't be `instantiate_identity()`, we shouldn't leak `TyKind::Param`s.

let callable_sig =

db.callable_item_signature(self.id.into()).instantiate_identity().skip_binder();

.enumerate()

.skip(skip)

.map(|(idx, ty)| {

Param { func: Callee::Def(CallableDefId::FunctionId(self.id)), ty, idx }

})

.collect()

db: &'db dyn HirDatabase,

generics: impl Iterator<Item = Type<'db>>,

) -> Vec<Param<'db>> {

let interner = DbInterner::new_no_crate(db);

let args = generic_args_from_tys(interner, self.id.into(), generics.map(|ty| ty.ty));

let callable_sig =

.enumerate()

.skip(skip)

.map(|(idx, ty)| {

Param { func: Callee::Def(CallableDefId::FunctionId(self.id)), ty, idx }

})

.collect()

/// is this a `fn main` or a function with an `export_name` of `main`?

pub fn is_main(self, db: &dyn HirDatabase) -> bool {

self.exported_main(db)

}

/// Is this a function with an `export_name` of `main`?

let body = db.monomorphized_mir_body(

self.id.into(),

GenericArgs::new_from_iter(interner, []),

)?;

let (result, output) = interpret_mir(db, body, false, None)?;

let mut text = match result {

// FIXME: This shouldn't be `instantiate_identity()`, we shouldn't leak `TyKind::Param`s.

let callable_sig =

db.callable_item_signature(self.func.into()).instantiate_identity().skip_binder();

let ty = callable_sig.inputs().as_slice()[0];

Type { env: environment, ty }

}

let args = generic_args_from_tys(interner, self.func.into(), generics.map(|ty| ty.ty));

let callable_sig =

db.callable_item_signature(self.func.into()).instantiate(interner, args).skip_binder();

let ty = callable_sig.inputs().as_slice()[0];

Type { env: environment, ty }

}

pub fn resolved_crate(self, db: &dyn HirDatabase) -> Option<Crate> {

let loc = self.id.lookup(db);

let name = self.name(db);

if name == sym::self_ {

Some(krate.into())

/// Returns the crate defining this item (or `None` if `self` is built-in).

pub fn krate(&self, db: &dyn HirDatabase) -> Option<Crate> {

match self {

}

}

pub struct GenericSubstitution<'db> {

def: GenericDefId,

subst: GenericArgs<'db>,

}

impl<'db> GenericSubstitution<'db> {

Self { def, subst, env }

}

.zip(type_params);

container_params

.chain(self_params)

.collect()

}

}

}

pub fn all_in_module(db: &dyn HirDatabase, module: Module) -> Vec<Impl> {

}

/// **Note:** This is an **approximation** that strives to give the *human-perceived notion* of an "impl for type",

if let Some(module) = method_resolution::simplified_type_module(db, &simplified_ty) {

InherentImpls::for_each_crate_and_block(

db,

&mut |impls| extend_with_impls(impls.for_self_ty(&simplified_ty)),

);

for &krate in &**db.all_crates() {

TraitImpls::for_crate(db, krate)

.for_self_ty(&simplified_ty, &mut extend_with_impls);

let mut handle_impls = |impls: &TraitImpls| {

impls.for_trait(trait_.id, |impls| all.extend(impls.iter().copied().map(Impl::from)));

};

handle_impls(TraitImpls::for_crate(db, krate));

}

&& let Some(impls) = TraitImpls::for_block(db, block)

{

handle_impls(impls);

MacroCallKind::Derive { ast_id, derive_attr_index, derive_index, .. } => {

let module_id = self.id.lookup(db).container;

(

.scope

.derive_macro_invoc(ast_id, derive_attr_index)?,

derive_index,

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

pub struct TraitRef<'db> {

trait_ref: hir_ty::next_solver::TraitRef<'db>,

}

resolver: &Resolver<'_>,

trait_ref: hir_ty::next_solver::TraitRef<'db>,

) -> Self {

TraitRef { env, trait_ref }

}

pub fn self_ty(&self) -> TypeNs<'_> {

let ty = self.trait_ref.self_ty();

}

/// Returns `idx`-th argument of this trait reference if it is a type argument. Note that the

.as_slice()

.get(idx)

.and_then(|arg| arg.ty())

}

}

let owner = db.lookup_intern_closure(id).0;

let infer = InferenceResult::for_body(db, owner);

let (captures, _) = infer.closure_info(id);

}

pub fn fn_trait(&self, db: &dyn HirDatabase) -> FnTrait {

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

pub struct Type<'db> {

ty: Ty<'db>,

}

resolver: &Resolver<'_>,

ty: Ty<'db>,

) -> Self {

Type { env: environment, ty }

}

pub(crate) fn new_for_crate(krate: base_db::Crate, ty: Ty<'db>) -> Self {

}

fn new(db: &'db dyn HirDatabase, lexical_env: impl HasResolver, ty: Ty<'db>) -> Self {

let resolver = lexical_env.resolver(db);

Type { env: environment, ty }

}

pub fn new_tuple(krate: base_db::Crate, tys: &[Self]) -> Self {

let tys = tys.iter().map(|it| it.ty);

let interner = DbInterner::conjure();

}

pub fn is_unit(&self) -> bool {

})

.or(lang_items.Future)?;

return None;

}

let Some(iterator_trait) = lang_items.Iterator else {

return false;

};

}

/// Resolves the projection `<Self as IntoIterator>::IntoIter` and returns the resulting type

Some(into_iter_trait.id)

})?;

return None;

}

None => return false,

};

}

// FIXME: Find better API that also handles const generics

trait_.id.into(),

std::iter::once(self.ty).chain(args.iter().map(|ty| ty.ty)),

);

}

pub fn normalize_trait_assoc_type(

);

let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);

if ty.is_ty_error() { None } else { Some(self.derived(ty)) }

}

// This will happen when it implements fn or fn mut, since we add an autoborrow adjustment

TyKind::Ref(_, inner_ty, _) => return self.derived(inner_ty).as_callable(db),

_ => {

return Some(Callable {

ty: self.clone(),

sig,

let interner = DbInterner::new_no_crate(db);

// There should be no inference vars in types passed here

let canonical = hir_ty::replace_errors_with_variables(interner, &self.ty);

}

// This would be nicer if it just returned an iterator, but that runs into

if let Some(module) = method_resolution::simplified_type_module(db, &simplified_type) {

InherentImpls::for_each_crate_and_block(

db,

&mut |impls| {

handle_impls(impls.for_self_ty(&simplified_type));

},

f: impl FnOnce(&MethodResolutionContext<'_, 'db>) -> R,

) -> R {

let module = resolver.module();

let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);

let unstable_features =

MethodResolutionUnstableFeatures::from_def_map(resolver.top_level_def_map());

let ctx = MethodResolutionContext {

infcx: &infcx,

resolver,

traits_in_scope,

edition: resolver.krate().data(db).edition,

unstable_features: &unstable_features,

.filter(|ty| matches!(ty.kind(), TyKind::Param(_)))

.flat_map(|ty| {

self.env

.flat_map(|t| hir_ty::all_super_traits(db, t))

})

.map(Trait::from)

}

fn derived(&self, ty: Ty<'db>) -> Self {

}

/// Visits every type, including generic arguments, in this type. `callback` is called with type

pub fn walk(&self, db: &'db dyn HirDatabase, callback: impl FnMut(Type<'db>)) {

struct Visitor<'db, F> {

db: &'db dyn HirDatabase,

callback: F,

visited: FxHashSet<Ty<'db>>,

}

return;

}

if let Some(bounds) = ty.impl_trait_bounds(self.db) {

bounds.visit_with(self);

}

}

self.ty.visit_with(&mut visitor);

}

/// Check if type unifies with another type.

pub fn could_unify_with(&self, db: &'db dyn HirDatabase, other: &Type<'db>) -> bool {

let interner = DbInterner::new_no_crate(db);

let tys = hir_ty::replace_errors_with_variables(interner, &(self.ty, other.ty));

}

/// Check if type unifies with another type eagerly making sure there are no unresolved goals.

pub fn could_unify_with_deeply(&self, db: &'db dyn HirDatabase, other: &Type<'db>) -> bool {

let interner = DbInterner::new_no_crate(db);

let tys = hir_ty::replace_errors_with_variables(interner, &(self.ty, other.ty));

}

pub fn could_coerce_to(&self, db: &'db dyn HirDatabase, to: &Type<'db>) -> bool {

let interner = DbInterner::new_no_crate(db);

let tys = hir_ty::replace_errors_with_variables(interner, &(self.ty, to.ty));

}

pub fn as_type_param(&self, _db: &'db dyn HirDatabase) -> Option<TypeParam> {

}

pub fn layout(&self, db: &'db dyn HirDatabase) -> Result<Layout, LayoutError> {

.map(|layout| Layout(layout, db.target_data_layout(self.env.krate).unwrap()))

}

pub fn drop_glue(&self, db: &'db dyn HirDatabase) -> DropGlue {

let interner = DbInterner::new_with(db, self.env.krate);

let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);

}

}

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

pub struct TypeNs<'db> {

ty: Ty<'db>,

}

impl<'db> TypeNs<'db> {

fn new(db: &'db dyn HirDatabase, lexical_env: impl HasResolver, ty: Ty<'db>) -> Self {

let resolver = lexical_env.resolver(db);

TypeNs { env: environment, ty }

}

pub fn to_type(&self, _db: &'db dyn HirDatabase) -> Type<'db> {

}

// FIXME: Find better API that also handles const generics

pub fn krate(&self, db: &dyn HirDatabase) -> Option<Crate> {

match self {

ScopeDef::ImplSelfType(_) => None,

ScopeDef::Unknown => None,

}

}

impl<T: hir_def::HasModule> HasCrate for T {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for AssocItem {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Struct {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Union {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Enum {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Field {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Variant {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Function {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Const {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for TypeAlias {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Macro {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Trait {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Static {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Adt {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Impl {

fn krate(&self, db: &dyn HirDatabase) -> Crate {

}

}

impl HasCrate for Module {

}

}

fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

// FIXME: handle block expressions as modules (their parent is in a different DefMap)

let def_map = self.id.def_map(db);

None => ItemContainer::Crate(def_map.krate().into()),

}

}

.filter_map(|&krate| {

let segments = segments.clone();

let mut def_map = crate_def_map(db, krate);

let mut segments = segments.with_position().peekable();

while let Some((_, segment)) = segments.next_if(|&(position, _)| {

!matches!(position, itertools::Position::Last | itertools::Position::Only)

_ => None,

})?;

def_map = res.def_map(db);

}

let (_, item_name) = segments.next()?;

let res = module.scope.get(&Name::new_symbol_root(item_name));

})

}

pub use hir_ty::next_solver;

pub use hir_ty::setup_tracing;