bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Basic removal of Ty from places (boring)

Browse source
This commit is contained in:
Boxy 2024-06-03 01:10:24 +01:00
parent 7ebd2bdbf6
commit 58feec9b85
71 changed files with 331 additions and 581 deletions
Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_borrowck/src/type_check/relate_tys.rs
View file

@ -193,7 +193,7 @@ impl<'me, 'bccx, 'tcx> NllTypeRelating<'me, 'bccx, 'tcx> {
types: &mut |_bound_ty: ty::BoundTy| { types: &mut |_bound_ty: ty::BoundTy| {
unreachable!("we only replace regions in nll_relate, not types") unreachable!("we only replace regions in nll_relate, not types")
}, },
consts: &mut |_bound_var: ty::BoundVar, _ty| { consts: &mut |_bound_var: ty::BoundVar| {
unreachable!("we only replace regions in nll_relate, not consts") unreachable!("we only replace regions in nll_relate, not consts")
}, },
}; };
@ -231,7 +231,7 @@ impl<'me, 'bccx, 'tcx> NllTypeRelating<'me, 'bccx, 'tcx> {
types: &mut |_bound_ty: ty::BoundTy| { types: &mut |_bound_ty: ty::BoundTy| {
unreachable!("we only replace regions in nll_relate, not types") unreachable!("we only replace regions in nll_relate, not types")
}, },
consts: &mut |_bound_var: ty::BoundVar, _ty| { consts: &mut |_bound_var: ty::BoundVar| {
unreachable!("we only replace regions in nll_relate, not consts") unreachable!("we only replace regions in nll_relate, not consts")
}, },
}; };

3
compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
View file

@ -693,7 +693,8 @@ fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut S
ty::ConstKind::Param(param) => { ty::ConstKind::Param(param) => {
write!(output, "{}", param.name) write!(output, "{}", param.name)
} }
_ => match ct.ty().kind() { // THISPR
_ => match { todo!() as Ty<'tcx> }.kind() {
ty::Int(ity) => { ty::Int(ity) => {
let bits = ct.eval_bits(tcx, ty::ParamEnv::reveal_all()); let bits = ct.eval_bits(tcx, ty::ParamEnv::reveal_all());
let val = Integer::from_int_ty(&tcx, *ity).size().sign_extend(bits) as i128; let val = Integer::from_int_ty(&tcx, *ity).size().sign_extend(bits) as i128;

3
compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
View file

@ -2198,9 +2198,6 @@ fn param_env_with_gat_bounds<'tcx>(
tcx, tcx,
ty::INNERMOST, ty::INNERMOST,
ty::BoundVar::from_usize(bound_vars.len() - 1), ty::BoundVar::from_usize(bound_vars.len() - 1),
tcx.type_of(param.def_id)
.no_bound_vars()
.expect("const parameter types cannot be generic"),
) )
.into() .into()
} }

12
compiler/rustc_hir_analysis/src/collect.rs
View file

@ -396,16 +396,8 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
Ty::new_error_with_message(self.tcx(), span, "bad placeholder type") Ty::new_error_with_message(self.tcx(), span, "bad placeholder type")
} }
fn ct_infer(&self, ty: Ty<'tcx>, _: Option<&ty::GenericParamDef>, span: Span) -> Const<'tcx> { fn ct_infer(&self, _: Option<&ty::GenericParamDef>, span: Span) -> Const<'tcx> {
let ty = self.tcx.fold_regions(ty, |r, _| match *r { ty::Const::new_error_with_message(self.tcx(), span, "bad placeholder constant")
rustc_type_ir::RegionKind::ReStatic => r,
// This is never reached in practice. If it ever is reached,
// `ReErased` should be changed to `ReStatic`, and any other region
// left alone.
r => bug!("unexpected region: {r:?}"),
});
ty::Const::new_error_with_message(self.tcx(), ty, span, "bad placeholder constant")
} }
fn probe_ty_param_bounds( fn probe_ty_param_bounds(

2
compiler/rustc_hir_analysis/src/collect/predicates_of.rs
View file

@ -196,7 +196,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
.type_of(param.def_id.to_def_id()) .type_of(param.def_id.to_def_id())
.no_bound_vars() .no_bound_vars()
.expect("const parameters cannot be generic"); .expect("const parameters cannot be generic");
let ct = icx.lowerer().lower_const_param(param.hir_id, ct_ty); let ct = icx.lowerer().lower_const_param(param.hir_id);
predicates predicates
.insert((ty::ClauseKind::ConstArgHasType(ct, ct_ty).upcast(tcx), param.span)); .insert((ty::ClauseKind::ConstArgHasType(ct, ct_ty).upcast(tcx), param.span));
} }

6
compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
View file

@ -368,11 +368,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
}, },
) )
}); });
let ty = tcx ty::Const::new_error(tcx, guar).into()
.type_of(param.def_id)
.no_bound_vars()
.expect("ct params cannot have early bound vars");
ty::Const::new_error(tcx, guar, ty).into()
} }
}; };
num_bound_vars += 1; num_bound_vars += 1;

47
compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
View file

@ -111,12 +111,7 @@ pub trait HirTyLowerer<'tcx> {
fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx>; fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx>;
/// Returns the const to use when a const is omitted. /// Returns the const to use when a const is omitted.
fn ct_infer( fn ct_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Const<'tcx>;
&self,
ty: Ty<'tcx>,
param: Option<&ty::GenericParamDef>,
span: Span,
) -> Const<'tcx>;
/// Probe bounds in scope where the bounded type coincides with the given type parameter. /// Probe bounds in scope where the bounded type coincides with the given type parameter.
/// ///
@ -439,7 +434,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
fn provided_kind( fn provided_kind(
&mut self, &mut self,
preceding_args: &[ty::GenericArg<'tcx>], _preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef, param: &ty::GenericParamDef,
arg: &GenericArg<'tcx>, arg: &GenericArg<'tcx>,
) -> ty::GenericArg<'tcx> { ) -> ty::GenericArg<'tcx> {
@ -447,7 +442,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
if let Err(incorrect) = self.incorrect_args { if let Err(incorrect) = self.incorrect_args {
if incorrect.invalid_args.contains(&(param.index as usize)) { if incorrect.invalid_args.contains(&(param.index as usize)) {
return param.to_error(tcx, preceding_args); return param.to_error(tcx);
} }
} }
@ -487,12 +482,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
ty::Const::from_anon_const(tcx, did).into() ty::Const::from_anon_const(tcx, did).into()
} }
(&GenericParamDefKind::Const { .. }, hir::GenericArg::Infer(inf)) => { (&GenericParamDefKind::Const { .. }, hir::GenericArg::Infer(inf)) => {
let ty = tcx self.lowerer.ct_infer(Some(param), inf.span).into()
.at(self.span)
.type_of(param.def_id)
.no_bound_vars()
.expect("const parameter types cannot be generic");
self.lowerer.ct_infer(ty, Some(param), inf.span).into()
} }
(kind, arg) => span_bug!( (kind, arg) => span_bug!(
self.span, self.span,
@ -511,7 +501,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
if let Err(incorrect) = self.incorrect_args { if let Err(incorrect) = self.incorrect_args {
if incorrect.invalid_args.contains(&(param.index as usize)) { if incorrect.invalid_args.contains(&(param.index as usize)) {
return param.to_error(tcx, preceding_args); return param.to_error(tcx);
} }
} }
match param.kind { match param.kind {
@ -548,7 +538,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
.no_bound_vars() .no_bound_vars()
.expect("const parameter types cannot be generic"); .expect("const parameter types cannot be generic");
if let Err(guar) = ty.error_reported() { if let Err(guar) = ty.error_reported() {
return ty::Const::new_error(tcx, guar, ty).into(); return ty::Const::new_error(tcx, guar).into();
} }
// FIXME(effects) see if we should special case effect params here // FIXME(effects) see if we should special case effect params here
if !infer_args && has_default { if !infer_args && has_default {
@ -557,10 +547,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
.into() .into()
} else { } else {
if infer_args { if infer_args {
self.lowerer.ct_infer(ty, Some(param), self.span).into() self.lowerer.ct_infer(Some(param), self.span).into()
} else { } else {
// We've already errored above about the mismatch. // We've already errored above about the mismatch.
ty::Const::new_misc_error(tcx, ty).into() ty::Const::new_misc_error(tcx).into()
} }
} }
} }
@ -1908,7 +1898,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
/// ///
/// Early-bound const parameters get lowered to [`ty::ConstKind::Param`] /// Early-bound const parameters get lowered to [`ty::ConstKind::Param`]
/// and late-bound ones to [`ty::ConstKind::Bound`]. /// and late-bound ones to [`ty::ConstKind::Bound`].
pub(crate) fn lower_const_param(&self, hir_id: HirId, param_ty: Ty<'tcx>) -> Const<'tcx> { pub(crate) fn lower_const_param(&self, hir_id: HirId) -> Const<'tcx> {
let tcx = self.tcx(); let tcx = self.tcx();
match tcx.named_bound_var(hir_id) { match tcx.named_bound_var(hir_id) {
Some(rbv::ResolvedArg::EarlyBound(def_id)) => { Some(rbv::ResolvedArg::EarlyBound(def_id)) => {
@ -1918,12 +1908,12 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
let generics = tcx.generics_of(item_def_id); let generics = tcx.generics_of(item_def_id);
let index = generics.param_def_id_to_index[&def_id]; let index = generics.param_def_id_to_index[&def_id];
let name = tcx.item_name(def_id); let name = tcx.item_name(def_id);
ty::Const::new_param(tcx, ty::ParamConst::new(index, name), param_ty) ty::Const::new_param(tcx, ty::ParamConst::new(index, name))
} }
Some(rbv::ResolvedArg::LateBound(debruijn, index, _)) => { Some(rbv::ResolvedArg::LateBound(debruijn, index, _)) => {
ty::Const::new_bound(tcx, debruijn, ty::BoundVar::from_u32(index), param_ty) ty::Const::new_bound(tcx, debruijn, ty::BoundVar::from_u32(index))
} }
Some(rbv::ResolvedArg::Error(guar)) => ty::Const::new_error(tcx, guar, param_ty), Some(rbv::ResolvedArg::Error(guar)) => ty::Const::new_error(tcx, guar),
arg => bug!("unexpected bound var resolution for {:?}: {arg:?}", hir_id), arg => bug!("unexpected bound var resolution for {:?}: {arg:?}", hir_id),
} }
} }
@ -2139,7 +2129,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
} }
hir::TyKind::Array(ty, length) => { hir::TyKind::Array(ty, length) => {
let length = match length { let length = match length {
hir::ArrayLen::Infer(inf) => self.ct_infer(tcx.types.usize, None, inf.span), hir::ArrayLen::Infer(inf) => self.ct_infer(None, inf.span),
hir::ArrayLen::Body(constant) => { hir::ArrayLen::Body(constant) => {
ty::Const::from_anon_const(tcx, constant.def_id) ty::Const::from_anon_const(tcx, constant.def_id)
} }
@ -2177,7 +2167,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
match tcx.lit_to_const(lit_input) { match tcx.lit_to_const(lit_input) {
Ok(c) => c, Ok(c) => c,
Err(LitToConstError::Reported(err)) => { Err(LitToConstError::Reported(err)) => {
ty::Const::new_error(tcx, err, ty) ty::Const::new_error(tcx, err)
} }
Err(LitToConstError::TypeError) => todo!(), Err(LitToConstError::TypeError) => todo!(),
} }
@ -2198,19 +2188,20 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
.type_of(def_id) .type_of(def_id)
.no_bound_vars() .no_bound_vars()
.expect("const parameter types cannot be generic"); .expect("const parameter types cannot be generic");
self.lower_const_param(expr.hir_id, ty) self.lower_const_param(expr.hir_id)
} }
_ => { _ => {
let err = tcx let err = tcx
.dcx() .dcx()
.emit_err(crate::errors::NonConstRange { span: expr.span }); .emit_err(crate::errors::NonConstRange { span: expr.span });
ty::Const::new_error(tcx, err, ty) ty::Const::new_error(tcx, err)
} }
}; };
self.record_ty(expr.hir_id, c.ty(), expr.span); // THISPR
self.record_ty(expr.hir_id, todo!(), expr.span);
if let Some((id, span)) = neg { if let Some((id, span)) = neg {
self.record_ty(id, c.ty(), span); self.record_ty(id, todo!(), span);
} }
c c
}; };

3
compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs
View file

@ -144,7 +144,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
let references_self = match pred.skip_binder().term.unpack() { let references_self = match pred.skip_binder().term.unpack() {
ty::TermKind::Ty(ty) => ty.walk().any(|arg| arg == dummy_self.into()), ty::TermKind::Ty(ty) => ty.walk().any(|arg| arg == dummy_self.into()),
ty::TermKind::Const(c) => { ty::TermKind::Const(c) => {
c.ty().walk().any(|arg| arg == dummy_self.into()) // THISPR
false
} }
}; };

2
compiler/rustc_hir_typeck/src/demand.rs
View file

@ -350,7 +350,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
lt_op: |_| self.tcx.lifetimes.re_erased, lt_op: |_| self.tcx.lifetimes.re_erased,
ct_op: |ct| { ct_op: |ct| {
if let ty::ConstKind::Infer(_) = ct.kind() { if let ty::ConstKind::Infer(_) = ct.kind() {
self.next_const_var(ct.ty(), DUMMY_SP) self.next_const_var(DUMMY_SP)
} else { } else {
ct ct
} }

14
compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
View file

@ -436,7 +436,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pub fn lower_array_length(&self, length: &hir::ArrayLen<'tcx>) -> ty::Const<'tcx> { pub fn lower_array_length(&self, length: &hir::ArrayLen<'tcx>) -> ty::Const<'tcx> {
match length { match length {
hir::ArrayLen::Infer(inf) => self.ct_infer(self.tcx.types.usize, None, inf.span), hir::ArrayLen::Infer(inf) => self.ct_infer(None, inf.span),
hir::ArrayLen::Body(anon_const) => { hir::ArrayLen::Body(anon_const) => {
let span = self.tcx.def_span(anon_const.def_id); let span = self.tcx.def_span(anon_const.def_id);
let c = ty::Const::from_anon_const(self.tcx, anon_const.def_id); let c = ty::Const::from_anon_const(self.tcx, anon_const.def_id);
@ -1292,20 +1292,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
&GenericParamDefKind::Const { has_default, is_host_effect }, &GenericParamDefKind::Const { has_default, is_host_effect },
GenericArg::Infer(inf), GenericArg::Infer(inf),
) => { ) => {
let tcx = self.fcx.tcx();
if has_default && is_host_effect { if has_default && is_host_effect {
self.fcx.var_for_effect(param) self.fcx.var_for_effect(param)
} else { } else {
self.fcx self.fcx.ct_infer(Some(param), inf.span).into()
.ct_infer(
tcx.type_of(param.def_id)
.no_bound_vars()
.expect("const parameter types cannot be generic"),
Some(param),
inf.span,
)
.into()
} }
} }
_ => unreachable!(), _ => unreachable!(),

9
compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
View file

@ -237,12 +237,7 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
} }
} }
fn ct_infer( fn ct_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Const<'tcx> {
&self,
ty: Ty<'tcx>,
param: Option<&ty::GenericParamDef>,
span: Span,
) -> Const<'tcx> {
// FIXME ideally this shouldn't use unwrap // FIXME ideally this shouldn't use unwrap
match param { match param {
Some( Some(
@ -252,7 +247,7 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
}, },
) => self.var_for_effect(param).as_const().unwrap(), ) => self.var_for_effect(param).as_const().unwrap(),
Some(param) => self.var_for_def(span, param).as_const().unwrap(), Some(param) => self.var_for_def(span, param).as_const().unwrap(),
None => self.next_const_var(ty, span), None => self.next_const_var(span),
} }
} }

11
compiler/rustc_hir_typeck/src/method/confirm.rs
View file

