Skip to content

Commit 98dabb6

Browse files
borsbors
committed
Auto merge of #124953 - compiler-errors:own-params, r=lcnr
Rename `Generics::params` to `Generics::own_params` I hope this makes it slightly more obvious that `generics.own_params` is insufficient when considering nested items. I didn't actually audit any of the usages, for the record. r? lcnr
2 parents a6e87c5 + 1c19b6a commit 98dabb6

File tree

54 files changed

+179
-171
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

54 files changed

+179
-171
lines changed

Diff for: ‎compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

+29-26
Original file line numberDiff line numberDiff line change
@@ -317,36 +317,39 @@ impl<'tcx> BorrowExplanation<'tcx> {
317317
let mut has_dyn = false;
318318
let mut failed = false;
319319

320-
let elaborated_args = std::iter::zip(*args, &generics.params).map(|(arg, param)| {
321-
if let Some(ty::Dynamic(obj, _, ty::Dyn)) = arg.as_type().map(Ty::kind) {
322-
let default = tcx.object_lifetime_default(param.def_id);
323-
324-
let re_static = tcx.lifetimes.re_static;
325-
326-
let implied_region = match default {
327-
// This is not entirely precise.
328-
ObjectLifetimeDefault::Empty => re_static,
329-
ObjectLifetimeDefault::Ambiguous => {
330-
failed = true;
331-
re_static
332-
}
333-
ObjectLifetimeDefault::Param(param_def_id) => {
334-
let index = generics.param_def_id_to_index[&param_def_id] as usize;
335-
args.get(index).and_then(|arg| arg.as_region()).unwrap_or_else(|| {
320+
let elaborated_args =
321+
std::iter::zip(*args, &generics.own_params).map(|(arg, param)| {
322+
if let Some(ty::Dynamic(obj, _, ty::Dyn)) = arg.as_type().map(Ty::kind) {
323+
let default = tcx.object_lifetime_default(param.def_id);
324+
325+
let re_static = tcx.lifetimes.re_static;
326+
327+
let implied_region = match default {
328+
// This is not entirely precise.
329+
ObjectLifetimeDefault::Empty => re_static,
330+
ObjectLifetimeDefault::Ambiguous => {
336331
failed = true;
337332
re_static
338-
})
339-
}
340-
ObjectLifetimeDefault::Static => re_static,
341-
};
333+
}
334+
ObjectLifetimeDefault::Param(param_def_id) => {
335+
let index = generics.param_def_id_to_index[&param_def_id] as usize;
336+
args.get(index).and_then(|arg| arg.as_region()).unwrap_or_else(
337+
|| {
338+
failed = true;
339+
re_static
340+
},
341+
)
342+
}
343+
ObjectLifetimeDefault::Static => re_static,
344+
};
342345

343-
has_dyn = true;
346+
has_dyn = true;
344347

345-
Ty::new_dynamic(tcx, obj, implied_region, ty::Dyn).into()
346-
} else {
347-
arg
348-
}
349-
});
348+
Ty::new_dynamic(tcx, obj, implied_region, ty::Dyn).into()
349+
} else {
350+
arg
351+
}
352+
});
350353
let elaborated_ty = Ty::new_adt(tcx, *def, tcx.mk_args_from_iter(elaborated_args));
351354

352355
if has_dyn && !failed {

Diff for: ‎compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1281,7 +1281,7 @@ fn build_generic_type_param_di_nodes<'ll, 'tcx>(
12811281
let mut names = generics
12821282
.parent
12831283
.map_or_else(Vec::new, |def_id| get_parameter_names(cx, cx.tcx.generics_of(def_id)));
1284-
names.extend(generics.params.iter().map(|param| param.name));
1284+
names.extend(generics.own_params.iter().map(|param| param.name));
12851285
names
12861286
}
12871287
}

Diff for: ‎compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -512,7 +512,7 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
512512
let mut names = generics.parent.map_or_else(Vec::new, |def_id| {
513513
get_parameter_names(cx, cx.tcx.generics_of(def_id))
514514
});
515-
names.extend(generics.params.iter().map(|param| param.name));
515+
names.extend(generics.own_params.iter().map(|param| param.name));
516516
names
517517
}
518518

