+ GenericParamId::TypeParamId(it) => it.parent(),

+ GenericParamId::ConstParamId(it) => it.parent(),

+ generics::{

+ TypeOrConstParamData, TypeParamProvenance, WherePredicate, WherePredicateTypeTarget,

+ },

+ LifetimeParam, Module, Static, Struct, Trait, TyBuilder, Type, TypeAlias, TypeOrConstParam,

+ TypeParam, Union, Variant,

+ GenericParam::LifetimeParam(it) => it.hir_fmt(f),

+ }

+ }

+}

+

+impl HirDisplay for TypeOrConstParam {

+ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {

+ match self.split(f.db) {

+ either::Either::Left(x) => x.hir_fmt(f),

+ either::Either::Right(x) => x.hir_fmt(f),

+ let bounds = f.db.generic_predicates_for_param(self.id.parent(), self.id.into(), None);

+ let substs = TyBuilder::type_params_subst(f.db, self.id.parent());

+ let krate = self.id.parent().krate(f.db).id;

+ .filter_map(|x| x.1.type_param())

+ .all(|param| !matches!(param.provenance, TypeParamProvenance::TypeParamList))

+ if let Some(name) = &ty.name() {

+ match ty {

+ TypeOrConstParamData::TypeParamData(ty) => {

+ if ty.provenance != TypeParamProvenance::TypeParamList {

+ continue;

+ }

+ delim(f)?;

+ write!(f, "{}", name)?;

+ if let Some(default) = &ty.default {

+ write!(f, " = ")?;

+ default.hir_fmt(f)?;

+ }

+ }

+ TypeOrConstParamData::ConstParamData(c) => {

+ delim(f)?;

+ write!(f, "const {}: ", name)?;

+ c.ty.hir_fmt(f)?;

+ }

+ WherePredicateTypeTarget::TypeOrConstParam(id) => params.types[*id].name().is_none(),

+ WherePredicateTypeTarget::TypeOrConstParam(id) => match &params.types[*id].name() {

+ (hir_def::TypeOrConstParamId, crate::TypeOrConstParam),

+ (hir_def::LifetimeParamId, crate::LifetimeParam),

+ GenericParamId::LifetimeParamId(it) => GenericParam::LifetimeParam(it.into()),

+ GenericParam::ConstParam(it) => GenericParamId::ConstParamId(it.id.into()),

+ GenericParam::TypeParam(it) => GenericParamId::TypeParamId(it.id.into()),

+ db::HirDatabase, Adt, Const, Enum, Field, FieldSource, Function, Impl, LifetimeParam, MacroDef,

+ Module, Static, Struct, Trait, TypeAlias, TypeOrConstParam, Union, Variant,

+impl HasSource for TypeOrConstParam {

+ type Ast = Either<ast::TypeOrConstParam, ast::Trait>;

+ TypeOrConstParamId, TypeParamId, UnionId,

+use stdx::{format_to, impl_from, never};

+ let ty_params = generics.types.iter().map(|(local_id, _)| {

+ let toc = TypeOrConstParam { id: TypeOrConstParamId { parent: self.into(), local_id } };

+ match toc.split(db) {

+ Either::Left(x) => GenericParam::ConstParam(x),

+ Either::Right(x) => GenericParam::TypeParam(x),

+ }

+ });

+ ty_params.chain(lt_params).collect()

+ pub fn type_params(self, db: &dyn HirDatabase) -> Vec<TypeOrConstParam> {

+ .map(|(local_id, _)| TypeOrConstParam {

+ id: TypeOrConstParamId { parent: self.into(), local_id },

+ })

+ LifetimeParam(LifetimeParam),

+impl_from!(TypeParam, ConstParam, LifetimeParam for GenericParam);

+ GenericParam::LifetimeParam(it) => it.module(db),

+ GenericParam::LifetimeParam(it) => it.name(db),

+ pub fn merge(self) -> TypeOrConstParam {

+ TypeOrConstParam { id: self.id.into() }

+ }

+

+ self.merge().name(db)

+ self.id.parent().module(db.upcast()).into()

+ let resolver = self.id.parent().resolver(db.upcast());

+ let krate = self.id.parent().module(db.upcast()).krate();

+ let ty =

+ TyKind::Placeholder(hir_ty::to_placeholder_idx(db, self.id.into())).intern(Interner);

+ db.generic_predicates_for_param(self.id.parent(), self.id.into(), None)

+ let params = db.generic_defaults(self.id.parent());

+ let local_idx = hir_ty::param_idx(db, self.id.into())?;

+ let resolver = self.id.parent().resolver(db.upcast());

+ let krate = self.id.parent().module(db.upcast()).krate();

+ let subst = TyBuilder::type_params_subst(db, self.id.parent());

+ pub fn merge(self) -> TypeOrConstParam {

+ TypeOrConstParam { id: self.id.into() }

+ }

+

+ pub fn name(self, db: &dyn HirDatabase) -> Name {

+ let params = db.generic_params(self.id.parent());

+ match params.types[self.id.local_id()].name() {

+ Some(x) => x.clone(),

+ None => {

+ never!();

+ Name::missing()

+ }

+ }

+ }

+

+ pub fn module(self, db: &dyn HirDatabase) -> Module {

+ self.id.parent().module(db.upcast()).into()

+ }

+

+ pub fn parent(self, _db: &dyn HirDatabase) -> GenericDef {

+ self.id.parent().into()

+ }

+

+ pub fn ty(self, db: &dyn HirDatabase) -> Type {

+ let def = self.id.parent();

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

+ Type::new(db, krate, def, db.const_param_ty(self.id))

+ }

+}

+

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

+pub struct TypeOrConstParam {

+ pub(crate) id: TypeOrConstParamId,

+}

+

+impl TypeOrConstParam {

+ match params.types[self.id.local_id].name() {

+ Some(n) => n.clone(),

+ _ => Name::missing(),

+ }

+ pub fn split(self, db: &dyn HirDatabase) -> Either<ConstParam, TypeParam> {

+ let params = db.generic_params(self.id.parent);

+ match &params.types[self.id.local_id] {

+ hir_def::generics::TypeOrConstParamData::TypeParamData(_) => {

+ Either::Right(TypeParam { id: self.id.into() })

+ }

+ hir_def::generics::TypeOrConstParamData::ConstParamData(_) => {

+ Either::Left(ConstParam { id: self.id.into() })

+ }

+ }

+ }

+

+ match self.split(db) {

+ Either::Left(x) => x.ty(db),

+ Either::Right(x) => x.ty(db),

+ }

+ PathResolution::TypeParam(param) => Some(TypeNs::GenericParam(param.merge().into())),

+ dyn_map[keys::TYPE_PARAM].get(&src.value).copied().map(|x| x.into())

+ dyn_map[keys::CONST_PARAM].get(&src.value).copied().map(|x| x.into())

+ TypeOrConstParam, Variant,

+ TypeNs::GenericParam(id) => match (TypeOrConstParam { id }).split(db) {

+ either::Either::Left(x) => PathResolution::ConstParam(x),

+ either::Either::Right(x) => PathResolution::TypeParam(x),

+ },

+ ValueNs::GenericParam(id) => PathResolution::ConstParam(id.into()),

+ TypeNs::GenericParam(id) => match (TypeOrConstParam { id }).split(db) {

+ either::Either::Left(x) => PathResolution::ConstParam(x),

+ either::Either::Right(x) => PathResolution::TypeParam(x),

+ },

+ GenericParamId::ConstParamId(it) => {

+ let src = it.parent().child_source(db);

+ RawAttrs::from_attrs_owner(

+ db,

+ src.with_value(src.value[it.local_id()].as_ref().either(

+ |it| match it {

+ ast::TypeOrConstParam::Type(it) => it as _,

+ ast::TypeOrConstParam::Const(it) => it as _,

+ },

+ |it| it as _,

+ )),

+ )

+ }

+ let src = it.parent().child_source(db);

+ src.with_value(src.value[it.local_id()].as_ref().either(

+ |it| match it {

+ ast::TypeOrConstParam::Type(it) => it as _,

+ ast::TypeOrConstParam::Const(it) => it as _,

+ },

+ |it| it as _,

+ )),

+ GenericParamId::ConstParamId(id) => {

+ id.parent().child_source(db).map(|source| match &source[id.local_id()] {

+ Either::Left(ast::TypeOrConstParam::Type(id)) => {

+ ast::AnyHasAttrs::new(id.clone())

+ }

+ Either::Left(ast::TypeOrConstParam::Const(id)) => {

+ ast::AnyHasAttrs::new(id.clone())

+ }

+ Either::Right(id) => ast::AnyHasAttrs::new(id.clone()),

+ })

+ }

+ id.parent().child_source(db).map(|source| match &source[id.local_id()] {

+ Either::Left(ast::TypeOrConstParam::Type(id)) => {

+ ast::AnyHasAttrs::new(id.clone())

+ }

+ Either::Left(ast::TypeOrConstParam::Const(id)) => {

+ ast::AnyHasAttrs::new(id.clone())

+ }

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

+use stdx::impl_from;

+ AdtId, GenericDefId, HasModule, LifetimeParamId, LocalLifetimeParamId, LocalTypeOrConstParamId,

+ Lookup, TypeOrConstParamId,

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

+pub enum TypeOrConstParamData {

+ TypeParamData(TypeParamData),

+ ConstParamData(ConstParamData),

+}

+

+impl TypeOrConstParamData {

+ pub fn name(&self) -> Option<&Name> {

+ match self {

+ TypeOrConstParamData::TypeParamData(x) => x.name.as_ref(),

+ TypeOrConstParamData::ConstParamData(x) => Some(&x.name),

+ }

+ }

+

+ pub fn type_param(&self) -> Option<&TypeParamData> {

+ match self {

+ TypeOrConstParamData::TypeParamData(x) => Some(&x),

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

+ }

+ }

+

+ pub fn is_trait_self(&self) -> bool {

+ match self {

+ TypeOrConstParamData::TypeParamData(x) => {

+ x.provenance == TypeParamProvenance::TraitSelf

+ }

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

+ }

+ }

+}

+

+impl_from!(TypeParamData, ConstParamData for TypeOrConstParamData);

+

+ pub types: Arena<TypeOrConstParamData>,

+ TypeOrConstParam(LocalTypeOrConstParamId),

+ // FIXME: almost every usecase of this function is wrong. every one should check

+ // const generics

+ pub fn type_iter<'a>(

+ &'a self,

+ ) -> impl Iterator<Item = (Idx<TypeOrConstParamData>, &TypeParamData)> {

+ self.types.iter().filter_map(|x| x.1.type_param().map(|y| (x.0, y)))

+ }

+

+ for type_or_const_param in params.type_or_const_params() {

+ match type_or_const_param {

+ ast::TypeOrConstParam::Type(type_param) => {

+ let name = type_param.name().map_or_else(Name::missing, |it| it.as_name());

+ // FIXME: Use `Path::from_src`

+ let default = type_param

+ .default_type()

+ .map(|it| Interned::new(TypeRef::from_ast(lower_ctx, it)));

+ let param = TypeParamData {

+ name: Some(name.clone()),

+ default,

+ provenance: TypeParamProvenance::TypeParamList,

+ };

+ self.types.alloc(param.into());

+ let type_ref = TypeRef::Path(name.into());

+ self.fill_bounds(lower_ctx, &type_param, Either::Left(type_ref));

+ }

+ ast::TypeOrConstParam::Const(const_param) => {

+ let name = const_param.name().map_or_else(Name::missing, |it| it.as_name());

+ let ty = const_param

+ .ty()

+ .map_or(TypeRef::Error, |it| TypeRef::from_ast(lower_ctx, it));

+ let param = ConstParamData { name, ty: Interned::new(ty) };

+ self.types.alloc(param.into());

+ }

+ }

+ let param_id = self.types.alloc(param.into());

+ target: WherePredicateTypeTarget::TypeOrConstParam(param_id),

+ let Self { lifetimes, types, where_predicates } = self;

+ pub fn find_type_or_const_by_name(&self, name: &Name) -> Option<LocalTypeOrConstParamId> {

+ .find_map(|(id, p)| if p.name().as_ref() == Some(&name) { Some(id) } else { None })

+ pub fn find_trait_self_param(&self) -> Option<LocalTypeOrConstParamId> {

+ if let TypeOrConstParamData::TypeParamData(p) = p {

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

+ Some(id)

+ } else {

+ None

+ }

+impl HasChildSource<LocalTypeOrConstParamId> for GenericDefId {

+ type Value = Either<ast::TypeOrConstParam, ast::Trait>;

+ ) -> InFile<ArenaMap<LocalTypeOrConstParamId, Self::Value>> {

+ for (idx, ast_param) in idx_iter.zip(generic_params_list.type_or_const_params()) {

+ let mut toc_idx_iter = generic_params.types.iter().map(|(idx, _)| idx);

+ toc_idx_iter.next().unwrap(); // advance_by(1);

+ for (local_id, ast_param) in

+ toc_idx_iter.zip(generic_params_list.type_or_const_params())

+ {

+ let id = TypeOrConstParamId { parent: *self, local_id };

+ match ast_param {

+ ast::TypeOrConstParam::Type(a) => res[keys::TYPE_PARAM].insert(a, id),

+ ast::TypeOrConstParam::Const(a) => res[keys::CONST_PARAM].insert(a, id),

+ }

+ generics.types.alloc(

+ TypeParamData {

+ name: Some(name![Self]),

+ default: None,

+ provenance: TypeParamProvenance::TraitSelf,

+ }

+ .into(),

+ );

+ generics::{TypeOrConstParamData, WherePredicate, WherePredicateTypeTarget},

+ if params.types.is_empty() && params.lifetimes.is_empty() {

+ for (idx, x) in params.types.iter() {

+ match x {

+ TypeOrConstParamData::TypeParamData(ty) => match &ty.name {

+ Some(name) => w!(self, "{}", name),

+ None => w!(self, "_anon_{}", idx.into_raw()),

+ },

+ TypeOrConstParamData::ConstParamData(konst) => {

+ w!(self, "const {}: ", konst.name);

+ self.print_type_ref(&konst.ty);

+ }

+ WherePredicateTypeTarget::TypeOrConstParam(id) => {

+ match &params.types[*id].name() {

+ Some(name) => w!(this, "{}", name),

+ None => w!(this, "_anon_{}", id.into_raw()),

+ }

+ }

+ ConstId, EnumId, EnumVariantId, FieldId, FunctionId, ImplId, LifetimeParamId, StaticId,

+ StructId, TraitId, TypeAliasId, TypeOrConstParamId, UnionId,

+pub const TYPE_PARAM: Key<ast::TypeParam, TypeOrConstParamId> = Key::new();

+pub const CONST_PARAM: Key<ast::ConstParam, TypeOrConstParamId> = Key::new();

+pub struct TypeOrConstParamId {

+ pub local_id: LocalTypeOrConstParamId,

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

+/// A TypeOrConstParamId with an invariant that it actually belongs to a type

+pub struct TypeParamId(TypeOrConstParamId);

+

+impl TypeParamId {

+ pub fn parent(&self) -> GenericDefId {

+ self.0.parent

+ }

+ pub fn local_id(&self) -> LocalTypeOrConstParamId {

+ self.0.local_id

+ }

+}

+

+impl From<TypeOrConstParamId> for TypeParamId {

+ fn from(x: TypeOrConstParamId) -> Self {

+ Self(x)

+ }

+}

+impl From<TypeParamId> for TypeOrConstParamId {

+ fn from(x: TypeParamId) -> Self {

+ x.0

+ }

+}

+/// A TypeOrConstParamId with an invariant that it actually belongs to a const

+pub struct ConstParamId(TypeOrConstParamId);

+

+impl ConstParamId {

+ pub fn parent(&self) -> GenericDefId {

+ self.0.parent

+ }

+ pub fn local_id(&self) -> LocalTypeOrConstParamId {

+ self.0.local_id

+ }

+

+impl From<TypeOrConstParamId> for ConstParamId {

+ fn from(x: TypeOrConstParamId) -> Self {

+ Self(x)

+ }

+}

+impl From<ConstParamId> for TypeOrConstParamId {

+ fn from(x: ConstParamId) -> Self {

+ x.0

+ }

+}

+

+pub type LocalTypeOrConstParamId = Idx<generics::TypeOrConstParamData>;

+pub struct LifetimeParamId {

+ pub local_id: LocalLifetimeParamId,

+pub type LocalLifetimeParamId = Idx<generics::LifetimeParamData>;

+ LifetimeParamId(LifetimeParamId),

+ GenericParamId::TypeParamId(it) => it.parent(),

+ GenericParamId::ConstParamId(it) => it.parent(),

+ generics::{GenericParams, TypeOrConstParamData},

+ TypeOrConstParamId, VariantId,

+ GenericParam(TypeOrConstParamId),

+ if let Some(local_id) = params.find_type_or_const_by_name(first_name) {

+ TypeNs::GenericParam(

+ TypeOrConstParamId { local_id, parent: *def }.into(),

+ ),

+ if let Some(local_id) = params.find_type_or_const_by_name(first_name) {

+ let ty = TypeNs::GenericParam(

+ TypeOrConstParamId { local_id, parent: *def }.into(),

+ );

+ if let Some(local_id) = params.find_type_or_const_by_name(first_name) {

+ let val = ValueNs::GenericParam(

+ TypeOrConstParamId { local_id, parent: *def }.into(),

+ );

+ if let Some(name) = &param.name() {

+ let id = TypeOrConstParamId { parent, local_id };

+ let data = &db.generic_params(parent).types[local_id];

+ acc.add(

+ name,

+ ScopeDef::GenericParam(match data {

+ TypeOrConstParamData::TypeParamData(_) => {

+ GenericParamId::TypeParamId(id.into())

+ }

+ TypeOrConstParamData::ConstParamData(_) => {

+ GenericParamId::ConstParamId(id.into())

+ }

+ }),

+ );

+ type_or_const_params: usize,

+ let type_or_const_params =

+ params.map_or(0, |type_param_list| type_param_list.type_or_const_params().count());

+ Ok(BasicAdtInfo { name: name_token, type_or_const_params })

+ let type_params = make_type_args(info.type_or_const_params, bound);

+ let type_args = make_type_args(info.type_or_const_params, Vec::new());

+ generics::TypeOrConstParamData,

+ match param_data {

+ TypeOrConstParamData::TypeParamData(p) => match p.provenance {

+ hir_def::generics::TypeParamProvenance::ArgumentImplTrait => {

+ let substs = TyBuilder::type_params_subst(db, id.parent);

+ let predicates = db

+ .generic_predicates(id.parent)

+ .iter()

+ .map(|pred| pred.clone().substitute(Interner, &substs))

+ .filter(|wc| match &wc.skip_binders() {

+ WhereClause::Implemented(tr) => {

+ &tr.self_type_parameter(Interner) == self

+ }

+ WhereClause::AliasEq(AliasEq {

+ alias: AliasTy::Projection(proj),

+ ty: _,

+ }) => &proj.self_type_parameter(Interner) == self,

+ _ => false,

+ })

+ .collect::<Vec<_>>();

+

+ Some(predicates)

+ }

+ _ => None,

+ },

+ ImplId, LifetimeParamId, LocalFieldId, TypeOrConstParamId, VariantId,

+ param_id: TypeOrConstParamId,

+ fn intern_type_or_const_param_id(

+ &self,

+ param_id: TypeOrConstParamId,

+ ) -> InternedTypeOrConstParamId;

+pub struct InternedTypeOrConstParamId(salsa::InternId);

+impl_intern_key!(InternedTypeOrConstParamId);

+ generics::{TypeOrConstParamData, TypeParamProvenance},

+ let id = from_placeholder_idx(f.db, idx);

+ let param_data = &generics.params.types[id.local_id];

+ write!(f, "{}", param_data.name().unwrap())

+ match param_data {

+ TypeOrConstParamData::TypeParamData(p) => match p.provenance {

+ TypeParamProvenance::TypeParamList | TypeParamProvenance::TraitSelf => {

+ write!(f, "{}", p.name.clone().unwrap_or_else(Name::missing))?

+ }

+ TypeParamProvenance::ArgumentImplTrait => {

+ let substs = generics.type_params_subst(f.db);

+ let bounds =

+ f.db.generic_predicates(id.parent)

+ .iter()

+ .map(|pred| pred.clone().substitute(Interner, &substs))

+ .filter(|wc| match &wc.skip_binders() {

+ WhereClause::Implemented(tr) => {

+ &tr.self_type_parameter(Interner) == self

+ }

+ WhereClause::AliasEq(AliasEq {

+ alias: AliasTy::Projection(proj),

+ ty: _,

+ }) => &proj.self_type_parameter(Interner) == self,

+ _ => false,

+ })

+ .collect::<Vec<_>>();

+ let krate = id.parent.module(f.db.upcast()).krate();

+ write_bounds_like_dyn_trait_with_prefix(

+ "impl",

+ &bounds,

+ SizedByDefault::Sized { anchor: krate },

+ f,

+ )?;

+ }

+ },

+ TypeOrConstParamData::ConstParamData(p) => {

+ write!(f, "{}", p.name)?;

+ generics::TypeOrConstParamData,

+ for (_id, param) in def_generics.iter_parent() {

+ match param {

+ TypeOrConstParamData::TypeParamData(_) => {

+ substs.push(self.table.new_type_var());

+ }

+ TypeOrConstParamData::ConstParamData(_) => {

+ // FIXME: here we should do something

+ }

+ }

+ TypeOrConstParamId,

+ from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, from_placeholder_idx,

+ lt_from_placeholder_idx, to_assoc_type_id, to_chalk_trait_id, to_foreign_def_id,

+ to_placeholder_idx,

+pub fn param_idx(db: &dyn HirDatabase, id: TypeOrConstParamId) -> Option<usize> {

+use hir_def::generics::TypeOrConstParamData;

+ AdtId, AssocItemId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, HasModule,

+ ImplId, ItemContainerId, LocalFieldId, Lookup, StaticId, StructId, TraitId, TypeAliasId,

+ UnionId, VariantId,

+use hir_def::{ConstParamId, TypeOrConstParamId};

+use stdx::{impl_from, never};

+ .type_iter()

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

+ TyKind::Placeholder(to_placeholder_idx(self.db, param_id.into()))

+ let idx = generics.param_idx(param_id.into()).expect("matching generics");

+ WherePredicateTypeTarget::TypeOrConstParam(param_id) => {

+ let param_id = hir_def::TypeOrConstParamId {

+ parent: generic_def,

+ local_id: *param_id,

+ };

+ let predicates = db.generic_predicates_for_param(def, param_id.into(), assoc_name);

+ if generics.params.types[param_id.local_id].is_trait_self() {

+ param_id: TypeOrConstParamId,

+ if ctx.lower_ty_only_param(type_ref) != Some(param_id.into()) {

+ WherePredicateTypeTarget::TypeOrConstParam(local_id) => {

+ _param_id: &TypeOrConstParamId,

+ .type_iter()

+ .type_iter()

+// returns None if def is a type arg

+ let parent_data = db.generic_params(def.parent());

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

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

+ match data {

+ TypeOrConstParamData::TypeParamData(_) => {

+ never!();

+ Ty::new(Interner, TyKind::Error)

+ }

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

+ }

+use hir_def::{LifetimeParamId, TraitId, TypeAliasId, TypeOrConstParamId};

+pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeOrConstParamId {

+ db.lookup_intern_type_or_const_param_id(interned_id)

+pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeOrConstParamId) -> PlaceholderIndex {

+ let interned_id = db.intern_type_or_const_param_id(id);

+ GenericParams, TypeOrConstParamData, TypeParamData, TypeParamProvenance, WherePredicate,

+ WherePredicateTypeTarget,

+ GenericDefId, ItemContainerId, Lookup, TraitId, TypeAliasId, TypeOrConstParamId,

+ WherePredicateTypeTarget::TypeOrConstParam(local_id)

+ if Some(*local_id) == trait_self =>

+ {

+ Some(p) => TypeOrConstParamId { parent: trait_ref.hir_trait_id().into(), local_id: p },

+ // FIXME: we should drop this and handle const and type generics at the same time

+ pub(crate) fn type_iter<'a>(

+ ) -> impl Iterator<Item = (TypeOrConstParamId, &'a TypeParamData)> + 'a {

+ .type_iter()

+ .map(move |(local_id, p)| (TypeOrConstParamId { parent: it.def, local_id }, p))

+ self.params.type_iter().map(move |(local_id, p)| {

+ (TypeOrConstParamId { parent: self.def, local_id }, p)

+ }),

+ ) -> impl Iterator<Item = (TypeOrConstParamId, &'a TypeOrConstParamData)> + 'a {

+ .map(move |(local_id, p)| (TypeOrConstParamId { parent: it.def, local_id }, p))

+ // FIXME: we should not filter const generics here, but at now it breaks tests

+ let child = self.params.types.iter().filter_map(|x| x.1.type_param()).count();

+ .filter_map(|x| x.1.type_param())

+ .filter(|p| p.provenance == TypeParamProvenance::TraitSelf)

+ .filter_map(|x| x.1.type_param())

+ .filter(|p| p.provenance == TypeParamProvenance::TypeParamList)

+ .filter_map(|x| x.1.type_param())

+ .filter(|p| p.provenance == TypeParamProvenance::ArgumentImplTrait)

+ pub(crate) fn param_idx(&self, param: TypeOrConstParamId) -> Option<usize> {

+ fn find_param(&self, param: TypeOrConstParamId) -> Option<(usize, &TypeOrConstParamData)> {

+ self.type_iter()

+ self.type_iter().map(|(id, _)| {

+fn const_generic_order() {

+ check(

+ r#"

+struct Foo;

+struct S$0T<const C: usize = 1, T = Foo>(T);

+"#,

+ expect![[r#"

+ *ST*

+

+ ```rust

+ test

+ ```

+

+ ```rust

+ struct ST<const C: usize, T = Foo>

+ ```

+ "#]],

+ );

+}

+

+#[test]

+use stdx::never;

+ let InFile { file_id, value } = self.merge().source(db)?;

+ let value = match value {

+ Either::Left(ast::TypeOrConstParam::Type(x)) => Either::Left(x),

+ Either::Left(ast::TypeOrConstParam::Const(_)) => {

+ never!();

+ return None;

+ }

+ Either::Right(x) => Either::Right(x),

+ };

+

+impl TryToNav for hir::TypeOrConstParam {

+ fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {

+ self.split(db).try_to_nav(db)

+ }

+}

+

+ let InFile { file_id, value } = self.merge().source(db)?;

+ let value = match value {

+ Either::Left(ast::TypeOrConstParam::Const(x)) => x,

+ _ => {

+ never!();

+ return None;

+ }

+ };

+

+ hir::GenericParam::LifetimeParam(_) => SymbolKind::LifetimeParam,

+ <span class="comment documentation">/// ```</span>

+ <span class="comment documentation">/// </span><span class="comment injected">// functions</span>

+ <span class="comment documentation">/// </span><span class="keyword injected">fn</span><span class="none injected"> </span><span class="function declaration injected">foo</span><span class="angle injected">&lt;</span><span class="type_param declaration injected">T</span><span class="comma injected">,</span><span class="none injected"> </span><span class="keyword injected">const</span><span class="none injected"> </span><span class="const_param declaration injected">X</span><span class="colon injected">:</span><span class="none injected"> </span><span class="builtin_type injected">usize</span><span class="angle injected">&gt;</span><span class="parenthesis injected">(</span><span class="value_param declaration injected">arg</span><span class="colon injected">:</span><span class="none injected"> </span><span class="builtin_type injected">i32</span><span class="parenthesis injected">)</span><span class="none injected"> </span><span class="brace injected">{</span>

+ <span class="comment documentation">/// </span><span class="none injected"> </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">x</span><span class="colon injected">:</span><span class="none injected"> </span><span class="type_param injected">T</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="const_param injected">X</span><span class="semicolon injected">;</span>

+ <span class="comment documentation">/// </span><span class="brace injected">}</span>

+ <span class="comment documentation">/// ```</span>

+ <span class="comment documentation">///</span>

+ /// ```

+ /// // functions

+ /// fn foo<T, const X: usize>(arg: i32) {

+ /// let x: T = X;

+ /// }

+ /// ```

+ ///

+ let toc_params = generic_params.type_or_const_params().map(|toc_param| match toc_param {

+ ast::TypeOrConstParam::Type(type_param) => {

+ let mut buf = String::new();

+ if let Some(it) = type_param.name() {

+ format_to!(buf, "{}", it.syntax());

+ }

+ if let Some(it) = type_param.colon_token() {

+ format_to!(buf, "{} ", it);

+ }

+ if let Some(it) = type_param.type_bound_list() {

+ format_to!(buf, "{}", it.syntax());

+ }

+ buf

+ ast::TypeOrConstParam::Const(const_param) => const_param.syntax().to_string(),

+ let generics = lifetimes.chain(toc_params).format(", ");

+ let mut type_params = type_param_list.type_or_const_params();

+ if type_params.all(|p| match p {

+ ast::TypeOrConstParam::Type(t) => t.type_bound_list().is_none(),

+ ast::TypeOrConstParam::Const(_) => true,

+ }) {

+ for toc_param in type_param_list.type_or_const_params() {

+ let type_param = match toc_param {

+ ast::TypeOrConstParam::Type(x) => x,

+ ast::TypeOrConstParam::Const(_) => continue,

+ };

+ let toc_params = generic_params.type_or_const_params().map(|toc_param| {

+ let type_param = match toc_param {

+ ast::TypeOrConstParam::Type(x) => x,

+ ast::TypeOrConstParam::Const(x) => return x.syntax().to_string(),

+ };

+ let generics = lifetimes.chain(toc_params).format(", ");

+ let toc_params = generic_params

+ .type_or_const_params()

+ format_to!(buf, "<{}>", lifetime_params.chain(toc_params).format(", "))

+ hir::GenericParam::LifetimeParam(_) => SymbolKind::LifetimeParam,

+ hir::db::InternTypeOrConstParamIdQuery

+ hir::db::InternTypeOrConstParamIdQuery

+ PathResolution::ConstParam(par) => Definition::GenericParam(par.into()),

+use either::Either;

+ .filter_map(|(k, v)| match k.split(db) {

+ Either::Left(_) => None,

+ Either::Right(t) => match v {

+ Some(v) => Some((k, v.clone())),

+ None => {

+ let default = t.default(db)?;

+ Some((

+ k,

+ ast::make::ty(

+ &default.display_source_code(db, source_module.into()).ok()?,

+ ),

+ ))

+ }

+ },

+ substs: FxHashMap<hir::TypeOrConstParam, ast::Type>,

+ if let Some(subst) = self.substs.get(&tp.merge()) {

+ hir::GenericParam::LifetimeParam(lifetime_param) => {

+ let src = lifetime_param.source(sema.db)?;

+ src.with_value(src.value.lifetime()?.syntax()).original_file_range_opt(sema.db)

+ }

+ _ => {

+ let x = match generic_param {

+ hir::GenericParam::TypeParam(it) => it.merge(),

+ hir::GenericParam::ConstParam(it) => it.merge(),

+ hir::GenericParam::LifetimeParam(_) => return None,

+ };

+ let src = x.source(sema.db)?;

+ Either::Left(x) => x.name()?,

+ Either::Right(_) => return None,

+ SlicePatComponents, StructKind, TypeBoundKind, TypeOrConstParam, VisibilityKind,

+#[derive(Debug, Clone)]

+pub enum TypeOrConstParam {

+ Type(ast::TypeParam),

+ Const(ast::ConstParam),

+}

+

+impl TypeOrConstParam {

+ pub fn name(&self) -> Option<ast::Name> {

+ match self {

+ TypeOrConstParam::Type(x) => x.name(),

+ TypeOrConstParam::Const(x) => x.name(),

+ }

+ }

+}

+

+ pub fn type_or_const_params(&self) -> impl Iterator<Item = ast::TypeOrConstParam> {

+ ast::GenericParam::TypeParam(it) => Some(ast::TypeOrConstParam::Type(it)),

+ ast::GenericParam::LifetimeParam(_) => None,

+ ast::GenericParam::ConstParam(it) => Some(ast::TypeOrConstParam::Const(it)),