//! A wrapper around [`TyLoweringContext`] specifically for lowering paths.

use either::Either;

use hir_def::{

expr_store::{

ExpressionStore, HygieneId,

},

hir::generics::{

GenericParamDataRef, TypeOrConstParamData, TypeParamData, TypeParamProvenance,

signatures::TraitFlags,

type_ref::{TypeRef, TypeRefId},

};

use smallvec::SmallVec;

use stdx::never;

use crate::{

consteval::{unknown_const, unknown_const_as_generic},

db::HirDatabase,

generics::{Generics, generics},

};

>;

// We cannot use `&mut dyn FnMut()` because of lifetime issues, and we don't want to use `Box<dyn FnMut()>`

// because of the allocation, so we create a lifetime-less callback, tailored for our needs.

}

path: &'a Path,

segments: PathSegments<'a>,

current_segment_idx: usize,

current_or_prev_segment: PathSegment<'a>,

}

#[inline]

pub(crate) fn new(

path: &'a Path,

) -> Self {

let segments = path.segments();

}

#[inline]

self.ctx

}

#[inline]

fn with_lifetime_elision<T>(

&mut self,

) -> T {

let old_lifetime_elision =

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

pub(crate) fn lower_ty_relative_path(

&mut self,

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

res: Option<TypeNs>,

infer_args: bool,

0 => (ty, res),

1 => {

// resolve unselected assoc types

}

_ => {

// FIXME report error (ambiguous associated type)

}

}

}

&mut self,

resolution: TypeNs,

infer_args: bool,

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

let ty = match resolution {

TypeNs::TraitId(trait_) => {

1 => {

let trait_ref = self.lower_trait_ref_from_resolved_path(

trait_,

);

self.skip_resolved_segment();

let segment = self.current_or_prev_segment;

let found =

match found {

Some(associated_ty) => {

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

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

let substitution = self.substs_from_path_segment(

associated_ty.into(),

None,

true,

);

);

}

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

}

let generics = self.ctx.generics();

}

}

}

TypeNs::AdtSelfType(adt) => {

}

TypeNs::AdtId(it) => self.lower_path_inner(it.into(), infer_args),

TypeNs::TypeAliasId(it) => self.lower_path_inner(it.into(), infer_args),

// FIXME: report error

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

}

};

self.skip_resolved_segment();

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

}

let mut prohibit_generics_on_resolved = |reason| {

if self.current_or_prev_segment.args_and_bindings.is_some() {

let segment = self.current_segment_u32();

prohibit_generics_on_resolved(GenericArgsProhibitedReason::TyParam)

}

TypeNs::AdtSelfType(_) => {

}

TypeNs::BuiltinType(_) => {

prohibit_generics_on_resolved(GenericArgsProhibitedReason::PrimitiveTy)

TypeNs::AdtId(_)

| TypeNs::EnumVariantId(_)

| TypeNs::TypeAliasId(_)

}

}

pub(crate) fn resolve_path_in_type_ns_fully(&mut self) -> Option<TypeNs> {

Some(res)

}

pub(crate) fn resolve_path_in_type_ns(&mut self) -> Option<(TypeNs, Option<usize>)> {

let (resolution, remaining_index, _, prefix_info) =

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

self.current_or_prev_segment =

segments.get(resolved_segment_idx).expect("should have resolved segment");

for (i, mod_segment) in module_segments.iter().enumerate() {

if mod_segment.args_and_bindings.is_some() {

self.on_diagnostic(PathLoweringDiagnostic::GenericArgsProhibited {

}

}

}

Some((resolution, remaining_index))

}

}

}

}

match &res {

match resolution {

ValueNs::ImplSelf(_) => {

}

// FIXME: rustc generates E0107 (incorrect number of generic arguments) and not

// E0109 (generic arguments provided for a type that doesn't accept them) for

}

}

ResolveValueResult::Partial(resolution, _, _) => {

}

};

Some(res)

}

let Some(res) = res else {

};

let segment = self.current_or_prev_segment;

}

let generic_def = match typeable {

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

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

};

}

/// Collect generic arguments from a path into a `Substs`. See also

resolved: ValueTyDefId,

infer_args: bool,

lowering_assoc_type_generics: bool,

let prev_current_segment_idx = self.current_segment_idx;

let prev_current_segment = self.current_or_prev_segment;

ValueTyDefId::StructId(it) => it.into(),

ValueTyDefId::UnionId(it) => it.into(),

ValueTyDefId::ConstId(it) => it.into(),

