Auto merge of #124401 - oli-obk:some_hir_cleanups, r=cjgillot

Some hir cleanups

It seemed odd to not put `AnonConst` in the arena, compared with the other types that we did put into an arena. This way we can also give it a `Span` without growing a lot of other HIR data structures because of the extra field.

r? compiler

compiler/rustc_ast_lowering/src/index.rs

@@ -62,7 +62,7 @@ pub(super) fn index_hir<'hir>(
  if let Node::Err(span) = node.node {
  let hir_id = HirId { owner: item.def_id(), local_id };
  let msg = format!("ID {hir_id} not encountered when visiting item HIR");
- tcx.dcx().span_delayed_bug(*span, msg);
+ tcx.dcx().span_delayed_bug(span, msg);
  }
  }
 
@@ -376,7 +376,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
  }
  }
 
- fn visit_array_length(&mut self, len: &'hir ArrayLen) {
+ fn visit_array_length(&mut self, len: &'hir ArrayLen<'hir>) {
  match len {
  ArrayLen::Infer(inf) => self.insert(inf.span, inf.hir_id, Node::ArrayLenInfer(inf)),
  ArrayLen::Body(..) => intravisit::walk_array_len(self, len),

compiler/rustc_ast_lowering/src/item.rs

@@ -1589,11 +1589,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
  }),
  )),
  )),
- default: Some(hir::AnonConst {
+ default: Some(self.arena.alloc(hir::AnonConst {
  def_id: anon_const,
  hir_id: const_id,
  body: const_body,
- }),
+ span,
+ })),
  is_host_effect: true,
  },
  colon_span: None,

compiler/rustc_ast_lowering/src/lib.rs

@@ -1178,14 +1178,17 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  tokens: None,
  };
 
- let ct = self.with_new_scopes(span, |this| hir::AnonConst {
- def_id,
- hir_id: this.lower_node_id(node_id),
- body: this.lower_const_body(path_expr.span, Some(&path_expr)),
+ let ct = self.with_new_scopes(span, |this| {
+ self.arena.alloc(hir::AnonConst {
+ def_id,
+ hir_id: this.lower_node_id(node_id),
+ body: this
+ .lower_const_body(path_expr.span, Some(&path_expr)),
+ span,
+ })
  });
  return GenericArg::Const(ConstArg {
  value: ct,
- span,
  is_desugared_from_effects: false,
  });
  }
@@ -1197,7 +1200,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  }
  ast::GenericArg::Const(ct) => GenericArg::Const(ConstArg {
  value: self.lower_anon_const(ct),
- span: self.lower_span(ct.value.span),
  is_desugared_from_effects: false,
  }),
  }
@@ -2315,7 +2317,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  }
 
  #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