@ -406,16 +406,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
self.cfcx.ty_infer(Some(param), inf.span).into() self.cfcx.ty_infer(Some(param), inf.span).into()
} }
(GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => { (GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
let tcx = self.cfcx.tcx(); self.cfcx.ct_infer(Some(param), inf.span).into()
self.cfcx
.ct_infer(
tcx.type_of(param.def_id)
.no_bound_vars()
.expect("const parameter types cannot be generic"),
Some(param),
inf.span,
)
.into()
} }
(kind, arg) => { (kind, arg) => {
bug!("mismatched method arg kind {kind:?} in turbofish: {arg:?}") bug!("mismatched method arg kind {kind:?} in turbofish: {arg:?}")

4
compiler/rustc_hir_typeck/src/method/suggest.rs
View file

@ -2096,9 +2096,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
.next_region_var(RegionVariableOrigin::MiscVariable(DUMMY_SP)) .next_region_var(RegionVariableOrigin::MiscVariable(DUMMY_SP))
.into(), .into(),
GenericArgKind::Type(_) => self.next_ty_var(DUMMY_SP).into(), GenericArgKind::Type(_) => self.next_ty_var(DUMMY_SP).into(),
GenericArgKind::Const(arg) => { GenericArgKind::Const(_) => self.next_const_var(DUMMY_SP).into(),
self.next_const_var(arg.ty(), DUMMY_SP).into()
}
} }
} else { } else {
arg arg

2
compiler/rustc_hir_typeck/src/writeback.rs
View file

@ -863,7 +863,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Resolver<'cx, 'tcx> {
fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> { fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
self.handle_term(ct, ty::Const::outer_exclusive_binder, |tcx, guar| { self.handle_term(ct, ty::Const::outer_exclusive_binder, |tcx, guar| {
ty::Const::new_error(tcx, guar, ct.ty()) ty::Const::new_error(tcx, guar)
}) })
.super_fold_with(self) .super_fold_with(self)
} }

27
compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
View file

@ -462,7 +462,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
// any equated inference vars correctly! // any equated inference vars correctly!
let root_vid = self.infcx.unwrap().root_const_var(vid); let root_vid = self.infcx.unwrap().root_const_var(vid);
if root_vid != vid { if root_vid != vid {
ct = ty::Const::new_var(self.tcx, root_vid, ct.ty()); ct = ty::Const::new_var(self.tcx, root_vid);
vid = root_vid; vid = root_vid;
} }
@ -481,7 +481,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
ui = ty::UniverseIndex::ROOT; ui = ty::UniverseIndex::ROOT;
} }
return self.canonicalize_const_var( return self.canonicalize_const_var(
CanonicalVarInfo { kind: CanonicalVarKind::Const(ui, ct.ty()) }, CanonicalVarInfo { kind: CanonicalVarKind::Const(ui) },
ct, ct,
); );
} }
@ -510,9 +510,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
} }
ty::ConstKind::Placeholder(placeholder) => { ty::ConstKind::Placeholder(placeholder) => {
return self.canonicalize_const_var( return self.canonicalize_const_var(
CanonicalVarInfo { CanonicalVarInfo { kind: CanonicalVarKind::PlaceholderConst(placeholder) },
kind: CanonicalVarKind::PlaceholderConst(placeholder, ct.ty()),
},
ct, ct,
); );
} }
@ -719,9 +717,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
CanonicalVarKind::Region(u) => { CanonicalVarKind::Region(u) => {
CanonicalVarKind::Region(reverse_universe_map[&u]) CanonicalVarKind::Region(reverse_universe_map[&u])
} }
CanonicalVarKind::Const(u, t) => { CanonicalVarKind::Const(u) => CanonicalVarKind::Const(reverse_universe_map[&u]),
CanonicalVarKind::Const(reverse_universe_map[&u], t)
}
CanonicalVarKind::PlaceholderTy(placeholder) => { CanonicalVarKind::PlaceholderTy(placeholder) => {
CanonicalVarKind::PlaceholderTy(ty::Placeholder { CanonicalVarKind::PlaceholderTy(ty::Placeholder {
universe: reverse_universe_map[&placeholder.universe], universe: reverse_universe_map[&placeholder.universe],
@ -734,14 +730,11 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
..placeholder ..placeholder
}) })
} }
CanonicalVarKind::PlaceholderConst(placeholder, t) => { CanonicalVarKind::PlaceholderConst(placeholder) => {
CanonicalVarKind::PlaceholderConst( CanonicalVarKind::PlaceholderConst(ty::Placeholder {
ty::Placeholder { universe: reverse_universe_map[&placeholder.universe],
universe: reverse_universe_map[&placeholder.universe], ..placeholder
..placeholder })
},
t,
)
} }
}, },
}) })
@ -806,6 +799,6 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
!self.infcx.is_some_and(|infcx| const_var != infcx.shallow_resolve_const(const_var)) !self.infcx.is_some_and(|infcx| const_var != infcx.shallow_resolve_const(const_var))
); );
let var = self.canonical_var(info, const_var.into()); let var = self.canonical_var(info, const_var.into());
ty::Const::new_bound(self.tcx, self.binder_index, var, self.fold_ty(const_var.ty())) ty::Const::new_bound(self.tcx, self.binder_index, var)
} }
} }

2
compiler/rustc_infer/src/infer/canonical/instantiate.rs
View file

@ -70,7 +70,7 @@ where
GenericArgKind::Type(ty) => ty, GenericArgKind::Type(ty) => ty,
r => bug!("{:?} is a type but value is {:?}", bound_ty, r), r => bug!("{:?} is a type but value is {:?}", bound_ty, r),
}, },
consts: &mut |bound_ct: ty::BoundVar, _| match var_values[bound_ct].unpack() { consts: &mut |bound_ct: ty::BoundVar| match var_values[bound_ct].unpack() {
GenericArgKind::Const(ct) => ct, GenericArgKind::Const(ct) => ct,
c => bug!("{:?} is a const but value is {:?}", bound_ct, c), c => bug!("{:?} is a const but value is {:?}", bound_ct, c),
}, },

11
compiler/rustc_infer/src/infer/canonical/mod.rs
View file

@ -143,8 +143,8 @@ impl<'tcx> InferCtxt<'tcx> {
ty::Region::new_placeholder(self.tcx, placeholder_mapped).into() ty::Region::new_placeholder(self.tcx, placeholder_mapped).into()
} }
CanonicalVarKind::Const(ui, ty) => { CanonicalVarKind::Const(ui) => {
self.next_const_var_in_universe(ty, span, universe_map(ui)).into() self.next_const_var_in_universe(span, universe_map(ui)).into()
} }
CanonicalVarKind::Effect => { CanonicalVarKind::Effect => {
let vid = self let vid = self
@ -153,13 +153,12 @@ impl<'tcx> InferCtxt<'tcx> {
.effect_unification_table() .effect_unification_table()
.new_key(EffectVarValue::Unknown) .new_key(EffectVarValue::Unknown)
.vid; .vid;
ty::Const::new_infer(self.tcx, ty::InferConst::EffectVar(vid), self.tcx.types.bool) ty::Const::new_infer(self.tcx, ty::InferConst::EffectVar(vid)).into()
.into()
} }
CanonicalVarKind::PlaceholderConst(ty::PlaceholderConst { universe, bound }, ty) => { CanonicalVarKind::PlaceholderConst(ty::PlaceholderConst { universe, bound }) => {
let universe_mapped = universe_map(universe); let universe_mapped = universe_map(universe);
let placeholder_mapped = ty::PlaceholderConst { universe: universe_mapped, bound }; let placeholder_mapped = ty::PlaceholderConst { universe: universe_mapped, bound };
ty::Const::new_placeholder(self.tcx, placeholder_mapped, ty).into() ty::Const::new_placeholder(self.tcx, placeholder_mapped).into()
} }
} }
} }

4
compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
View file

@ -543,9 +543,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
match arg.unpack() { match arg.unpack() {
GenericArgKind::Lifetime(_) => bug!("unexpected lifetime"), GenericArgKind::Lifetime(_) => bug!("unexpected lifetime"),
GenericArgKind::Type(_) => self.next_ty_var(DUMMY_SP).into(), GenericArgKind::Type(_) => self.next_ty_var(DUMMY_SP).into(),
GenericArgKind::Const(arg) => { GenericArgKind::Const(_) => self.next_const_var(DUMMY_SP).into(),
self.next_const_var(arg.ty(), DUMMY_SP).into()
}
} }
})) }))
.unwrap(); .unwrap();

7
compiler/rustc_infer/src/infer/freshen.rs
View file

@ -79,7 +79,6 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
&mut self, &mut self,
input: Result<ty::Const<'tcx>, ty::InferConst>, input: Result<ty::Const<'tcx>, ty::InferConst>,
freshener: F, freshener: F,
ty: Ty<'tcx>,
) -> ty::Const<'tcx> ) -> ty::Const<'tcx>
where where
F: FnOnce(u32) -> ty::InferConst, F: FnOnce(u32) -> ty::InferConst,
@ -91,7 +90,7 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
Entry::Vacant(entry) => { Entry::Vacant(entry) => {
let index = self.const_freshen_count; let index = self.const_freshen_count;
self.const_freshen_count += 1; self.const_freshen_count += 1;
let ct = ty::Const::new_infer(self.infcx.tcx, freshener(index), ty); let ct = ty::Const::new_infer(self.infcx.tcx, freshener(index));
entry.insert(ct); entry.insert(ct);
ct ct
} }
@ -149,7 +148,7 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for TypeFreshener<'a, 'tcx> {
ty::InferConst::Var(inner.const_unification_table().find(v).vid) ty::InferConst::Var(inner.const_unification_table().find(v).vid)
}); });
drop(inner); drop(inner);
self.freshen_const(input, ty::InferConst::Fresh, ct.ty()) self.freshen_const(input, ty::InferConst::Fresh)
} }
ty::ConstKind::Infer(ty::InferConst::EffectVar(v)) => { ty::ConstKind::Infer(ty::InferConst::EffectVar(v)) => {
let mut inner = self.infcx.inner.borrow_mut(); let mut inner = self.infcx.inner.borrow_mut();
@ -158,7 +157,7 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for TypeFreshener<'a, 'tcx> {
ty::InferConst::EffectVar(inner.effect_unification_table().find(v).vid) ty::InferConst::EffectVar(inner.effect_unification_table().find(v).vid)
}); });
drop(inner); drop(inner);
self.freshen_const(input, ty::InferConst::Fresh, ct.ty()) self.freshen_const(input, ty::InferConst::Fresh)
} }
ty::ConstKind::Infer(ty::InferConst::Fresh(i)) => { ty::ConstKind::Infer(ty::InferConst::Fresh(i)) => {
if i >= self.const_freshen_count { if i >= self.const_freshen_count {

53
compiler/rustc_infer/src/infer/mod.rs
View file

@ -392,18 +392,18 @@ impl<'tcx> ty::InferCtxtLike for InferCtxt<'tcx> {
self.opportunistic_resolve_float_var(vid) self.opportunistic_resolve_float_var(vid)
} }
fn opportunistic_resolve_ct_var(&self, vid: ConstVid, ty: Ty<'tcx>) -> ty::Const<'tcx> { fn opportunistic_resolve_ct_var(&self, vid: ConstVid) -> ty::Const<'tcx> {
match self.probe_const_var(vid) { match self.probe_const_var(vid) {
Ok(ct) => ct, Ok(ct) => ct,
Err(_) => ty::Const::new_var(self.tcx, self.root_const_var(vid), ty), Err(_) => ty::Const::new_var(self.tcx, self.root_const_var(vid)),
} }
} }
fn opportunistic_resolve_effect_var(&self, vid: EffectVid, ty: Ty<'tcx>) -> ty::Const<'tcx> { fn opportunistic_resolve_effect_var(&self, vid: EffectVid) -> ty::Const<'tcx> {
match self.probe_effect_var(vid) { match self.probe_effect_var(vid) {
Some(ct) => ct, Some(ct) => ct,
None => { None => {
ty::Const::new_infer(self.tcx, InferConst::EffectVar(self.root_effect_var(vid)), ty) ty::Const::new_infer(self.tcx, InferConst::EffectVar(self.root_effect_var(vid)))
} }
} }
} }
@ -832,9 +832,7 @@ impl<'tcx> InferCtxt<'tcx> {
(0..table.len()) (0..table.len())
.map(|i| ty::EffectVid::from_usize(i)) .map(|i| ty::EffectVid::from_usize(i))
.filter(|&vid| table.probe_value(vid).is_unknown()) .filter(|&vid| table.probe_value(vid).is_unknown())
.map(|v| { .map(|v| ty::Const::new_infer(self.tcx, ty::InferConst::EffectVar(v)))
ty::Const::new_infer(self.tcx, ty::InferConst::EffectVar(v), self.tcx.types.bool)
})
.collect() .collect()
} }
@ -993,27 +991,22 @@ impl<'tcx> InferCtxt<'tcx> {
Ty::new_var(self.tcx, vid) Ty::new_var(self.tcx, vid)
} }
pub fn next_const_var(&self, ty: Ty<'tcx>, span: Span) -> ty::Const<'tcx> { pub fn next_const_var(&self, span: Span) -> ty::Const<'tcx> {
self.next_const_var_with_origin(ty, ConstVariableOrigin { span, param_def_id: None }) self.next_const_var_with_origin(ConstVariableOrigin { span, param_def_id: None })
} }
pub fn next_const_var_with_origin( pub fn next_const_var_with_origin(&self, origin: ConstVariableOrigin) -> ty::Const<'tcx> {
&self,
ty: Ty<'tcx>,
origin: ConstVariableOrigin,
) -> ty::Const<'tcx> {
let vid = self let vid = self
.inner .inner
.borrow_mut() .borrow_mut()
.const_unification_table() .const_unification_table()
.new_key(ConstVariableValue::Unknown { origin, universe: self.universe() }) .new_key(ConstVariableValue::Unknown { origin, universe: self.universe() })
.vid; .vid;
ty::Const::new_var(self.tcx, vid, ty) ty::Const::new_var(self.tcx, vid)
} }
pub fn next_const_var_in_universe( pub fn next_const_var_in_universe(
&self, &self,
ty: Ty<'tcx>,
span: Span, span: Span,
universe: ty::UniverseIndex, universe: ty::UniverseIndex,
) -> ty::Const<'tcx> { ) -> ty::Const<'tcx> {
@ -1024,7 +1017,7 @@ impl<'tcx> InferCtxt<'tcx> {
.const_unification_table() .const_unification_table()
.new_key(ConstVariableValue::Unknown { origin, universe }) .new_key(ConstVariableValue::Unknown { origin, universe })
.vid; .vid;
ty::Const::new_var(self.tcx, vid, ty) ty::Const::new_var(self.tcx, vid)
} }
pub fn next_const_var_id(&self, origin: ConstVariableOrigin) -> ConstVid { pub fn next_const_var_id(&self, origin: ConstVariableOrigin) -> ConstVid {
@ -1135,15 +1128,7 @@ impl<'tcx> InferCtxt<'tcx> {
.const_unification_table() .const_unification_table()
.new_key(ConstVariableValue::Unknown { origin, universe: self.universe() }) .new_key(ConstVariableValue::Unknown { origin, universe: self.universe() })
.vid; .vid;
ty::Const::new_var( ty::Const::new_var(self.tcx, const_var_id).into()
self.tcx,
const_var_id,
self.tcx
.type_of(param.def_id)
.no_bound_vars()
.expect("const parameter types cannot be generic"),
)
.into()
} }
} }
} }
@ -1157,7 +1142,7 @@ impl<'tcx> InferCtxt<'tcx> {
.no_bound_vars() .no_bound_vars()
.expect("const parameter types cannot be generic"); .expect("const parameter types cannot be generic");
debug_assert_eq!(self.tcx.types.bool, ty); debug_assert_eq!(self.tcx.types.bool, ty);
ty::Const::new_infer(self.tcx, ty::InferConst::EffectVar(effect_vid), ty).into() ty::Const::new_infer(self.tcx, ty::InferConst::EffectVar(effect_vid)).into()
} }
/// Given a set of generics defined on a type or impl, returns the generic parameters mapping each /// Given a set of generics defined on a type or impl, returns the generic parameters mapping each
@ -1469,10 +1454,10 @@ impl<'tcx> InferCtxt<'tcx> {
.or_insert_with(|| self.infcx.next_ty_var(self.span).into()) .or_insert_with(|| self.infcx.next_ty_var(self.span).into())
.expect_ty() .expect_ty()
} }
fn replace_const(&mut self, bv: ty::BoundVar, ty: Ty<'tcx>) -> ty::Const<'tcx> { fn replace_const(&mut self, bv: ty::BoundVar) -> ty::Const<'tcx> {
self.map self.map
.entry(bv) .entry(bv)
.or_insert_with(|| self.infcx.next_const_var(ty, self.span).into()) .or_insert_with(|| self.infcx.next_const_var(self.span).into())
.expect_const() .expect_const()
} }
} }
@ -1526,11 +1511,11 @@ impl<'tcx> InferCtxt<'tcx> {
&self, &self,
param_env: ty::ParamEnv<'tcx>, param_env: ty::ParamEnv<'tcx>,
unevaluated: ty::UnevaluatedConst<'tcx>, unevaluated: ty::UnevaluatedConst<'tcx>,
ty: Ty<'tcx>,
span: Span, span: Span,
) -> Result<ty::Const<'tcx>, ErrorHandled> { ) -> Result<ty::Const<'tcx>, ErrorHandled> {
match self.const_eval_resolve(param_env, unevaluated, span) { match self.const_eval_resolve(param_env, unevaluated, span) {
Ok(Some(val)) => Ok(ty::Const::new_value(self.tcx, val, ty)), // THISPR
Ok(Some(val)) => Ok(ty::Const::new_value(self.tcx, val, todo!())),
Ok(None) => { Ok(None) => {
let tcx = self.tcx; let tcx = self.tcx;
let def_id = unevaluated.def; let def_id = unevaluated.def;
@ -1964,11 +1949,6 @@ fn replace_param_and_infer_args_with_placeholder<'tcx>(
fn fold_const(&mut self, c: ty::Const<'tcx>) -> ty::Const<'tcx> { fn fold_const(&mut self, c: ty::Const<'tcx>) -> ty::Const<'tcx> {
if let ty::ConstKind::Infer(_) = c.kind() { if let ty::ConstKind::Infer(_) = c.kind() {
let ty = c.ty();
// If the type references param or infer then ICE ICE ICE
if ty.has_non_region_param() || ty.has_non_region_infer() {
bug!("const `{c}`'s type should not reference params or types");
}
ty::Const::new_placeholder( ty::Const::new_placeholder(
self.tcx, self.tcx,
ty::PlaceholderConst { ty::PlaceholderConst {
@ -1979,7 +1959,6 @@ fn replace_param_and_infer_args_with_placeholder<'tcx>(
idx idx
}), }),
}, },
ty,
) )
} else { } else {
c.super_fold_with(self) c.super_fold_with(self)

8
compiler/rustc_infer/src/infer/relate/generalize.rs
View file

@ -653,7 +653,7 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
{ {
variable_table.union(vid, new_var_id); variable_table.union(vid, new_var_id);
} }
Ok(ty::Const::new_var(self.tcx(), new_var_id, c.ty())) Ok(ty::Const::new_var(self.tcx(), new_var_id))
} }
} }
} }
@ -671,11 +671,7 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
args, args,
args, args,
)?; )?;
Ok(ty::Const::new_unevaluated( Ok(ty::Const::new_unevaluated(self.tcx(), ty::UnevaluatedConst { def, args }))
self.tcx(),
ty::UnevaluatedConst { def, args },
c.ty(),
))
} }
ty::ConstKind::Placeholder(placeholder) => { ty::ConstKind::Placeholder(placeholder) => {
if self.for_universe.can_name(placeholder.universe) { if self.for_universe.can_name(placeholder.universe) {

3
compiler/rustc_infer/src/infer/relate/higher_ranked.rs
View file

@ -43,11 +43,10 @@ impl<'tcx> InferCtxt<'tcx> {
ty::PlaceholderType { universe: next_universe, bound: bound_ty }, ty::PlaceholderType { universe: next_universe, bound: bound_ty },
) )
}, },
consts: &mut |bound_var: ty::BoundVar, ty| { consts: &mut |bound_var: ty::BoundVar| {
ty::Const::new_placeholder( ty::Const::new_placeholder(
self.tcx, self.tcx,
ty::PlaceholderConst { universe: next_universe, bound: bound_var }, ty::PlaceholderConst { universe: next_universe, bound: bound_var },
ty,
) )
}, },
}; };

