}

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![];

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

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

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) => {

}

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 {

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

}