Store associated item defaultness in impl_defaultness.

Author: cjgillot

compiler/rustc_ast_lowering/src/index.rs

@@ -323,16 +323,15 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
  fn visit_trait_item_ref(&mut self, ii: &'hir TraitItemRef) {
  // Do not visit the duplicate information in TraitItemRef. We want to
  // map the actual nodes, not the duplicate ones in the *Ref.
- let TraitItemRef { id, ident: _, kind: _, span: _, defaultness: _ } = *ii;
+ let TraitItemRef { id, ident: _, kind: _, span: _ } = *ii;
 
  self.visit_nested_trait_item(id);
  }
 
  fn visit_impl_item_ref(&mut self, ii: &'hir ImplItemRef) {
  // Do not visit the duplicate information in ImplItemRef. We want to
  // map the actual nodes, not the duplicate ones in the *Ref.
- let ImplItemRef { id, ident: _, kind: _, span: _, defaultness: _, trait_item_def_id: _ } =
- *ii;
+ let ImplItemRef { id, ident: _, kind: _, span: _, trait_item_def_id: _ } = *ii;
 
  self.visit_nested_impl_item(id);
  }

compiler/rustc_ast_lowering/src/item.rs

@@ -755,17 +755,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
  let hir_id = self.lower_node_id(i.id);
  let trait_item_def_id = hir_id.expect_owner();
 
- let (generics, kind) = match i.kind {
+ let (generics, kind, has_default) = match i.kind {
  AssocItemKind::Const(_, ref ty, ref default) => {
  let ty = self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type));
  let body = default.as_ref().map(|x| self.lower_const_body(i.span, Some(x)));
- (hir::Generics::empty(), hir::TraitItemKind::Const(ty, body))
+ (hir::Generics::empty(), hir::TraitItemKind::Const(ty, body), body.is_some())
  }
  AssocItemKind::Fn(box Fn { ref sig, ref generics, body: None, .. }) => {
  let names = self.lower_fn_params_to_names(&sig.decl);
  let (generics, sig) =
  self.lower_method_sig(generics, sig, i.id, FnDeclKind::Trait, None);
- (generics, hir::TraitItemKind::Fn(sig, hir::TraitFn::Required(names)))
+ (generics, hir::TraitItemKind::Fn(sig, hir::TraitFn::Required(names)), false)
  }
  AssocItemKind::Fn(box Fn { ref sig, ref generics, body: Some(ref body), .. }) => {
  let asyncness = sig.header.asyncness;
@@ -778,7 +778,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  FnDeclKind::Trait,
  asyncness.opt_return_id(),
  );
- (generics, hir::TraitItemKind::Fn(sig, hir::TraitFn::Provided(body_id)))
+ (generics, hir::TraitItemKind::Fn(sig, hir::TraitFn::Provided(body_id)), true)
  }
  AssocItemKind::TyAlias(box TyAlias {
  ref generics,
@@ -789,7 +789,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  }) => {
  let mut generics = generics.clone();
  add_ty_alias_where_clause(&mut generics, where_clauses, false);
- self.lower_generics(
+ let (generics, kind) = self.lower_generics(
  &generics,
  i.id,
  ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
@@ -805,7 +805,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
  ty,
  )
  },
- )
+ );
+ (generics, kind, ty.is_some())
  }
  AssocItemKind::MacCall(..) => panic!("macro item shouldn't exist at this point"),
  };
@@ -817,28 +818,25 @@ impl<'hir> LoweringContext<'_, 'hir> {
  generics,
  kind,
  span: self.lower_span(i.span),