2
compiler/rustc_infer/src/infer/snapshot/fudge.rs
View file

@ -244,7 +244,7 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for InferenceFudger<'a, 'tcx> {
// Recreate it with a fresh variable here. // Recreate it with a fresh variable here.
let idx = vid.index() - self.const_vars.0.start.index(); let idx = vid.index() - self.const_vars.0.start.index();
let origin = self.const_vars.1[idx]; let origin = self.const_vars.1[idx];
self.infcx.next_const_var_with_origin(ct.ty(), origin) self.infcx.next_const_var_with_origin(origin)
} else { } else {
ct ct
} }

28
compiler/rustc_middle/src/mir/consts.rs
View file

@ -237,7 +237,8 @@ impl<'tcx> Const<'tcx> {
#[inline(always)] #[inline(always)]
pub fn ty(&self) -> Ty<'tcx> { pub fn ty(&self) -> Ty<'tcx> {
match self { match self {
Const::Ty(c) => c.ty(), // THISPR
Const::Ty(c) => todo!(),
Const::Val(_, ty) | Const::Unevaluated(_, ty) => *ty, Const::Val(_, ty) | Const::Unevaluated(_, ty) => *ty,
} }
} }
@ -260,7 +261,9 @@ impl<'tcx> Const<'tcx> {
pub fn try_to_scalar(self) -> Option<Scalar> { pub fn try_to_scalar(self) -> Option<Scalar> {
match self { match self {
Const::Ty(c) => match c.kind() { Const::Ty(c) => match c.kind() {
ty::ConstKind::Value(valtree) if c.ty().is_primitive() => { // THISPR
// if c.ty().is_primitive()
ty::ConstKind::Value(valtree) if todo!() => {
// A valtree of a type where leaves directly represent the scalar const value. // A valtree of a type where leaves directly represent the scalar const value.
// Just checking whether it is a leaf is insufficient as e.g. references are leafs // Just checking whether it is a leaf is insufficient as e.g. references are leafs
// but the leaf value is the value they point to, not the reference itself! // but the leaf value is the value they point to, not the reference itself!
@ -279,9 +282,9 @@ impl<'tcx> Const<'tcx> {
match self { match self {
Const::Val(ConstValue::Scalar(Scalar::Int(x)), _) => Some(x), Const::Val(ConstValue::Scalar(Scalar::Int(x)), _) => Some(x),
Const::Ty(c) => match c.kind() { Const::Ty(c) => match c.kind() {
ty::ConstKind::Value(valtree) if c.ty().is_primitive() => { // THISPR
Some(valtree.unwrap_leaf()) // if c.ty().is_primitive()
} ty::ConstKind::Value(valtree) if todo!() => Some(valtree.unwrap_leaf()),
_ => None, _ => None,
}, },
_ => None, _ => None,
@ -326,7 +329,7 @@ impl<'tcx> Const<'tcx> {
match self.eval(tcx, param_env, DUMMY_SP) { match self.eval(tcx, param_env, DUMMY_SP) {
Ok(val) => Self::Val(val, self.ty()), Ok(val) => Self::Val(val, self.ty()),
Err(ErrorHandled::Reported(guar, _span)) => { Err(ErrorHandled::Reported(guar, _span)) => {
Self::Ty(ty::Const::new_error(tcx, guar.into(), self.ty())) Self::Ty(ty::Const::new_error(tcx, guar.into()))
} }
Err(ErrorHandled::TooGeneric(_span)) => self, Err(ErrorHandled::TooGeneric(_span)) => self,
} }
@ -339,7 +342,9 @@ impl<'tcx> Const<'tcx> {
param_env: ty::ParamEnv<'tcx>, param_env: ty::ParamEnv<'tcx>,
) -> Option<Scalar> { ) -> Option<Scalar> {
match self { match self {
Const::Ty(c) if c.ty().is_primitive() => { // THISPR
// c.ty().is_primitive()
Const::Ty(c) if todo!() => {
// Avoid the `valtree_to_const_val` query. Can only be done on primitive types that // Avoid the `valtree_to_const_val` query. Can only be done on primitive types that
// are valtree leaves, and *not* on references. (References should return the // are valtree leaves, and *not* on references. (References should return the
// pointer here, which valtrees don't represent.) // pointer here, which valtrees don't represent.)
@ -443,8 +448,9 @@ impl<'tcx> Const<'tcx> {
match c.kind() { match c.kind() {
ty::ConstKind::Value(valtree) => { ty::ConstKind::Value(valtree) => {
// Make sure that if `c` is normalized, then the return value is normalized. // Make sure that if `c` is normalized, then the return value is normalized.
let const_val = tcx.valtree_to_const_val((c.ty(), valtree)); // THISPR
Self::Val(const_val, c.ty()) let const_val = tcx.valtree_to_const_val((todo!(), valtree));
Self::Val(const_val, todo!())
} }
_ => Self::Ty(c), _ => Self::Ty(c),
} }
@ -463,7 +469,9 @@ impl<'tcx> Const<'tcx> {
// A valtree may be a reference. Valtree references correspond to a // A valtree may be a reference. Valtree references correspond to a
// different allocation each time they are evaluated. Valtrees for primitive // different allocation each time they are evaluated. Valtrees for primitive
// types are fine though. // types are fine though.
ty::ConstKind::Value(_) => c.ty().is_primitive(), // THISPR
// c.ty().is_primitive()
ty::ConstKind::Value(_) => todo!(),
ty::ConstKind::Unevaluated(..) | ty::ConstKind::Expr(..) => false, ty::ConstKind::Unevaluated(..) | ty::ConstKind::Expr(..) => false,
// This can happen if evaluation of a constant failed. The result does not matter // This can happen if evaluation of a constant failed. The result does not matter
// much since compilation is doomed. // much since compilation is doomed.

2
compiler/rustc_middle/src/ty/abstract_const.rs
View file

@ -53,7 +53,7 @@ impl<'tcx> TyCtxt<'tcx> {
fn fold_const(&mut self, c: Const<'tcx>) -> Const<'tcx> { fn fold_const(&mut self, c: Const<'tcx>) -> Const<'tcx> {
let ct = match c.kind() { let ct = match c.kind() {
ty::ConstKind::Unevaluated(uv) => match self.tcx.thir_abstract_const(uv.def) { ty::ConstKind::Unevaluated(uv) => match self.tcx.thir_abstract_const(uv.def) {
Err(e) => ty::Const::new_error(self.tcx, e, c.ty()), Err(e) => ty::Const::new_error(self.tcx, e),
Ok(Some(bac)) => { Ok(Some(bac)) => {
let args = self.tcx.erase_regions(uv.args); let args = self.tcx.erase_regions(uv.args);
let bac = bac.instantiate(self.tcx, args); let bac = bac.instantiate(self.tcx, args);

4
compiler/rustc_middle/src/ty/codec.rs
View file

@ -350,8 +350,8 @@ impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> RefDecodable<'tcx, D>
impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D> for ty::Const<'tcx> { impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D> for ty::Const<'tcx> {
fn decode(decoder: &mut D) -> Self { fn decode(decoder: &mut D) -> Self {
let consts: ty::ConstData<'tcx> = Decodable::decode(decoder); let kind: ty::ConstKind<'tcx> = Decodable::decode(decoder);
decoder.interner().mk_ct_from_kind(consts.kind, consts.ty) decoder.interner().mk_ct_from_kind(kind)
} }
} }

144
compiler/rustc_middle/src/ty/consts.rs
View file

@ -6,7 +6,7 @@ use rustc_error_messages::MultiSpan;
use rustc_hir as hir; use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res}; use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::LocalDefId; use rustc_hir::def_id::LocalDefId;
use rustc_macros::{HashStable, TyDecodable, TyEncodable}; use rustc_macros::HashStable;
use rustc_type_ir::{self as ir, TypeFlags, WithCachedTypeInfo}; use rustc_type_ir::{self as ir, TypeFlags, WithCachedTypeInfo};
use tracing::{debug, instrument}; use tracing::{debug, instrument};
@ -26,10 +26,9 @@ pub type UnevaluatedConst<'tcx> = ir::UnevaluatedConst<TyCtxt<'tcx>>;
#[cfg(target_pointer_width = "64")] #[cfg(target_pointer_width = "64")]
rustc_data_structures::static_assert_size!(ConstKind<'_>, 24); rustc_data_structures::static_assert_size!(ConstKind<'_>, 24);
/// Use this rather than `ConstData`, whenever possible.
#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable)] #[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable)]
#[rustc_pass_by_value] #[rustc_pass_by_value]
pub struct Const<'tcx>(pub(super) Interned<'tcx, WithCachedTypeInfo<ConstData<'tcx>>>); pub struct Const<'tcx>(pub(super) Interned<'tcx, WithCachedTypeInfo<ConstKind<'tcx>>>);
impl<'tcx> rustc_type_ir::inherent::IntoKind for Const<'tcx> { impl<'tcx> rustc_type_ir::inherent::IntoKind for Const<'tcx> {
type Kind = ConstKind<'tcx>; type Kind = ConstKind<'tcx>;
@ -49,26 +48,11 @@ impl<'tcx> rustc_type_ir::visit::Flags for Const<'tcx> {
} }
} }
/// Typed constant value.
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
#[derive(HashStable, TyEncodable, TyDecodable)]
pub struct ConstData<'tcx> {
pub ty: Ty<'tcx>,
pub kind: ConstKind<'tcx>,
}
#[cfg(target_pointer_width = "64")]
rustc_data_structures::static_assert_size!(ConstData<'_>, 32);
impl<'tcx> Const<'tcx> { impl<'tcx> Const<'tcx> {
#[inline]
pub fn ty(self) -> Ty<'tcx> {
self.0.ty
}
#[inline] #[inline]
pub fn kind(self) -> ConstKind<'tcx> { pub fn kind(self) -> ConstKind<'tcx> {
self.0.kind let a: &ConstKind<'tcx> = self.0.0;
*a
} }
// FIXME(compiler-errors): Think about removing this. // FIXME(compiler-errors): Think about removing this.
@ -84,28 +68,28 @@ impl<'tcx> Const<'tcx> {
} }
#[inline] #[inline]
pub fn new(tcx: TyCtxt<'tcx>, kind: ty::ConstKind<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> { pub fn new(tcx: TyCtxt<'tcx>, kind: ty::ConstKind<'tcx>) -> Const<'tcx> {
tcx.mk_ct_from_kind(kind, ty) tcx.mk_ct_from_kind(kind)
} }
#[inline] #[inline]
pub fn new_param(tcx: TyCtxt<'tcx>, param: ty::ParamConst, ty: Ty<'tcx>) -> Const<'tcx> { pub fn new_param(tcx: TyCtxt<'tcx>, param: ty::ParamConst) -> Const<'tcx> {
Const::new(tcx, ty::ConstKind::Param(param), ty) Const::new(tcx, ty::ConstKind::Param(param))
} }
#[inline] #[inline]
pub fn new_var(tcx: TyCtxt<'tcx>, infer: ty::ConstVid, ty: Ty<'tcx>) -> Const<'tcx> { pub fn new_var(tcx: TyCtxt<'tcx>, infer: ty::ConstVid) -> Const<'tcx> {
Const::new(tcx, ty::ConstKind::Infer(ty::InferConst::Var(infer)), ty) Const::new(tcx, ty::ConstKind::Infer(ty::InferConst::Var(infer)))
} }
#[inline] #[inline]
pub fn new_fresh(tcx: TyCtxt<'tcx>, fresh: u32, ty: Ty<'tcx>) -> Const<'tcx> { pub fn new_fresh(tcx: TyCtxt<'tcx>, fresh: u32) -> Const<'tcx> {
Const::new(tcx, ty::ConstKind::Infer(ty::InferConst::Fresh(fresh)), ty) Const::new(tcx, ty::ConstKind::Infer(ty::InferConst::Fresh(fresh)))
} }
#[inline] #[inline]
pub fn new_infer(tcx: TyCtxt<'tcx>, infer: ty::InferConst, ty: Ty<'tcx>) -> Const<'tcx> { pub fn new_infer(tcx: TyCtxt<'tcx>, infer: ty::InferConst) -> Const<'tcx> {
Const::new(tcx, ty::ConstKind::Infer(infer), ty) Const::new(tcx, ty::ConstKind::Infer(infer))
} }
#[inline] #[inline]
@ -113,50 +97,40 @@ impl<'tcx> Const<'tcx> {
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
debruijn: ty::DebruijnIndex, debruijn: ty::DebruijnIndex,
var: ty::BoundVar, var: ty::BoundVar,
ty: Ty<'tcx>,
) -> Const<'tcx> { ) -> Const<'tcx> {
Const::new(tcx, ty::ConstKind::Bound(debruijn, var), ty) Const::new(tcx, ty::ConstKind::Bound(debruijn, var))
} }
#[inline] #[inline]
pub fn new_placeholder( pub fn new_placeholder(tcx: TyCtxt<'tcx>, placeholder: ty::PlaceholderConst) -> Const<'tcx> {
tcx: TyCtxt<'tcx>, Const::new(tcx, ty::ConstKind::Placeholder(placeholder))
placeholder: ty::PlaceholderConst,
ty: Ty<'tcx>,
) -> Const<'tcx> {
Const::new(tcx, ty::ConstKind::Placeholder(placeholder), ty)
} }
#[inline] #[inline]
pub fn new_unevaluated( pub fn new_unevaluated(tcx: TyCtxt<'tcx>, uv: ty::UnevaluatedConst<'tcx>) -> Const<'tcx> {
tcx: TyCtxt<'tcx>, Const::new(tcx, ty::ConstKind::Unevaluated(uv))
uv: ty::UnevaluatedConst<'tcx>,
ty: Ty<'tcx>,
) -> Const<'tcx> {
Const::new(tcx, ty::ConstKind::Unevaluated(uv), ty)
} }
#[inline] #[inline]
pub fn new_value(tcx: TyCtxt<'tcx>, val: ty::ValTree<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> { pub fn new_value(tcx: TyCtxt<'tcx>, val: ty::ValTree<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> {
Const::new(tcx, ty::ConstKind::Value(val), ty) Const::new(tcx, ty::ConstKind::Value(ty, val))
} }
#[inline] #[inline]
pub fn new_expr(tcx: TyCtxt<'tcx>, expr: ty::Expr<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> { pub fn new_expr(tcx: TyCtxt<'tcx>, expr: ty::Expr<'tcx>) -> Const<'tcx> {
Const::new(tcx, ty::ConstKind::Expr(expr), ty) Const::new(tcx, ty::ConstKind::Expr(expr))
} }
#[inline] #[inline]
pub fn new_error(tcx: TyCtxt<'tcx>, e: ty::ErrorGuaranteed, ty: Ty<'tcx>) -> Const<'tcx> { pub fn new_error(tcx: TyCtxt<'tcx>, e: ty::ErrorGuaranteed) -> Const<'tcx> {
Const::new(tcx, ty::ConstKind::Error(e), ty) Const::new(tcx, ty::ConstKind::Error(e))
} }
/// Like [Ty::new_error] but for constants. /// Like [Ty::new_error] but for constants.
#[track_caller] #[track_caller]
pub fn new_misc_error(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> { pub fn new_misc_error(tcx: TyCtxt<'tcx>) -> Const<'tcx> {
Const::new_error_with_message( Const::new_error_with_message(
tcx, tcx,
ty,
DUMMY_SP, DUMMY_SP,
"ty::ConstKind::Error constructed but no error reported", "ty::ConstKind::Error constructed but no error reported",
) )
@ -166,48 +140,33 @@ impl<'tcx> Const<'tcx> {
#[track_caller] #[track_caller]
pub fn new_error_with_message<S: Into<MultiSpan>>( pub fn new_error_with_message<S: Into<MultiSpan>>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
ty: Ty<'tcx>,
span: S, span: S,
msg: &'static str, msg: &'static str,
) -> Const<'tcx> { ) -> Const<'tcx> {
let reported = tcx.dcx().span_delayed_bug(span, msg); let reported = tcx.dcx().span_delayed_bug(span, msg);
Const::new_error(tcx, reported, ty) Const::new_error(tcx, reported)
} }
} }
impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> { impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {
fn new_infer(tcx: TyCtxt<'tcx>, infer: ty::InferConst, ty: Ty<'tcx>) -> Self { fn new_infer(tcx: TyCtxt<'tcx>, infer: ty::InferConst) -> Self {
Const::new_infer(tcx, infer, ty) Const::new_infer(tcx, infer)
} }
fn new_var(tcx: TyCtxt<'tcx>, vid: ty::ConstVid, ty: Ty<'tcx>) -> Self { fn new_var(tcx: TyCtxt<'tcx>, vid: ty::ConstVid) -> Self {
Const::new_var(tcx, vid, ty) Const::new_var(tcx, vid)
} }
fn new_bound( fn new_bound(interner: TyCtxt<'tcx>, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self {
interner: TyCtxt<'tcx>, Const::new_bound(interner, debruijn, var)
debruijn: ty::DebruijnIndex,
var: ty::BoundVar,
ty: Ty<'tcx>,
) -> Self {
Const::new_bound(interner, debruijn, var, ty)
} }
fn new_anon_bound( fn new_anon_bound(tcx: TyCtxt<'tcx>, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self {
tcx: TyCtxt<'tcx>, Const::new_bound(tcx, debruijn, var)
debruijn: ty::DebruijnIndex,
var: ty::BoundVar,
ty: Ty<'tcx>,
) -> Self {
Const::new_bound(tcx, debruijn, var, ty)
} }
fn new_unevaluated( fn new_unevaluated(interner: TyCtxt<'tcx>, uv: ty::UnevaluatedConst<'tcx>) -> Self {
interner: TyCtxt<'tcx>, Const::new_unevaluated(interner, uv)
uv: ty::UnevaluatedConst<'tcx>,
ty: Ty<'tcx>,
) -> Self {
Const::new_unevaluated(interner, uv, ty)
} }
fn ty(self) -> Ty<'tcx> { fn ty(self) -> Ty<'tcx> {
@ -241,7 +200,6 @@ impl<'tcx> Const<'tcx> {
def: def.to_def_id(), def: def.to_def_id(),
args: GenericArgs::identity_for_item(tcx, def.to_def_id()), args: GenericArgs::identity_for_item(tcx, def.to_def_id()),
}, },
ty,
), ),
} }
} }
@ -293,9 +251,6 @@ impl<'tcx> Const<'tcx> {
_, _,
&hir::Path { res: Res::Def(DefKind::ConstParam, def_id), .. }, &hir::Path { res: Res::Def(DefKind::ConstParam, def_id), .. },
)) => { )) => {
// Use the type from the param's definition, since we can resolve it,
// not the expected parameter type from WithOptConstParam.
let param_ty = tcx.type_of(def_id).instantiate_identity();
match tcx.named_bound_var(expr.hir_id) { match tcx.named_bound_var(expr.hir_id) {
Some(rbv::ResolvedArg::EarlyBound(_)) => { Some(rbv::ResolvedArg::EarlyBound(_)) => {
// Find the name and index of the const parameter by indexing the generics of // Find the name and index of the const parameter by indexing the generics of
@ -304,19 +259,12 @@ impl<'tcx> Const<'tcx> {
let generics = tcx.generics_of(item_def_id); let generics = tcx.generics_of(item_def_id);
let index = generics.param_def_id_to_index[&def_id]; let index = generics.param_def_id_to_index[&def_id];
let name = tcx.item_name(def_id); let name = tcx.item_name(def_id);
Some(ty::Const::new_param(tcx, ty::ParamConst::new(index, name), param_ty)) Some(ty::Const::new_param(tcx, ty::ParamConst::new(index, name)))
} }
Some(rbv::ResolvedArg::LateBound(debruijn, index, _)) => { Some(rbv::ResolvedArg::LateBound(debruijn, index, _)) => {
Some(ty::Const::new_bound( Some(ty::Const::new_bound(tcx, debruijn, ty::BoundVar::from_u32(index)))
tcx,
debruijn,
ty::BoundVar::from_u32(index),
param_ty,
))
}
Some(rbv::ResolvedArg::Error(guar)) => {
Some(ty::Const::new_error(tcx, guar, param_ty))
} }
Some(rbv::ResolvedArg::Error(guar)) => Some(ty::Const::new_error(tcx, guar)),
arg => bug!("unexpected bound var resolution for {:?}: {arg:?}", expr.hir_id), arg => bug!("unexpected bound var resolution for {:?}: {arg:?}", expr.hir_id),
} }
} }
@ -397,8 +345,8 @@ impl<'tcx> Const<'tcx> {
#[inline] #[inline]
pub fn normalize(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> Self { pub fn normalize(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> Self {
match self.eval(tcx, param_env, DUMMY_SP) { match self.eval(tcx, param_env, DUMMY_SP) {
Ok(val) => Self::new_value(tcx, val, self.ty()), Ok(val) => Self::new_value(tcx, val, self.ty_for_ctfe(tcx).unwrap()),
Err(ErrorHandled::Reported(r, _span)) => Self::new_error(tcx, r.into(), self.ty()), Err(ErrorHandled::Reported(r, _span)) => Self::new_error(tcx, r.into()),
Err(ErrorHandled::TooGeneric(_span)) => self, Err(ErrorHandled::TooGeneric(_span)) => self,
} }
} }
@ -430,8 +378,12 @@ impl<'tcx> Const<'tcx> {
/// contains const generic parameters or pointers). /// contains const generic parameters or pointers).
pub fn try_eval_bits(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> Option<u128> { pub fn try_eval_bits(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> Option<u128> {
let int = self.try_eval_scalar_int(tcx, param_env)?; let int = self.try_eval_scalar_int(tcx, param_env)?;
let size = let size = tcx
tcx.layout_of(param_env.with_reveal_all_normalized(tcx).and(self.ty())).ok()?.size; .layout_of(
param_env.with_reveal_all_normalized(tcx).and(self.ty_for_ctfe(tcx).unwrap()),
)
.ok()?
.size;
// if `ty` does not depend on generic parameters, use an empty param_env // if `ty` does not depend on generic parameters, use an empty param_env
int.try_to_bits(size).ok() int.try_to_bits(size).ok()
} }
@ -440,7 +392,7 @@ impl<'tcx> Const<'tcx> {
/// Panics if the value cannot be evaluated or doesn't contain a valid integer of the given type. /// Panics if the value cannot be evaluated or doesn't contain a valid integer of the given type.
pub fn eval_bits(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> u128 { pub fn eval_bits(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> u128 {
self.try_eval_bits(tcx, param_env) self.try_eval_bits(tcx, param_env)
.unwrap_or_else(|| bug!("expected bits of {:#?}, got {:#?}", self.ty(), self)) .unwrap_or_else(|| bug!("failed to evalate {:#?} to bits", self))
} }
#[inline] #[inline]

51
compiler/rustc_middle/src/ty/context.rs
View file

@ -28,10 +28,10 @@ use crate::traits::solve::{
}; };
use crate::ty::predicate::ExistentialPredicateStableCmpExt as _; use crate::ty::predicate::ExistentialPredicateStableCmpExt as _;
use crate::ty::{ use crate::ty::{
self, AdtDef, AdtDefData, AdtKind, Binder, Clause, Clauses, Const, ConstData, self, AdtDef, AdtDefData, AdtKind, Binder, Clause, Clauses, Const, GenericParamDefKind,
GenericParamDefKind, ImplPolarity, List, ListWithCachedTypeInfo, ParamConst, ParamTy, Pattern, ImplPolarity, List, ListWithCachedTypeInfo, ParamConst, ParamTy, Pattern, PatternKind,
PatternKind, PolyExistentialPredicate, PolyFnSig, Predicate, PredicateKind, PredicatePolarity, PolyExistentialPredicate, PolyFnSig, Predicate, PredicateKind, PredicatePolarity, Region,
Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyVid, Visibility, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyVid, Visibility,
}; };
use crate::ty::{GenericArg, GenericArgs, GenericArgsRef}; use crate::ty::{GenericArg, GenericArgs, GenericArgsRef};
use rustc_ast::{self as ast, attr}; use rustc_ast::{self as ast, attr};
@ -268,7 +268,7 @@ pub struct CtxtInterners<'tcx> {
clauses: InternedSet<'tcx, ListWithCachedTypeInfo<Clause<'tcx>>>, clauses: InternedSet<'tcx, ListWithCachedTypeInfo<Clause<'tcx>>>,
projs: InternedSet<'tcx, List<ProjectionKind>>, projs: InternedSet<'tcx, List<ProjectionKind>>,
place_elems: InternedSet<'tcx, List<PlaceElem<'tcx>>>, place_elems: InternedSet<'tcx, List<PlaceElem<'tcx>>>,
const_: InternedSet<'tcx, WithCachedTypeInfo<ConstData<'tcx>>>, const_: InternedSet<'tcx, WithCachedTypeInfo<ty::ConstKind<'tcx>>>,
pat: InternedSet<'tcx, PatternKind<'tcx>>, pat: InternedSet<'tcx, PatternKind<'tcx>>,
const_allocation: InternedSet<'tcx, Allocation>, const_allocation: InternedSet<'tcx, Allocation>,
bound_variable_kinds: InternedSet<'tcx, List<ty::BoundVariableKind>>, bound_variable_kinds: InternedSet<'tcx, List<ty::BoundVariableKind>>,
@ -338,18 +338,18 @@ impl<'tcx> CtxtInterners<'tcx> {
#[inline(never)] #[inline(never)]
fn intern_const( fn intern_const(
&self, &self,
data: ty::ConstData<'tcx>, kind: ty::ConstKind<'tcx>,
sess: &Session, sess: &Session,
untracked: &Untracked, untracked: &Untracked,
) -> Const<'tcx> { ) -> Const<'tcx> {
Const(Interned::new_unchecked( Const(Interned::new_unchecked(
self.const_ self.const_
.intern(data, |data: ConstData<'_>| { .intern(kind, |kind: ty::ConstKind<'_>| {
let flags = super::flags::FlagComputation::for_const(&data.kind, data.ty); let flags = super::flags::FlagComputation::for_const_kind(&kind);
let stable_hash = self.stable_hash(&flags, sess, untracked, &data); let stable_hash = self.stable_hash(&flags, sess, untracked, &kind);
InternedInSet(self.arena.alloc(WithCachedTypeInfo { InternedInSet(self.arena.alloc(WithCachedTypeInfo {
internee: data, internee: kind,
stable_hash, stable_hash,
flags: flags.flags, flags: flags.flags,
outer_exclusive_binder: flags.outer_exclusive_binder, outer_exclusive_binder: flags.outer_exclusive_binder,
@ -601,18 +601,9 @@ impl<'tcx> CommonConsts<'tcx> {
}; };
CommonConsts { CommonConsts {
unit: mk_const(ty::ConstData { unit: mk_const(ty::ConstKind::Value(ty::ValTree::zst())),
kind: ty::ConstKind::Value(ty::ValTree::zst()), true_: mk_const(ty::ConstKind::Value(ty::ValTree::Leaf(ty::ScalarInt::TRUE))),
ty: types.unit, false_: mk_const(ty::ConstKind::Value(ty::ValTree::Leaf(ty::ScalarInt::FALSE))),
}),
true_: mk_const(ty::ConstData {
kind: ty::ConstKind::Value(ty::ValTree::Leaf(ty::ScalarInt::TRUE)),
ty: types.bool,
}),
false_: mk_const(ty::ConstData {
kind: ty::ConstKind::Value(ty::ValTree::Leaf(ty::ScalarInt::FALSE)),
ty: types.bool,
}),
} }
} }
} }
@ -2225,9 +2216,9 @@ impl<'tcx> TyCtxt<'tcx> {
} }
#[inline] #[inline]
pub fn mk_ct_from_kind(self, kind: ty::ConstKind<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> { pub fn mk_ct_from_kind(self, kind: ty::ConstKind<'tcx>) -> Const<'tcx> {
self.interners.intern_const( self.interners.intern_const(
ty::ConstData { kind, ty }, kind,
self.sess, self.sess,
// This is only used to create a stable hashing context. // This is only used to create a stable hashing context.
&self.untracked, &self.untracked,
@ -2252,14 +2243,10 @@ impl<'tcx> TyCtxt<'tcx> {
ty::Region::new_early_param(self, param.to_early_bound_region_data()).into() ty::Region::new_early_param(self, param.to_early_bound_region_data()).into()
} }
GenericParamDefKind::Type { .. } => Ty::new_param(self, param.index, param.name).into(), GenericParamDefKind::Type { .. } => Ty::new_param(self, param.index, param.name).into(),
GenericParamDefKind::Const { .. } => ty::Const::new_param( GenericParamDefKind::Const { .. } => {
self, ty::Const::new_param(self, ParamConst { index: param.index, name: param.name })
ParamConst { index: param.index, name: param.name }, .into()
self.type_of(param.def_id) }
.no_bound_vars()
.expect("const parameter types cannot be generic"),
)
.into(),
} }
} }

5
compiler/rustc_middle/src/ty/flags.rs
View file

@ -28,10 +28,9 @@ impl FlagComputation {
result result
} }
pub fn for_const(c: &ty::ConstKind<'_>, t: Ty<'_>) -> FlagComputation { pub fn for_const_kind(kind: &ty::ConstKind<'_>) -> FlagComputation {
let mut result = FlagComputation::new(); let mut result = FlagComputation::new();
result.add_const_kind(c); result.add_const_kind(kind);
result.add_ty(t);
result result
} }

20
compiler/rustc_middle/src/ty/fold.rs
View file

@ -134,13 +134,13 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for RegionFolder<'a, 'tcx> {
pub trait BoundVarReplacerDelegate<'tcx> { pub trait BoundVarReplacerDelegate<'tcx> {
fn replace_region(&mut self, br: ty::BoundRegion) -> ty::Region<'tcx>; fn replace_region(&mut self, br: ty::BoundRegion) -> ty::Region<'tcx>;
fn replace_ty(&mut self, bt: ty::BoundTy) -> Ty<'tcx>; fn replace_ty(&mut self, bt: ty::BoundTy) -> Ty<'tcx>;
fn replace_const(&mut self, bv: ty::BoundVar, ty: Ty<'tcx>) -> ty::Const<'tcx>; fn replace_const(&mut self, bv: ty::BoundVar) -> ty::Const<'tcx>;
} }
pub struct FnMutDelegate<'a, 'tcx> { pub struct FnMutDelegate<'a, 'tcx> {
pub regions: &'a mut (dyn FnMut(ty::BoundRegion) -> ty::Region<'tcx> + 'a), pub regions: &'a mut (dyn FnMut(ty::BoundRegion) -> ty::Region<'tcx> + 'a),
pub types: &'a mut (dyn FnMut(ty::BoundTy) -> Ty<'tcx> + 'a), pub types: &'a mut (dyn FnMut(ty::BoundTy) -> Ty<'tcx> + 'a),
pub consts: &'a mut (dyn FnMut(ty::BoundVar, Ty<'tcx>) -> ty::Const<'tcx> + 'a), pub consts: &'a mut (dyn FnMut(ty::BoundVar) -> ty::Const<'tcx> + 'a),
} }
impl<'a, 'tcx> BoundVarReplacerDelegate<'tcx> for FnMutDelegate<'a, 'tcx> { impl<'a, 'tcx> BoundVarReplacerDelegate<'tcx> for FnMutDelegate<'a, 'tcx> {
@ -150,8 +150,8 @@ impl<'a, 'tcx> BoundVarReplacerDelegate<'tcx> for FnMutDelegate<'a, 'tcx> {
fn replace_ty(&mut self, bt: ty::BoundTy) -> Ty<'tcx> { fn replace_ty(&mut self, bt: ty::BoundTy) -> Ty<'tcx> {
(self.types)(bt) (self.types)(bt)
} }
fn replace_const(&mut self, bv: ty::BoundVar, ty: Ty<'tcx>) -> ty::Const<'tcx> { fn replace_const(&mut self, bv: ty::BoundVar) -> ty::Const<'tcx> {
(self.consts)(bv, ty) (self.consts)(bv)
} }
} }
@ -224,7 +224,7 @@ where
fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> { fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
match ct.kind() { match ct.kind() {
ty::ConstKind::Bound(debruijn, bound_const) if debruijn == self.current_index => { ty::ConstKind::Bound(debruijn, bound_const) if debruijn == self.current_index => {
let ct = self.delegate.replace_const(bound_const, ct.ty()); let ct = self.delegate.replace_const(bound_const);
debug_assert!(!ct.has_vars_bound_above(ty::INNERMOST)); debug_assert!(!ct.has_vars_bound_above(ty::INNERMOST));
ty::fold::shift_vars(self.tcx, ct, self.current_index.as_u32()) ty::fold::shift_vars(self.tcx, ct, self.current_index.as_u32())
} }
@ -282,7 +282,7 @@ impl<'tcx> TyCtxt<'tcx> {
let delegate = FnMutDelegate { let delegate = FnMutDelegate {
regions: &mut replace_regions, regions: &mut replace_regions,
types: &mut |b| bug!("unexpected bound ty in binder: {b:?}"), types: &mut |b| bug!("unexpected bound ty in binder: {b:?}"),
consts: &mut |b, ty| bug!("unexpected bound ct in binder: {b:?} {ty}"), consts: &mut |b| bug!("unexpected bound ct in binder: {b:?}"),
}; };
let mut replacer = BoundVarReplacer::new(self, delegate); let mut replacer = BoundVarReplacer::new(self, delegate);
value.fold_with(&mut replacer) value.fold_with(&mut replacer)
@ -353,9 +353,7 @@ impl<'tcx> TyCtxt<'tcx> {
ty::BoundTy { var: shift_bv(t.var), kind: t.kind }, ty::BoundTy { var: shift_bv(t.var), kind: t.kind },
) )
}, },
consts: &mut |c, ty: Ty<'tcx>| { consts: &mut |c| ty::Const::new_bound(self, ty::INNERMOST, shift_bv(c)),
ty::Const::new_bound(self, ty::INNERMOST, shift_bv(c), ty)
},
}, },
) )
} }
@ -398,12 +396,12 @@ impl<'tcx> TyCtxt<'tcx> {
.expect_ty(); .expect_ty();
Ty::new_bound(self.tcx, ty::INNERMOST, BoundTy { var, kind }) Ty::new_bound(self.tcx, ty::INNERMOST, BoundTy { var, kind })
} }
fn replace_const(&mut self, bv: ty::BoundVar, ty: Ty<'tcx>) -> ty::Const<'tcx> { fn replace_const(&mut self, bv: ty::BoundVar) -> ty::Const<'tcx> {
let entry = self.map.entry(bv); let entry = self.map.entry(bv);
let index = entry.index(); let index = entry.index();
let var = ty::BoundVar::from_usize(index); let var = ty::BoundVar::from_usize(index);
let () = entry.or_insert_with(|| ty::BoundVariableKind::Const).expect_const(); let () = entry.or_insert_with(|| ty::BoundVariableKind::Const).expect_const();
ty::Const::new_bound(self.tcx, ty::INNERMOST, var, ty) ty::Const::new_bound(self.tcx, ty::INNERMOST, var)
} }
} }

6
compiler/rustc_middle/src/ty/generic_args.rs
View file

@ -228,7 +228,7 @@ impl<'tcx> GenericArg<'tcx> {
ptr.cast::<WithCachedTypeInfo<ty::TyKind<'tcx>>>().as_ref(), ptr.cast::<WithCachedTypeInfo<ty::TyKind<'tcx>>>().as_ref(),
))), ))),
CONST_TAG => GenericArgKind::Const(ty::Const(Interned::new_unchecked( CONST_TAG => GenericArgKind::Const(ty::Const(Interned::new_unchecked(
ptr.cast::<WithCachedTypeInfo<ty::ConstData<'tcx>>>().as_ref(), ptr.cast::<WithCachedTypeInfo<ty::ConstKind<'tcx>>>().as_ref(),
))), ))),
_ => intrinsics::unreachable(), _ => intrinsics::unreachable(),
} }
@ -454,11 +454,11 @@ impl<'tcx> GenericArgs<'tcx> {
def_id: DefId, def_id: DefId,
original_args: &[GenericArg<'tcx>], original_args: &[GenericArg<'tcx>],
) -> GenericArgsRef<'tcx> { ) -> GenericArgsRef<'tcx> {
ty::GenericArgs::for_item(tcx, def_id, |def, args| { ty::GenericArgs::for_item(tcx, def_id, |def, _| {
if let Some(arg) = original_args.get(def.index as usize) { if let Some(arg) = original_args.get(def.index as usize) {
*arg *arg
} else { } else {
def.to_error(tcx, args) def.to_error(tcx)
} }
}) })
} }

12
compiler/rustc_middle/src/ty/generics.rs
View file

@ -100,19 +100,11 @@ impl GenericParamDef {
} }
} }
pub fn to_error<'tcx>( pub fn to_error<'tcx>(&self, tcx: TyCtxt<'tcx>) -> ty::GenericArg<'tcx> {
&self,
tcx: TyCtxt<'tcx>,
preceding_args: &[ty::GenericArg<'tcx>],
) -> ty::GenericArg<'tcx> {
match &self.kind { match &self.kind {
ty::GenericParamDefKind::Lifetime => ty::Region::new_error_misc(tcx).into(), ty::GenericParamDefKind::Lifetime => ty::Region::new_error_misc(tcx).into(),
ty::GenericParamDefKind::Type { .. } => Ty::new_misc_error(tcx).into(), ty::GenericParamDefKind::Type { .. } => Ty::new_misc_error(tcx).into(),
ty::GenericParamDefKind::Const { .. } => ty::Const::new_misc_error( ty::GenericParamDefKind::Const { .. } => ty::Const::new_misc_error(tcx).into(),
tcx,
tcx.type_of(self.def_id).instantiate(tcx, preceding_args),
)
.into(),
} }
} }
} }