Diff for: ‎compiler/rustc_hir_analysis/src/check/check.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -561,7 +561,7 @@ fn check_opaque_precise_captures<'tcx>(tcx: TyCtxt<'tcx>, opaque_def_id: LocalDe
561561
let generics = tcx.generics_of(generics);
562562
def_id = generics.parent;
563563

564-
for param in &generics.params {
564+
for param in &generics.own_params {
565565
if expected_captures.contains(&param.def_id) {
566566
assert_eq!(
567567
variances[param.index as usize],
@@ -778,7 +778,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
778778
let def_id = item.id.owner_id.def_id;
779779
let generics = tcx.generics_of(def_id);
780780
let own_counts = generics.own_counts();
781-
if generics.params.len() - own_counts.lifetimes != 0 {
781+
if generics.own_params.len() - own_counts.lifetimes != 0 {
782782
let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts)
783783
{
784784
(_, 0) => ("type", "types", Some("u32")),
@@ -1544,7 +1544,7 @@ fn check_type_alias_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalD
15441544
.collect::<FxIndexMap<_, _>>()
15451545
});
15461546

1547-
let mut params_used = BitSet::new_empty(generics.params.len());
1547+
let mut params_used = BitSet::new_empty(generics.own_params.len());
15481548
for leaf in ty.walk() {
15491549
if let GenericArgKind::Type(leaf_ty) = leaf.unpack()
15501550
&& let ty::Param(param) = leaf_ty.kind()
@@ -1554,7 +1554,7 @@ fn check_type_alias_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalD
15541554
}
15551555
}
15561556

1557-
for param in &generics.params {
1557+
for param in &generics.own_params {
15581558
if !params_used.contains(param.index)
15591559
&& let ty::GenericParamDefKind::Type { .. } = param.kind
15601560
{

Diff for: ‎compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

+13-11
Original file line numberDiff line numberDiff line change
@@ -716,7 +716,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
716716
// since we previously enforce that the trait method and impl method have the
717717
// same generics.
718718
let num_trait_args = trait_to_impl_args.len();
719-
let num_impl_args = tcx.generics_of(impl_m.container_id(tcx)).params.len();
719+
let num_impl_args = tcx.generics_of(impl_m.container_id(tcx)).own_params.len();
720720
let ty = match ty.try_fold_with(&mut RemapHiddenTyRegions {
721721
tcx,
722722
map,
@@ -1494,14 +1494,16 @@ fn compare_synthetic_generics<'tcx>(
14941494
let mut error_found = None;
14951495
let impl_m_generics = tcx.generics_of(impl_m.def_id);
14961496
let trait_m_generics = tcx.generics_of(trait_m.def_id);
1497-
let impl_m_type_params = impl_m_generics.params.iter().filter_map(|param| match param.kind {
1498-
GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
1499-
GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => None,
1500-
});
1501-
let trait_m_type_params = trait_m_generics.params.iter().filter_map(|param| match param.kind {
1502-
GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
1503-
GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => None,
1504-
});
1497+
let impl_m_type_params =
1498+
impl_m_generics.own_params.iter().filter_map(|param| match param.kind {
1499+
GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
1500+
GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => None,
1501+
});
1502+
let trait_m_type_params =
1503+
trait_m_generics.own_params.iter().filter_map(|param| match param.kind {
1504+
GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
1505+
GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => None,
1506+
});
15051507
for ((impl_def_id, impl_synthetic), (trait_def_id, trait_synthetic)) in
15061508
iter::zip(impl_m_type_params, trait_m_type_params)
15071509
{
@@ -1639,7 +1641,7 @@ fn compare_generic_param_kinds<'tcx>(
16391641
assert_eq!(impl_item.kind, trait_item.kind);
16401642

16411643
let ty_const_params_of = |def_id| {
1642-
tcx.generics_of(def_id).params.iter().filter(|param| {
1644+
tcx.generics_of(def_id).own_params.iter().filter(|param| {
16431645
matches!(
16441646
param.kind,
16451647
GenericParamDefKind::Const { .. } | GenericParamDefKind::Type { .. }
@@ -2140,7 +2142,7 @@ fn param_env_with_gat_bounds<'tcx>(
21402142
};
21412143

21422144
let mut bound_vars: smallvec::SmallVec<[ty::BoundVariableKind; 8]> =
2143-
smallvec::SmallVec::with_capacity(tcx.generics_of(impl_ty.def_id).params.len());
2145+
smallvec::SmallVec::with_capacity(tcx.generics_of(impl_ty.def_id).own_params.len());
21442146
// Extend the impl's identity args with late-bound GAT vars
21452147
let normalize_impl_ty_args = ty::GenericArgs::identity_for_item(tcx, container_id)
21462148
.extend_to(tcx, impl_ty.def_id, |param, _| match param.kind {

Diff for: ‎compiler/rustc_hir_analysis/src/check/wfcheck.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -431,7 +431,7 @@ fn check_gat_where_clauses(tcx: TyCtxt<'_>, trait_def_id: LocalDefId) {
431431
}
432432
let gat_generics = tcx.generics_of(gat_def_id);
433433
// FIXME(jackh726): we can also warn in the more general case
434-
if gat_generics.params.is_empty() {
434+
if gat_generics.own_params.is_empty() {
435435
continue;
436436
}
437437

@@ -1400,7 +1400,7 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
14001400
// struct Foo<T = Vec<[u32]>> { .. }
14011401
//
14021402
// Here, the default `Vec<[u32]>` is not WF because `[u32]: Sized` does not hold.
1403-
for param in &generics.params {
1403+
for param in &generics.own_params {
14041404
match param.kind {
14051405
GenericParamDefKind::Type { .. } => {
14061406
if is_our_default(param) {
@@ -1879,7 +1879,7 @@ fn check_variances_for_type_defn<'tcx>(
18791879
continue;
18801880
}
18811881

1882-
let ty_param = &ty_generics.params[index];
1882+
let ty_param = &ty_generics.own_params[index];
18831883
let hir_param = &hir_generics.params[index];
18841884

18851885
if ty_param.def_id != hir_param.def_id.into() {

Diff for: ‎compiler/rustc_hir_analysis/src/coherence/orphan.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -571,7 +571,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for TyVarReplacer<'cx, 'tcx> {
571571
if let Some(def_id) = origin.param_def_id {
572572
// The generics of an `impl` don't have a parent, we can index directly.
573573
let index = self.generics.param_def_id_to_index[&def_id];
574-
let name = self.generics.params[index as usize].name;
574+
let name = self.generics.own_params[index as usize].name;
575575

576576
Ty::new_param(self.infcx.tcx, index, name)
577577
} else {

Diff for: ‎compiler/rustc_hir_analysis/src/coherence/unsafety.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ pub(super) fn check_item(
1414
trait_def: &TraitDef,
1515
) -> Result<(), ErrorGuaranteed> {
1616
let unsafe_attr =
17-
tcx.generics_of(def_id).params.iter().find(|p| p.pure_wrt_drop).map(|_| "may_dangle");
17+
tcx.generics_of(def_id).own_params.iter().find(|p| p.pure_wrt_drop).map(|_| "may_dangle");
1818
let trait_ref = trait_header.trait_ref.instantiate_identity();
1919

2020
match (trait_def.unsafety, unsafe_attr, trait_header.unsafety, trait_header.polarity) {

Diff for: ‎compiler/rustc_hir_analysis/src/collect/generics_of.rs

+22-21
Original file line numberDiff line numberDiff line change
@@ -22,28 +22,28 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
2222
let trait_def_id = tcx.parent(fn_def_id);
2323
let opaque_ty_generics = tcx.generics_of(opaque_def_id);
2424
let opaque_ty_parent_count = opaque_ty_generics.parent_count;
25-
let mut params = opaque_ty_generics.params.clone();
25+
let mut own_params = opaque_ty_generics.own_params.clone();
2626

2727
let parent_generics = tcx.generics_of(trait_def_id);
28-
let parent_count = parent_generics.parent_count + parent_generics.params.len();
28+
let parent_count = parent_generics.parent_count + parent_generics.own_params.len();
2929

30-
let mut trait_fn_params = tcx.generics_of(fn_def_id).params.clone();
30+
let mut trait_fn_params = tcx.generics_of(fn_def_id).own_params.clone();
3131

32-
for param in &mut params {
32+
for param in &mut own_params {
3333
param.index = param.index + parent_count as u32 + trait_fn_params.len() as u32
3434
- opaque_ty_parent_count as u32;
3535
}
3636

37-
trait_fn_params.extend(params);
38-
params = trait_fn_params;
37+
trait_fn_params.extend(own_params);
38+
own_params = trait_fn_params;
3939

4040
let param_def_id_to_index =
41-
params.iter().map(|param| (param.def_id, param.index)).collect();
41+
own_params.iter().map(|param| (param.def_id, param.index)).collect();
4242

4343
return ty::Generics {
4444
parent: Some(trait_def_id),
4545
parent_count,
46-
params,
46+
own_params,
4747
param_def_id_to_index,
4848
has_self: opaque_ty_generics.has_self,
4949
has_late_bound_regions: opaque_ty_generics.has_late_bound_regions,
@@ -124,17 +124,17 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
124124
let generics = tcx.generics_of(parent_def_id.to_def_id());
125125
let param_def_idx = generics.param_def_id_to_index[&param_id.to_def_id()];
126126
// In the above example this would be .params[..N#0]
127-
let params = generics.params_to(param_def_idx as usize, tcx).to_owned();
127+
let own_params = generics.params_to(param_def_idx as usize, tcx).to_owned();
128128
let param_def_id_to_index =
129-
params.iter().map(|param| (param.def_id, param.index)).collect();
129+
own_params.iter().map(|param| (param.def_id, param.index)).collect();
130130

131131
return ty::Generics {
132132
// we set the parent of these generics to be our parent's parent so that we
133133
// dont end up with args: [N, M, N] for the const default on a struct like this:
134134
// struct Foo<const N: usize, const M: usize = { ... }>;
135135
parent: generics.parent,
136136
parent_count: generics.parent_count,
137-
params,
137+
own_params,
138138
param_def_id_to_index,
139139
has_self: generics.has_self,
140140
has_late_bound_regions: generics.has_late_bound_regions,
@@ -274,17 +274,17 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
274274
parent_has_self = generics.has_self;
275275
host_effect_index = generics.host_effect_index;
276276
own_start = generics.count() as u32;
277-
generics.parent_count + generics.params.len()
277+
generics.parent_count + generics.own_params.len()
278278
});
279279

280-
let mut params: Vec<_> = Vec::with_capacity(hir_generics.params.len() + has_self as usize);
280+
let mut own_params: Vec<_> = Vec::with_capacity(hir_generics.params.len() + has_self as usize);
281281

282282
if let Some(opt_self) = opt_self {
283-
params.push(opt_self);
283+
own_params.push(opt_self);
284284
}
285285

286286
let early_lifetimes = super::early_bound_lifetimes_from_generics(tcx, hir_generics);
287-
params.extend(early_lifetimes.enumerate().map(|(i, param)| ty::GenericParamDef {
287+
own_params.extend(early_lifetimes.enumerate().map(|(i, param)| ty::GenericParamDef {
288288
name: param.name.ident().name,
289289
index: own_start + i as u32,
290290
def_id: param.def_id.to_def_id(),
@@ -293,7 +293,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
293293
}));
294294

295295
// Now create the real type and const parameters.
296-
let type_start = own_start - has_self as u32 + params.len() as u32;
296+
let type_start = own_start - has_self as u32 + own_params.len() as u32;
297297
let mut i: u32 = 0;
298298
let mut next_index = || {
299299
let prev = i;
@@ -304,7 +304,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
304304
const TYPE_DEFAULT_NOT_ALLOWED: &'static str = "defaults for type parameters are only allowed in \
305305
`struct`, `enum`, `type`, or `trait` definitions";
306306

307-
params.extend(hir_generics.params.iter().filter_map(|param| match param.kind {
307+
own_params.extend(hir_generics.params.iter().filter_map(|param| match param.kind {
308308
GenericParamKind::Lifetime { .. } => None,
309309
GenericParamKind::Type { default, synthetic, .. } => {
310310
if default.is_some() {
@@ -404,7 +404,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
404404
][..],
405405
};
406406

407-
params.extend(dummy_args.iter().map(|&arg| ty::GenericParamDef {
407+
own_params.extend(dummy_args.iter().map(|&arg| ty::GenericParamDef {
408408
index: next_index(),
409409
name: Symbol::intern(arg),
410410
def_id: def_id.to_def_id(),
@@ -415,7 +415,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
415415

416416
// provide junk type parameter defs for const blocks.
417417
if let Node::ConstBlock(_) = node {
418-
params.push(ty::GenericParamDef {
418+
own_params.push(ty::GenericParamDef {
419419
index: next_index(),
420420
name: Symbol::intern("<const_ty>"),
421421
def_id: def_id.to_def_id(),
@@ -424,12 +424,13 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
424424
});
425425
}
426426

427-
let param_def_id_to_index = params.iter().map(|param| (param.def_id, param.index)).collect();
427+
let param_def_id_to_index =
428+
own_params.iter().map(|param| (param.def_id, param.index)).collect();
428429

429430
ty::Generics {
430431
parent: parent_def_id,
431432
parent_count,
432-
params,
433+
own_params,
433434
param_def_id_to_index,
434435
has_self: has_self || parent_has_self,
435436
has_late_bound_regions: has_late_bound_regions(tcx, node),

Diff for: ‎compiler/rustc_hir_analysis/src/collect/predicates_of.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -73,8 +73,8 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
7373
// opaque lifetimes, which explains the slicing below.
7474
compute_bidirectional_outlives_predicates(
7575
tcx,
76-
&tcx.generics_of(def_id.to_def_id()).params
77-
[tcx.generics_of(fn_def_id).params.len()..],
76+
&tcx.generics_of(def_id.to_def_id()).own_params
77+
[tcx.generics_of(fn_def_id).own_params.len()..],
7878
&mut predicates,
7979
);
8080

@@ -300,7 +300,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
300300
};
301301
debug!(?lifetimes);
302302

303-
compute_bidirectional_outlives_predicates(tcx, &generics.params, &mut predicates);
303+
compute_bidirectional_outlives_predicates(tcx, &generics.own_params, &mut predicates);
304304
debug!(?predicates);
305305
}
306306

Diff for: ‎compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

+4-3
Original file line numberDiff line numberDiff line change
@@ -1562,7 +1562,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
15621562
ObjectLifetimeDefault::Ambiguous => None,
15631563
};
15641564
generics
1565-
.params
1565+
.own_params
15661566
.iter()
15671567
.filter_map(|param| {
15681568
match self.tcx.def_kind(param.def_id) {
@@ -1668,7 +1668,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
16681668
binding.ident,
16691669
ty::AssocKind::Fn,
16701670
) {
1671-
bound_vars.extend(self.tcx.generics_of(assoc_fn.def_id).params.iter().map(
1671+
bound_vars.extend(self.tcx.generics_of(assoc_fn.def_id).own_params.iter().map(
16721672
|param| match param.kind {
16731673
ty::GenericParamDefKind::Lifetime => ty::BoundVariableKind::Region(
16741674
ty::BoundRegionKind::BrNamed(param.def_id, param.name),
@@ -2003,7 +2003,8 @@ fn is_late_bound_map(
20032003
// just consider args to be unconstrained.
20042004
let generics = self.tcx.generics_of(alias_def);
20052005
let mut walker = ConstrainedCollectorPostHirTyLowering {
2006-
arg_is_constrained: vec![false; generics.params.len()].into_boxed_slice(),
2006+
arg_is_constrained: vec![false; generics.own_params.len()]
2007+
.into_boxed_slice(),
20072008
};
20082009
walker.visit_ty(self.tcx.type_of(alias_def).instantiate_identity());
20092010

0 commit comments

Comments
 (0)