use crate::{

GenericArgsProhibitedReason, IncorrectGenericsLenKind, PathGenericsSource,

db::HirDatabase,

generics::{Generics, generics},

lower::{

AssocTypeShorthandResolution, ForbidParamsAfterReason, GenericPredicateSource,

LifetimeElisionKind, PathDiagnosticCallbackData, const_param_ty,

}

}

#[inline]

#[cold]

fn on_diagnostic(&mut self, diag: PathLoweringDiagnostic) {

// We need the original resolution to lower `Self::AssocTy` correctly

res: Option<TypeNs>,

infer_args: bool,

) -> (Ty<'db>, Option<TypeNs>) {

let remaining_segments = self.segments.len() - self.current_segment_idx;

match remaining_segments {

0 => (ty, res),

1 => {

// resolve unselected assoc types

}

_ => {

// FIXME report error (ambiguous associated type)

}

}

}

&mut self,

resolution: TypeNs,

infer_args: bool,

) -> (Ty<'db>, Option<TypeNs>) {

let remaining_segments = self.segments.skip(self.current_segment_idx + 1);

tracing::debug!(?remaining_segments);

1 => {

let trait_ref = self.lower_trait_ref_from_resolved_path(

trait_,

infer_args,

);

tracing::debug!(?trait_ref);

self.skip_resolved_segment();

infer_args,

None,

true,

);

let args = GenericArgs::new_from_iter(

self.ctx.interner,

}

None => {

// FIXME: report error (associated type not found)

}

}

}

// Trait object type without dyn; this should be handled in upstream. See

// `lower_path()`.

stdx::never!("unexpected fully resolved trait path");

}

_ => {

// FIXME report error (ambiguous associated type)

}

};

return (ty, None);

Ty::new_adt(self.ctx.interner, adt, args)

}

// FIXME: report error

TypeNs::EnumVariantId(_) | TypeNs::ModuleId(_) => {

}

};

tracing::debug!(?ty);

self.skip_resolved_segment();

}

/// This returns whether to keep the resolution (`true`) of throw it (`false`).

}

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

let interner = self.ctx.interner;

let db = self.ctx.db;

let def = self.ctx.generic_def;

let segment = self.current_or_prev_segment;

let assoc_name = segment.name;

let (assoc_type, trait_args) = match res {

Some(TypeNs::GenericParam(param)) => {

let AssocTypeShorthandResolution::Resolved(assoc_type) =

)

else {

// FIXME: Emit an error.

};

assoc_type

.get_with(|(assoc_type, trait_args)| (*assoc_type, trait_args.as_ref()))

}

Some(TypeNs::SelfType(impl_)) => {

let Some(impl_trait) = db.impl_trait(impl_) else {

};

let impl_trait = impl_trait.instantiate_identity().skip_norm_wip();

// Searching for `Self::Assoc` in `impl Trait for Type` is like searching for `Self::Assoc` in `Trait`.

)

else {

// FIXME: Emit an error.

};

let (assoc_type, trait_args) = assoc_type

.get_with(|(assoc_type, trait_args)| (*assoc_type, trait_args.as_ref()))

.skip_norm_wip(),

)

}

};

// FIXME: `substs_from_path_segment()` pushes `TyKind::Error` for every parent

// generic params. It's inefficient to splice the `Substitution`s, so we may want

// that method to optionally take parent `Substitution` as we already know them at

// this point (`t.substitution`).

let substs = GenericArgs::new_from_iter(

interner,

Ty::new_projection_from_args(interner, assoc_type.into(), substs)

}

let generic_def = match typeable {

TyDefId::BuiltinType(builtinty) => {

return Ty::from_builtin_type(self.ctx.interner, builtinty);

TyDefId::AdtId(it) => it.into(),

TyDefId::TypeAliasId(it) => it.into(),

};

let ty = ty_query(self.ctx.db, typeable);

ty.instantiate(self.ctx.interner, args).skip_norm_wip()

}

resolved: ValueTyDefId,

infer_args: bool,

lowering_assoc_type_generics: bool,

) -> GenericArgs<'db> {

let interner = self.ctx.interner;

let prev_current_segment_idx = self.current_segment_idx;

infer_args,

None,

lowering_assoc_type_generics,

);

self.current_segment_idx = prev_current_segment_idx;