4
compiler/rustc_middle/src/ty/layout.rs
View file

@ -385,9 +385,7 @@ impl<'tcx> SizeSkeleton<'tcx> {
), ),
} }
} }
ty::Array(inner, len) ty::Array(inner, len) if tcx.features().transmute_generic_consts => {
if len.ty() == tcx.types.usize && tcx.features().transmute_generic_consts =>
{
let len_eval = len.try_eval_target_usize(tcx, param_env); let len_eval = len.try_eval_target_usize(tcx, param_env);
if len_eval == Some(0) { if len_eval == Some(0) {
return Ok(SizeSkeleton::Known(Size::from_bytes(0))); return Ok(SizeSkeleton::Known(Size::from_bytes(0)));

4
compiler/rustc_middle/src/ty/mod.rs
View file

@ -87,7 +87,7 @@ pub use self::closure::{
CAPTURE_STRUCT_LOCAL, CAPTURE_STRUCT_LOCAL,
}; };
pub use self::consts::{ pub use self::consts::{
Const, ConstData, ConstInt, ConstKind, Expr, ExprKind, ScalarInt, UnevaluatedConst, ValTree, Const, ConstInt, ConstKind, Expr, ExprKind, ScalarInt, UnevaluatedConst, ValTree,
}; };
pub use self::context::{ pub use self::context::{
tls, CtxtInterners, CurrentGcx, DeducedParamAttrs, Feed, FreeRegionInfo, GlobalCtxt, Lift, tls, CtxtInterners, CurrentGcx, DeducedParamAttrs, Feed, FreeRegionInfo, GlobalCtxt, Lift,
@ -617,7 +617,7 @@ impl<'tcx> Term<'tcx> {
ptr.cast::<WithCachedTypeInfo<ty::TyKind<'tcx>>>().as_ref(), ptr.cast::<WithCachedTypeInfo<ty::TyKind<'tcx>>>().as_ref(),
))), ))),
CONST_TAG => TermKind::Const(ty::Const(Interned::new_unchecked( CONST_TAG => TermKind::Const(ty::Const(Interned::new_unchecked(
ptr.cast::<WithCachedTypeInfo<ty::ConstData<'tcx>>>().as_ref(), ptr.cast::<WithCachedTypeInfo<ty::ConstKind<'tcx>>>().as_ref(),
))), ))),
_ => core::intrinsics::unreachable(), _ => core::intrinsics::unreachable(),
} }