+ defaultness: hir::Defaultness::Default { has_value: has_default },
  };
  self.arena.alloc(item)
  }
 
  fn lower_trait_item_ref(&mut self, i: &AssocItem) -> hir::TraitItemRef {
- let (kind, has_default) = match &i.kind {
- AssocItemKind::Const(_, _, default) => (hir::AssocItemKind::Const, default.is_some()),
- AssocItemKind::TyAlias(box TyAlias { ty, .. }) => {
- (hir::AssocItemKind::Type, ty.is_some())
- }
- AssocItemKind::Fn(box Fn { sig, body, .. }) => {
- (hir::AssocItemKind::Fn { has_self: sig.decl.has_self() }, body.is_some())
+ let kind = match &i.kind {
+ AssocItemKind::Const(..) => hir::AssocItemKind::Const,
+ AssocItemKind::TyAlias(..) => hir::AssocItemKind::Type,
+ AssocItemKind::Fn(box Fn { sig, .. }) => {
+ hir::AssocItemKind::Fn { has_self: sig.decl.has_self() }
  }
  AssocItemKind::MacCall(..) => unimplemented!(),
  };
  let id = hir::TraitItemId { def_id: self.local_def_id(i.id) };
- let defaultness = hir::Defaultness::Default { has_value: has_default };
  hir::TraitItemRef {
  id,
  ident: self.lower_ident(i.ident),
  span: self.lower_span(i.span),
- defaultness,
  kind,
  }
  }
@@ -849,6 +847,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
  }
 
  fn lower_impl_item(&mut self, i: &AssocItem) -> &'hir hir::ImplItem<'hir> {
+ // Since `default impl` is not yet implemented, this is always true in impls.
+ let has_value = true;
+ let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value);
+
  let (generics, kind) = match &i.kind {
  AssocItemKind::Const(_, ty, expr) => {
  let ty = self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type));
@@ -903,19 +905,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
  kind,
  vis_span: self.lower_span(i.vis.span),
  span: self.lower_span(i.span),
+ defaultness,
  };
  self.arena.alloc(item)
  }
 
  fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemRef {
- // Since `default impl` is not yet implemented, this is always true in impls.
- let has_value = true;
- let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value);
  hir::ImplItemRef {
  id: hir::ImplItemId { def_id: self.local_def_id(i.id) },
  ident: self.lower_ident(i.ident),
  span: self.lower_span(i.span),
- defaultness,
  kind: match &i.kind {
  AssocItemKind::Const(..) => hir::AssocItemKind::Const,
  AssocItemKind::TyAlias(..) => hir::AssocItemKind::Type,

compiler/rustc_hir/src/hir.rs

@@ -2222,6 +2222,7 @@ pub struct TraitItem<'hir> {
  pub generics: &'hir Generics<'hir>,
  pub kind: TraitItemKind<'hir>,
  pub span: Span,
+ pub defaultness: Defaultness,
 }
 
 impl TraitItem<'_> {
@@ -2281,6 +2282,7 @@ pub struct ImplItem<'hir> {
  pub def_id: LocalDefId,
  pub generics: &'hir Generics<'hir>,
  pub kind: ImplItemKind<'hir>,
+ pub defaultness: Defaultness,
  pub span: Span,
  pub vis_span: Span,
 }
@@ -3083,7 +3085,6 @@ pub struct TraitItemRef {
  pub ident: Ident,
  pub kind: AssocItemKind,
  pub span: Span,
- pub defaultness: Defaultness,
 }
 
 /// A reference from an impl to one of its associated items. This
@@ -3098,7 +3099,6 @@ pub struct ImplItemRef {
  pub ident: Ident,
  pub kind: AssocItemKind,
  pub span: Span,
- pub defaultness: Defaultness,
  /// When we are in a trait impl, link to the trait-item's id.
  pub trait_item_def_id: Option<DefId>,
 }
