Auto merge of rust-lang#101228 - nnethercote:simplify-hir-PathSegment…

…, r=petrochenkov

Simplify `hir::PathSegment`

r? `@petrochenkov`

compiler/rustc_ast_lowering/src/expr.rs

@@ -1776,12 +1776,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
  binding: hir::HirId,
  attrs: AttrVec,
  ) -> hir::Expr<'hir> {
+ let hir_id = self.next_id();
+ let res = Res::Local(binding);
  let expr_path = hir::ExprKind::Path(hir::QPath::Resolved(
  None,
  self.arena.alloc(hir::Path {
  span: self.lower_span(span),
- res: Res::Local(binding),
- segments: arena_vec![self; hir::PathSegment::from_ident(ident)],
+ res,
+ segments: arena_vec![self; hir::PathSegment::new(ident, hir_id, res)],
  }),
  ));
 

compiler/rustc_ast_lowering/src/index.rs

@@ -246,9 +246,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
  }
 
  fn visit_path_segment(&mut self, path_span: Span, path_segment: &'hir PathSegment<'hir>) {
- if let Some(hir_id) = path_segment.hir_id {
- self.insert(path_span, hir_id, Node::PathSegment(path_segment));
- }
+ self.insert(path_span, path_segment.hir_id, Node::PathSegment(path_segment));
  intravisit::walk_path_segment(self, path_span, path_segment);
  }
 

compiler/rustc_ast_lowering/src/item.rs

@@ -1439,10 +1439,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
  GenericParamKind::Const { .. } => None,
  GenericParamKind::Type { .. } => {
  let def_id = self.local_def_id(id).to_def_id();
+ let hir_id = self.next_id();
+ let res = Res::Def(DefKind::TyParam, def_id);
  let ty_path = self.arena.alloc(hir::Path {
  span: param_span,
- res: Res::Def(DefKind::TyParam, def_id),
- segments: self.arena.alloc_from_iter([hir::PathSegment::from_ident(ident)]),
+ res,
+ segments: self
+ .arena
+ .alloc_from_iter([hir::PathSegment::new(ident, hir_id, res)]),
  });
  let ty_id = self.next_id();
  let bounded_ty =

compiler/rustc_ast_lowering/src/lib.rs

@@ -1260,14 +1260,17 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  return self.lower_path_ty(t, qself, path, ParamMode::Explicit, itctx);
  }
  TyKind::ImplicitSelf => {
+ let hir_id = self.lower_node_id(t.id);
  let res = self.expect_full_res(t.id);
  let res = self.lower_res(res);
  hir::TyKind::Path(hir::QPath::Resolved(
  None,
  self.arena.alloc(hir::Path {
  res,
- segments: arena_vec![self; hir::PathSegment::from_ident(
- Ident::with_dummy_span(kw::SelfUpper)
+ segments: arena_vec![self; hir::PathSegment::new(
+ Ident::with_dummy_span(kw::SelfUpper),
+ hir_id,
+ res
  )],
  span: self.lower_span(t.span),
  }),
@@ -2193,12 +2196,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  hir::PredicateOrigin::ImplTrait,
  );
 
+ let hir_id = self.next_id();
+ let res = Res::Def(DefKind::TyParam, def_id.to_def_id());
  let ty = hir::TyKind::Path(hir::QPath::Resolved(
  None,
  self.arena.alloc(hir::Path {
  span: self.lower_span(span),
- res: Res::Def(DefKind::TyParam, def_id.to_def_id()),
- segments: arena_vec![self; hir::PathSegment::from_ident(self.lower_ident(ident))],
+ res,
+ segments:
+ arena_vec![self; hir::PathSegment::new(self.lower_ident(ident), hir_id, res)],
  }),
  ));
 

compiler/rustc_ast_lowering/src/pat.rs

@@ -254,14 +254,18 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  lower_sub(self),
  )
  }
- Some(res) => hir::PatKind::Path(hir::QPath::Resolved(
- None,
- self.arena.alloc(hir::Path {
- span: self.lower_span(ident.span),
- res: self.lower_res(res),
- segments: arena_vec![self; hir::PathSegment::from_ident(self.lower_ident(ident))],
- }),
- )),
+ Some(res) => {
+ let hir_id = self.next_id();
+ let res = self.lower_res(res);
+ hir::PatKind::Path(hir::QPath::Resolved(
+ None,
+ self.arena.alloc(hir::Path {
+ span: self.lower_span(ident.span),
+ res,
+ segments: arena_vec![self; hir::PathSegment::new(self.lower_ident(ident), hir_id, res)],
+ }),
+ ))
+ }
  }
  }
 