2
compiler/rustc_middle/src/ty/opaque_types.rs
View file

@ -216,7 +216,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReverseMapper<'tcx> {
}) })
.emit_unless(self.ignore_errors); .emit_unless(self.ignore_errors);
ty::Const::new_error(self.tcx, guar, ct.ty()) ty::Const::new_error(self.tcx, guar)
} }
} }
} }

4
compiler/rustc_middle/src/ty/print/pretty.rs
View file

@ -1467,7 +1467,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
write!(this, "_")?; write!(this, "_")?;
Ok(()) Ok(())
}, },
|this| this.print_type(ct.ty()), |this| this.print_type(todo!()),
": ", ": ",
)?; )?;
} else { } else {
@ -1512,7 +1512,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
}, },
ty::ConstKind::Param(ParamConst { name, .. }) => p!(write("{}", name)), ty::ConstKind::Param(ParamConst { name, .. }) => p!(write("{}", name)),
ty::ConstKind::Value(value) => { ty::ConstKind::Value(value) => {
return self.pretty_print_const_valtree(value, ct.ty(), print_ty); return self.pretty_print_const_valtree(value, todo!(), print_ty);
} }
ty::ConstKind::Bound(debruijn, bound_var) => { ty::ConstKind::Bound(debruijn, bound_var) => {

13
compiler/rustc_middle/src/ty/relate.rs
View file

@ -652,18 +652,17 @@ pub fn structurally_relate_consts<'tcx, R: TypeRelation<'tcx>>(
// and is the better alternative to waiting until `generic_const_exprs` can // and is the better alternative to waiting until `generic_const_exprs` can
// be stabilized. // be stabilized.
(ty::ConstKind::Unevaluated(au), ty::ConstKind::Unevaluated(bu)) if au.def == bu.def => { (ty::ConstKind::Unevaluated(au), ty::ConstKind::Unevaluated(bu)) if au.def == bu.def => {
assert_eq!(a.ty(), b.ty()); let a_ty = tcx.type_of(au.def).instantiate(tcx, au.args);
let b_ty = tcx.type_of(bu.def).instantiate(tcx, bu.args);
assert_eq!(a_ty, b_ty);
let args = relation.relate_with_variance( let args = relation.relate_with_variance(
ty::Variance::Invariant, ty::Variance::Invariant,
ty::VarianceDiagInfo::default(), ty::VarianceDiagInfo::default(),
au.args, au.args,
bu.args, bu.args,
)?; )?;
return Ok(ty::Const::new_unevaluated( return Ok(ty::Const::new_unevaluated(tcx, ty::UnevaluatedConst { def: au.def, args }));
tcx,
ty::UnevaluatedConst { def: au.def, args },
a.ty(),
));
} }
(ty::ConstKind::Expr(ae), ty::ConstKind::Expr(be)) => { (ty::ConstKind::Expr(ae), ty::ConstKind::Expr(be)) => {
match (ae.kind, be.kind) { match (ae.kind, be.kind) {
@ -676,7 +675,7 @@ pub fn structurally_relate_consts<'tcx, R: TypeRelation<'tcx>>(
} }
let args = relation.relate(ae.args(), be.args())?; let args = relation.relate(ae.args(), be.args())?;
return Ok(ty::Const::new_expr(tcx, ty::Expr::new(ae.kind, args), a.ty())); return Ok(ty::Const::new_expr(tcx, ty::Expr::new(ae.kind, args)));
} }
_ => false, _ => false,
}; };

19
compiler/rustc_middle/src/ty/structural_impls.rs
View file

@ -210,17 +210,14 @@ impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::Const<'tcx> {
bug!("we checked that this is a valtree") bug!("we checked that this is a valtree")
}; };
let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS); let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS);
cx.pretty_print_const_valtree(valtree, lifted.ty(), /*print_ty*/ true)?; // THISPR
todo!();
// cx.pretty_print_const_valtree(valtree, lifted.ty(), /*print_ty*/ true)?;
f.write_str(&cx.into_buffer()) f.write_str(&cx.into_buffer())
}); });
} }
// Fall back to something verbose. // Fall back to something verbose.
write!( write!(f, "{kind:?}", kind = &this.map(|data| data.kind()))
f,
"{kind:?}: {ty:?}",
ty = &this.map(|data| data.ty()),
kind = &this.map(|data| data.kind())
)
} }
} }
@ -647,7 +644,6 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for ty::Const<'tcx> {
self, self,
folder: &mut F, folder: &mut F,
) -> Result<Self, F::Error> { ) -> Result<Self, F::Error> {
let ty = self.ty().try_fold_with(folder)?;
let kind = match self.kind() { let kind = match self.kind() {
ConstKind::Param(p) => ConstKind::Param(p.try_fold_with(folder)?), ConstKind::Param(p) => ConstKind::Param(p.try_fold_with(folder)?),
ConstKind::Infer(i) => ConstKind::Infer(i.try_fold_with(folder)?), ConstKind::Infer(i) => ConstKind::Infer(i.try_fold_with(folder)?),
@ -660,17 +656,12 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for ty::Const<'tcx> {
ConstKind::Error(e) => ConstKind::Error(e.try_fold_with(folder)?), ConstKind::Error(e) => ConstKind::Error(e.try_fold_with(folder)?),
ConstKind::Expr(e) => ConstKind::Expr(e.try_fold_with(folder)?), ConstKind::Expr(e) => ConstKind::Expr(e.try_fold_with(folder)?),
}; };
if ty != self.ty() || kind != self.kind() { if kind != self.kind() { Ok(folder.interner().mk_ct_from_kind(kind)) } else { Ok(self) }
Ok(folder.interner().mk_ct_from_kind(kind, ty))
} else {
Ok(self)
}
} }
} }
impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for ty::Const<'tcx> { impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for ty::Const<'tcx> {
fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result { fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
try_visit!(self.ty().visit_with(visitor));
match self.kind() { match self.kind() {
ConstKind::Param(p) => p.visit_with(visitor), ConstKind::Param(p) => p.visit_with(visitor),
ConstKind::Infer(i) => i.visit_with(visitor), ConstKind::Infer(i) => i.visit_with(visitor),

25
compiler/rustc_middle/src/ty/walk.rs
View file

@ -212,21 +212,18 @@ fn push_inner<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent: GenericArg<'tcx>)
} }
}, },
GenericArgKind::Lifetime(_) => {} GenericArgKind::Lifetime(_) => {}
GenericArgKind::Const(parent_ct) => { GenericArgKind::Const(parent_ct) => match parent_ct.kind() {
stack.push(parent_ct.ty().into()); ty::ConstKind::Infer(_)
match parent_ct.kind() { | ty::ConstKind::Param(_)
ty::ConstKind::Infer(_) | ty::ConstKind::Placeholder(_)
| ty::ConstKind::Param(_) | ty::ConstKind::Bound(..)
| ty::ConstKind::Placeholder(_) | ty::ConstKind::Value(_)
| ty::ConstKind::Bound(..) | ty::ConstKind::Error(_) => {}
| ty::ConstKind::Value(_)
| ty::ConstKind::Error(_) => {}
ty::ConstKind::Expr(expr) => stack.extend(expr.args().iter().rev()), ty::ConstKind::Expr(expr) => stack.extend(expr.args().iter().rev()),
ty::ConstKind::Unevaluated(ct) => { ty::ConstKind::Unevaluated(ct) => {
stack.extend(ct.args.iter().rev()); stack.extend(ct.args.iter().rev());
}
} }
} },
} }
} }

6
compiler/rustc_mir_build/src/build/expr/as_constant.rs
View file

