Auto merge of #148308 - GuillaumeGomez:rollup-mxz6q4j, r=GuillaumeGomez

Rollup of 4 pull requests Successful merges: - #144291 (Constify trait aliases) - #147633 (Add new `--bypass-ignore-backends` option) - #148262 (Fix types being marked as dead when they are inferred generic arguments) - #148268 (rustdoc: fix `--emit=dep-info` on scraped examples) r? `@ghost` `@rustbot` modify labels: rollup

Author: bors

compiler/rustc_ast/src/ast.rs

@@ -3540,8 +3540,9 @@ impl Item {
  ItemKind::Const(i) => Some(&i.generics),
  ItemKind::Fn(i) => Some(&i.generics),
  ItemKind::TyAlias(i) => Some(&i.generics),
- ItemKind::TraitAlias(_, generics, _)
- | ItemKind::Enum(_, generics, _)
+ ItemKind::TraitAlias(i) => Some(&i.generics),
+
+ ItemKind::Enum(_, generics, _)
  | ItemKind::Struct(_, generics, _)
  | ItemKind::Union(_, generics, _) => Some(&generics),
  ItemKind::Trait(i) => Some(&i.generics),
@@ -3623,6 +3624,15 @@ impl Default for FnHeader {
  }
 }
 
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub struct TraitAlias {
+ pub constness: Const,
+ pub ident: Ident,
+ pub generics: Generics,
+ #[visitable(extra = BoundKind::Bound)]
+ pub bounds: GenericBounds,
+}
+
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Trait {
  pub constness: Const,
@@ -3798,7 +3808,7 @@ pub enum ItemKind {
  /// Trait alias.
  ///
  /// E.g., `trait Foo = Bar + Quux;`.
- TraitAlias(Ident, Generics, GenericBounds),
+ TraitAlias(Box<TraitAlias>),
  /// An implementation.
  ///
  /// E.g., `impl<A> Foo<A> { .. }` or `impl<A> Trait for Foo<A> { .. }`.
@@ -3831,7 +3841,7 @@ impl ItemKind {
  | ItemKind::Struct(ident, ..)
  | ItemKind::Union(ident, ..)
  | ItemKind::Trait(box Trait { ident, .. })
- | ItemKind::TraitAlias(ident, ..)
+ | ItemKind::TraitAlias(box TraitAlias { ident, .. })
  | ItemKind::MacroDef(ident, _)
  | ItemKind::Delegation(box Delegation { ident, .. }) => Some(ident),
 
@@ -3888,7 +3898,7 @@ impl ItemKind {
  | Self::Struct(_, generics, _)
  | Self::Union(_, generics, _)
  | Self::Trait(box Trait { generics, .. })
- | Self::TraitAlias(_, generics, _)
+ | Self::TraitAlias(box TraitAlias { generics, .. })
  | Self::Impl(Impl { generics, .. }) => Some(generics),
  _ => None,
  }
@@ -4050,8 +4060,8 @@ mod size_asserts {
  static_assert_size!(GenericBound, 88);
  static_assert_size!(Generics, 40);
  static_assert_size!(Impl, 64);
- static_assert_size!(Item, 144);
- static_assert_size!(ItemKind, 80);
+ static_assert_size!(Item, 136);
+ static_assert_size!(ItemKind, 72);
  static_assert_size!(LitKind, 24);
  static_assert_size!(Local, 96);
  static_assert_size!(MetaItemLit, 40);

compiler/rustc_ast/src/visit.rs

@@ -833,8 +833,8 @@ macro_rules! common_visitor_and_walkers {
  visit_visitable!($($mut)? vis, impl_),
  ItemKind::Trait(trait_) =>
  visit_visitable!($($mut)? vis, trait_),
- ItemKind::TraitAlias(ident, generics, bounds) => {
- visit_visitable!($($mut)? vis, ident, generics);
+ ItemKind::TraitAlias(box TraitAlias { constness, ident, generics, bounds}) => {
+ visit_visitable!($($mut)? vis, constness, ident, generics);
  visit_visitable_with!($($mut)? vis, bounds, BoundKind::Bound)
  }
  ItemKind::MacCall(m) =>

compiler/rustc_ast_lowering/src/item.rs

@@ -415,7 +415,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
  );
  hir::ItemKind::Trait(constness, *is_auto, safety, ident, generics, bounds, items)
  }
- ItemKind::TraitAlias(ident, generics, bounds) => {
+ ItemKind::TraitAlias(box TraitAlias { constness, ident, generics, bounds }) => {
+ let constness = self.lower_constness(*constness);
  let ident = self.lower_ident(*ident);
  let (generics, bounds) = self.lower_generics(
  generics,
@@ -429,7 +430,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  )
  },
  );
- hir::ItemKind::TraitAlias(ident, generics, bounds)
+ hir::ItemKind::TraitAlias(constness, ident, generics, bounds)
  }
  ItemKind::MacroDef(ident, MacroDef { body, macro_rules }) => {
  let ident = self.lower_ident(*ident);

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1192,6 +1192,14 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
  walk_list!(this, visit_assoc_item, items, AssocCtxt::Trait);
  });
  }
+ ItemKind::TraitAlias(box TraitAlias { constness, generics, bounds, .. }) => {
+ let disallowed = matches!(constness, ast::Const::No)
+ .then(|| TildeConstReason::Trait { span: item.span });
+ self.with_tilde_const(disallowed, |this| {
+ this.visit_generics(generics);
+ walk_list!(this, visit_param_bound, bounds, BoundKind::SuperTraits)
+ });
+ }
  ItemKind::Mod(safety, ident, mod_kind) => {
  if let &Safety::Unsafe(span) = safety {
  self.dcx().emit_err(errors::UnsafeItem { span, kind: "module" });

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -1,7 +1,6 @@
 use ast::StaticItem;
 use itertools::{Itertools, Position};
-use rustc_ast as ast;
-use rustc_ast::ModKind;
+use rustc_ast::{self as ast, ModKind, TraitAlias};
 use rustc_span::Ident;
 
 use crate::pp::BoxMarker;
@@ -386,8 +385,11 @@ impl<'a> State<'a> {
  let empty = item.attrs.is_empty() && items.is_empty();
  self.bclose(item.span, empty, cb);
  }
- ast::ItemKind::TraitAlias(ident, generics, bounds) => {
- let (cb, ib) = self.head(visibility_qualified(&item.vis, "trait"));
+ ast::ItemKind::TraitAlias(box TraitAlias { constness, ident, generics, bounds }) => {
+ let (cb, ib) = self.head("");
+ self.print_visibility(&item.vis);
+ self.print_constness(*constness);
+ self.word_nbsp("trait");
  self.print_ident(*ident);
  self.print_generic_params(&generics.params);
  self.nbsp();

compiler/rustc_hir/src/hir.rs

@@ -4151,8 +4151,8 @@ impl<'hir> Item<'hir> {
  ItemKind::Trait(constness, is_auto, safety, ident, generics, bounds, items),
  (*constness, *is_auto, *safety, *ident, generics, bounds, items);
 
- expect_trait_alias, (Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
- ItemKind::TraitAlias(ident, generics, bounds), (*ident, generics, bounds);
+ expect_trait_alias, (Constness, Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
+ ItemKind::TraitAlias(constness, ident, generics, bounds), (*constness, *ident, generics, bounds);
 
  expect_impl, &Impl<'hir>, ItemKind::Impl(imp), imp;
  }
@@ -4329,7 +4329,7 @@ pub enum ItemKind<'hir> {
  &'hir [TraitItemId],
  ),
  /// A trait alias.
- TraitAlias(Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
+ TraitAlias(Constness, Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
 
  /// An implementation, e.g., `impl<A> Trait for Foo { .. }`.
  Impl(Impl<'hir>),
@@ -4374,7 +4374,7 @@ impl ItemKind<'_> {
  | ItemKind::Struct(ident, ..)
  | ItemKind::Union(ident, ..)
  | ItemKind::Trait(_, _, _, ident, ..)
- | ItemKind::TraitAlias(ident, ..) => Some(ident),
+ | ItemKind::TraitAlias(_, ident, ..) => Some(ident),
 
  ItemKind::Use(_, UseKind::Glob | UseKind::ListStem)
  | ItemKind::ForeignMod { .. }
@@ -4392,7 +4392,7 @@ impl ItemKind<'_> {
  | ItemKind::Struct(_, generics, _)
  | ItemKind::Union(_, generics, _)
  | ItemKind::Trait(_, _, _, _, generics, _, _)
- | ItemKind::TraitAlias(_, generics, _)
+ | ItemKind::TraitAlias(_, _, generics, _)
  | ItemKind::Impl(Impl { generics, .. }) => generics,
  _ => return None,
  })

compiler/rustc_hir/src/intravisit.rs

@@ -626,7 +626,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
  walk_list!(visitor, visit_param_bound, bounds);
  walk_list!(visitor, visit_trait_item_ref, trait_item_refs);
  }
- ItemKind::TraitAlias(ident, ref generics, bounds) => {
+ ItemKind::TraitAlias(_constness, ident, ref generics, bounds) => {
  try_visit!(visitor.visit_ident(ident));
  try_visit!(visitor.visit_generics(generics));
  walk_list!(visitor, visit_param_bound, bounds);

compiler/rustc_hir_analysis/src/collect.rs

@@ -847,7 +847,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
  hir::ItemKind::Trait(constness, is_auto, safety, ..) => {
  (constness, false, is_auto == hir::IsAuto::Yes, safety)
  }
- hir::ItemKind::TraitAlias(..) => (hir::Constness::NotConst, true, false, hir::Safety::Safe),
+ hir::ItemKind::TraitAlias(constness, ..) => (constness, true, false, hir::Safety::Safe),
  _ => span_bug!(item.span, "trait_def_of_item invoked on non-trait"),
  };
 

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -167,7 +167,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
  }
  }
  ItemKind::Trait(_, _, _, _, _, self_bounds, ..)
- | ItemKind::TraitAlias(_, _, self_bounds) => {
+ | ItemKind::TraitAlias(_, _, _, self_bounds) => {
  is_trait = Some((self_bounds, item.span));
  }
  _ => {}
@@ -654,7 +654,7 @@ pub(super) fn implied_predicates_with_filter<'tcx>(
 
  let (generics, superbounds) = match item.kind {
  hir::ItemKind::Trait(.., generics, supertraits, _) => (generics, supertraits),
- hir::ItemKind::TraitAlias(_, generics, supertraits) => (generics, supertraits),
+ hir::ItemKind::TraitAlias(_, _, generics, supertraits) => (generics, supertraits),
  _ => span_bug!(item.span, "super_predicates invoked on non-trait"),
  };
 
@@ -1032,7 +1032,10 @@ pub(super) fn const_conditions<'tcx>(
  hir::ItemKind::Impl(impl_) => (impl_.generics, None, false),
  hir::ItemKind::Fn { generics, .. } => (generics, None, false),
  hir::ItemKind::Trait(_, _, _, _, generics, supertraits, _) => {
- (generics, Some((item.owner_id.def_id, supertraits)), false)
+ (generics, Some((Some(item.owner_id.def_id), supertraits)), false)
+ }
+ hir::ItemKind::TraitAlias(_, _, generics, supertraits) => {
+ (generics, Some((None, supertraits)), false)
  }
  _ => bug!("const_conditions called on wrong item: {def_id:?}"),
  },
@@ -1089,12 +1092,14 @@ pub(super) fn const_conditions<'tcx>(
  }
 
  if let Some((def_id, supertraits)) = trait_def_id_and_supertraits {
- // We've checked above that the trait is conditionally const.
- bounds.push((
- ty::Binder::dummy(ty::TraitRef::identity(tcx, def_id.to_def_id()))
- .to_host_effect_clause(tcx, ty::BoundConstness::Maybe),
- DUMMY_SP,
- ));
+ if let Some(def_id) = def_id {
+ // We've checked above that the trait is conditionally const.
+ bounds.push((
+ ty::Binder::dummy(ty::TraitRef::identity(tcx, def_id.to_def_id()))
+ .to_host_effect_clause(tcx, ty::BoundConstness::Maybe),
+ DUMMY_SP,
+ ));
+ }
 
  icx.lowerer().lower_bounds(
  tcx.types.self_param,
@@ -1143,13 +1148,14 @@ pub(super) fn explicit_implied_const_bounds<'tcx>(
  span_bug!(tcx.def_span(def_id), "RPITIT in impl should not have item bounds")
  }
  None => match tcx.hir_node_by_def_id(def_id) {
- Node::Item(hir::Item { kind: hir::ItemKind::Trait(..), .. }) => {
- implied_predicates_with_filter(
- tcx,
- def_id.to_def_id(),
- PredicateFilter::SelfConstIfConst,
- )
- }
+ Node::Item(hir::Item {
+ kind: hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..),
+ ..
+ }) => implied_predicates_with_filter(
+ tcx,
+ def_id.to_def_id(),
+ PredicateFilter::SelfConstIfConst,
+ ),
  Node::TraitItem(hir::TraitItem { kind: hir::TraitItemKind::Type(..), .. })
  | Node::OpaqueTy(_) => {
  explicit_item_bounds_with_filter(tcx, def_id, PredicateFilter::ConstIfConst)

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -632,7 +632,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
  | hir::ItemKind::Struct(_, generics, _)
  | hir::ItemKind::Union(_, generics, _)
  | hir::ItemKind::Trait(_, _, _, _, generics, ..)
- | hir::ItemKind::TraitAlias(_, generics, ..)
+ | hir::ItemKind::TraitAlias(_, _, generics, ..)
  | hir::ItemKind::Impl(hir::Impl { generics, .. }) => {
  // These kinds of items have only early-bound lifetime parameters.
  self.visit_early(item.hir_id(), generics, |this| intravisit::walk_item(this, item));