self.current_or_prev_segment = prev_current_segment;

infer_args: bool,

explicit_self_ty: Option<Ty<'db>>,

lowering_assoc_type_generics: bool,

) -> GenericArgs<'db> {

let old_lifetime_elision = self.ctx.lifetime_elision;

PathGenericsSource::Segment(self.current_segment_u32()),

lowering_assoc_type_generics,

self.ctx.lifetime_elision,

);

self.ctx.lifetime_elision = old_lifetime_elision;

result

generics_source: PathGenericsSource,

lowering_assoc_type_generics: bool,

lifetime_elision: LifetimeElisionKind<'db>,

) -> GenericArgs<'db> {

struct LowererCtx<'a, 'b, 'c, 'db> {

ctx: &'a mut PathLoweringContext<'b, 'c, 'db>,

generics_source: PathGenericsSource,

}

impl<'db> GenericArgsLowerer<'db> for LowererCtx<'_, '_, '_, 'db> {

fn provided_type_like_const(

&mut self,

const_ty: Ty<'db>,

arg: TypeLikeConst<'_>,

) -> Const<'db> {

match arg {

TypeLikeConst::Path(path) => self.ctx.ctx.lower_path_as_const(path, const_ty),

}

}

param: GenericParamDataRef<'_>,

infer_args: bool,

preceding_args: &[GenericArg<'db>],

) -> GenericArg<'db> {

let default = || {

self.ctx.ctx.db.generic_defaults(def).get(preceding_args.len()).map(|default| {

default.instantiate(self.ctx.ctx.interner, preceding_args).skip_norm_wip()

})

};

match param {

GenericParamDataRef::LifetimeParamData(_) => {

}

GenericParamDataRef::TypeParamData(param) => {

if !infer_args

{

return default;

}

}

GenericParamDataRef::ConstParamData(param) => {

if !infer_args

{

return default;

}

unreachable!("non-const param ID for const param");

};

}

}

}

GenericParamId::TypeParamId(_) => {

Ty::new_error(self.ctx.ctx.interner, ErrorGuaranteed).into()

}

}

}

lifetime_elision,

lowering_assoc_type_generics,

explicit_self_ty,

)

}

resolved: TraitId,

explicit_self_ty: Ty<'db>,

infer_args: bool,

) -> TraitRef<'db> {

TraitRef::new_from_args(self.ctx.interner, resolved.into(), args)

}

resolved: TraitId,

explicit_self_ty: Ty<'db>,

infer_args: bool,

) -> GenericArgs<'db> {

}

pub(super) fn assoc_type_bindings_from_type_bound<'c>(

mut self,

trait_ref: TraitRef<'db>,

) -> Option<impl Iterator<Item = (Clause<'db>, GenericPredicateSource)> + use<'a, 'b, 'c, 'db>>

{

let interner = self.ctx.interner;

},

false,

this.ctx.lifetime_elision,

)

});

let args = GenericArgs::new_from_iter(

param: GenericParamDataRef<'_>,

infer_args: bool,

preceding_args: &[GenericArg<'db>],

) -> GenericArg<'db>;

fn parent_arg(&mut self, param_idx: u32, param_id: GenericParamId) -> GenericArg<'db>;

ctx.provided_kind(self_param_id, self_param, self_ty)

} else {

explicit_self_ty.map(|it| it.into()).unwrap_or_else(|| {

})

};

params.next();

{

// Do not allow specifying `impl Trait` explicitly. We already err at that, but if we won't handle it here

// we will handle it as if it was specified, instead of inferring it.

params.next();

}

(HirGenericArg::Lifetime(_), GenericParamDataRef::LifetimeParamData(_))

) => {

// We expected a lifetime argument, but got a type or const

// argument. That means we're inferring the lifetime.

params.next();

force_infer_lt = Some((arg_idx as u32, param_id));

}

| LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true }

| LifetimeElisionKind::AnonymousReportError => {

assert!(had_count_error);

}

LifetimeElisionKind::StaticIfNoLifetimeInScope { only_lint: _ } => {

Region::new_static(interner).into()

| LifetimeElisionKind::Infer => {

// FIXME: With `AnonymousCreateParameter`, we need to create a new lifetime parameter here

// (but this will probably be done in hir-def lowering instead).

}

}

} else {

};

substs.push(param);

params.next();