+use chalk_ir::{BoundVar, cast::Cast, fold::Shift};

+ GenericDefId, GenericParamId, Lookup, TraitId,

+ expr_store::{

+ ExpressionStore, HygieneId,

+ path::{GenericArg, GenericArgs, GenericArgsParentheses, Path, PathSegment, PathSegments},

+ },

+ hir::generics::{

+ GenericParamDataRef, TypeOrConstParamData, TypeParamData, TypeParamProvenance,

+ },

+ signatures::TraitFlags,

+ type_ref::{TypeRef, TypeRefId},

+ AliasEq, AliasTy, GenericArgsProhibitedReason, ImplTraitLoweringMode, IncorrectGenericsLenKind,

+ Interner, ParamLoweringMode, PathGenericsSource, PathLoweringDiagnostic, ProjectionTy,

+ QuantifiedWhereClause, Substitution, TraitRef, Ty, TyBuilder, TyDefId, TyKind,

+ TyLoweringContext, ValueTyDefId, WhereClause,

+ consteval::{unknown_const, unknown_const_as_generic},

+ db::HirDatabase,

+ generics::{Generics, generics},

+ lower::{LifetimeElisionKind, named_associated_type_shorthand_candidates},

+ static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,

+ #[inline]

+ fn with_lifetime_elision<T>(

+ &mut self,

+ lifetime_elision: LifetimeElisionKind,

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

+ ) -> T {

+ let old_lifetime_elision =

+ std::mem::replace(&mut self.ctx.lifetime_elision, lifetime_elision);

+ let result = f(self);

+ self.ctx.lifetime_elision = old_lifetime_elision;

+ result

+ }

+

+ infer_args: bool,

+ (self.select_associated_type(res, infer_args), None)

+ infer_args,

+ self.ctx.db.trait_items(trait_).associated_type_by_name(segment.name);

+ infer_args,

+ true,

+ trait_ref.substitution.iter(Interner).chain(

+ substitution

+ .iter(Interner)

+ .skip(trait_ref.substitution.len(Interner)),

+ ),

+ let idx = match self.ctx.generics().type_or_const_param_idx(param_id.into()) {

+ let generics = self.ctx.generics();

+ ParamLoweringMode::Variable => TyBuilder::impl_self_ty(self.ctx.db, impl_id)

+ .fill_with_bound_vars(self.ctx.in_binders, 0)

+ .build(),

+ let generics = generics(self.ctx.db, adt.into());

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

+ return (TyKind::Error.intern(Interner), None);

+ }

+ self.lower_ty_relative_path(ty, Some(resolution), infer_args)

+ TypeNs::ModuleId(_) => {

+ prohibit_generics_on_resolved(GenericArgsProhibitedReason::Module)

+ }

+ let (resolution, remaining_index, _, prefix_info) =

+ self.ctx.resolver.resolve_path_in_type_ns_with_prefix_info(self.ctx.db, self.path)?;

+ self.ctx.db,