@@ -3496,11 +3496,11 @@ mod size_asserts {
  rustc_data_structures::static_assert_size!(ForeignItem<'static>, 72);
  rustc_data_structures::static_assert_size!(GenericBound<'_>, 48);
  rustc_data_structures::static_assert_size!(Generics<'static>, 56);
- rustc_data_structures::static_assert_size!(ImplItem<'static>, 80);
+ rustc_data_structures::static_assert_size!(ImplItem<'static>, 88);
  rustc_data_structures::static_assert_size!(Impl<'static>, 80);
  rustc_data_structures::static_assert_size!(Item<'static>, 80);
  rustc_data_structures::static_assert_size!(Pat<'static>, 88);
  rustc_data_structures::static_assert_size!(QPath<'static>, 24);
- rustc_data_structures::static_assert_size!(TraitItem<'static>, 88);
+ rustc_data_structures::static_assert_size!(TraitItem<'static>, 96);
  rustc_data_structures::static_assert_size!(Ty<'static>, 72);
 }

compiler/rustc_hir/src/intravisit.rs

@@ -948,6 +948,7 @@ pub fn walk_fn<'v, V: Visitor<'v>>(
 pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v TraitItem<'v>) {
  visitor.visit_ident(trait_item.ident);
  visitor.visit_generics(&trait_item.generics);
+ visitor.visit_defaultness(&trait_item.defaultness);
  match trait_item.kind {
  TraitItemKind::Const(ref ty, default) => {
  visitor.visit_id(trait_item.hir_id());
@@ -980,19 +981,27 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v Trai
 
 pub fn walk_trait_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, trait_item_ref: &'v TraitItemRef) {
  // N.B., deliberately force a compilation error if/when new fields are added.
- let TraitItemRef { id, ident, ref kind, span: _, ref defaultness } = *trait_item_ref;
+ let TraitItemRef { id, ident, ref kind, span: _ } = *trait_item_ref;
  visitor.visit_nested_trait_item(id);
  visitor.visit_ident(ident);
  visitor.visit_associated_item_kind(kind);
- visitor.visit_defaultness(defaultness);
 }
 
 pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplItem<'v>) {
  // N.B., deliberately force a compilation error if/when new fields are added.
- let ImplItem { def_id: _, ident, ref generics, ref kind, span: _, vis_span: _ } = *impl_item;
+ let ImplItem {
+ def_id: _,
+ ident,
+ ref generics,
+ ref kind,
+ ref defaultness,
+ span: _,
+ vis_span: _,
+ } = *impl_item;
 
  visitor.visit_ident(ident);
  visitor.visit_generics(generics);
+ visitor.visit_defaultness(defaultness);
  match *kind {
  ImplItemKind::Const(ref ty, body) => {
  visitor.visit_id(impl_item.hir_id());
@@ -1027,12 +1036,10 @@ pub fn walk_foreign_item_ref<'v, V: Visitor<'v>>(
 
 pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, impl_item_ref: &'v ImplItemRef) {
  // N.B., deliberately force a compilation error if/when new fields are added.
- let ImplItemRef { id, ident, ref kind, span: _, ref defaultness, trait_item_def_id: _ } =
- *impl_item_ref;
+ let ImplItemRef { id, ident, ref kind, span: _, trait_item_def_id: _ } = *impl_item_ref;
  visitor.visit_nested_impl_item(id);
  visitor.visit_ident(ident);
  visitor.visit_associated_item_kind(kind);
- visitor.visit_defaultness(defaultness);
 }
 
 pub fn walk_struct_def<'v, V: Visitor<'v>>(

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1152,7 +1152,6 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
  name,
  kind,
  vis: self.get_visibility(id),
- defaultness: container.defaultness(),
  def_id: self.local_def_id(id),
  trait_item_def_id: self.get_trait_item_def_id(id),
  container: container.with_def_id(parent),

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1212,22 +1212,17 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  let tcx = self.tcx;
 
  let ast_item = tcx.hir().expect_trait_item(def_id.expect_local());
+ self.tables.impl_defaultness.set(def_id.index, ast_item.defaultness);
  let trait_item = tcx.associated_item(def_id);
 
- let container = match trait_item.defaultness {
- hir::Defaultness::Default { has_value: true } => AssocContainer::TraitWithDefault,
- hir::Defaultness::Default { has_value: false } => AssocContainer::TraitRequired,
- hir::Defaultness::Final => span_bug!(ast_item.span, "traits cannot have final items"),
- };
-
  match trait_item.kind {
  ty::AssocKind::Const => {
  let rendered = rustc_hir_pretty::to_string(
  &(&self.tcx.hir() as &dyn intravisit::Map<'_>),
  |s| s.print_trait_item(ast_item),
  );
 
- record!(self.tables.kind[def_id] <- EntryKind::AssocConst(container));
+ record!(self.tables.kind[def_id] <- EntryKind::AssocConst(AssocContainer::Trait));
  record!(self.tables.mir_const_qualif[def_id] <- mir::ConstQualifs::default());
  record!(self.tables.rendered_const[def_id] <- rendered);
  }
@@ -1244,21 +1239,21 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  self.tables.asyncness.set(def_id.index, m_sig.header.asyncness);
  self.tables.constness.set(def_id.index, hir::Constness::NotConst);
  record!(self.tables.kind[def_id] <- EntryKind::AssocFn(self.lazy(AssocFnData {
- container,
+ container:AssocContainer::Trait,
  has_self: trait_item.fn_has_self_parameter,
  })));
  }
  ty::AssocKind::Type => {
  self.encode_explicit_item_bounds(def_id);
- record!(self.tables.kind[def_id] <- EntryKind::AssocType(container));
+ record!(self.tables.kind[def_id] <- EntryKind::AssocType(AssocContainer::Trait));
  }
  }
  match trait_item.kind {
  ty::AssocKind::Const | ty::AssocKind::Fn => {
  self.encode_item_type(def_id);
  }
  ty::AssocKind::Type => {
- if trait_item.defaultness.has_value() {
+ if ast_item.defaultness.has_value() {
  self.encode_item_type(def_id);
  }
  }
@@ -1273,23 +1268,16 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  let tcx = self.tcx;
 
  let ast_item = self.tcx.hir().expect_impl_item(def_id.expect_local());
+ self.tables.impl_defaultness.set(def_id.index, ast_item.defaultness);
  let impl_item = self.tcx.associated_item(def_id);
 
- let container = match impl_item.defaultness {
- hir::Defaultness::Default { has_value: true } => AssocContainer::ImplDefault,
- hir::Defaultness::Final => AssocContainer::ImplFinal,
- hir::Defaultness::Default { has_value: false } => {
- span_bug!(ast_item.span, "impl items always have values (currently)")
- }
- };
-
  match impl_item.kind {
  ty::AssocKind::Const => {
  if let hir::ImplItemKind::Const(_, body_id) = ast_item.kind {
  let qualifs = self.tcx.at(ast_item.span).mir_const_qualif(def_id);
  let const_data = self.encode_rendered_const_for_body(body_id);
 
- record!(self.tables.kind[def_id] <- EntryKind::AssocConst(container));
+ record!(self.tables.kind[def_id] <- EntryKind::AssocConst(AssocContainer::Impl));
  record!(self.tables.mir_const_qualif[def_id] <- qualifs);
  record!(self.tables.rendered_const[def_id] <- const_data);
  } else {
@@ -1308,12 +1296,12 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  };
  self.tables.constness.set(def_id.index, constness);
  record!(self.tables.kind[def_id] <- EntryKind::AssocFn(self.lazy(AssocFnData {
- container,
+ container:AssocContainer::Impl,
  has_self: impl_item.fn_has_self_parameter,
  })));
  }
  ty::AssocKind::Type => {
- record!(self.tables.kind[def_id] <- EntryKind::AssocType(container));
+ record!(self.tables.kind[def_id] <- EntryKind::AssocType(AssocContainer::Impl));
  }
  }
  self.encode_item_type(def_id);

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -439,32 +439,15 @@ struct VariantData {
 /// a default, or an in impl, whether it's marked "default".
 #[derive(Copy, Clone, TyEncodable, TyDecodable)]
 enum AssocContainer {
- TraitRequired,
- TraitWithDefault,
- ImplDefault,
- ImplFinal,
+ Trait,
+ Impl,
 }
 
 impl AssocContainer {
  fn with_def_id(&self, def_id: DefId) -> ty::AssocItemContainer {
  match *self {
- AssocContainer::TraitRequired | AssocContainer::TraitWithDefault => {
- ty::TraitContainer(def_id)
- }
-
- AssocContainer::ImplDefault | AssocContainer::ImplFinal => ty::ImplContainer(def_id),
- }
- }
-
- fn defaultness(&self) -> hir::Defaultness {
- match *self {
- AssocContainer::TraitRequired => hir::Defaultness::Default { has_value: false },
-
- AssocContainer::TraitWithDefault | AssocContainer::ImplDefault => {
- hir::Defaultness::Default { has_value: true }
- }
-
- AssocContainer::ImplFinal => hir::Defaultness::Final,
+ AssocContainer::Trait => ty::TraitContainer(def_id),
+ AssocContainer::Impl => ty::ImplContainer(def_id),
  }
  }
 }

compiler/rustc_middle/src/traits/specialization_graph.rs

@@ -217,7 +217,7 @@ impl<'tcx> Ancestors<'tcx> {
  self.find_map(|node| {
  if let Some(item) = node.item(tcx, trait_item_def_id) {
  if finalizing_node.is_none() {
- let is_specializable = item.defaultness.is_default()
+ let is_specializable = item.defaultness(tcx).is_default()
  || tcx.impl_defaultness(node.def_id()).is_default();
 
  if !is_specializable {

compiler/rustc_middle/src/ty/assoc.rs

@@ -47,7 +47,6 @@ pub struct AssocItem {
  pub name: Symbol,
  pub kind: AssocKind,
  pub vis: Visibility,
- pub defaultness: hir::Defaultness,
  pub container: AssocItemContainer,
 
  /// If this is an item in an impl of a trait then this is the `DefId` of
@@ -64,6 +63,10 @@ impl AssocItem {
  Ident::new(self.name, tcx.def_ident_span(self.def_id).unwrap())
  }
 
+ pub fn defaultness(&self, tcx: TyCtxt<'_>) -> hir::Defaultness {
+ tcx.impl_defaultness(self.def_id)
+ }
+
  pub fn signature(&self, tcx: TyCtxt<'_>) -> String {
  match self.kind {
  ty::AssocKind::Fn => {