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

signatures::{FunctionSignature, TraitFlags, TypeAliasFlags},

type_ref::{

},

};

use hir_expand::name::Name;

use triomphe::{Arc, ThinArc};

use crate::{

consteval::intern_const_ref,

db::{HirDatabase, InternedOpaqueTyId},

generics::{Generics, generics, trait_self_param_idx},

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

pub struct ImplTrait {

pub(crate) predicates: StoredClauses,

}

pub type ImplTraitIdx = Idx<ImplTrait>;

}

}

pub enum LifetimeElisionKind<'db> {

/// Create a new anonymous lifetime parameter and reference it.

///

}

}

#[derive(Debug)]

pub struct TyLoweringContext<'db, 'a> {

pub db: &'db dyn HirDatabase,

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

}

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

TypeRef::DynTrait(bounds) => self.lower_dyn_trait(bounds),

TypeRef::ImplTrait(bounds) => {

match self.impl_trait_mode.mode {

// this dance is to make sure the data is in the right

// place even if we encounter more opaque types while

// lowering the bounds

let impl_trait_id = origin.either(

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

(ty, res)

}

/// This is only for `generic_predicates_for_param`, where we can't just

/// lower the self types of the predicates since that could lead to cycles.

/// So we just check here if the `type_ref` resolves to a generic param, and which.

ignore_bindings: bool,

generics: &Generics,

predicate_filter: PredicateFilter,

match where_predicate {

WherePredicate::ForLifetime { target, bound, .. }

| WherePredicate::TypeBound { target, bound } => {

let self_ty = self.lower_ty(*target);

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

}

self.interner,

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

rustc_type_ir::ClauseKind::RegionOutlives(OutlivesPredicate(

self.lower_lifetime(target),

)),

)),

}

.into_iter()

}

bound: &'b TypeBound,

self_ty: Ty<'db>,

ignore_bindings: bool,

let interner = self.interner;

let meta_sized = self.lang_items.MetaSized;

let pointee_sized = self.lang_items.PointeeSized;

}

TypeBound::Use(_) | TypeBound::Error => {}

}

}

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

for b in bounds {

let db = ctx.db;

match b.kind().skip_binder() {

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

let id = t.def_id();

rustc_type_ir::AliasTyKind::Opaque,

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

);

}

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

.expect("owner should have opaque type")

.get_with(|it| it.impl_traits[idx].predicates.as_ref().as_slice())

}

}

impl InternedOpaqueTyId {

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

self.loc(db).predicates(db)

}

}

#[salsa::tracked]

(res, create_diagnostics(ctx.diagnostics))

}

/// This query exists only to be used when resolving short-hand associated types

/// like `T::Item`.

///

/// See the analogous query in rustc and its comment:

/// <https://github.com/rust-lang/rust/blob/9150f844e2624eb013ec78ca08c1d416e6644026/src/librustc_typeck/astconv.rs#L46>

/// This is a query mostly to handle cycles somewhat gracefully; e.g. the

/// following bounds are disallowed: `T: Foo<U::Item>, U: Foo<T::Item>`, but

/// these are fine: `T: Foo<U::Item>, U: Foo<()>`.

);

// we have to filter out all other predicates *first*, before attempting to lower them

WherePredicate::ForLifetime { target, bound, .. }

| WherePredicate::TypeBound { target, bound, .. } => {

let invalid_target = { ctx.lower_ty_only_param(*target) != Some(param_id) };

return false;

};

}

TypeBound::Use(_) | TypeBound::Lifetime(_) | TypeBound::Error => false,

}

{

ctx.store = maybe_parent_generics.store();

for pred in maybe_parent_generics.where_predicates() {

}

}

}

StoredEarlyBinder::bind(Clauses::empty(DbInterner::new_no_crate(db)).store())

}

#[inline]

pub(crate) fn type_alias_bounds<'db>(

db: &'db dyn HirDatabase,

type_alias: TypeAliasId,

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

}

db: &'db dyn HirDatabase,

type_alias: TypeAliasId,

#[salsa::tracked(returns(ref))]

pub fn type_alias_bounds_with_diagnostics_query<'db>(

db: &'db dyn HirDatabase,

type_alias: TypeAliasId,

let type_alias_data = db.type_alias_signature(type_alias);

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

let mut ctx = TyLoweringContext::new(

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 {

}

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

};

}

(

create_diagnostics(ctx.diagnostics),

)

}

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

pub struct GenericPredicates {

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

predicates: StoredEarlyBinder<StoredClauses>,

own_predicates_start: u32,

is_trait: bool,

parent_is_trait: bool,

}

pub(crate) fn from_explicit_own_predicates(

predicates: StoredEarlyBinder<StoredClauses>,

) -> Self {

}

#[inline]

}

#[inline]

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

self.predicates.get().map_bound(|it| it.as_slice())

}

self.predicates.get().map_bound(|it| &it.as_slice()[self.own_predicates_start as usize..])

}

#[inline]

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

self.predicates.get().map_bound(|it| {

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

})

}

);

let sized_trait = ctx.lang_items.Sized;

let all_generics =

std::iter::successors(Some(&generics), |generics| generics.parent_generics())

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

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

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

ctx.diagnostics.clear();

ctx.store = maybe_parent_generics.store();

for pred in maybe_parent_generics.where_predicates() {

tracing::debug!(?pred);

}

if let Some(sized_trait) = sized_trait {

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

}),

)),

));

};

let parent_params_len = maybe_parent_generics.len_parent();

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

// 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.

}

}

let diagnostics = create_diagnostics(ctx.diagnostics);

let predicates = GenericPredicates {

own_predicates_start,

is_trait,

parent_is_trait,

predicates: StoredEarlyBinder::bind(Clauses::new_from_slice(&predicates).store()),

};

return (predicates, diagnostics);

interner: DbInterner<'db>,

def: GenericDefId,

predicate_filter: PredicateFilter,

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

if let GenericDefId::TraitId(def_id) = def

&& predicate_filter == PredicateFilter::All

{

}

}

}

let mut bounds = Vec::new();

for bound in &type_alias_data.bounds {

if let Some(bound) = pred

.kind()

.map_bound(|c| match c {