+use std::{cell::OnceCell, iter, mem};

+use arrayvec::ArrayVec;

+ FunctionId, GeneralConstId, GenericDefId, GenericParamId, HasModule, ImplId, ItemContainerId,

+ LifetimeParamId, LocalFieldId, Lookup, StaticId, StructId, TypeAliasId, TypeOrConstParamId,

+ TypeParamId, UnionId, VariantId,

+ expr_store::{ExpressionStore, HygieneId, path::Path},

+ hir::generics::{

+ GenericParamDataRef, TypeOrConstParamData, TypeParamProvenance, WherePredicate,

+ },

+ lang_item::LangItems,

+ resolver::{HasResolver, LifetimeNs, Resolver, TypeNs, ValueNs},

+use la_arena::{Arena, ArenaMap, Idx};

+use path::{PathDiagnosticCallback, PathLoweringContext};

+use rustc_ast_ir::Mutability;

+use rustc_pattern_analysis::Captures;

+use rustc_type_ir::{

+ AliasTyKind, BoundVarIndexKind, ConstKind, DebruijnIndex, ExistentialPredicate,

+ ExistentialProjection, ExistentialTraitRef, FnSig, Interner, OutlivesPredicate, TermKind,

+ TyKind::{self},

+ TypeFoldable, TypeVisitableExt, Upcast, UpcastFrom, elaborate,

+ inherent::{

+ Clause as _, GenericArg as _, GenericArgs as _, IntoKind as _, Region as _, SliceLike,

+ Ty as _,

+ },

+};

+use smallvec::{SmallVec, smallvec};

+use tracing::debug;

+ FnAbi, ImplTraitId, TraitEnvironment, TyLoweringDiagnostic, TyLoweringDiagnosticKind,

+ consteval::intern_const_ref,

+ db::{HirDatabase, InternedOpaqueTyId},

+ next_solver::{

+ AliasTy, Binder, BoundExistentialPredicates, Clause, ClauseKind, Clauses, Const,

+ DbInterner, EarlyBinder, EarlyParamRegion, ErrorGuaranteed, FxIndexMap, GenericArg,

+ GenericArgs, ParamConst, ParamEnv, PolyFnSig, Predicate, Region, SolverDefId,

+ TraitPredicate, TraitRef, Ty, Tys, UnevaluatedConst, abi::Safety, util::BottomUpFolder,

+pub(crate) struct PathDiagnosticCallbackData(pub(crate) TypeRefId);

+

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

+pub struct ImplTraits<'db> {

+ pub(crate) impl_traits: Arena<ImplTrait<'db>>,

+}

+

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

+pub struct ImplTrait<'db> {

+ pub(crate) predicates: Box<[Clause<'db>]>,

+}

+

+pub type ImplTraitIdx<'db> = Idx<ImplTrait<'db>>;

+

+struct ImplTraitLoweringState<'db> {

+ opaque_type_data: Arena<ImplTrait<'db>>,

+