ValueTyDefId::EnumVariantId(var) => {

// the generic args for an enum variant may be either specified

// on the segment referring to the enum, or on the segment

// This simplifies the code a bit.

let penultimate_idx = self.current_segment_idx.wrapping_sub(1);

let penultimate = self.segments.get(penultimate_idx);

}

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

}

&mut self,

def: GenericDefId,

infer_args: bool,

lowering_assoc_type_generics: bool,

}

}

}

self.current_or_prev_segment.args_and_bindings,

def,

infer_args,

explicit_self_ty,

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

lowering_assoc_type_generics,

}

pub(super) fn substs_from_args_and_bindings(

&mut self,

def: GenericDefId,

infer_args: bool,

generics_source: PathGenericsSource,

lowering_assoc_type_generics: bool,

generics_source: PathGenericsSource,

}

fn report_len_mismatch(

&mut self,

def: GenericDefId,

&mut self,

param_id: GenericParamId,

param: GenericParamDataRef<'_>,

}

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

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

};

self.ctx

.ctx

}

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

}

fn provided_type_like_const(

&mut self,

arg: TypeLikeConst<'_>,

match arg {

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

TypeLikeConst::Infer => unknown_const(const_ty),

param_id: GenericParamId,

param: GenericParamDataRef<'_>,

infer_args: bool,

match param {

GenericParamDataRef::TypeParamData(param) => {

}

}

GenericParamDataRef::ConstParamData(param) => {

}

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

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

};

}

}

}

match param_id {

GenericParamId::ConstParamId(const_id) => {

}

}

}

pub(crate) fn lower_trait_ref_from_resolved_path(

&mut self,

resolved: TraitId,

infer_args: bool,

}

fn trait_ref_substs_from_path(

&mut self,

resolved: TraitId,

infer_args: bool,

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

}

pub(super) fn assoc_type_bindings_from_type_bound<'c>(

mut self,

self.current_or_prev_segment.args_and_bindings.map(|args_and_bindings| {

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

let found = associated_type_by_name_including_super_traits(

self.ctx.db,

&binding.name,

);

let (super_trait_ref, associated_ty) = match found {

None => return SmallVec::new(),

Some(t) => t,

};

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

binding.args.as_ref(),

associated_ty.into(),

false, // this is not relevant

PathGenericsSource::AssocType {

segment: this.current_segment_u32(),

assoc_type: binding_idx as u32,

this.ctx.lifetime_elision.clone(),

)

});

);

let mut predicates: SmallVec<[_; 1]> = SmallVec::with_capacity(

binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),

);

if let Some(type_ref) = binding.type_ref {

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

} else {

self.ctx.lifetime_elision.clone()

};

ImplTraitLoweringMode::Disallowed | ImplTraitLoweringMode::Opaque,

) => {

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

}

}

}

predicates

})

})

Path(&'a Path),

}

fn report_elided_lifetimes_in_path(

&mut self,

def: GenericDefId,

&mut self,

param_id: GenericParamId,

param: GenericParamDataRef<'_>,

fn inferred_kind(

&mut self,

param_id: GenericParamId,

param: GenericParamDataRef<'_>,

infer_args: bool,

}

/// Returns true if there was an error.

def: GenericDefId,

def_generics: &Generics,

infer_args: bool,

lowering_assoc_type_generics: bool,

) -> bool {

let mut had_error = false;

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

for arg in args_no_self {

match arg {

}

}

}

had_error

}

store: &ExpressionStore,

def: GenericDefId,

mut infer_args: bool,

lowering_assoc_type_generics: bool,

// Order is

// - Parent parameters

// - Optional Self parameter

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

let has_non_lifetime_args =

infer_args &= !has_non_lifetime_args;

let had_count_error = check_generic_args_len(

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 {

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

})

};

// input. We try to handle both sensibly.

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

(Some(&(arg_idx, arg)), Some(&(param_id, param))) => match (arg, 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

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

params.next();

}

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

args.next();

params.next();

}

(

GenericParamDataRef::LifetimeParamData(_),

) => {

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

params.next();

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

}

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

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

panic!("unmatching param kinds");

};

args.next();

params.next();

} else {

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

if !had_count_error {

assert!(

"the only possible situation here is incorrect lifetime order"

);

let (provided_arg_idx, param_id) =

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

}

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

}

LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false }

| LifetimeElisionKind::Infer => {

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

}

}

}

fn type_looks_like_const(

_ => None,

}

}