+ ValueNs::GenericParam(_) => {

+ ValueNs::LocalBinding(_) => {

+ prohibit_generics_on_resolved(GenericArgsProhibitedReason::LocalVariable)

+ }

+ ValueNs::FunctionId(_)

+ | ValueNs::StructId(_)

+ | ValueNs::EnumVariantId(_)

+ | ValueNs::ConstId(_) => {}

+ fn select_associated_type(&mut self, res: Option<TypeNs>, infer_args: bool) -> Ty {

+ let Some(res) = res else {

+ self.ctx.def,

+ let generics = self.ctx.generics();

+ let substs =

+ self.substs_from_path_segment(associated_ty.into(), infer_args, None, true);

+ parent_subst

+ .iter(Interner)

+ .chain(substs.iter(Interner).skip(parent_subst.len(Interner))),

+ let substs = self.substs_from_path_segment(generic_def, infer_args, None, false);

+ lowering_assoc_type_generics: bool,

+ var.lookup(self.ctx.db).parent.into()

+ let result = self.substs_from_path_segment(

+ generic_def,

+ infer_args,

+ None,

+ lowering_assoc_type_generics,

+ );

+ lowering_assoc_type_generics: bool,

+ let mut lifetime_elision = self.ctx.lifetime_elision.clone();

+

+ if let Some(args) = self.current_or_prev_segment.args_and_bindings {

+ if args.parenthesized != GenericArgsParentheses::No {

+ let prohibit_parens = match def {

+ GenericDefId::TraitId(trait_) => {

+ // RTN is prohibited anyways if we got here.

+ let is_rtn =

+ args.parenthesized == GenericArgsParentheses::ReturnTypeNotation;

+ let is_fn_trait = self

+ .ctx

+ .db

+ .trait_signature(trait_)

+ .flags

+ .contains(TraitFlags::RUSTC_PAREN_SUGAR);

+ is_rtn || !is_fn_trait

+ }

+ _ => true,

+ };

+

+ if prohibit_parens {

+ let segment = self.current_segment_u32();

+ self.on_diagnostic(

+ PathLoweringDiagnostic::ParenthesizedGenericArgsWithoutFnTrait { segment },

+ );

+

+ return TyBuilder::unknown_subst(self.ctx.db, def);

+ }

+

+ // `Fn()`-style generics are treated like functions for the purpose of lifetime elision.

+ lifetime_elision =

+ LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false };

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

+ lowering_assoc_type_generics,

+ lifetime_elision,

+ generics_source: PathGenericsSource,

+ lowering_assoc_type_generics: bool,

+ lifetime_elision: LifetimeElisionKind,

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

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

+ generics_source: PathGenericsSource,

+ }

+

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

+ fn report_len_mismatch(

+ &mut self,

+ def: GenericDefId,

+ provided_count: u32,

+ expected_count: u32,

+ kind: IncorrectGenericsLenKind,

+ ) {

+ self.ctx.on_diagnostic(PathLoweringDiagnostic::IncorrectGenericsLen {

+ generics_source: self.generics_source,

+ provided_count,

+ expected_count,

+ kind,

+ def,

+ });

+ }

+

+ fn report_arg_mismatch(

+ &mut self,

+ param_id: GenericParamId,

+ arg_idx: u32,

+ has_self_arg: bool,

+ ) {

+ self.ctx.on_diagnostic(PathLoweringDiagnostic::IncorrectGenericsOrder {

+ generics_source: self.generics_source,

+ param_id,

+ arg_idx,

+ has_self_arg,

+ });

+ }

+

+ fn provided_kind(

+ &mut self,

+ param_id: GenericParamId,

+ param: GenericParamDataRef<'_>,

+ arg: &GenericArg,

+ ) -> crate::GenericArg {

+ match (param, arg) {

+ (GenericParamDataRef::LifetimeParamData(_), GenericArg::Lifetime(lifetime)) => {

+ self.ctx.ctx.lower_lifetime(*lifetime).cast(Interner)

+ }

+ (GenericParamDataRef::TypeParamData(_), GenericArg::Type(type_ref)) => {

+ self.ctx.ctx.lower_ty(*type_ref).cast(Interner)

+ }

+ (GenericParamDataRef::ConstParamData(_), GenericArg::Const(konst)) => {

+ let GenericParamId::ConstParamId(const_id) = param_id else {

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

+ };

+ self.ctx

+ .ctx

+ .lower_const(konst, self.ctx.ctx.db.const_param_ty(const_id))

+ .cast(Interner)

+ }

+ _ => unreachable!("unmatching param kinds were passed to `provided_kind()`"),

+

+ fn provided_type_like_const(

+ &mut self,

+ const_ty: Ty,

+ arg: TypeLikeConst<'_>,

+ ) -> crate::Const {

+ match arg {

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

+ TypeLikeConst::Infer => unknown_const(const_ty),

+ }

+ }

+

+ fn inferred_kind(

+ &mut self,

+ def: GenericDefId,

+ param_id: GenericParamId,

+ param: GenericParamDataRef<'_>,

+ infer_args: bool,

+ preceding_args: &[crate::GenericArg],

+ ) -> crate::GenericArg {

+ let default = || {

+ self.ctx

+ .ctx

+ .db

+ .generic_defaults(def)

+ .get(preceding_args.len())

+ .map(|default| default.clone().substitute(Interner, preceding_args))

+ };

+ match param {

+ GenericParamDataRef::LifetimeParamData(_) => error_lifetime().cast(Interner),

+ GenericParamDataRef::TypeParamData(param) => {

+ if !infer_args && param.default.is_some() {

+ if let Some(default) = default() {

+ return default;

+ }

+ }

+ TyKind::Error.intern(Interner).cast(Interner)

+ }

+ GenericParamDataRef::ConstParamData(param) => {

+ if !infer_args && param.default.is_some() {

+ if let Some(default) = default() {

+ return default;

+ }

+ }

+ let GenericParamId::ConstParamId(const_id) = param_id else {

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

+ };

+ unknown_const_as_generic(self.ctx.ctx.db.const_param_ty(const_id))

+ .cast(Interner)

+ fn parent_arg(&mut self, param_id: GenericParamId) -> crate::GenericArg {

+ match param_id {

+ GenericParamId::TypeParamId(_) => TyKind::Error.intern(Interner).cast(Interner),

+ GenericParamId::ConstParamId(const_id) => {

+ unknown_const_as_generic(self.ctx.ctx.db.const_param_ty(const_id))

+ }

+ GenericParamId::LifetimeParamId(_) => error_lifetime().cast(Interner),

+ }

+

+ fn report_elided_lifetimes_in_path(

+ &mut self,

+ def: GenericDefId,

+ expected_count: u32,

+ hard_error: bool,

+ ) {

+ self.ctx.on_diagnostic(PathLoweringDiagnostic::ElidedLifetimesInPath {

+ generics_source: self.generics_source,

+ def,

+ expected_count,

+ hard_error,

+ });

+ }

+

+ fn report_elision_failure(&mut self, def: GenericDefId, expected_count: u32) {

+ self.ctx.on_diagnostic(PathLoweringDiagnostic::ElisionFailure {

+ generics_source: self.generics_source,

+ def,

+ expected_count,

+ });

+ }

+

+ fn report_missing_lifetime(&mut self, def: GenericDefId, expected_count: u32) {

+ self.ctx.on_diagnostic(PathLoweringDiagnostic::MissingLifetime {

+ generics_source: self.generics_source,

+ def,

+ expected_count,

+ });

+ substs_from_args_and_bindings(

+ self.ctx.db,

+ self.ctx.store,

+ args_and_bindings,

+ def,

+ infer_args,

+ lifetime_elision,

+ lowering_assoc_type_generics,

+ explicit_self_ty,

+ &mut LowererCtx { ctx: self, generics_source },

+ )

+ infer_args: bool,

+ let substs = self.trait_ref_substs_from_path(resolved, explicit_self_ty, infer_args);

+ infer_args: bool,

+ self.substs_from_path_segment(resolved.into(), infer_args, Some(explicit_self_ty), false)

+ args_and_bindings.bindings.iter().enumerate().flat_map(move |(binding_idx, binding)| {

+ let substitution =

+ self.with_lifetime_elision(LifetimeElisionKind::AnonymousReportError, |this| {

+ // 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 (`super_trait_ref.substitution`).

+ this.substs_from_args_and_bindings(

+ binding.args.as_ref(),

+ associated_ty.into(),

+ false, // this is not relevant

+ Some(super_trait_ref.self_type_parameter(Interner)),

+ PathGenericsSource::AssocType {

+ segment: this.current_segment_u32(),

+ assoc_type: binding_idx as u32,

+ },

+ false,

+ this.ctx.lifetime_elision.clone(),

+ )

+ });

+ super_trait_ref.substitution.iter(Interner).chain(

+ substitution

+ .iter(Interner)

+ .skip(super_trait_ref.substitution.len(Interner)),

+ ),

+

+ let lifetime_elision =

+ if args_and_bindings.parenthesized == GenericArgsParentheses::ParenSugar {

+ // `Fn()`-style generics are elided like functions. This is `Output` (we lower to it in hir-def).

+ LifetimeElisionKind::for_fn_ret()

+ } else {

+ self.ctx.lifetime_elision.clone()

+ };

+ self.with_lifetime_elision(lifetime_elision, |this| {

+ match (&this.ctx.store[type_ref], this.ctx.impl_trait_mode.mode) {

+ (TypeRef::ImplTrait(_), ImplTraitLoweringMode::Disallowed) => (),

+ (

+ _,

+ ImplTraitLoweringMode::Disallowed | ImplTraitLoweringMode::Opaque,

+ ) => {

+ let ty = this.ctx.lower_ty(type_ref);

+ let alias_eq = AliasEq {

+ alias: AliasTy::Projection(projection_ty.clone()),

+ ty,

+ };

+ predicates.push(crate::wrap_empty_binders(WhereClause::AliasEq(

+ alias_eq,

+ )));

+ }

+ });

+

+ self.with_lifetime_elision(LifetimeElisionKind::AnonymousReportError, |this| {

+ for bound in binding.bounds.iter() {

+ predicates.extend(

+ this.ctx.lower_type_bound(

+ bound,

+ TyKind::Alias(AliasTy::Projection(projection_ty.clone()))

+ .intern(Interner),

+ false,

+ ),

+ );

+ }

+ });

+

+

+/// A const that were parsed like a type.

+pub(crate) enum TypeLikeConst<'a> {

+ Infer,

+ Path(&'a Path),

+}

+

+pub(crate) trait GenericArgsLowerer {

+ fn report_elided_lifetimes_in_path(

+ &mut self,

+ def: GenericDefId,

+ expected_count: u32,

+ hard_error: bool,

+ );

+

+ fn report_elision_failure(&mut self, def: GenericDefId, expected_count: u32);

+

+ fn report_missing_lifetime(&mut self, def: GenericDefId, expected_count: u32);

+

+ fn report_len_mismatch(

+ &mut self,

+ def: GenericDefId,

+ provided_count: u32,

+ expected_count: u32,

+ kind: IncorrectGenericsLenKind,

+ );

+

+ fn report_arg_mismatch(&mut self, param_id: GenericParamId, arg_idx: u32, has_self_arg: bool);

+

+ fn provided_kind(

+ &mut self,

+ param_id: GenericParamId,

+ param: GenericParamDataRef<'_>,

+ arg: &GenericArg,

+ ) -> crate::GenericArg;

+

+ fn provided_type_like_const(&mut self, const_ty: Ty, arg: TypeLikeConst<'_>) -> crate::Const;

+

+ fn inferred_kind(

+ &mut self,

+ def: GenericDefId,

+ param_id: GenericParamId,

+ param: GenericParamDataRef<'_>,

+ infer_args: bool,

+ preceding_args: &[crate::GenericArg],

+ ) -> crate::GenericArg;

+

+ fn parent_arg(&mut self, param_id: GenericParamId) -> crate::GenericArg;

+}

+

+/// Returns true if there was an error.

+fn check_generic_args_len(

+ args_and_bindings: Option<&GenericArgs>,

+ def: GenericDefId,

+ def_generics: &Generics,

+ infer_args: bool,

+ lifetime_elision: &LifetimeElisionKind,

+ lowering_assoc_type_generics: bool,

+ ctx: &mut impl GenericArgsLowerer,

+) -> bool {

+ let mut had_error = false;

+

+ let (mut provided_lifetimes_count, mut provided_types_and_consts_count) = (0usize, 0usize);

+ if let Some(args_and_bindings) = args_and_bindings {

+ let args_no_self = &args_and_bindings.args[usize::from(args_and_bindings.has_self_type)..];

+ for arg in args_no_self {

+ match arg {

+ GenericArg::Lifetime(_) => provided_lifetimes_count += 1,

+ GenericArg::Type(_) | GenericArg::Const(_) => provided_types_and_consts_count += 1,

+ }

+ }

+ }

+

+ let lifetime_args_len = def_generics.len_lifetimes_self();

+ if provided_lifetimes_count == 0 && lifetime_args_len > 0 && !lowering_assoc_type_generics {

+ // In generic associated types, we never allow inferring the lifetimes.

+ match lifetime_elision {

+ &LifetimeElisionKind::AnonymousCreateParameter { report_in_path } => {

+ ctx.report_elided_lifetimes_in_path(def, lifetime_args_len as u32, report_in_path);

+ had_error |= report_in_path;

+ }

+ LifetimeElisionKind::AnonymousReportError => {

+ ctx.report_missing_lifetime(def, lifetime_args_len as u32);

+ had_error = true

+ }

+ LifetimeElisionKind::ElisionFailure => {

+ ctx.report_elision_failure(def, lifetime_args_len as u32);

+ had_error = true;

+ }

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

+ // FIXME: Check there are other lifetimes in scope, and error/lint.

+ }

+ LifetimeElisionKind::Elided(_) => {

+ ctx.report_elided_lifetimes_in_path(def, lifetime_args_len as u32, false);

+ }

+ LifetimeElisionKind::Infer => {

+ // Allow eliding lifetimes.

+ }

+ }

+ } else if lifetime_args_len != provided_lifetimes_count {

+ ctx.report_len_mismatch(

+ def,

+ provided_lifetimes_count as u32,

+ lifetime_args_len as u32,

+ IncorrectGenericsLenKind::Lifetimes,

+ );

+ had_error = true;

+ }

+

+ let defaults_count =

+ def_generics.iter_self_type_or_consts().filter(|(_, param)| param.has_default()).count();

+ let named_type_and_const_params_count = def_generics

+ .iter_self_type_or_consts()

+ .filter(|(_, param)| match param {

+ TypeOrConstParamData::TypeParamData(param) => {

+ param.provenance == TypeParamProvenance::TypeParamList

+ }

+ TypeOrConstParamData::ConstParamData(_) => true,

+ })

+ .count();

+ let expected_max = named_type_and_const_params_count;

+ let expected_min =

+ if infer_args { 0 } else { named_type_and_const_params_count - defaults_count };

+ if provided_types_and_consts_count < expected_min

+ || expected_max < provided_types_and_consts_count

+ {

+ ctx.report_len_mismatch(

+ def,

+ provided_types_and_consts_count as u32,

+ named_type_and_const_params_count as u32,

+ IncorrectGenericsLenKind::TypesAndConsts,

+ );

+ had_error = true;

+ }

+

+ had_error

+}

+

+pub(crate) fn substs_from_args_and_bindings(

+ db: &dyn HirDatabase,

+ store: &ExpressionStore,

+ args_and_bindings: Option<&GenericArgs>,

+ def: GenericDefId,

+ mut infer_args: bool,

+ lifetime_elision: LifetimeElisionKind,

+ lowering_assoc_type_generics: bool,

+ explicit_self_ty: Option<Ty>,

+ ctx: &mut impl GenericArgsLowerer,

+) -> Substitution {

+ // Order is

+ // - Parent parameters

+ // - Optional Self parameter

+ // - Lifetime parameters

+ // - Type or Const parameters

+ let def_generics = generics(db, def);

+ let args_slice = args_and_bindings.map(|it| &*it.args).unwrap_or_default();

+

+ // We do not allow inference if there are specified args, i.e. we do not allow partial inference.

+ let has_non_lifetime_args =

+ args_slice.iter().any(|arg| !matches!(arg, GenericArg::Lifetime(_)));

+ infer_args &= !has_non_lifetime_args;

+

+ let had_count_error = check_generic_args_len(

+ args_and_bindings,

+ def,

+ &def_generics,

+ infer_args,

+ &lifetime_elision,

+ lowering_assoc_type_generics,

+ ctx,

+ );

+

+ let mut substs = Vec::with_capacity(def_generics.len());

+

+ substs.extend(def_generics.iter_parent_id().map(|id| ctx.parent_arg(id)));

+

+ let mut args = args_slice.iter().enumerate().peekable();

+ let mut params = def_generics.iter_self().peekable();

+

+ // If we encounter a type or const when we expect a lifetime, we infer the lifetimes.

+ // If we later encounter a lifetime, we know that the arguments were provided in the

+ // wrong order. `force_infer_lt` records the type or const that forced lifetimes to be

+ // inferred, so we can use it for diagnostics later.

+ let mut force_infer_lt = None;

+

+ let has_self_arg = args_and_bindings.is_some_and(|it| it.has_self_type);

+ // First, handle `Self` parameter. Consume it from the args if provided, otherwise from `explicit_self_ty`,

+ // and lastly infer it.

+ if let Some(&(

+ self_param_id,

+ self_param @ GenericParamDataRef::TypeParamData(TypeParamData {

+ provenance: TypeParamProvenance::TraitSelf,

+ ..

+ }),

+ )) = params.peek()

+ {

+ let self_ty = if has_self_arg {

+ let (_, self_ty) = args.next().expect("has_self_type=true, should have Self type");

+ ctx.provided_kind(self_param_id, self_param, self_ty)

+ } else {

+ explicit_self_ty.map(|it| it.cast(Interner)).unwrap_or_else(|| {

+ ctx.inferred_kind(def, self_param_id, self_param, infer_args, &substs)

+ })

+ };

+ params.next();

+ substs.push(self_ty);

+ }

+

+ loop {

+ // We're going to iterate through the generic arguments that the user

+ // provided, matching them with the generic parameters we expect.

+ // Mismatches can occur as a result of elided lifetimes, or for malformed

+ // input. We try to handle both sensibly.

+ match (args.peek(), params.peek()) {

+ (Some(&(arg_idx, arg)), Some(&(param_id, param))) => match (arg, param) {

+ (GenericArg::Type(_), GenericParamDataRef::TypeParamData(type_param))

+ if type_param.provenance == TypeParamProvenance::ArgumentImplTrait =>

+ {

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

+ substs.push(ctx.inferred_kind(def, param_id, param, infer_args, &substs));

+ params.next();

+ }

+ (GenericArg::Lifetime(_), GenericParamDataRef::LifetimeParamData(_))

+ | (GenericArg::Type(_), GenericParamDataRef::TypeParamData(_))

+ | (GenericArg::Const(_), GenericParamDataRef::ConstParamData(_)) => {

+ substs.push(ctx.provided_kind(param_id, param, arg));

+ args.next();

+ params.next();

+ }

+ (

+ GenericArg::Type(_) | GenericArg::Const(_),

+ GenericParamDataRef::LifetimeParamData(_),

+ ) => {

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

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

+ substs.push(ctx.inferred_kind(def, param_id, param, infer_args, &substs));

+ params.next();

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

+ }

+ (GenericArg::Type(type_ref), GenericParamDataRef::ConstParamData(_)) => {

+ if let Some(konst) = type_looks_like_const(store, *type_ref) {

+ let GenericParamId::ConstParamId(param_id) = param_id else {

+ panic!("unmatching param kinds");

+ };

+ let const_ty = db.const_param_ty(param_id);

+ substs.push(ctx.provided_type_like_const(const_ty, konst).cast(Interner));

+ args.next();

+ params.next();

+ } else {

+ // See the `_ => { ... }` branch.

+ if !had_count_error {

+ ctx.report_arg_mismatch(param_id, arg_idx as u32, has_self_arg);

+ }

+ while args.next().is_some() {}

+ }

+ }

+ _ => {

+ // We expected one kind of parameter, but the user provided

+ // another. This is an error. However, if we already know that

+ // the arguments don't match up with the parameters, we won't issue

+ // an additional error, as the user already knows what's wrong.

+ if !had_count_error {

+ ctx.report_arg_mismatch(param_id, arg_idx as u32, has_self_arg);

+ }

+

+ // We've reported the error, but we want to make sure that this

+ // problem doesn't bubble down and create additional, irrelevant

+ // errors. In this case, we're simply going to ignore the argument

+ // and any following arguments. The rest of the parameters will be

+ // inferred.

+ while args.next().is_some() {}

+ }

+ },

+

+ (Some(&(_, arg)), None) => {

+ // We should never be able to reach this point with well-formed input.

+ // There are two situations in which we can encounter this issue.

+ //

+ // 1. The number of arguments is incorrect. In this case, an error

+ // will already have been emitted, and we can ignore it.

+ // 2. We've inferred some lifetimes, which have been provided later (i.e.

+ // after a type or const). We want to throw an error in this case.

+ if !had_count_error {

+ assert!(

+ matches!(arg, GenericArg::Lifetime(_)),

+ "the only possible situation here is incorrect lifetime order"

+ );

+ let (provided_arg_idx, param_id) =

+ force_infer_lt.expect("lifetimes ought to have been inferred");

+ ctx.report_arg_mismatch(param_id, provided_arg_idx, has_self_arg);

+ }

+

+ break;

+ }

+

+ (None, Some(&(param_id, param))) => {

+ // If there are fewer arguments than parameters, it means we're inferring the remaining arguments.

+ let param = if let GenericParamId::LifetimeParamId(_) = param_id {

+ match &lifetime_elision {

+ LifetimeElisionKind::ElisionFailure

+ | LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true }

+ | LifetimeElisionKind::AnonymousReportError => {

+ assert!(had_count_error);

+ ctx.inferred_kind(def, param_id, param, infer_args, &substs)

+ }

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

+ static_lifetime().cast(Interner)

+ }

+ LifetimeElisionKind::Elided(lifetime) => lifetime.clone().cast(Interner),

+ LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false }

+ | 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).

+ ctx.inferred_kind(def, param_id, param, infer_args, &substs)

+ }

+ }

+ } else {

+ ctx.inferred_kind(def, param_id, param, infer_args, &substs)

+ };

+ substs.push(param);

+ params.next();

+ }

+

+ (None, None) => break,

+ }

+ }

+

+ Substitution::from_iter(Interner, substs)

+}

+

+fn type_looks_like_const(

+ store: &ExpressionStore,

+ type_ref: TypeRefId,

+) -> Option<TypeLikeConst<'_>> {

+ // A path/`_` const will be parsed as a type, instead of a const, because when parsing/lowering

+ // in hir-def we don't yet know the expected argument kind. rustc does this a bit differently,

+ // when lowering to HIR it resolves the path, and if it doesn't resolve to the type namespace

+ // it is lowered as a const. Our behavior could deviate from rustc when the value is resolvable

+ // in both the type and value namespaces, but I believe we only allow more code.

+ let type_ref = &store[type_ref];

+ match type_ref {

+ TypeRef::Path(path) => Some(TypeLikeConst::Path(path)),

+ TypeRef::Placeholder => Some(TypeLikeConst::Infer),

+ _ => None,

+ }

+}