+impl<'db> ImplTraitLoweringState<'db> {

+ fn new(mode: ImplTraitLoweringMode) -> ImplTraitLoweringState<'db> {

+pub enum LifetimeElisionKind<'db> {

+ Elided(Region<'db>),

+impl<'db> LifetimeElisionKind<'db> {

+ pub(crate) fn for_const(

+ interner: DbInterner<'db>,

+ const_parent: ItemContainerId,

+ ) -> LifetimeElisionKind<'db> {

+ LifetimeElisionKind::Elided(Region::new_static(interner))

+ pub(crate) fn for_fn_params(data: &FunctionSignature) -> LifetimeElisionKind<'db> {

+ pub(crate) fn for_fn_ret(interner: DbInterner<'db>) -> LifetimeElisionKind<'db> {

+ LifetimeElisionKind::Elided(Region::error(interner))

+pub struct TyLoweringContext<'db, 'a> {

+ interner: DbInterner<'db>,

+ lang_items: &'db LangItems,

+ resolver: &'a Resolver<'db>,

+ store: &'a ExpressionStore,

+ impl_trait_mode: ImplTraitLoweringState<'db>,

+ pub(crate) unsized_types: FxHashSet<Ty<'db>>,

+ lifetime_elision: LifetimeElisionKind<'db>,

+ /// When lowering the defaults for generic params, this contains the index of the currently lowered param.

+ /// We disallow referring to later params, or to ADT's `Self`.

+ lowering_param_default: Option<u32>,

+impl<'db, 'a> TyLoweringContext<'db, 'a> {

+ resolver: &'a Resolver<'db>,

+ store: &'a ExpressionStore,

+ lifetime_elision: LifetimeElisionKind<'db>,

+ let in_binders = DebruijnIndex::ZERO;

+ let interner = DbInterner::new_with(db, resolver.krate());

+ // Can provide no block since we don't use it for trait solving.

+ interner,

+ lang_items: interner.lang_items(),

+ lowering_param_default: None,

+ pub(crate) fn set_lifetime_elision(&mut self, lifetime_elision: LifetimeElisionKind<'db>) {

+ self.lifetime_elision = lifetime_elision;

+ }

+

+ pub(crate) fn with_debruijn<T>(

+ f: impl FnOnce(&mut TyLoweringContext<'db, '_>) -> T,

+ pub(crate) fn with_shifted_in<T>(

+ f: impl FnOnce(&mut TyLoweringContext<'db, '_>) -> T,

+ self.with_debruijn(self.in_binders.shifted_in(debruijn.as_u32()), f)

+ pub(crate) fn with_impl_trait_mode(self, impl_trait_mode: ImplTraitLoweringMode) -> Self {

+ pub(crate) fn impl_trait_mode(&mut self, impl_trait_mode: ImplTraitLoweringMode) -> &mut Self {

+ pub(crate) fn lowering_param_default(&mut self, index: u32) {

+ self.lowering_param_default = Some(index);

+ pub(crate) fn push_diagnostic(&mut self, type_ref: TypeRefId, kind: TyLoweringDiagnosticKind) {

+pub(crate) enum ImplTraitLoweringMode {

+impl<'db, 'a> TyLoweringContext<'db, 'a> {

+ pub fn lower_ty(&mut self, type_ref: TypeRefId) -> Ty<'db> {

+ pub(crate) fn lower_const(&mut self, const_ref: ConstRef, const_type: Ty<'db>) -> Const<'db> {

+ hir_def::hir::Expr::Path(path) => {

+ self.path_to_const(path).unwrap_or_else(|| unknown_const(const_type))

+ }

+ pub(crate) fn path_to_const(&mut self, path: &Path) -> Option<Const<'db>> {

+ match self.resolver.resolve_path_in_value_ns_fully(self.db, path, HygieneId::ROOT) {

+ Some(ValueNs::GenericParam(p)) => {

+ let args = self.generics();

+ match args.type_or_const_param_idx(p.into()) {

+ Some(idx) => Some(self.const_param(p, idx as u32)),

+ None => {

+ never!(

+ "Generic list doesn't contain this param: {:?}, {:?}, {:?}",

+ args,

+ path,

+ p

+ );

+ None

+ }

+ }

+ }

+ Some(ValueNs::ConstId(c)) => {

+ let args = GenericArgs::new_from_iter(self.interner, []);

+ Some(Const::new(

+ self.interner,

+ rustc_type_ir::ConstKind::Unevaluated(UnevaluatedConst::new(

+ GeneralConstId::ConstId(c).into(),

+ args,

+ )),

+ ))

+ }

+ _ => None,

+ }

+ }

+

+ pub(crate) fn lower_path_as_const(&mut self, path: &Path, const_type: Ty<'db>) -> Const<'db> {

+ self.path_to_const(path).unwrap_or_else(|| unknown_const(const_type))

+ fn param_index_is_disallowed(&self, index: u32) -> bool {

+ self.lowering_param_default

+ .is_some_and(|disallow_params_after| index >= disallow_params_after)

+ }

+

+ fn type_param(&mut self, id: TypeParamId, index: u32) -> Ty<'db> {

+ if self.param_index_is_disallowed(index) {

+ // FIXME: Report an error.

+ Ty::new_error(self.interner, ErrorGuaranteed)

+ } else {

+ Ty::new_param(self.interner, id, index)

+ }

+ }

+

+ fn const_param(&mut self, id: ConstParamId, index: u32) -> Const<'db> {

+ if self.param_index_is_disallowed(index) {

+ // FIXME: Report an error.

+ Const::error(self.interner)

+ } else {

+ Const::new_param(self.interner, ParamConst { id, index })

+ }

+ }

+

+ fn region_param(&mut self, id: LifetimeParamId, index: u32) -> Region<'db> {

+ if self.param_index_is_disallowed(index) {

+ // FIXME: Report an error.

+ Region::error(self.interner)

+ } else {

+ Region::new_early_param(self.interner, EarlyParamRegion { id, index })

+ }

+ }

+

+ #[tracing::instrument(skip(self), ret)]

+ pub fn lower_ty_ext(&mut self, type_ref_id: TypeRefId) -> (Ty<'db>, Option<TypeNs>) {

+ let interner = self.interner;

+ tracing::debug!(?type_ref);

+ TypeRef::Never => Ty::new(interner, TyKind::Never),

+ Ty::new_tup_from_iter(interner, inner_tys)

+

+ let generics = self.generics();

+ let (idx, _data) =

+ generics.type_or_const_param(type_param_id.into()).expect("matching generics");

+ self.type_param(type_param_id, idx as u32)

+ Ty::new(interner, TyKind::RawPtr(inner_ty, lower_mutability(mutability)))

+ let const_len = self.lower_const(array.len, Ty::new_usize(interner));

+ Ty::new_array_with_const_len(interner, inner_ty, const_len)

+ Ty::new_slice(interner, inner_ty)

+ // FIXME: It should infer the eldided lifetimes instead of stubbing with error

+ .map_or_else(|| Region::error(interner), |lr| self.lower_lifetime(lr));

+ Ty::new_ref(interner, lifetime, inner_ty, lower_mutability(ref_.mutability))

+ TypeRef::Placeholder => Ty::new_error(interner, ErrorGuaranteed),

+ let substs = self.with_shifted_in(

+ DebruijnIndex::from_u32(1),

+ |ctx: &mut TyLoweringContext<'_, '_>| {

+ Tys::new_from_iter(

+ interner,

+ fn_.params.iter().map(|&(_, tr)| ctx.lower_ty(tr)),

+ )

+ },

+ );

+ Ty::new_fn_ptr(

+ interner,

+ Binder::dummy(FnSig {

+ c_variadic: fn_.is_varargs,

+ inputs_and_output: substs,

+ }),

+ )

+ let origin = match self.resolver.generic_def() {

+ Some(GenericDefId::FunctionId(it)) => Either::Left(it),

+ Some(GenericDefId::TypeAliasId(it)) => Either::Right(it),

+ let idx = self

+ .impl_trait_mode

+ .opaque_type_data

+ .alloc(ImplTrait { predicates: Box::default() });

+

+ let impl_trait_id = origin.either(

+ |f| ImplTraitId::ReturnTypeImplTrait(f, idx),

+ |a| ImplTraitId::TypeAliasImplTrait(a, idx),

+ );

+ let opaque_ty_id: SolverDefId =

+ self.db.intern_impl_trait_id(impl_trait_id).into();

+

+ .with_debruijn(DebruijnIndex::ZERO, |ctx| {

+ ctx.lower_impl_trait(opaque_ty_id, bounds)

+ let args = GenericArgs::identity_for_item(self.interner, opaque_ty_id);

+ Ty::new_alias(

+ self.interner,

+ AliasTyKind::Opaque,

+ AliasTy::new_from_args(self.interner, opaque_ty_id, args),

+ )

+ Ty::new_error(self.interner, ErrorGuaranteed)

+ TypeRef::Error => Ty::new_error(self.interner, ErrorGuaranteed),

+ fn lower_ty_only_param(&self, type_ref: TypeRefId) -> Option<TypeOrConstParamId> {

+ let type_ref = &self.store[type_ref];

+ let resolution = match self.resolver.resolve_path_in_type_ns(self.db, path) {

+ Some((it, None, _)) => it,

+ fn on_path_diagnostic_callback<'b>(type_ref: TypeRefId) -> PathDiagnosticCallback<'b, 'db> {

+ fn at_path(&mut self, path_id: PathId) -> PathLoweringContext<'_, 'a, 'db> {

+ pub(crate) fn lower_path(&mut self, path: &Path, path_id: PathId) -> (Ty<'db>, Option<TypeNs>) {

+ None => return (Ty::new_error(self.interner, ErrorGuaranteed), None),

+ explicit_self_ty: Ty<'db>,

+ ) -> Option<(TraitRef<'db>, PathLoweringContext<'_, 'a, 'db>)> {

+ explicit_self_ty: Ty<'db>,

+ ) -> Option<TraitRef<'db>> {

+ generics: &Generics,

+ predicate_filter: PredicateFilter,

+ ) -> impl Iterator<Item = Clause<'db>> + use<'a, 'b, 'db> {

+ if let PredicateFilter::SelfTrait = predicate_filter {

+ let target_type = &self.store[*target];

+ let self_type = 'is_self: {

+ if let TypeRef::Path(path) = target_type

+ && path.is_self_type()

+ {

+ break 'is_self true;

+ }

+ if let TypeRef::TypeParam(param) = target_type

+ && generics[param.local_id()].is_trait_self()

+ {

+ break 'is_self true;

+ }

+ false

+ };

+ if !self_type {

+ return Either::Left(Either::Left(iter::empty()));

+ }

+ }

+ Either::Left(Either::Right(self.lower_type_bound(bound, self_ty, ignore_bindings)))

+ }

+ &WherePredicate::Lifetime { bound, target } => {

+ Either::Right(iter::once(Clause(Predicate::new(

+ self.interner,

+ Binder::dummy(rustc_type_ir::PredicateKind::Clause(

+ rustc_type_ir::ClauseKind::RegionOutlives(OutlivesPredicate(

+ self.lower_lifetime(bound),

+ self.lower_lifetime(target),

+ )),

+ )),

+ ))))

+ self_ty: Ty<'db>,

+ ) -> impl Iterator<Item = Clause<'db>> + use<'b, 'a, 'db> {

+ let interner = self.interner;

+ let meta_sized = self.lang_items.MetaSized;

+ let pointee_sized = self.lang_items.PointeeSized;

+ if let Some((trait_ref, mut ctx)) = self.lower_trait_ref_from_path(path, self_ty) {

+ if meta_sized.is_some_and(|it| it == trait_ref.def_id.0) {

+ } else if pointee_sized.is_some_and(|it| it == trait_ref.def_id.0) {

+ assoc_bounds = ctx.assoc_type_bindings_from_type_bound(trait_ref);

+ clause = Some(Clause(Predicate::new(

+ interner,

+ Binder::dummy(rustc_type_ir::PredicateKind::Clause(

+ rustc_type_ir::ClauseKind::Trait(TraitPredicate {

+ trait_ref,

+ polarity: rustc_type_ir::PredicatePolarity::Positive,

+ }),

+ )),

+ )));

+ let sized_trait = self.lang_items.Sized;

+ .lower_trait_ref_from_path(path, self_ty)

+ .map(|(trait_ref, _)| trait_ref.def_id.0);

+ clause = Some(Clause(Predicate::new(

+ self.interner,

+ Binder::dummy(rustc_type_ir::PredicateKind::Clause(

+ rustc_type_ir::ClauseKind::TypeOutlives(OutlivesPredicate(

+ self_ty, lifetime,

+ )),

+ )),

+ )));

+ fn lower_dyn_trait(&mut self, bounds: &[TypeBound]) -> Ty<'db> {

+ let interner = self.interner;

+ let dummy_self_ty = dyn_trait_dummy_self(interner);

+ let mut region = None;

+ let bounds = self.with_shifted_in(DebruijnIndex::from_u32(1), |ctx| {

+ let mut principal = None;

+ let mut auto_traits = SmallVec::<[_; 3]>::new();

+ let mut projections = Vec::new();

+ let mut had_error = false;

+

+ let db = ctx.db;

+ ctx.lower_type_bound(b, dummy_self_ty, false).for_each(|b| {

+ match b.kind().skip_binder() {

+ rustc_type_ir::ClauseKind::Trait(t) => {

+ let id = t.def_id();

+ let is_auto = db.trait_signature(id.0).flags.contains(TraitFlags::AUTO);

+ if is_auto {

+ auto_traits.push(t.def_id().0);

+ } else {

+ if principal.is_some() {

+ // FIXME: Report an error.

+ had_error = true;

+ }

+ principal = Some(b.kind().rebind(t.trait_ref));

+ }

+ rustc_type_ir::ClauseKind::Projection(p) => {

+ projections.push(b.kind().rebind(p));

+ }

+ rustc_type_ir::ClauseKind::TypeOutlives(outlives_predicate) => {

+ if region.is_some() {

+ // FIXME: Report an error.

+ had_error = true;

+ }

+ region = Some(outlives_predicate.1);

+ }

+ rustc_type_ir::ClauseKind::RegionOutlives(_)

+ | rustc_type_ir::ClauseKind::ConstArgHasType(_, _)

+ | rustc_type_ir::ClauseKind::WellFormed(_)

+ | rustc_type_ir::ClauseKind::ConstEvaluatable(_)

+ | rustc_type_ir::ClauseKind::HostEffect(_)

+ | rustc_type_ir::ClauseKind::UnstableFeature(_) => unreachable!(),

+ })

+ }

+

+ if had_error {

+ return None;

+ }

+

+ if principal.is_none() && auto_traits.is_empty() {

+ // No traits is not allowed.

+ return None;

+ }

+

+ // `Send + Sync` is the same as `Sync + Send`.

+ auto_traits.sort_unstable();

+ // Duplicate auto traits are permitted.

+ auto_traits.dedup();

+

+ // Map the projection bounds onto a key that makes it easy to remove redundant

+ // bounds that are constrained by supertraits of the principal def id.

+ //

+ // Also make sure we detect conflicting bounds from expanding a trait alias and

+ // also specifying it manually, like:

+ // ```

+ // type Alias = Trait<Assoc = i32>;

+ // let _: &dyn Alias<Assoc = u32> = /* ... */;

+ // ```

+ let mut projection_bounds = FxIndexMap::default();

+ for proj in projections {

+ let key = (

+ proj.skip_binder().def_id().expect_type_alias(),

+ interner.anonymize_bound_vars(

+ proj.map_bound(|proj| proj.projection_term.trait_ref(interner)),

+ ),

+ );

+ if let Some(old_proj) = projection_bounds.insert(key, proj)

+ && interner.anonymize_bound_vars(proj)

+ != interner.anonymize_bound_vars(old_proj)

+ {

+ // FIXME: Report "conflicting associated type" error.

+ }

+ // A stable ordering of associated types from the principal trait and all its

+ // supertraits. We use this to ensure that different substitutions of a trait

+ // don't result in `dyn Trait` types with different projections lists, which

+ // can be unsound: <https://github.com/rust-lang/rust/pull/136458>.

+ // We achieve a stable ordering by walking over the unsubstituted principal

+ // trait ref.

+ let mut ordered_associated_types = vec![];

+

+ if let Some(principal_trait) = principal {

+ for clause in elaborate::elaborate(

+ interner,

+ [Clause::upcast_from(

+ TraitRef::identity(interner, principal_trait.def_id()),

+ interner,

+ )],

+ )

+ .filter_only_self()

+ {

+ let clause = clause.instantiate_supertrait(interner, principal_trait);

+ debug!("observing object predicate `{clause:?}`");

+

+ let bound_predicate = clause.kind();

+ match bound_predicate.skip_binder() {

+ ClauseKind::Trait(pred) => {

+ // FIXME(negative_bounds): Handle this correctly...

+ let trait_ref = interner

+ .anonymize_bound_vars(bound_predicate.rebind(pred.trait_ref));

+ ordered_associated_types.extend(

+ pred.trait_ref

+ .def_id

+ .0

+ .trait_items(self.db)

+ .associated_types()

+ .map(|item| (item, trait_ref)),

+ );

+ ClauseKind::Projection(pred) => {

+ let pred = bound_predicate.rebind(pred);

+ // A `Self` within the original bound will be instantiated with a

+ // `trait_object_dummy_self`, so check for that.

+ let references_self = match pred.skip_binder().term.kind() {

+ TermKind::Ty(ty) => {

+ ty.walk().any(|arg| arg == dummy_self_ty.into())

+ }

+ // FIXME(associated_const_equality): We should walk the const instead of not doing anything

+ TermKind::Const(_) => false,

+ };

+

+ // If the projection output contains `Self`, force the user to

+ // elaborate it explicitly to avoid a lot of complexity.

+ //

+ // The "classically useful" case is the following:

+ // ```

+ // trait MyTrait: FnMut() -> <Self as MyTrait>::MyOutput {

+ // type MyOutput;

+ // }

+ // ```

+ //

+ // Here, the user could theoretically write `dyn MyTrait<MyOutput = X>`,

+ // but actually supporting that would "expand" to an infinitely-long type

+ // `fix $ τ → dyn MyTrait<MyOutput = X, Output = <τ as MyTrait>::MyOutput`.

+ //

+ // Instead, we force the user to write

+ // `dyn MyTrait<MyOutput = X, Output = X>`, which is uglier but works. See

+ // the discussion in #56288 for alternatives.

+ if !references_self {

+ let key = (

+ pred.skip_binder().projection_term.def_id.expect_type_alias(),

+ interner.anonymize_bound_vars(pred.map_bound(|proj| {

+ proj.projection_term.trait_ref(interner)

+ })),

+ );

+ if !projection_bounds.contains_key(&key) {

+ projection_bounds.insert(key, pred);

+ _ => (),

+ }

+

+ // We compute the list of projection bounds taking the ordered associated types,

+ // and check if there was an entry in the collected `projection_bounds`. Those

+ // are computed by first taking the user-written associated types, then elaborating

+ // the principal trait ref, and only using those if there was no user-written.

+ // See note below about how we handle missing associated types with `Self: Sized`,

+ // which are not required to be provided, but are still used if they are provided.

+ let mut projection_bounds: Vec<_> = ordered_associated_types

+ .into_iter()

+ .filter_map(|key| projection_bounds.get(&key).copied())

+ .collect();

+

+ projection_bounds.sort_unstable_by_key(|proj| proj.skip_binder().def_id());

+

+ let principal = principal.map(|principal| {

+ principal.map_bound(|principal| {

+ // Verify that `dummy_self` did not leak inside default type parameters.

+ let args: Vec<_> = principal

+ .args

+ .iter()

+ // Skip `Self`

+ .skip(1)

+ .map(|arg| {

+ if arg.walk().any(|arg| arg == dummy_self_ty.into()) {

+ // FIXME: Report an error.

+ Ty::new_error(interner, ErrorGuaranteed).into()

+ } else {

+ arg

+ }

+ })

+ .collect();

+

+ ExistentialPredicate::Trait(ExistentialTraitRef::new(

+ interner,

+ principal.def_id,

+ args,

+ ))

+ })

+ let projections = projection_bounds.into_iter().map(|proj| {

+ proj.map_bound(|mut proj| {

+ // Like for trait refs, verify that `dummy_self` did not leak inside default type

+ // parameters.

+ let references_self = proj.projection_term.args.iter().skip(1).any(|arg| {

+ if arg.walk().any(|arg| arg == dummy_self_ty.into()) {

+ return true;

+ }

+ false

+ });

+ if references_self {

+ proj.projection_term =

+ replace_dummy_self_with_error(interner, proj.projection_term);

+ }

+ ExistentialPredicate::Projection(ExistentialProjection::erase_self_ty(

+ interner, proj,

+ ))

+ })

+ });

+ let auto_traits = auto_traits.into_iter().map(|auto_trait| {

+ Binder::dummy(ExistentialPredicate::AutoTrait(auto_trait.into()))

+ });

+ // N.b. principal, projections, auto traits

+ Some(BoundExistentialPredicates::new_from_iter(

+ interner,

+ principal.into_iter().chain(projections).chain(auto_traits),

+ ))

+ let region = match region {

+ Some(it) => match it.kind() {

+ rustc_type_ir::RegionKind::ReBound(BoundVarIndexKind::Bound(db), var) => {

+ Region::new_bound(

+ self.interner,

+ db.shifted_out_to_binder(DebruijnIndex::from_u32(2)),

+ var,

+ )

+ }

+ _ => it,

+ None => Region::new_static(self.interner),

+ };

+ Ty::new_dynamic(self.interner, bounds, region)

+ Ty::new_error(self.interner, ErrorGuaranteed)

+ fn lower_impl_trait(&mut self, def_id: SolverDefId, bounds: &[TypeBound]) -> ImplTrait<'db> {

+ let interner = self.interner;

+ let args = GenericArgs::identity_for_item(interner, def_id);

+ let self_ty = Ty::new_alias(

+ self.interner,

+ rustc_type_ir::AliasTyKind::Opaque,

+ AliasTy::new_from_args(interner, def_id, args),

+ );

+ let predicates = self.with_shifted_in(DebruijnIndex::from_u32(1), |ctx| {

+ predicates.extend(ctx.lower_type_bound(b, self_ty, false));

+ let sized_trait = self.lang_items.Sized;

+ let trait_ref = TraitRef::new_from_args(

+ interner,

+ trait_id.into(),

+ GenericArgs::new_from_iter(interner, [self_ty.into()]),

+ );

+ Clause(Predicate::new(

+ interner,

+ Binder::dummy(rustc_type_ir::PredicateKind::Clause(

+ rustc_type_ir::ClauseKind::Trait(TraitPredicate {

+ trait_ref,

+ polarity: rustc_type_ir::PredicatePolarity::Positive,

+ }),

+ )),

+ ))

+ predicates.into_boxed_slice()

+ ImplTrait { predicates }

+ pub(crate) fn lower_lifetime(&mut self, lifetime: LifetimeRefId) -> Region<'db> {

+ LifetimeNs::Static => Region::new_static(self.interner),

+ LifetimeNs::LifetimeParam(id) => {

+ let idx = match self.generics().lifetime_idx(id) {

+ None => return Region::error(self.interner),

+ Some(idx) => idx,

+ };

+ self.region_param(id, idx as u32)

+ None => Region::error(self.interner),

+fn dyn_trait_dummy_self(interner: DbInterner<'_>) -> Ty<'_> {

+ // This type must not appear anywhere except here.

+ Ty::new_fresh(interner, 0)

+}

+

+fn replace_dummy_self_with_error<'db, T: TypeFoldable<DbInterner<'db>>>(

+ interner: DbInterner<'db>,

+ t: T,

+) -> T {

+ let dyn_trait_dummy_self = dyn_trait_dummy_self(interner);

+ t.fold_with(&mut BottomUpFolder {

+ interner,

+ ty_op: |ty| {

+ if ty == dyn_trait_dummy_self { Ty::new_error(interner, ErrorGuaranteed) } else { ty }

+ },

+ lt_op: |lt| lt,

+ ct_op: |ct| ct,

+ })

+}

+

+pub(crate) fn lower_mutability(m: hir_def::type_ref::Mutability) -> Mutability {

+ match m {

+ hir_def::type_ref::Mutability::Shared => Mutability::Not,

+ hir_def::type_ref::Mutability::Mut => Mutability::Mut,

+fn unknown_const(_ty: Ty<'_>) -> Const<'_> {

+ Const::new(DbInterner::conjure(), ConstKind::Error(ErrorGuaranteed))

+}

+pub(crate) type Diagnostics = Option<ThinArc<(), TyLoweringDiagnostic>>;

+

+pub(crate) fn create_diagnostics(diagnostics: Vec<TyLoweringDiagnostic>) -> Diagnostics {

+ (!diagnostics.is_empty()).then(|| ThinArc::from_header_and_iter((), diagnostics.into_iter()))

+}

+

+pub(crate) fn impl_trait_query<'db>(

+ db: &'db dyn HirDatabase,

+ impl_id: ImplId,

+) -> Option<EarlyBinder<'db, TraitRef<'db>>> {

+ db.impl_trait_with_diagnostics(impl_id).map(|it| it.0)

+}

+

+pub(crate) fn impl_trait_with_diagnostics_query<'db>(

+ db: &'db dyn HirDatabase,

+ impl_id: ImplId,

+) -> Option<(EarlyBinder<'db, TraitRef<'db>>, Diagnostics)> {

+ let impl_data = db.impl_signature(impl_id);

+ let resolver = impl_id.resolver(db);

+ let mut ctx = TyLoweringContext::new(

+ db,

+ &resolver,

+ &impl_data.store,

+ impl_id.into(),

+ LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true },

+ );

+ let self_ty = db.impl_self_ty(impl_id).skip_binder();

+ let target_trait = impl_data.target_trait.as_ref()?;

+ let trait_ref = EarlyBinder::bind(ctx.lower_trait_ref(target_trait, self_ty)?);

+ Some((trait_ref, create_diagnostics(ctx.diagnostics)))

+}

+

+impl<'db> ImplTraitId<'db> {

+ #[inline]

+ pub fn predicates(self, db: &'db dyn HirDatabase) -> EarlyBinder<'db, &'db [Clause<'db>]> {

+ let (impl_traits, idx) = match self {

+ ImplTraitId::ReturnTypeImplTrait(owner, idx) => {

+ (ImplTraits::return_type_impl_traits(db, owner), idx)

+ }

+ ImplTraitId::TypeAliasImplTrait(owner, idx) => {

+ (ImplTraits::type_alias_impl_traits(db, owner), idx)

+ };

+ impl_traits

+ .as_deref()

+ .expect("owner should have opaque type")

+ .as_ref()

+ .map_bound(|it| &*it.impl_traits[idx].predicates)

+ }

+}

+

+impl InternedOpaqueTyId {

+ #[inline]

+ pub fn predicates<'db>(self, db: &'db dyn HirDatabase) -> EarlyBinder<'db, &'db [Clause<'db>]> {

+ self.loc(db).predicates(db)

+ }

+}

+

+#[salsa::tracked]

+impl<'db> ImplTraits<'db> {

+ #[salsa::tracked(returns(ref), unsafe(non_update_return_type))]

+ pub(crate) fn return_type_impl_traits(

+ db: &'db dyn HirDatabase,

+ def: hir_def::FunctionId,

+ ) -> Option<Box<EarlyBinder<'db, ImplTraits<'db>>>> {

+ // FIXME unify with fn_sig_for_fn instead of doing lowering twice, maybe

+ let data = db.function_signature(def);

+ let resolver = def.resolver(db);

+ let mut ctx_ret = TyLoweringContext::new(

+ db,

+ &resolver,

+ &data.store,

+ def.into(),

+ LifetimeElisionKind::Infer,

+ )

+ .with_impl_trait_mode(ImplTraitLoweringMode::Opaque);

+ if let Some(ret_type) = data.ret_type {

+ let _ret = ctx_ret.lower_ty(ret_type);

+ }

+ let mut return_type_impl_traits =

+ ImplTraits { impl_traits: ctx_ret.impl_trait_mode.opaque_type_data };

+ if return_type_impl_traits.impl_traits.is_empty() {

+ } else {

+ return_type_impl_traits.impl_traits.shrink_to_fit();

+ Some(Box::new(EarlyBinder::bind(return_type_impl_traits)))

+ }

+ }

+ #[salsa::tracked(returns(ref), unsafe(non_update_return_type))]

+ pub(crate) fn type_alias_impl_traits(

+ db: &'db dyn HirDatabase,

+ def: hir_def::TypeAliasId,

+ ) -> Option<Box<EarlyBinder<'db, ImplTraits<'db>>>> {

+ let data = db.type_alias_signature(def);

+ let resolver = def.resolver(db);

+ let mut ctx = TyLoweringContext::new(

+ db,

+ &resolver,

+ &data.store,

+ def.into(),

+ LifetimeElisionKind::AnonymousReportError,

+ )

+ .with_impl_trait_mode(ImplTraitLoweringMode::Opaque);

+ if let Some(type_ref) = data.ty {

+ let _ty = ctx.lower_ty(type_ref);

+ let mut type_alias_impl_traits =

+ ImplTraits { impl_traits: ctx.impl_trait_mode.opaque_type_data };

+ if type_alias_impl_traits.impl_traits.is_empty() {

+ } else {

+ type_alias_impl_traits.impl_traits.shrink_to_fit();

+ Some(Box::new(EarlyBinder::bind(type_alias_impl_traits)))

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

+pub enum TyDefId {

+ BuiltinType(BuiltinType),

+ AdtId(AdtId),

+ TypeAliasId(TypeAliasId),

+}

+impl_from!(BuiltinType, AdtId(StructId, EnumId, UnionId), TypeAliasId for TyDefId);

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, salsa_macros::Supertype)]

+pub enum ValueTyDefId {

+ FunctionId(FunctionId),

+ StructId(StructId),

+ UnionId(UnionId),

+ EnumVariantId(EnumVariantId),

+ ConstId(ConstId),

+ StaticId(StaticId),

+}

+impl_from!(FunctionId, StructId, UnionId, EnumVariantId, ConstId, StaticId for ValueTyDefId);

+

+impl ValueTyDefId {

+ pub(crate) fn to_generic_def_id(self, db: &dyn HirDatabase) -> GenericDefId {

+ match self {

+ Self::FunctionId(id) => id.into(),

+ Self::StructId(id) => id.into(),

+ Self::UnionId(id) => id.into(),

+ Self::EnumVariantId(var) => var.lookup(db).parent.into(),

+ Self::ConstId(id) => id.into(),

+ Self::StaticId(id) => id.into(),

+ }

+ }

+}

+

+/// Build the declared type of an item. This depends on the namespace; e.g. for

+/// `struct Foo(usize)`, we have two types: The type of the struct itself, and

+/// the constructor function `(usize) -> Foo` which lives in the values

+/// namespace.

+pub(crate) fn ty_query<'db>(db: &'db dyn HirDatabase, def: TyDefId) -> EarlyBinder<'db, Ty<'db>> {

+ let interner = DbInterner::new_no_crate(db);

+ match def {

+ TyDefId::BuiltinType(it) => EarlyBinder::bind(Ty::from_builtin_type(interner, it)),

+ TyDefId::AdtId(it) => EarlyBinder::bind(Ty::new_adt(

+ interner,

+ it,

+ GenericArgs::identity_for_item(interner, it.into()),

+ )),

+ TyDefId::TypeAliasId(it) => db.type_for_type_alias_with_diagnostics(it).0,

+ }

+}

+

+/// Build the declared type of a function. This should not need to look at the

+/// function body.

+fn type_for_fn<'db>(db: &'db dyn HirDatabase, def: FunctionId) -> EarlyBinder<'db, Ty<'db>> {

+ let interner = DbInterner::new_no_crate(db);

+ EarlyBinder::bind(Ty::new_fn_def(

+ interner,

+ CallableDefId::FunctionId(def).into(),

+ GenericArgs::identity_for_item(interner, def.into()),

+ ))

+}

+

+/// Build the declared type of a const.

+fn type_for_const<'db>(db: &'db dyn HirDatabase, def: ConstId) -> EarlyBinder<'db, Ty<'db>> {

+ let resolver = def.resolver(db);

+ let data = db.const_signature(def);

+ let parent = def.loc(db).container;

+ let mut ctx = TyLoweringContext::new(

+ db,

+ &resolver,

+ &data.store,

+ def.into(),

+ LifetimeElisionKind::AnonymousReportError,

+ );

+ ctx.set_lifetime_elision(LifetimeElisionKind::for_const(ctx.interner, parent));

+ EarlyBinder::bind(ctx.lower_ty(data.type_ref))

+}

+

+/// Build the declared type of a static.

+fn type_for_static<'db>(db: &'db dyn HirDatabase, def: StaticId) -> EarlyBinder<'db, Ty<'db>> {

+ let resolver = def.resolver(db);

+ let data = db.static_signature(def);

+ let mut ctx = TyLoweringContext::new(

+ db,

+ &resolver,

+ &data.store,

+ def.into(),

+ LifetimeElisionKind::AnonymousReportError,

+ );

+ ctx.set_lifetime_elision(LifetimeElisionKind::Elided(Region::new_static(ctx.interner)));

+ EarlyBinder::bind(ctx.lower_ty(data.type_ref))

+/// Build the type of a tuple struct constructor.

+fn type_for_struct_constructor<'db>(

+ db: &'db dyn HirDatabase,

+ def: StructId,

+) -> Option<EarlyBinder<'db, Ty<'db>>> {

+ let struct_data = def.fields(db);

+ match struct_data.shape {

+ FieldsShape::Record => None,

+ FieldsShape::Unit => Some(type_for_adt(db, def.into())),

+ FieldsShape::Tuple => {

+ let interner = DbInterner::new_no_crate(db);

+ Some(EarlyBinder::bind(Ty::new_fn_def(

+ interner,

+ CallableDefId::StructId(def).into(),

+ GenericArgs::identity_for_item(interner, def.into()),

+ )))

+ }

+ }

+}

+

+/// Build the type of a tuple enum variant constructor.

+fn type_for_enum_variant_constructor<'db>(

+ db: &'db dyn HirDatabase,

+ def: EnumVariantId,

+) -> Option<EarlyBinder<'db, Ty<'db>>> {

+ let struct_data = def.fields(db);

+ match struct_data.shape {

+ FieldsShape::Record => None,

+ FieldsShape::Unit => Some(type_for_adt(db, def.loc(db).parent.into())),

+ FieldsShape::Tuple => {

+ let interner = DbInterner::new_no_crate(db);

+ Some(EarlyBinder::bind(Ty::new_fn_def(

+ interner,

+ CallableDefId::EnumVariantId(def).into(),

+ GenericArgs::identity_for_item(interner, def.loc(db).parent.into()),

+ )))

+ }

+ }

+}

+

+pub(crate) fn value_ty_query<'db>(

+ db: &'db dyn HirDatabase,

+ def: ValueTyDefId,

+) -> Option<EarlyBinder<'db, Ty<'db>>> {

+ match def {

+ ValueTyDefId::FunctionId(it) => Some(type_for_fn(db, it)),

+ ValueTyDefId::StructId(it) => type_for_struct_constructor(db, it),

+ ValueTyDefId::UnionId(it) => Some(type_for_adt(db, it.into())),

+ ValueTyDefId::EnumVariantId(it) => type_for_enum_variant_constructor(db, it),

+ ValueTyDefId::ConstId(it) => Some(type_for_const(db, it)),

+ ValueTyDefId::StaticId(it) => Some(type_for_static(db, it)),

+ }

+}

+

+pub(crate) fn type_for_type_alias_with_diagnostics_query<'db>(

+ db: &'db dyn HirDatabase,

+ t: TypeAliasId,

+) -> (EarlyBinder<'db, Ty<'db>>, Diagnostics) {

+ let type_alias_data = db.type_alias_signature(t);

+ let mut diags = None;

+ let resolver = t.resolver(db);

+ let interner = DbInterner::new_no_crate(db);

+ let inner = if type_alias_data.flags.contains(TypeAliasFlags::IS_EXTERN) {

+ EarlyBinder::bind(Ty::new_foreign(interner, t.into()))

+ } else {

+ let mut ctx = TyLoweringContext::new(

+ db,

+ &resolver,

+ &type_alias_data.store,

+ t.into(),

+ LifetimeElisionKind::AnonymousReportError,

+ )

+ .with_impl_trait_mode(ImplTraitLoweringMode::Opaque);

+ let res = EarlyBinder::bind(

+ type_alias_data

+ .ty

+ .map(|type_ref| ctx.lower_ty(type_ref))

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

+ );

+ diags = create_diagnostics(ctx.diagnostics);

+ res

+ };

+ (inner, diags)

+}

+

+pub(crate) fn type_for_type_alias_with_diagnostics_cycle_result<'db>(

+ db: &'db dyn HirDatabase,

+ _adt: TypeAliasId,

+) -> (EarlyBinder<'db, Ty<'db>>, Diagnostics) {

+ (EarlyBinder::bind(Ty::new_error(DbInterner::new_no_crate(db), ErrorGuaranteed)), None)

+}

+

+pub(crate) fn impl_self_ty_query<'db>(

+ db: &'db dyn HirDatabase,

+ impl_id: ImplId,

+) -> EarlyBinder<'db, Ty<'db>> {

+ db.impl_self_ty_with_diagnostics(impl_id).0

+}

+

+pub(crate) fn impl_self_ty_with_diagnostics_query<'db>(

+ db: &'db dyn HirDatabase,

+ impl_id: ImplId,

+) -> (EarlyBinder<'db, Ty<'db>>, Diagnostics) {

+ let resolver = impl_id.resolver(db);

+

+ let impl_data = db.impl_signature(impl_id);

+ let mut ctx = TyLoweringContext::new(

+ db,

+ &resolver,

+ &impl_data.store,

+ impl_id.into(),

+ LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true },

+ );

+ let ty = ctx.lower_ty(impl_data.self_ty);

+ assert!(!ty.has_escaping_bound_vars());

+ (EarlyBinder::bind(ty), create_diagnostics(ctx.diagnostics))

+}

+

+pub(crate) fn impl_self_ty_with_diagnostics_cycle_result(

+ _impl_id: ImplId,

+) -> (EarlyBinder<'_, Ty<'_>>, Diagnostics) {

+ (EarlyBinder::bind(Ty::new_error(DbInterner::new_no_crate(db), ErrorGuaranteed)), None)

+}

+

+pub(crate) fn const_param_ty_query<'db>(db: &'db dyn HirDatabase, def: ConstParamId) -> Ty<'db> {

+ db.const_param_ty_with_diagnostics(def).0

+}

+

+// returns None if def is a type arg

+pub(crate) fn const_param_ty_with_diagnostics_query<'db>(

+ db: &'db dyn HirDatabase,

+ def: ConstParamId,

+) -> (Ty<'db>, Diagnostics) {

+ let (parent_data, store) = db.generic_params_and_store(def.parent());

+ let data = &parent_data[def.local_id()];

+ let resolver = def.parent().resolver(db);

+ let interner = DbInterner::new_no_crate(db);

+ let mut ctx = TyLoweringContext::new(

+ db,

+ &resolver,

+ &store,

+ def.parent(),

+ LifetimeElisionKind::AnonymousReportError,

+ );

+ let ty = match data {

+ TypeOrConstParamData::TypeParamData(_) => {

+ never!();

+ Ty::new_error(interner, ErrorGuaranteed)

+ }

+ TypeOrConstParamData::ConstParamData(d) => ctx.lower_ty(d.ty),

+ };

+ (ty, create_diagnostics(ctx.diagnostics))

+}

+

+pub(crate) fn const_param_ty_with_diagnostics_cycle_result<'db>(

+ db: &'db dyn HirDatabase,

+ _: crate::db::HirDatabaseData,

+ _def: ConstParamId,

+) -> (Ty<'db>, Diagnostics) {

+ let interner = DbInterner::new_no_crate(db);

+ (Ty::new_error(interner, ErrorGuaranteed), None)

+}

+

+pub(crate) fn field_types_query<'db>(

+ db: &'db dyn HirDatabase,

+) -> Arc<ArenaMap<LocalFieldId, EarlyBinder<'db, Ty<'db>>>> {

+pub(crate) fn field_types_with_diagnostics_query<'db>(

+ db: &'db dyn HirDatabase,

+) -> (Arc<ArenaMap<LocalFieldId, EarlyBinder<'db, Ty<'db>>>>, Diagnostics) {

+ );

+ for (field_id, field_data) in var_data.fields().iter() {

+ res.insert(field_id, EarlyBinder::bind(ctx.lower_ty(field_data.type_ref)));

+#[tracing::instrument(skip(db), ret)]

+#[salsa::tracked(returns(ref), unsafe(non_update_return_type), cycle_result = generic_predicates_for_param_cycle_result)]

+pub(crate) fn generic_predicates_for_param<'db>(

+ db: &'db dyn HirDatabase,

+) -> EarlyBinder<'db, Box<[Clause<'db>]>> {

+ let interner = DbInterner::new_no_crate(db);

+ );

+ let predicate = |pred: &_, ctx: &mut TyLoweringContext<'_, '_>| match pred {

+ let Some(pointee_sized) = ctx.lang_items.PointeeSized else {

+ ctx.lower_where_predicate(pred, true, &generics, PredicateFilter::All)

+ .for_each(drop);

+ rustc_type_ir::elaborate::supertrait_def_ids(interner, tr.into()).any(|tr| {

+ tr.0.trait_items(db).items.iter().any(|(name, item)| {

+ predicates.extend(ctx.lower_where_predicate(

+ pred,

+ true,

+ maybe_parent_generics,

+ PredicateFilter::All,

+ ));

+ let args = GenericArgs::identity_for_item(interner, def.into());

+ if !args.is_empty() {

+ ctx.lang_items,

+ &args,

+ predicates.extend(implicitly_sized_predicates);

+ EarlyBinder::bind(predicates.into_boxed_slice())

+pub(crate) fn generic_predicates_for_param_cycle_result<'db>(

+ _db: &'db dyn HirDatabase,

+) -> EarlyBinder<'db, Box<[Clause<'db>]>> {

+ EarlyBinder::bind(Box::new([]))

+#[inline]

+pub(crate) fn type_alias_bounds<'db>(

+ db: &'db dyn HirDatabase,

+ type_alias: TypeAliasId,

+) -> EarlyBinder<'db, &'db [Clause<'db>]> {

+ type_alias_bounds_with_diagnostics(db, type_alias).0.as_ref().map_bound(|it| &**it)

+#[salsa::tracked(returns(ref), unsafe(non_update_return_type))]

+pub fn type_alias_bounds_with_diagnostics<'db>(

+ db: &'db dyn HirDatabase,

+ type_alias: TypeAliasId,

+) -> (EarlyBinder<'db, Box<[Clause<'db>]>>, Diagnostics) {

+ let type_alias_data = db.type_alias_signature(type_alias);

+ let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db);

+ &type_alias_data.store,

+ type_alias.into(),

+ );

+ let interner = ctx.interner;

+ let def_id = type_alias.into();

+ let item_args = GenericArgs::identity_for_item(interner, def_id);

+ let interner_ty = Ty::new_projection_from_args(interner, def_id, item_args);

+

+ let mut bounds = Vec::new();

+ for bound in &type_alias_data.bounds {

+ ctx.lower_type_bound(bound, interner_ty, false).for_each(|pred| {

+ bounds.push(pred);

+ });

+ if !ctx.unsized_types.contains(&interner_ty) {

+ let sized_trait = ctx.lang_items.Sized;

+ if let Some(sized_trait) = sized_trait {

+ let trait_ref = TraitRef::new_from_args(

+ interner,

+ sized_trait.into(),

+ GenericArgs::new_from_iter(interner, [interner_ty.into()]),

+ );

+ bounds.push(trait_ref.upcast(interner));

+ (EarlyBinder::bind(bounds.into_boxed_slice()), create_diagnostics(ctx.diagnostics))

+pub struct GenericPredicates<'db> {

+ // The order is the following: first, if `parent_is_trait == true`, comes the implicit trait predicate for the

+ // parent. Then come the explicit predicates for the parent, then the explicit trait predicate for the child,

+ // then the implicit trait predicate for the child, if `is_trait` is `true`.

+ predicates: EarlyBinder<'db, Box<[Clause<'db>]>>,

+ own_predicates_start: u32,

+ is_trait: bool,

+ parent_is_trait: bool,

+}

+

+#[salsa::tracked]

+impl<'db> GenericPredicates<'db> {

+ /// Resolve the where clause(s) of an item with generics.

+ ///

+ /// Diagnostics are computed only for this item's predicates, not for parents.

+ #[salsa::tracked(returns(ref), unsafe(non_update_return_type))]

+ pub fn query_with_diagnostics(

+ db: &'db dyn HirDatabase,

+ def: GenericDefId,

+ ) -> (GenericPredicates<'db>, Diagnostics) {

+ generic_predicates_filtered_by(db, def, PredicateFilter::All, |_| true)

+ }

+}

+

+impl<'db> GenericPredicates<'db> {

+ #[inline]

+ pub fn query(db: &'db dyn HirDatabase, def: GenericDefId) -> &'db GenericPredicates<'db> {

+ &Self::query_with_diagnostics(db, def).0

+ }

+

+ #[inline]

+ pub fn query_all(

+ db: &'db dyn HirDatabase,

+ def: GenericDefId,

+ ) -> EarlyBinder<'db, &'db [Clause<'db>]> {

+ Self::query(db, def).all_predicates()

+ }

+

+ #[inline]

+ pub fn query_own(

+ db: &'db dyn HirDatabase,

+ def: GenericDefId,

+ ) -> EarlyBinder<'db, &'db [Clause<'db>]> {

+ Self::query(db, def).own_predicates()

+ }

+ #[inline]

+ pub fn query_explicit(

+ db: &'db dyn HirDatabase,

+ def: GenericDefId,

+ ) -> EarlyBinder<'db, &'db [Clause<'db>]> {

+ Self::query(db, def).explicit_predicates()

+ }

+

+ #[inline]

+ pub fn all_predicates(&self) -> EarlyBinder<'db, &[Clause<'db>]> {

+ self.predicates.as_ref().map_bound(|it| &**it)

+ }

+ #[inline]

+ pub fn own_predicates(&self) -> EarlyBinder<'db, &[Clause<'db>]> {

+ self.predicates.as_ref().map_bound(|it| &it[self.own_predicates_start as usize..])

+ }

+

+ /// Returns the predicates, minus the implicit `Self: Trait` predicate for a trait.

+ #[inline]

+ pub fn explicit_predicates(&self) -> EarlyBinder<'db, &[Clause<'db>]> {

+ self.predicates.as_ref().map_bound(|it| {

+ &it[usize::from(self.parent_is_trait)..it.len() - usize::from(self.is_trait)]

+ })

+pub(crate) fn trait_environment_for_body_query(

+ def: DefWithBodyId,

+) -> Arc<TraitEnvironment<'_>> {

+ let Some(def) = def.as_generic_def_id(db) else {

+ let krate = def.module(db).krate();

+ return TraitEnvironment::empty(krate);

+ };

+ db.trait_environment(def)

+}

+

+pub(crate) fn trait_environment_query<'db>(

+ db: &'db dyn HirDatabase,

+) -> Arc<TraitEnvironment<'db>> {

+ let module = def.module(db);

+ let interner = DbInterner::new_with(db, module.krate());

+ let predicates = GenericPredicates::query_all(db, def);

+ let traits_in_scope = predicates

+ .iter_identity_copied()

+ .filter_map(|pred| match pred.kind().skip_binder() {

+ ClauseKind::Trait(tr) => Some((tr.self_ty(), tr.def_id().0)),

+ _ => None,

+ })

+ .collect();

+ let clauses = rustc_type_ir::elaborate::elaborate(interner, predicates.iter_identity_copied());

+ let clauses = Clauses::new_from_iter(interner, clauses);

+ let env = ParamEnv { clauses };

+

+ // FIXME: We should normalize projections here, like rustc does.

+

+ TraitEnvironment::new(module.krate(), module.containing_block(), traits_in_scope, env)

+}

+

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

+pub(crate) enum PredicateFilter {

+ SelfTrait,

+ All,

+#[tracing::instrument(skip(db, filter), ret)]

+pub(crate) fn generic_predicates_filtered_by<'db, F>(

+ db: &'db dyn HirDatabase,

+ predicate_filter: PredicateFilter,

+) -> (GenericPredicates<'db>, Diagnostics)

+ F: Fn(GenericDefId) -> bool,

+ let interner = DbInterner::new_no_crate(db);

+ );

+ let sized_trait = ctx.lang_items.Sized;

+ let all_generics =

+ .collect::<ArrayVec<_, 2>>();

+ let mut is_trait = false;

+ let mut parent_is_trait = false;

+ if all_generics.len() > 1 {

+ add_implicit_trait_predicate(

+ interner,

+ all_generics.last().unwrap().def(),

+ predicate_filter,

+ &mut predicates,

+ &mut parent_is_trait,

+ );

+ }

+ // We need to lower parent predicates first - see the comment below lowering of implicit `Sized` predicates

+ // for why.

+ let mut own_predicates_start = 0;

+ for &maybe_parent_generics in all_generics.iter().rev() {

+ let current_def_predicates_start = predicates.len();

+ // Collect only diagnostics from the child, not including parents.

+ ctx.diagnostics.clear();

+

+ if filter(maybe_parent_generics.def()) {

+ ctx.store = maybe_parent_generics.store();

+ for pred in maybe_parent_generics.where_predicates() {

+ tracing::debug!(?pred);

+ predicates.extend(ctx.lower_where_predicate(

+ pred,

+ false,

+ maybe_parent_generics,

+ predicate_filter,

+ ));

+ }

+

+ push_const_arg_has_type_predicates(db, &mut predicates, maybe_parent_generics);

+

+ if let Some(sized_trait) = sized_trait {

+ let mut add_sized_clause = |param_idx, param_id, param_data| {

+ let (

+ GenericParamId::TypeParamId(param_id),

+ GenericParamDataRef::TypeParamData(param_data),

+ ) = (param_id, param_data)

+ else {

+ return;

+ };

+

+ if param_data.provenance == TypeParamProvenance::TraitSelf {

+ return;

+ }

+

+ let param_ty = Ty::new_param(interner, param_id, param_idx);

+ if ctx.unsized_types.contains(&param_ty) {

+ return;

+ }

+ let trait_ref = TraitRef::new_from_args(

+ interner,

+ sized_trait.into(),

+ GenericArgs::new_from_iter(interner, [param_ty.into()]),

+ );

+ let clause = Clause(Predicate::new(

+ interner,

+ Binder::dummy(rustc_type_ir::PredicateKind::Clause(

+ rustc_type_ir::ClauseKind::Trait(TraitPredicate {

+ trait_ref,

+ polarity: rustc_type_ir::PredicatePolarity::Positive,

+ }),

+ )),

+ ));

+ predicates.push(clause);

+ };

+ let parent_params_len = maybe_parent_generics.len_parent();

+ maybe_parent_generics.iter_self().enumerate().for_each(

+ |(param_idx, (param_id, param_data))| {

+ add_sized_clause(

+ (param_idx + parent_params_len) as u32,

+ param_id,

+ param_data,

+ );

+ },

+

+ // We do not clear `ctx.unsized_types`, as the `?Sized` clause of a child (e.g. an associated type) can

+ // be declared on the parent (e.g. the trait). It is nevertheless fine to register the implicit `Sized`

+ // predicates before lowering the child, as a child cannot define a `?Sized` predicate for its parent.

+ // But we do have to lower the parent first.

+ }

+

+ if maybe_parent_generics.def() == def {

+ own_predicates_start = current_def_predicates_start as u32;

+ add_implicit_trait_predicate(interner, def, predicate_filter, &mut predicates, &mut is_trait);

+

+ let diagnostics = create_diagnostics(ctx.diagnostics);

+ let predicates = GenericPredicates {

+ own_predicates_start,

+ is_trait,

+ parent_is_trait,

+ predicates: EarlyBinder::bind(predicates.into_boxed_slice()),

+ };

+ return (predicates, diagnostics);

+

+ fn add_implicit_trait_predicate<'db>(

+ interner: DbInterner<'db>,

+ def: GenericDefId,

+ predicate_filter: PredicateFilter,

+ predicates: &mut Vec<Clause<'db>>,

+ set_is_trait: &mut bool,

+ ) {

+ // For traits, add `Self: Trait` predicate. This is

+ // not part of the predicates that a user writes, but it

+ // is something that one must prove in order to invoke a

+ // method or project an associated type.

+ //

+ // In the chalk setup, this predicate is not part of the

+ // "predicates" for a trait item. But it is useful in

+ // rustc because if you directly (e.g.) invoke a trait

+ // method like `Trait::method(...)`, you must naturally

+ // prove that the trait applies to the types that were

+ // used, and adding the predicate into this list ensures

+ // that this is done.

+ if let GenericDefId::TraitId(def_id) = def

+ && predicate_filter == PredicateFilter::All

+ *set_is_trait = true;

+ predicates.push(TraitRef::identity(interner, def_id.into()).upcast(interner));

+ }

+}

+fn push_const_arg_has_type_predicates<'db>(

+ db: &'db dyn HirDatabase,

+ predicates: &mut Vec<Clause<'db>>,

+ generics: &Generics,

+) {

+ let interner = DbInterner::new_no_crate(db);

+ let const_params_offset = generics.len_parent() + generics.len_lifetimes_self();

+ for (param_index, (param_idx, param_data)) in generics.iter_self_type_or_consts().enumerate() {

+ if !matches!(param_data, TypeOrConstParamData::ConstParamData(_)) {

+ continue;

+ }

+

+ let param_id = ConstParamId::from_unchecked(TypeOrConstParamId {

+ parent: generics.def(),

+ local_id: param_idx,

+ });

+ predicates.push(Clause(

+ ClauseKind::ConstArgHasType(

+ Const::new_param(

+ interner,

+ ParamConst { id: param_id, index: (param_index + const_params_offset) as u32 },

+ ),

+ db.const_param_ty_ns(param_id),

+ )

+ .upcast(interner),

+ ));

+ }

+fn implicitly_sized_clauses<'a, 'subst, 'db>(

+ lang_items: &LangItems,

+ explicitly_unsized_tys: &'a FxHashSet<Ty<'db>>,

+ args: &'subst GenericArgs<'db>,

+) -> Option<impl Iterator<Item = Clause<'db>> + Captures<'a> + Captures<'subst>> {

+ let interner = DbInterner::new_no_crate(db);

+ let sized_trait = lang_items.Sized?;

+ args.iter()

+ .filter_map(|generic_arg| generic_arg.as_type())

+ .filter(move |self_ty| !explicitly_unsized_tys.contains(self_ty))

+ let trait_ref = TraitRef::new_from_args(

+ interner,

+ sized_trait.into(),

+ GenericArgs::new_from_iter(interner, [self_ty.into()]),

+ );

+ Clause(Predicate::new(

+ interner,

+ Binder::dummy(rustc_type_ir::PredicateKind::Clause(

+ rustc_type_ir::ClauseKind::Trait(TraitPredicate {

+ trait_ref,

+ polarity: rustc_type_ir::PredicatePolarity::Positive,

+ }),

+ )),

+ ))

+pub struct GenericDefaults<'db>(Option<Arc<[Option<EarlyBinder<'db, GenericArg<'db>>>]>>);

+impl<'db> GenericDefaults<'db> {

+ #[inline]

+ pub fn get(&self, idx: usize) -> Option<EarlyBinder<'db, GenericArg<'db>>> {

+ self.0.as_ref()?[idx]

+pub(crate) fn generic_defaults_query(

+ db: &dyn HirDatabase,

+ def: GenericDefId,

+) -> GenericDefaults<'_> {

+) -> (GenericDefaults<'_>, Diagnostics) {

+ .with_impl_trait_mode(ImplTraitLoweringMode::Disallowed);

+ .map(|((_id, p), store)| {

+ let (result, has_default) = handle_generic_param(&mut ctx, idx, p);

+ defaults.extend(generic_params.iter_self().map(|(_id, p)| {

+ let (result, has_default) = handle_generic_param(&mut ctx, idx, p);

+ fn handle_generic_param<'db>(

+ ctx: &mut TyLoweringContext<'db, '_>,

+ ) -> (Option<EarlyBinder<'db, GenericArg<'db>>>, bool) {

+ ctx.lowering_param_default(idx as u32);

+ let ty = p.default.map(|ty| ctx.lower_ty(ty));

+ (ty.map(|ty| EarlyBinder::bind(ty.into())), p.default.is_some())

+ let val = p.default.map(|c| {

+ let param_ty = ctx.lower_ty(p.ty);

+ let c = ctx.lower_const(c, param_ty);

+ c.into()

+ });

+ (val.map(EarlyBinder::bind), p.default.is_some())

+ GenericParamDataRef::LifetimeParamData(_) => (None, false),

+) -> (GenericDefaults<'_>, Diagnostics) {

+/// Build the signature of a callable item (function, struct or enum variant).

+pub(crate) fn callable_item_signature_query<'db>(

+ db: &'db dyn HirDatabase,

+ def: CallableDefId,

+) -> EarlyBinder<'db, PolyFnSig<'db>> {

+ match def {

+ CallableDefId::FunctionId(f) => fn_sig_for_fn(db, f),

+ CallableDefId::StructId(s) => fn_sig_for_struct_constructor(db, s),

+ CallableDefId::EnumVariantId(e) => fn_sig_for_enum_variant_constructor(db, e),

+ }

+}

+

+fn fn_sig_for_fn<'db>(

+ db: &'db dyn HirDatabase,

+ def: FunctionId,

+) -> EarlyBinder<'db, PolyFnSig<'db>> {

+ let interner = DbInterner::new_no_crate(db);

+ );

+ LifetimeElisionKind::for_fn_ret(interner),

+ .with_impl_trait_mode(ImplTraitLoweringMode::Opaque);

+ None => Ty::new_tup(interner, &[]),

+ let inputs_and_output = Tys::new_from_iter(interner, params.chain(Some(ret)));

+ // If/when we track late bound vars, we need to switch this to not be `dummy`

+ EarlyBinder::bind(rustc_type_ir::Binder::dummy(FnSig {

+ abi: data.abi.as_ref().map_or(FnAbi::Rust, FnAbi::from_symbol),

+ c_variadic: data.is_varargs(),

+ safety: if data.is_unsafe() { Safety::Unsafe } else { Safety::Safe },

+ inputs_and_output,

+ }))

+fn type_for_adt<'db>(db: &'db dyn HirDatabase, adt: AdtId) -> EarlyBinder<'db, Ty<'db>> {

+ let interner = DbInterner::new_no_crate(db);

+ let args = GenericArgs::identity_for_item(interner, adt.into());

+ let ty = Ty::new_adt(interner, adt, args);

+ EarlyBinder::bind(ty)

+fn fn_sig_for_struct_constructor<'db>(

+ db: &'db dyn HirDatabase,

+ def: StructId,

+) -> EarlyBinder<'db, PolyFnSig<'db>> {

+ let params = field_tys.iter().map(|(_, ty)| ty.skip_binder());

+ let ret = type_for_adt(db, def.into()).skip_binder();

+

+ let inputs_and_output =

+ Tys::new_from_iter(DbInterner::new_no_crate(db), params.chain(Some(ret)));

+ EarlyBinder::bind(Binder::dummy(FnSig {

+ abi: FnAbi::RustCall,

+ c_variadic: false,

+ safety: Safety::Safe,

+ inputs_and_output,

+ }))

+fn fn_sig_for_enum_variant_constructor<'db>(

+ db: &'db dyn HirDatabase,

+ def: EnumVariantId,

+) -> EarlyBinder<'db, PolyFnSig<'db>> {

+ let params = field_tys.iter().map(|(_, ty)| ty.skip_binder());

+ let ret = type_for_adt(db, parent.into()).skip_binder();

+

+ let inputs_and_output =

+ Tys::new_from_iter(DbInterner::new_no_crate(db), params.chain(Some(ret)));

+ EarlyBinder::bind(Binder::dummy(FnSig {

+ abi: FnAbi::RustCall,

+ c_variadic: false,

+ safety: Safety::Safe,

+ inputs_and_output,

+ }))

+// FIXME(next-solver): should merge this with `explicit_item_bounds` in some way

+pub(crate) fn associated_ty_item_bounds<'db>(

+ db: &'db dyn HirDatabase,

+ type_alias: TypeAliasId,

+) -> EarlyBinder<'db, BoundExistentialPredicates<'db>> {

+ let type_alias_data = db.type_alias_signature(type_alias);

+ let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db);

+ let interner = DbInterner::new_no_crate(db);

+ let mut ctx = TyLoweringContext::new(

+ db,

+ &resolver,

+ &type_alias_data.store,

+ type_alias.into(),

+ LifetimeElisionKind::AnonymousReportError,

+ );

+ // FIXME: we should never create non-existential predicates in the first place

+ // For now, use an error type so we don't run into dummy binder issues

+ let self_ty = Ty::new_error(interner, ErrorGuaranteed);

+

+ let mut bounds = Vec::new();

+ for bound in &type_alias_data.bounds {

+ ctx.lower_type_bound(bound, self_ty, false).for_each(|pred| {

+ if let Some(bound) = pred

+ .kind()

+ .map_bound(|c| match c {

+ rustc_type_ir::ClauseKind::Trait(t) => {

+ let id = t.def_id();

+ let is_auto = db.trait_signature(id.0).flags.contains(TraitFlags::AUTO);

+ if is_auto {

+ Some(ExistentialPredicate::AutoTrait(t.def_id()))

+ } else {

+ Some(ExistentialPredicate::Trait(ExistentialTraitRef::new_from_args(

+ interner,

+ t.def_id(),

+ GenericArgs::new_from_iter(

+ interner,

+ t.trait_ref.args.iter().skip(1),

+ ),

+ )))

+ }

+ }

+ rustc_type_ir::ClauseKind::Projection(p) => Some(

+ ExistentialPredicate::Projection(ExistentialProjection::new_from_args(

+ interner,

+ p.def_id(),

+ GenericArgs::new_from_iter(

+ interner,

+ p.projection_term.args.iter().skip(1),

+ ),

+ p.term,

+ )),

+ ),

+ rustc_type_ir::ClauseKind::TypeOutlives(_) => None,

+ rustc_type_ir::ClauseKind::RegionOutlives(_)

+ | rustc_type_ir::ClauseKind::ConstArgHasType(_, _)

+ | rustc_type_ir::ClauseKind::WellFormed(_)

+ | rustc_type_ir::ClauseKind::ConstEvaluatable(_)

+ | rustc_type_ir::ClauseKind::HostEffect(_)

+ | rustc_type_ir::ClauseKind::UnstableFeature(_) => unreachable!(),

+ })

+ .transpose()

+ {

+ bounds.push(bound);

+ }

+ });

+ if !ctx.unsized_types.contains(&self_ty)

+ && let Some(sized_trait) = ctx.lang_items.Sized

+ {

+ let sized_clause = Binder::dummy(ExistentialPredicate::Trait(ExistentialTraitRef::new(

+ interner,

+ sized_trait.into(),

+ [] as [GenericArg<'_>; 0],

+ )));

+ bounds.push(sized_clause);

+ EarlyBinder::bind(BoundExistentialPredicates::new_from_iter(interner, bounds))

+pub(crate) fn associated_type_by_name_including_super_traits<'db>(

+ db: &'db dyn HirDatabase,

+ trait_ref: TraitRef<'db>,

+ name: &Name,

+) -> Option<(TraitRef<'db>, TypeAliasId)> {

+ let module = trait_ref.def_id.0.module(db);

+ let interner = DbInterner::new_with(db, module.krate());

+ rustc_type_ir::elaborate::supertraits(interner, Binder::dummy(trait_ref)).find_map(|t| {

+ let trait_id = t.as_ref().skip_binder().def_id.0;

+ let assoc_type = trait_id.trait_items(db).associated_type_by_name(name)?;

+ Some((t.skip_binder(), assoc_type))

+ })

+pub fn associated_type_shorthand_candidates(

+ def: GenericDefId,

+ res: TypeNs,

+ mut cb: impl FnMut(&Name, TypeAliasId) -> bool,

+) -> Option<TypeAliasId> {

+ let interner = DbInterner::new_no_crate(db);

+ named_associated_type_shorthand_candidates(interner, def, res, None, |name, _, id| {

+ cb(name, id).then_some(id)

+ })

+#[tracing::instrument(skip(interner, check_alias))]

+fn named_associated_type_shorthand_candidates<'db, R>(

+ interner: DbInterner<'db>,

+ // If the type parameter is defined in an impl and we're in a method, there

+ // might be additional where clauses to consider

+ def: GenericDefId,

+ res: TypeNs,

+ assoc_name: Option<Name>,

+ mut check_alias: impl FnMut(&Name, TraitRef<'db>, TypeAliasId) -> Option<R>,

+) -> Option<R> {

+ let db = interner.db;

+ let mut search = |t: TraitRef<'db>| -> Option<R> {

+ let mut checked_traits = FxHashSet::default();

+ let mut check_trait = |trait_ref: TraitRef<'db>| {

+ let trait_id = trait_ref.def_id.0;

+ let name = &db.trait_signature(trait_id).name;

+ tracing::debug!(?trait_id, ?name);

+ if !checked_traits.insert(trait_id) {

+ return None;

+ }

+ let data = trait_id.trait_items(db);

+ tracing::debug!(?data.items);

+ for (name, assoc_id) in &data.items {

+ if let &AssocItemId::TypeAliasId(alias) = assoc_id

+ && let Some(ty) = check_alias(name, trait_ref, alias)

+ {

+ return Some(ty);

+ }

+ }

+ None

+ };

+ let mut stack: SmallVec<[_; 4]> = smallvec![t];

+ while let Some(trait_ref) = stack.pop() {

+ if let Some(alias) = check_trait(trait_ref) {

+ return Some(alias);

+ }

+ for pred in generic_predicates_filtered_by(

+ db,

+ GenericDefId::TraitId(trait_ref.def_id.0),

+ PredicateFilter::SelfTrait,

+ // We are likely in the midst of lowering generic predicates of `def`.

+ // So, if we allow `pred == def` we might fall into an infinite recursion.

+ // Actually, we have already checked for the case `pred == def` above as we started

+ // with a stack including `trait_id`

+ |pred| pred != def && pred == GenericDefId::TraitId(trait_ref.def_id.0),

+ )

+ .0

+ .predicates

+ .instantiate_identity()

+ {

+ tracing::debug!(?pred);

+ let sup_trait_ref = match pred.kind().skip_binder() {

+ rustc_type_ir::ClauseKind::Trait(pred) => pred.trait_ref,

+ _ => continue,

+ };

+ let sup_trait_ref =

+ EarlyBinder::bind(sup_trait_ref).instantiate(interner, trait_ref.args);

+ stack.push(sup_trait_ref);

+ }

+ tracing::debug!(?stack);

+ };

+ match res {

+ TypeNs::SelfType(impl_id) => {

+ let trait_ref = db.impl_trait(impl_id)?;

+ // FIXME(next-solver): same method in `lower` checks for impl or not

+ // Is that needed here?

+ // we're _in_ the impl -- the binders get added back later. Correct,

+ // but it would be nice to make this more explicit

+ search(trait_ref.skip_binder())

+ }

+ TypeNs::GenericParam(param_id) => {

+ // Handle `Self::Type` referring to own associated type in trait definitions

+ // This *must* be done first to avoid cycles with

+ // `generic_predicates_for_param`, but not sure that it's sufficient,

+ if let GenericDefId::TraitId(trait_id) = param_id.parent() {

+ let trait_name = &db.trait_signature(trait_id).name;

+ tracing::debug!(?trait_name);

+ let trait_generics = generics(db, trait_id.into());

+ tracing::debug!(?trait_generics);

+ if trait_generics[param_id.local_id()].is_trait_self() {

+ let args = GenericArgs::identity_for_item(interner, trait_id.into());

+ let trait_ref = TraitRef::new_from_args(interner, trait_id.into(), args);

+ tracing::debug!(?args, ?trait_ref);

+ return search(trait_ref);

+ }

+

+ let predicates =

+ generic_predicates_for_param(db, def, param_id.into(), assoc_name.clone());

+ predicates

+ .as_ref()

+ .iter_identity_copied()

+ .find_map(|pred| match pred.kind().skip_binder() {

+ rustc_type_ir::ClauseKind::Trait(trait_predicate) => Some(trait_predicate),

+ _ => None,

+ })

+ .and_then(|trait_predicate| {

+ let trait_ref = trait_predicate.trait_ref;

+ assert!(

+ !trait_ref.has_escaping_bound_vars(),

+ "FIXME unexpected higher-ranked trait bound"

+ );

+ search(trait_ref)

+ })

+ }

+ _ => None,

+ }