- fn lower_array_length(&mut self, c: &AnonConst) -> hir::ArrayLen {
+ fn lower_array_length(&mut self, c: &AnonConst) -> hir::ArrayLen<'hir> {
  match c.value.kind {
  ExprKind::Underscore => {
  if self.tcx.features().generic_arg_infer {
@@ -2338,12 +2340,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  }
  }
 
- fn lower_anon_const(&mut self, c: &AnonConst) -> hir::AnonConst {
- self.with_new_scopes(c.value.span, |this| hir::AnonConst {
+ fn lower_anon_const(&mut self, c: &AnonConst) -> &'hir hir::AnonConst {
+ self.arena.alloc(self.with_new_scopes(c.value.span, |this| hir::AnonConst {
  def_id: this.local_def_id(c.id),
  hir_id: this.lower_node_id(c.id),
  body: this.lower_const_body(c.value.span, Some(&c.value)),
- })
+ span: this.lower_span(c.value.span),
+ }))
  }
 
  fn lower_unsafe_source(&mut self, u: UnsafeSource) -> hir::UnsafeSource {
@@ -2650,8 +2653,7 @@ impl<'hir> GenericArgsCtor<'hir> {
 
  lcx.children.push((def_id, hir::MaybeOwner::NonOwner(hir_id)));
  self.args.push(hir::GenericArg::Const(hir::ConstArg {
- value: hir::AnonConst { def_id, hir_id, body },
- span,
+ value: lcx.arena.alloc(hir::AnonConst { def_id, hir_id, body, span }),
  is_desugared_from_effects: true,
  }))
  }

compiler/rustc_hir/src/hir.rs

@@ -229,9 +229,8 @@ impl<'hir> PathSegment<'hir> {
 }
 
 #[derive(Clone, Copy, Debug, HashStable_Generic)]
-pub struct ConstArg {
- pub value: AnonConst,
- pub span: Span,
+pub struct ConstArg<'hir> {
+ pub value: &'hir AnonConst,
  /// Indicates whether this comes from a `~const` desugaring.
  pub is_desugared_from_effects: bool,
 }
@@ -252,7 +251,7 @@ impl InferArg {
 pub enum GenericArg<'hir> {
  Lifetime(&'hir Lifetime),
  Type(&'hir Ty<'hir>),
- Const(ConstArg),
+ Const(ConstArg<'hir>),
  Infer(InferArg),
 }
 
@@ -261,7 +260,7 @@ impl GenericArg<'_> {
  match self {
  GenericArg::Lifetime(l) => l.ident.span,
  GenericArg::Type(t) => t.span,
- GenericArg::Const(c) => c.span,
+ GenericArg::Const(c) => c.value.span,
  GenericArg::Infer(i) => i.span,
  }
  }
@@ -490,7 +489,7 @@ pub enum GenericParamKind<'hir> {
  Const {
  ty: &'hir Ty<'hir>,
  /// Optional default value for the const generic param
- default: Option<AnonConst>,
+ default: Option<&'hir AnonConst>,
  is_host_effect: bool,
  },
 }
@@ -1562,12 +1561,12 @@ impl fmt::Display for ConstContext {
 pub type Lit = Spanned<LitKind>;
 
 #[derive(Copy, Clone, Debug, HashStable_Generic)]
-pub enum ArrayLen {
+pub enum ArrayLen<'hir> {
  Infer(InferArg),
- Body(AnonConst),
+ Body(&'hir AnonConst),
 }
 
-impl ArrayLen {
+impl ArrayLen<'_> {
  pub fn hir_id(&self) -> HirId {
  match self {
  ArrayLen::Infer(InferArg { hir_id, .. }) | ArrayLen::Body(AnonConst { hir_id, .. }) => {
@@ -1590,6 +1589,7 @@ pub struct AnonConst {
  pub hir_id: HirId,
  pub def_id: LocalDefId,
  pub body: BodyId,
+ pub span: Span,
 }
 
 /// An inline constant expression `const { something }`.
@@ -2002,7 +2002,7 @@ pub enum ExprKind<'hir> {
  ///
  /// E.g., `[1; 5]`. The first expression is the element
  /// to be repeated; the second is the number of times to repeat it.
- Repeat(&'hir Expr<'hir>, ArrayLen),
+ Repeat(&'hir Expr<'hir>, ArrayLen<'hir>),
 
  /// A suspension point for coroutines (i.e., `yield <expr>`).
  Yield(&'hir Expr<'hir>, YieldSource),
@@ -2382,7 +2382,7 @@ pub struct TypeBinding<'hir> {
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub enum Term<'hir> {
  Ty(&'hir Ty<'hir>),
- Const(AnonConst),
+ Const(&'hir AnonConst),
 }
 
 impl<'hir> From<&'hir Ty<'hir>> for Term<'hir> {
@@ -2391,8 +2391,8 @@ impl<'hir> From<&'hir Ty<'hir>> for Term<'hir> {
  }
 }
 
-impl<'hir> From<AnonConst> for Term<'hir> {
- fn from(c: AnonConst) -> Self {
+impl<'hir> From<&'hir AnonConst> for Term<'hir> {
+ fn from(c: &'hir AnonConst) -> Self {
  Term::Const(c)
  }
 }
@@ -2683,7 +2683,7 @@ pub enum TyKind<'hir> {
  /// A variable length slice (i.e., `[T]`).
  Slice(&'hir Ty<'hir>),
  /// A fixed length array (i.e., `[T; n]`).
- Array(&'hir Ty<'hir>, ArrayLen),
+ Array(&'hir Ty<'hir>, ArrayLen<'hir>),
  /// A raw pointer (i.e., `*const T` or `*mut T`).
  Ptr(MutTy<'hir>),
  /// A reference (i.e., `&'a T` or `&'a mut T`).
@@ -2712,7 +2712,7 @@ pub enum TyKind<'hir> {
  /// where `Bound` is a trait or a lifetime.
  TraitObject(&'hir [PolyTraitRef<'hir>], &'hir Lifetime, TraitObjectSyntax),
  /// Unused for now.
- Typeof(AnonConst),
+ Typeof(&'hir AnonConst),
  /// `TyKind::Infer` means the type should be inferred instead of it having been
  /// specified. This can appear anywhere in a type.
  Infer,
@@ -2745,10 +2745,10 @@ pub enum InlineAsmOperand<'hir> {
  out_expr: Option<&'hir Expr<'hir>>,
  },
  Const {
- anon_const: AnonConst,
+ anon_const: &'hir AnonConst,
  },
  SymFn {
- anon_const: AnonConst,
+ anon_const: &'hir AnonConst,
  },
  SymStatic {
  path: QPath<'hir>,
@@ -2950,7 +2950,7 @@ pub struct Variant<'hir> {
  /// Fields and constructor id of the variant.
  pub data: VariantData<'hir>,
  /// Explicit discriminant (e.g., `Foo = 1`).
- pub disr_expr: Option<AnonConst>,
+ pub disr_expr: Option<&'hir AnonConst>,
  /// Span
  pub span: Span,
 }
@@ -3479,15 +3479,13 @@ impl<'hir> OwnerNode<'hir> {
  }
  }
 
- // Span by reference to pass to `Node::Err`.
- #[allow(rustc::pass_by_value)]
- pub fn span(&self) -> &'hir Span {
+ pub fn span(&self) -> Span {
  match self {
  OwnerNode::Item(Item { span, .. })
  | OwnerNode::ForeignItem(ForeignItem { span, .. })
  | OwnerNode::ImplItem(ImplItem { span, .. })
- | OwnerNode::TraitItem(TraitItem { span, .. }) => span,
- OwnerNode::Crate(Mod { spans: ModSpans { inner_span, .. }, .. }) => inner_span,
+ | OwnerNode::TraitItem(TraitItem { span, .. }) => *span,
+ OwnerNode::Crate(Mod { spans: ModSpans { inner_span, .. }, .. }) => *inner_span,
  OwnerNode::Synthetic => unreachable!(),
  }
  }
@@ -3632,9 +3630,7 @@ pub enum Node<'hir> {
  PreciseCapturingNonLifetimeArg(&'hir PreciseCapturingNonLifetimeArg),
  // Created by query feeding
  Synthetic,
- // Span by reference to minimize `Node`'s size
- #[allow(rustc::pass_by_value)]
- Err(&'hir Span),
+ Err(Span),
 }
 
 impl<'hir> Node<'hir> {
@@ -3871,7 +3867,7 @@ mod size_asserts {
  static_assert_size!(FnDecl<'_>, 40);
  static_assert_size!(ForeignItem<'_>, 72);
  static_assert_size!(ForeignItemKind<'_>, 40);
- static_assert_size!(GenericArg<'_>, 32);
+ static_assert_size!(GenericArg<'_>, 24);
  static_assert_size!(GenericBound<'_>, 48);
  static_assert_size!(Generics<'_>, 56);
  static_assert_size!(Impl<'_>, 80);

compiler/rustc_hir/src/intravisit.rs

@@ -338,7 +338,7 @@ pub trait Visitor<'v>: Sized {
  fn visit_pat_field(&mut self, f: &'v PatField<'v>) -> Self::Result {
  walk_pat_field(self, f)
  }
- fn visit_array_length(&mut self, len: &'v ArrayLen) -> Self::Result {
+ fn visit_array_length(&mut self, len: &'v ArrayLen<'v>) -> Self::Result {
  walk_array_len(self, len)
  }
  fn visit_anon_const(&mut self, c: &'v AnonConst) -> Self::Result {
@@ -703,7 +703,7 @@ pub fn walk_pat_field<'v, V: Visitor<'v>>(visitor: &mut V, field: &'v PatField<'
  visitor.visit_pat(field.pat)
 }
 
-pub fn walk_array_len<'v, V: Visitor<'v>>(visitor: &mut V, len: &'v ArrayLen) -> V::Result {
+pub fn walk_array_len<'v, V: Visitor<'v>>(visitor: &mut V, len: &'v ArrayLen<'v>) -> V::Result {
  match len {
  // FIXME: Use `visit_infer` here.
  ArrayLen::Infer(InferArg { hir_id, span: _ }) => visitor.visit_id(*hir_id),

compiler/rustc_hir_analysis/src/collect.rs

@@ -143,7 +143,7 @@ impl<'v> Visitor<'v> for HirPlaceholderCollector {
  _ => {}
  }
  }
- fn visit_array_length(&mut self, length: &'v hir::ArrayLen) {
+ fn visit_array_length(&mut self, length: &'v hir::ArrayLen<'v>) {
  if let hir::ArrayLen::Infer(inf) = length {
  self.0.push(inf.span);
  }

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -24,7 +24,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
  let hir_id = tcx.local_def_id_to_hir_id(def_id);
 
  let node = tcx.hir_node(hir_id);
- let Node::AnonConst(_) = node else {
+ let Node::AnonConst(&AnonConst { span, .. }) = node else {
  span_bug!(
  tcx.def_span(def_id),
  "expected anon const in `anon_const_type_of`, got {node:?}"
@@ -134,7 +134,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
  // I dont think it's possible to reach this but I'm not 100% sure - BoxyUwU
  return Ty::new_error_with_message(
  tcx,
- tcx.def_span(def_id),
+ span,
  "unexpected non-GAT usage of an anon const",
  );
  }
@@ -152,7 +152,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
  let Some(type_dependent_def) = tables.type_dependent_def_id(parent_node_id) else {
  return Ty::new_error_with_message(
  tcx,
- tcx.def_span(def_id),
+ span,
  format!("unable to find type-dependent def for {parent_node_id:?}"),
  );
  };
@@ -194,15 +194,15 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
  } else {
  return Ty::new_error_with_message(
  tcx,
- tcx.def_span(def_id),
+ span,
  format!("unable to find const parent for {hir_id} in pat {pat:?}"),
  );
  }
  }
  _ => {
  return Ty::new_error_with_message(
  tcx,
- tcx.def_span(def_id),
+ span,
  format!("unexpected const parent path {parent_node:?}"),
  );
  }
@@ -226,19 +226,15 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
  .map(|idx| (idx, seg))
  })
  }) else {
- return Ty::new_error_with_message(
- tcx,
- tcx.def_span(def_id),
- "no arg matching AnonConst in path",
- );
+ return Ty::new_error_with_message(tcx, span, "no arg matching AnonConst in path");
  };
 
  let generics = match tcx.res_generics_def_id(segment.res) {
  Some(def_id) => tcx.generics_of(def_id),
  None => {
  return Ty::new_error_with_message(
  tcx,
- tcx.def_span(def_id),
+ span,
  format!("unexpected anon const res {:?} in path: {:?}", segment.res, path),
  );
  }
@@ -250,7 +246,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
  _ => {
  return Ty::new_error_with_message(
  tcx,
- tcx.def_span(def_id),
+ span,
  format!("unexpected const parent in type_of(): {parent_node:?}"),
  );
  }
@@ -278,7 +274,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
  } else {
  return Ty::new_error_with_message(
  tcx,
- tcx.def_span(def_id),
+ span,
  format!("const generic parameter not found in {generics:?} at position {arg_idx:?}"),
  );
  }