generics::{LifetimeParamData, TypeOrConstParamData, TypeParamProvenance},

},

item_tree::ImportAlias,

layout::{self, ReprOptions, TargetDataLayout},

nameres::{

assoc::TraitItems,

PolyFnSig, Region, SolverDefId, Ty, TyKind, TypingMode,

infer::{DbInternerInferExt, InferCtxt},

},

};

use itertools::Itertools;

use rustc_hash::FxHashSet;

attr::{AttrSourceMap, Attrs, AttrsWithOwner},

find_path::PrefixKind,

import_map,

nameres::{DefMap, ModuleSource, crate_def_map},

per_ns::Namespace,

type_ref::{Mutability, TypeRef},

}

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 drop_maybe_dangle = (|| {

// FIXME: This can be simplified a lot by exposing hir-ty's utils.rs::Generics helper

let trait_ = trait_?;

if drop_trait != trait_.into() {

return None;

}

impl<'db> InstantiatedField<'db> {

/// Returns the type as in the signature of the struct.

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

let var_id = self.inner.parent.into();

let field = db.field_types(var_id)[self.inner.id];

}

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

let ty = db

.infer(self.owner)

.tuple_field_access_type(self.tuple)

VariantDef::Union(it) => it.id.into(),

VariantDef::Variant(it) => it.parent_enum(db).id.into(),

};

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

let ty = db.field_types(var_id)[self.id].instantiate(interner, args);

Type::new(db, var_id, ty)

}

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

let ty = db.ty(self.inner.id.into());

TypeNs::new(db, self.inner.id, ty.instantiate(interner, self.args))

/// The type of the enum variant bodies.

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

Type::new_for_crate(

self.id.lookup(db).container.krate(),

match db.enum_signature(self.id).variant_body_type() {

impl<'db> InstantiatedEnum<'db> {

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

let ty = db.ty(self.inner.id.into());

TypeNs::new(db, self.inner.id, ty.instantiate(interner, self.args))

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

let env = db.trait_environment(self.into());

let adt_id = AdtId::from(self);

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

GenericArg::error_from_id(interner, id)

args: impl IntoIterator<Item = Type<'db>>,

) -> Type<'db> {

let id = AdtId::from(self);

let ty = Ty::new_adt(

interner,

id,

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

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

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

let ty = Ty::new_fn_ptr(interner, callable_sig);

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

) -> Type<'db> {

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

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

let ty = db

.callable_item_signature(self.id.into())

.instantiate(interner, args)

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

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

let environment = db.trait_environment(self.id.into());

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

let callable_sig =

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

let ret_type = self.ret_type(db);

let Some(impl_traits) = ret_type.as_impl_traits(db) else { return false };

return false;

};

return false;

};

db: &dyn HirDatabase,

span_formatter: impl Fn(FileId, TextRange) -> String,

) -> Result<String, ConstEvalError<'_>> {

let body = db.monomorphized_mir_body(

self.id.into(),

GenericArgs::new_from_iter(interner, []),

db: &'db dyn HirDatabase,

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

) -> Type<'db> {

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

/// Evaluate the constant.

pub fn eval(self, db: &dyn HirDatabase) -> Result<EvaluatedConst<'_>, ConstEvalError<'_>> {

let ty = db.value_ty(self.id.into()).unwrap().instantiate_identity();

db.const_eval(self.id, GenericArgs::new_from_iter(interner, []), None)

.map(|it| EvaluatedConst { const_: it, def: self.id.into(), ty })

}

impl Trait {

}

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

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

let core = Crate::core(db).map(|core| core.id).unwrap_or_else(|| db.all_crates()[0]);

Type::new_for_crate(core, Ty::from_builtin_type(interner, self.inner))

}

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

let resolver = self.id.parent().resolver(db);

let index = hir_ty::param_idx(db, self.id.into()).unwrap();

let ty = Ty::new_param(interner, self.id, index as u32);

Type::new_with_resolver_inner(db, &resolver, ty)

/// blanket impls, and only does a shallow type constructor check. In fact, this should've probably been on `Adt`

/// etc., and not on `Type`. If you would want to create a precise list of all impls applying to a type,

/// you would need to include blanket impls, and try to prove to predicates for each candidate.

let mut result = Vec::new();

let Some(simplified_ty) =

fast_reject::simplify_type(interner, ty, fast_reject::TreatParams::AsRigid)