@ -50,9 +50,7 @@ pub(crate) fn as_constant_inner<'tcx>(
let const_ = match lit_to_mir_constant(tcx, LitToConstInput { lit: &lit.node, ty, neg }) let const_ = match lit_to_mir_constant(tcx, LitToConstInput { lit: &lit.node, ty, neg })
{ {
Ok(c) => c, Ok(c) => c,
Err(LitToConstError::Reported(guar)) => { Err(LitToConstError::Reported(guar)) => Const::Ty(ty::Const::new_error(tcx, guar)),
Const::Ty(ty::Const::new_error(tcx, guar, ty))
}
Err(LitToConstError::TypeError) => { Err(LitToConstError::TypeError) => {
bug!("encountered type error in `lit_to_mir_constant`") bug!("encountered type error in `lit_to_mir_constant`")
} }
@ -83,7 +81,7 @@ pub(crate) fn as_constant_inner<'tcx>(
ConstOperand { user_ty, span, const_ } ConstOperand { user_ty, span, const_ }
} }
ExprKind::ConstParam { param, def_id: _ } => { ExprKind::ConstParam { param, def_id: _ } => {
let const_param = ty::Const::new_param(tcx, param, expr.ty); let const_param = ty::Const::new_param(tcx, param);
let const_ = Const::Ty(const_param); let const_ = Const::Ty(const_param);
ConstOperand { user_ty: None, span, const_ } ConstOperand { user_ty: None, span, const_ }

50
compiler/rustc_next_trait_solver/src/canonicalizer.rs
View file

@ -386,23 +386,15 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I>
} }
fn fold_const(&mut self, c: I::Const) -> I::Const { fn fold_const(&mut self, c: I::Const) -> I::Const {
// We could canonicalize all consts with static types, but the only ones we
// *really* need to worry about are the ones that we end up putting into `CanonicalVarKind`
// since canonical vars can't reference other canonical vars.
let ty = c
.ty()
.fold_with(&mut RegionsToStatic { interner: self.interner(), binder: ty::INNERMOST });
let kind = match c.kind() { let kind = match c.kind() {
ty::ConstKind::Infer(i) => match i { ty::ConstKind::Infer(i) => match i {
ty::InferConst::Var(vid) => { ty::InferConst::Var(vid) => {
// We compare `kind`s here because we've folded the `ty` with `RegionsToStatic`
// so we'll get a mismatch in types if it actually changed any regions.
assert_eq!( assert_eq!(
self.infcx.opportunistic_resolve_ct_var(vid, ty).kind(), self.infcx.opportunistic_resolve_ct_var(vid),
c.kind(), c,
"region vid should have been resolved fully before canonicalization" "const vid should have been resolved fully before canonicalization"
); );
CanonicalVarKind::Const(self.infcx.universe_of_ct(vid).unwrap(), ty) CanonicalVarKind::Const(self.infcx.universe_of_ct(vid).unwrap())
} }
ty::InferConst::EffectVar(_) => CanonicalVarKind::Effect, ty::InferConst::EffectVar(_) => CanonicalVarKind::Effect,
ty::InferConst::Fresh(_) => todo!(), ty::InferConst::Fresh(_) => todo!(),
@ -410,16 +402,14 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I>
ty::ConstKind::Placeholder(placeholder) => match self.canonicalize_mode { ty::ConstKind::Placeholder(placeholder) => match self.canonicalize_mode {
CanonicalizeMode::Input => CanonicalVarKind::PlaceholderConst( CanonicalizeMode::Input => CanonicalVarKind::PlaceholderConst(
PlaceholderLike::new(placeholder.universe(), self.variables.len().into()), PlaceholderLike::new(placeholder.universe(), self.variables.len().into()),
ty,
), ),
CanonicalizeMode::Response { .. } => { CanonicalizeMode::Response { .. } => {
CanonicalVarKind::PlaceholderConst(placeholder, ty) CanonicalVarKind::PlaceholderConst(placeholder)
} }
}, },
ty::ConstKind::Param(_) => match self.canonicalize_mode { ty::ConstKind::Param(_) => match self.canonicalize_mode {
CanonicalizeMode::Input => CanonicalVarKind::PlaceholderConst( CanonicalizeMode::Input => CanonicalVarKind::PlaceholderConst(
PlaceholderLike::new(ty::UniverseIndex::ROOT, self.variables.len().into()), PlaceholderLike::new(ty::UniverseIndex::ROOT, self.variables.len().into()),
ty,
), ),
CanonicalizeMode::Response { .. } => panic!("param ty in response: {c:?}"), CanonicalizeMode::Response { .. } => panic!("param ty in response: {c:?}"),
}, },
@ -440,34 +430,6 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I>
}), }),
); );
Const::new_anon_bound(self.interner(), self.binder_index, var, ty) Const::new_anon_bound(self.interner(), self.binder_index, var)
}
}
struct RegionsToStatic<I> {
interner: I,
binder: ty::DebruijnIndex,
}
impl<I: Interner> TypeFolder<I> for RegionsToStatic<I> {
fn interner(&self) -> I {
self.interner
}
fn fold_binder<T>(&mut self, t: ty::Binder<I, T>) -> ty::Binder<I, T>
where
T: TypeFoldable<I>,
{
self.binder.shift_in(1);
let t = t.super_fold_with(self);
self.binder.shift_out(1);
t
}
fn fold_region(&mut self, r: I::Region) -> I::Region {
match r.kind() {
ty::ReBound(db, _) if self.binder > db => r,
_ => Region::new_static(self.interner()),
}
} }
} }

7
compiler/rustc_next_trait_solver/src/resolve.rs
View file

@ -58,8 +58,7 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I> for EagerRes
fn fold_const(&mut self, c: I::Const) -> I::Const { fn fold_const(&mut self, c: I::Const) -> I::Const {
match c.kind() { match c.kind() {
ty::ConstKind::Infer(ty::InferConst::Var(vid)) => { ty::ConstKind::Infer(ty::InferConst::Var(vid)) => {
let ty = c.ty().fold_with(self); let resolved = self.infcx.opportunistic_resolve_ct_var(vid);
let resolved = self.infcx.opportunistic_resolve_ct_var(vid, ty);
if c != resolved && resolved.has_infer() { if c != resolved && resolved.has_infer() {
resolved.fold_with(self) resolved.fold_with(self)
} else { } else {
@ -67,9 +66,7 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I> for EagerRes
} }
} }
ty::ConstKind::Infer(ty::InferConst::EffectVar(vid)) => { ty::ConstKind::Infer(ty::InferConst::EffectVar(vid)) => {
let bool = Ty::new_bool(self.infcx.interner()); self.infcx.opportunistic_resolve_effect_var(vid)
debug_assert_eq!(c.ty(), bool);
self.infcx.opportunistic_resolve_effect_var(vid, bool)
} }
_ => { _ => {
if c.has_infer() { if c.has_infer() {

11
compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
View file

@ -111,7 +111,8 @@ fn encode_const<'tcx>(
// L<element-type>E as literal argument // L<element-type>E as literal argument
// Element type // Element type
s.push_str(&encode_ty(tcx, c.ty(), dict, options)); // THISPR
s.push_str(&encode_ty(tcx, todo!(), dict, options));
} }
// Literal arguments // Literal arguments
@ -119,12 +120,14 @@ fn encode_const<'tcx>(
// L<element-type>[n]<element-value>E as literal argument // L<element-type>[n]<element-value>E as literal argument
// Element type // Element type
s.push_str(&encode_ty(tcx, c.ty(), dict, options)); // THISPR
let ct_ty: Ty<'tcx> = todo!();
s.push_str(&encode_ty(tcx, ct_ty, dict, options));
// The only allowed types of const values are bool, u8, u16, u32, // The only allowed types of const values are bool, u8, u16, u32,
// u64, u128, usize i8, i16, i32, i64, i128, isize, and char. The // u64, u128, usize i8, i16, i32, i64, i128, isize, and char. The
// bool value false is encoded as 0 and true as 1. // bool value false is encoded as 0 and true as 1.
match c.ty().kind() { match ct_ty.kind() {
ty::Int(ity) => { ty::Int(ity) => {
let bits = c.eval_bits(tcx, ty::ParamEnv::reveal_all()); let bits = c.eval_bits(tcx, ty::ParamEnv::reveal_all());
let val = Integer::from_int_ty(&tcx, *ity).size().sign_extend(bits) as i128; let val = Integer::from_int_ty(&tcx, *ity).size().sign_extend(bits) as i128;
@ -142,7 +145,7 @@ fn encode_const<'tcx>(
let _ = write!(s, "{val}"); let _ = write!(s, "{val}");
} }
_ => { _ => {
bug!("encode_const: unexpected type `{:?}`", c.ty()); bug!("encode_const: unexpected type `{:?}`", ct_ty);
} }
} }
} }

5
compiler/rustc_smir/src/rustc_smir/convert/ty.rs
View file

@ -463,7 +463,10 @@ impl<'tcx> Stable<'tcx> for ty::Const<'tcx> {
ty::ValTree::Branch(tables.tcx.lift(branch).unwrap()) ty::ValTree::Branch(tables.tcx.lift(branch).unwrap())
} }
}; };
let ty = tables.tcx.lift(self.ty()).unwrap();
// THISPR
let ty = todo!();
// let ty = tables.tcx.lift(c.ty()).unwrap();
let const_val = tables.tcx.valtree_to_const_val((ty, val)); let const_val = tables.tcx.valtree_to_const_val((ty, val));
if matches!(const_val, mir::ConstValue::ZeroSized) { if matches!(const_val, mir::ConstValue::ZeroSized) {
stable_mir::ty::TyConstKind::ZSTValue(ty.stable(tables)) stable_mir::ty::TyConstKind::ZSTValue(ty.stable(tables))

11
compiler/rustc_symbol_mangling/src/legacy.rs
View file

@ -269,16 +269,21 @@ impl<'tcx> Printer<'tcx> for SymbolPrinter<'tcx> {
} }
fn print_const(&mut self, ct: ty::Const<'tcx>) -> Result<(), PrintError> { fn print_const(&mut self, ct: ty::Const<'tcx>) -> Result<(), PrintError> {
// THISPR
let ct_ty: Ty<'tcx> = todo!();
// only print integers // only print integers
match (ct.kind(), ct.ty().kind()) { match (ct.kind(), ct_ty.kind()) {
(ty::ConstKind::Value(ty::ValTree::Leaf(scalar)), ty::Int(_) | ty::Uint(_)) => { (ty::ConstKind::Value(ty::ValTree::Leaf(scalar)), ty::Int(_) | ty::Uint(_)) => {
// The `pretty_print_const` formatting depends on -Zverbose-internals // The `pretty_print_const` formatting depends on -Zverbose-internals
// flag, so we cannot reuse it here. // flag, so we cannot reuse it here.
let signed = matches!(ct.ty().kind(), ty::Int(_)); let signed = matches!(ct_ty.kind(), ty::Int(_));
write!( write!(
self, self,
"{:#?}", "{:#?}",
ty::ConstInt::new(scalar, signed, ct.ty().is_ptr_sized_integral()) // THISPR
// ct.ty().is_ptr_sized_integral()
ty::ConstInt::new(scalar, signed, todo!())
)?; )?;
} }
_ => self.write_str("_")?, _ => self.write_str("_")?,

16
compiler/rustc_symbol_mangling/src/v0.rs
View file

@ -567,7 +567,9 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
} }
let start = self.out.len(); let start = self.out.len();
let ty = ct.ty(); // THISPR
let ty: Ty<'tcx> = todo!();
// let ty = ct.ty();
match ty.kind() { match ty.kind() {
ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Char => { ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Char => {
@ -626,12 +628,10 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
} }
} }
_ => { _ => {
let pointee_ty = ct let pointee_ty =
.ty() ty.builtin_deref(true).expect("tried to dereference on non-ptr type");
.builtin_deref(true)
.expect("tried to dereference on non-ptr type");
// FIXME(const_generics): add an assert that we only do this for valtrees. // FIXME(const_generics): add an assert that we only do this for valtrees.
let dereferenced_const = self.tcx.mk_ct_from_kind(ct.kind(), pointee_ty); let dereferenced_const = self.tcx.mk_ct_from_kind(ct.kind());
dereferenced_const.print(self)?; dereferenced_const.print(self)?;
} }
} }
@ -649,7 +649,7 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
Ok(()) Ok(())
}; };
match *ct.ty().kind() { match *ty.kind() {
ty::Array(..) | ty::Slice(_) => { ty::Array(..) | ty::Slice(_) => {
self.push("A"); self.push("A");
print_field_list(self)?; print_field_list(self)?;
@ -698,7 +698,7 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
} }
} }
_ => { _ => {
bug!("symbol_names: unsupported constant of type `{}` ({:?})", ct.ty(), ct); bug!("symbol_names: unsupported constant of type `{}` ({:?})", ty, ct);
} }
} }

2
compiler/rustc_trait_selection/src/solve/eval_ctxt/canonical.rs
View file

@ -444,7 +444,7 @@ pub(in crate::solve) fn instantiate_canonical_state<'tcx, T: TypeFoldable<TyCtxt
infcx.next_region_var(RegionVariableOrigin::MiscVariable(span)).into() infcx.next_region_var(RegionVariableOrigin::MiscVariable(span)).into()
} }
ty::GenericArgKind::Type(_) => infcx.next_ty_var(span).into(), ty::GenericArgKind::Type(_) => infcx.next_ty_var(span).into(),
ty::GenericArgKind::Const(ct) => infcx.next_const_var(ct.ty(), span).into(), ty::GenericArgKind::Const(_) => infcx.next_const_var(span).into(),
}; };
orig_values.push(unconstrained); orig_values.push(unconstrained);

14
compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs
View file

