Skip to content

Commit 3a66230

Browse files
VeykrilVeykril
committed
There can only be one self param
1 parent c133c64 commit 3a66230

File tree

5 files changed

+61
-66
lines changed

5 files changed

+61
-66
lines changed

‎src/tools/rust-analyzer/crates/hir-def/src/generics.rs

+15-11
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ use hir_expand::{
1111
ExpandResult,
1212
};
1313
use intern::Interned;
14-
use la_arena::Arena;
14+
use la_arena::{Arena, RawIdx};
1515
use once_cell::unsync::Lazy;
1616
use stdx::impl_from;
1717
use syntax::ast::{self, HasGenericParams, HasName, HasTypeBounds};
@@ -28,6 +28,9 @@ use crate::{
2828
LocalLifetimeParamId, LocalTypeOrConstParamId, Lookup, TypeOrConstParamId, TypeParamId,
2929
};
3030

31+
const SELF_PARAM_ID_IN_SELF: la_arena::Idx<TypeOrConstParamData> =
32+
LocalTypeOrConstParamId::from_raw(RawIdx::from_u32(0));
33+
3134
/// Data about a generic type parameter (to a function, struct, impl, ...).
3235
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
3336
pub struct TypeParamData {
@@ -606,16 +609,17 @@ impl GenericParams {
606609
}
607610

608611
pub fn find_trait_self_param(&self) -> Option<LocalTypeOrConstParamId> {
609-
self.type_or_consts.iter().find_map(|(id, p)| {
610-
matches!(
611-
p,
612-
TypeOrConstParamData::TypeParamData(TypeParamData {
613-
provenance: TypeParamProvenance::TraitSelf,
614-
..
615-
})
616-
)
617-
.then(|| id)
618-
})
612+
if self.type_or_consts.is_empty() {
613+
return None;
614+
}
615+
matches!(
616+
self.type_or_consts[SELF_PARAM_ID_IN_SELF],
617+
TypeOrConstParamData::TypeParamData(TypeParamData {
618+
provenance: TypeParamProvenance::TraitSelf,
619+
..
620+
})
621+
)
622+
.then(|| SELF_PARAM_ID_IN_SELF)
619623
}
620624

621625
pub fn find_lifetime_by_name(

‎src/tools/rust-analyzer/crates/hir-ty/src/display.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -989,15 +989,15 @@ impl HirDisplay for Ty {
989989

990990
if parameters.len(Interner) > 0 {
991991
let generics = generics(db.upcast(), def.into());
992-
let (parent_len, self_, type_, const_, impl_, lifetime) =
992+
let (parent_len, self_param, type_, const_, impl_, lifetime) =
993993
generics.provenance_split();
994994
let parameters = parameters.as_slice(Interner);
995995
// We print all params except implicit impl Trait params. Still a bit weird; should we leave out parent and self?
996996
if parameters.len() - impl_ > 0 {
997997
// `parameters` are in the order of fn's params (including impl traits), fn's lifetimes
998998
// parent's params (those from enclosing impl or trait, if any).
999999
let (fn_params, other) =
1000-
parameters.split_at(self_ + type_ + const_ + lifetime);
1000+
parameters.split_at(self_param as usize + type_ + const_ + lifetime);
10011001
let (_impl, parent_params) = other.split_at(impl_);
10021002
debug_assert_eq!(parent_params.len(), parent_len);
10031003

‎src/tools/rust-analyzer/crates/hir-ty/src/generics.rs

+8-4
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,10 @@ impl Generics {
5353
self.iter().map(|(id, _)| id)
5454
}
5555

56+
pub(crate) fn iter_self_id(&self) -> impl Iterator<Item = GenericParamId> + '_ {
57+
self.iter_self().map(|(id, _)| id)
58+
}
59+
5660
pub(crate) fn iter_self_type_or_consts(
5761
&self,
5862
) -> impl DoubleEndedIterator<Item = (LocalTypeOrConstParamId, &TypeOrConstParamData)> {
@@ -99,16 +103,16 @@ impl Generics {
99103
}
100104

101105
/// (parent total, self param, type params, const params, impl trait list, lifetimes)
102-
pub(crate) fn provenance_split(&self) -> (usize, usize, usize, usize, usize, usize) {
103-
let mut self_params = 0;
106+
pub(crate) fn provenance_split(&self) -> (usize, bool, usize, usize, usize, usize) {
107+
let mut self_param = false;
104108
let mut type_params = 0;
105109
let mut impl_trait_params = 0;
106110
let mut const_params = 0;
107111
let mut lifetime_params = 0;
108112
self.params.iter_type_or_consts().for_each(|(_, data)| match data {
109113
TypeOrConstParamData::TypeParamData(p) => match p.provenance {
110114
TypeParamProvenance::TypeParamList => type_params += 1,
111-
TypeParamProvenance::TraitSelf => self_params += 1,
115+
TypeParamProvenance::TraitSelf => self_param |= true,
112116
TypeParamProvenance::ArgumentImplTrait => impl_trait_params += 1,
113117
},
114118
TypeOrConstParamData::ConstParamData(_) => const_params += 1,
@@ -117,7 +121,7 @@ impl Generics {
117121
self.params.iter_lt().for_each(|(_, _)| lifetime_params += 1);
118122

119123
let parent_len = self.parent_generics().map_or(0, Generics::len);
120-
(parent_len, self_params, type_params, const_params, impl_trait_params, lifetime_params)
124+
(parent_len, self_param, type_params, const_params, impl_trait_params, lifetime_params)
121125
}
122126

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

‎src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs

+8-11
Original file line numberDiff line numberDiff line change
@@ -1830,27 +1830,25 @@ impl InferenceContext<'_> {
18301830
) -> Substitution {
18311831
let (
18321832
parent_params,
1833-
self_params,
1833+
has_self_param,
18341834
type_params,
18351835
const_params,
18361836
impl_trait_params,
18371837
lifetime_params,
18381838
) = def_generics.provenance_split();
1839-
assert_eq!(self_params, 0); // method shouldn't have another Self param
1839+
assert!(!has_self_param); // method shouldn't have another Self param
18401840
let total_len =
18411841
parent_params + type_params + const_params + impl_trait_params + lifetime_params;
18421842
let mut substs = Vec::with_capacity(total_len);
18431843

18441844
// handle provided arguments
18451845
if let Some(generic_args) = generic_args {
18461846
// if args are provided, it should be all of them, but we can't rely on that
1847-
for (arg, kind_id) in generic_args
1848-
.args
1849-
.iter()
1850-
.take(type_params + const_params + lifetime_params)
1851-
.zip(def_generics.iter_id())
1847+
let self_params = type_params + const_params + lifetime_params;
1848+
for (arg, kind_id) in
1849+
generic_args.args.iter().zip(def_generics.iter_self_id()).take(self_params)
18521850
{
1853-
if let Some(g) = generic_arg_to_chalk(
1851+
let arg = generic_arg_to_chalk(
18541852
self.db,
18551853
kind_id,
18561854
arg,
@@ -1869,9 +1867,8 @@ impl InferenceContext<'_> {
18691867
)
18701868
},
18711869
|this, lt_ref| this.make_lifetime(lt_ref),
1872-
) {
1873-
substs.push(g);
1874-
}
1870+
);
1871+
substs.push(arg);
18751872
}
18761873
};
18771874

‎src/tools/rust-analyzer/crates/hir-ty/src/lower.rs

+28-38
Original file line numberDiff line numberDiff line change
@@ -375,7 +375,7 @@ impl<'a> TyLoweringContext<'a> {
375375
counter.set(idx + count_impl_traits(type_ref) as u16);
376376
let (
377377
_parent_params,
378-
self_params,
378+
self_param,
379379
type_params,
380380
const_params,
381381
_impl_trait_params,
@@ -386,7 +386,7 @@ impl<'a> TyLoweringContext<'a> {
386386
.provenance_split();
387387
TyKind::BoundVar(BoundVar::new(
388388
self.in_binders,
389-
idx as usize + self_params + type_params + const_params,
389+
idx as usize + self_param as usize + type_params + const_params,
390390
))
391391
.intern(Interner)
392392
}
@@ -817,33 +817,31 @@ impl<'a> TyLoweringContext<'a> {
817817
let def_generics = generics(self.db.upcast(), def);
818818
let (
819819
parent_params,
820-
self_params,
820+
self_param,
821821
type_params,
822822
const_params,
823823
impl_trait_params,
824824
lifetime_params,
825825
) = def_generics.provenance_split();
826826
let item_len =
827-
self_params + type_params + const_params + impl_trait_params + lifetime_params;
827+
self_param as usize + type_params + const_params + impl_trait_params + lifetime_params;
828828
let total_len = parent_params + item_len;
829829

830830
let ty_error = TyKind::Error.intern(Interner).cast(Interner);
831831

832832
let mut def_generic_iter = def_generics.iter_id();
833833

834834
let fill_self_params = || {
835-
for x in explicit_self_ty
836-
.into_iter()
837-
.map(|x| x.cast(Interner))
838-
.chain(iter::repeat(ty_error.clone()))
839-
.take(self_params)
840-
{
835+
if self_param {
836+
let self_ty =
837+
explicit_self_ty.map(|x| x.cast(Interner)).unwrap_or_else(|| ty_error.clone());
838+
841839
if let Some(id) = def_generic_iter.next() {
842840
assert!(matches!(
843841
id,
844842
GenericParamId::TypeParamId(_) | GenericParamId::LifetimeParamId(_)
845843
));
846-
substs.push(x);
844+
substs.push(self_ty);
847845
}
848846
}
849847
};
@@ -854,11 +852,11 @@ impl<'a> TyLoweringContext<'a> {
854852
fill_self_params();
855853
}
856854
let expected_num = if generic_args.has_self_type {
857-
self_params + type_params + const_params
855+
self_param as usize + type_params + const_params
858856
} else {
859857
type_params + const_params
860858
};
861-
let skip = if generic_args.has_self_type && self_params == 0 { 1 } else { 0 };
859+
let skip = if generic_args.has_self_type && !self_param { 1 } else { 0 };
862860
// if args are provided, it should be all of them, but we can't rely on that
863861
for arg in generic_args
864862
.args
@@ -868,21 +866,17 @@ impl<'a> TyLoweringContext<'a> {
868866
.take(expected_num)
869867
{
870868
if let Some(id) = def_generic_iter.next() {
871-
if let Some(x) = generic_arg_to_chalk(
869+
let arg = generic_arg_to_chalk(
872870
self.db,
873871
id,
874872
arg,
875873
&mut (),
876874
|_, type_ref| self.lower_ty(type_ref),
877875
|_, const_ref, ty| self.lower_const(const_ref, ty),
878876
|_, lifetime_ref| self.lower_lifetime(lifetime_ref),
879-
) {
880-
had_explicit_args = true;
881-
substs.push(x);
882-
} else {
883-
// we just filtered them out
884-
never!("Unexpected lifetime argument");
885-
}
877+
);
878+
had_explicit_args = true;
879+
substs.push(arg);
886880
}
887881
}
888882

@@ -895,21 +889,17 @@ impl<'a> TyLoweringContext<'a> {
895889
// Taking into the fact that def_generic_iter will always have lifetimes at the end
896890
// Should have some test cases tho to test this behaviour more properly
897891
if let Some(id) = def_generic_iter.next() {
898-
if let Some(x) = generic_arg_to_chalk(
892+
let arg = generic_arg_to_chalk(
899893
self.db,
900894
id,
901895
arg,
902896
&mut (),
903897
|_, type_ref| self.lower_ty(type_ref),
904898
|_, const_ref, ty| self.lower_const(const_ref, ty),
905899
|_, lifetime_ref| self.lower_lifetime(lifetime_ref),
906-
) {
907-
had_explicit_args = true;
908-
substs.push(x);
909-
} else {
910-
// Never return a None explicitly
911-
never!("Unexpected None by generic_arg_to_chalk");
912-
}
900+
);
901+
had_explicit_args = true;
902+
substs.push(arg);
913903
}
914904
}
915905
} else {
@@ -2170,7 +2160,6 @@ pub(crate) fn lower_to_chalk_mutability(m: hir_def::type_ref::Mutability) -> Mut
21702160
/// Checks if the provided generic arg matches its expected kind, then lower them via
21712161
/// provided closures. Use unknown if there was kind mismatch.
21722162
///
2173-
/// Returns `Some` of the lowered generic arg. `None` if the provided arg is a lifetime.
21742163
pub(crate) fn generic_arg_to_chalk<'a, T>(
21752164
db: &dyn HirDatabase,
21762165
kind_id: GenericParamId,
@@ -2179,7 +2168,7 @@ pub(crate) fn generic_arg_to_chalk<'a, T>(
21792168
for_type: impl FnOnce(&mut T, &TypeRef) -> Ty + 'a,
21802169
for_const: impl FnOnce(&mut T, &ConstRef, Ty) -> Const + 'a,
21812170
for_lifetime: impl FnOnce(&mut T, &LifetimeRef) -> Lifetime + 'a,
2182-
) -> Option<crate::GenericArg> {
2171+
) -> crate::GenericArg {
21832172
let kind = match kind_id {
21842173
GenericParamId::TypeParamId(_) => ParamKind::Type,
21852174
GenericParamId::ConstParamId(id) => {
@@ -2188,7 +2177,7 @@ pub(crate) fn generic_arg_to_chalk<'a, T>(
21882177
}
21892178
GenericParamId::LifetimeParamId(_) => ParamKind::Lifetime,
21902179
};
2191-
Some(match (arg, kind) {
2180+
match (arg, kind) {
21922181
(GenericArg::Type(type_ref), ParamKind::Type) => for_type(this, type_ref).cast(Interner),
21932182
(GenericArg::Const(c), ParamKind::Const(c_ty)) => for_const(this, c, c_ty).cast(Interner),
21942183
(GenericArg::Lifetime(lifetime_ref), ParamKind::Lifetime) => {
@@ -2201,11 +2190,12 @@ pub(crate) fn generic_arg_to_chalk<'a, T>(
22012190
// as types. Maybe here is not the best place to do it, but
22022191
// it works.
22032192
if let TypeRef::Path(p) = t {
2204-
let p = p.mod_path()?;
2205-
if p.kind == PathKind::Plain {
2206-
if let [n] = p.segments() {
2207-
let c = ConstRef::Path(n.clone());
2208-
return Some(for_const(this, &c, c_ty).cast(Interner));
2193+
if let Some(p) = p.mod_path() {
2194+
if p.kind == PathKind::Plain {
2195+
if let [n] = p.segments() {
2196+
let c = ConstRef::Path(n.clone());
2197+
return for_const(this, &c, c_ty).cast(Interner);
2198+
}
22092199
}
22102200
}
22112201
}
@@ -2214,7 +2204,7 @@ pub(crate) fn generic_arg_to_chalk<'a, T>(
22142204
(GenericArg::Lifetime(_), ParamKind::Const(c_ty)) => unknown_const_as_generic(c_ty),
22152205
(GenericArg::Type(_), ParamKind::Lifetime) => error_lifetime().cast(Interner),
22162206
(GenericArg::Const(_), ParamKind::Lifetime) => error_lifetime().cast(Interner),
2217-
})
2207+
}
22182208
}
22192209

22202210
pub(crate) fn const_or_path_to_chalk(

0 commit comments

Comments
 (0)