compiler/rustc_ast_lowering/src/path.rs

@@ -250,16 +250,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  }
 
  let res = self.expect_full_res(segment.id);
- let id = self.lower_node_id(segment.id);
+ let hir_id = self.lower_node_id(segment.id);
  debug!(
  "lower_path_segment: ident={:?} original-id={:?} new-id={:?}",
- segment.ident, segment.id, id,
+ segment.ident, segment.id, hir_id,
  );
 
  hir::PathSegment {
  ident: self.lower_ident(segment.ident),
- hir_id: Some(id),
- res: Some(self.lower_res(res)),
+ hir_id,
+ res: self.lower_res(res),
  infer_args,
  args: if generic_args.is_empty() && generic_args.span.is_empty() {
  None

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -935,10 +935,11 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
  _,
  ) = hir_map.body(fn_body_id).value.kind
  {
- let opt_suggestions = path_segment
- .hir_id
- .map(|path_hir_id| self.infcx.tcx.typeck(path_hir_id.owner))
- .and_then(|typeck| typeck.type_dependent_def_id(*hir_id))
+ let opt_suggestions = self
+ .infcx
+ .tcx
+ .typeck(path_segment.hir_id.owner)
+ .type_dependent_def_id(*hir_id)
  .and_then(|def_id| self.infcx.tcx.impl_of_method(def_id))
  .map(|def_id| self.infcx.tcx.associated_items(def_id))
  .map(|assoc_items| {

compiler/rustc_hir/src/def.rs

@@ -308,6 +308,7 @@ pub enum Res<Id = hir::HirId> {
  ///
  /// **Belongs to the type namespace.**
  PrimTy(hir::PrimTy),
+
  /// The `Self` type, optionally with the [`DefId`] of the trait it belongs to and
  /// optionally with the [`DefId`] of the item introducing the `Self` type alias.
  ///
@@ -355,7 +356,8 @@ pub enum Res<Id = hir::HirId> {
  /// const fn baz<T>() -> usize { 10 }
  /// ```
  /// We do however allow `Self` in repeat expression even if it is generic to not break code
- /// which already works on stable while causing the `const_evaluatable_unchecked` future compat lint:
+ /// which already works on stable while causing the `const_evaluatable_unchecked` future compat
+ /// lint:
  /// ```
  /// fn foo<T>() {
  /// let _bar = [1_u8; std::mem::size_of::<*mut T>()];
@@ -370,6 +372,7 @@ pub enum Res<Id = hir::HirId> {
  /// from mentioning generics (i.e. when used in an anonymous constant).
  alias_to: Option<(DefId, bool)>,
  },
+
  /// A tool attribute module; e.g., the `rustfmt` in `#[rustfmt::skip]`.
  ///
  /// **Belongs to the type namespace.**
@@ -383,6 +386,7 @@ pub enum Res<Id = hir::HirId> {
  ///
  /// *See also [`Res::SelfTy`].*
  SelfCtor(DefId),
+
  /// A local variable or function parameter.
  ///
  /// **Belongs to the value namespace.**

compiler/rustc_hir/src/hir.rs

@@ -202,13 +202,8 @@ impl Path<'_> {
 pub struct PathSegment<'hir> {
  /// The identifier portion of this path segment.
  pub ident: Ident,
- // `id` and `res` are optional. We currently only use these in save-analysis,
- // any path segments without these will not have save-analysis info and
- // therefore will not have 'jump to def' in IDEs, but otherwise will not be
- // affected. (In general, we don't bother to get the defs for synthesized
- // segments, only for segments which have come from the AST).
- pub hir_id: Option<HirId>,
- pub res: Option<Res>,
+ pub hir_id: HirId,
+ pub res: Res,
 
  /// Type/lifetime parameters attached to this path. They come in
  /// two flavors: `Path<A,B,C>` and `Path(A,B) -> C`. Note that
@@ -226,12 +221,12 @@ pub struct PathSegment<'hir> {
 
 impl<'hir> PathSegment<'hir> {
  /// Converts an identifier to the corresponding segment.
- pub fn from_ident(ident: Ident) -> PathSegment<'hir> {
- PathSegment { ident, hir_id: None, res: None, infer_args: true, args: None }
+ pub fn new(ident: Ident, hir_id: HirId, res: Res) -> PathSegment<'hir> {
+ PathSegment { ident, hir_id, res, infer_args: true, args: None }
  }
 
  pub fn invalid() -> Self {
- Self::from_ident(Ident::empty())
+ Self::new(Ident::empty(), HirId::INVALID, Res::Err)
  }
 
  pub fn args(&self) -> &GenericArgs<'hir> {

compiler/rustc_hir/src/hir_id.rs

@@ -20,6 +20,9 @@ pub struct HirId {
 }
 
 impl HirId {
+ /// Signal local id which should never be used.
+ pub const INVALID: HirId = HirId { owner: CRATE_DEF_ID, local_id: ItemLocalId::INVALID };
+
  #[inline]
  pub fn expect_owner(self) -> LocalDefId {
  assert_eq!(self.local_id.index(), 0);

compiler/rustc_hir/src/intravisit.rs

@@ -724,7 +724,7 @@ pub fn walk_path_segment<'v, V: Visitor<'v>>(
  segment: &'v PathSegment<'v>,
 ) {
  visitor.visit_ident(segment.ident);
- walk_list!(visitor, visit_id, segment.hir_id);
+ visitor.visit_id(segment.hir_id);
  if let Some(ref args) = segment.args {
  visitor.visit_generic_args(path_span, args);
  }

compiler/rustc_hir_pretty/src/lib.rs

@@ -1189,7 +1189,7 @@ impl<'a> State<'a> {
 
  let generic_args = segment.args();
  if !generic_args.args.is_empty() || !generic_args.bindings.is_empty() {
- self.print_generic_args(generic_args, segment.infer_args, true);
+ self.print_generic_args(generic_args, true);
  }
 
  self.print_call_post(base_args)
@@ -1592,15 +1592,15 @@ impl<'a> State<'a> {
  }
  if segment.ident.name != kw::PathRoot {
  self.print_ident(segment.ident);
- self.print_generic_args(segment.args(), segment.infer_args, colons_before_params);
+ self.print_generic_args(segment.args(), colons_before_params);
  }
  }
  }
 
  pub fn print_path_segment(&mut self, segment: &hir::PathSegment<'_>) {
  if segment.ident.name != kw::PathRoot {
  self.print_ident(segment.ident);
- self.print_generic_args(segment.args(), segment.infer_args, false);
+ self.print_generic_args(segment.args(), false);
  }
  }
 
@@ -1619,23 +1619,15 @@ impl<'a> State<'a> {
  }
  if segment.ident.name != kw::PathRoot {
  self.print_ident(segment.ident);
- self.print_generic_args(
- segment.args(),
- segment.infer_args,
- colons_before_params,
- );
+ self.print_generic_args(segment.args(), colons_before_params);
  }
  }
 
  self.word(">");
  self.word("::");
  let item_segment = path.segments.last().unwrap();
  self.print_ident(item_segment.ident);
- self.print_generic_args(
- item_segment.args(),
- item_segment.infer_args,
- colons_before_params,
- )
+ self.print_generic_args(item_segment.args(), colons_before_params)
  }
  hir::QPath::TypeRelative(qself, item_segment) => {
  // If we've got a compound-qualified-path, let's push an additional pair of angle
@@ -1651,11 +1643,7 @@ impl<'a> State<'a> {
 
  self.word("::");
  self.print_ident(item_segment.ident);
- self.print_generic_args(
- item_segment.args(),
- item_segment.infer_args,
- colons_before_params,
- )
+ self.print_generic_args(item_segment.args(), colons_before_params)
  }
  hir::QPath::LangItem(lang_item, span, _) => {
  self.word("#[lang = \"");
@@ -1668,7 +1656,6 @@ impl<'a> State<'a> {
  fn print_generic_args(
  &mut self,
  generic_args: &hir::GenericArgs<'_>,
- infer_args: bool,
  colons_before_params: bool,
  ) {
  if generic_args.parenthesized {
@@ -1715,13 +1702,6 @@ impl<'a> State<'a> {
  );
  }
 
- // FIXME(eddyb): this would leak into error messages (e.g.,
- // "non-exhaustive patterns: `Some::<..>(_)` not covered").
- if infer_args && false {
- start_or_comma(self);
- self.word("..");
- }
-
  for binding in generic_args.bindings {
  start_or_comma(self);
  self.print_type_binding(binding);
@@ -1735,7 +1715,7 @@ impl<'a> State<'a> {
 
  pub fn print_type_binding(&mut self, binding: &hir::TypeBinding<'_>) {
  self.print_ident(binding.ident);
- self.print_generic_args(binding.gen_args, false, false);
+ self.print_generic_args(binding.gen_args, false);
  self.space();
  match binding.kind {
  hir::TypeBindingKind::Equality { ref term } => {

compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs

@@ -909,7 +909,7 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
  None?
  }
  let substs = self.node_substs_opt(expr.hir_id)?;
- let span = tcx.hir().span(segment.hir_id?);
+ let span = tcx.hir().span(segment.hir_id);
  let insert_span = segment.ident.span.shrink_to_hi().with_hi(span.hi());
  InsertableGenericArgs {
  insert_span,
@@ -957,13 +957,13 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
  path.segments
  .iter()
  .filter_map(move |segment| {
- let res = segment.res?;
+ let res = segment.res;
  let generics_def_id = tcx.res_generics_def_id(res)?;
  let generics = tcx.generics_of(generics_def_id);
  if generics.has_impl_trait() {
  return None;
  }
- let span = tcx.hir().span(segment.hir_id?);
+ let span = tcx.hir().span(segment.hir_id);
  let insert_span = segment.ident.span.shrink_to_hi().with_hi(span.hi());
  Some(InsertableGenericArgs {
  insert_span,
@@ -996,7 +996,7 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
  if !segment.infer_args || generics.has_impl_trait() {
  None?;
  }
- let span = tcx.hir().span(segment.hir_id?);
+ let span = tcx.hir().span(segment.hir_id);
  let insert_span = segment.ident.span.shrink_to_hi().with_hi(span.hi());
  InsertableGenericArgs { insert_span, substs, generics_def_id: def_id, def_id }
  };

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/trait_impl_difference.rs

@@ -154,16 +154,11 @@ impl<'tcx> Visitor<'tcx> for TypeParamSpanVisitor<'tcx> {
  }
  hir::TyKind::Path(hir::QPath::Resolved(None, path)) => match &path.segments {
  [segment]
- if segment
- .res
- .map(|res| {
- matches!(
- res,
- Res::SelfTy { trait_: _, alias_to: _ }
- | Res::Def(hir::def::DefKind::TyParam, _)
- )
- })
- .unwrap_or(false) =>
+ if matches!(
+ segment.res,
+ Res::SelfTy { trait_: _, alias_to: _ }
+ | Res::Def(hir::def::DefKind::TyParam, _)
+ ) =>
  {
  self.types.push(path.span);
  }

compiler/rustc_lint/src/internal.rs

@@ -118,8 +118,7 @@ impl<'tcx> LateLintPass<'tcx> for TyTyKind {
  _: rustc_hir::HirId,
  ) {
  if let Some(segment) = path.segments.iter().nth_back(1)
- && let Some(res) = &segment.res
- && lint_ty_kind_usage(cx, res)
+ && lint_ty_kind_usage(cx, &segment.res)
  {
  let span = path.span.with_hi(
  segment.args.map_or(segment.ident.span, |a| a.span_ext).hi()