@ -609,8 +609,8 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
ty ty
} }
pub(super) fn next_const_infer(&mut self, ty: Ty<'tcx>) -> ty::Const<'tcx> { pub(super) fn next_const_infer(&mut self) -> ty::Const<'tcx> {
let ct = self.infcx.next_const_var(ty, DUMMY_SP); let ct = self.infcx.next_const_var(DUMMY_SP);
self.inspect.add_var_value(ct); self.inspect.add_var_value(ct);
ct ct
} }
@ -620,7 +620,7 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
pub(super) fn next_term_infer_of_kind(&mut self, kind: ty::Term<'tcx>) -> ty::Term<'tcx> { pub(super) fn next_term_infer_of_kind(&mut self, kind: ty::Term<'tcx>) -> ty::Term<'tcx> {
match kind.unpack() { match kind.unpack() {
ty::TermKind::Ty(_) => self.next_ty_infer().into(), ty::TermKind::Ty(_) => self.next_ty_infer().into(),
ty::TermKind::Const(ct) => self.next_const_infer(ct.ty()).into(), ty::TermKind::Const(_) => self.next_const_infer().into(),
} }
} }
@ -1037,14 +1037,14 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
&self, &self,
param_env: ty::ParamEnv<'tcx>, param_env: ty::ParamEnv<'tcx>,
unevaluated: ty::UnevaluatedConst<'tcx>, unevaluated: ty::UnevaluatedConst<'tcx>,
ty: Ty<'tcx>,
) -> Option<ty::Const<'tcx>> { ) -> Option<ty::Const<'tcx>> {
use rustc_middle::mir::interpret::ErrorHandled; use rustc_middle::mir::interpret::ErrorHandled;
match self.infcx.const_eval_resolve(param_env, unevaluated, DUMMY_SP) { match self.infcx.const_eval_resolve(param_env, unevaluated, DUMMY_SP) {
Ok(Some(val)) => Some(ty::Const::new_value(self.interner(), val, ty)), // THISPR
Ok(Some(val)) => Some(ty::Const::new_value(self.interner(), val, todo!())),
Ok(None) | Err(ErrorHandled::TooGeneric(_)) => None, Ok(None) | Err(ErrorHandled::TooGeneric(_)) => None,
Err(ErrorHandled::Reported(e, _)) => { Err(ErrorHandled::Reported(e, _)) => {
Some(ty::Const::new_error(self.interner(), e.into(), ty)) Some(ty::Const::new_error(self.interner(), e.into()))
} }
} }
} }
@ -1124,7 +1124,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReplaceAliasWithInfer<'_, '_, 'tcx> {
fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> { fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
match ct.kind() { match ct.kind() {
ty::ConstKind::Unevaluated(..) if !ct.has_escaping_bound_vars() => { ty::ConstKind::Unevaluated(..) if !ct.has_escaping_bound_vars() => {
let infer_ct = self.ecx.next_const_infer(ct.ty()); let infer_ct = self.ecx.next_const_infer();
let normalizes_to = ty::PredicateKind::AliasRelate( let normalizes_to = ty::PredicateKind::AliasRelate(
ct.into(), ct.into(),
infer_ct.into(), infer_ct.into(),

2
compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
View file

@ -208,7 +208,7 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
Some(ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term })) => { Some(ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term })) => {
let unconstrained_term = match term.unpack() { let unconstrained_term = match term.unpack() {
ty::TermKind::Ty(_) => infcx.next_ty_var(span).into(), ty::TermKind::Ty(_) => infcx.next_ty_var(span).into(),
ty::TermKind::Const(ct) => infcx.next_const_var(ct.ty(), span).into(), ty::TermKind::Const(_) => infcx.next_const_var(span).into(),
}; };
let goal = let goal =
goal.with(infcx.tcx, ty::NormalizesTo { alias, term: unconstrained_term }); goal.with(infcx.tcx, ty::NormalizesTo { alias, term: unconstrained_term });

5
compiler/rustc_trait_selection/src/solve/mod.rs
View file

@ -169,7 +169,7 @@ impl<'a, 'tcx> EvalCtxt<'a, InferCtxt<'tcx>> {
// FIXME(generic_const_exprs): Implement handling for generic // FIXME(generic_const_exprs): Implement handling for generic
// const expressions here. // const expressions here.
if let Some(_normalized) = self.try_const_eval_resolve(param_env, uv, ct.ty()) { if let Some(_normalized) = self.try_const_eval_resolve(param_env, uv) {
self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
} else { } else {
self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS) self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
@ -217,7 +217,8 @@ impl<'a, 'tcx> EvalCtxt<'a, InferCtxt<'tcx>> {
self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
} }
_ => { _ => {
self.eq(goal.param_env, ct.ty(), ty)?; // THISPR
self.eq(goal.param_env, todo!(), ty)?;
self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
} }
} }

9
compiler/rustc_trait_selection/src/solve/normalize.rs
View file

@ -109,7 +109,6 @@ where
fn normalize_unevaluated_const( fn normalize_unevaluated_const(
&mut self, &mut self,
ty: Ty<'tcx>,
uv: ty::UnevaluatedConst<'tcx>, uv: ty::UnevaluatedConst<'tcx>,
) -> Result<ty::Const<'tcx>, Vec<E>> { ) -> Result<ty::Const<'tcx>, Vec<E>> {
let infcx = self.at.infcx; let infcx = self.at.infcx;
@ -126,7 +125,7 @@ where
self.depth += 1; self.depth += 1;
let new_infer_ct = infcx.next_const_var(ty, self.at.cause.span); let new_infer_ct = infcx.next_const_var(self.at.cause.span);
let obligation = Obligation::new( let obligation = Obligation::new(
tcx, tcx,
self.at.cause.clone(), self.at.cause.clone(),
@ -143,7 +142,7 @@ where
let ct = infcx.resolve_vars_if_possible(new_infer_ct); let ct = infcx.resolve_vars_if_possible(new_infer_ct);
ct.try_fold_with(self)? ct.try_fold_with(self)?
} else { } else {
ty::Const::new_unevaluated(tcx, uv, ty).try_super_fold_with(self)? ty::Const::new_unevaluated(tcx, uv).try_super_fold_with(self)?
}; };
self.depth -= 1; self.depth -= 1;
@ -214,7 +213,7 @@ where
if uv.has_escaping_bound_vars() { if uv.has_escaping_bound_vars() {
let (uv, mapped_regions, mapped_types, mapped_consts) = let (uv, mapped_regions, mapped_types, mapped_consts) =
BoundVarReplacer::replace_bound_vars(infcx, &mut self.universes, uv); BoundVarReplacer::replace_bound_vars(infcx, &mut self.universes, uv);
let result = ensure_sufficient_stack(|| self.normalize_unevaluated_const(ct.ty(), uv))?; let result = ensure_sufficient_stack(|| self.normalize_unevaluated_const(uv))?;
Ok(PlaceholderReplacer::replace_placeholders( Ok(PlaceholderReplacer::replace_placeholders(
infcx, infcx,
mapped_regions, mapped_regions,
@ -224,7 +223,7 @@ where
result, result,
)) ))
} else { } else {
ensure_sufficient_stack(|| self.normalize_unevaluated_const(ct.ty(), uv)) ensure_sufficient_stack(|| self.normalize_unevaluated_const(uv))
} }
} }
} }

4
compiler/rustc_trait_selection/src/solve/normalizes_to/anon_const.rs
View file

@ -12,10 +12,6 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
if let Some(normalized_const) = self.try_const_eval_resolve( if let Some(normalized_const) = self.try_const_eval_resolve(
goal.param_env, goal.param_env,
ty::UnevaluatedConst::new(goal.predicate.alias.def_id, goal.predicate.alias.args), ty::UnevaluatedConst::new(goal.predicate.alias.def_id, goal.predicate.alias.args),
self.interner()
.type_of(goal.predicate.alias.def_id)
.no_bound_vars()
.expect("const ty should not rely on other generics"),
) { ) {
self.instantiate_normalizes_to_term(goal, normalized_const.into()); self.instantiate_normalizes_to_term(goal, normalized_const.into());
self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)

9
compiler/rustc_trait_selection/src/solve/normalizes_to/mod.rs
View file

@ -201,13 +201,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for NormalizesTo<'tcx> {
let error_response = |ecx: &mut EvalCtxt<'_, InferCtxt<'tcx>>, reason| { let error_response = |ecx: &mut EvalCtxt<'_, InferCtxt<'tcx>>, reason| {
let guar = tcx.dcx().span_delayed_bug(tcx.def_span(assoc_def.item.def_id), reason); let guar = tcx.dcx().span_delayed_bug(tcx.def_span(assoc_def.item.def_id), reason);
let error_term = match assoc_def.item.kind { let error_term = match assoc_def.item.kind {
ty::AssocKind::Const => ty::Const::new_error( ty::AssocKind::Const => ty::Const::new_error(tcx, guar).into(),
tcx,
guar,
tcx.type_of(goal.predicate.def_id())
.instantiate(tcx, goal.predicate.alias.args),
)
.into(),
ty::AssocKind::Type => Ty::new_error(tcx, guar).into(), ty::AssocKind::Type => Ty::new_error(tcx, guar).into(),
// This makes no sense... // This makes no sense...
ty::AssocKind::Fn => span_bug!( ty::AssocKind::Fn => span_bug!(
@ -253,7 +247,6 @@ impl<'tcx> assembly::GoalKind<'tcx> for NormalizesTo<'tcx> {
ty::EarlyBinder::bind( ty::EarlyBinder::bind(
ty::Const::new_error_with_message( ty::Const::new_error_with_message(
tcx, tcx,
tcx.type_of(assoc_def.item.def_id).instantiate_identity(),
DUMMY_SP, DUMMY_SP,
"associated const projection is not supported yet", "associated const projection is not supported yet",
) )

3
compiler/rustc_trait_selection/src/traits/auto_trait.rs
View file

@ -765,7 +765,8 @@ impl<'tcx> AutoTraitFinder<'tcx> {
unevaluated, unevaluated,
obligation.cause.span, obligation.cause.span,
) { ) {
Ok(Some(valtree)) => Ok(ty::Const::new_value(selcx.tcx(),valtree, c.ty())), // THISPR
Ok(Some(valtree)) => Ok(ty::Const::new_value(selcx.tcx(),valtree, todo!())),
Ok(None) => { Ok(None) => {
let tcx = self.tcx; let tcx = self.tcx;
let reported = let reported =

1
compiler/rustc_trait_selection/src/traits/coherence.rs
View file

@ -529,7 +529,6 @@ fn plug_infer_with_placeholders<'tcx>(
ty::Const::new_placeholder( ty::Const::new_placeholder(
self.infcx.tcx, self.infcx.tcx,
ty::Placeholder { universe: self.universe, bound: self.next_var() }, ty::Placeholder { universe: self.universe, bound: self.next_var() },
ct.ty(),
), ),
) )
else { else {

4
compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
View file

@ -173,8 +173,7 @@ fn satisfied_from_param_env<'tcx>(
debug!("is_const_evaluatable: candidate={:?}", c); debug!("is_const_evaluatable: candidate={:?}", c);
if self.infcx.probe(|_| { if self.infcx.probe(|_| {
let ocx = ObligationCtxt::new(self.infcx); let ocx = ObligationCtxt::new(self.infcx);
ocx.eq(&ObligationCause::dummy(), self.param_env, c.ty(), self.ct.ty()).is_ok() ocx.eq(&ObligationCause::dummy(), self.param_env, c, self.ct).is_ok()
&& ocx.eq(&ObligationCause::dummy(), self.param_env, c, self.ct).is_ok()
&& ocx.select_all_or_error().is_empty() && ocx.select_all_or_error().is_empty()
}) { }) {
self.single_match = match self.single_match { self.single_match = match self.single_match {
@ -215,7 +214,6 @@ fn satisfied_from_param_env<'tcx>(
if let Some(Ok(c)) = single_match { if let Some(Ok(c)) = single_match {
let ocx = ObligationCtxt::new(infcx); let ocx = ObligationCtxt::new(infcx);
assert!(ocx.eq(&ObligationCause::dummy(), param_env, c.ty(), ct.ty()).is_ok());
assert!(ocx.eq(&ObligationCause::dummy(), param_env, c, ct).is_ok()); assert!(ocx.eq(&ObligationCause::dummy(), param_env, c, ct).is_ok());
assert!(ocx.select_all_or_error().is_empty()); assert!(ocx.select_all_or_error().is_empty());
return true; return true;

3
compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
View file

@ -920,7 +920,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
&obligation.cause, &obligation.cause,
None, None,
None, None,
TypeError::Sorts(ty::error::ExpectedFound::new(true, ty, ct.ty())), // THISPR
TypeError::Sorts(ty::error::ExpectedFound::new(true, ty, todo!())),
false, false,
false, false,
); );

4
compiler/rustc_trait_selection/src/traits/fulfill.rs
View file

@ -459,7 +459,8 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
match self.selcx.infcx.at(&obligation.cause, obligation.param_env).eq( match self.selcx.infcx.at(&obligation.cause, obligation.param_env).eq(
// Only really excercised by generic_const_exprs // Only really excercised by generic_const_exprs
DefineOpaqueTypes::Yes, DefineOpaqueTypes::Yes,
ct.ty(), // THISPR
todo!(),
ty, ty,
) { ) {
Ok(inf_ok) => { Ok(inf_ok) => {
@ -633,7 +634,6 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
match self.selcx.infcx.try_const_eval_resolve( match self.selcx.infcx.try_const_eval_resolve(
obligation.param_env, obligation.param_env,
unevaluated, unevaluated,
c.ty(),
obligation.cause.span, obligation.cause.span,
) { ) {
Ok(val) => Ok(val), Ok(val) => Ok(val),

2
compiler/rustc_trait_selection/src/traits/mod.rs
View file

@ -359,7 +359,7 @@ pub fn normalize_param_env_or_error<'tcx>(
// `ty::Const::normalize` can only work with properly preserved binders. // `ty::Const::normalize` can only work with properly preserved binders.
if c.has_escaping_bound_vars() { if c.has_escaping_bound_vars() {
return ty::Const::new_misc_error(self.0, c.ty()); return ty::Const::new_misc_error(self.0);
} }
// While it is pretty sus to be evaluating things with an empty param env, it // While it is pretty sus to be evaluating things with an empty param env, it
// should actually be okay since without `feature(generic_const_exprs)` the only // should actually be okay since without `feature(generic_const_exprs)` the only

20
compiler/rustc_trait_selection/src/traits/project.rs
View file

@ -523,16 +523,9 @@ fn normalize_to_error<'a, 'tcx>(
| ty::AliasTermKind::InherentTy | ty::AliasTermKind::InherentTy
| ty::AliasTermKind::OpaqueTy | ty::AliasTermKind::OpaqueTy
| ty::AliasTermKind::WeakTy => selcx.infcx.next_ty_var(cause.span).into(), | ty::AliasTermKind::WeakTy => selcx.infcx.next_ty_var(cause.span).into(),
ty::AliasTermKind::UnevaluatedConst | ty::AliasTermKind::ProjectionConst => selcx ty::AliasTermKind::UnevaluatedConst | ty::AliasTermKind::ProjectionConst => {
.infcx selcx.infcx.next_const_var(cause.span).into()
.next_const_var( }
selcx
.tcx()
.type_of(projection_term.def_id)
.instantiate(selcx.tcx(), projection_term.args),
cause.span,
)
.into(),
}; };
let trait_obligation = Obligation { let trait_obligation = Obligation {
cause, cause,
@ -744,8 +737,6 @@ fn project<'cx, 'tcx>(
obligation.predicate.def_id, obligation.predicate.def_id,
obligation.predicate.args, obligation.predicate.args,
), ),
tcx.type_of(obligation.predicate.def_id)
.instantiate(tcx, obligation.predicate.args),
) )
.into(), .into(),
kind => { kind => {
@ -2071,15 +2062,14 @@ fn confirm_impl_candidate<'cx, 'tcx>(
// * `args` ends up as `[u32, S]` // * `args` ends up as `[u32, S]`
let args = obligation.predicate.args.rebase_onto(tcx, trait_def_id, args); let args = obligation.predicate.args.rebase_onto(tcx, trait_def_id, args);
let args = translate_args(selcx.infcx, param_env, impl_def_id, args, assoc_ty.defining_node); let args = translate_args(selcx.infcx, param_env, impl_def_id, args, assoc_ty.defining_node);
let ty = tcx.type_of(assoc_ty.item.def_id);
let is_const = matches!(tcx.def_kind(assoc_ty.item.def_id), DefKind::AssocConst); let is_const = matches!(tcx.def_kind(assoc_ty.item.def_id), DefKind::AssocConst);
let term: ty::EarlyBinder<'tcx, ty::Term<'tcx>> = if is_const { let term: ty::EarlyBinder<'tcx, ty::Term<'tcx>> = if is_const {
let did = assoc_ty.item.def_id; let did = assoc_ty.item.def_id;
let identity_args = crate::traits::GenericArgs::identity_for_item(tcx, did); let identity_args = crate::traits::GenericArgs::identity_for_item(tcx, did);
let uv = ty::UnevaluatedConst::new(did, identity_args); let uv = ty::UnevaluatedConst::new(did, identity_args);
ty.map_bound(|ty| ty::Const::new_unevaluated(tcx, uv, ty).into()) ty::EarlyBinder::bind(ty::Const::new_unevaluated(tcx, uv).into())
} else { } else {
ty.map_bound(|ty| ty.into()) tcx.type_of(assoc_ty.item.def_id).map_bound(|ty| ty.into())
}; };
if !tcx.check_args_compatible(assoc_ty.item.def_id, args) { if !tcx.check_args_compatible(assoc_ty.item.def_id, args) {
let err = Ty::new_error_with_message( let err = Ty::new_error_with_message(

3
compiler/rustc_trait_selection/src/traits/select/confirmation.rs
View file

@ -665,9 +665,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
tcx, tcx,
ty::INNERMOST, ty::INNERMOST,
ty::BoundVar::from_usize(bound_vars.len() - 1), ty::BoundVar::from_usize(bound_vars.len() - 1),
tcx.type_of(param.def_id)
.no_bound_vars()
.expect("const parameter types cannot be generic"),
) )
.into() .into()
} }

5
compiler/rustc_trait_selection/src/traits/select/mod.rs
View file

@ -947,7 +947,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
match self.infcx.try_const_eval_resolve( match self.infcx.try_const_eval_resolve(
obligation.param_env, obligation.param_env,
unevaluated, unevaluated,
c.ty(),
obligation.cause.span, obligation.cause.span,
) { ) {
Ok(val) => Ok(val), Ok(val) => Ok(val),
@ -1009,7 +1008,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
return Ok(EvaluatedToAmbig); return Ok(EvaluatedToAmbig);
} }
ty::ConstKind::Error(_) => return Ok(EvaluatedToOk), ty::ConstKind::Error(_) => return Ok(EvaluatedToOk),
_ => ct.ty(), // THISPR
_ => todo!(),
// _ => ct.ty(),
}; };
match self.infcx.at(&obligation.cause, obligation.param_env).eq( match self.infcx.at(&obligation.cause, obligation.param_env).eq(

4
compiler/rustc_trait_selection/src/traits/util.rs
View file

@ -483,7 +483,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for BoundVarReplacer<'_, 'tcx> {
let universe = self.universe_for(debruijn); let universe = self.universe_for(debruijn);
let p = ty::PlaceholderConst { universe, bound: bound_const }; let p = ty::PlaceholderConst { universe, bound: bound_const };
self.mapped_consts.insert(p, bound_const); self.mapped_consts.insert(p, bound_const);
ty::Const::new_placeholder(self.infcx.tcx, p, ct.ty()) ty::Const::new_placeholder(self.infcx.tcx, p)
} }
_ => ct.super_fold_with(self), _ => ct.super_fold_with(self),
} }
@ -626,7 +626,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for PlaceholderReplacer<'_, 'tcx> {
let db = ty::DebruijnIndex::from_usize( let db = ty::DebruijnIndex::from_usize(
self.universe_indices.len() - index + self.current_index.as_usize() - 1, self.universe_indices.len() - index + self.current_index.as_usize() - 1,
); );
ty::Const::new_bound(self.infcx.tcx, db, *replace_var, ct.ty()) ty::Const::new_bound(self.infcx.tcx, db, *replace_var)
} }
None => { None => {
if ct.has_infer() { if ct.has_infer() {

3
compiler/rustc_transmute/src/lib.rs
View file

@ -144,7 +144,8 @@ mod rustc {
}); });
}; };
let adt_def = c.ty().ty_adt_def()?; let assume_def_id = tcx.get_lang_items(()).get(LangItem::TransmuteOpts)?;
let adt_def = tcx.adt_def(assume_def_id);
assert_eq!( assert_eq!(
tcx.require_lang_item(LangItem::TransmuteOpts, None), tcx.require_lang_item(LangItem::TransmuteOpts, None),

41
compiler/rustc_ty_utils/src/consts.rs
View file

@ -32,7 +32,10 @@ fn destructure_const<'tcx>(
_ => bug!("cannot destructure constant {:?}", const_), _ => bug!("cannot destructure constant {:?}", const_),
}; };
let (fields, variant) = match const_.ty().kind() { // THISPR
let ct_ty: Ty<'tcx> = todo!();
let (fields, variant) = match ct_ty.kind() {
ty::Array(inner_ty, _) | ty::Slice(inner_ty) => { ty::Array(inner_ty, _) | ty::Slice(inner_ty) => {
// construct the consts for the elements of the array/slice // construct the consts for the elements of the array/slice
let field_consts = branches let field_consts = branches
@ -121,7 +124,7 @@ fn recurse_build<'tcx>(
let sp = node.span; let sp = node.span;
match tcx.at(sp).lit_to_const(LitToConstInput { lit: &lit.node, ty: node.ty, neg }) { match tcx.at(sp).lit_to_const(LitToConstInput { lit: &lit.node, ty: node.ty, neg }) {
Ok(c) => c, Ok(c) => c,
Err(LitToConstError::Reported(guar)) => ty::Const::new_error(tcx, guar, node.ty), Err(LitToConstError::Reported(guar)) => ty::Const::new_error(tcx, guar),
Err(LitToConstError::TypeError) => { Err(LitToConstError::TypeError) => {
bug!("encountered type error in lit_to_const") bug!("encountered type error in lit_to_const")
} }
@ -137,35 +140,31 @@ fn recurse_build<'tcx>(
} }
&ExprKind::NamedConst { def_id, args, user_ty: _ } => { &ExprKind::NamedConst { def_id, args, user_ty: _ } => {
let uneval = ty::UnevaluatedConst::new(def_id, args); let uneval = ty::UnevaluatedConst::new(def_id, args);
ty::Const::new_unevaluated(tcx, uneval, node.ty) ty::Const::new_unevaluated(tcx, uneval)
} }
ExprKind::ConstParam { param, .. } => ty::Const::new_param(tcx, *param, node.ty), ExprKind::ConstParam { param, .. } => ty::Const::new_param(tcx, *param),
ExprKind::Call { fun, args, .. } => { ExprKind::Call { fun, args, .. } => {
let fun_ty = body.exprs[*fun].ty;
let fun = recurse_build(tcx, body, *fun, root_span)?; let fun = recurse_build(tcx, body, *fun, root_span)?;
let mut new_args = Vec::<ty::Const<'tcx>>::with_capacity(args.len()); let mut new_args = Vec::<ty::Const<'tcx>>::with_capacity(args.len());
for &id in args.iter() { for &id in args.iter() {
new_args.push(recurse_build(tcx, body, id, root_span)?); new_args.push(recurse_build(tcx, body, id, root_span)?);
} }
ty::Const::new_expr( ty::Const::new_expr(tcx, Expr::new_call(tcx, fun_ty, fun, new_args.into_iter()))
tcx,
Expr::new_call(tcx, fun.ty(), fun, new_args.into_iter()),
node.ty,
)
} }
&ExprKind::Binary { op, lhs, rhs } if check_binop(op) => { &ExprKind::Binary { op, lhs, rhs } if check_binop(op) => {
let lhs_ty = body.exprs[lhs].ty;
let lhs = recurse_build(tcx, body, lhs, root_span)?; let lhs = recurse_build(tcx, body, lhs, root_span)?;
let rhs_ty = body.exprs[rhs].ty;
let rhs = recurse_build(tcx, body, rhs, root_span)?; let rhs = recurse_build(tcx, body, rhs, root_span)?;
ty::Const::new_expr( ty::Const::new_expr(tcx, Expr::new_binop(tcx, op, lhs_ty, rhs_ty, lhs, rhs))
tcx,
Expr::new_binop(tcx, op, lhs.ty(), rhs.ty(), lhs, rhs),
node.ty,
)
} }
&ExprKind::Unary { op, arg } if check_unop(op) => { &ExprKind::Unary { op, arg } if check_unop(op) => {
let arg_ty = body.exprs[arg].ty;
let arg = recurse_build(tcx, body, arg, root_span)?; let arg = recurse_build(tcx, body, arg, root_span)?;
ty::Const::new_expr(tcx, Expr::new_unop(tcx, op, arg.ty(), arg), node.ty) ty::Const::new_expr(tcx, Expr::new_unop(tcx, op, arg_ty, arg))
} }
// This is necessary so that the following compiles: // This is necessary so that the following compiles:
// //
@ -187,20 +186,12 @@ fn recurse_build<'tcx>(
&ExprKind::Use { source } => { &ExprKind::Use { source } => {
let value_ty = body.exprs[source].ty; let value_ty = body.exprs[source].ty;
let value = recurse_build(tcx, body, source, root_span)?; let value = recurse_build(tcx, body, source, root_span)?;
ty::Const::new_expr( ty::Const::new_expr(tcx, Expr::new_cast(tcx, CastKind::Use, value_ty, value, node.ty))
tcx,
Expr::new_cast(tcx, CastKind::Use, value_ty, value, node.ty),
node.ty,
)
} }
&ExprKind::Cast { source } => { &ExprKind::Cast { source } => {
let value_ty = body.exprs[source].ty; let value_ty = body.exprs[source].ty;
let value = recurse_build(tcx, body, source, root_span)?; let value = recurse_build(tcx, body, source, root_span)?;
ty::Const::new_expr( ty::Const::new_expr(tcx, Expr::new_cast(tcx, CastKind::As, value_ty, value, node.ty))
tcx,
Expr::new_cast(tcx, CastKind::As, value_ty, value, node.ty),
node.ty,
)
} }
ExprKind::Borrow { arg, .. } => { ExprKind::Borrow { arg, .. } => {
let arg_node = &body.exprs[*arg]; let arg_node = &body.exprs[*arg];

55
compiler/rustc_type_ir/src/canonical.rs
View file

@ -115,8 +115,8 @@ impl<I: Interner> CanonicalVarInfo<I> {
CanonicalVarKind::PlaceholderTy(_) => false, CanonicalVarKind::PlaceholderTy(_) => false,
CanonicalVarKind::Region(_) => true, CanonicalVarKind::Region(_) => true,
CanonicalVarKind::PlaceholderRegion(..) => false, CanonicalVarKind::PlaceholderRegion(..) => false,
CanonicalVarKind::Const(..) => true, CanonicalVarKind::Const(_) => true,
CanonicalVarKind::PlaceholderConst(_, _) => false, CanonicalVarKind::PlaceholderConst(_) => false,
CanonicalVarKind::Effect => true, CanonicalVarKind::Effect => true,
} }
} }
@ -126,8 +126,8 @@ impl<I: Interner> CanonicalVarInfo<I> {
CanonicalVarKind::Region(_) | CanonicalVarKind::PlaceholderRegion(_) => true, CanonicalVarKind::Region(_) | CanonicalVarKind::PlaceholderRegion(_) => true,
CanonicalVarKind::Ty(_) CanonicalVarKind::Ty(_)
| CanonicalVarKind::PlaceholderTy(_) | CanonicalVarKind::PlaceholderTy(_)
| CanonicalVarKind::Const(_, _) | CanonicalVarKind::Const(_)
| CanonicalVarKind::PlaceholderConst(_, _) | CanonicalVarKind::PlaceholderConst(_)
| CanonicalVarKind::Effect => false, | CanonicalVarKind::Effect => false,
} }
} }
@ -136,12 +136,12 @@ impl<I: Interner> CanonicalVarInfo<I> {
match self.kind { match self.kind {
CanonicalVarKind::Ty(_) CanonicalVarKind::Ty(_)
| CanonicalVarKind::Region(_) | CanonicalVarKind::Region(_)
| CanonicalVarKind::Const(_, _) | CanonicalVarKind::Const(_)
| CanonicalVarKind::Effect => panic!("expected placeholder: {self:?}"), | CanonicalVarKind::Effect => panic!("expected placeholder: {self:?}"),
CanonicalVarKind::PlaceholderRegion(placeholder) => placeholder.var().as_usize(), CanonicalVarKind::PlaceholderRegion(placeholder) => placeholder.var().as_usize(),
CanonicalVarKind::PlaceholderTy(placeholder) => placeholder.var().as_usize(), CanonicalVarKind::PlaceholderTy(placeholder) => placeholder.var().as_usize(),
CanonicalVarKind::PlaceholderConst(placeholder, _) => placeholder.var().as_usize(), CanonicalVarKind::PlaceholderConst(placeholder) => placeholder.var().as_usize(),
} }
} }
} }
@ -169,13 +169,13 @@ pub enum CanonicalVarKind<I: Interner> {
PlaceholderRegion(I::PlaceholderRegion), PlaceholderRegion(I::PlaceholderRegion),
/// Some kind of const inference variable. /// Some kind of const inference variable.
Const(UniverseIndex, I::Ty), Const(UniverseIndex),
/// Effect variable `'?E`. /// Effect variable `'?E`.
Effect, Effect,
/// A "placeholder" that represents "any const". /// A "placeholder" that represents "any const".
PlaceholderConst(I::PlaceholderConst, I::Ty), PlaceholderConst(I::PlaceholderConst),
} }
impl<I: Interner> PartialEq for CanonicalVarKind<I> { impl<I: Interner> PartialEq for CanonicalVarKind<I> {
@ -185,10 +185,8 @@ impl<I: Interner> PartialEq for CanonicalVarKind<I> {
(Self::PlaceholderTy(l0), Self::PlaceholderTy(r0)) => l0 == r0, (Self::PlaceholderTy(l0), Self::PlaceholderTy(r0)) => l0 == r0,
(Self::Region(l0), Self::Region(r0)) => l0 == r0, (Self::Region(l0), Self::Region(r0)) => l0 == r0,
(Self::PlaceholderRegion(l0), Self::PlaceholderRegion(r0)) => l0 == r0, (Self::PlaceholderRegion(l0), Self::PlaceholderRegion(r0)) => l0 == r0,
(Self::Const(l0, l1), Self::Const(r0, r1)) => l0 == r0 && l1 == r1, (Self::Const(l0), Self::Const(r0)) => l0 == r0,
(Self::PlaceholderConst(l0, l1), Self::PlaceholderConst(r0, r1)) => { (Self::PlaceholderConst(l0), Self::PlaceholderConst(r0)) => l0 == r0,
l0 == r0 && l1 == r1
}
_ => std::mem::discriminant(self) == std::mem::discriminant(other), _ => std::mem::discriminant(self) == std::mem::discriminant(other),
} }
} }
@ -199,10 +197,10 @@ impl<I: Interner> CanonicalVarKind<I> {
match self { match self {
CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui)) => ui, CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui)) => ui,
CanonicalVarKind::Region(ui) => ui, CanonicalVarKind::Region(ui) => ui,
CanonicalVarKind::Const(ui, _) => ui, CanonicalVarKind::Const(ui) => ui,
CanonicalVarKind::PlaceholderTy(placeholder) => placeholder.universe(), CanonicalVarKind::PlaceholderTy(placeholder) => placeholder.universe(),
CanonicalVarKind::PlaceholderRegion(placeholder) => placeholder.universe(), CanonicalVarKind::PlaceholderRegion(placeholder) => placeholder.universe(),
CanonicalVarKind::PlaceholderConst(placeholder, _) => placeholder.universe(), CanonicalVarKind::PlaceholderConst(placeholder) => placeholder.universe(),
CanonicalVarKind::Ty(CanonicalTyVarKind::Float | CanonicalTyVarKind::Int) => { CanonicalVarKind::Ty(CanonicalTyVarKind::Float | CanonicalTyVarKind::Int) => {
UniverseIndex::ROOT UniverseIndex::ROOT
} }
@ -220,7 +218,7 @@ impl<I: Interner> CanonicalVarKind<I> {
CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui)) CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui))
} }
CanonicalVarKind::Region(_) => CanonicalVarKind::Region(ui), CanonicalVarKind::Region(_) => CanonicalVarKind::Region(ui),
CanonicalVarKind::Const(_, ty) => CanonicalVarKind::Const(ui, ty), CanonicalVarKind::Const(_) => CanonicalVarKind::Const(ui),
CanonicalVarKind::PlaceholderTy(placeholder) => { CanonicalVarKind::PlaceholderTy(placeholder) => {
CanonicalVarKind::PlaceholderTy(placeholder.with_updated_universe(ui)) CanonicalVarKind::PlaceholderTy(placeholder.with_updated_universe(ui))
@ -228,8 +226,8 @@ impl<I: Interner> CanonicalVarKind<I> {
CanonicalVarKind::PlaceholderRegion(placeholder) => { CanonicalVarKind::PlaceholderRegion(placeholder) => {
CanonicalVarKind::PlaceholderRegion(placeholder.with_updated_universe(ui)) CanonicalVarKind::PlaceholderRegion(placeholder.with_updated_universe(ui))
} }
CanonicalVarKind::PlaceholderConst(placeholder, ty) => { CanonicalVarKind::PlaceholderConst(placeholder) => {
CanonicalVarKind::PlaceholderConst(placeholder.with_updated_universe(ui), ty) CanonicalVarKind::PlaceholderConst(placeholder.with_updated_universe(ui))
} }
CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float)
| CanonicalVarKind::Effect => { | CanonicalVarKind::Effect => {
@ -345,21 +343,14 @@ impl<I: Interner> CanonicalVarValues<I> {
Region::new_anon_bound(tcx, ty::INNERMOST, ty::BoundVar::from_usize(i)) Region::new_anon_bound(tcx, ty::INNERMOST, ty::BoundVar::from_usize(i))
.into() .into()
} }
CanonicalVarKind::Effect => Const::new_anon_bound( CanonicalVarKind::Effect => {
tcx, Const::new_anon_bound(tcx, ty::INNERMOST, ty::BoundVar::from_usize(i))
ty::INNERMOST, .into()
ty::BoundVar::from_usize(i), }
Ty::new_bool(tcx), CanonicalVarKind::Const(_) | CanonicalVarKind::PlaceholderConst(_) => {
) Const::new_anon_bound(tcx, ty::INNERMOST, ty::BoundVar::from_usize(i))
.into(), .into()
CanonicalVarKind::Const(_, ty) }
| CanonicalVarKind::PlaceholderConst(_, ty) => Const::new_anon_bound(
tcx,
ty::INNERMOST,
ty::BoundVar::from_usize(i),
ty,
)
.into(),
} }
}, },
)), )),

4
compiler/rustc_type_ir/src/debug.rs
View file

@ -38,11 +38,11 @@ impl<I: Interner> InferCtxtLike for NoInfcx<I> {
panic!("cannot resolve {vid:?}") panic!("cannot resolve {vid:?}")
} }
fn opportunistic_resolve_ct_var(&self, vid: ConstVid, _: I::Ty) -> I::Const { fn opportunistic_resolve_ct_var(&self, vid: ConstVid) -> I::Const {
panic!("cannot resolve {vid:?}") panic!("cannot resolve {vid:?}")
} }
fn opportunistic_resolve_effect_var(&self, vid: EffectVid, _: I::Ty) -> I::Const { fn opportunistic_resolve_effect_var(&self, vid: EffectVid) -> I::Const {
panic!("cannot resolve {vid:?}") panic!("cannot resolve {vid:?}")
} }

2
compiler/rustc_type_ir/src/fold.rs
View file

@ -387,7 +387,7 @@ impl<I: Interner> TypeFolder<I> for Shifter<I> {
match ct.kind() { match ct.kind() {
ty::ConstKind::Bound(debruijn, bound_ct) if debruijn >= self.current_index => { ty::ConstKind::Bound(debruijn, bound_ct) if debruijn >= self.current_index => {
let debruijn = debruijn.shifted_in(self.amount); let debruijn = debruijn.shifted_in(self.amount);
Const::new_bound(self.tcx, debruijn, bound_ct, ct.ty()) Const::new_bound(self.tcx, debruijn, bound_ct)
} }
_ => ct.super_fold_with(self), _ => ct.super_fold_with(self),
} }

7
compiler/rustc_type_ir/src/infcx.rs
View file

@ -12,15 +12,10 @@ pub trait InferCtxtLike {
fn opportunistic_resolve_ty_var(&self, vid: TyVid) -> <Self::Interner as Interner>::Ty; fn opportunistic_resolve_ty_var(&self, vid: TyVid) -> <Self::Interner as Interner>::Ty;
fn opportunistic_resolve_int_var(&self, vid: IntVid) -> <Self::Interner as Interner>::Ty; fn opportunistic_resolve_int_var(&self, vid: IntVid) -> <Self::Interner as Interner>::Ty;
fn opportunistic_resolve_float_var(&self, vid: FloatVid) -> <Self::Interner as Interner>::Ty; fn opportunistic_resolve_float_var(&self, vid: FloatVid) -> <Self::Interner as Interner>::Ty;
fn opportunistic_resolve_ct_var( fn opportunistic_resolve_ct_var(&self, vid: ConstVid) -> <Self::Interner as Interner>::Const;
&self,
vid: ConstVid,
ty: <Self::Interner as Interner>::Ty,
) -> <Self::Interner as Interner>::Const;
fn opportunistic_resolve_effect_var( fn opportunistic_resolve_effect_var(
&self, &self,
vid: EffectVid, vid: EffectVid,
ty: <Self::Interner as Interner>::Ty,
) -> <Self::Interner as Interner>::Const; ) -> <Self::Interner as Interner>::Const;
fn opportunistic_resolve_lt_var(&self, vid: RegionVid) -> <Self::Interner as Interner>::Region; fn opportunistic_resolve_lt_var(&self, vid: RegionVid) -> <Self::Interner as Interner>::Region;

17
compiler/rustc_type_ir/src/inherent.rs
View file

@ -104,22 +104,15 @@ pub trait Const<I: Interner<Const = Self>>:
+ TypeSuperFoldable<I> + TypeSuperFoldable<I>
+ Flags + Flags
{ {
fn new_infer(interner: I, var: ty::InferConst, ty: I::Ty) -> Self; fn new_infer(interner: I, var: ty::InferConst) -> Self;
fn new_var(interner: I, var: ty::ConstVid, ty: I::Ty) -> Self; fn new_var(interner: I, var: ty::ConstVid) -> Self;
fn new_bound(interner: I, debruijn: ty::DebruijnIndex, var: I::BoundConst, ty: I::Ty) -> Self; fn new_bound(interner: I, debruijn: ty::DebruijnIndex, var: I::BoundConst) -> Self;
fn new_anon_bound( fn new_anon_bound(interner: I, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self;
interner: I,
debruijn: ty::DebruijnIndex,
var: ty::BoundVar,
ty: I::Ty,
) -> Self;
fn new_unevaluated(interner: I, uv: ty::UnevaluatedConst<I>, ty: I::Ty) -> Self; fn new_unevaluated(interner: I, uv: ty::UnevaluatedConst<I>) -> Self;
fn ty(self) -> I::Ty;
} }
pub trait GenericsOf<I: Interner<GenericsOf = Self>> { pub trait GenericsOf<I: Interner<GenericsOf = Self>> {

1
compiler/rustc_type_ir/src/predicate.rs
View file

@ -567,7 +567,6 @@ impl<I: Interner> AliasTerm<I> {
I::Const::new_unevaluated( I::Const::new_unevaluated(
interner, interner,
ty::UnevaluatedConst::new(self.def_id, self.args), ty::UnevaluatedConst::new(self.def_id, self.args),
interner.type_of(self.def_id).instantiate(interner, &self.args),
) )
.into() .into()
} }