Skip to content

Commit 6c02c7d

Browse files
BoxyUwUBoxyUwU
committed
Introduce feature(generic_const_parameter_types) 
1 parent ad27045 commit 6c02c7d

File tree

54 files changed

+353
-153
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

+353
-153
lines changed

‎compiler/rustc_feature/src/unstable.rs

+2
Original file line numberDiff line numberDiff line change
@@ -508,6 +508,8 @@ declare_features! (
508508
(incomplete, generic_const_exprs, "1.56.0", Some(76560)),
509509
/// Allows generic parameters and where-clauses on free & associated const items.
510510
(incomplete, generic_const_items, "1.73.0", Some(113521)),
511+
/// Allows the type of const generics to depend on generic parameters
512+
(incomplete, generic_const_parameter_types, "CURRENT_RUSTC_VERSION", None),
511513
/// Allows any generic constants being used as pattern type range ends
512514
(incomplete, generic_pattern_types, "1.86.0", Some(136574)),
513515
/// Allows registering static items globally, possibly across crates, to iterate over at runtime.

‎compiler/rustc_hir_analysis/src/check/wfcheck.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -966,7 +966,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
966966
let ty = tcx.type_of(param.def_id).instantiate_identity();
967967

968968
if tcx.features().unsized_const_params() {
969-
enter_wf_checking_ctxt(tcx, hir_ty.span, param.def_id, |wfcx| {
969+
enter_wf_checking_ctxt(tcx, hir_ty.span, tcx.local_parent(param.def_id), |wfcx| {
970970
wfcx.register_bound(
971971
ObligationCause::new(
972972
hir_ty.span,
@@ -980,7 +980,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
980980
Ok(())
981981
})
982982
} else if tcx.features().adt_const_params() {
983-
enter_wf_checking_ctxt(tcx, hir_ty.span, param.def_id, |wfcx| {
983+
enter_wf_checking_ctxt(tcx, hir_ty.span, tcx.local_parent(param.def_id), |wfcx| {
984984
wfcx.register_bound(
985985
ObligationCause::new(
986986
hir_ty.span,

‎compiler/rustc_hir_analysis/src/collect.rs

+4-1
Original file line numberDiff line numberDiff line change
@@ -1823,6 +1823,9 @@ fn const_param_default<'tcx>(
18231823
),
18241824
};
18251825
let icx = ItemCtxt::new(tcx, def_id);
1826-
let ct = icx.lowerer().lower_const_arg(default_ct, FeedConstTy::Param(def_id.to_def_id()));
1826+
let identity_args = ty::GenericArgs::identity_for_item(tcx, def_id);
1827+
let ct = icx
1828+
.lowerer()
1829+
.lower_const_arg(default_ct, FeedConstTy::Param(def_id.to_def_id(), identity_args));
18271830
ty::EarlyBinder::bind(ct)
18281831
}

‎compiler/rustc_hir_analysis/src/collect/predicates_of.rs

+1-4
Original file line numberDiff line numberDiff line change
@@ -223,10 +223,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
223223
}
224224
hir::GenericParamKind::Const { .. } => {
225225
let param_def_id = param.def_id.to_def_id();
226-
let ct_ty = tcx
227-
.type_of(param_def_id)
228-
.no_bound_vars()
229-
.expect("const parameters cannot be generic");
226+
let ct_ty = tcx.type_of(param_def_id).instantiate_identity();
230227
let ct = icx.lowerer().lower_const_param(param_def_id, param.hir_id);
231228
predicates
232229
.insert((ty::ClauseKind::ConstArgHasType(ct, ct_ty).upcast(tcx), param.span));

‎compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -273,7 +273,7 @@ pub fn lower_generic_args<'tcx: 'a, 'a>(
273273

274274
// We lower to an infer even when the feature gate is not enabled
275275
// as it is useful for diagnostics to be able to see a `ConstKind::Infer`
276-
args.push(ctx.provided_kind(param, arg));
276+
args.push(ctx.provided_kind(&args, param, arg));
277277
args_iter.next();
278278
params.next();
279279
}

‎compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

+35-12
Original file line numberDiff line numberDiff line change
@@ -232,12 +232,12 @@ impl AssocItemQSelf {
232232
/// Use this enum with `<dyn HirTyLowerer>::lower_const_arg` to instruct it with the
233233
/// desired behavior.
234234
#[derive(Debug, Clone, Copy)]
235-
pub enum FeedConstTy {
235+
pub enum FeedConstTy<'a, 'tcx> {
236236
/// Feed the type.
237237
///
238238
/// The `DefId` belongs to the const param that we are supplying
239239
/// this (anon) const arg to.
240-
Param(DefId),
240+
Param(DefId, &'a [ty::GenericArg<'tcx>]),
241241
/// Don't feed the type.
242242
No,
243243
}
@@ -298,6 +298,7 @@ pub trait GenericArgsLowerer<'a, 'tcx> {
298298

299299
fn provided_kind(
300300
&mut self,
301+
preceding_args: &[ty::GenericArg<'tcx>],
301302
param: &ty::GenericParamDef,
302303
arg: &GenericArg<'tcx>,
303304
) -> ty::GenericArg<'tcx>;
@@ -481,6 +482,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
481482

482483
fn provided_kind(
483484
&mut self,
485+
preceding_args: &[ty::GenericArg<'tcx>],
484486
param: &ty::GenericParamDef,
485487
arg: &GenericArg<'tcx>,
486488
) -> ty::GenericArg<'tcx> {
@@ -526,7 +528,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
526528
(GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => self
527529
.lowerer
528530
// Ambig portions of `ConstArg` are handled in the match arm below
529-
.lower_const_arg(ct.as_unambig_ct(), FeedConstTy::Param(param.def_id))
531+
.lower_const_arg(
532+
ct.as_unambig_ct(),
533+
FeedConstTy::Param(param.def_id, preceding_args),
534+
)
530535
.into(),
531536
(&GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
532537
self.lowerer.ct_infer(Some(param), inf.span).into()
@@ -582,8 +587,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
582587
let ty = tcx
583588
.at(self.span)
584589
.type_of(param.def_id)
585-
.no_bound_vars()
586-
.expect("const parameter types cannot be generic");
590+
.instantiate(tcx, preceding_args);
587591
if let Err(guar) = ty.error_reported() {
588592
return ty::Const::new_error(tcx, guar).into();
589593
}
@@ -2107,14 +2111,33 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
21072111
pub fn lower_const_arg(
21082112
&self,
21092113
const_arg: &hir::ConstArg<'tcx>,
2110-
feed: FeedConstTy,
2114+
feed: FeedConstTy<'_, 'tcx>,
21112115
) -> Const<'tcx> {
21122116
let tcx = self.tcx();
21132117

2114-
if let FeedConstTy::Param(param_def_id) = feed
2118+
if let FeedConstTy::Param(param_def_id, args) = feed
21152119
&& let hir::ConstArgKind::Anon(anon) = &const_arg.kind
21162120
{
2117-
tcx.feed_anon_const_type(anon.def_id, tcx.type_of(param_def_id));
2121+
let anon_const_type = tcx.type_of(param_def_id).instantiate(tcx, args);
2122+
2123+
// We must error if the instantiated type has any inference variables as we will
2124+
// use this type to feed the `type_of` and query results must not contain inference
2125+
// variables otherwise we will ICE.
2126+
//
2127+
// FIXME(generic_const_parameter_types): Ideally we remove this one day when we
2128+
// have the ability to intermix typeck of anon const const args with the parent
2129+
// bodies typeck.
2130+
if anon_const_type.has_infer() {
2131+
let e =
2132+
tcx.dcx().span_err(const_arg.span(), "Type of const argument is uninferred");
2133+
tcx.feed_anon_const_type(anon.def_id, ty::EarlyBinder::bind(Ty::new_error(tcx, e)));
2134+
return ty::Const::new_error(tcx, e);
2135+
}
2136+
2137+
tcx.feed_anon_const_type(
2138+
anon.def_id,
2139+
ty::EarlyBinder::bind(tcx.type_of(param_def_id).instantiate(tcx, args)),
2140+
);
21182141
}
21192142

21202143
let hir_id = const_arg.hir_id;
@@ -2230,10 +2253,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
22302253
let expr = &tcx.hir_body(anon.body).value;
22312254
debug!(?expr);
22322255

2233-
let ty = tcx
2234-
.type_of(anon.def_id)
2235-
.no_bound_vars()
2236-
.expect("const parameter types cannot be generic");
2256+
// FIXME(generic_const_parameter_types): We should use the proper generic args
2257+
// here. It's only used as a hint for literals so doesn't matter too much to use the right
2258+
// generic arguments, just weaker type inference.
2259+
let ty = tcx.type_of(anon.def_id).instantiate_identity();
22372260

22382261
match self.try_lower_anon_const_lit(ty, expr) {
22392262
Some(v) => v,

‎compiler/rustc_hir_analysis/src/lib.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -260,7 +260,7 @@ pub fn lower_ty<'tcx>(tcx: TyCtxt<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
260260
pub fn lower_const_arg_for_rustdoc<'tcx>(
261261
tcx: TyCtxt<'tcx>,
262262
hir_ct: &hir::ConstArg<'tcx>,
263-
feed: FeedConstTy,
263+
feed: FeedConstTy<'_, 'tcx>,
264264
) -> Const<'tcx> {
265265
let env_def_id = tcx.hir_get_parent_item(hir_ct.hir_id);
266266
collect::ItemCtxt::new(tcx, env_def_id.def_id).lowerer().lower_const_arg(hir_ct, feed)

‎compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

+18-3
Original file line numberDiff line numberDiff line change
@@ -519,7 +519,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
519519
pub(crate) fn lower_const_arg(
520520
&self,
521521
const_arg: &'tcx hir::ConstArg<'tcx>,
522-
feed: FeedConstTy,
522+
feed: FeedConstTy<'_, 'tcx>,
523523
) -> ty::Const<'tcx> {
524524
let ct = self.lowerer().lower_const_arg(const_arg, feed);
525525
self.register_wf_obligation(
@@ -1261,6 +1261,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
12611261

12621262
fn provided_kind(
12631263
&mut self,
1264+
preceding_args: &[ty::GenericArg<'tcx>],
12641265
param: &ty::GenericParamDef,
12651266
arg: &GenericArg<'tcx>,
12661267
) -> ty::GenericArg<'tcx> {
@@ -1280,7 +1281,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
12801281
(GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => self
12811282
.fcx
12821283
// Ambiguous parts of `ConstArg` are handled in the match arms below
1283-
.lower_const_arg(ct.as_unambig_ct(), FeedConstTy::Param(param.def_id))
1284+
.lower_const_arg(
1285+
ct.as_unambig_ct(),
1286+
FeedConstTy::Param(param.def_id, preceding_args),
1287+
)
12841288
.into(),
12851289
(&GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
12861290
self.fcx.ct_infer(Some(param), inf.span).into()
@@ -1351,7 +1355,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
13511355
let ty = tcx.type_of(def_id);
13521356
assert!(!args.has_escaping_bound_vars());
13531357
assert!(!ty.skip_binder().has_escaping_bound_vars());
1354-
let ty_instantiated = self.normalize(span, ty.instantiate(tcx, args));
1358+
1359+
let ty_instantiated = self.normalize(
1360+
span,
1361+
match res {
1362+
// types of const parameters are somewhat special as they are part of
1363+
// the same environment as the const parameter itself. this means that
1364+
// unlike most paths `type-of(N)` can return a type naming parameters
1365+
// introduced by the containing item, rather than provided through `N`.
1366+
Res::Def(DefKind::ConstParam, _) => ty.instantiate_identity(),
1367+
_ => ty.instantiate(tcx, args),
1368+
},
1369+
);
13551370

13561371
if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
13571372
// In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`

‎compiler/rustc_hir_typeck/src/method/confirm.rs

+5-1
Original file line numberDiff line numberDiff line change
@@ -426,6 +426,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
426426

427427
fn provided_kind(
428428
&mut self,
429+
preceding_args: &[ty::GenericArg<'tcx>],
429430
param: &ty::GenericParamDef,
430431
arg: &GenericArg<'tcx>,
431432
) -> ty::GenericArg<'tcx> {
@@ -446,7 +447,10 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
446447
(GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => self
447448
.cfcx
448449
// We handle the ambig portions of `ConstArg` in the match arms below
449-
.lower_const_arg(ct.as_unambig_ct(), FeedConstTy::Param(param.def_id))
450+
.lower_const_arg(
451+
ct.as_unambig_ct(),
452+
FeedConstTy::Param(param.def_id, preceding_args),
453+
)
450454
.into(),
451455
(GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
452456
self.cfcx.ct_infer(Some(param), inf.span).into()

‎compiler/rustc_middle/src/ty/sty.rs

+1
Original file line numberDiff line numberDiff line change
@@ -342,6 +342,7 @@ impl ParamConst {
342342
ParamConst::new(def.index, def.name)
343343
}
344344

345+
#[instrument(level = "debug")]
345346
pub fn find_ty_from_env<'tcx>(self, env: ParamEnv<'tcx>) -> Ty<'tcx> {
346347
let mut candidates = env.caller_bounds().iter().filter_map(|clause| {
347348
// `ConstArgHasType` are never desugared to be higher ranked.

‎compiler/rustc_resolve/messages.ftl

-9
Original file line numberDiff line numberDiff line change
@@ -125,9 +125,6 @@ resolve_const_param_in_enum_discriminant =
125125
resolve_const_param_in_non_trivial_anon_const =
126126
const parameters may only be used as standalone arguments, i.e. `{$name}`
127127
128-
resolve_const_param_in_ty_of_const_param =
129-
const parameters may not be used in the type of const parameters
130-
131128
resolve_constructor_private_if_any_field_private =
132129
a constructor is private if any of the fields is private
133130
@@ -250,9 +247,6 @@ resolve_lifetime_param_in_enum_discriminant =
250247
resolve_lifetime_param_in_non_trivial_anon_const =
251248
lifetime parameters may not be used in const expressions
252249
253-
resolve_lifetime_param_in_ty_of_const_param =
254-
lifetime parameters may not be used in the type of const parameters
255-
256250
resolve_lowercase_self =
257251
attempt to use a non-constant value in a constant
258252
.suggestion = try using `Self`
@@ -437,9 +431,6 @@ resolve_type_param_in_enum_discriminant =
437431
resolve_type_param_in_non_trivial_anon_const =
438432
type parameters may not be used in const expressions
439433
440-
resolve_type_param_in_ty_of_const_param =
441-
type parameters may not be used in the type of const parameters
442-
443434
resolve_undeclared_label =
444435
use of undeclared label `{$name}`
445436
.label = undeclared label `{$name}`

‎compiler/rustc_resolve/src/diagnostics.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -890,9 +890,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
890890
ResolutionError::ForwardDeclaredGenericParam => {
891891
self.dcx().create_err(errs::ForwardDeclaredGenericParam { span })
892892
}
893-
ResolutionError::ParamInTyOfConstParam { name, param_kind: is_type } => self
894-
.dcx()
895-
.create_err(errs::ParamInTyOfConstParam { span, name, param_kind: is_type }),
893+
ResolutionError::ParamInTyOfConstParam { name } => {
894+
self.dcx().create_err(errs::ParamInTyOfConstParam { span, name })
895+
}
896896
ResolutionError::ParamInNonTrivialAnonConst { name, param_kind: is_type } => {
897897
self.dcx().create_err(errs::ParamInNonTrivialAnonConst {
898898
span,

‎compiler/rustc_resolve/src/errors.rs

-13
Original file line numberDiff line numberDiff line change
@@ -347,19 +347,6 @@ pub(crate) struct ParamInTyOfConstParam {
347347
#[label]
348348
pub(crate) span: Span,
349349
pub(crate) name: Symbol,
350-
#[subdiagnostic]
351-
pub(crate) param_kind: Option<ParamKindInTyOfConstParam>,
352-
}
353-
354-
#[derive(Debug)]
355-
#[derive(Subdiagnostic)]
356-
pub(crate) enum ParamKindInTyOfConstParam {
357-
#[note(resolve_type_param_in_ty_of_const_param)]
358-
Type,
359-
#[note(resolve_const_param_in_ty_of_const_param)]
360-
Const,
361-
#[note(resolve_lifetime_param_in_ty_of_const_param)]
362-
Lifetime,
363350
}
364351

365352
#[derive(Diagnostic)]

‎compiler/rustc_resolve/src/ident.rs

+14-28
Original file line numberDiff line numberDiff line change
@@ -1131,6 +1131,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
11311131
return Res::Err;
11321132
}
11331133

1134+
if let RibKind::ConstParamTy = all_ribs[rib_index].kind {
1135+
if let Some(span) = finalize {
1136+
self.report_error(
1137+
span,
1138+
ResolutionError::ParamInTyOfConstParam { name: rib_ident.name },
1139+
);
1140+
}
1141+
assert_eq!(res, Res::Err);
1142+
return Res::Err;
1143+
}
1144+
11341145
match res {
11351146
Res::Local(_) => {
11361147
use ResolutionError::*;
@@ -1209,10 +1220,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
12091220
if let Some(span) = finalize {
12101221
self.report_error(
12111222
span,
1212-
ParamInTyOfConstParam {
1213-
name: rib_ident.name,
1214-
param_kind: None,
1215-
},
1223+
ParamInTyOfConstParam { name: rib_ident.name },
12161224
);
12171225
}
12181226
return Res::Err;
@@ -1239,6 +1247,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
12391247
| RibKind::MacroDefinition(..)
12401248
| RibKind::InlineAsmSym
12411249
| RibKind::AssocItem
1250+
| RibKind::ConstParamTy
12421251
| RibKind::ForwardGenericParamBan => {
12431252
// Nothing to do. Continue.
12441253
continue;
@@ -1292,18 +1301,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
12921301
RibKind::Item(has_generic_params, def_kind) => {
12931302
(has_generic_params, def_kind)
12941303
}
1295-
RibKind::ConstParamTy => {
1296-
if let Some(span) = finalize {
1297-
self.report_error(
1298-
span,
1299-
ResolutionError::ParamInTyOfConstParam {
1300-
name: rib_ident.name,
1301-
param_kind: Some(errors::ParamKindInTyOfConstParam::Type),
1302-
},
1303-
);
1304-
}
1305-
return Res::Err;
1306-
}
13071304
};
13081305

13091306
if let Some(span) = finalize {
@@ -1328,6 +1325,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
13281325
| RibKind::MacroDefinition(..)
13291326
| RibKind::InlineAsmSym
13301327
| RibKind::AssocItem
1328+
| RibKind::ConstParamTy
13311329
| RibKind::ForwardGenericParamBan => continue,
13321330

13331331
RibKind::ConstantItem(trivial, _) => {
@@ -1361,18 +1359,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
13611359
RibKind::Item(has_generic_params, def_kind) => {
13621360
(has_generic_params, def_kind)
13631361
}
1364-
RibKind::ConstParamTy => {
1365-
if let Some(span) = finalize {
1366-
self.report_error(
1367-
span,
1368-
ResolutionError::ParamInTyOfConstParam {
1369-
name: rib_ident.name,
1370-
param_kind: Some(errors::ParamKindInTyOfConstParam::Const),
1371-
},
1372-
);
1373-
}
1374-
return Res::Err;
1375-
}
13761362
};
13771363

13781364
// This was an attempt to use a const parameter outside its scope.

0 commit comments

Comments
 (0)