mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Store a LocalDefId in hir::GenericParam.

Browse Source
This commit is contained in:
Camille GILLOT 2022-11-06 18:26:36 +00:00
parent e82c08f58e
commit 18482f7b23
19 changed files with 67 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
compiler/rustc_ast_lowering/src/lib.rs
View File

@ -830,8 +830,10 @@ fn lifetime_res_to_generic_param(
), ),
}; };
let hir_id = self.lower_node_id(node_id); let hir_id = self.lower_node_id(node_id);
let def_id = self.local_def_id(node_id);
Some(hir::GenericParam { Some(hir::GenericParam {
hir_id, hir_id,
def_id,
name, name,
span: self.lower_span(ident.span), span: self.lower_span(ident.span),
pure_wrt_drop: false, pure_wrt_drop: false,
@ -1521,6 +1523,7 @@ fn lower_opaque_impl_trait(
hir::GenericParam { hir::GenericParam {
hir_id, hir_id,
def_id: lctx.local_def_id(new_node_id),
name, name,
span: lifetime.ident.span, span: lifetime.ident.span,
pure_wrt_drop: false, pure_wrt_drop: false,
@ -1978,6 +1981,7 @@ fn lower_async_fn_ret_ty(
hir::GenericParam { hir::GenericParam {
hir_id, hir_id,
def_id: this.local_def_id(new_node_id),
name, name,
span: lifetime.ident.span, span: lifetime.ident.span,
pure_wrt_drop: false, pure_wrt_drop: false,
@ -2176,6 +2180,7 @@ fn lower_generic_param(&mut self, param: &GenericParam) -> hir::GenericParam<'hi
self.lower_attrs(hir_id, &param.attrs); self.lower_attrs(hir_id, &param.attrs);
hir::GenericParam { hir::GenericParam {
hir_id, hir_id,
def_id: self.local_def_id(param.id),
name, name,
span: self.lower_span(param.span()), span: self.lower_span(param.span()),
pure_wrt_drop: self.tcx.sess.contains_name(&param.attrs, sym::may_dangle), pure_wrt_drop: self.tcx.sess.contains_name(&param.attrs, sym::may_dangle),
@ -2280,6 +2285,7 @@ fn lower_generic_and_bounds(
// Set the name to `impl Bound1 + Bound2`. // Set the name to `impl Bound1 + Bound2`.
let param = hir::GenericParam { let param = hir::GenericParam {
hir_id: self.lower_node_id(node_id), hir_id: self.lower_node_id(node_id),
def_id,
name: ParamName::Plain(self.lower_ident(ident)), name: ParamName::Plain(self.lower_ident(ident)),
pure_wrt_drop: false, pure_wrt_drop: false,
span: self.lower_span(span), span: self.lower_span(span),

3
compiler/rustc_hir/src/hir.rs
View File

@ -487,6 +487,7 @@ pub enum GenericParamKind<'hir> {
#[derive(Debug, HashStable_Generic)] #[derive(Debug, HashStable_Generic)]
pub struct GenericParam<'hir> { pub struct GenericParam<'hir> {
pub hir_id: HirId, pub hir_id: HirId,
pub def_id: LocalDefId,
pub name: ParamName, pub name: ParamName,
pub span: Span, pub span: Span,
pub pure_wrt_drop: bool, pub pure_wrt_drop: bool,
@ -1628,7 +1629,7 @@ pub fn hir_id(&self) -> HirId {
/// explicit discriminant values for enum variants. /// explicit discriminant values for enum variants.
/// ///
/// You can check if this anon const is a default in a const param /// You can check if this anon const is a default in a const param
/// `const N: usize = { ... }` with `tcx.hir().opt_const_param_default_param_hir_id(..)` /// `const N: usize = { ... }` with `tcx.hir().opt_const_param_default_param_def_id(..)`
#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStable_Generic)] #[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStable_Generic)]
pub struct AnonConst { pub struct AnonConst {
pub hir_id: HirId, pub hir_id: HirId,

5
compiler/rustc_hir_analysis/src/astconv/mod.rs
View File

@ -856,7 +856,7 @@ pub(crate) fn add_implicitly_sized<'hir>(
&self, &self,
bounds: &mut Bounds<'hir>, bounds: &mut Bounds<'hir>,
ast_bounds: &'hir [hir::GenericBound<'hir>], ast_bounds: &'hir [hir::GenericBound<'hir>],
self_ty_where_predicates: Option<(hir::HirId, &'hir [hir::WherePredicate<'hir>])>, self_ty_where_predicates: Option<(LocalDefId, &'hir [hir::WherePredicate<'hir>])>,
span: Span, span: Span,
) { ) {
let tcx = self.tcx(); let tcx = self.tcx();
@ -876,10 +876,9 @@ pub(crate) fn add_implicitly_sized<'hir>(
}; };
search_bounds(ast_bounds); search_bounds(ast_bounds);
if let Some((self_ty, where_clause)) = self_ty_where_predicates { if let Some((self_ty, where_clause)) = self_ty_where_predicates {
let self_ty_def_id = tcx.hir().local_def_id(self_ty).to_def_id();
for clause in where_clause { for clause in where_clause {
if let hir::WherePredicate::BoundPredicate(pred) = clause { if let hir::WherePredicate::BoundPredicate(pred) = clause {
if pred.is_param_bound(self_ty_def_id) { if pred.is_param_bound(self_ty.to_def_id()) {
search_bounds(pred.bounds); search_bounds(pred.bounds);
} }
} }

2
compiler/rustc_hir_analysis/src/check/wfcheck.rs
View File

@ -853,7 +853,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) {
// Const parameters are well formed if their type is structural match. // Const parameters are well formed if their type is structural match.
hir::GenericParamKind::Const { ty: hir_ty, default: _ } => { hir::GenericParamKind::Const { ty: hir_ty, default: _ } => {
let ty = tcx.type_of(tcx.hir().local_def_id(param.hir_id)); let ty = tcx.type_of(param.def_id);
if tcx.features().adt_const_params { if tcx.features().adt_const_params {
if let Some(non_structural_match_ty) = if let Some(non_structural_match_ty) =

8
compiler/rustc_hir_analysis/src/collect.rs
View File

@ -291,18 +291,16 @@ fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) {
match param.kind { match param.kind {
hir::GenericParamKind::Lifetime { .. } => {} hir::GenericParamKind::Lifetime { .. } => {}
hir::GenericParamKind::Type { default: Some(_), .. } => { hir::GenericParamKind::Type { default: Some(_), .. } => {
let def_id = self.tcx.hir().local_def_id(param.hir_id); self.tcx.ensure().type_of(param.def_id);
self.tcx.ensure().type_of(def_id);
} }
hir::GenericParamKind::Type { .. } => {} hir::GenericParamKind::Type { .. } => {}
hir::GenericParamKind::Const { default, .. } => { hir::GenericParamKind::Const { default, .. } => {
let def_id = self.tcx.hir().local_def_id(param.hir_id); self.tcx.ensure().type_of(param.def_id);
self.tcx.ensure().type_of(def_id);
if let Some(default) = default { if let Some(default) = default {
let default_def_id = self.tcx.hir().local_def_id(default.hir_id); let default_def_id = self.tcx.hir().local_def_id(default.hir_id);
// need to store default and type of default // need to store default and type of default
self.tcx.ensure().type_of(default_def_id); self.tcx.ensure().type_of(default_def_id);
self.tcx.ensure().const_param_default(def_id); self.tcx.ensure().const_param_default(param.def_id);
} }
} }
} }

11
compiler/rustc_hir_analysis/src/collect/generics_of.rs
View File

@ -51,7 +51,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
// of a const parameter type, e.g. `struct Foo<const N: usize, const M: [u8; N]>` is not allowed. // of a const parameter type, e.g. `struct Foo<const N: usize, const M: [u8; N]>` is not allowed.
None None
} else if tcx.lazy_normalization() { } else if tcx.lazy_normalization() {
if let Some(param_id) = tcx.hir().opt_const_param_default_param_hir_id(hir_id) { if let Some(param_id) = tcx.hir().opt_const_param_default_param_def_id(hir_id) {
// If the def_id we are calling generics_of on is an anon ct default i.e: // If the def_id we are calling generics_of on is an anon ct default i.e:
// //
// struct Foo<const N: usize = { .. }>; // struct Foo<const N: usize = { .. }>;
@ -77,8 +77,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
// This has some implications for how we get the predicates available to the anon const // This has some implications for how we get the predicates available to the anon const
// see `explicit_predicates_of` for more information on this // see `explicit_predicates_of` for more information on this
let generics = tcx.generics_of(parent_def_id.to_def_id()); let generics = tcx.generics_of(parent_def_id.to_def_id());
let param_def = tcx.hir().local_def_id(param_id).to_def_id(); let param_def_idx = generics.param_def_id_to_index[&param_id.to_def_id()];
let param_def_idx = generics.param_def_id_to_index[&param_def];
// In the above example this would be .params[..N#0] // In the above example this would be .params[..N#0]
let params = generics.params[..param_def_idx as usize].to_owned(); let params = generics.params[..param_def_idx as usize].to_owned();
let param_def_id_to_index = let param_def_id_to_index =
@ -241,7 +240,7 @@ enum Defaults {
params.extend(early_lifetimes.enumerate().map(|(i, param)| ty::GenericParamDef { params.extend(early_lifetimes.enumerate().map(|(i, param)| ty::GenericParamDef {
name: param.name.ident().name, name: param.name.ident().name,
index: own_start + i as u32, index: own_start + i as u32,
def_id: tcx.hir().local_def_id(param.hir_id).to_def_id(), def_id: param.def_id.to_def_id(),
pure_wrt_drop: param.pure_wrt_drop, pure_wrt_drop: param.pure_wrt_drop,
kind: ty::GenericParamDefKind::Lifetime, kind: ty::GenericParamDefKind::Lifetime,
})); }));
@ -286,7 +285,7 @@ enum Defaults {
Some(ty::GenericParamDef { Some(ty::GenericParamDef {
index: next_index(), index: next_index(),
name: param.name.ident().name, name: param.name.ident().name,
def_id: tcx.hir().local_def_id(param.hir_id).to_def_id(), def_id: param.def_id.to_def_id(),
pure_wrt_drop: param.pure_wrt_drop, pure_wrt_drop: param.pure_wrt_drop,
kind, kind,
}) })
@ -303,7 +302,7 @@ enum Defaults {
Some(ty::GenericParamDef { Some(ty::GenericParamDef {
index: next_index(), index: next_index(),
name: param.name.ident().name, name: param.name.ident().name,
def_id: tcx.hir().local_def_id(param.hir_id).to_def_id(), def_id: param.def_id.to_def_id(),
pure_wrt_drop: param.pure_wrt_drop, pure_wrt_drop: param.pure_wrt_drop,
kind: ty::GenericParamDefKind::Const { has_default: default.is_some() }, kind: ty::GenericParamDefKind::Const { has_default: default.is_some() },
}) })

48
compiler/rustc_hir_analysis/src/collect/lifetimes.rs
View File

@ -15,7 +15,6 @@
use rustc_hir::intravisit::{self, Visitor}; use rustc_hir::intravisit::{self, Visitor};
use rustc_hir::{GenericArg, GenericParam, GenericParamKind, HirIdMap, LifetimeName, Node}; use rustc_hir::{GenericArg, GenericParam, GenericParamKind, HirIdMap, LifetimeName, Node};
use rustc_middle::bug; use rustc_middle::bug;
use rustc_middle::hir::map::Map;
use rustc_middle::hir::nested_filter; use rustc_middle::hir::nested_filter;
use rustc_middle::middle::resolve_lifetime::*; use rustc_middle::middle::resolve_lifetime::*;
use rustc_middle::ty::{self, DefIdTree, TyCtxt, TypeSuperVisitable, TypeVisitor}; use rustc_middle::ty::{self, DefIdTree, TyCtxt, TypeSuperVisitable, TypeVisitor};
@ -25,9 +24,9 @@
use std::fmt; use std::fmt;
trait RegionExt { trait RegionExt {
fn early(hir_map: Map<'_>, param: &GenericParam<'_>) -> (LocalDefId, Region); fn early(param: &GenericParam<'_>) -> (LocalDefId, Region);
fn late(index: u32, hir_map: Map<'_>, param: &GenericParam<'_>) -> (LocalDefId, Region); fn late(index: u32, param: &GenericParam<'_>) -> (LocalDefId, Region);
fn id(&self) -> Option<DefId>; fn id(&self) -> Option<DefId>;
@ -35,20 +34,18 @@ trait RegionExt {
} }
impl RegionExt for Region { impl RegionExt for Region {
fn early(hir_map: Map<'_>, param: &GenericParam<'_>) -> (LocalDefId, Region) { fn early(param: &GenericParam<'_>) -> (LocalDefId, Region) {
let def_id = hir_map.local_def_id(param.hir_id); debug!("Region::early: def_id={:?}", param.def_id);
debug!("Region::early: def_id={:?}", def_id); (param.def_id, Region::EarlyBound(param.def_id.to_def_id()))
(def_id, Region::EarlyBound(def_id.to_def_id()))
} }
fn late(idx: u32, hir_map: Map<'_>, param: &GenericParam<'_>) -> (LocalDefId, Region) { fn late(idx: u32, param: &GenericParam<'_>) -> (LocalDefId, Region) {
let depth = ty::INNERMOST; let depth = ty::INNERMOST;
let def_id = hir_map.local_def_id(param.hir_id);
debug!( debug!(
"Region::late: idx={:?}, param={:?} depth={:?} def_id={:?}", "Region::late: idx={:?}, param={:?} depth={:?} def_id={:?}",
idx, param, depth, def_id, idx, param, depth, param.def_id,
); );
(def_id, Region::LateBound(depth, idx, def_id.to_def_id())) (param.def_id, Region::LateBound(depth, idx, param.def_id.to_def_id()))
} }
fn id(&self) -> Option<DefId> { fn id(&self) -> Option<DefId> {
@ -395,7 +392,7 @@ fn visit_ty(&mut self, t: &'v hir::Ty<'v>) {
.filter(|param| matches!(param.kind, GenericParamKind::Lifetime { .. })) .filter(|param| matches!(param.kind, GenericParamKind::Lifetime { .. }))
.enumerate() .enumerate()
.map(|(late_bound_idx, param)| { .map(|(late_bound_idx, param)| {
let pair = Region::late(late_bound_idx as u32, self.tcx.hir(), param); let pair = Region::late(late_bound_idx as u32, param);
let r = late_region_as_bound_region(self.tcx, &pair.1); let r = late_region_as_bound_region(self.tcx, &pair.1);
(pair, r) (pair, r)
}) })
@ -492,7 +489,7 @@ fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
for param in generics.params { for param in generics.params {
match param.kind { match param.kind {
GenericParamKind::Lifetime { .. } => { GenericParamKind::Lifetime { .. } => {
let (def_id, reg) = Region::early(self.tcx.hir(), &param); let (def_id, reg) = Region::early(&param);
lifetimes.insert(def_id, reg); lifetimes.insert(def_id, reg);
} }
GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => {} GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => {}
@ -523,9 +520,7 @@ fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
.params .params
.iter() .iter()
.filter_map(|param| match param.kind { .filter_map(|param| match param.kind {
GenericParamKind::Lifetime { .. } => { GenericParamKind::Lifetime { .. } => Some(Region::early(param)),
Some(Region::early(self.tcx.hir(), param))
}
GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => None, GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => None,
}) })
.collect(); .collect();
@ -573,7 +568,7 @@ fn visit_ty(&mut self, ty: &'tcx hir::Ty<'tcx>) {
.filter(|param| matches!(param.kind, GenericParamKind::Lifetime { .. })) .filter(|param| matches!(param.kind, GenericParamKind::Lifetime { .. }))
.enumerate() .enumerate()
.map(|(late_bound_idx, param)| { .map(|(late_bound_idx, param)| {
let pair = Region::late(late_bound_idx as u32, self.tcx.hir(), param); let pair = Region::late(late_bound_idx as u32, param);
let r = late_region_as_bound_region(self.tcx, &pair.1); let r = late_region_as_bound_region(self.tcx, &pair.1);
(pair, r) (pair, r)
}) })
@ -731,9 +726,7 @@ fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) {
.params .params
.iter() .iter()
.filter_map(|param| match param.kind { .filter_map(|param| match param.kind {
GenericParamKind::Lifetime { .. } => { GenericParamKind::Lifetime { .. } => Some(Region::early(param)),
Some(Region::early(self.tcx.hir(), param))
}
GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => None, GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => None,
}) })
.collect(); .collect();
@ -779,9 +772,7 @@ fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) {
.params .params
.iter() .iter()
.filter_map(|param| match param.kind { .filter_map(|param| match param.kind {
GenericParamKind::Lifetime { .. } => { GenericParamKind::Lifetime { .. } => Some(Region::early(param)),
Some(Region::early(self.tcx.hir(), param))
}
GenericParamKind::Const { .. } | GenericParamKind::Type { .. } => None, GenericParamKind::Const { .. } | GenericParamKind::Type { .. } => None,
}) })
.collect(); .collect();
@ -886,7 +877,7 @@ fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) {
}) })
.enumerate() .enumerate()
.map(|(late_bound_idx, param)| { .map(|(late_bound_idx, param)| {
Region::late(late_bound_idx as u32, this.tcx.hir(), param) Region::late(late_bound_idx as u32, param)
}) })
.collect(); .collect();
let binders: Vec<_> = let binders: Vec<_> =
@ -999,8 +990,7 @@ fn visit_poly_trait_ref(&mut self, trait_ref: &'tcx hir::PolyTraitRef<'tcx>) {
.filter(|param| matches!(param.kind, GenericParamKind::Lifetime { .. })) .filter(|param| matches!(param.kind, GenericParamKind::Lifetime { .. }))
.enumerate() .enumerate()
.map(|(late_bound_idx, param)| { .map(|(late_bound_idx, param)| {
let pair = let pair = Region::late(initial_bound_vars + late_bound_idx as u32, param);
Region::late(initial_bound_vars + late_bound_idx as u32, self.tcx.hir(), param);
let r = late_region_as_bound_region(self.tcx, &pair.1); let r = late_region_as_bound_region(self.tcx, &pair.1);
lifetimes.insert(pair.0, pair.1); lifetimes.insert(pair.0, pair.1);
r r
@ -1131,9 +1121,9 @@ fn visit_early_late<F>(
if self.tcx.is_late_bound(param.hir_id) { if self.tcx.is_late_bound(param.hir_id) {
let late_bound_idx = named_late_bound_vars; let late_bound_idx = named_late_bound_vars;
named_late_bound_vars += 1; named_late_bound_vars += 1;
Some(Region::late(late_bound_idx, self.tcx.hir(), param)) Some(Region::late(late_bound_idx, param))
} else { } else {
Some(Region::early(self.tcx.hir(), param)) Some(Region::early(param))
} }
} }
GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => None, GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => None,
@ -1149,7 +1139,7 @@ fn visit_early_late<F>(
}) })
.enumerate() .enumerate()
.map(|(late_bound_idx, param)| { .map(|(late_bound_idx, param)| {
let pair = Region::late(late_bound_idx as u32, self.tcx.hir(), param); let pair = Region::late(late_bound_idx as u32, param);
late_region_as_bound_region(self.tcx, &pair.1) late_region_as_bound_region(self.tcx, &pair.1)
}) })
.collect(); .collect();

14
compiler/rustc_hir_analysis/src/collect/predicates_of.rs
View File

@ -199,7 +199,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
&icx, &icx,
&mut bounds, &mut bounds,
&[], &[],
Some((param.hir_id, ast_generics.predicates)), Some((param.def_id, ast_generics.predicates)),
param.span, param.span,
); );
trace!(?bounds); trace!(?bounds);
@ -429,7 +429,7 @@ pub(super) fn explicit_predicates_of<'tcx>(
let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
let parent_def_id = tcx.hir().get_parent_item(hir_id); let parent_def_id = tcx.hir().get_parent_item(hir_id);
if tcx.hir().opt_const_param_default_param_hir_id(hir_id).is_some() { if tcx.hir().opt_const_param_default_param_def_id(hir_id).is_some() {
// In `generics_of` we set the generics' parent to be our parent's parent which means that // In `generics_of` we set the generics' parent to be our parent's parent which means that
// we lose out on the predicates of our actual parent if we dont return those predicates here. // we lose out on the predicates of our actual parent if we dont return those predicates here.
// (See comment in `generics_of` for more information on why the parent shenanigans is necessary) // (See comment in `generics_of` for more information on why the parent shenanigans is necessary)
@ -531,7 +531,7 @@ pub(super) fn super_predicates_that_define_assoc_type(
let is_trait_alias = tcx.is_trait_alias(trait_def_id); let is_trait_alias = tcx.is_trait_alias(trait_def_id);
let superbounds2 = icx.type_parameter_bounds_in_generics( let superbounds2 = icx.type_parameter_bounds_in_generics(
generics, generics,
item.hir_id(), item.owner_id.def_id,
self_param_ty, self_param_ty,
OnlySelfBounds(!is_trait_alias), OnlySelfBounds(!is_trait_alias),
assoc_name, assoc_name,
@ -641,7 +641,7 @@ pub(super) fn type_param_predicates(
let extra_predicates = extend.into_iter().chain( let extra_predicates = extend.into_iter().chain(
icx.type_parameter_bounds_in_generics( icx.type_parameter_bounds_in_generics(
ast_generics, ast_generics,
param_id, def_id,
ty, ty,
OnlySelfBounds(true), OnlySelfBounds(true),
Some(assoc_name), Some(assoc_name),
@ -666,13 +666,11 @@ impl<'tcx> ItemCtxt<'tcx> {
fn type_parameter_bounds_in_generics( fn type_parameter_bounds_in_generics(
&self, &self,
ast_generics: &'tcx hir::Generics<'tcx>, ast_generics: &'tcx hir::Generics<'tcx>,
param_id: hir::HirId, param_def_id: LocalDefId,
ty: Ty<'tcx>, ty: Ty<'tcx>,
only_self_bounds: OnlySelfBounds, only_self_bounds: OnlySelfBounds,
assoc_name: Option<Ident>, assoc_name: Option<Ident>,
) -> Vec<(ty::Predicate<'tcx>, Span)> { ) -> Vec<(ty::Predicate<'tcx>, Span)> {
let param_def_id = self.tcx.hir().local_def_id(param_id).to_def_id();
trace!(?param_def_id);
ast_generics ast_generics
.predicates .predicates
.iter() .iter()
@ -681,7 +679,7 @@ fn type_parameter_bounds_in_generics(
_ => None, _ => None,
}) })
.flat_map(|bp| { .flat_map(|bp| {
let bt = if bp.is_param_bound(param_def_id) { let bt = if bp.is_param_bound(param_def_id.to_def_id()) {
Some(ty) Some(ty)
} else if !only_self_bounds.0 { } else if !only_self_bounds.0 {
Some(self.to_ty(bp.bounded_ty)) Some(self.to_ty(bp.bounded_ty))

4
compiler/rustc_hir_analysis/src/collect/type_of.rs
View File

@ -514,10 +514,10 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
} }
Node::GenericParam(&GenericParam { Node::GenericParam(&GenericParam {
hir_id: param_hir_id, def_id: param_def_id,
kind: GenericParamKind::Const { default: Some(ct), .. }, kind: GenericParamKind::Const { default: Some(ct), .. },
.. ..
}) if ct.hir_id == hir_id => tcx.type_of(tcx.hir().local_def_id(param_hir_id)), }) if ct.hir_id == hir_id => tcx.type_of(param_def_id),
x => tcx.ty_error_with_message( x => tcx.ty_error_with_message(
DUMMY_SP, DUMMY_SP,

2
compiler/rustc_hir_analysis/src/outlives/mod.rs
View File

@ -22,7 +22,7 @@ fn inferred_outlives_of(tcx: TyCtxt<'_>, item_def_id: DefId) -> &[(ty::Predicate
if matches!(tcx.def_kind(item_def_id), hir::def::DefKind::AnonConst) && tcx.lazy_normalization() if matches!(tcx.def_kind(item_def_id), hir::def::DefKind::AnonConst) && tcx.lazy_normalization()
{ {
if tcx.hir().opt_const_param_default_param_hir_id(id).is_some() { if tcx.hir().opt_const_param_default_param_def_id(id).is_some() {
// In `generics_of` we set the generics' parent to be our parent's parent which means that // In `generics_of` we set the generics' parent to be our parent's parent which means that
// we lose out on the predicates of our actual parent if we dont return those predicates here. // we lose out on the predicates of our actual parent if we dont return those predicates here.
// (See comment in `generics_of` for more information on why the parent shenanigans is necessary) // (See comment in `generics_of` for more information on why the parent shenanigans is necessary)

3
compiler/rustc_metadata/src/rmeta/encoder.rs
View File

@ -2101,11 +2101,10 @@ fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) {
impl<'a, 'tcx> EncodeContext<'a, 'tcx> { impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
fn encode_info_for_generics(&mut self, generics: &hir::Generics<'tcx>) { fn encode_info_for_generics(&mut self, generics: &hir::Generics<'tcx>) {
for param in generics.params { for param in generics.params {
let def_id = self.tcx.hir().local_def_id(param.hir_id);
match param.kind { match param.kind {
hir::GenericParamKind::Lifetime { .. } | hir::GenericParamKind::Type { .. } => {} hir::GenericParamKind::Lifetime { .. } | hir::GenericParamKind::Type { .. } => {}
hir::GenericParamKind::Const { ref default, .. } => { hir::GenericParamKind::Const { ref default, .. } => {
let def_id = def_id.to_def_id(); let def_id = param.def_id.to_def_id();
if default.is_some() { if default.is_some() {
record!(self.tables.const_param_default[def_id] <- self.tcx.const_param_default(def_id)) record!(self.tables.const_param_default[def_id] <- self.tcx.const_param_default(def_id))
} }

4
compiler/rustc_middle/src/hir/map/mod.rs
View File

@ -1086,10 +1086,10 @@ pub fn node_to_string(self, id: HirId) -> String {
/// Returns the HirId of `N` in `struct Foo<const N: usize = { ... }>` when /// Returns the HirId of `N` in `struct Foo<const N: usize = { ... }>` when
/// called with the HirId for the `{ ... }` anon const /// called with the HirId for the `{ ... }` anon const
pub fn opt_const_param_default_param_hir_id(self, anon_const: HirId) -> Option<HirId> { pub fn opt_const_param_default_param_def_id(self, anon_const: HirId) -> Option<LocalDefId> {
match self.get(self.get_parent_node(anon_const)) { match self.get(self.get_parent_node(anon_const)) {
Node::GenericParam(GenericParam { Node::GenericParam(GenericParam {
hir_id: param_id, def_id: param_id,
kind: GenericParamKind::Const { .. }, kind: GenericParamKind::Const { .. },
.. ..
}) => Some(*param_id), }) => Some(*param_id),

10
compiler/rustc_middle/src/mir/mod.rs
View File

@ -10,7 +10,7 @@
use crate::ty::fold::{FallibleTypeFolder, TypeFoldable}; use crate::ty::fold::{FallibleTypeFolder, TypeFoldable};
use crate::ty::print::{FmtPrinter, Printer}; use crate::ty::print::{FmtPrinter, Printer};
use crate::ty::visit::{TypeVisitable, TypeVisitor}; use crate::ty::visit::{TypeVisitable, TypeVisitor};
use crate::ty::{self, List, Ty, TyCtxt}; use crate::ty::{self, DefIdTree, List, Ty, TyCtxt};
use crate::ty::{AdtDef, InstanceDef, ScalarInt, UserTypeAnnotationIndex}; use crate::ty::{AdtDef, InstanceDef, ScalarInt, UserTypeAnnotationIndex};
use crate::ty::{GenericArg, InternalSubsts, SubstsRef}; use crate::ty::{GenericArg, InternalSubsts, SubstsRef};
@ -2470,12 +2470,10 @@ fn from_opt_const_arg_anon_const(
ExprKind::Path(QPath::Resolved(_, &Path { res: Res::Def(ConstParam, def_id), .. })) => { ExprKind::Path(QPath::Resolved(_, &Path { res: Res::Def(ConstParam, def_id), .. })) => {
// 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
// the parent item and construct a `ParamConst`. // the parent item and construct a `ParamConst`.
let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let item_def_id = tcx.parent(def_id);
let item_id = tcx.hir().get_parent_node(hir_id); let generics = tcx.generics_of(item_def_id);
let item_def_id = tcx.hir().local_def_id(item_id);
let generics = tcx.generics_of(item_def_id.to_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.hir().name(hir_id); let name = tcx.item_name(def_id);
let ty_const = let ty_const =
tcx.mk_const(ty::ConstKind::Param(ty::ParamConst::new(index, name)), ty); tcx.mk_const(ty::ConstKind::Param(ty::ParamConst::new(index, name)), ty);
debug!(?ty_const); debug!(?ty_const);

10
compiler/rustc_middle/src/ty/consts.rs
View File

@ -1,6 +1,6 @@
use crate::mir::interpret::LitToConstInput; use crate::mir::interpret::LitToConstInput;
use crate::mir::ConstantKind; use crate::mir::ConstantKind;
use crate::ty::{self, InternalSubsts, ParamEnv, ParamEnvAnd, Ty, TyCtxt}; use crate::ty::{self, DefIdTree, InternalSubsts, ParamEnv, ParamEnvAnd, Ty, TyCtxt};
use rustc_data_structures::intern::Interned; use rustc_data_structures::intern::Interned;
use rustc_hir as hir; use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::def_id::{DefId, LocalDefId};
@ -131,12 +131,10 @@ fn try_eval_lit_or_param(
ExprKind::Path(QPath::Resolved(_, &Path { res: Res::Def(ConstParam, def_id), .. })) => { ExprKind::Path(QPath::Resolved(_, &Path { res: Res::Def(ConstParam, def_id), .. })) => {
// 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
// the parent item and construct a `ParamConst`. // the parent item and construct a `ParamConst`.
let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let item_def_id = tcx.parent(def_id);
let item_id = tcx.hir().get_parent_node(hir_id); let generics = tcx.generics_of(item_def_id);
let item_def_id = tcx.hir().local_def_id(item_id);
let generics = tcx.generics_of(item_def_id.to_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.hir().name(hir_id); let name = tcx.item_name(def_id);
Some(tcx.mk_const(ty::ConstKind::Param(ty::ParamConst::new(index, name)), ty)) Some(tcx.mk_const(ty::ConstKind::Param(ty::ParamConst::new(index, name)), ty))
} }
_ => None, _ => None,

11
compiler/rustc_middle/src/ty/diagnostics.rs
View File

@ -151,7 +151,6 @@ enum SuggestChangingConstraintsMessage<'a> {
} }
fn suggest_removing_unsized_bound( fn suggest_removing_unsized_bound(
tcx: TyCtxt<'_>,
generics: &hir::Generics<'_>, generics: &hir::Generics<'_>,
suggestions: &mut Vec<(Span, String, SuggestChangingConstraintsMessage<'_>)>, suggestions: &mut Vec<(Span, String, SuggestChangingConstraintsMessage<'_>)>,
param: &hir::GenericParam<'_>, param: &hir::GenericParam<'_>,
@ -160,17 +159,16 @@ fn suggest_removing_unsized_bound(
// See if there's a `?Sized` bound that can be removed to suggest that. // See if there's a `?Sized` bound that can be removed to suggest that.
// First look at the `where` clause because we can have `where T: ?Sized`, // First look at the `where` clause because we can have `where T: ?Sized`,
// then look at params. // then look at params.
let param_def_id = tcx.hir().local_def_id(param.hir_id);
for (where_pos, predicate) in generics.predicates.iter().enumerate() { for (where_pos, predicate) in generics.predicates.iter().enumerate() {
let WherePredicate::BoundPredicate(predicate) = predicate else { let WherePredicate::BoundPredicate(predicate) = predicate else {
continue; continue;
}; };
if !predicate.is_param_bound(param_def_id.to_def_id()) { if !predicate.is_param_bound(param.def_id.to_def_id()) {
continue; continue;
}; };
for (pos, bound) in predicate.bounds.iter().enumerate() { for (pos, bound) in predicate.bounds.iter().enumerate() {
let hir::GenericBound::Trait(poly, hir::TraitBoundModifier::Maybe) = bound else { let hir::GenericBound::Trait(poly, hir::TraitBoundModifier::Maybe) = bound else {
continue; continue;
}; };
if poly.trait_ref.trait_def_id() != def_id { if poly.trait_ref.trait_def_id() != def_id {
@ -232,7 +230,7 @@ pub fn suggest_constraining_type_params<'a>(
param.span, param.span,
&format!("this type parameter needs to be `{}`", constraint), &format!("this type parameter needs to be `{}`", constraint),
); );
suggest_removing_unsized_bound(tcx, generics, &mut suggestions, param, def_id); suggest_removing_unsized_bound(generics, &mut suggestions, param, def_id);
} }
} }
@ -283,8 +281,7 @@ pub fn suggest_constraining_type_params<'a>(
// -- // --
// | // |
// replace with: `T: Bar +` // replace with: `T: Bar +`
let param_def_id = tcx.hir().local_def_id(param.hir_id); if let Some(span) = generics.bounds_span_for_suggestions(param.def_id) {
if let Some(span) = generics.bounds_span_for_suggestions(param_def_id) {
suggest_restrict(span, true); suggest_restrict(span, true);
continue; continue;
} }

4
compiler/rustc_mir_build/src/thir/cx/expr.rs
View File

@ -859,9 +859,7 @@ fn convert_path_expr(&mut self, expr: &'tcx hir::Expr<'tcx>, res: Res) -> ExprKi
Res::Def(DefKind::ConstParam, def_id) => { Res::Def(DefKind::ConstParam, def_id) => {
let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
let item_id = self.tcx.hir().get_parent_node(hir_id); let generics = self.tcx.generics_of(hir_id.owner);
let item_def_id = self.tcx.hir().local_def_id(item_id);
let generics = self.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 = self.tcx.hir().name(hir_id); let name = self.tcx.hir().name(hir_id);
let param = ty::ParamConst::new(index, name); let param = ty::ParamConst::new(index, name);

3
compiler/rustc_passes/src/check_attr.rs
View File

@ -411,8 +411,7 @@ fn check_object_lifetime_default(&self, hir_id: HirId) {
if let Some(generics) = tcx.hir().get_generics(tcx.hir().local_def_id(hir_id)) { if let Some(generics) = tcx.hir().get_generics(tcx.hir().local_def_id(hir_id)) {
for p in generics.params { for p in generics.params {
let hir::GenericParamKind::Type { .. } = p.kind else { continue }; let hir::GenericParamKind::Type { .. } = p.kind else { continue };
let param_id = tcx.hir().local_def_id(p.hir_id); let default = tcx.object_lifetime_default(p.def_id);
let default = tcx.object_lifetime_default(param_id);
let repr = match default { let repr = match default {
ObjectLifetimeDefault::Empty => "BaseDefault".to_owned(), ObjectLifetimeDefault::Empty => "BaseDefault".to_owned(),
ObjectLifetimeDefault::Static => "'static".to_owned(), ObjectLifetimeDefault::Static => "'static".to_owned(),

2
compiler/rustc_passes/src/stability.rs
View File

@ -500,7 +500,7 @@ fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam<'tcx>) {
}; };
self.annotate( self.annotate(
self.tcx.hir().local_def_id(p.hir_id), p.def_id,
p.span, p.span,
None, None,
kind, kind,

5
compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
View File

@ -2619,11 +2619,10 @@ fn maybe_suggest_unsized_generics(&self, err: &mut Diagnostic, span: Span, node:
let Some(param) = generics.params.iter().find(|param| param.span == span) else { let Some(param) = generics.params.iter().find(|param| param.span == span) else {
return; return;
}; };
let param_def_id = self.tcx.hir().local_def_id(param.hir_id);
// Check that none of the explicit trait bounds is `Sized`. Assume that an explicit // Check that none of the explicit trait bounds is `Sized`. Assume that an explicit
// `Sized` bound is there intentionally and we don't need to suggest relaxing it. // `Sized` bound is there intentionally and we don't need to suggest relaxing it.
let explicitly_sized = generics let explicitly_sized = generics
.bounds_for_param(param_def_id) .bounds_for_param(param.def_id)
.flat_map(|bp| bp.bounds) .flat_map(|bp| bp.bounds)
.any(|bound| bound.trait_ref().and_then(|tr| tr.trait_def_id()) == sized_trait); .any(|bound| bound.trait_ref().and_then(|tr| tr.trait_def_id()) == sized_trait);
if explicitly_sized { if explicitly_sized {
@ -2646,7 +2645,7 @@ fn maybe_suggest_unsized_generics(&self, err: &mut Diagnostic, span: Span, node:
_ => {} _ => {}
}; };
// Didn't add an indirection suggestion, so add a general suggestion to relax `Sized`. // Didn't add an indirection suggestion, so add a general suggestion to relax `Sized`.
let (span, separator) = if let Some(s) = generics.bounds_span_for_suggestions(param_def_id) let (span, separator) = if let Some(s) = generics.bounds_span_for_suggestions(param.def_id)
{ {
(s, " +") (s, " +")
} else { } else {