mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Simplify confusing ResolvedArg constructors

Browse source
This commit is contained in:
Michael Goulet 2024-10-22 19:57:58 +00:00
parent 916e9ced40
commit 0b52ec3d7e
1 changed files with 46 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

103
compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
View file

@ -33,18 +33,12 @@ use crate::errors;
#[extension(trait RegionExt)] #[extension(trait RegionExt)]
impl ResolvedArg { impl ResolvedArg {
fn early(param: &GenericParam<'_>) -> (LocalDefId, ResolvedArg) { fn early(param: &GenericParam<'_>) -> ResolvedArg {
debug!("ResolvedArg::early: def_id={:?}", param.def_id); ResolvedArg::EarlyBound(param.def_id)
(param.def_id, ResolvedArg::EarlyBound(param.def_id))
} }
fn late(idx: u32, param: &GenericParam<'_>) -> (LocalDefId, ResolvedArg) { fn late(idx: u32, param: &GenericParam<'_>) -> ResolvedArg {
let depth = ty::INNERMOST; ResolvedArg::LateBound(ty::INNERMOST, idx, param.def_id)
debug!(
"ResolvedArg::late: idx={:?}, param={:?} depth={:?} def_id={:?}",
idx, param, depth, param.def_id,
);
(param.def_id, ResolvedArg::LateBound(depth, idx, param.def_id))
} }
fn id(&self) -> Option<LocalDefId> { fn id(&self) -> Option<LocalDefId> {
@ -282,24 +276,18 @@ fn resolve_bound_vars(tcx: TyCtxt<'_>, local_def_id: hir::OwnerId) -> ResolveBou
fn late_arg_as_bound_arg<'tcx>( fn late_arg_as_bound_arg<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
arg: &ResolvedArg,
param: &GenericParam<'tcx>, param: &GenericParam<'tcx>,
) -> ty::BoundVariableKind { ) -> ty::BoundVariableKind {
match arg { let def_id = param.def_id.to_def_id();
ResolvedArg::LateBound(_, _, def_id) => { let name = tcx.item_name(def_id);
let def_id = def_id.to_def_id(); match param.kind {
let name = tcx.item_name(def_id); GenericParamKind::Lifetime { .. } => {
match param.kind { ty::BoundVariableKind::Region(ty::BrNamed(def_id, name))
GenericParamKind::Lifetime { .. } => {
ty::BoundVariableKind::Region(ty::BrNamed(def_id, name))
}
GenericParamKind::Type { .. } => {
ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id, name))
}
GenericParamKind::Const { .. } => ty::BoundVariableKind::Const,
}
} }
_ => bug!("{:?} is not a late argument", arg), GenericParamKind::Type { .. } => {
ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id, name))
}
GenericParamKind::Const { .. } => ty::BoundVariableKind::Const,
} }
} }
@ -360,10 +348,9 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
let mut bound_vars: FxIndexMap<LocalDefId, ResolvedArg> = FxIndexMap::default(); let mut bound_vars: FxIndexMap<LocalDefId, ResolvedArg> = FxIndexMap::default();
let binders_iter = let binders_iter =
trait_ref.bound_generic_params.iter().enumerate().map(|(late_bound_idx, param)| { trait_ref.bound_generic_params.iter().enumerate().map(|(late_bound_idx, param)| {
let pair = ResolvedArg::late(initial_bound_vars + late_bound_idx as u32, param); let arg = ResolvedArg::late(initial_bound_vars + late_bound_idx as u32, param);
let r = late_arg_as_bound_arg(self.tcx, &pair.1, param); bound_vars.insert(param.def_id, arg);
bound_vars.insert(pair.0, pair.1); late_arg_as_bound_arg(self.tcx, param)
r
}); });
binders.extend(binders_iter); binders.extend(binders_iter);
@ -458,9 +445,10 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
.iter() .iter()
.enumerate() .enumerate()
.map(|(late_bound_idx, param)| { .map(|(late_bound_idx, param)| {
let pair = ResolvedArg::late(late_bound_idx as u32, param); (
let r = late_arg_as_bound_arg(self.tcx, &pair.1, param); (param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),
(pair, r) late_arg_as_bound_arg(self.tcx, param),
)
}) })
.unzip(); .unzip();
@ -492,8 +480,8 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
let mut bound_vars = FxIndexMap::default(); let mut bound_vars = FxIndexMap::default();
debug!(?opaque.generics.params); debug!(?opaque.generics.params);
for param in opaque.generics.params { for param in opaque.generics.params {
let (def_id, reg) = ResolvedArg::early(param); let arg = ResolvedArg::early(param);
bound_vars.insert(def_id, reg); bound_vars.insert(param.def_id, arg);
} }
let hir_id = self.tcx.local_def_id_to_hir_id(opaque.def_id); let hir_id = self.tcx.local_def_id_to_hir_id(opaque.def_id);
@ -618,9 +606,10 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
.iter() .iter()
.enumerate() .enumerate()
.map(|(late_bound_idx, param)| { .map(|(late_bound_idx, param)| {
let pair = ResolvedArg::late(late_bound_idx as u32, param); (
let r = late_arg_as_bound_arg(self.tcx, &pair.1, param); (param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),
(pair, r) late_arg_as_bound_arg(self.tcx, param),
)
}) })
.unzip(); .unzip();
@ -870,9 +859,10 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
.iter() .iter()
.enumerate() .enumerate()
.map(|(late_bound_idx, param)| { .map(|(late_bound_idx, param)| {
let pair = ResolvedArg::late(late_bound_idx as u32, param); (
let r = late_arg_as_bound_arg(self.tcx, &pair.1, param); (param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),
(pair, r) late_arg_as_bound_arg(self.tcx, param),
)
}) })
.unzip(); .unzip();
@ -1052,19 +1042,21 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
let bound_vars: FxIndexMap<LocalDefId, ResolvedArg> = generics let bound_vars: FxIndexMap<LocalDefId, ResolvedArg> = generics
.params .params
.iter() .iter()
.map(|param| match param.kind { .map(|param| {
GenericParamKind::Lifetime { .. } => { (param.def_id, match param.kind {
if self.tcx.is_late_bound(param.hir_id) { GenericParamKind::Lifetime { .. } => {
let late_bound_idx = named_late_bound_vars; if self.tcx.is_late_bound(param.hir_id) {
named_late_bound_vars += 1; let late_bound_idx = named_late_bound_vars;
ResolvedArg::late(late_bound_idx, param) named_late_bound_vars += 1;
} else { ResolvedArg::late(late_bound_idx, param)
} else {
ResolvedArg::early(param)
}
}
GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => {
ResolvedArg::early(param) ResolvedArg::early(param)
} }
} })
GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => {
ResolvedArg::early(param)
}
}) })
.collect(); .collect();
@ -1075,11 +1067,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
matches!(param.kind, GenericParamKind::Lifetime { .. }) matches!(param.kind, GenericParamKind::Lifetime { .. })
&& self.tcx.is_late_bound(param.hir_id) && self.tcx.is_late_bound(param.hir_id)
}) })
.enumerate() .map(|param| late_arg_as_bound_arg(self.tcx, param))
.map(|(late_bound_idx, param)| {
let pair = ResolvedArg::late(late_bound_idx as u32, param);
late_arg_as_bound_arg(self.tcx, &pair.1, param)
})
.collect(); .collect();
self.record_late_bound_vars(hir_id, binders); self.record_late_bound_vars(hir_id, binders);
let scope = Scope::Binder { let scope = Scope::Binder {
@ -1096,7 +1084,8 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
where where
F: for<'b, 'c> FnOnce(&'b mut BoundVarContext<'c, 'tcx>), F: for<'b, 'c> FnOnce(&'b mut BoundVarContext<'c, 'tcx>),
{ {
let bound_vars = generics.params.iter().map(ResolvedArg::early).collect(); let bound_vars =
generics.params.iter().map(|param| (param.def_id, ResolvedArg::early(param))).collect();
self.record_late_bound_vars(hir_id, vec![]); self.record_late_bound_vars(hir_id, vec![]);
let scope = Scope::Binder { let scope = Scope::Binder {
hir_id, hir_id,