else {

impl<'db> Closure<'db> {

fn as_ty(&self, db: &'db dyn HirDatabase) -> Ty<'db> {

match self.id {

AnyClosureId::ClosureId(id) => Ty::new_closure(interner, id.into(), self.subst),

AnyClosureId::CoroutineClosureId(id) => {

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

let infer = db.infer(owner);

let info = infer.closure_info(id);

}

AnyClosureId::CoroutineClosureId(_id) => {

// FIXME: Infer kind for coroutine closures.

}

}

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

pub struct ClosureCapture<'db> {

owner: DefWithBodyId,

}

fn from_def(db: &'db dyn HirDatabase, def: impl Into<TyDefId> + HasResolver) -> Self {

let ty = db.ty(def.into());

let def = match def.into() {

TyDefId::AdtId(it) => GenericDefId::AdtId(it),

db: &'db dyn HirDatabase,

def: impl Into<ValueTyDefId> + HasResolver,

) -> Self {

let Some(ty) = db.value_ty(def.into()) else {

return Type::new(db, def, Ty::new_error(interner, ErrorGuaranteed));

};

}

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

return self.ty.visit_with(&mut Visitor { interner }).is_break();

fn is_phantom_data(db: &dyn HirDatabase, adt_id: AdtId) -> bool {

/// `std::future::Future` and returns the `Output` associated type.

/// This function is used in `.await` syntax completion.

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

.and_then(|into_future_fn| {

let assoc_item = as_assoc_item(db, AssocItem::Function, into_future_fn)?;

let into_future_trait = assoc_item.container_or_implemented_trait(db)?;

Some(into_future_trait.id)

})

if !traits::implements_trait_unique(self.ty, db, self.env.clone(), trait_) {

return None;

/// This does **not** resolve `IntoFuture`, only `Future`.

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

self.normalize_trait_assoc_type(db, &[], future_output.into())

}

/// This does **not** resolve `IntoIterator`, only `Iterator`.

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

let iterator_item = iterator_trait

.trait_items(db)

.associated_type_by_name(&Name::new_symbol_root(sym::Item))?;

}

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

return false;

};

traits::implements_trait_unique(self.ty, db, self.env.clone(), iterator_trait)

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

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

if !traits::implements_trait_unique(self.ty, db, self.env.clone(), trait_) {

return None;

/// This function can be used to check if a particular type is callable, since FnOnce is a

/// supertrait of Fn and FnMut, so all callable types implements at least FnOnce.

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

Some(it) => it,

None => return false,

};

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

pub fn impls_trait(&self, db: &'db dyn HirDatabase, trait_: Trait, args: &[Type<'db>]) -> bool {

let args = generic_args_from_tys(

interner,

trait_.id.into(),

args: &[Type<'db>],

alias: TypeAlias,

) -> Option<Type<'db>> {

let args = generic_args_from_tys(

interner,

alias.id.into(),

}

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

return false;

};

self.impls_trait(db, copy_trait.into(), &[])

}

pub fn as_callable(&self, db: &'db dyn HirDatabase) -> Option<Callable<'db>> {

let callee = match self.ty.kind() {

TyKind::Closure(id, subst) => Callee::Closure(id.0, subst),

TyKind::CoroutineClosure(id, subst) => Callee::CoroutineClosure(id.0, subst),

}

pub fn fields(&self, db: &'db dyn HirDatabase) -> Vec<(Field, Self)> {

let (variant_id, substs) = match self.ty.kind() {

TyKind::Adt(adt_def, substs) => {

let id = match adt_def.def_id().0 {

}

fn autoderef_(&self, db: &'db dyn HirDatabase) -> impl Iterator<Item = Ty<'db>> {

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

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

autoderef(db, self.env.clone(), canonical)

}

};

let Some(simplified_type) =

fast_reject::simplify_type(interner, self.ty, fast_reject::TreatParams::AsRigid)

else {

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

/// Note that we consider placeholder types to unify with everything.

/// For example `Option<T>` and `Option<U>` unify although there is unresolved goal `T = U`.

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

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

hir_ty::could_unify(db, self.env.clone(), &tys)

}

/// This means that placeholder types are not considered to unify if there are any bounds set on

/// them. For example `Option<T>` and `Option<U>` do not unify as we cannot show that `T = U`

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

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

hir_ty::could_unify_deeply(db, self.env.clone(), &tys)

}

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

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

hir_ty::could_coerce(db, self.env.clone(), &tys)

}

}

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

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

hir_ty::drop::has_drop_glue(&infcx, self.ty, self.env.clone())

}

Closure(InternedClosureId, GenericArgs<'db>),

CoroutineClosure(InternedCoroutineId, GenericArgs<'db>),

FnPtr,

}

pub enum CallableKind<'db> {

CallableKind::Closure(Closure { id: AnyClosureId::CoroutineClosureId(id), subst })

}

Callee::FnPtr => CallableKind::FnPtr,

}

}

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